3288 rexy
1 /*!
2 * jQuery JavaScript Library v1.12.4-ff3fix-ff2fix-CVE_2015_9251fix-CVE_2019_11358fix-CVE_2020_11022fix-CVE_2020_11023fix
3 * http://jquery.com/
4 *
5 * Includes Sizzle.js
6 * http://sizzlejs.com/
7 *
8 * Copyright jQuery Foundation and other contributors
9 * Released under the MIT license
10 * http://jquery.org/license
11 *
12 * Date: 2016-05-20T17:17Z
13 */
14
15 (function
16
17 if "object" "object"
18 // For CommonJS and CommonJS-like environments where a proper `window`
19 // is present, execute the factory and get jQuery.
20 // For environments that do not have a `window` with a `document`
21 // (such as Node.js), expose a factory as module.exports.
22 // This accentuates the need for the creation of a real `window`.
23 // e.g. var jQuery = require("jquery")(window);
24 // See ticket #14549 for more info.
25
26 factory( global, true
27 function
28 if
29 throw new "jQuery requires a window with a document"
30 }
31 return
32 };
33 } else
34 factory( global );
35 }
36
37 // Pass this if window is not defined yet
38 "undefined" this function
39
40 // Support: Firefox 18+
41 // Can't be in strict mode, several libs including ASP.NET trace
42 // the stack via arguments.caller.callee and Firefox dies if
43 // you try to trace through "use strict" call chains. (#13335)
44 //"use strict";
45 var
46
47 var
48
49 var
50
51 var
52
53 var
54
55 var
56
57 var
58
59 var
60
61 var
62
63 var
64
65
66
67 var
68 version = "1.12.4"
69
70 // Define a local copy of jQuery
71 function
72
73 // The jQuery object is actually just the init constructor 'enhanced'
74 // Need init if jQuery is called (just allow error to be thrown if not included)
75 return new
76 },
77
78 // Support: Android<4.1, IE<9
79 // Make sure we trim BOM and NBSP
80 /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/
81
82 // Matches dashed string for camelizing
83 /^-ms-/
84 rdashAlpha = /-([\da-z])/
85
86 // Used by jQuery.camelCase as callback to replace()
87 function
88 return
89 };
90
91 jQuery.fn = jQuery.prototype = {
92
93 // The current version of jQuery being used
94
95
96 constructor: jQuery,
97
98 // Start with an empty selector
99 ""
100
101 // The default length of a jQuery object is 0
102
103
104 toArray: function
105 return this
106 },
107
108 // Get the Nth element in the matched element set OR
109 // Get the whole matched element set as a clean array
110 function
111 return null
112
113 // Return just the one element from the set
114 this this this
115
116 // Return all the elements in a clean array
117 this
118 },
119
120 // Take an array of elements and push it onto the stack
121 // (returning the new matched element set)
122 function
123
124 // Build a new jQuery matched element set
125 var this
126
127 // Add the old object onto the stack (as a reference)
128 this
129 ret.context = this
130
131 // Return the newly-formed element set
132 return
133 },
134
135 // Execute a callback for every element in the matched set.
136 function
137 return this
138 },
139
140 map: function
141 return this this function
142 return
143 } ) );
144 },
145
146 slice: function
147 return this this
148 },
149
150 first: function
151 return this
152 },
153
154 last: function
155 return this
156 },
157
158 eq: function
159 var this
160 j = +i + ( i < 0 ? len : 0 );
161 return this this
162 },
163
164 end: function
165 return this this
166 },
167
168 // For internal use only.
169 // Behaves like an Array's method, not like a jQuery method.
170
171 sort: deletedIds.sort,
172 splice: deletedIds.splice
173 };
174
175 jQuery.extend = jQuery.fn.extend = function
176 var
177 target = arguments[ 0 ] || {},
178 i = 1,
179 length = arguments.length,
180 deep = false
181
182 // Handle a deep copy situation
183 if "boolean"
184 deep = target;
185
186 // skip the boolean and the target
187
188 i++;
189 }
190
191 // Handle case when target is a string or something (possible in deep copy)
192 if "object"
193 target = {};
194 }
195
196 // extend jQuery itself if only one argument is passed
197 if
198 target = this
199 i--;
200 }
201
202 for
203
204 // Only deal with non-null/undefined values
205 if null
206
207 // Extend the base object
208 for in
209 src = target[ name ];
210 copy = options[ name ];
211
212 // Prevent Object.prototype pollution
213 // Prevent never-ending loop
214 if "__proto__"
215 continue
216 }
217
218 // Recurse if we're merging plain objects or arrays
219 if
220 ( copyIsArray = jQuery.isArray( copy ) ) ) ) {
221
222 if
223 copyIsArray = false
224 clone = src && jQuery.isArray( src ) ? src : [];
225
226 } else
227 clone = src && jQuery.isPlainObject( src ) ? src : {};
228 }
229
230 // Never move original objects, clone them
231
232
233 // Don't bring in undefined values
234 else if
235 target[ name ] = copy;
236 }
237 }
238 }
239 }
240
241 // Return the modified object
242 return
243 };
244
245 jQuery.extend( {
246
247 // Unique for each copy of jQuery on the page
248 "jQuery" Math /\D/ ""
249
250 // Assume jQuery is ready without the ready module
251 true
252
253 error: function
254 throw new
255 },
256
257 noop: function
258
259 // See test/unit/core.js for details concerning isFunction.
260 // Since version 1.3, DOM methods and functions like alert
261 // aren't supported. They return false on IE (#2968).
262 function
263 return "function"
264 },
265
266 isArray: Array.isArray || function
267 return "array"
268 },
269
270 isWindow: function
271 /* jshint eqeqeq: false */
272 return null
273 },
274
275 isNumeric: function
276
277 // parseFloat NaNs numeric-cast false positives (null|true|false|"")
278 // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
279 // subtraction forces infinities to NaN
280 // adding 1 corrects loss of precision from parseFloat (#15100)
281 var
282 return parseFloat
283 },
284
285 isEmptyObject: function
286 var
287 for in
288 return false
289 }
290 return true
291 },
292
293 isPlainObject: function
294 var
295
296 // Must be an Object.
297 // Because of IE, we also have to check the presence of the constructor property.
298 // Make sure that DOM nodes and window objects don't pass through, as well
299 if "object"
300 return false
301 }
302
303 try
304
305 // Not own constructor property must be Object
306 if
307 !hasOwn.call( obj, "constructor"
308 !hasOwn.call( obj.constructor.prototype, "isPrototypeOf"
309 return false
310 }
311 } catch
312
313 // IE8,9 Will throw exceptions on certain host objects #9897
314 return false
315 }
316
317 // Support: IE<9
318 // Handle iteration over inherited properties before own properties.
319 if
320 for in
321 return
322 }
323 }
324
325 // Own properties are enumerated firstly, so to speed up,
326 // if last one is own, then all properties are own.
327 for in
328
329 return
330 },
331
332 type: function
333 if null
334 return ""
335 }
336 return "object" "function"
337 class2type[ toString.call( obj ) ] || "object"
338 typeof obj;
339 },
340
341 // Workarounds based on findings by Jim Driscoll
342 // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
343 function
344 if
345
346 // We use execScript on Internet Explorer
347 // We use an anonymous function so that context is window
348 // rather than jQuery in Firefox
349 function
350 window[ "eval" // jscs:ignore requireDotNotation
351
352 }
353 },
354
355 // Convert dashed to camelCase; used by the css and data modules
356 // Microsoft forgot to hump their vendor prefix (#9572)
357 function
358 return "ms-"
359 },
360
361 nodeName: function
362 return
363 },
364
365 each: function
366 var
367
368 if
369 length = obj.length;
370 for
371 if false
372 break
373 }
374 }
375 } else
376 for in
377 if false
378 break
379 }
380 }
381 }
382
383 return
384 },
385
386 // Support: Android<4.1, IE<9
387 function
388 return null
389 ""
390 ( text + "" ""
391 },
392
393 // results is for internal usage only
394 function
395 var
396
397 if null
398 if
399 jQuery.merge( ret,
400 typeof arr === "string"
401 [ arr ] : arr
402 );
403 } else
404 push.call( ret, arr );
405 }
406 }
407
408 return
409 },
410
411 inArray: function
412 var
413
414 if
415 if
416 return
417 }
418
419 len = arr.length;
420 i = i ? i < 0 ? Math
421
422 for
423
424 // Skip accessing in sparse arrays
425 if in
426 return
427 }
428 }
429 }
430
431 return
432 },
433
434 merge: function
435 var
436 j = 0,
437 i = first.length;
438
439 while
440 first[ i++ ] = second[ j++ ];
441 }
442
443 // Support: IE<9
444 // Workaround casting of .length to NaN on otherwise arraylike objects (e.g., NodeLists)
445 if
446 while
447 first[ i++ ] = second[ j++ ];
448 }
449 }
450
451 first.length = i;
452
453 return
454 },
455
456 grep: function
457 var
458 matches = [],
459 i = 0,
460 length = elems.length,
461 callbackExpect = !invert;
462
463 // Go through the array, only saving the items
464 // that pass the validator function
465 for
466 callbackInverse = !callback( elems[ i ], i );
467 if
468 matches.push( elems[ i ] );
469 }
470 }
471
472 return
473 },
474
475 // arg is for internal usage only
476 function
477 var
478 i = 0,
479 ret = [];
480
481 // Go through the array, translating each of the items to their new values
482 if
483 length = elems.length;
484 for
485 value = callback( elems[ i ], i, arg );
486
487 if null
488 ret.push( value );
489 }
490 }
491
492 // Go through every key on the object,
493 else
494 for in
495 value = callback( elems[ i ], i, arg );
496
497 if null
498 ret.push( value );
499 }
500 }
501 }
502
503 // Flatten any nested arrays
504 return
505 },
506
507 // A global GUID counter for objects
508
509
510 // Bind a function to a context, optionally partially applying any
511 // arguments.
512 function
513 var
514
515 if "string"
516 tmp = fn[ context ];
517 context = fn;
518 fn = tmp;
519 }
520
521 // Quick check to determine if target is callable, in the spec
522 // this throws a TypeError, but we will just return undefined.
523 if
524 return
525 }
526
527 // Simulated bind
528
529 proxy = function
530 return this
531 };
532
533 // Set the guid of unique handler to the same of original handler, so it can be removed
534
535
536 return
537 },
538
539 now: function
540 return new Date
541 },
542
543 // jQuery.support is not used in Core but other projects attach their
544 // properties to it so it needs to exist.
545
546 } );
547
548 // JSHint would error on this code due to the Symbol not being defined in ES5.
549 // Defining this global in .jshintrc would create a danger of using the global
550 // unguarded in another place, it seems safer to just disable JSHint for these
551 // three lines.
552 /* jshint ignore: start */
553 if "function"
554 jQuery.fn[ Symbol.iterator ] = deletedIds[ Symbol.iterator ];
555 }
556 /* jshint ignore: end */
557
558 // Populate the class2type map
559 "Boolean Number String Function Array Date RegExp Object Error Symbol" " "
560 function
561 class2type[ "[object " "]"
562 } );
563
564 function isArrayLike
565
566 // Support: iOS 8.2 (not reproducible in simulator)
567 // `in` check used to prevent JIT error (gh-2145)
568 // hasOwn isn't used here due to false negatives
569 // regarding Nodelist length in IE
570 var "length" in
571 type = jQuery.type( obj );
572
573 if "function"
574 return false
575 }
576
577 return "array"
578 typeof length === "number" in
579 }
580 var
581 /*!
582 * Sizzle CSS Selector Engine v2.2.1
583 * http://sizzlejs.com/
584 *
585 * Copyright jQuery Foundation and other contributors
586 * Released under the MIT license
587 * http://jquery.org/license
588 *
589 * Date: 2015-10-17
590 */
591 (function
592
593 var
594 support,
595 Expr,
596 getText,
597 isXML,
598 tokenize,
599 compile,
600 select,
601 outermostContext,
602 sortInput,
603 hasDuplicate,
604
605 // Local document vars
606
607 document,
608 docElem,
609 documentIsHTML,
610 rbuggyQSA,
611 rbuggyMatches,
612 matches,
613 contains,
614
615 // Instance-specific data
616 "sizzle" new Date
617 preferredDoc = window.document,
618 dirruns = 0,
619 done = 0,
620 classCache = createCache(),
621 tokenCache = createCache(),
622 compilerCache = createCache(),
623 sortOrder = function
624 if
625 hasDuplicate = true
626 }
627 return
628 },
629
630 // General-purpose constants
631
632
633 // Instance methods
634
635 arr = [],
636 pop = arr.pop,
637 push_native = arr.push,
638 push = arr.push,
639 slice = arr.slice,
640 // Use a stripped-down indexOf as it's faster than native
641 // http://jsperf.com/thor-indexof-vs-for/5
642 function
643 var
644 len = list.length;
645 for
646 if
647 return
648 }
649 }
650 return
651 },
652
653 booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped"
654
655 // Regular expressions
656
657 // http://www.w3.org/TR/css3-selectors/#whitespace
658 "[\\x20\\t\\r\\n\\f]"
659
660 // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
661 "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+"
662
663 // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
664 "\\[" "*(" ")(?:"
665 // Operator (capture 2)
666 "*([*^$|!~]?=)"
667 // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
668 "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" "))|)"
669 "*\\]"
670
671 pseudos = ":(" ")(?:\\(("
672 // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
673 // 1. quoted (capture 3; capture 4 or capture 5)
674 "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|"
675 // 2. simple (capture 6)
676 "((?:\\\\.|[^\\\\()[\\]]|" ")*)|"
677 // 3. anything else (capture 2)
678 ".*"
679 ")\\)|)"
680
681 // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
682 new "+" "g"
683 rtrim = new "^" "+|((?:^|[^\\\\])(?:\\\\.)*)" "+$" "g"
684
685 rcomma = new "^" "*," "*"
686 rcombinators = new "^" "*([>+~]|" ")" "*"
687
688 rattributeQuotes = new "=" "*([^\\]'\"]*?)" "*\\]" "g"
689
690 rpseudo = new
691 ridentifier = new "^" "$"
692
693 matchExpr = {
694 "ID" new "^#(" ")"
695 "CLASS" new "^\\.(" ")"
696 "TAG" new "^(" "|[*])"
697 "ATTR" new "^"
698 "PSEUDO" new "^"
699 "CHILD" new "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("
700 "*(even|odd|(([+-]|)(\\d*)n|)" "*(?:([+-]|)"
701 "*(\\d+)|))" "*\\)|)" "i"
702 "bool" new "^(?:" ")$" "i"
703 // For use in libraries implementing .is()
704 // We use this for POS matching in `select`
705 "needsContext" new "^" "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("
706 whitespace + "*((?:-\\d)?\\d*)" "*\\)|)(?=[^-]|$)" "i"
707 },
708
709 rinputs = /^(?:input|select|textarea|button)$/
710 rheader = /^h\d$/
711
712 rnative = /^[^{]+\{\s*\[native \w/
713
714 // Easily-parseable/retrievable ID or TAG or CLASS selectors
715 /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/
716
717 rsibling = /[+~]/
718 rescape = /'|\\/g,
719
720 / / CSS escapes http:/ /www.w3.org/ /CSS21/
721 runescape = new "\\\\([\\da-f]{1,6}" "?|(" ")|.)" "ig"
722 funescape = function
723 var "0x"
724 // NaN means non-codepoint
725 // Support: Firefox<24
726 // Workaround erroneous numeric interpretation of +"0x"
727 return
728 escaped :
729 high < 0 ?
730 // BMP codepoint
731
732 // Supplemental Plane codepoint (surrogate pair)
733
734 },
735
736 // Used for iframes
737 // See setDocument()
738 // Removing the function wrapper causes a "Permission Denied"
739 // error in IE
740 function
741 setDocument();
742 };
743
744 // Optimize for push.apply( _, NodeList )
745 try
746 push.apply(
747 (arr = slice.call( preferredDoc.childNodes )),
748 preferredDoc.childNodes
749 );
750 // Support: Android<4.0
751 // Detect silently failing push.apply
752
753 } catch
754 push = { apply: arr.length ?
755
756 // Leverage slice if possible
757 function
758 push_native.apply( target, slice.call(els) );
759 } :
760
761 // Support: IE<9
762 // Otherwise append directly
763 function
764 var
765 i = 0;
766 // Can't trust NodeList.length
767 while
768 target.length = j - 1;
769 }
770 };
771 }
772
773 function Sizzle
774 var
775 newContext = context && context.ownerDocument,
776
777 // nodeType defaults to 9, since context defaults to document
778
779
780 results = results || [];
781
782 // Return early from calls with invalid selector or context
783 if "string"
784 nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
785
786 return
787 }
788
789 // Try to shortcut find operations (as opposed to filters) in HTML documents
790 if
791
792 if
793 setDocument( context );
794 }
795 context = context || document;
796
797 if
798
799 // If the selector is sufficiently simple, try using a "get*By*" DOM method
800 // (excepting DocumentFragment context, where the methods don't exist)
801 if
802
803 // ID selector
804 if
805
806 // Document context
807 if
808 if
809
810 // Support: IE, Opera, Webkit
811 // TODO: identify versions
812 // getElementById can match elements by name instead of ID
813 if
814 results.push( elem );
815 return
816 }
817 } else
818 return
819 }
820
821 // Element context
822 else
823
824 // Support: IE, Opera, Webkit
825 // TODO: identify versions
826 // getElementById can match elements by name instead of ID
827 if
828 contains( context, elem ) &&
829 elem.id === m ) {
830
831 results.push( elem );
832 return
833 }
834 }
835
836 // Type selector
837 else if
838 push.apply( results, context.getElementsByTagName( selector ) );
839 return
840
841 // Class selector
842 else if
843 context.getElementsByClassName ) {
844
845 push.apply( results, context.getElementsByClassName( m ) );
846 return
847 }
848 }
849
850 // Take advantage of querySelectorAll
851 if
852 !compilerCache[ selector + " "
853 (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
854
855 if
856 newContext = context;
857 newSelector = selector;
858
859 // qSA looks outside Element context, which is not what we want
860 // Thanks to Andrew Dupont for this workaround technique
861 // Support: IE <=8
862 // Exclude object elements
863 else if "object"
864
865 // Capture the context ID, setting it first if necessary
866 if "id"
867 nid = nid.replace( rescape, "\\$&"
868 } else
869 context.setAttribute( "id"
870 }
871
872 // Prefix every selector in the list
873
874 i = groups.length;
875 nidselect = ridentifier.test( nid ) ? "#" "[id='" "']"
876 while
877 groups[i] = nidselect + " "
878 }
879 newSelector = groups.join( ","
880
881 // Expand context for sibling selectors
882
883 context;
884 }
885
886 if
887 try
888 push.apply( results,
889 newContext.querySelectorAll( newSelector )
890 );
891 return
892 } catch
893 } finally
894 if
895 context.removeAttribute( "id"
896 }
897 }
898 }
899 }
900 }
901 }
902
903 // All others
904 return "$1"
905 }
906
907 /**
908 * Create key-value caches of limited size
909 * @returns {function(string, object)} Returns the Object data after storing it on itself with
910 * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
911 * deleting the oldest entry
912 */
913 function createCache
914 var
915
916 function cache
917 // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
918 if " "
919 // Only keep the most recent entries
920
921 }
922 return " "
923 }
924 return
925 }
926
927 /**
928 * Mark a function for special use by Sizzle
929 * @param {Function} fn The function to mark
930 */
931 function markFunction
932 fn[ expando ] = true
933 return
934 }
935
936 /**
937 * Support testing using an element
938 * @param {Function} fn Passed the created div and expects a boolean result
939 */
940 function assert
941 var "div"
942
943 try
944 return
945 } catch
946 return false
947 } finally
948 // Remove from its parent by default
949 if
950 div.parentNode.removeChild( div );
951 }
952 // release memory in IE
953 null
954 }
955 }
956
957 /**
958 * Adds the same handler for all of the specified attrs
959 * @param {String} attrs Pipe-separated list of attributes
960 * @param {Function} handler The method that will be applied
961 */
962 function addHandle
963 var "|"
964 i = arr.length;
965
966 while
967 Expr.attrHandle[ arr[i] ] = handler;
968 }
969 }
970
971 /**
972 * Checks document order of two siblings
973 * @param {Element} a
974 * @param {Element} b
975 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
976 */
977 function siblingCheck
978 var
979 diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
980 ( ~b.sourceIndex || MAX_NEGATIVE ) -
981 ( ~a.sourceIndex || MAX_NEGATIVE );
982
983 // Use IE sourceIndex if available on both nodes
984 if
985 return
986 }
987
988 // Check if b follows a
989 if
990 while
991 if
992 return
993 }
994 }
995 }
996
997 return
998 }
999
1000 /**
1001 * Returns a function to use in pseudos for input types
1002 * @param {String} type
1003 */
1004 function createInputPseudo
1005 return function
1006 var
1007 return "input"
1008 };
1009 }
1010
1011 /**
1012 * Returns a function to use in pseudos for buttons
1013 * @param {String} type
1014 */
1015 function createButtonPseudo
1016 return function
1017 var
1018 return "input" "button"
1019 };
1020 }
1021
1022 /**
1023 * Returns a function to use in pseudos for positionals
1024 * @param {Function} fn
1025 */
1026 function createPositionalPseudo
1027 return function
1028 argument = +argument;
1029 return function
1030 var
1031 matchIndexes = fn( [], seed.length, argument ),
1032 i = matchIndexes.length;
1033
1034 // Match elements found at the specified indexes
1035 while
1036 if
1037 seed[j] = !(matches[j] = seed[j]);
1038 }
1039 }
1040 });
1041 });
1042 }
1043
1044 /**
1045 * Checks a node for validity as a Sizzle context
1046 * @param {Element|Object=} context
1047 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1048 */
1049 function testContext
1050 return "undefined"
1051 }
1052
1053 // Expose support vars for convenience
1054
1055
1056 /**
1057 * Detects XML nodes
1058 * @param {Element|Object} elem An element or a document
1059 * @returns {Boolean} True iff elem is a non-HTML XML node
1060 */
1061 isXML = Sizzle.isXML = function
1062 // documentElement is verified for cases where it doesn't yet exist
1063 // (such as loading iframes in IE - #4833)
1064 var
1065 return "HTML" false
1066 };
1067
1068 /**
1069 * Sets document-related variables once based on the current document
1070 * @param {Element|Object} [doc] An element or document object to use to set the document
1071 * @returns {Object} Returns the current document
1072 */
1073 setDocument = Sizzle.setDocument = function
1074 var
1075 doc = node ? node.ownerDocument || node : preferredDoc;
1076
1077 // Return early if doc is invalid or already selected
1078 if
1079 return
1080 }
1081
1082 // Update global variables
1083
1084 docElem = document.documentElement;
1085 documentIsHTML = !isXML( document );
1086
1087 // Support: IE 9-11, Edge
1088 // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
1089 if
1090 // Support: IE 11
1091 if
1092 parent.addEventListener( "unload" false
1093
1094 // Support: IE 9 - 10 only
1095 else if
1096 parent.attachEvent( "onunload"
1097 }
1098 }
1099
1100 /* Attributes
1101 ---------------------------------------------------------------------- */
1102
1103 // Support: IE<8
1104 // Verify that getAttribute really returns attributes and not properties
1105 // (excepting IE8 booleans)
1106 function
1107 div.className = "i"
1108 return "className"
1109 });
1110
1111 /* getElement(s)By*
1112 ---------------------------------------------------------------------- */
1113
1114 // Check if getElementsByTagName("*") returns only elements
1115 function
1116 div.appendChild( document.createComment(""
1117 return "*"
1118 });
1119
1120 // Support: IE<9
1121
1122
1123 // Support: IE<10
1124 // Check if getElementById returns elements by name
1125 // The broken getElementById methods don't pick up programatically-set names,
1126 // so use a roundabout getElementsByName test
1127 function
1128 docElem.appendChild( div ).id = expando;
1129 return
1130 });
1131
1132 // ID find and filter
1133 if
1134 Expr.find["ID" function
1135 if "undefined"
1136 var
1137 return
1138 }
1139 };
1140 Expr.filter["ID" function
1141 var
1142 return function
1143 return "id"
1144 };
1145 };
1146 } else
1147 // Support: IE6/7
1148 // getElementById is not reliable as a find shortcut
1149 "ID"
1150
1151 Expr.filter["ID" function
1152 var
1153 return function
1154 var "undefined"
1155 elem.getAttributeNode("id"
1156 return
1157 };
1158 };
1159 }
1160
1161 // Tag
1162 "TAG"
1163 function
1164 if "undefined"
1165 return
1166
1167 // DocumentFragment nodes don't have gEBTN
1168 else if
1169 return
1170 }
1171 } :
1172
1173 function
1174 var
1175 tmp = [],
1176 i = 0,
1177 // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1178
1179
1180 // Filter out possible comments
1181 if "*"
1182 while
1183 if
1184 tmp.push( elem );
1185 }
1186 }
1187
1188 return
1189 }
1190 return
1191 };
1192
1193 // Class
1194 "CLASS" function
1195 if "undefined"
1196 return
1197 }
1198 };
1199
1200 /* QSA/matchesSelector
1201 ---------------------------------------------------------------------- */
1202
1203 // QSA and matchesSelector support
1204
1205 // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1206
1207
1208 // qSa(:focus) reports false when true (Chrome 21)
1209 // We allow this because of a bug in IE8/9 that throws an error
1210 // whenever `document.activeElement` is accessed on an iframe
1211 // So, we allow :focus to pass through QSA all the time to avoid the IE error
1212 // See http://bugs.jquery.com/ticket/13378
1213
1214
1215 if
1216 // Build QSA regex
1217 // Regex strategy adopted from Diego Perini
1218 function
1219 // Select is set to empty string on purpose
1220 // This is to test IE's treatment of not explicitly
1221 // setting a boolean content attribute,
1222 // since its presence should be enough
1223 // http://bugs.jquery.com/ticket/12359
1224 "<a id='" "'></a>"
1225 "<select id='" "-\r\\' msallowcapture=''>"
1226 "<option selected=''></option></select>"
1227
1228 // Support: IE8, Opera 11-12.16
1229 // Nothing should be selected when empty strings follow ^= or $= or *=
1230 // The test attribute must be unknown in Opera but "safe" for WinRT
1231 // http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1232 if "[msallowcapture^='']"
1233 rbuggyQSA.push( "[*^$]=" "*(?:''|\"\")"
1234 }
1235
1236 // Support: IE8
1237 // Boolean attributes and "value" are not treated correctly
1238 if "[selected]"
1239 rbuggyQSA.push( "\\[" "*(?:value|" ")"
1240 }
1241
1242 // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1243 if "[id~=" "-]"
1244 rbuggyQSA.push("~="
1245 }
1246
1247 // Webkit/Opera - :checked should return selected option elements
1248 // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1249 // IE8 throws error here and will not see later tests
1250 if ":checked"
1251 rbuggyQSA.push(":checked"
1252 }
1253
1254 // Support: Safari 8+, iOS 8+
1255 // https://bugs.webkit.org/show_bug.cgi?id=136851
1256 // In-page `selector#id sibing-combinator selector` fails
1257 if "a#" "+*"
1258 rbuggyQSA.push(".#.+[+~]"
1259 }
1260 });
1261
1262 assert(function
1263 // Support: Windows 8 Native Apps
1264 // The type and name attributes are restricted during .innerHTML assignment
1265 var "input"
1266 input.setAttribute( "type" "hidden"
1267 div.appendChild( input ).setAttribute( "name" "D"
1268
1269 // Support: IE8
1270 // Enforce case-sensitivity of name attribute
1271 if "[name=d]"
1272 rbuggyQSA.push( "name" "*[*^$|!~]?="
1273 }
1274
1275 // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1276 // IE8 throws error here and will not see later tests
1277 if ":enabled"
1278 rbuggyQSA.push( ":enabled" ":disabled"
1279 }
1280
1281 // Opera 10-11 does not throw on post-comma invalid pseudos
1282 "*,:x"
1283 rbuggyQSA.push(",.*:"
1284 });
1285 }
1286
1287 if
1288 docElem.webkitMatchesSelector ||
1289 docElem.mozMatchesSelector ||
1290 docElem.oMatchesSelector ||
1291 docElem.msMatchesSelector) )) ) {
1292
1293 assert(function
1294 // Check to see if it's possible to do matchesSelector
1295 // on a disconnected node (IE 9)
1296 "div"
1297
1298 // This should fail with an exception
1299 // Gecko does not error, returns false instead
1300 "[s!='']:x"
1301 rbuggyMatches.push( "!="
1302 });
1303 }
1304
1305 rbuggyQSA = rbuggyQSA.length && new "|"
1306 rbuggyMatches = rbuggyMatches.length && new "|"
1307
1308 /* Contains
1309 ---------------------------------------------------------------------- */
1310 hasCompare = rnative.test( docElem.compareDocumentPosition );
1311
1312 // Element contains another
1313 // Purposefully self-exclusive
1314 // As in, an element does not contain itself
1315
1316 function
1317 var
1318 bup = b && b.parentNode;
1319 return
1320 adown.contains ?
1321 adown.contains( bup ) :
1322 a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1323 ));
1324 } :
1325 function
1326 if
1327 while
1328 if
1329 return true
1330 }
1331 }
1332 }
1333 return false
1334 };
1335
1336 /* Sorting
1337 ---------------------------------------------------------------------- */
1338
1339 // Document order sorting
1340
1341 function
1342
1343 // Flag for duplicate removal
1344 if
1345 hasDuplicate = true
1346 return
1347 }
1348
1349 // Sort on method existence if only one input has compareDocumentPosition
1350 var
1351 if
1352 return
1353 }
1354
1355 // Calculate position if both inputs belong to the same document
1356
1357 a.compareDocumentPosition( b ) :
1358
1359 // Otherwise we know they are disconnected
1360
1361
1362 // Disconnected nodes
1363 if
1364 (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1365
1366 // Choose the first element that is related to our preferred document
1367 if
1368 return
1369 }
1370 if
1371 return
1372 }
1373
1374 // Maintain original order
1375 return
1376 ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1377 0;
1378 }
1379
1380 return
1381 } :
1382 function
1383 // Exit early if the nodes are identical
1384 if
1385 hasDuplicate = true
1386 return
1387 }
1388
1389 var
1390 i = 0,
1391 aup = a.parentNode,
1392 bup = b.parentNode,
1393 ap = [ a ],
1394 bp = [ b ];
1395
1396 // Parentless nodes are either documents or disconnected
1397 if
1398 return
1399 b === document ? 1 :
1400 aup ? -1 :
1401 bup ? 1 :
1402 sortInput ?
1403 ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1404 0;
1405
1406 // If the nodes are siblings, we can do a quick check
1407 else if
1408 return
1409 }
1410
1411 // Otherwise we need full lists of their ancestors for comparison
1412
1413 while
1414 ap.unshift( cur );
1415 }
1416 cur = b;
1417 while
1418 bp.unshift( cur );
1419 }
1420
1421 // Walk down the tree looking for a discrepancy
1422 while
1423 i++;
1424 }
1425
1426 return
1427 // Do a sibling check if the nodes have a common ancestor
1428
1429
1430 // Otherwise nodes in our document sort first
1431
1432 bp[i] === preferredDoc ? 1 :
1433 0;
1434 };
1435
1436 return
1437 };
1438
1439 Sizzle.matches = function
1440 return null null
1441 };
1442
1443 Sizzle.matchesSelector = function
1444 // Set document vars if needed
1445 if
1446 setDocument( elem );
1447 }
1448
1449 // Make sure that attribute selectors are quoted
1450 "='$1']"
1451
1452 if
1453 !compilerCache[ expr + " "
1454 ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1455 ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {
1456
1457 try
1458 var
1459
1460 // IE 9's matchesSelector returns false on disconnected nodes
1461 if
1462 // As well, disconnected nodes are said to be in a document
1463 // fragment in IE 9
1464
1465 return
1466 }
1467 } catch
1468 }
1469
1470 return null
1471 };
1472
1473 Sizzle.contains = function
1474 // Set document vars if needed
1475 if
1476 setDocument( context );
1477 }
1478 return
1479 };
1480
1481 Sizzle.attr = function
1482 // Set document vars if needed
1483 if
1484 setDocument( elem );
1485 }
1486
1487 var
1488 // Don't get fooled by Object.prototype properties (jQuery #13807)
1489
1490 fn( elem, name, !documentIsHTML ) :
1491 undefined;
1492
1493 return
1494 val :
1495 support.attributes || !documentIsHTML ?
1496 elem.getAttribute( name ) :
1497 (val = elem.getAttributeNode(name)) && val.specified ?
1498 val.value :
1499 null
1500 };
1501
1502 Sizzle.error = function
1503 throw new "Syntax error, unrecognized expression: "
1504 };
1505
1506 /**
1507 * Document sorting and removing duplicates
1508 * @param {ArrayLike} results
1509 */
1510 Sizzle.uniqueSort = function
1511 var
1512 duplicates = [],
1513 j = 0,
1514 i = 0;
1515
1516 // Unless we *know* we can detect duplicates, assume their presence
1517
1518 sortInput = !support.sortStable && results.slice( 0 );
1519 results.sort( sortOrder );
1520
1521 if
1522 while
1523 if
1524 j = duplicates.push( i );
1525 }
1526 }
1527 while
1528 results.splice( duplicates[ j ], 1 );
1529 }
1530 }
1531
1532 // Clear input after sorting to release objects
1533 // See https://github.com/jquery/sizzle/pull/225
1534 null
1535
1536 return
1537 };
1538
1539 /**
1540 * Utility function for retrieving the text value of an array of DOM nodes
1541 * @param {Array|Element} elem
1542 */
1543 getText = Sizzle.getText = function
1544 var
1545 ret = ""
1546 i = 0,
1547 nodeType = elem.nodeType;
1548
1549 if
1550 // If no nodeType, this is expected to be an array
1551 while
1552 // Do not traverse comment nodes
1553
1554 }
1555 } else if
1556 // Use textContent for elements
1557 // innerText usage removed for consistency of new lines (jQuery #11153)
1558 if "string"
1559 return
1560 } else
1561 // Traverse its children
1562 for
1563 ret += getText( elem );
1564 }
1565 }
1566 } else if
1567 return
1568 }
1569 // Do not include comment or processing instruction nodes
1570
1571 return
1572 };
1573
1574 Expr = Sizzle.selectors = {
1575
1576 // Can be adjusted by the user
1577
1578
1579 createPseudo: markFunction,
1580
1581 match: matchExpr,
1582
1583 attrHandle: {},
1584
1585 find: {},
1586
1587 relative: {
1588 ">" "parentNode" true
1589 " " "parentNode"
1590 "+" "previousSibling" true
1591 "~" "previousSibling"
1592 },
1593
1594 preFilter: {
1595 "ATTR" function
1596 match[1] = match[1].replace( runescape, funescape );
1597
1598 // Move the given value to match[3] whether quoted or unquoted
1599 ""
1600
1601 if "~="
1602 match[3] = " " " "
1603 }
1604
1605 return
1606 },
1607
1608 "CHILD" function
1609 /* matches from matchExpr["CHILD"]
1610 1 type (only|nth|...)
1611 2 what (child|of-type)
1612 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1613 4 xn-component of xn+y argument ([+-]?\d*n|)
1614 5 sign of xn-component
1615 6 x of xn-component
1616 7 sign of y-component
1617 8 y of y-component
1618 */
1619 match[1] = match[1].toLowerCase();
1620
1621 if "nth"
1622 // nth-* requires argument
1623 if
1624 Sizzle.error( match[0] );
1625 }
1626
1627 // numeric x and y parameters for Expr.filter.CHILD
1628 // remember that false/true cast respectively to 0/1
1629 "even" "odd"
1630 match[5] = +( ( match[7] + match[8] ) || match[3] === "odd"
1631
1632 // other types prohibit arguments
1633 else if
1634 Sizzle.error( match[0] );
1635 }
1636
1637 return
1638 },
1639
1640 "PSEUDO" function
1641 var
1642 unquoted = !match[6] && match[2];
1643
1644 if "CHILD"
1645 return null
1646 }
1647
1648 // Accept quoted arguments as-is
1649 if
1650 match[2] = match[4] || match[5] || ""
1651
1652 // Strip excess characters from unquoted arguments
1653 else if
1654 // Get excess from tokenize (recursively)
1655 true
1656 // advance to the next closing parenthesis
1657 ")"
1658
1659 // excess is a negative index
1660
1661 match[2] = unquoted.slice( 0, excess );
1662 }
1663
1664 // Return only captures needed by the pseudo filter method (type and argument)
1665 return
1666 }
1667 },
1668
1669 filter: {
1670
1671 "TAG" function
1672 var
1673 return "*"
1674 function return true
1675 function
1676 return
1677 };
1678 },
1679
1680 "CLASS" function
1681 var " "
1682
1683 return
1684 (pattern = new "(^|" ")" "(" "|$)"
1685 classCache( className, function
1686 return "string" "undefined" "class" ""
1687 });
1688 },
1689
1690 "ATTR" function
1691 return function
1692 var
1693
1694 if null
1695 return "!="
1696 }
1697 if
1698 return true
1699 }
1700
1701 result += ""
1702
1703 return "="
1704 operator === "!="
1705 operator === "^="
1706 operator === "*="
1707 operator === "$="
1708 operator === "~=" " " " " " "
1709 operator === "|=" "-"
1710 false
1711 };
1712 },
1713
1714 "CHILD" function
1715 var "nth"
1716 forward = type.slice( -4 ) !== "last"
1717 ofType = what === "of-type"
1718
1719 return
1720
1721 // Shortcut for :nth-*(n)
1722 function
1723 return
1724 } :
1725
1726 function
1727 var
1728 dir = simple !== forward ? "nextSibling" "previousSibling"
1729 parent = elem.parentNode,
1730 name = ofType && elem.nodeName.toLowerCase(),
1731 useCache = !xml && !ofType,
1732 diff = false
1733
1734 if
1735
1736 // :(first|last|only)-(child|of-type)
1737 if
1738 while
1739 node = elem;
1740 while
1741 if
1742 node.nodeName.toLowerCase() === name :
1743 node.nodeType === 1 ) {
1744
1745 return false
1746 }
1747 }
1748 // Reverse direction for :only-* (if we haven't yet done so)
1749 "only" "nextSibling"
1750 }
1751 return true
1752 }
1753
1754 start = [ forward ? parent.firstChild : parent.lastChild ];
1755
1756 // non-xml :nth-child(...) stores cache data on `parent`
1757 if
1758
1759 // Seek `elem` from a previously-cached index
1760
1761 // ...in a gzip-friendly way
1762
1763 outerCache = node[ expando ] || (node[ expando ] = {});
1764
1765 // Support: IE <9 only
1766 // Defend against cloned attroperties (jQuery gh-1709)
1767
1768 (outerCache[ node.uniqueID ] = {});
1769
1770 cache = uniqueCache[ type ] || [];
1771 nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1772 diff = nodeIndex && cache[ 2 ];
1773 node = nodeIndex && parent.childNodes[ nodeIndex ];
1774
1775 while
1776
1777 // Fallback to seeking `elem` from the start
1778
1779
1780 // When found, cache indexes on `parent` and break
1781 if
1782 uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
1783 break
1784 }
1785 }
1786
1787 } else
1788 // Use previously-cached element index if available
1789 if
1790 // ...in a gzip-friendly way
1791
1792 outerCache = node[ expando ] || (node[ expando ] = {});
1793
1794 // Support: IE <9 only
1795 // Defend against cloned attroperties (jQuery gh-1709)
1796
1797 (outerCache[ node.uniqueID ] = {});
1798
1799 cache = uniqueCache[ type ] || [];
1800 nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1801 diff = nodeIndex;
1802 }
1803
1804 // xml :nth-child(...)
1805 // or :nth-last-child(...) or :nth(-last)?-of-type(...)
1806 if false
1807 // Use the same loop as above to seek `elem` from the start
1808 while
1809 (diff = nodeIndex = 0) || start.pop()) ) {
1810
1811 if
1812 node.nodeName.toLowerCase() === name :
1813 node.nodeType === 1 ) &&
1814 ++diff ) {
1815
1816 // Cache the index of each encountered element
1817 if
1818 outerCache = node[ expando ] || (node[ expando ] = {});
1819
1820 // Support: IE <9 only
1821 // Defend against cloned attroperties (jQuery gh-1709)
1822
1823 (outerCache[ node.uniqueID ] = {});
1824
1825 uniqueCache[ type ] = [ dirruns, diff ];
1826 }
1827
1828 if
1829 break
1830 }
1831 }
1832 }
1833 }
1834 }
1835
1836 // Incorporate the offset, then check against cycle size
1837
1838 return / first >= 0 );
1839 }
1840 };
1841 },
1842
1843 "PSEUDO": function( pseudo, argument ) {
1844 / / pseudo-class names are case-insensitive
1845 / / http:/ /www.w3.org/ /selectors/
1846 // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1847 // Remember that setFilters inherits from pseudos
1848 var
1849 fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
1850 Sizzle.error( "unsupported pseudo: "
1851
1852 // The user may use createPseudo to indicate that
1853 // arguments are needed to create the filter function
1854 // just as Sizzle does
1855 if
1856 return
1857 }
1858
1859 // But maintain support for old signatures
1860 if
1861 args = [ pseudo, pseudo, ""
1862 return
1863 markFunction(function
1864 var
1865 matched = fn( seed, argument ),
1866 i = matched.length;
1867 while
1868 idx = indexOf( seed, matched[i] );
1869 seed[ idx ] = !( matches[ idx ] = matched[i] );
1870 }
1871 }) :
1872 function
1873 return
1874 };
1875 }
1876
1877 return
1878 }
1879 },
1880
1881 pseudos: {
1882 // Potentially complex pseudos
1883 "not" function
1884 // Trim the selector passed to compile
1885 // to avoid treating leading and trailing
1886 // spaces as combinators
1887 var
1888 results = [],
1889 matcher = compile( selector.replace( rtrim, "$1"
1890
1891 return
1892 markFunction(function
1893 var
1894 unmatched = matcher( seed, null
1895 i = seed.length;
1896
1897 // Match elements unmatched by `matcher`
1898 while
1899 if
1900 seed[i] = !(matches[i] = elem);
1901 }
1902 }
1903 }) :
1904 function
1905 input[0] = elem;
1906 matcher( input, null
1907 // Don't keep the element (issue #299)
1908 null
1909 return
1910 };
1911 }),
1912
1913 "has" function
1914 return function
1915 return
1916 };
1917 }),
1918
1919 "contains" function
1920 text = text.replace( runescape, funescape );
1921 return function
1922 return
1923 };
1924 }),
1925
1926 // "Whether an element is represented by a :lang() selector
1927 // is based solely on the element's language value
1928 // being equal to the identifier C,
1929 // or beginning with the identifier C immediately followed by "-".
1930 // The matching of C against the element's language value is performed case-insensitively.
1931 // The identifier C does not have to be a valid language name."
1932 // http://www.w3.org/TR/selectors/#lang-pseudo
1933 "lang" function
1934 // lang value must be a valid identifier
1935 if ""
1936 Sizzle.error( "unsupported lang: "
1937 }
1938 lang = lang.replace( runescape, funescape ).toLowerCase();
1939 return function
1940 var
1941 do
1942 if
1943 elem.lang :
1944 elem.getAttribute("xml:lang" "lang"
1945
1946 elemLang = elemLang.toLowerCase();
1947 return "-"
1948 }
1949 } while
1950 return false
1951 };
1952 }),
1953
1954 // Miscellaneous
1955 "target" function
1956 var
1957 return
1958 },
1959
1960 "root" function
1961 return
1962 },
1963
1964 "focus" function
1965 return
1966 },
1967
1968 // Boolean properties
1969 "enabled" function
1970 return false
1971 },
1972
1973 "disabled" function
1974 return true
1975 },
1976
1977 "checked" function
1978 // In CSS3, :checked should return both checked and selected elements
1979 // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1980 var
1981 return "input" "option"
1982 },
1983
1984 "selected" function
1985 // Accessing this property makes selected-by-default
1986 // options in Safari work properly
1987 if
1988 elem.parentNode.selectedIndex;
1989 }
1990
1991 return true
1992 },
1993
1994 // Contents
1995 "empty" function
1996 // http://www.w3.org/TR/selectors/#empty-pseudo
1997 // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
1998 // but not by others (comment: 8; processing instruction: 7; etc.)
1999 // nodeType < 6 works because attributes (2) do not appear as children
2000 for
2001 if
2002 return false
2003 }
2004 }
2005 return true
2006 },
2007
2008 "parent" function
2009 return "empty"
2010 },
2011
2012 // Element/input types
2013 "header" function
2014 return
2015 },
2016
2017 "input" function
2018 return
2019 },
2020
2021 "button" function
2022 var
2023 return "input" "button" "button"
2024 },
2025
2026 "text" function
2027 var
2028 return "input"
2029 elem.type === "text"
2030
2031 // Support: IE<8
2032 // New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
2033 "type" null "text"
2034 },
2035
2036 // Position-in-collection
2037 "first" function
2038 return
2039 }),
2040
2041 "last" function
2042 return
2043 }),
2044
2045 "eq" function
2046 return
2047 }),
2048
2049 "even" function
2050 var
2051 for
2052 matchIndexes.push( i );
2053 }
2054 return
2055 }),
2056
2057 "odd" function
2058 var
2059 for
2060 matchIndexes.push( i );
2061 }
2062 return
2063 }),
2064
2065 "lt" function
2066 var
2067 for
2068 matchIndexes.push( i );
2069 }
2070 return
2071 }),
2072
2073 "gt" function
2074 var
2075 for
2076 matchIndexes.push( i );
2077 }
2078 return
2079 })
2080 }
2081 };
2082
2083 Expr.pseudos["nth" "eq"
2084
2085 // Add button/input type pseudos
2086 for in true true true true true
2087 Expr.pseudos[ i ] = createInputPseudo( i );
2088 }
2089 for in true true
2090 Expr.pseudos[ i ] = createButtonPseudo( i );
2091 }
2092
2093 // Easy API for creating new setFilters
2094 function setFilters
2095 setFilters.prototype = Expr.filters = Expr.pseudos;
2096 Expr.setFilters = new
2097
2098 tokenize = Sizzle.tokenize = function
2099 var
2100 soFar, groups, preFilters,
2101 cached = tokenCache[ selector + " "
2102
2103 if
2104 return
2105 }
2106
2107 soFar = selector;
2108 groups = [];
2109 preFilters = Expr.preFilter;
2110
2111 while
2112
2113 // Comma and first run
2114 if
2115 if
2116 // Don't consume trailing commas as valid
2117
2118 }
2119 groups.push( (tokens = []) );
2120 }
2121
2122 matched = false
2123
2124 // Combinators
2125 if
2126 matched = match.shift();
2127 tokens.push({
2128 value: matched,
2129 // Cast descendant combinators to space
2130 " "
2131 });
2132 soFar = soFar.slice( matched.length );
2133 }
2134
2135 // Filters
2136 for in
2137 if
2138 (match = preFilters[ type ]( match ))) ) {
2139 matched = match.shift();
2140 tokens.push({
2141 value: matched,
2142 type: type,
2143 matches: match
2144 });
2145 soFar = soFar.slice( matched.length );
2146 }
2147 }
2148
2149 if
2150 break
2151 }
2152 }
2153
2154 // Return the length of the invalid excess
2155 // if we're just parsing
2156 // Otherwise, throw an error or return tokens
2157 return
2158 soFar.length :
2159 soFar ?
2160 Sizzle.error( selector ) :
2161 // Cache the tokens
2162
2163 };
2164
2165 function toSelector
2166 var
2167 len = tokens.length,
2168 selector = ""
2169 for
2170 selector += tokens[i].value;
2171 }
2172 return
2173 }
2174
2175 function addCombinator
2176 var
2177 checkNonElements = base && dir === "parentNode"
2178 doneName = done++;
2179
2180 return
2181 // Check against closest ancestor/preceding element
2182 function
2183 while
2184 if
2185 return
2186 }
2187 }
2188 } :
2189
2190 // Check against all ancestor/preceding elements
2191 function
2192 var
2193 newCache = [ dirruns, doneName ];
2194
2195 // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2196 if
2197 while
2198 if
2199 if
2200 return true
2201 }
2202 }
2203 }
2204 } else
2205 while
2206 if
2207 outerCache = elem[ expando ] || (elem[ expando ] = {});
2208
2209 // Support: IE <9 only
2210 // Defend against cloned attroperties (jQuery gh-1709)
2211
2212
2213 if
2214 oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2215
2216 // Assign to newCache so results back-propagate to previous elements
2217 return
2218 } else
2219 // Reuse newcache so results back-propagate to previous elements
2220
2221
2222 // A match means we're done; a fail means we have to keep checking
2223 if
2224 return true
2225 }
2226 }
2227 }
2228 }
2229 }
2230 };
2231 }
2232
2233 function elementMatcher
2234 return
2235 function
2236 var
2237 while
2238 if
2239 return false
2240 }
2241 }
2242 return true
2243 } :
2244 matchers[0];
2245 }
2246
2247 function multipleContexts
2248 var
2249 len = contexts.length;
2250 for
2251 Sizzle( selector, contexts[i], results );
2252 }
2253 return
2254 }
2255
2256 function condense
2257 var
2258 newUnmatched = [],
2259 i = 0,
2260 len = unmatched.length,
2261 mapped = map != null
2262
2263 for
2264 if
2265 if
2266 newUnmatched.push( elem );
2267 if
2268 map.push( i );
2269 }
2270 }
2271 }
2272 }
2273
2274 return
2275 }
2276
2277 function setMatcher
2278 if
2279 postFilter = setMatcher( postFilter );
2280 }
2281 if
2282 postFinder = setMatcher( postFinder, postSelector );
2283 }
2284 return function
2285 var
2286 preMap = [],
2287 postMap = [],
2288 preexisting = results.length,
2289
2290 // Get initial elements from seed or context
2291 "*"
2292
2293 // Prefilter to get matcher input, preserving a map for seed-results synchronization
2294
2295 condense( elems, preMap, preFilter, context, xml ) :
2296 elems,
2297
2298 matcherOut = matcher ?
2299 // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2300
2301
2302 // ...intermediate processing is necessary
2303
2304
2305 // ...otherwise use results directly
2306
2307 matcherIn;
2308
2309 // Find primary matches
2310 if
2311 matcher( matcherIn, matcherOut, context, xml );
2312 }
2313
2314 // Apply postFilter
2315 if
2316 temp = condense( matcherOut, postMap );
2317 postFilter( temp, [], context, xml );
2318
2319 // Un-match failing elements by moving them back to matcherIn
2320
2321 while
2322 if
2323 matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2324 }
2325 }
2326 }
2327
2328 if
2329 if
2330 if
2331 // Get the final matcherOut by condensing this intermediate into postFinder contexts
2332
2333 i = matcherOut.length;
2334 while
2335 if
2336 // Restore matcherIn since elem is not yet a final match
2337
2338 }
2339 }
2340 postFinder( null
2341 }
2342
2343 // Move matched elements from seed to results to keep them synchronized
2344
2345 while
2346 if
2347 (temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
2348
2349 seed[temp] = !(results[temp] = elem);
2350 }
2351 }
2352 }
2353
2354 // Add elements to results, through postFinder if defined
2355 else
2356 matcherOut = condense(
2357 matcherOut === results ?
2358 matcherOut.splice( preexisting, matcherOut.length ) :
2359 matcherOut
2360 );
2361 if
2362 postFinder( null
2363 } else
2364 push.apply( results, matcherOut );
2365 }
2366 }
2367 });
2368 }
2369
2370 function matcherFromTokens
2371 var
2372 len = tokens.length,
2373 leadingRelative = Expr.relative[ tokens[0].type ],
2374 implicitRelative = leadingRelative || Expr.relative[" "
2375 i = leadingRelative ? 1 : 0,
2376
2377 // The foundational matcher ensures that elements are reachable from top-level context(s)
2378 function
2379 return
2380 }, implicitRelative, true
2381 matchAnyContext = addCombinator( function
2382 return
2383 }, implicitRelative, true
2384 matchers = [ function
2385 var
2386 (checkContext = context).nodeType ?
2387 matchContext( elem, context, xml ) :
2388 matchAnyContext( elem, context, xml ) );
2389 // Avoid hanging onto element (issue #299)
2390 null
2391 return
2392 } ];
2393
2394 for
2395 if
2396 matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2397 } else
2398 matcher = Expr.filter[ tokens[i].type ].apply( null
2399
2400 // Return special upon seeing a positional matcher
2401 if
2402 // Find the next relative operator (if any) for proper handling
2403
2404 for
2405 if
2406 break
2407 }
2408 }
2409 return
2410 i > 1 && elementMatcher( matchers ),
2411 i > 1 && toSelector(
2412 // If the preceding token was a descendant combinator, insert an implicit any-element `*`
2413 " " "*" ""
2414 ).replace( rtrim, "$1"
2415 matcher,
2416 i < j && matcherFromTokens( tokens.slice( i, j ) ),
2417 j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2418 j < len && toSelector( tokens )
2419 );
2420 }
2421 matchers.push( matcher );
2422 }
2423 }
2424
2425 return
2426 }
2427
2428 function matcherFromGroupMatchers
2429 var
2430 byElement = elementMatchers.length > 0,
2431 superMatcher = function
2432 var
2433 matchedCount = 0,
2434 i = "0"
2435 unmatched = seed && [],
2436 setMatched = [],
2437 contextBackup = outermostContext,
2438 // We must always have either seed elements or outermost context
2439 "TAG" "*"
2440 // Use integer dirruns iff this is the outermost matcher
2441 null Math
2442 len = elems.length;
2443
2444 if
2445 outermostContext = context === document || context || outermost;
2446 }
2447
2448 // Add elements passing elementMatchers directly to results
2449 // Support: IE<9, Safari
2450 // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2451 for null
2452 if
2453 j = 0;
2454 if
2455 setDocument( elem );
2456 xml = !documentIsHTML;
2457 }
2458 while
2459 if
2460 results.push( elem );
2461 break
2462 }
2463 }
2464 if
2465 dirruns = dirrunsUnique;
2466 }
2467 }
2468
2469 // Track unmatched elements for set filters
2470 if
2471 // They will have gone through all possible matchers
2472 if
2473 matchedCount--;
2474 }
2475
2476 // Lengthen the array for every element, matched or not
2477 if
2478 unmatched.push( elem );
2479 }
2480 }
2481 }
2482
2483 // `i` is now the count of elements visited above, and adding it to `matchedCount`
2484 // makes the latter nonnegative.
2485
2486
2487 // Apply set filters to unmatched elements
2488 // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2489 // equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2490 // no element matchers and no seed.
2491 // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2492 // case, which will result in a "00" `matchedCount` that differs from `i` but is also
2493 // numerically zero.
2494 if
2495 j = 0;
2496 while
2497 matcher( unmatched, setMatched, context, xml );
2498 }
2499
2500 if
2501 // Reintegrate element matches to eliminate the need for sorting
2502 if
2503 while
2504 if
2505 setMatched[i] = pop.call( results );
2506 }
2507 }
2508 }
2509
2510 // Discard index placeholder values to get only actual matches
2511
2512 }
2513
2514 // Add matches to results
2515
2516
2517 // Seedless set matches succeeding multiple successful matchers stipulate sorting
2518 if
2519 ( matchedCount + setMatchers.length ) > 1 ) {
2520
2521 Sizzle.uniqueSort( results );
2522 }
2523 }
2524
2525 // Override manipulation of globals by nested matchers
2526 if
2527 dirruns = dirrunsUnique;
2528 outermostContext = contextBackup;
2529 }
2530
2531 return
2532 };
2533
2534 return
2535 markFunction( superMatcher ) :
2536 superMatcher;
2537 }
2538
2539 compile = Sizzle.compile = function /* Internal Use Only */
2540 var
2541 setMatchers = [],
2542 elementMatchers = [],
2543 cached = compilerCache[ selector + " "
2544
2545 if
2546 // Generate a function of recursive functions that can be used to check each element
2547 if
2548 match = tokenize( selector );
2549 }
2550 i = match.length;
2551 while
2552 cached = matcherFromTokens( match[i] );
2553 if
2554 setMatchers.push( cached );
2555 } else
2556 elementMatchers.push( cached );
2557 }
2558 }
2559
2560 // Cache the compiled function
2561
2562
2563 // Save selector and tokenization
2564
2565 }
2566 return
2567 };
2568
2569 /**
2570 * A low-level selection function that works with Sizzle's compiled
2571 * selector functions
2572 * @param {String|Function} selector A selector or a pre-compiled
2573 * selector function built with Sizzle.compile
2574 * @param {Element} context
2575 * @param {Array} [results]
2576 * @param {Array} [seed] A set of elements to match against
2577 */
2578 select = Sizzle.select = function
2579 var
2580 compiled = typeof selector === "function"
2581 match = !seed && tokenize( (selector = compiled.selector || selector) );
2582
2583 results = results || [];
2584
2585 // Try to minimize operations if there is only one selector in the list and no seed
2586 // (the latter of which guarantees us context)
2587 if
2588
2589 // Reduce context if the leading compound selector is an ID
2590
2591 if "ID"
2592 support.getById && context.nodeType === 9 && documentIsHTML &&
2593 Expr.relative[ tokens[1].type ] ) {
2594
2595 context = ( Expr.find["ID"
2596 if
2597 return
2598
2599 // Precompiled matchers will still verify ancestry, so step up a level
2600 else if
2601 context = context.parentNode;
2602 }
2603
2604 selector = selector.slice( tokens.shift().value.length );
2605 }
2606
2607 // Fetch a seed set for right-to-left matching
2608 "needsContext"
2609 while
2610 token = tokens[i];
2611
2612 // Abort if we hit a combinator
2613 if
2614 break
2615 }
2616 if
2617 // Search, expanding context for leading sibling combinators
2618 if
2619 token.matches[0].replace( runescape, funescape ),
2620 rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
2621 )) ) {
2622
2623 // If seed is empty or no tokens remain, we can return early
2624
2625 selector = seed.length && toSelector( tokens );
2626 if
2627 push.apply( results, seed );
2628 return
2629 }
2630
2631 break
2632 }
2633 }
2634 }
2635 }
2636
2637 // Compile and execute a filtering function if one is not provided
2638 // Provide `match` to avoid retokenization if we modified the selector above
2639
2640 seed,
2641 context,
2642 !documentIsHTML,
2643 results,
2644 !context || rsibling.test( selector ) && testContext( context.parentNode ) || context
2645 );
2646 return
2647 };
2648
2649 // One-time assignments
2650
2651 // Sort stability
2652 "" ""
2653
2654 // Support: Chrome 14-35+
2655 // Always assume duplicates if they aren't passed to the comparison function
2656
2657
2658 // Initialize against the default document
2659
2660
2661 // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2662 // Detached nodes confoundingly follow *each other*
2663 function
2664 // Should return 1, but returns 4 (following)
2665 return "div"
2666 });
2667
2668 // Support: IE<8
2669 // Prevent attribute/property "interpolation"
2670 // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2671 if function
2672 div.innerHTML = "<a href='#'></a>"
2673 return "href" "#"
2674 }) ) {
2675 addHandle( "type|href|height|width" function
2676 if
2677 return "type"
2678 }
2679 });
2680 }
2681
2682 // Support: IE<9
2683 // Use defaultValue in place of getAttribute("value")
2684 if function
2685 div.innerHTML = "<input/>"
2686 div.firstChild.setAttribute( "value" ""
2687 return "value" ""
2688 }) ) {
2689 addHandle( "value" function
2690 if "input"
2691 return
2692 }
2693 });
2694 }
2695
2696 // Support: IE<9
2697 // Use getAttributeNode to fetch booleans when getAttribute lies
2698 if function
2699 return "disabled" null
2700 }) ) {
2701 addHandle( booleans, function
2702 var
2703 if
2704 return true
2705 (val = elem.getAttributeNode( name )) && val.specified ?
2706 val.value :
2707 null
2708 }
2709 });
2710 }
2711
2712 return
2713
2714 })( window );
2715
2716
2717
2718 jQuery.find = Sizzle;
2719 jQuery.expr = Sizzle.selectors;
2720 jQuery.expr[ ":"
2721 jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
2722 jQuery.text = Sizzle.getText;
2723 jQuery.isXMLDoc = Sizzle.isXML;
2724 jQuery.contains = Sizzle.contains;
2725
2726
2727
2728 var function
2729 var
2730 truncate = until !== undefined;
2731
2732 while
2733 if
2734 if
2735 break
2736 }
2737 matched.push( elem );
2738 }
2739 }
2740 return
2741 };
2742
2743
2744 var function
2745 var
2746
2747 for
2748 if
2749 matched.push( n );
2750 }
2751 }
2752
2753 return
2754 };
2755
2756
2757 var
2758
2759 var /^<([\w-]+)\s*\/?>(?:<\/\1>|)$/
2760
2761
2762
2763 <([\w-]+)\s*\/?><\/\1>var /^.[^:#\[\.,]*$/
2764
2765 <([\w-]+)\s*\/?><\/\1>// Implement the identical functionality for filter and not
2766 <([\w-]+)\s*\/?><\/\1>function winnow
2767 <([\w-]+)\s*\/?><\/\1> if
2768 <([\w-]+)\s*\/?><\/\1> return function
2769 <([\w-]+)\s*\/?><\/\1> /* jshint -W018 */
2770 <([\w-]+)\s*\/?><\/\1> return
2771 <([\w-]+)\s*\/?><\/\1> } );
2772
2773 <([\w-]+)\s*\/?><\/\1> }
2774
2775 <([\w-]+)\s*\/?><\/\1> if
2776 <([\w-]+)\s*\/?><\/\1> return function
2777 <([\w-]+)\s*\/?><\/\1> return
2778 <([\w-]+)\s*\/?><\/\1> } );
2779
2780 <([\w-]+)\s*\/?><\/\1> }
2781
2782 <([\w-]+)\s*\/?><\/\1> if "string"
2783 <([\w-]+)\s*\/?><\/\1> if
2784 <([\w-]+)\s*\/?><\/\1> return
2785 <([\w-]+)\s*\/?><\/\1> }
2786
2787 <([\w-]+)\s*\/?><\/\1> qualifier = jQuery.filter( qualifier, elements );
2788 <([\w-]+)\s*\/?><\/\1> }
2789
2790 <([\w-]+)\s*\/?><\/\1> return function
2791 <([\w-]+)\s*\/?><\/\1> return
2792 <([\w-]+)\s*\/?><\/\1> } );
2793 <([\w-]+)\s*\/?><\/\1>}
2794
2795 <([\w-]+)\s*\/?><\/\1>jQuery.filter = function
2796 <([\w-]+)\s*\/?><\/\1> var
2797
2798 <([\w-]+)\s*\/?><\/\1> if
2799 <([\w-]+)\s*\/?><\/\1> expr = ":not(" ")"
2800 <([\w-]+)\s*\/?><\/\1> }
2801
2802 <([\w-]+)\s*\/?><\/\1> return
2803 <([\w-]+)\s*\/?><\/\1> jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :
2804 <([\w-]+)\s*\/?><\/\1> jQuery.find.matches( expr, jQuery.grep( elems, function
2805 <([\w-]+)\s*\/?><\/\1> return
2806 <([\w-]+)\s*\/?><\/\1> } ) );
2807 <([\w-]+)\s*\/?><\/\1>};
2808
2809 <([\w-]+)\s*\/?><\/\1>jQuery.fn.extend( {
2810 <([\w-]+)\s*\/?><\/\1> find: function
2811 <([\w-]+)\s*\/?><\/\1> var
2812 <([\w-]+)\s*\/?><\/\1> ret = [],
2813 <([\w-]+)\s*\/?><\/\1> self = this
2814 <([\w-]+)\s*\/?><\/\1> len = self.length;
2815
2816 <([\w-]+)\s*\/?><\/\1> if "string"
2817 <([\w-]+)\s*\/?><\/\1> return this function
2818 <([\w-]+)\s*\/?><\/\1> for
2819 <([\w-]+)\s*\/?><\/\1> if this
2820 <([\w-]+)\s*\/?><\/\1> return true
2821 <([\w-]+)\s*\/?><\/\1> }
2822 <([\w-]+)\s*\/?><\/\1> }
2823 <([\w-]+)\s*\/?><\/\1> } ) );
2824 <([\w-]+)\s*\/?><\/\1> }
2825
2826 <([\w-]+)\s*\/?><\/\1> for
2827 <([\w-]+)\s*\/?><\/\1> jQuery.find( selector, self[ i ], ret );
2828 <([\w-]+)\s*\/?><\/\1> }
2829
2830 <([\w-]+)\s*\/?><\/\1> // Needed because $( selector, context ) becomes $( context ).find( selector )
2831 <([\w-]+)\s*\/?><\/\1>this
2832 <([\w-]+)\s*\/?><\/\1> ret.selector = this this " "
2833 <([\w-]+)\s*\/?><\/\1> return
2834 <([\w-]+)\s*\/?><\/\1> },
2835 <([\w-]+)\s*\/?><\/\1> filter: function
2836 <([\w-]+)\s*\/?><\/\1> return this this false
2837 <([\w-]+)\s*\/?><\/\1> },
2838 <([\w-]+)\s*\/?><\/\1> not: function
2839 <([\w-]+)\s*\/?><\/\1> return this this true
2840 <([\w-]+)\s*\/?><\/\1> },
2841 <([\w-]+)\s*\/?><\/\1> is: function
2842 <([\w-]+)\s*\/?><\/\1> return
2843 <([\w-]+)\s*\/?><\/\1> this
2844
2845 <([\w-]+)\s*\/?><\/\1> // If this is a positional/relative selector, check membership in the returned set
2846 <([\w-]+)\s*\/?><\/\1>// so $("p:first").is("p:last") won't return true for a doc with two "p".
2847 <([\w-]+)\s*\/?><\/\1>"string"
2848 <([\w-]+)\s*\/?><\/\1> jQuery( selector ) :
2849 <([\w-]+)\s*\/?><\/\1> selector || [],
2850 <([\w-]+)\s*\/?><\/\1> false
2851 <([\w-]+)\s*\/?><\/\1> ).length;
2852 <([\w-]+)\s*\/?><\/\1> }
2853 <([\w-]+)\s*\/?><\/\1>} );
2854
2855
2856 <([\w-]+)\s*\/?><\/\1>// Initialize a jQuery object
2857
2858
2859 <([\w-]+)\s*\/?><\/\1>// A central reference to the root jQuery(document)
2860 <([\w-]+)\s*\/?><\/\1>var
2861
2862 <([\w-]+)\s*\/?><\/\1> // A simple way to check for HTML strings
2863 <([\w-]+)\s*\/?><\/\1>// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
2864 <([\w-]+)\s*\/?><\/\1>// Strict HTML recognition (#11290: must start with <)
2865 <([\w-]+)\s*\/?><\/\1>/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/
2866
2867 <([\w-]+)\s*\/?><\/\1><[\w\W]+> init = jQuery.fn.init = function
2868 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
2869
2870 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // HANDLE: $(""), $(null), $(undefined), $(false)
2871 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
2872 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
2873 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
2874
2875 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // init accepts an alternate rootjQuery
2876 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// so migrate can support jQuery.sub (gh-2101)
2877 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
2878
2879 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Handle HTML strings
2880 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if "string"
2881 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if "<"
2882 <([\w-]+)\s*\/?><\/\1><[\w\W]+> selector.charAt( selector.length - 1 ) === ">"
2883 <([\w-]+)\s*\/?><\/\1><[\w\W]+> selector.length >= 3 ) {
2884
2885 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Assume that strings that start and end with <> are HTML and skip the regex check
2886 <([\w-]+)\s*\/?><\/\1><[\w\W]+>null null
2887
2888 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } else
2889 <([\w-]+)\s*\/?><\/\1><[\w\W]+> match = rquickExpr.exec( selector );
2890 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
2891
2892 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Match html or make sure no context is specified for #id
2893 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
2894
2895 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // HANDLE: $(html) -> $(array)
2896 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
2897 <([\w-]+)\s*\/?><\/\1><[\w\W]+> context = context instanceof
2898
2899 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // scripts is true for back-compat
2900 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Intentionally let the error be thrown if parseHTML is not present
2901 <([\w-]+)\s*\/?><\/\1><[\w\W]+>this
2902 <([\w-]+)\s*\/?><\/\1><[\w\W]+> match[ 1 ],
2903 <([\w-]+)\s*\/?><\/\1><[\w\W]+> context && context.nodeType ? context.ownerDocument || context : document,
2904 <([\w-]+)\s*\/?><\/\1><[\w\W]+> true
2905 <([\w-]+)\s*\/?><\/\1><[\w\W]+> ) );
2906
2907 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // HANDLE: $(html, props)
2908 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
2909 <([\w-]+)\s*\/?><\/\1><[\w\W]+> for in
2910
2911 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Properties of context are called as methods if possible
2912 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if this
2913 <([\w-]+)\s*\/?><\/\1><[\w\W]+> this
2914
2915 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // ...and otherwise set as attributes
2916 <([\w-]+)\s*\/?><\/\1><[\w\W]+>else
2917 <([\w-]+)\s*\/?><\/\1><[\w\W]+> this
2918 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
2919 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
2920 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
2921
2922 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
2923
2924 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // HANDLE: $(#id)
2925 <([\w-]+)\s*\/?><\/\1><[\w\W]+>else
2926 <([\w-]+)\s*\/?><\/\1><[\w\W]+> elem = document.getElementById( match[ 2 ] );
2927
2928 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Check parentNode to catch when Blackberry 4.6 returns
2929 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// nodes that are no longer in the document #6963
2930 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
2931
2932 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Handle the case where IE and Opera return items
2933 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// by name instead of ID
2934 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
2935 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
2936 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
2937
2938 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Otherwise, we inject the element directly into the jQuery object
2939 <([\w-]+)\s*\/?><\/\1><[\w\W]+>this
2940 <([\w-]+)\s*\/?><\/\1><[\w\W]+> this
2941 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
2942
2943 <([\w-]+)\s*\/?><\/\1><[\w\W]+> this
2944 <([\w-]+)\s*\/?><\/\1><[\w\W]+> this
2945 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
2946 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
2947
2948 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // HANDLE: $(expr, $(...))
2949 <([\w-]+)\s*\/?><\/\1><[\w\W]+>else if
2950 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
2951
2952 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // HANDLE: $(expr, context)
2953 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// (which is just equivalent to: $(context).find(expr)
2954 <([\w-]+)\s*\/?><\/\1><[\w\W]+>else
2955 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
2956 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
2957
2958 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // HANDLE: $(DOMElement)
2959 <([\w-]+)\s*\/?><\/\1><[\w\W]+>else if
2960 <([\w-]+)\s*\/?><\/\1><[\w\W]+> this this
2961 <([\w-]+)\s*\/?><\/\1><[\w\W]+> this
2962 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
2963
2964 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // HANDLE: $(function)
2965 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Shortcut for document ready
2966 <([\w-]+)\s*\/?><\/\1><[\w\W]+>else if
2967 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return "undefined"
2968 <([\w-]+)\s*\/?><\/\1><[\w\W]+> root.ready( selector ) :
2969
2970 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Execute immediately if ready is not present
2971 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
2972 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
2973
2974 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
2975 <([\w-]+)\s*\/?><\/\1><[\w\W]+> this
2976 <([\w-]+)\s*\/?><\/\1><[\w\W]+> this
2977 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
2978
2979 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
2980 <([\w-]+)\s*\/?><\/\1><[\w\W]+> };
2981
2982 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Give the init function the jQuery prototype for later instantiation
2983 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
2984
2985 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Initialize central reference
2986 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
2987
2988
2989 <([\w-]+)\s*\/?><\/\1><[\w\W]+>var /^(?:parents|prev(?:Until|All))/
2990
2991 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // methods guaranteed to produce a unique set when starting from a unique set
2992 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
2993 <([\w-]+)\s*\/?><\/\1><[\w\W]+> children: true
2994 <([\w-]+)\s*\/?><\/\1><[\w\W]+> contents: true
2995 <([\w-]+)\s*\/?><\/\1><[\w\W]+> next: true
2996 <([\w-]+)\s*\/?><\/\1><[\w\W]+> prev: true
2997 <([\w-]+)\s*\/?><\/\1><[\w\W]+> };
2998
2999 <([\w-]+)\s*\/?><\/\1><[\w\W]+>jQuery.fn.extend( {
3000 <([\w-]+)\s*\/?><\/\1><[\w\W]+> has: function
3001 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
3002 <([\w-]+)\s*\/?><\/\1><[\w\W]+> targets = jQuery( target, this
3003 <([\w-]+)\s*\/?><\/\1><[\w\W]+> len = targets.length;
3004
3005 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this function
3006 <([\w-]+)\s*\/?><\/\1><[\w\W]+> for
3007 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if this
3008 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return true
3009 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3010 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3011 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } );
3012 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3013
3014 <([\w-]+)\s*\/?><\/\1><[\w\W]+> closest: function
3015 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
3016 <([\w-]+)\s*\/?><\/\1><[\w\W]+> i = 0,
3017 <([\w-]+)\s*\/?><\/\1><[\w\W]+> l = this
3018 <([\w-]+)\s*\/?><\/\1><[\w\W]+> matched = [],
3019 <([\w-]+)\s*\/?><\/\1><[\w\W]+> pos = rneedsContext.test( selectors ) || typeof selectors !== "string"
3020 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery( selectors, context || this
3021 <([\w-]+)\s*\/?><\/\1><[\w\W]+> 0;
3022
3023 <([\w-]+)\s*\/?><\/\1><[\w\W]+> for
3024 <([\w-]+)\s*\/?><\/\1><[\w\W]+> for this
3025
3026 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Always skip document fragments
3027 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3028 <([\w-]+)\s*\/?><\/\1><[\w\W]+> pos.index( cur ) > -1 :
3029
3030 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Don't pass non-elements to Sizzle
3031 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3032 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.find.matchesSelector( cur, selectors ) ) ) {
3033
3034 <([\w-]+)\s*\/?><\/\1><[\w\W]+> matched.push( cur );
3035 <([\w-]+)\s*\/?><\/\1><[\w\W]+> break
3036 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3037 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3038 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3039
3040 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
3041 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3042
3043 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Determine the position of an element within
3044 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// the matched set of elements
3045 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3046
3047 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // No argument, return index in parent
3048 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3049 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this this this
3050 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3051
3052 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // index in selector
3053 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if "string"
3054 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
3055 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3056
3057 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Locate the position of the desired element
3058 <([\w-]+)\s*\/?><\/\1><[\w\W]+>return
3059
3060 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // If it receives a jQuery object, the first element is used
3061 <([\w-]+)\s*\/?><\/\1><[\w\W]+>this
3062 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3063
3064 <([\w-]+)\s*\/?><\/\1><[\w\W]+> add: function
3065 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
3066 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.uniqueSort(
3067 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.merge( this
3068 <([\w-]+)\s*\/?><\/\1><[\w\W]+> )
3069 <([\w-]+)\s*\/?><\/\1><[\w\W]+> );
3070 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3071
3072 <([\w-]+)\s*\/?><\/\1><[\w\W]+> addBack: function
3073 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this null
3074 <([\w-]+)\s*\/?><\/\1><[\w\W]+> this this
3075 <([\w-]+)\s*\/?><\/\1><[\w\W]+> );
3076 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3077 <([\w-]+)\s*\/?><\/\1><[\w\W]+>} );
3078
3079 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function sibling
3080 <([\w-]+)\s*\/?><\/\1><[\w\W]+> do
3081 <([\w-]+)\s*\/?><\/\1><[\w\W]+> cur = cur[ dir ];
3082 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } while
3083
3084 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3085 <([\w-]+)\s*\/?><\/\1><[\w\W]+>}
3086
3087 <([\w-]+)\s*\/?><\/\1><[\w\W]+>jQuery.each( {
3088 <([\w-]+)\s*\/?><\/\1><[\w\W]+> parent: function
3089 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
3090 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return null
3091 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3092 <([\w-]+)\s*\/?><\/\1><[\w\W]+> parents: function
3093 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return "parentNode"
3094 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3095 <([\w-]+)\s*\/?><\/\1><[\w\W]+> parentsUntil: function
3096 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return "parentNode"
3097 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3098 <([\w-]+)\s*\/?><\/\1><[\w\W]+> next: function
3099 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return "nextSibling"
3100 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3101 <([\w-]+)\s*\/?><\/\1><[\w\W]+> prev: function
3102 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return "previousSibling"
3103 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3104 <([\w-]+)\s*\/?><\/\1><[\w\W]+> nextAll: function
3105 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return "nextSibling"
3106 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3107 <([\w-]+)\s*\/?><\/\1><[\w\W]+> prevAll: function
3108 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return "previousSibling"
3109 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3110 <([\w-]+)\s*\/?><\/\1><[\w\W]+> nextUntil: function
3111 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return "nextSibling"
3112 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3113 <([\w-]+)\s*\/?><\/\1><[\w\W]+> prevUntil: function
3114 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return "previousSibling"
3115 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3116 <([\w-]+)\s*\/?><\/\1><[\w\W]+> siblings: function
3117 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3118 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3119 <([\w-]+)\s*\/?><\/\1><[\w\W]+> children: function
3120 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3121 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3122 <([\w-]+)\s*\/?><\/\1><[\w\W]+> contents: function
3123 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return "iframe"
3124 <([\w-]+)\s*\/?><\/\1><[\w\W]+> elem.contentDocument || elem.contentWindow.document :
3125 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.merge( [], elem.childNodes );
3126 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3127 <([\w-]+)\s*\/?><\/\1><[\w\W]+>}, function
3128 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.fn[ name ] = function
3129 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var this
3130
3131 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if "Until"
3132 <([\w-]+)\s*\/?><\/\1><[\w\W]+> selector = until;
3133 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3134
3135 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if "string"
3136 <([\w-]+)\s*\/?><\/\1><[\w\W]+> ret = jQuery.filter( selector, ret );
3137 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3138
3139 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if this
3140
3141 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Remove duplicates
3142 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3143 <([\w-]+)\s*\/?><\/\1><[\w\W]+> ret = jQuery.uniqueSort( ret );
3144 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3145
3146 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Reverse order for parents* and prev-derivatives
3147 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3148 <([\w-]+)\s*\/?><\/\1><[\w\W]+> ret = ret.reverse();
3149 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3150 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3151
3152 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
3153 <([\w-]+)\s*\/?><\/\1><[\w\W]+> };
3154 <([\w-]+)\s*\/?><\/\1><[\w\W]+>} );
3155 <([\w-]+)\s*\/?><\/\1><[\w\W]+>var /\S+/
3156
3157
3158
3159 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Convert String-formatted options into Object-formatted ones
3160 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function createOptions
3161 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
3162 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.each( options.match( rnotwhite ) || [], function
3163 <([\w-]+)\s*\/?><\/\1><[\w\W]+> object[ flag ] = true
3164 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } );
3165 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3166 <([\w-]+)\s*\/?><\/\1><[\w\W]+>}
3167
3168 <([\w-]+)\s*\/?><\/\1><[\w\W]+>/*
3169 <([\w-]+)\s*\/?><\/\1><[\w\W]+> * Create a callback list using the following parameters:
3170 <([\w-]+)\s*\/?><\/\1><[\w\W]+> *
3171 <([\w-]+)\s*\/?><\/\1><[\w\W]+> * options: an optional list of space-separated options that will change how
3172 <([\w-]+)\s*\/?><\/\1><[\w\W]+> * the callback list behaves or a more traditional option object
3173 <([\w-]+)\s*\/?><\/\1><[\w\W]+> *
3174 <([\w-]+)\s*\/?><\/\1><[\w\W]+> * By default a callback list will act like an event callback list and can be
3175 <([\w-]+)\s*\/?><\/\1><[\w\W]+> * "fired" multiple times.
3176 <([\w-]+)\s*\/?><\/\1><[\w\W]+> *
3177 <([\w-]+)\s*\/?><\/\1><[\w\W]+> * Possible options:
3178 <([\w-]+)\s*\/?><\/\1><[\w\W]+> *
3179 <([\w-]+)\s*\/?><\/\1><[\w\W]+> * once: will ensure the callback list can only be fired once (like a Deferred)
3180 <([\w-]+)\s*\/?><\/\1><[\w\W]+> *
3181 <([\w-]+)\s*\/?><\/\1><[\w\W]+> * memory: will keep track of previous values and will call any callback added
3182 <([\w-]+)\s*\/?><\/\1><[\w\W]+> * after the list has been fired right away with the latest "memorized"
3183 <([\w-]+)\s*\/?><\/\1><[\w\W]+> * values (like a Deferred)
3184 <([\w-]+)\s*\/?><\/\1><[\w\W]+> *
3185 <([\w-]+)\s*\/?><\/\1><[\w\W]+> * unique: will ensure a callback can only be added once (no duplicate in the list)
3186 <([\w-]+)\s*\/?><\/\1><[\w\W]+> *
3187 <([\w-]+)\s*\/?><\/\1><[\w\W]+> * stopOnFalse: interrupt callings when a callback returns false
3188 <([\w-]+)\s*\/?><\/\1><[\w\W]+> *
3189 <([\w-]+)\s*\/?><\/\1><[\w\W]+> */
3190 <([\w-]+)\s*\/?><\/\1><[\w\W]+>jQuery.Callbacks = function
3191
3192 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Convert options from String-formatted to Object-formatted if needed
3193 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// (we check in cache first)
3194 <([\w-]+)\s*\/?><\/\1><[\w\W]+>"string"
3195 <([\w-]+)\s*\/?><\/\1><[\w\W]+> createOptions( options ) :
3196 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.extend( {}, options );
3197
3198 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var // Flag to know if list is currently firing
3199 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3200
3201 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Last fire value for non-forgettable lists
3202 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3203
3204 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Flag to know if list was already fired
3205 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3206
3207 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Flag to prevent firing
3208 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3209
3210 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Actual callback list
3211 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3212
3213 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Queue of execution data for repeatable lists
3214 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3215
3216 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Index of currently firing callback (modified by add/remove as needed)
3217 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3218
3219 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Fire callbacks
3220 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3221
3222 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Enforce single-firing
3223 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3224
3225 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Execute callbacks for all pending executions,
3226 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// respecting firingIndex overrides and runtime changes
3227 <([\w-]+)\s*\/?><\/\1><[\w\W]+>true
3228 <([\w-]+)\s*\/?><\/\1><[\w\W]+> for
3229 <([\w-]+)\s*\/?><\/\1><[\w\W]+> memory = queue.shift();
3230 <([\w-]+)\s*\/?><\/\1><[\w\W]+> while
3231
3232 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Run callback and check for early termination
3233 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if false
3234 <([\w-]+)\s*\/?><\/\1><[\w\W]+> options.stopOnFalse ) {
3235
3236 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Jump to end and forget the data so .add doesn't re-fire
3237 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3238 <([\w-]+)\s*\/?><\/\1><[\w\W]+> memory = false
3239 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3240 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3241 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3242
3243 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Forget the data if we're done with it
3244 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3245 <([\w-]+)\s*\/?><\/\1><[\w\W]+> memory = false
3246 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3247
3248 <([\w-]+)\s*\/?><\/\1><[\w\W]+> firing = false
3249
3250 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Clean up if we're done firing for good
3251 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3252
3253 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Keep an empty list if we have data for future add calls
3254 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3255 <([\w-]+)\s*\/?><\/\1><[\w\W]+> list = [];
3256
3257 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Otherwise, this object is spent
3258 <([\w-]+)\s*\/?><\/\1><[\w\W]+>else
3259 <([\w-]+)\s*\/?><\/\1><[\w\W]+> list = ""
3260 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3261 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3262 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3263
3264 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Actual Callbacks object
3265 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3266
3267 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Add a callback or a collection of callbacks to the list
3268 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3269 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3270
3271 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // If we have memory from a past run, we should fire after adding
3272 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3273 <([\w-]+)\s*\/?><\/\1><[\w\W]+> firingIndex = list.length - 1;
3274 <([\w-]+)\s*\/?><\/\1><[\w\W]+> queue.push( memory );
3275 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3276
3277 <([\w-]+)\s*\/?><\/\1><[\w\W]+> ( function add
3278 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.each( args, function
3279 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3280 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3281 <([\w-]+)\s*\/?><\/\1><[\w\W]+> list.push( arg );
3282 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3283 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } else if "string"
3284
3285 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Inspect recursively
3286 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3287 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3288 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } );
3289 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } )( arguments );
3290
3291 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3292 <([\w-]+)\s*\/?><\/\1><[\w\W]+> fire();
3293 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3294 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3295 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
3296 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3297
3298 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Remove a callback from the list
3299 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3300 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.each( arguments, function
3301 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
3302 <([\w-]+)\s*\/?><\/\1><[\w\W]+> while
3303 <([\w-]+)\s*\/?><\/\1><[\w\W]+> list.splice( index, 1 );
3304
3305 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Handle firing indexes
3306 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3307 <([\w-]+)\s*\/?><\/\1><[\w\W]+> firingIndex--;
3308 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3309 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3310 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } );
3311 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
3312 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3313
3314 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Check if a given callback is in the list.
3315 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// If no argument is given, return whether or not list has callbacks attached.
3316 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3317 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3318 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.inArray( fn, list ) > -1 :
3319 <([\w-]+)\s*\/?><\/\1><[\w\W]+> list.length > 0;
3320 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3321
3322 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Remove all callbacks from the list
3323 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3324 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3325 <([\w-]+)\s*\/?><\/\1><[\w\W]+> list = [];
3326 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3327 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
3328 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3329
3330 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Disable .fire and .add
3331 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Abort any current/pending executions
3332 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Clear all callbacks and values
3333 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3334 <([\w-]+)\s*\/?><\/\1><[\w\W]+> locked = queue = [];
3335 <([\w-]+)\s*\/?><\/\1><[\w\W]+> list = memory = ""
3336 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
3337 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3338 <([\w-]+)\s*\/?><\/\1><[\w\W]+> disabled: function
3339 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3340 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3341
3342 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Disable .fire
3343 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Also disable .add unless we have memory (since it would have no effect)
3344 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Abort any pending executions
3345 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3346 <([\w-]+)\s*\/?><\/\1><[\w\W]+> locked = true
3347 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3348 <([\w-]+)\s*\/?><\/\1><[\w\W]+> self.disable();
3349 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3350 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
3351 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3352 <([\w-]+)\s*\/?><\/\1><[\w\W]+> locked: function
3353 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3354 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3355
3356 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Call all callbacks with the given context and arguments
3357 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3358 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3359 <([\w-]+)\s*\/?><\/\1><[\w\W]+> args = args || [];
3360 <([\w-]+)\s*\/?><\/\1><[\w\W]+> args = [ context, args.slice ? args.slice() : args ];
3361 <([\w-]+)\s*\/?><\/\1><[\w\W]+> queue.push( args );
3362 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3363 <([\w-]+)\s*\/?><\/\1><[\w\W]+> fire();
3364 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3365 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3366 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
3367 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3368
3369 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Call all the callbacks with the given arguments
3370 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3371 <([\w-]+)\s*\/?><\/\1><[\w\W]+> self.fireWith( this
3372 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
3373 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3374
3375 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // To know if the callbacks have already been called at least once
3376 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3377 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3378 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3379 <([\w-]+)\s*\/?><\/\1><[\w\W]+> };
3380
3381 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3382 <([\w-]+)\s*\/?><\/\1><[\w\W]+>};
3383
3384
3385 <([\w-]+)\s*\/?><\/\1><[\w\W]+>jQuery.extend( {
3386
3387 <([\w-]+)\s*\/?><\/\1><[\w\W]+> Deferred: function
3388 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
3389
3390 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // action, add listener, listener list, final state
3391 <([\w-]+)\s*\/?><\/\1><[\w\W]+>"resolve" "done" "once memory" "resolved"
3392 <([\w-]+)\s*\/?><\/\1><[\w\W]+> [ "reject" "fail" "once memory" "rejected"
3393 <([\w-]+)\s*\/?><\/\1><[\w\W]+> [ "notify" "progress" "memory"
3394 <([\w-]+)\s*\/?><\/\1><[\w\W]+> ],
3395 <([\w-]+)\s*\/?><\/\1><[\w\W]+> state = "pending"
3396 <([\w-]+)\s*\/?><\/\1><[\w\W]+> promise = {
3397 <([\w-]+)\s*\/?><\/\1><[\w\W]+> state: function
3398 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3399 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3400 <([\w-]+)\s*\/?><\/\1><[\w\W]+> always: function
3401 <([\w-]+)\s*\/?><\/\1><[\w\W]+> deferred.done( arguments ).fail( arguments );
3402 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
3403 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3404 <([\w-]+)\s*\/?><\/\1><[\w\W]+> then: function /* fnDone, fnFail, fnProgress */
3405 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
3406 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return function
3407 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.each( tuples, function
3408 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
3409
3410 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // deferred[ done | fail | progress ] for forwarding actions to newDefer
3411 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3412 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var this
3413 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3414 <([\w-]+)\s*\/?><\/\1><[\w\W]+> returned.promise()
3415 <([\w-]+)\s*\/?><\/\1><[\w\W]+> .progress( newDefer.notify )
3416 <([\w-]+)\s*\/?><\/\1><[\w\W]+> .done( newDefer.resolve )
3417 <([\w-]+)\s*\/?><\/\1><[\w\W]+> .fail( newDefer.reject );
3418 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } else
3419 <([\w-]+)\s*\/?><\/\1><[\w\W]+> newDefer[ tuple[ 0 ] + "With"
3420 <([\w-]+)\s*\/?><\/\1><[\w\W]+> this this
3421 <([\w-]+)\s*\/?><\/\1><[\w\W]+> fn ? [ returned ] : arguments
3422 <([\w-]+)\s*\/?><\/\1><[\w\W]+> );
3423 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3424 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } );
3425 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } );
3426 <([\w-]+)\s*\/?><\/\1><[\w\W]+> fns = null
3427 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } ).promise();
3428 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3429
3430 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Get a promise for this deferred
3431 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// If obj is provided, the promise aspect is added to the object
3432 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3433 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return null
3434 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3435 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3436 <([\w-]+)\s*\/?><\/\1><[\w\W]+> deferred = {};
3437
3438 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Keep pipe for back-compat
3439 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3440
3441 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Add list-specific methods
3442 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3443 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
3444 <([\w-]+)\s*\/?><\/\1><[\w\W]+> stateString = tuple[ 3 ];
3445
3446 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // promise[ done | fail | progress ] = list.add
3447 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3448
3449 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Handle state
3450 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3451 <([\w-]+)\s*\/?><\/\1><[\w\W]+> list.add( function
3452
3453 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // state = [ resolved | rejected ]
3454 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3455
3456 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // [ reject_list | resolve_list ].disable; progress_list.lock
3457 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3458 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3459
3460 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // deferred[ resolve | reject | notify ]
3461 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3462 <([\w-]+)\s*\/?><\/\1><[\w\W]+> deferred[ tuple[ 0 ] + "With" this this
3463 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
3464 <([\w-]+)\s*\/?><\/\1><[\w\W]+> };
3465 <([\w-]+)\s*\/?><\/\1><[\w\W]+> deferred[ tuple[ 0 ] + "With"
3466 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } );
3467
3468 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Make the deferred a promise
3469 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3470
3471 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Call given func if any
3472 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3473 <([\w-]+)\s*\/?><\/\1><[\w\W]+> func.call( deferred, deferred );
3474 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3475
3476 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // All done!
3477 <([\w-]+)\s*\/?><\/\1><[\w\W]+>return
3478 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3479
3480 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Deferred helper
3481 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function /* , ..., subordinateN */
3482 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
3483 <([\w-]+)\s*\/?><\/\1><[\w\W]+> resolveValues = slice.call( arguments ),
3484 <([\w-]+)\s*\/?><\/\1><[\w\W]+> length = resolveValues.length,
3485
3486 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // the count of uncompleted subordinates
3487 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3488 <([\w-]+)\s*\/?><\/\1><[\w\W]+> ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
3489
3490 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // the master Deferred.
3491 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// If resolveValues consist of only a single Deferred, just use that.
3492 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3493
3494 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Update function for both resolve and progress values
3495 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3496 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return function
3497 <([\w-]+)\s*\/?><\/\1><[\w\W]+> contexts[ i ] = this
3498 <([\w-]+)\s*\/?><\/\1><[\w\W]+> values[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
3499 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3500 <([\w-]+)\s*\/?><\/\1><[\w\W]+> deferred.notifyWith( contexts, values );
3501
3502 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } else if
3503 <([\w-]+)\s*\/?><\/\1><[\w\W]+> deferred.resolveWith( contexts, values );
3504 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3505 <([\w-]+)\s*\/?><\/\1><[\w\W]+> };
3506 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3507
3508 <([\w-]+)\s*\/?><\/\1><[\w\W]+> progressValues, progressContexts, resolveContexts;
3509
3510 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // add listeners to Deferred subordinates; treat others as resolved
3511 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3512 <([\w-]+)\s*\/?><\/\1><[\w\W]+> progressValues = new
3513 <([\w-]+)\s*\/?><\/\1><[\w\W]+> progressContexts = new
3514 <([\w-]+)\s*\/?><\/\1><[\w\W]+> resolveContexts = new
3515 <([\w-]+)\s*\/?><\/\1><[\w\W]+> for
3516 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3517 <([\w-]+)\s*\/?><\/\1><[\w\W]+> resolveValues[ i ].promise()
3518 <([\w-]+)\s*\/?><\/\1><[\w\W]+> .progress( updateFunc( i, progressContexts, progressValues ) )
3519 <([\w-]+)\s*\/?><\/\1><[\w\W]+> .done( updateFunc( i, resolveContexts, resolveValues ) )
3520 <([\w-]+)\s*\/?><\/\1><[\w\W]+> .fail( deferred.reject );
3521 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } else
3522 <([\w-]+)\s*\/?><\/\1><[\w\W]+> --remaining;
3523 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3524 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3525 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3526
3527 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // if we're not waiting on anything, resolve the master
3528 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3529 <([\w-]+)\s*\/?><\/\1><[\w\W]+> deferred.resolveWith( resolveContexts, resolveValues );
3530 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3531
3532 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3533 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3534 <([\w-]+)\s*\/?><\/\1><[\w\W]+>} );
3535
3536
3537 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// The deferred used on DOM ready
3538 <([\w-]+)\s*\/?><\/\1><[\w\W]+>var
3539
3540 <([\w-]+)\s*\/?><\/\1><[\w\W]+>jQuery.fn.ready = function
3541
3542 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Add the callback
3543 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3544
3545 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
3546 <([\w-]+)\s*\/?><\/\1><[\w\W]+>};
3547
3548 <([\w-]+)\s*\/?><\/\1><[\w\W]+>jQuery.extend( {
3549
3550 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Is the DOM ready to be used? Set to true once it occurs.
3551 <([\w-]+)\s*\/?><\/\1><[\w\W]+>false
3552
3553 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // A counter to track how many items to wait for before
3554 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// the ready event fires. See #6781
3555 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3556
3557 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Hold (or release) the ready event
3558 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3559 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3560 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.readyWait++;
3561 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } else
3562 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.ready( true
3563 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3564 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
3565
3566 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Handle when the DOM is ready
3567 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3568
3569 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Abort if there are pending holds or we're already ready
3570 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if true
3571 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3572 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3573
3574 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Remember that the DOM is ready
3575 <([\w-]+)\s*\/?><\/\1><[\w\W]+>true
3576
3577 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // If a normal DOM Ready event fired, decrement, and wait if need be
3578 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if true
3579 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3580 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3581
3582 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // If there are functions bound, to execute
3583 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3584
3585 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Trigger any bound ready events
3586 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3587 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery( document ).triggerHandler( "ready"
3588 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery( document ).off( "ready"
3589 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3590 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3591 <([\w-]+)\s*\/?><\/\1><[\w\W]+>} );
3592
3593 <([\w-]+)\s*\/?><\/\1><[\w\W]+>/**
3594 <([\w-]+)\s*\/?><\/\1><[\w\W]+> * Clean-up method for dom ready events
3595 <([\w-]+)\s*\/?><\/\1><[\w\W]+> */
3596 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function detach
3597 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3598 <([\w-]+)\s*\/?><\/\1><[\w\W]+> document.removeEventListener( "DOMContentLoaded" false
3599 <([\w-]+)\s*\/?><\/\1><[\w\W]+> window.removeEventListener( "load" false
3600
3601 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } else
3602 <([\w-]+)\s*\/?><\/\1><[\w\W]+> document.detachEvent( "onreadystatechange"
3603 <([\w-]+)\s*\/?><\/\1><[\w\W]+> window.detachEvent( "onload"
3604 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3605 <([\w-]+)\s*\/?><\/\1><[\w\W]+>}
3606
3607 <([\w-]+)\s*\/?><\/\1><[\w\W]+>/**
3608 <([\w-]+)\s*\/?><\/\1><[\w\W]+> * The ready event handler and self cleanup method
3609 <([\w-]+)\s*\/?><\/\1><[\w\W]+> */
3610 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function completed
3611
3612 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // readyState === "complete" is good enough for us to call the dom ready in oldIE
3613 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3614 <([\w-]+)\s*\/?><\/\1><[\w\W]+> window.event.type === "load"
3615 <([\w-]+)\s*\/?><\/\1><[\w\W]+> document.readyState === "complete"
3616
3617 <([\w-]+)\s*\/?><\/\1><[\w\W]+> detach();
3618 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.ready();
3619 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3620 <([\w-]+)\s*\/?><\/\1><[\w\W]+>}
3621
3622 <([\w-]+)\s*\/?><\/\1><[\w\W]+>jQuery.ready.promise = function
3623 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3624 <([\w-]+)\s*\/?><\/\1><[\w\W]+> readyList = jQuery.Deferred();
3625
3626 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Catch cases where $(document).ready() is called
3627 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// after the browser event has already occurred.
3628 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Support: IE6-10
3629 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Older IE sometimes signals "interactive" too soon
3630 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if "complete"
3631 <([\w-]+)\s*\/?><\/\1><[\w\W]+> ( document.readyState !== "loading" /a/ 'a'
3632
3633 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Handle it asynchronously to allow scripts the opportunity to delay ready
3634 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3635
3636 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Standards-based browsers support DOMContentLoaded
3637 <([\w-]+)\s*\/?><\/\1><[\w\W]+>else if
3638
3639 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Use the handy event callback
3640 <([\w-]+)\s*\/?><\/\1><[\w\W]+>"DOMContentLoaded" false
3641
3642 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // A fallback to window.onload, that will always work
3643 <([\w-]+)\s*\/?><\/\1><[\w\W]+>"load" false
3644
3645 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // If IE event model is used
3646 <([\w-]+)\s*\/?><\/\1><[\w\W]+>else
3647
3648 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Ensure firing before onload, maybe late but safe also for iframes
3649 <([\w-]+)\s*\/?><\/\1><[\w\W]+>"onreadystatechange"
3650
3651 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // A fallback to window.onload, that will always work
3652 <([\w-]+)\s*\/?><\/\1><[\w\W]+>"onload"
3653
3654 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // If IE and not a frame
3655 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// continually check to see if the document is ready
3656 <([\w-]+)\s*\/?><\/\1><[\w\W]+>var false
3657
3658 <([\w-]+)\s*\/?><\/\1><[\w\W]+> try
3659 <([\w-]+)\s*\/?><\/\1><[\w\W]+> top = window.frameElement == null
3660 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } catch
3661
3662 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3663 <([\w-]+)\s*\/?><\/\1><[\w\W]+> ( function doScrollCheck
3664 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3665
3666 <([\w-]+)\s*\/?><\/\1><[\w\W]+> try
3667
3668 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Use the trick by Diego Perini
3669 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// http://javascript.nwbox.com/IEContentLoaded/
3670 <([\w-]+)\s*\/?><\/\1><[\w\W]+>"left"
3671 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } catch
3672 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3673 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3674
3675 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // detach all dom ready events
3676 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3677
3678 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // and execute any waiting functions
3679 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3680 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3681 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } )();
3682 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3683 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3684 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3685 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3686 <([\w-]+)\s*\/?><\/\1><[\w\W]+>};
3687
3688 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Kick off the DOM ready check even if the user does not
3689 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3690
3691
3692
3693
3694 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Support: IE<9
3695 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Iteration over object's inherited properties before its own
3696 <([\w-]+)\s*\/?><\/\1><[\w\W]+>var
3697 <([\w-]+)\s*\/?><\/\1><[\w\W]+>for in
3698 <([\w-]+)\s*\/?><\/\1><[\w\W]+> break
3699 <([\w-]+)\s*\/?><\/\1><[\w\W]+>}
3700 <([\w-]+)\s*\/?><\/\1><[\w\W]+>support.ownFirst = i === "0"
3701
3702 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Note: most support tests are defined in their respective modules.
3703 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// false until the test is run
3704 <([\w-]+)\s*\/?><\/\1><[\w\W]+>false
3705
3706 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Execute ASAP in case we need to set body.style.zoom
3707 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
3708
3709 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Minified: var a,b,c,d
3710 <([\w-]+)\s*\/?><\/\1><[\w\W]+>var
3711
3712 <([\w-]+)\s*\/?><\/\1><[\w\W]+> body = document.getElementsByTagName( "body"
3713 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3714
3715 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Return for frameset docs that don't have a body
3716 <([\w-]+)\s*\/?><\/\1><[\w\W]+>return
3717 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3718
3719 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Setup
3720 <([\w-]+)\s*\/?><\/\1><[\w\W]+>"div"
3721 <([\w-]+)\s*\/?><\/\1><[\w\W]+> container = document.createElement( "div"
3722 <([\w-]+)\s*\/?><\/\1><[\w\W]+> container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px"
3723 <([\w-]+)\s*\/?><\/\1><[\w\W]+> body.appendChild( container ).appendChild( div );
3724
3725 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if "undefined"
3726
3727 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Support: IE<8
3728 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Check if natively block-level elements act like inline-block
3729 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// elements when setting their display to 'inline' and giving
3730 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// them layout
3731 <([\w-]+)\s*\/?><\/\1><[\w\W]+>"display:inline;margin:0;border:0;padding:1px;width:1px;zoom:1"
3732
3733 <([\w-]+)\s*\/?><\/\1><[\w\W]+> support.inlineBlockNeedsLayout = val = div.offsetWidth === 3;
3734 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3735
3736 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Prevent IE 6 from affecting layout for positioned elements #11048
3737 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Prevent IE from shrinking the body in IE 7 mode #12869
3738 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Support: IE<8
3739 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3740 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3741 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3742
3743 <([\w-]+)\s*\/?><\/\1><[\w\W]+> body.removeChild( container );
3744 <([\w-]+)\s*\/?><\/\1><[\w\W]+>} );
3745
3746
3747 <([\w-]+)\s*\/?><\/\1><[\w\W]+>( function
3748 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var "div"
3749
3750 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Support: IE<9
3751 <([\w-]+)\s*\/?><\/\1><[\w\W]+>true
3752 <([\w-]+)\s*\/?><\/\1><[\w\W]+> try
3753 <([\w-]+)\s*\/?><\/\1><[\w\W]+> delete div.test;
3754 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } catch
3755 <([\w-]+)\s*\/?><\/\1><[\w\W]+> support.deleteExpando = false
3756 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3757
3758 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Null elements to avoid leaks in IE.
3759 <([\w-]+)\s*\/?><\/\1><[\w\W]+>null
3760 <([\w-]+)\s*\/?><\/\1><[\w\W]+>} )();
3761 <([\w-]+)\s*\/?><\/\1><[\w\W]+>var function
3762 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var " "
3763 <([\w-]+)\s*\/?><\/\1><[\w\W]+> nodeType = +elem.nodeType || 1;
3764
3765 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Do not set data on non-element DOM nodes because it will not be cleared (#8335).
3766 <([\w-]+)\s*\/?><\/\1><[\w\W]+>return
3767 <([\w-]+)\s*\/?><\/\1><[\w\W]+> false
3768
3769 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Nodes accept data unless otherwise specified; rejection can be conditional
3770 <([\w-]+)\s*\/?><\/\1><[\w\W]+>true "classid"
3771 <([\w-]+)\s*\/?><\/\1><[\w\W]+>};
3772
3773
3774
3775
3776 <([\w-]+)\s*\/?><\/\1><[\w\W]+>var /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/
3777 <([\w-]+)\s*\/?><\/\1><[\w\W]+> rmultiDash = /([A-Z])/
3778
3779 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function dataAttr
3780
3781 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // If nothing was found internally, try to fetch any
3782 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// data from the HTML5 data-* attribute
3783 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3784
3785 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var "data-" "-$1"
3786
3787 <([\w-]+)\s*\/?><\/\1><[\w\W]+> data = elem.getAttribute( name );
3788
3789 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if "string"
3790 <([\w-]+)\s*\/?><\/\1><[\w\W]+> try
3791 <([\w-]+)\s*\/?><\/\1><[\w\W]+> data = data === "true" true
3792 <([\w-]+)\s*\/?><\/\1><[\w\W]+> data === "false" false
3793 <([\w-]+)\s*\/?><\/\1><[\w\W]+> data === "null" null
3794
3795 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Only convert to a number if it doesn't change the string
3796 <([\w-]+)\s*\/?><\/\1><[\w\W]+>""
3797 <([\w-]+)\s*\/?><\/\1><[\w\W]+> rbrace.test( data ) ? jQuery.parseJSON( data ) :
3798 <([\w-]+)\s*\/?><\/\1><[\w\W]+> data;
3799 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } catch
3800
3801 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Make sure we set the data so it isn't changed later
3802 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3803
3804 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } else
3805 <([\w-]+)\s*\/?><\/\1><[\w\W]+> data = undefined;
3806 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3807 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3808
3809 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3810 <([\w-]+)\s*\/?><\/\1><[\w\W]+>}
3811
3812 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// checks a cache object for emptiness
3813 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function isEmptyDataObject
3814 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
3815 <([\w-]+)\s*\/?><\/\1><[\w\W]+> for in
3816
3817 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // if the public data object is empty, the private is still empty
3818 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if "data"
3819 <([\w-]+)\s*\/?><\/\1><[\w\W]+> continue
3820 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3821 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if "toJSON"
3822 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return false
3823 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3824 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3825
3826 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return true
3827 <([\w-]+)\s*\/?><\/\1><[\w\W]+>}
3828
3829 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function internalData /* Internal Use Only */
3830 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3831 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3832 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3833
3834 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
3835 <([\w-]+)\s*\/?><\/\1><[\w\W]+> internalKey = jQuery.expando,
3836
3837 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // We have to handle DOM nodes and JS objects differently because IE6-7
3838 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// can't GC object references properly across the DOM-JS boundary
3839 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3840
3841 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Only DOM nodes need the global jQuery cache; JS object data is
3842 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// attached directly to the object so GC can occur automatically
3843 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3844
3845 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Only defining an ID for JS objects if its cache already exists allows
3846 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// the code to shortcut on the same path as a DOM node with no cache
3847 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3848
3849 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Avoid doing any more work than we need to when trying to get data on an
3850 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// object that has no data at all
3851 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3852 <([\w-]+)\s*\/?><\/\1><[\w\W]+> data === undefined && typeof name === "string"
3853 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3854 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3855
3856 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3857
3858 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Only DOM nodes need a new unique ID for each element since their data
3859 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// ends up in the global cache
3860 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3861 <([\w-]+)\s*\/?><\/\1><[\w\W]+> id = elem[ internalKey ] = deletedIds.pop() || jQuery.guid++;
3862 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } else
3863 <([\w-]+)\s*\/?><\/\1><[\w\W]+> id = internalKey;
3864 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3865 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3866
3867 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3868
3869 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Avoid exposing jQuery metadata on plain JS objects when the object
3870 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// is serialized using JSON.stringify
3871 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3872 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3873
3874 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // An object can be passed to jQuery.data instead of a key/value pair; this gets
3875 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// shallow copied over onto the existing cache
3876 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if "object" "function"
3877 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3878 <([\w-]+)\s*\/?><\/\1><[\w\W]+> cache[ id ] = jQuery.extend( cache[ id ], name );
3879 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } else
3880 <([\w-]+)\s*\/?><\/\1><[\w\W]+> cache[ id ].data = jQuery.extend( cache[ id ].data, name );
3881 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3882 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3883
3884 <([\w-]+)\s*\/?><\/\1><[\w\W]+> thisCache = cache[ id ];
3885
3886 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // jQuery data() is stored in a separate object inside the object's internal data
3887 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// cache in order to avoid key collisions between internal data and user-defined
3888 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// data.
3889 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3890 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3891 <([\w-]+)\s*\/?><\/\1><[\w\W]+> thisCache.data = {};
3892 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3893
3894 <([\w-]+)\s*\/?><\/\1><[\w\W]+> thisCache = thisCache.data;
3895 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3896
3897 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3898 <([\w-]+)\s*\/?><\/\1><[\w\W]+> thisCache[ jQuery.camelCase( name ) ] = data;
3899 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3900
3901 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Check for both converted-to-camel and non-converted data property names
3902 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// If a data property was specified
3903 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if "string"
3904
3905 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // First Try to find as-is property data
3906 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3907
3908 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Test for null|undefined property data
3909 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if null
3910
3911 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Try to find the camelCased property
3912 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3913 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3914 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } else
3915 <([\w-]+)\s*\/?><\/\1><[\w\W]+> ret = thisCache;
3916 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3917
3918 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3919 <([\w-]+)\s*\/?><\/\1><[\w\W]+>}
3920
3921 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function internalRemoveData
3922 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3923 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3924 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3925
3926 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
3927 <([\w-]+)\s*\/?><\/\1><[\w\W]+> isNode = elem.nodeType,
3928
3929 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // See jQuery.data for more information
3930 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3931 <([\w-]+)\s*\/?><\/\1><[\w\W]+> id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
3932
3933 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // If there is already no cache entry for this object, there is no
3934 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// purpose in continuing
3935 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3936 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3937 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3938
3939 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3940
3941 <([\w-]+)\s*\/?><\/\1><[\w\W]+> thisCache = pvt ? cache[ id ] : cache[ id ].data;
3942
3943 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
3944
3945 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Support array or space separated string names for data keys
3946 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3947
3948 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // try the string as a key before any manipulation
3949 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if in
3950 <([\w-]+)\s*\/?><\/\1><[\w\W]+> name = [ name ];
3951 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } else
3952
3953 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // split the camel cased version by spaces unless a key with the spaces exists
3954 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3955 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if in
3956 <([\w-]+)\s*\/?><\/\1><[\w\W]+> name = [ name ];
3957 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } else
3958 <([\w-]+)\s*\/?><\/\1><[\w\W]+> name = name.split( " "
3959 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3960 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3961 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } else
3962
3963 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // If "name" is an array of keys...
3964 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// When data is initially created, via ("key", "val") signature,
3965 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// keys will be converted to camelCase.
3966 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Since there is no way to tell _how_ a key was added, remove
3967 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// both plain key and camelCase key. #12786
3968 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// This will only penalize the array argument path.
3969 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
3970 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3971
3972 <([\w-]+)\s*\/?><\/\1><[\w\W]+> i = name.length;
3973 <([\w-]+)\s*\/?><\/\1><[\w\W]+> while
3974 <([\w-]+)\s*\/?><\/\1><[\w\W]+> delete thisCache[ name[ i ] ];
3975 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3976
3977 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // If there is no data left in the cache, we want to continue
3978 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// and let the cache object itself get destroyed
3979 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3980 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3981 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3982 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3983 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3984
3985 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // See jQuery.data for more information
3986 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3987 <([\w-]+)\s*\/?><\/\1><[\w\W]+> delete cache[ id ].data;
3988
3989 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Don't destroy the parent cache unless the internal data object
3990 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// had been the only thing left in it
3991 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3992 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
3993 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3994 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
3995
3996 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Destroy the cache
3997 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
3998 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.cleanData( [ elem ], true
3999
4000 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
4001 <([\w-]+)\s*\/?><\/\1><[\w\W]+>/* jshint eqeqeq: false */
4002 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } else if
4003 <([\w-]+)\s*\/?><\/\1><[\w\W]+> /* jshint eqeqeq: true */
4004 <([\w-]+)\s*\/?><\/\1><[\w\W]+> delete cache[ id ];
4005
4006 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // When all else fails, undefined
4007 <([\w-]+)\s*\/?><\/\1><[\w\W]+>else
4008 <([\w-]+)\s*\/?><\/\1><[\w\W]+> cache[ id ] = undefined;
4009 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4010 <([\w-]+)\s*\/?><\/\1><[\w\W]+>}
4011
4012 <([\w-]+)\s*\/?><\/\1><[\w\W]+>jQuery.extend( {
4013 <([\w-]+)\s*\/?><\/\1><[\w\W]+> cache: {},
4014
4015 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // The following elements (space-suffixed to avoid Object.prototype collisions)
4016 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// throw uncatchable exceptions if you attempt to set expando properties
4017 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
4018 <([\w-]+)\s*\/?><\/\1><[\w\W]+> "applet " true
4019 <([\w-]+)\s*\/?><\/\1><[\w\W]+> "embed " true
4020
4021 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // ...but Flash objects (which have this classid) *can* handle expandos
4022 <([\w-]+)\s*\/?><\/\1><[\w\W]+>"object " "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"
4023 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
4024
4025 <([\w-]+)\s*\/?><\/\1><[\w\W]+> hasData: function
4026 <([\w-]+)\s*\/?><\/\1><[\w\W]+> elem = elem.nodeType ? jQuery.cache[ elem[ jQuery.expando ] ] : elem[ jQuery.expando ];
4027 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
4028 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
4029
4030 <([\w-]+)\s*\/?><\/\1><[\w\W]+> data: function
4031 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
4032 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
4033
4034 <([\w-]+)\s*\/?><\/\1><[\w\W]+> removeData: function
4035 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
4036 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
4037
4038 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // For internal use only.
4039 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
4040 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return true
4041 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
4042
4043 <([\w-]+)\s*\/?><\/\1><[\w\W]+> _removeData: function
4044 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return true
4045 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4046 <([\w-]+)\s*\/?><\/\1><[\w\W]+>} );
4047
4048 <([\w-]+)\s*\/?><\/\1><[\w\W]+>jQuery.fn.extend( {
4049 <([\w-]+)\s*\/?><\/\1><[\w\W]+> data: function
4050 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
4051 <([\w-]+)\s*\/?><\/\1><[\w\W]+> elem = this
4052 <([\w-]+)\s*\/?><\/\1><[\w\W]+> attrs = elem && elem.attributes;
4053
4054 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Special expections of .data basically thwart jQuery.access,
4055 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// so implement the relevant behavior ourselves
4056
4057 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Gets all values
4058 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
4059 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if this
4060 <([\w-]+)\s*\/?><\/\1><[\w\W]+> data = jQuery.data( elem );
4061
4062 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if "parsedAttrs"
4063 <([\w-]+)\s*\/?><\/\1><[\w\W]+> i = attrs.length;
4064 <([\w-]+)\s*\/?><\/\1><[\w\W]+> while
4065
4066 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Support: IE11+
4067 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// The attrs elements can be null (#14894)
4068 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
4069 <([\w-]+)\s*\/?><\/\1><[\w\W]+> name = attrs[ i ].name;
4070 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if "data-"
4071 <([\w-]+)\s*\/?><\/\1><[\w\W]+> name = jQuery.camelCase( name.slice( 5 ) );
4072 <([\w-]+)\s*\/?><\/\1><[\w\W]+> dataAttr( elem, name, data[ name ] );
4073 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4074 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4075 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4076 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery._data( elem, "parsedAttrs" true
4077 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4078 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4079
4080 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
4081 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4082
4083 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Sets multiple values
4084 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if "object"
4085 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this function
4086 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.data( this
4087 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } );
4088 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4089
4090 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
4091
4092 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Sets one value
4093 <([\w-]+)\s*\/?><\/\1><[\w\W]+>this function
4094 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.data( this
4095 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } ) :
4096
4097 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Gets one value
4098 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Try to fetch any internally stored data first
4099 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
4100 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
4101
4102 <([\w-]+)\s*\/?><\/\1><[\w\W]+> removeData: function
4103 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this function
4104 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.removeData( this
4105 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } );
4106 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4107 <([\w-]+)\s*\/?><\/\1><[\w\W]+>} );
4108
4109
4110 <([\w-]+)\s*\/?><\/\1><[\w\W]+>jQuery.extend( {
4111 <([\w-]+)\s*\/?><\/\1><[\w\W]+> queue: function
4112 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
4113
4114 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
4115 <([\w-]+)\s*\/?><\/\1><[\w\W]+> type = ( type || "fx" "queue"
4116 <([\w-]+)\s*\/?><\/\1><[\w\W]+> queue = jQuery._data( elem, type );
4117
4118 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Speed up dequeue by getting out quickly if this is just a lookup
4119 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
4120 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
4121 <([\w-]+)\s*\/?><\/\1><[\w\W]+> queue = jQuery._data( elem, type, jQuery.makeArray( data ) );
4122 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } else
4123 <([\w-]+)\s*\/?><\/\1><[\w\W]+> queue.push( data );
4124 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4125 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4126 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
4127 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4128 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
4129
4130 <([\w-]+)\s*\/?><\/\1><[\w\W]+> dequeue: function
4131 <([\w-]+)\s*\/?><\/\1><[\w\W]+> type = type || "fx"
4132
4133 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
4134 <([\w-]+)\s*\/?><\/\1><[\w\W]+> startLength = queue.length,
4135 <([\w-]+)\s*\/?><\/\1><[\w\W]+> fn = queue.shift(),
4136 <([\w-]+)\s*\/?><\/\1><[\w\W]+> hooks = jQuery._queueHooks( elem, type ),
4137 <([\w-]+)\s*\/?><\/\1><[\w\W]+> next = function
4138 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.dequeue( elem, type );
4139 <([\w-]+)\s*\/?><\/\1><[\w\W]+> };
4140
4141 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // If the fx queue is dequeued, always remove the progress sentinel
4142 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if "inprogress"
4143 <([\w-]+)\s*\/?><\/\1><[\w\W]+> fn = queue.shift();
4144 <([\w-]+)\s*\/?><\/\1><[\w\W]+> startLength--;
4145 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4146
4147 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
4148
4149 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Add a progress sentinel to prevent the fx queue from being
4150 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// automatically dequeued
4151 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if "fx"
4152 <([\w-]+)\s*\/?><\/\1><[\w\W]+> queue.unshift( "inprogress"
4153 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4154
4155 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // clear up the last queue stop function
4156 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
4157 <([\w-]+)\s*\/?><\/\1><[\w\W]+> fn.call( elem, next, hooks );
4158 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4159
4160 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
4161 <([\w-]+)\s*\/?><\/\1><[\w\W]+> hooks.empty.fire();
4162 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4163 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
4164
4165 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // not intended for public consumption - generates a queueHooks object,
4166 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// or returns the current one
4167 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
4168 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var "queueHooks"
4169 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
4170 <([\w-]+)\s*\/?><\/\1><[\w\W]+> empty: jQuery.Callbacks( "once memory" function
4171 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery._removeData( elem, type + "queue"
4172 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery._removeData( elem, key );
4173 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } )
4174 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } );
4175 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4176 <([\w-]+)\s*\/?><\/\1><[\w\W]+>} );
4177
4178 <([\w-]+)\s*\/?><\/\1><[\w\W]+>jQuery.fn.extend( {
4179 <([\w-]+)\s*\/?><\/\1><[\w\W]+> queue: function
4180 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
4181
4182 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if "string"
4183 <([\w-]+)\s*\/?><\/\1><[\w\W]+> data = type;
4184 <([\w-]+)\s*\/?><\/\1><[\w\W]+> type = "fx"
4185 <([\w-]+)\s*\/?><\/\1><[\w\W]+> setter--;
4186 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4187
4188 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
4189 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this
4190 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4191
4192 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
4193 <([\w-]+)\s*\/?><\/\1><[\w\W]+> this
4194 <([\w-]+)\s*\/?><\/\1><[\w\W]+> this function
4195 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var this
4196
4197 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // ensure a hooks for this queue
4198 <([\w-]+)\s*\/?><\/\1><[\w\W]+>this
4199
4200 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if "fx" "inprogress"
4201 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.dequeue( this
4202 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4203 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } );
4204 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
4205 <([\w-]+)\s*\/?><\/\1><[\w\W]+> dequeue: function
4206 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this function
4207 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.dequeue( this
4208 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } );
4209 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
4210 <([\w-]+)\s*\/?><\/\1><[\w\W]+> clearQueue: function
4211 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return this "fx"
4212 <([\w-]+)\s*\/?><\/\1><[\w\W]+> },
4213
4214 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Get a promise resolved when queues of a certain type
4215 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// are emptied (fx is the type by default)
4216 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function
4217 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
4218 <([\w-]+)\s*\/?><\/\1><[\w\W]+> count = 1,
4219 <([\w-]+)\s*\/?><\/\1><[\w\W]+> defer = jQuery.Deferred(),
4220 <([\w-]+)\s*\/?><\/\1><[\w\W]+> elements = this
4221 <([\w-]+)\s*\/?><\/\1><[\w\W]+> i = this
4222 <([\w-]+)\s*\/?><\/\1><[\w\W]+> resolve = function
4223 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
4224 <([\w-]+)\s*\/?><\/\1><[\w\W]+> defer.resolveWith( elements, [ elements ] );
4225 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4226 <([\w-]+)\s*\/?><\/\1><[\w\W]+> };
4227
4228 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if "string"
4229 <([\w-]+)\s*\/?><\/\1><[\w\W]+> obj = type;
4230 <([\w-]+)\s*\/?><\/\1><[\w\W]+> type = undefined;
4231 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4232 <([\w-]+)\s*\/?><\/\1><[\w\W]+> type = type || "fx"
4233
4234 <([\w-]+)\s*\/?><\/\1><[\w\W]+> while
4235 <([\w-]+)\s*\/?><\/\1><[\w\W]+> tmp = jQuery._data( elements[ i ], type + "queueHooks"
4236 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
4237 <([\w-]+)\s*\/?><\/\1><[\w\W]+> count++;
4238 <([\w-]+)\s*\/?><\/\1><[\w\W]+> tmp.empty.add( resolve );
4239 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4240 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4241 <([\w-]+)\s*\/?><\/\1><[\w\W]+> resolve();
4242 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
4243 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4244 <([\w-]+)\s*\/?><\/\1><[\w\W]+>} );
4245
4246
4247 <([\w-]+)\s*\/?><\/\1><[\w\W]+>( function
4248 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
4249
4250 <([\w-]+)\s*\/?><\/\1><[\w\W]+> support.shrinkWrapBlocks = function
4251 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if null
4252 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
4253 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4254
4255 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Will be changed later if needed.
4256 <([\w-]+)\s*\/?><\/\1><[\w\W]+>false
4257
4258 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Minified: var b,c,d
4259 <([\w-]+)\s*\/?><\/\1><[\w\W]+>var
4260
4261 <([\w-]+)\s*\/?><\/\1><[\w\W]+> body = document.getElementsByTagName( "body"
4262 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
4263
4264 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Test fired too early or in an unsupported environment, exit.
4265 <([\w-]+)\s*\/?><\/\1><[\w\W]+>return
4266 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4267
4268 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Setup
4269 <([\w-]+)\s*\/?><\/\1><[\w\W]+>"div"
4270 <([\w-]+)\s*\/?><\/\1><[\w\W]+> container = document.createElement( "div"
4271 <([\w-]+)\s*\/?><\/\1><[\w\W]+> container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px"
4272 <([\w-]+)\s*\/?><\/\1><[\w\W]+> body.appendChild( container ).appendChild( div );
4273
4274 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Support: IE6
4275 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Check if elements with layout shrink-wrap their children
4276 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if "undefined"
4277
4278 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Reset CSS: box-sizing; display; margin; border
4279 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
4280
4281 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Support: Firefox<29, Android 2.3
4282 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Vendor-prefix box-sizing
4283 <([\w-]+)\s*\/?><\/\1><[\w\W]+>"-webkit-box-sizing:content-box;-moz-box-sizing:content-box;"
4284 <([\w-]+)\s*\/?><\/\1><[\w\W]+> "box-sizing:content-box;display:block;margin:0;border:0;"
4285 <([\w-]+)\s*\/?><\/\1><[\w\W]+> "padding:1px;width:1px;zoom:1"
4286 <([\w-]+)\s*\/?><\/\1><[\w\W]+> div.appendChild( document.createElement( "div" "5px"
4287 <([\w-]+)\s*\/?><\/\1><[\w\W]+> shrinkWrapBlocksVal = div.offsetWidth !== 3;
4288 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4289
4290 <([\w-]+)\s*\/?><\/\1><[\w\W]+> body.removeChild( container );
4291
4292 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
4293 <([\w-]+)\s*\/?><\/\1><[\w\W]+> };
4294
4295 <([\w-]+)\s*\/?><\/\1><[\w\W]+>} )();
4296 <([\w-]+)\s*\/?><\/\1><[\w\W]+>var /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/
4297
4298 <([\w-]+)\s*\/?><\/\1><[\w\W]+>var new "^(?:([+-])=|)(" ")([a-z%]*)$" "i"
4299
4300
4301 <([\w-]+)\s*\/?><\/\1><[\w\W]+>var "Top" "Right" "Bottom" "Left"
4302
4303 <([\w-]+)\s*\/?><\/\1><[\w\W]+>var function
4304
4305 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // isHidden might be called from jQuery#filter function;
4306 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// in that case, element will be second argument
4307 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
4308 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return "display" "none"
4309 <([\w-]+)\s*\/?><\/\1><[\w\W]+> !jQuery.contains( elem.ownerDocument, elem );
4310 <([\w-]+)\s*\/?><\/\1><[\w\W]+> };
4311
4312
4313
4314 <([\w-]+)\s*\/?><\/\1><[\w\W]+>function adjustCSS
4315 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
4316 <([\w-]+)\s*\/?><\/\1><[\w\W]+> scale = 1,
4317 <([\w-]+)\s*\/?><\/\1><[\w\W]+> maxIterations = 20,
4318 <([\w-]+)\s*\/?><\/\1><[\w\W]+> currentValue = tween ?
4319 <([\w-]+)\s*\/?><\/\1><[\w\W]+> function return
4320 <([\w-]+)\s*\/?><\/\1><[\w\W]+> function return ""
4321 <([\w-]+)\s*\/?><\/\1><[\w\W]+> initial = currentValue(),
4322 <([\w-]+)\s*\/?><\/\1><[\w\W]+> unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" "px"
4323
4324 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Starting value computation is required for potential unit mismatches
4325 <([\w-]+)\s*\/?><\/\1><[\w\W]+>"px"
4326 <([\w-]+)\s*\/?><\/\1><[\w\W]+> rcssNum.exec( jQuery.css( elem, prop ) );
4327
4328 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
4329
4330 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Trust units reported by jQuery.css
4331 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
4332
4333 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Make sure we update the tween properties later on
4334 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
4335
4336 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Iteratively approximate from a nonzero starting point
4337 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
4338
4339 <([\w-]+)\s*\/?><\/\1><[\w\W]+> do
4340
4341 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // If previous iteration zeroed out, double until we get *something*.
4342 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Use string for doubling so we don't accidentally see scale as unchanged below
4343 <([\w-]+)\s*\/?><\/\1><[\w\W]+>".5"
4344
4345 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Adjust and apply
4346 <([\w-]+)\s*\/?><\/\1><[\w\W]+>/ scale;
4347 <([\w-]+)\s*\/?><\/\1><[\w\W]+> jQuery.style( elem, prop, initialInUnit + unit );
4348
4349 <([\w-]+)\s*\/?><\/\1><[\w\W]+> / / Update scale, tolerating zero or NaN from tween.cur()
4350 <([\w-]+)\s*\/?><\/\1><[\w\W]+> / / Break the loop if scale is unchanged or perfect, or if we've just had enough.
4351 <([\w-]+)\s*\/?><\/\1><[\w\W]+> } while (
4352 <([\w-]+)\s*\/?><\/\1><[\w\W]+> scale !== ( scale = currentValue() /
4353 <([\w-]+)\s*\/?><\/\1><[\w\W]+> );
4354 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4355
4356 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
4357 <([\w-]+)\s*\/?><\/\1><[\w\W]+> initialInUnit = +initialInUnit || +initial || 0;
4358
4359 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Apply relative offset (+=/-=) if specified
4360 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
4361 <([\w-]+)\s*\/?><\/\1><[\w\W]+> initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
4362 <([\w-]+)\s*\/?><\/\1><[\w\W]+> +valueParts[ 2 ];
4363 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
4364 <([\w-]+)\s*\/?><\/\1><[\w\W]+> tween.unit = unit;
4365 <([\w-]+)\s*\/?><\/\1><[\w\W]+> tween.start = initialInUnit;
4366 <([\w-]+)\s*\/?><\/\1><[\w\W]+> tween.end = adjusted;
4367 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4368 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4369 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
4370 <([\w-]+)\s*\/?><\/\1><[\w\W]+>}
4371
4372
4373 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// Multifunctional method to get and set values of a collection
4374 <([\w-]+)\s*\/?><\/\1><[\w\W]+>// The value/s can optionally be executed if it's a function
4375 <([\w-]+)\s*\/?><\/\1><[\w\W]+>var function
4376 <([\w-]+)\s*\/?><\/\1><[\w\W]+> var
4377 <([\w-]+)\s*\/?><\/\1><[\w\W]+> length = elems.length,
4378 <([\w-]+)\s*\/?><\/\1><[\w\W]+> bulk = key == null
4379
4380 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Sets many values
4381 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if "object"
4382 <([\w-]+)\s*\/?><\/\1><[\w\W]+> chainable = true
4383 <([\w-]+)\s*\/?><\/\1><[\w\W]+> for in
4384 <([\w-]+)\s*\/?><\/\1><[\w\W]+> access( elems, fn, i, key[ i ], true
4385 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4386
4387 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Sets one value
4388 <([\w-]+)\s*\/?><\/\1><[\w\W]+>else if
4389 <([\w-]+)\s*\/?><\/\1><[\w\W]+> chainable = true
4390
4391 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
4392 <([\w-]+)\s*\/?><\/\1><[\w\W]+> raw = true
4393 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4394
4395 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
4396
4397 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Bulk operations run against the entire set
4398 <([\w-]+)\s*\/?><\/\1><[\w\W]+>if
4399 <([\w-]+)\s*\/?><\/\1><[\w\W]+> fn.call( elems, value );
4400 <([\w-]+)\s*\/?><\/\1><[\w\W]+> fn = null
4401
4402 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // ...except when executing function values
4403 <([\w-]+)\s*\/?><\/\1><[\w\W]+>else
4404 <([\w-]+)\s*\/?><\/\1><[\w\W]+> bulk = fn;
4405 <([\w-]+)\s*\/?><\/\1><[\w\W]+> fn = function
4406 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
4407 <([\w-]+)\s*\/?><\/\1><[\w\W]+> };
4408 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4409 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4410
4411 <([\w-]+)\s*\/?><\/\1><[\w\W]+> if
4412 <([\w-]+)\s*\/?><\/\1><[\w\W]+> for
4413 <([\w-]+)\s*\/?><\/\1><[\w\W]+> fn(
4414 <([\w-]+)\s*\/?><\/\1><[\w\W]+> elems[ i ],
4415 <([\w-]+)\s*\/?><\/\1><[\w\W]+> key,
4416 <([\w-]+)\s*\/?><\/\1><[\w\W]+> raw ? value : value.call( elems[ i ], i, fn( elems[ i ], key ) )
4417 <([\w-]+)\s*\/?><\/\1><[\w\W]+> );
4418 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4419 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4420 <([\w-]+)\s*\/?><\/\1><[\w\W]+> }
4421
4422 <([\w-]+)\s*\/?><\/\1><[\w\W]+> return
4423 <([\w-]+)\s*\/?><\/\1><[\w\W]+> elems :
4424
4425 <([\w-]+)\s*\/?><\/\1><[\w\W]+> // Gets
4426 <([\w-]+)\s*\/?><\/\1><[\w\W]+>
4427 <([\w-]+)\s*\/?><\/\1><[\w\W]+> fn.call( elems ) :
4428 <([\w-]+)\s*\/?><\/\1><[\w\W]+> length ? fn( elems[ 0 ], key ) : emptyGet;
4429 <([\w-]+)\s*\/?><\/\1><[\w\W]+>};
4430 <([\w-]+)\s*\/?><\/\1><[\w\W]+>var /^(?:checkbox|radio)$/
4431
4432 <([\w-]+)\s*\/?><\/\1><[\w\W]+>var /<([\w:-]+)/
4433
4434 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/var /^$|\/(?:java|ecma)script/
4435
4436 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/var /^\s+/
4437
4438 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/var "abbr|article|aside|audio|bdi|canvas|data|datalist|"
4439 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ "details|dialog|figcaption|figure|footer|header|hgroup|main|"
4440 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ "mark|meter|nav|output|picture|progress|section|summary|template|time|video"
4441
4442
4443
4444 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/function createSafeFragment
4445 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ var "|"
4446 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ safeFrag = document.createDocumentFragment();
4447
4448 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ if
4449 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ while
4450 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ safeFrag.createElement(
4451 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ list.pop()
4452 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ );
4453 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ }
4454 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ }
4455 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ return
4456 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/}
4457
4458
4459 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/( function
4460 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ var "div"
4461 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ fragment = document.createDocumentFragment(),
4462 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ input = document.createElement( "input"
4463
4464 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ // Setup
4465 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/" <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"
4466
4467 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ // IE strips leading whitespace when .innerHTML is used
4468 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/
4469
4470 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ // Make sure that tbody elements aren't automatically inserted
4471 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// IE will insert them into empty tables
4472 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/"tbody"
4473
4474 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ // Make sure that link elements get serialized correctly by innerHTML
4475 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// This requires a wrapper element in IE
4476 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/"link"
4477
4478 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ // Makes sure cloning an html5 element does not cause problems
4479 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// Where outerHTML is undefined, this still works
4480 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/
4481 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ document.createElement( "nav" true "<:nav></:nav>"
4482
4483 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ // Check if a disconnected checkbox will retain its checked
4484 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// value of true after appended to the DOM (IE6/7)
4485 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/"checkbox"
4486 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ input.checked = true
4487 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ fragment.appendChild( input );
4488 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ support.appendChecked = input.checked;
4489
4490 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ // Make sure textarea (and checkbox) defaultValue is properly cloned
4491 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// Support: IE6-IE11+
4492 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/"<textarea>x</textarea>"
4493 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ support.noCloneChecked = !!div.cloneNode( true
4494
4495 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ // Support: IE <=9 only
4496 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// IE <=9 replaces <option> tags with their contents when inserted outside of
4497 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// the select element.
4498 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/"<option></option>"
4499 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ support.option = !!div.lastChild;
4500
4501 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ // #11217 - WebKit loses check when the name is after the checked attribute
4502 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/
4503
4504 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ // Support: Windows Web Apps (WWA)
4505 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// `name` and `type` must use .setAttribute for WWA (#14901)
4506 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/"input"
4507 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ input.setAttribute( "type" "radio"
4508 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ input.setAttribute( "checked" "checked"
4509 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ input.setAttribute( "name" "t"
4510
4511 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ div.appendChild( input );
4512
4513 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ // Support: Safari 5.1, iOS 5.1, Android 4.x, Android 2.3
4514 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// old WebKit doesn't clone checked state correctly in fragments
4515 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/true true
4516
4517 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ // Support: IE<9
4518 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// Cloned elements keep attachEvent handlers, we use addEventListener on IE9+
4519 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/
4520
4521 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ // Support: IE<9
4522 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// Since attributes and properties are the same in IE,
4523 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// cleanData must set properties to undefined rather than use removeAttribute
4524 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/
4525 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ support.attributes = !div.getAttribute( jQuery.expando );
4526 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/} )();
4527
4528
4529 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// We have to close these tags to support XHTML (#13200)
4530 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/var
4531 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// option: [ 1, "<select multiple='multiple'>", "</select>" ],
4532 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/"<fieldset>" "</fieldset>"
4533 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ area: [ 1, "<map>" "</map>"
4534
4535 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ // Support: IE8
4536 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/"<object>" "</object>"
4537 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ thead: [ 1, "<table>" "</table>"
4538 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ tr: [ 2, "<table><tbody>" "</tbody></table>"
4539 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ col: [ 2, "<table><tbody></tbody><colgroup>" "</colgroup></table>"
4540 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ td: [ 3, "<table><tbody><tr>" "</tr></tbody></table>"
4541
4542 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ // IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
4543 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// unless wrapped in a div with non-breaking characters in front of it.
4544 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/"" "" "X<div>" "</div>"
4545 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/};
4546
4547 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// Support: IE8-IE9
4548 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)///wrapMap.optgroup = wrapMap.option;
4549
4550 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
4551 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/wrapMap.th = wrapMap.td;
4552
4553 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// Support: IE <=9 only
4554 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/if
4555 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ wrapMap.optgroup = wrapMap.option = [ 1, "<select multiple='multiple'>" "</select>"
4556 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/}
4557
4558 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/function getAll
4559 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ var
4560 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ i = 0,
4561 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ found = typeof context.getElementsByTagName !== "undefined"
4562 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ context.getElementsByTagName( tag || "*"
4563 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ typeof context.querySelectorAll !== "undefined"
4564 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ context.querySelectorAll( tag || "*"
4565 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ undefined;
4566
4567 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ if
4568 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ for
4569 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ ( elem = elems[ i ] ) != null
4570 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ i++
4571 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ ) {
4572 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ if
4573 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ found.push( elem );
4574 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ } else
4575 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ jQuery.merge( found, getAll( elem, tag ) );
4576 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ }
4577 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ }
4578 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ }
4579
4580 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ return
4581 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ jQuery.merge( [ context ], found ) :
4582 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ found;
4583 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/}
4584
4585
4586 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/// Mark scripts as having already been evaluated
4587 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/function setGlobalEval
4588 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ var
4589 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ i = 0;
4590 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ for null
4591 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ jQuery._data(
4592 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ elem,
4593 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ "globalEval"
4594 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ !refElements || jQuery._data( refElements[ i ], "globalEval"
4595 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ );
4596 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/ }
4597 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/}
4598
4599
4600 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/var /<|&#?\w+;/
4601 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ rtbody = /i;
4602
4603 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function fixDefaultChecked
4604 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
4605 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ elem.defaultChecked = elem.checked;
4606 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4607 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/}
4608
4609 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function buildFragment
4610 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var
4611 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ tmp, tag, tbody, wrap,
4612 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ l = elems.length,
4613
4614 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Ensure a safe fragment
4615 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
4616
4617 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ nodes = [],
4618 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ i = 0;
4619
4620 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ for
4621 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ elem = elems[ i ];
4622
4623 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
4624
4625 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Add nodes directly
4626 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "object"
4627 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
4628
4629 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Convert non-html into a text node
4630 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if
4631 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ nodes.push( context.createTextNode( elem ) );
4632
4633 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Convert html into DOM nodes
4634 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
4635 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ tmp = tmp || safe.appendChild( context.createElement( "div"
4636
4637 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Deserialize a standard representation
4638 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"" ""
4639 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ wrap = wrapMap[ tag ] || wrapMap._default;
4640
4641 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
4642
4643 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Descend through wrappers to the right content
4644 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
4645 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ while
4646 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ tmp = tmp.lastChild;
4647 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4648
4649 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Manually add leading whitespace removed by IE
4650 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
4651 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ nodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[ 0 ] ) );
4652 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4653
4654 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Remove IE's autoinserted <tbody> from table fragments
4655 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
4656
4657 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // String was a <table>, *may* have spurious <tbody>
4658 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"table"
4659 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ tmp.firstChild :
4660
4661 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // String was a bare <thead> or <tfoot>
4662 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"<table>"
4663 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ tmp :
4664 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ 0;
4665
4666 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ j = elem && elem.childNodes.length;
4667 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ while
4668 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if "tbody"
4669 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ !tbody.childNodes.length ) {
4670
4671 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ elem.removeChild( tbody );
4672 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4673 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4674 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4675
4676 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.merge( nodes, tmp.childNodes );
4677
4678 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Fix #12392 for WebKit and IE > 9
4679 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
4680
4681 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Fix #12392 for oldIE
4682 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while
4683 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ tmp.removeChild( tmp.firstChild );
4684 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4685
4686 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Remember the top-level container for proper cleanup
4687 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
4688 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4689 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4690 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4691
4692 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Fix #11356: Clear elements from fragment
4693 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
4694 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ safe.removeChild( tmp );
4695 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4696
4697 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Reset defaultChecked for any radios and checkboxes
4698 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// about to be appended to the DOM in IE 6/7 (#8060)
4699 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
4700 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.grep( getAll( nodes, "input"
4701 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4702
4703 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ i = 0;
4704 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ while
4705
4706 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Skip elements already in the context collection (trac-4087)
4707 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
4708 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
4709 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ignored.push( elem );
4710 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4711
4712 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ continue
4713 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4714
4715 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ contains = jQuery.contains( elem.ownerDocument, elem );
4716
4717 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Append to fragment
4718 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"script"
4719
4720 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Preserve script evaluation history
4721 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
4722 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ setGlobalEval( tmp );
4723 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4724
4725 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Capture executables
4726 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
4727 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ j = 0;
4728 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ while
4729 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ""
4730 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ scripts.push( elem );
4731 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4732 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4733 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4734 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4735
4736 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ tmp = null
4737
4738 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
4739 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/}
4740
4741
4742 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/( function
4743 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var
4744 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ div = document.createElement( "div"
4745
4746 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Support: IE<9 (lack submit/change bubble), Firefox (lack focus(in | out) events)
4747 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in true true true
4748 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ eventName = "on"
4749
4750 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if in
4751
4752 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP)
4753 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"t"
4754 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ support[ i ] = div.attributes[ eventName ].expando === false
4755 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4756 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4757
4758 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Null elements to avoid leaks in IE.
4759 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
4760 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/} )();
4761
4762
4763 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var /^(?:input|select|textarea)$/
4764 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ rkeyEvent = /^key/
4765 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/
4766 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ rfocusMorph = /^(?:focusinfocus|focusoutblur)$/
4767 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ rtypenamespace = /^([^.]*)(?:\.(.+)|)/
4768
4769 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function returnTrue
4770 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return true
4771 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/}
4772
4773 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function returnFalse
4774 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return false
4775 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/}
4776
4777 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE9
4778 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// See #13393 for more info
4779 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function safeActiveElement
4780 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ try
4781 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
4782 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } catch
4783 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/}
4784
4785 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function on
4786 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var
4787
4788 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Types can be a map of types/handlers
4789 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "object"
4790
4791 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // ( types-Object, selector, data )
4792 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "string"
4793
4794 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // ( types-Object, data )
4795 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
4796 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ selector = undefined;
4797 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4798 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ for in
4799 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ on( elem, type, selector, data, types[ type ], one );
4800 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4801 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
4802 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4803
4804 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if null null
4805
4806 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // ( types, fn )
4807 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
4808 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ data = selector = undefined;
4809 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } else if null
4810 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if "string"
4811
4812 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // ( types, selector, fn )
4813 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
4814 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ data = undefined;
4815 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } else
4816
4817 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // ( types, data, fn )
4818 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
4819 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ data = selector;
4820 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ selector = undefined;
4821 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4822 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4823 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if false
4824 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ fn = returnFalse;
4825 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } else if
4826 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
4827 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4828
4829 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
4830 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ origFn = fn;
4831 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ fn = function
4832
4833 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Can use an empty set, since event contains the info
4834 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
4835 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return this
4836 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ };
4837
4838 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Use same guid so caller can remove using origFn
4839 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
4840 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4841 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return function
4842 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.add( this
4843 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } );
4844 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/}
4845
4846 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//*
4847 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * Helper functions for managing events -- not part of the public interface.
4848 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * Props to Dean Edwards' addEvent library for many of the ideas.
4849 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ */
4850 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/jQuery.event = {
4851
4852 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ global: {},
4853
4854 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ add: function
4855 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var
4856 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ special, eventHandle, handleObj,
4857 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handlers, type, namespaces, origType,
4858 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ elemData = jQuery._data( elem );
4859
4860 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Don't attach events to noData or text/comment nodes (but allow plain objects)
4861 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
4862 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
4863 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4864
4865 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Caller can pass in an object of custom data in lieu of the handler
4866 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
4867 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handleObjIn = handler;
4868 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handler = handleObjIn.handler;
4869 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ selector = handleObjIn.selector;
4870 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4871
4872 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Make sure that the handler has a unique ID, used to find/remove it later
4873 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
4874 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handler.guid = jQuery.guid++;
4875 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4876
4877 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Init the element's event structure and main handler, if this is the first
4878 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
4879 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ events = elemData.events = {};
4880 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4881 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
4882 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ eventHandle = elemData.handle = function
4883
4884 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Discard the second event of a jQuery.event.trigger() and
4885 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// when an event is called after a page has unloaded
4886 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "undefined"
4887 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ( !e || jQuery.event.triggered !== e.type ) ?
4888 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
4889 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ undefined;
4890 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ };
4891
4892 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Add elem as a property of the handle fn to prevent a memory leak
4893 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// with IE non-native events
4894 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
4895 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4896
4897 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Handle multiple events separated by a space
4898 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"" ""
4899 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ t = types.length;
4900 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ while
4901 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ tmp = rtypenamespace.exec( types[ t ] ) || [];
4902 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ type = origType = tmp[ 1 ];
4903 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ namespaces = ( tmp[ 2 ] || "" "."
4904
4905 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // There *must* be a type, no attaching namespace-only handlers
4906 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
4907 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ continue
4908 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4909
4910 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // If event changes its type, use the special event handlers for the changed type
4911 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
4912
4913 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // If selector defined, determine special event api type, otherwise given type
4914 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
4915
4916 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Update special based on newly reset type
4917 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
4918
4919 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // handleObj is passed to all event handlers
4920 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
4921 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ type: type,
4922 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ origType: origType,
4923 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ data: data,
4924 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handler: handler,
4925 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ guid: handler.guid,
4926 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ selector: selector,
4927 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
4928 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ namespace: namespaces.join( "."
4929 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }, handleObjIn );
4930
4931 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Init the event handler queue if we're the first
4932 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
4933 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handlers = events[ type ] = [];
4934 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handlers.delegateCount = 0;
4935
4936 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Only use addEventListener/attachEvent if the special events handler returns false
4937 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
4938 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ special.setup.call( elem, data, namespaces, eventHandle ) === false
4939
4940 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Bind the global event handler to the element
4941 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
4942 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ elem.addEventListener( type, eventHandle, false
4943
4944 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } else if
4945 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ elem.attachEvent( "on"
4946 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4947 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4948 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4949
4950 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
4951 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ special.add.call( elem, handleObj );
4952
4953 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
4954 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handleObj.handler.guid = handler.guid;
4955 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4956 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4957
4958 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Add to the element's handler list, delegates in front
4959 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
4960 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handlers.splice( handlers.delegateCount++, 0, handleObj );
4961 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } else
4962 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handlers.push( handleObj );
4963 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4964
4965 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Keep track of which events have ever been used, for event optimization
4966 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
4967 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4968
4969 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Nullify elem to prevent memory leaks in IE
4970 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
4971 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
4972
4973 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Detach an event or set of events from an element
4974 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
4975 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var
4976 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ origCount, t, events,
4977 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ special, handlers, type,
4978 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ namespaces, origType,
4979 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ elemData = jQuery.hasData( elem ) && jQuery._data( elem );
4980
4981 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
4982 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
4983 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4984
4985 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Once for each type.namespace in types; type may be omitted
4986 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"" ""
4987 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ t = types.length;
4988 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ while
4989 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ tmp = rtypenamespace.exec( types[ t ] ) || [];
4990 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ type = origType = tmp[ 1 ];
4991 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ namespaces = ( tmp[ 2 ] || "" "."
4992
4993 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Unbind all events (on this namespace, if provided) for the element
4994 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
4995 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ for in
4996 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.remove( elem, type + types[ t ], handler, selector, true
4997 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
4998 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ continue
4999 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5000
5001 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ special = jQuery.event.special[ type ] || {};
5002 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ type = ( selector ? special.delegateType : special.bindType ) || type;
5003 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handlers = events[ type ] || [];
5004 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ tmp = tmp[ 2 ] &&
5005 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ new "(^|\\.)" "\\.(?:.*\\.|)" "(\\.|$)"
5006
5007 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Remove matching events
5008 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5009 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ while
5010 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handleObj = handlers[ j ];
5011
5012 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5013 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ( !handler || handler.guid === handleObj.guid ) &&
5014 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ( !tmp || tmp.test( handleObj.namespace ) ) &&
5015 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ( !selector || selector === handleObj.selector ||
5016 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ selector === "**"
5017 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handlers.splice( j, 1 );
5018
5019 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5020 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handlers.delegateCount--;
5021 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5022 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5023 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ special.remove.call( elem, handleObj );
5024 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5025 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5026 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5027
5028 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Remove generic event handler if we removed something and no more handlers exist
5029 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// (avoids potential for endless recursion during removal of special event handlers)
5030 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5031 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5032 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ special.teardown.call( elem, namespaces, elemData.handle ) === false
5033
5034 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.removeEvent( elem, type, elemData.handle );
5035 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5036
5037 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ delete events[ type ];
5038 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5039 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5040
5041 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Remove the expando if it's no longer used
5042 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5043 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ delete elemData.handle;
5044
5045 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // removeData also checks for emptiness and clears the expando if empty
5046 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// so use it instead of delete
5047 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"events"
5048 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5049 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5050
5051 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ trigger: function
5052 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var
5053 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ bubbleType, special, tmp, i,
5054 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ eventPath = [ elem || document ],
5055 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ type = hasOwn.call( event, "type"
5056 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ namespaces = hasOwn.call( event, "namespace" "."
5057
5058 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ cur = tmp = elem = elem || document;
5059
5060 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Don't do events on text and comment nodes
5061 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5062 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
5063 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5064
5065 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // focus/blur morphs to focusin/out; ensure we're not firing them right now
5066 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5067 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
5068 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5069
5070 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if "."
5071
5072 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Namespaced trigger; create a regexp to match event type in handle()
5073 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"."
5074 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ type = namespaces.shift();
5075 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ namespaces.sort();
5076 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5077 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ontype = type.indexOf( ":" "on"
5078
5079 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Caller can pass in a jQuery.Event object, Object, or just an event type string
5080 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5081 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event :
5082 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ new "object"
5083
5084 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
5085 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5086 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.namespace = namespaces.join( "."
5087 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.rnamespace = event.namespace ?
5088 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ new "(^|\\.)" "\\.(?:.*\\.|)" "(\\.|$)"
5089 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ null
5090
5091 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Clean up the event in case it is being reused
5092 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5093 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5094 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.target = elem;
5095 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5096
5097 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Clone any incoming data and prepend the event, creating the handler arg list
5098 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
5099 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ [ event ] :
5100 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.makeArray( data, [ event ] );
5101
5102 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Allow special events to draw outside the lines
5103 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5104 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if false
5105 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
5106 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5107
5108 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Determine event propagation path in advance, per W3C events spec (#9951)
5109 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
5110 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5111
5112 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ bubbleType = special.delegateType || type;
5113 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5114 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ cur = cur.parentNode;
5115 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5116 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ for
5117 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ eventPath.push( cur );
5118 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ tmp = cur;
5119 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5120
5121 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Only add window if we got to document (e.g., not plain obj or detached DOM)
5122 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5123 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ eventPath.push( tmp.defaultView || tmp.parentWindow || window );
5124 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5125 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5126
5127 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Fire handlers on the event path
5128 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5129 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ while
5130
5131 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.type = i > 1 ?
5132 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ bubbleType :
5133 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ special.bindType || type;
5134
5135 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // jQuery handler
5136 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"events"
5137 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery._data( cur, "handle"
5138
5139 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5140 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handle.apply( cur, data );
5141 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5142
5143 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Native handler
5144 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5145 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5146 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.result = handle.apply( cur, data );
5147 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if false
5148 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.preventDefault();
5149 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5150 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5151 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5152 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.type = type;
5153
5154 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // If nobody prevented the default action, do it now
5155 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5156
5157 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5158 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ( !special._default ||
5159 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ special._default.apply( eventPath.pop(), data ) === false
5160 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ) && acceptData( elem )
5161 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ) {
5162
5163 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Call a native DOM method on the target with the same name name as the event.
5164 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Can't use an .isFunction() check here because IE6/7 fails that test.
5165 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Don't do default actions on window, that's where global variables be (#6170)
5166 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5167
5168 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Don't re-trigger an onFOO event when we call its FOO() method
5169 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5170
5171 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5172 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ elem[ ontype ] = null
5173 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5174
5175 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Prevent re-triggering of the same event, since we already bubbled it above
5176 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5177 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ try
5178 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ elem[ type ]();
5179 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } catch
5180
5181 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // IE<9 dies on focus/blur to hidden element (#1486,#12518)
5182 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// only reproducible on winXP IE8 native, not IE9 in IE8 mode
5183 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5184 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.triggered = undefined;
5185
5186 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5187 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ elem[ ontype ] = tmp;
5188 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5189 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5190 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5191 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5192
5193 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
5194 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5195
5196 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ dispatch: function
5197
5198 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Make a writable jQuery.Event from the native event object
5199 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5200
5201 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var
5202 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handlerQueue = [],
5203 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ args = slice.call( arguments ),
5204 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handlers = ( jQuery._data( this "events"
5205 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ special = jQuery.event.special[ event.type ] || {};
5206
5207 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Use the fix-ed jQuery.Event rather than the (read-only) native event
5208 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5209 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.delegateTarget = this
5210
5211 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Call the preDispatch hook for the mapped type, and let it bail if desired
5212 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this false
5213 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
5214 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5215
5216 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Determine handlers
5217 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
5218
5219 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Run delegates first; they may want to stop propagation beneath us
5220 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5221 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ while
5222 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.currentTarget = matched.elem;
5223
5224 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ j = 0;
5225 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ while
5226 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ !event.isImmediatePropagationStopped() ) {
5227
5228 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Triggered event must either 1) have no namespace, or 2) have namespace(s)
5229 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// a subset or equal to those in the bound event (both can have no namespace).
5230 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5231
5232 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.handleObj = handleObj;
5233 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.data = handleObj.data;
5234
5235 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
5236 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handleObj.handler ).apply( matched.elem, args );
5237
5238 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5239 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if false
5240 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.preventDefault();
5241 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.stopPropagation();
5242 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5243 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5244 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5245 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5246 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5247
5248 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Call the postDispatch hook for the mapped type
5249 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5250 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ special.postDispatch.call( this
5251 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5252
5253 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
5254 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5255
5256 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handlers: function
5257 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var
5258 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handlerQueue = [],
5259 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ delegateCount = handlers.delegateCount,
5260 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ cur = event.target;
5261
5262 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Support (at least): Chrome, IE9
5263 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Find delegate handlers
5264 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Black-hole SVG <use> instance trees (#13180)
5265 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;///
5266 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Firefox<=42+
5267 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Avoid non-left-click in FF but don't block IE radio events (#3861, gh-2343)
5268 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5269 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ( event.type !== "click"
5270
5271 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ /* jshint eqeqeq: false */
5272 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ for this this
5273 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ /* jshint eqeqeq: true */
5274
5275 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Don't check non-elements (#13208)
5276 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
5277 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if true "click"
5278 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ matches = [];
5279 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ for
5280 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handleObj = handlers[ i ];
5281
5282 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Don't conflict with Object.prototype properties (#13203)
5283 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/" "
5284
5285 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5286 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ matches[ sel ] = handleObj.needsContext ?
5287 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery( sel, this
5288 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.find( sel, this null
5289 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5290 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5291 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ matches.push( handleObj );
5292 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5293 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5294 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5295 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handlerQueue.push( { elem: cur, handlers: matches } );
5296 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5297 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5298 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5299 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5300
5301 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Add the remaining (directly-bound) handlers
5302 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5303 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handlerQueue.push( { elem: this
5304 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5305
5306 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
5307 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5308
5309 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ fix: function
5310 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5311 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
5312 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5313
5314 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Create a writable copy of the event object and normalize some properties
5315 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
5316 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ type = event.type,
5317 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ originalEvent = event,
5318 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ fixHook = this
5319
5320 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5321 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this
5322 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ rmouseEvent.test( type ) ? this
5323 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ rkeyEvent.test( type ) ? this
5324 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ {};
5325 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5326 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ copy = fixHook.props ? this this
5327
5328 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event = new
5329
5330 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ i = copy.length;
5331 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ while
5332 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ prop = copy[ i ];
5333 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event[ prop ] = originalEvent[ prop ];
5334 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5335
5336 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Support: IE<9
5337 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Fix target property (#1925)
5338 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5339 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.target = originalEvent.srcElement || document;
5340 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5341
5342 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Support: Safari 6-8+
5343 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Target should not be a text node (#504, #13143)
5344 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5345 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.target = event.target.parentNode;
5346 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5347
5348 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Support: IE<9
5349 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// For mouse/key events, metaKey==false if it's undefined (#3368, #11328)
5350 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5351
5352 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
5353 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5354
5355 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Includes some event props shared by KeyEvent and MouseEvent
5356 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"altKey bubbles cancelable ctrlKey currentTarget detail eventPhase "
5357 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ "metaKey relatedTarget shiftKey target timeStamp view which" " "
5358
5359 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ fixHooks: {},
5360
5361 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ keyHooks: {
5362 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ props: "char charCode key keyCode" " "
5363 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ filter: function
5364
5365 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Add which for key events
5366 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if null
5367 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.which = original.charCode != null
5368 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5369
5370 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
5371 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5372 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5373
5374 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ mouseHooks: {
5375 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ props: ( "button buttons clientX clientY fromElement offsetX offsetY "
5376 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ "pageX pageY screenX screenY toElement" " "
5377 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ filter: function
5378 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var
5379 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ button = original.button,
5380 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ fromElement = original.fromElement;
5381
5382 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Calculate pageX/Y if missing and clientX/Y available
5383 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if null null
5384 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ eventDoc = event.target.ownerDocument || document;
5385 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ doc = eventDoc.documentElement;
5386 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ body = eventDoc.body;
5387
5388 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.pageX = original.clientX +
5389 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) -
5390 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ( doc && doc.clientLeft || body && body.clientLeft || 0 );
5391 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.pageY = original.clientY +
5392 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ( doc && doc.scrollTop || body && body.scrollTop || 0 ) -
5393 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ( doc && doc.clientTop || body && body.clientTop || 0 );
5394 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5395
5396 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Add relatedTarget, if necessary
5397 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5398 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.relatedTarget = fromElement === event.target ?
5399 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ original.toElement :
5400 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ fromElement;
5401 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5402
5403 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Add which for click: 1 === left; 2 === middle; 3 === right
5404 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Note: button is not normalized, so don't use it
5405 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5406 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
5407 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5408
5409 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
5410 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5411 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5412
5413 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ special: {
5414 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ load: {
5415
5416 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Prevent triggered image.load events from bubbling to window.load
5417 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
5418 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5419 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ focus: {
5420
5421 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Fire native event if possible so blur/focus sequence is correct
5422 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
5423 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if this this
5424 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ try
5425 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this
5426 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return false
5427 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } catch
5428
5429 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Support: IE<9
5430 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If we error on focus to hidden element (#1486, #12518),
5431 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// let .trigger() run the handlers
5432 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5433 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5434 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5435 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ delegateType: "focusin"
5436 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5437 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ blur: {
5438 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ trigger: function
5439 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if this this
5440 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this
5441 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return false
5442 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5443 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5444 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ delegateType: "focusout"
5445 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5446 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ click: {
5447
5448 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // For checkbox, fire native event so checked state will be right
5449 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
5450 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if this "input" this "checkbox" this
5451 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this
5452 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return false
5453 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5454 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5455
5456 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // For cross-browser consistency, don't fire native .click() on links
5457 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
5458 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return "a"
5459 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5460 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5461
5462 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ beforeunload: {
5463 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ postDispatch: function
5464
5465 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Support: Firefox 20+
5466 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Firefox doesn't alert if the returnValue field is not set.
5467 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5468 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.originalEvent.returnValue = event.result;
5469 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5470 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5471 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5472 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5473
5474 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Piggyback on a donor event to simulate a different one
5475 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
5476 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var
5477 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ new
5478 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event,
5479 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ {
5480 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ type: type,
5481 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ isSimulated: true
5482
5483 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Previously, `originalEvent: {}` was set here, so stopPropagation call
5484 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// would not be triggered on donor event, since in our own
5485 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// jQuery.event.stopPropagation function we had a check for existence of
5486 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// originalEvent.stopPropagation method, so, consequently it would be a noop.
5487 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;///
5488 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Guard for simulated events was moved to jQuery.event.stopPropagation function
5489 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// since `originalEvent` should point to the original event for the
5490 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// constancy with other events and for more focused logic
5491 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5492 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ );
5493
5494 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.trigger( e, null
5495
5496 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5497 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.preventDefault();
5498 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5499 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5500 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/};
5501
5502 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/jQuery.removeEvent = document.removeEventListener ?
5503 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ function
5504
5505 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // This "if" is needed for plain objects
5506 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5507 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ elem.removeEventListener( type, handle, false
5508 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5509 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } :
5510 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ function
5511 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var "on"
5512
5513 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5514
5515 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // #8545, #7054, preventing memory leaks for custom events in IE6-8
5516 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// detachEvent needed property on element, by name of that event,
5517 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// to properly expose it to GC
5518 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "undefined"
5519 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ elem[ name ] = null
5520 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5521
5522 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ elem.detachEvent( name, handle );
5523 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5524 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ };
5525
5526 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/jQuery.Event = function
5527
5528 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Allow instantiation without the 'new' keyword
5529 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this instanceof
5530 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return new
5531 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5532
5533 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Event object
5534 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5535 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this
5536 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this
5537
5538 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Events bubbling up the document may have been marked as prevented
5539 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// by a handler lower down the tree; reflect the correct value.
5540 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
5541 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ src.defaultPrevented === undefined &&
5542
5543 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Support: IE < 9, Android < 4.0
5544 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
5545 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ returnTrue :
5546 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ returnFalse;
5547
5548 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Event type
5549 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
5550 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this
5551 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5552
5553 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Put explicitly provided properties onto the event object
5554 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5555 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.extend( this
5556 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5557
5558 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Create a timestamp if incoming event doesn't have one
5559 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
5560
5561 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Mark it as fixed
5562 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this true
5563 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/};
5564
5565 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
5566 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
5567 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5568 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ constructor: jQuery.Event,
5569 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ isDefaultPrevented: returnFalse,
5570 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ isPropagationStopped: returnFalse,
5571 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ isImmediatePropagationStopped: returnFalse,
5572
5573 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ preventDefault: function
5574 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var this
5575
5576 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this
5577 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5578 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
5579 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5580
5581 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // If preventDefault exists, run it on the original event
5582 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5583 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ e.preventDefault();
5584
5585 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Support: IE
5586 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Otherwise set the returnValue property of the original event to false
5587 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
5588 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ e.returnValue = false
5589 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5590 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5591 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ stopPropagation: function
5592 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var this
5593
5594 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this
5595
5596 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if this
5597 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
5598 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5599
5600 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // If stopPropagation exists, run it on the original event
5601 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5602 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ e.stopPropagation();
5603 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5604
5605 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Support: IE
5606 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Set the cancelBubble property of the original event to true
5607 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
5608 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5609 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ stopImmediatePropagation: function
5610 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var this
5611
5612 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this
5613
5614 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5615 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ e.stopImmediatePropagation();
5616 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5617
5618 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this
5619 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5620 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/};
5621
5622 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Create mouseenter/leave events using mouseover/out and event-time checks
5623 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// so that event delegation works in jQuery.
5624 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Do the same for pointerenter/pointerleave and pointerover/pointerout
5625 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;///
5626 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Safari 7 only
5627 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Safari sends mouseenter too often; see:
5628 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// https://code.google.com/p/chromium/issues/detail?id=470258
5629 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// for the description of the bug (it existed in older Chrome versions as well).
5630 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5631 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ mouseenter: "mouseover"
5632 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ mouseleave: "mouseout"
5633 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ pointerenter: "pointerover"
5634 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ pointerleave: "pointerout"
5635 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/}, function
5636 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.special[ orig ] = {
5637 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ delegateType: fix,
5638 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ bindType: fix,
5639
5640 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handle: function
5641 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var
5642 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ target = this
5643 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ related = event.relatedTarget,
5644 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handleObj = event.handleObj;
5645
5646 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // For mouseenter/leave call the handler if related is outside the target.
5647 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// NB: No relatedTarget if the mouse left/entered the browser window
5648 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5649 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.type = handleObj.origType;
5650 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ret = handleObj.handler.apply( this
5651 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event.type = fix;
5652 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5653 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return
5654 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5655 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ };
5656 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/} );
5657
5658 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE submit delegation
5659 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5660
5661 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.special.submit = {
5662 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ setup: function
5663
5664 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Only need this for delegated form submit events
5665 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this "form"
5666 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return false
5667 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5668
5669 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Lazy-add a submit handler when a descendant form may potentially be submitted
5670 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this "click._submit keypress._submit" function
5671
5672 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Node name check avoids a VML-related crash in IE (#9807)
5673 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
5674 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ form = jQuery.nodeName( elem, "input" "button"
5675
5676 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Support: IE <=8
5677 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// We use jQuery.prop instead of elem.form
5678 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// to allow fixing the IE8 delegated submit issue (gh-2332)
5679 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// by 3rd party polyfills/workarounds.
5680 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"form"
5681 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ undefined;
5682
5683 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if "submit"
5684 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.add( form, "submit._submit" function
5685 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ event._submitBubble = true
5686 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } );
5687 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery._data( form, "submit" true
5688 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5689 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } );
5690
5691 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // return undefined since we don't need an event listener
5692 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5693
5694 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ postDispatch: function
5695
5696 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // If form was submitted by the user, bubble the event up the tree
5697 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5698 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ delete event._submitBubble;
5699 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if this
5700 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.simulate( "submit" this
5701 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5702 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5703 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5704
5705 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ teardown: function
5706
5707 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Only need this for delegated form submit events
5708 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this "form"
5709 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return false
5710 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5711
5712 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Remove delegated handlers; cleanData eventually reaps submit handlers attached above
5713 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this "._submit"
5714 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5715 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ };
5716 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/}
5717
5718 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE change delegation and checkbox/radio fix
5719 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5720
5721 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.special.change = {
5722
5723 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ setup: function
5724
5725 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if this
5726
5727 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // IE doesn't fire change on a check/radio until blur; trigger it on click
5728 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// after a propertychange. Eat the blur-change in special.change.handle.
5729 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// This still fires onchange a second time for check/radio after blur.
5730 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this "checkbox" this "radio"
5731 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.add( this "propertychange._change" function
5732 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if "checked"
5733 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this true
5734 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5735 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } );
5736 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.add( this "click._change" function
5737 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if this
5738 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this false
5739 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5740
5741 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Allow triggered, simulated change events (#11500)
5742 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"change" this
5743 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } );
5744 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5745 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return false
5746 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5747
5748 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Delegated event; lazy-add a change handler on descendant inputs
5749 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this "beforeactivate._change" function
5750 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var
5751
5752 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if "change"
5753 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.add( elem, "change._change" function
5754 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if this
5755 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.simulate( "change" this
5756 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5757 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } );
5758 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery._data( elem, "change" true
5759 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5760 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } );
5761 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5762
5763 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handle: function
5764 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var
5765
5766 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Swallow native change events from checkbox/radio, we already triggered them above
5767 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this
5768 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ( elem.type !== "radio" "checkbox"
5769
5770 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return this
5771 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5772 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5773
5774 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ teardown: function
5775 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.remove( this "._change"
5776
5777 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return this
5778 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5779 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ };
5780 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/}
5781
5782 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Firefox
5783 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Firefox doesn't have focus(in | out) events
5784 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
5785 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;///
5786 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Chrome, Safari
5787 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// focus(in | out) events fire after focus & blur events,
5788 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
5789 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Related ticket - https://code.google.com/p/chromium/issues/detail?id=449857
5790 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5791 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.each( { focus: "focusin" "focusout" function
5792
5793 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Attach a single capturing handler on the document while someone wants focusin/focusout
5794 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var function
5795 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
5796 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ };
5797
5798 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.special[ fix ] = {
5799 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ setup: function
5800 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var this this
5801 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ attaches = jQuery._data( doc, fix );
5802
5803 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5804 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ doc.addEventListener( orig, handler, true
5805 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5806 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery._data( doc, fix, ( attaches || 0 ) + 1 );
5807 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5808 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ teardown: function
5809 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var this this
5810 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ attaches = jQuery._data( doc, fix ) - 1;
5811
5812 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5813 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ doc.removeEventListener( orig, handler, true
5814 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery._removeData( doc, fix );
5815 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } else
5816 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery._data( doc, fix, attaches );
5817 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5818 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5819 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ };
5820 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } );
5821 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/}
5822
5823 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/jQuery.fn.extend( {
5824
5825 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ on: function
5826 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return this
5827 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5828 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ one: function
5829 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return this
5830 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5831 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ off: function
5832 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var
5833 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5834
5835 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // ( event ) dispatched jQuery.Event
5836 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5837 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery( types.delegateTarget ).off(
5838 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handleObj.namespace ?
5839 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handleObj.origType + "."
5840 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handleObj.origType,
5841 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handleObj.selector,
5842 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ handleObj.handler
5843 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ );
5844 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return this
5845 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5846 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if "object"
5847
5848 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // ( types-object [, selector] )
5849 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
5850 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this
5851 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5852 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return this
5853 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5854 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if false "function"
5855
5856 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // ( types [, fn] )
5857 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5858 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ selector = undefined;
5859 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5860 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if false
5861 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ fn = returnFalse;
5862 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5863 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return this function
5864 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.remove( this
5865 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } );
5866 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5867
5868 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ trigger: function
5869 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return this function
5870 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.event.trigger( type, data, this
5871 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } );
5872 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
5873 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ triggerHandler: function
5874 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var this
5875 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if
5876 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return true
5877 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5878 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
5879 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/} );
5880
5881
5882 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var / jQuery\d+="(?:null|\d+)"/
5883 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ rnoshimcache = new "<(?:" ")[\\s/>]" "i"
5884 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi,
5885
5886 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ // Support: IE 10-11, Edge 10240+
5887 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// In IE/Edge using regex groups here causes severe slowdowns.
5888 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// See https://connect.microsoft.com/IE/feedback/details/1736512/
5889 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//
5890
5891 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// checked="checked" or checked
5892 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//checked\s*(?:[^=]|=\s*.checked.)/
5893 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//^true\/(.*)/
5894 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//^\s*\s*$/
5895 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5896 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"div"
5897
5898 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE<8
5899 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Manipulating tables requires a tbody
5900 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function manipulationTarget
5901 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "table"
5902 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"tr"
5903
5904 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"tbody"
5905 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"tbody"
5906 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5907 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5908
5909 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Replace/restore the type attribute of script elements for safe DOM manipulation
5910 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function disableScript
5911 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"type" null "/"
5912 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
5913 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5914 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function restoreScript
5915 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
5916 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5917 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5918 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
5919 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"type"
5920 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5921 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
5922 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5923
5924 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function cloneCopyEvent
5925 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5926 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
5927 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5928
5929 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
5930 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5931 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5932 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5933
5934 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5935 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5936 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5937
5938 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
5939 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for
5940 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5941 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5942 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5943 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5944
5945 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// make the cloned public data object a copy from the original
5946 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5947 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5948 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5949 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5950
5951 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function fixCloneNodeIssues
5952 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
5953
5954 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// We do not need to do anything for non-Elements
5955 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5956 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
5957 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5958
5959 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5960
5961 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE6-8 copies events bound via attachEvent when using cloneNode.
5962 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5963 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5964
5965 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
5966 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5967 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5968
5969 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Event data gets referenced instead of copied if the expando gets copied too
5970 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5971 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5972
5973 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE blanks contents when cloning scripts, and tries to evaluate newly-set text
5974 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "script"
5975 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5976 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5977
5978 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE6-10 improperly clones children of object elements using classid.
5979 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE10 throws NoModificationAllowedError if parent is null, #12132.
5980 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if "object"
5981 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5982 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5983 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5984
5985 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// This path appears unavoidable for IE9. When cloning an object
5986 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// element in IE9, the outerHTML strategy above is not sufficient.
5987 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If the src has innerHTML and the destination does not,
5988 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// copy the src.innerHTML into the dest.innerHTML. #10324
5989 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
5990 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5991 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
5992
5993 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if "input"
5994
5995 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE6-8 fails to persist the checked state of a cloned checkbox
5996 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// or radio button. Worse, IE6-7 fail to give the cloned element
5997 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// a checked appearance if the defaultChecked value isn't also set
5998
5999 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6000
6001 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE6-7 get confused and end up setting the value of a cloned
6002 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// checkbox/radio button to an empty string instead of "on"
6003 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6004 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6005 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6006
6007 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE6-8 fails to return the selected option to the default selected
6008 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// state when cloning options
6009 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if "option"
6010 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6011
6012 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE6-8 fails to set the defaultValue to the correct value when
6013 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// cloning other types of input fields
6014 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if "input" "textarea"
6015 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6016 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6017 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6018
6019 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function domManip
6020
6021 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Flatten any nested arrays
6022 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6023
6024 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6025 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6026 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6027 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6028 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6029 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6030 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6031
6032 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// We can't cloneNode fragments that contain checked, in WebKit
6033 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6034 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"string"
6035 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6036 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return function
6037 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6038 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6039 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
6040 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6041 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6042 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6043 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6044
6045 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6046 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
6047 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6048
6049 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6050 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6051 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6052
6053 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Require either new content or an interest in ignored elements to invoke the callback
6054 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6055 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"script"
6056 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6057
6058 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Use the original fragment for the last item
6059 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// instead of the first because it can end up
6060 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// being emptied incorrectly in certain situations (#8070).
6061 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for
6062 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6063
6064 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6065 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true true
6066
6067 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Keep references to cloned scripts for later restoration
6068 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6069
6070 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Android<4.1, PhantomJS<2
6071 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// push.apply(_, arraylike) throws on ancient WebKit
6072 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"script"
6073 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6074 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6075
6076 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6077 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6078
6079 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6080 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6081
6082 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Reenable scripts
6083 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6084
6085 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Evaluate executable scripts on first document insertion
6086 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for
6087 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6088 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if ""
6089 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"globalEval"
6090 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6091
6092 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6093
6094 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Optional AJAX dependency, but won't run scripts if not present
6095 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6096 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6097 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6098 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
6099 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6100 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
6101 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
6102 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6103 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6104 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6105 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6106 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6107
6108 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Fix #11809: Avoid leaking memory
6109 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
6110 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6111 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6112
6113 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6114 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6115
6116 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function remove
6117 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6118 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6119 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6120
6121 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for null
6122
6123 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6124 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6125 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6126
6127 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6128 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6129 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"script"
6130 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6131 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6132 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6133 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6134
6135 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6136 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6137
6138 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6139 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6140 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// return html.replace( rxhtmlTag, "<$1></$2>" );
6141 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6142 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6143
6144 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6145 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6146 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6147
6148 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6149 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"<" ">"
6150
6151 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
6152
6153 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE<=8 does not properly clone detached, unknown element nodes
6154 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
6155 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6156 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6157 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6158
6159 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6160 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6161
6162 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
6163 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6164 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6165
6166 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Fix all IE cloning issues
6167 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for null
6168
6169 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Ensure that the destination node is not null; Fixes #9587
6170 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6171 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6172 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6173 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6174 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6175
6176 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Copy the events from the original to the clone
6177 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6178 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6179 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6180 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6181
6182 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for null
6183 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6184 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6185 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
6186 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6187 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6188 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6189
6190 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Preserve script evaluation history
6191 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"script"
6192 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6193 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"script"
6194 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6195
6196 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
6197
6198 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Return the cloned set
6199 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6200 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6201
6202 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function /* internal */
6203 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6204 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6205 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6206 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6207 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6208 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6209
6210 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for null
6211 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6212
6213 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6214 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6215
6216 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6217 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6218 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
6219 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6220 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6221
6222 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// This is a shortcut to avoid jQuery.event.remove's overhead
6223 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
6224 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6225 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6226 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6227 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6228
6229 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Remove cache only if it was not already removed by jQuery.event.remove
6230 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6231
6232 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6233
6234 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE<9
6235 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE does not allow us to delete expando properties from nodes
6236 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE creates expando attributes along with the property
6237 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE does not have a removeAttribute function on Document nodes
6238 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "undefined"
6239 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6240
6241 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Webkit & Blink performance suffers when deleting properties
6242 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// from DOM nodes, so set to undefined instead
6243 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// https://code.google.com/p/chromium/issues/detail?id=378607
6244 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
6245 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6246 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6247
6248 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6249 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6250 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6251 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6252 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6253 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6254 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6255
6256 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6257
6258 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Keep domManip exposed until 3.0 (gh-2225)
6259 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6260
6261 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6262 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this true
6263 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6264
6265 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6266 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
6267 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6268
6269 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6270 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
6271 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6272 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
6273 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
6274 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this
6275 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6276 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
6277 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6278
6279 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6280 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
6281 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this this this
6282 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var this
6283 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6284 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6285 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6286 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6287
6288 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6289 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
6290 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this this this
6291 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var this
6292 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6293 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6294 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6295 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6296
6297 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6298 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
6299 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this
6300 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this
6301 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6302 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6303 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6304
6305 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6306 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
6307 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this
6308 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this
6309 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6310 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6311 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6312
6313 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6314 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6315 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6316
6317 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for this null
6318
6319 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Remove element nodes and prevent memory leaks
6320 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6321 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
6322 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6323
6324 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Remove any remaining nodes
6325 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while
6326 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6327 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6328
6329 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If this is a select, ensure that it displays empty (#12336)
6330 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE<9
6331 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "select"
6332 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6333 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6334 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6335
6336 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
6337 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6338
6339 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6340 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null false
6341 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
6342
6343 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
6344 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
6345 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6346 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6347
6348 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6349 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
6350 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var this
6351 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6352 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
6353
6354 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6355 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6356 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
6357 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6358 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6359
6360 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// See if we can take a shortcut and just use innerHTML
6361 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "string"
6362 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6363 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6364 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"" ""
6365
6366 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6367
6368 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/try
6369 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for
6370
6371 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Remove element nodes and prevent memory leaks
6372 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
6373 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6374 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
6375 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6376 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6377 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6378
6379 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6380
6381 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If using innerHTML throws an exception, use the fallback method
6382 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/catch
6383 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6384
6385 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6386 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
6387 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6388 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
6389 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6390
6391 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6392 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6393
6394 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Make the changes, replacing each non-ignored context element with the new content
6395 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
6396 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var this
6397
6398 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this
6399 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
6400 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6401 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
6402 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6403 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6404
6405 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Force callback invocation
6406 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6407 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6408 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6409
6410 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6411 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"append"
6412 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"prepend"
6413 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"before"
6414 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"after"
6415 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"replaceWith"
6416 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6417 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6418 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6419 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6420 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6421 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6422 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6423
6424 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for
6425 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this true
6426 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6427
6428 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get()
6429 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6430 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6431
6432 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
6433 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6434 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6435
6436
6437 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6438 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6439
6440 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Firefox
6441 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// We have to pre-define these values for FF (#10227)
6442 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"block"
6443 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"block"
6444 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6445
6446 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//**
6447 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * Retrieve the actual display of a element
6448 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * @param {String} name nodeName of the element
6449 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * @param {Object} doc Document object
6450 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ */
6451
6452 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Called only from within defaultDisplay
6453 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function actualDisplay
6454 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6455
6456 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"display"
6457
6458 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// We don't have any data stored on the element,
6459 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// so use "detach" method as fast way to get rid of the element
6460 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6461
6462 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6463 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6464
6465 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//**
6466 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * Try to determine the default display value of an element
6467 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * @param {String} nodeName
6468 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ */
6469 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function defaultDisplay
6470 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6471 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6472
6473 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6474 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6475
6476 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If the simple way fails, read from inside an iframe
6477 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "none"
6478
6479 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Use the already-created iframe if possible
6480 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"<iframe frameborder='0' width='0' height='0'/>"
6481 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6482
6483 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
6484 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6485
6486 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE
6487 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6488 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6489
6490 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6491 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6492 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6493
6494 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Store the correct default display
6495 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6496 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6497
6498 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6499 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6500 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var /^margin/
6501
6502 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var new "^(" ")(?!px)[a-z%]+$" "i"
6503
6504 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var function
6505 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6506 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6507
6508 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Remember the old values, and insert the new ones
6509 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
6510 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6511 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6512 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6513
6514 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6515
6516 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Revert the old values
6517 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
6518 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6519 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6520
6521 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6522 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6523
6524
6525 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6526
6527
6528
6529 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6530 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6531 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6532 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"div"
6533 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"div"
6534
6535 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Finish early in limited (non-browser) environments
6536 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6537 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6538 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6539
6540 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"float:left;opacity:.5"
6541
6542 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE<9
6543 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Make sure that element opacity exists (as opposed to filter)
6544 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"0.5"
6545
6546 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Verify style float existence
6547 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// (IE uses styleFloat instead of cssFloat)
6548 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6549
6550 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"content-box"
6551 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true ""
6552 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"content-box"
6553
6554 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"div"
6555 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"border:0;width:8px;height:0;top:0;left:-9999px;"
6556 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"padding:0;margin-top:1px;position:absolute"
6557 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
6558 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6559
6560 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Firefox<29, Android 2.3
6561 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Vendor-prefix box-sizing
6562 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"" ""
6563 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
6564
6565 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6566 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6567 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if null
6568 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6569 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6570 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6571 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6572
6573 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6574
6575 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// We're checking for pixelPositionVal here instead of boxSizingReliableVal
6576 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// since that compresses better and they're computed together anyway.
6577 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if null
6578 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6579 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6580 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6581 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6582
6583 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6584
6585 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Android 4.0-4.3
6586 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if null
6587 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6588 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6589 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6590 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6591
6592 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6593 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if null
6594 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6595 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6596 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6597 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6598
6599 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6600
6601 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Android 2.3
6602 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if null
6603 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6604 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6605 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6606 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6607
6608 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6609
6610 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE <=8 only, Android 4.0 - 4.3 only, Firefox <=3 - 37
6611 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if null
6612 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6613 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6614 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6615 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6616 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6617
6618 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function computeStyleTests
6619 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6620 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6621
6622 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Setup
6623 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6624
6625 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6626
6627 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Android 2.3
6628 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Vendor-prefix box-sizing
6629 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"-webkit-box-sizing:border-box;box-sizing:border-box;"
6630 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"position:relative;display:block;"
6631 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"margin:auto;border:1px;padding:1px;"
6632 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"top:1%;width:50%"
6633
6634 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE<9
6635 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Assume reasonable values in the absence of getComputedStyle
6636 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
6637 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
6638
6639 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Check for getComputedStyle so that this code is not run in IE<9.
6640 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6641 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
6642 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"1%"
6643 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"2px"
6644 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"4px" "4px"
6645
6646 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Android 4.0 - 4.3 only
6647 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Some styles come back with percentage values, even though they shouldn't
6648 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"50%"
6649 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"4px" "4px"
6650
6651 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Android 2.3 only
6652 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Div with explicit width and no margin-right incorrectly
6653 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// gets computed margin-right based on width of container (#3333)
6654 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
6655 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"div"
6656
6657 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Reset CSS: box-sizing; display; margin; border; padding
6658 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6659
6660 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Android 2.3
6661 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Vendor-prefix box-sizing
6662 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"-webkit-box-sizing:content-box;-moz-box-sizing:content-box;"
6663 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"box-sizing:content-box;display:block;margin:0;border:0;padding:0"
6664 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"0"
6665 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"1px"
6666
6667 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6668 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/parseFloat null
6669
6670 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6671 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6672
6673 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE6-8
6674 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// First check that getClientRects works as expected
6675 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Check if table cells still have offsetWidth/Height when they are set
6676 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// to display:none and there are still other visible table cells in a
6677 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// table row; if so, offsetWidth/Height are not reliable for use when
6678 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// determining if an element has been hidden directly using
6679 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// display:none (it is still safe to use offsets if a parent element is
6680 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// hidden; don safety goggles and see bug #4512 for more information).
6681 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"none"
6682 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6683 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6684 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
6685 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"<table><tr><td></td><td>t</td></tr></table>"
6686 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"separate"
6687 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"td"
6688 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"margin:0;border:0;padding:0;display:none"
6689 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6690 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6691 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
6692 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"none"
6693 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6694 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6695 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6696
6697 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Teardown
6698 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6699 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6700
6701 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6702
6703
6704 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6705 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//^(top|right|bottom|left)$/
6706
6707 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6708 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6709
6710 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE<=11+, Firefox<=30+ (#15098, #14150)
6711 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE throws on elements created in popups
6712 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
6713 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6714
6715 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6716 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6717 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6718
6719 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return null
6720 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6721
6722 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6723 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6724 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6725
6726 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6727
6728 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// getPropertyValue is only needed for .css('filter') in IE9, see #12537
6729 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6730
6731 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Opera 12.1x only
6732 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Fall back to style even without computed
6733 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// computed is undefined for elems on document fragments
6734 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if ""
6735 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6736 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6737
6738 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6739
6740 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// A tribute to the "awesome hack by Dean Edwards"
6741 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Chrome < 17 and Safari 5.0 uses "computed value"
6742 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// instead of "used value" for margin-right
6743 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Safari 5.1.7 (at least) returns percentage for a larger set of values,
6744 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// but width seems to be reliably pixels
6745 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// this is against the CSSOM draft spec:
6746 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// http://dev.w3.org/csswg/cssom/#resolved-values
6747 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6748
6749 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Remember the original values
6750 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6751 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6752 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6753
6754 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Put in the new values to get a computed value out
6755 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6756 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6757
6758 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Revert the changed values
6759 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6760 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6761 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6762 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6763 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6764
6765 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE
6766 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE returns zIndex value as an integer.
6767 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6768 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6769 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
6770 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6771 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if
6772 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6773 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6774 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6775
6776 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6777 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6778 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6779
6780 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6781 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6782
6783 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Avoid setting ret to empty string here
6784 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// so we don't default to auto
6785 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if null
6786 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6787 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6788
6789 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// From the awesome hack by Dean Edwards
6790 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
6791
6792 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If we're not dealing with a regular pixel number
6793 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// but a number that has a weird ending, we need to convert it to pixels
6794 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// but not position css attributes, as those are
6795 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// proportional to the parent element instead
6796 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// and we can't measure the parent instead because it
6797 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// might trigger a "stacking dolls" problem
6798 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6799
6800 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Remember the original values
6801 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6802 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6803 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6804
6805 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Put in the new values to get a computed value out
6806 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6807 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6808 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6809 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"fontSize" "1em"
6810 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"px"
6811
6812 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Revert the changed values
6813 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6814 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6815 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6816 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6817 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6818
6819 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE
6820 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE returns zIndex value as an integer.
6821 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6822 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6823 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"" "auto"
6824 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6825 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6826
6827
6828
6829
6830 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function addGetHookIf
6831
6832 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Define the hook, we'll check on the first run if it's really needed.
6833 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6834 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
6835 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6836
6837 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Hook not needed (or it's not possible to use it due
6838 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// to missing dependency), remove it.
6839 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
6840 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6841 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6842
6843 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Hook needed; redefine it so that the support test is not executed again.
6844 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this this
6845 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6846 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6847 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6848
6849
6850 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6851
6852 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//alpha\([^)]*\)/
6853 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//opacity\s*=\s*([^)]*)/
6854
6855 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// swappable if display is none or starts with table except
6856 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// "table", "table-cell", or "table-caption"
6857 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// see here for display values:
6858 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// https://developer.mozilla.org/en-US/docs/CSS/display
6859 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//^(none|table(?!-c[ea]).+)/
6860 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/new "^(" ")(.*)$" "i"
6861
6862 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"absolute" "hidden" "block"
6863 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6864 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"0"
6865 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"400"
6866 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6867
6868 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"Webkit" "O" "Moz" "ms"
6869 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"div"
6870
6871
6872 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// return a css property mapped to a potentially vendor prefixed property
6873 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function vendorPropName
6874
6875 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// shortcut for names that are not vendor prefixed
6876 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if in
6877 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6878 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6879
6880 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// check for vendor prefixed names
6881 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6882 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6883
6884 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while
6885 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6886 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if in
6887 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6888 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6889 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6890 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6891
6892 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function showHide
6893 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6894 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6895 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6896 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6897
6898 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for
6899 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6900 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6901 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/continue
6902 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6903
6904 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"olddisplay"
6905 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6906 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6907
6908 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Reset the inline display of this element to learn if it is
6909 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// being hidden by cascaded rules or not
6910 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "none"
6911 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
6912 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6913
6914 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Set elements which have been overridden with display: none
6915 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// in a stylesheet to whatever the default browser style is
6916 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// for such an element
6917 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if ""
6918 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6919 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"olddisplay"
6920 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6921 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
6922 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6923
6924 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "none"
6925 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6926 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6927 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"olddisplay"
6928 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"display"
6929 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6930 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6931 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6932 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6933
6934 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Set the display of most of the elements in a second loop
6935 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// to avoid the constant reflow
6936 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for
6937 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6938 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6939 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/continue
6940 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6941 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "none" ""
6942 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"" "none"
6943 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6944 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6945
6946 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6947 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6948
6949 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function setPositiveNumber
6950 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
6951 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
6952
6953 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Guard against undefined "subtract", e.g., when used as in cssHooks
6954 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/Math "px"
6955 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6956 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6957
6958 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function augmentWidthOrHeight
6959 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var "border" "content"
6960
6961 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If we already have the right measurement, avoid augmentation
6962 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6963
6964 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Otherwise initialize for horizontal or vertical properties
6965 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"width"
6966
6967 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6968
6969 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for
6970
6971 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// both box models exclude margin, so add it if we want it
6972 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "margin"
6973 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
6974 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6975
6976 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
6977
6978 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// border-box includes padding, so remove it if we want content
6979 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "content"
6980 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"padding" true
6981 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6982
6983 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// at this point, extra isn't border nor margin, so remove border
6984 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "margin"
6985 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"border" "Width" true
6986 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6987 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
6988
6989 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// at this point, extra isn't content, so add padding
6990 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"padding" true
6991
6992 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// at this point, extra isn't content nor padding, so add border
6993 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "padding"
6994 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"border" "Width" true
6995 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6996 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6997 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
6998
6999 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7000 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7001
7002 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function getWidthOrHeight
7003
7004 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Start with offset property, which is equivalent to the border-box value
7005 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var true
7006 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"width"
7007 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7008 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7009 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"boxSizing" false "border-box"
7010
7011 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// some non-html elements return undefined for offsetWidth, so check for null/undefined
7012 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
7013 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
7014 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if null
7015
7016 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Fall back to computed then uncomputed css if necessary
7017 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7018 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if null
7019 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7020 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7021
7022 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Computed unit is not pixels. Stop here and return.
7023 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7024 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7025 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7026
7027 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// we need the check for style in case a browser which returns unreliable values
7028 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// for getComputedStyle silently falls back to the reliable elem.style
7029 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7030 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7031
7032 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Normalize "", auto, and prepare for extra
7033 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/parseFloat
7034 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7035
7036 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// use the active box-sizing model to add/subtract irrelevant styles
7037 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7038 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7039 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7040 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7041 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"border" "content"
7042 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7043 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7044 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7045 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"px"
7046 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7047
7048 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7049
7050 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Add in style property hooks for overriding the default
7051 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// behavior of getting and setting a style property
7052 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7053 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7054 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7055 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7056
7057 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// We should always get a number back from opacity
7058 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var "opacity"
7059 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "" "1"
7060 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7061 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7062 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7063 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7064
7065 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Don't automatically add "px" to these possibly-unitless properties
7066 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7067 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"animationIterationCount" true
7068 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"columnCount" true
7069 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"fillOpacity" true
7070 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"flexGrow" true
7071 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"flexShrink" true
7072 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"fontWeight" true
7073 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"lineHeight" true
7074 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"opacity" true
7075 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"order" true
7076 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"orphans" true
7077 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"widows" true
7078 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"zIndex" true
7079 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"zoom" true
7080 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7081
7082 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Add in properties whose names you wish to fix before
7083 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// setting or getting the value
7084 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7085
7086 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// normalize float css property
7087 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"float" "cssFloat" "styleFloat"
7088 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7089
7090 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Get and set the style property on a DOM Node
7091 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7092
7093 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Don't set styles on text and comment nodes
7094 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7095 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7096 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7097
7098 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Make sure that we're working with the right name
7099 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
7100 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7101 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7102
7103 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7104 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7105
7106 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// gets hook for the prefixed version
7107 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// followed by the unprefixed version
7108 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7109
7110 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Check if we're setting a value
7111 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7112 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7113
7114 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Convert "+=" or "-=" to relative numbers (#7345)
7115 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "string"
7116 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7117
7118 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Fixes bug #9237
7119 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"number"
7120 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7121
7122 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Make sure that null and NaN values aren't set. See: #7116
7123 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if null
7124 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7125 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7126
7127 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If a number was passed in, add the unit (except for certain CSS properties)
7128 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "number"
7129 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"" "px"
7130 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7131
7132 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Fixes #8908, it can be done more correctly by specifing setters in cssHooks,
7133 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// but it would mean to define eight
7134 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// (for every problematic property) identical functions
7135 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "" "background"
7136 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"inherit"
7137 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7138
7139 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If a hook was provided, use that value, otherwise just set the specified value
7140 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "set" in
7141 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7142
7143 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE
7144 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Swallow errors from 'invalid' CSS values (#5509)
7145 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/try
7146 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7147 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/catch
7148 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7149
7150 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
7151
7152 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If a hook was provided get the non-computed value from there
7153 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "get" in
7154 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
7155
7156 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7157 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7158
7159 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Otherwise just get the value from the style object
7160 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7161 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7162 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7163
7164 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7165 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
7166 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7167
7168 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Make sure that we're working with the right name
7169 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7170 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7171
7172 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// gets hook for the prefixed version
7173 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// followed by the unprefixed version
7174 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7175
7176 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If a hook was provided get the computed value from there
7177 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "get" in
7178 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
7179 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7180
7181 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Otherwise, if a way to get the computed value exists, use that
7182 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7183 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7184 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7185
7186 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;///convert "normal" to computed value
7187 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "normal" in
7188 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7189 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7190
7191 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Return, converting to number if forced or a qualifier was provided and val looks numeric
7192 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if ""
7193 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/parseFloat
7194 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return true
7195 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7196 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7197 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7198 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7199
7200 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"height" "width" function
7201 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7202 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7203 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7204
7205 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// certain elements can have dimension info if we invisibly show them
7206 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// however, it must have a current display style that would benefit from this
7207 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "display"
7208 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7209 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7210 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7211 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7212 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7213 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7214 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7215
7216 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7217 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
7218 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7219 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7220 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7221 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7222 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7223 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7224 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"boxSizing" false "border-box"
7225 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7226 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7227 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7228 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7229 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7230 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7231
7232 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7233 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7234 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7235
7236 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE uses filters for opacity
7237 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7238 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7239 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
7240 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/parseFloat ""
7241 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"1" ""
7242 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7243
7244 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7245 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
7246 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7247 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"alpha(opacity=" ")" ""
7248 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
7249
7250 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE has trouble with opacity if it does not have layout
7251 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Force it by setting the zoom level
7252 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7253
7254 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// if setting opacity to 1, and no other filters exist -
7255 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// attempt to remove filter attribute #6652
7256 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// if value === "", then remove inline opacity #12685
7257 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if ""
7258 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"" ""
7259 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7260
7261 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Setting style.filter to null, "" & " " still leave "filter:" in the cssText
7262 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// if "filter:" is present at all, clearType is disabled, we want to avoid this
7263 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// style.removeAttribute is IE Only, but so apparently is this code path...
7264 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"filter"
7265
7266 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// if there is no filter style applied in a css rule
7267 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// or unset inline opacity, we are done
7268 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if ""
7269 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7270 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7271 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7272
7273 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// otherwise, set new filter values
7274 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7275 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7276 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/" "
7277 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7278 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7279 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7280
7281 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7282 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7283 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7284 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "display" "inline-block"
7285 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"marginRight"
7286 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7287 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7288 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7289
7290 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7291 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7292 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7293 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7294 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/parseFloat "marginLeft"
7295
7296 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE<=11+
7297 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Running getBoundingClientRect on a disconnected node in IE throws an error
7298 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE8 only
7299 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// getClientRects() errors on disconnected elems
7300 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7301 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7302 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7303 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7304 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7305
7306 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7307 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"px"
7308 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7309 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7310 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7311
7312 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// These hooks are used by animate to expand properties
7313 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7314 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
7315 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
7316 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"Width"
7317 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7318 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7319 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7320 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
7321 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7322
7323 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// assumes a single number if not a string
7324 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"string" " "
7325
7326 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for
7327 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7328 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7329 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7330
7331 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7332 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7333 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7334
7335 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7336 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7337 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7338 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7339
7340 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7341 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7342 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
7343 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
7344 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7345 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7346
7347 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7348 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7349 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7350
7351 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for
7352 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
7353 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7354
7355 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7356 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7357
7358 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7359 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7360 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7361 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7362 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7363 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7364 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this true
7365 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7366 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7367 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
7368 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7369 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7370 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "boolean"
7371 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this this
7372 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7373
7374 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
7375 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this
7376 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
7377 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
7378 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
7379 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7380 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7381 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7382 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7383
7384
7385 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function Tween
7386 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return new
7387 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7388 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7389
7390 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7391 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7392 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7393 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
7394 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
7395 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
7396 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
7397 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this this
7398 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
7399 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this "" "px"
7400 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7401 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7402 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var this
7403
7404 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7405 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
7406 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
7407 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7408 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7409 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
7410 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
7411
7412 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this
7413 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this
7414 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this
7415 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7416 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
7417 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
7418 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7419 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this this this
7420
7421 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this
7422 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this this this
7423 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7424
7425 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7426 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
7427 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
7428 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
7429 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7430 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
7431 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7432 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7433
7434 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7435
7436 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7437 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7438 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7439 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
7440
7441 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Use a property on the element directly when it is not a DOM element,
7442 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// or when there is no matching style property that exists.
7443 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7444 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null null
7445 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7446 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7447
7448 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// passing an empty string as a 3rd parameter to .css will automatically
7449 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// attempt a parseFloat and fallback to a string if the parse fails
7450 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// so, simple values such as "10px" are parsed to Float.
7451 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// complex values such as "rotate(1rad)" are returned as is.
7452 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
7453
7454 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Empty strings, null, undefined and "auto" are converted to 0.
7455 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "auto"
7456 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7457 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7458
7459 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// use step hook for back compat - use cssHook if its there - use .style if its
7460 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// available and use plain properties where available
7461 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7462 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7463 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if
7464 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
7465 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7466 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7467 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
7468 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7469 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7470 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7471 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7472 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7473
7474 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE <=9
7475 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Panic based approach to setting things on disconnected nodes
7476
7477 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7478 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7479 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7480 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7481 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7482 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7483 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7484
7485 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7486 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7487 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
7488 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7489 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7490 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return Math Math / 2;
7491 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
7492 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ _default: "swing"
7493 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/};
7494
7495 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/jQuery.fx = Tween.prototype.init;
7496
7497 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;// / Back Compat <1.8 extension point
7498 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/<1.8 extension pointjQuery.fx.step = {};
7499
7500
7501
7502
7503 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/<1.8 extension pointvar
7504 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/<1.8 extension point fxNow, timerId,
7505 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/<1.8 extension point rfxtypes = / /,
7506 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ rrun = / /;
7507
7508 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;// / Animations created synchronously will run synchronously
7509 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function createFxNow() {
7510 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ window.setTimeout( function() {
7511 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ fxNow = undefined;
7512 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } );
7513 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return ( fxNow = jQuery.now() );
7514 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/}
7515
7516 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;// / Generate parameters to create a standard animation
7517 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function genFx( type, includeWidth ) {
7518 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var which,
7519 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ attrs = { height: type },
7520 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ i = 0;
7521
7522 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / if we include width, step value is 1 to do all cssExpand values,
7523 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / if we don't include width, step value is 2 to skip over Left and Right
7524 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ includeWidth = includeWidth ? 1 : 0;
7525 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ for ( ; i < 4 ; i += 2 - includeWidth ) {
7526 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< 4 ; i += 2 - includeWidth ) { which = cssExpand[ i ];
7527 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< 4 ; i += 2 - includeWidth ) { attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
7528 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< 4 ; i += 2 - includeWidth ) { }
7529
7530 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< 4 ; i += 2 - includeWidth ) { if ( includeWidth ) {
7531 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< 4 ; i += 2 - includeWidth ) { attrs.opacity = attrs.width = type;
7532 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< 4 ; i += 2 - includeWidth ) { }
7533
7534 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< 4 ; i += 2 - includeWidth ) { return attrs;
7535 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< 4 ; i += 2 - includeWidth ) {}
7536
7537 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< 4 ; i += 2 - includeWidth ) {function createTween( value, prop, animation ) {
7538 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< 4 ; i += 2 - includeWidth ) { var tween,
7539 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< 4 ; i += 2 - includeWidth ) { collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
7540 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< 4 ; i += 2 - includeWidth ) { index = 0,
7541 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< 4 ; i += 2 - includeWidth ) { length = collection.length;
7542 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< 4 ; i += 2 - includeWidth ) { for ( ; index < length; index++ ) {
7543 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< 4 ; i += 2 - includeWidth ) {< length; index++ ) { if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
7544
7545 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< 4 ; i += 2 - includeWidth ) {< length; index++ ) { / / we're done with this property
7546 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return tween;
7547 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7548 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7549 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/}
7550
7551 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function defaultPrefilter( elem, props, opts ) {
7552 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / true /
7553 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,
7554 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ anim = this,
7555 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ orig = {},
7556 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ style = elem.style,
7557 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ hidden = elem.nodeType && isHidden( elem ),
7558 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ dataShow = jQuery._data( elem, "fxshow" );
7559
7560 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / handle queue: false promises
7561 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( !opts.queue ) {
7562 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ hooks = jQuery._queueHooks( elem, "fx" );
7563 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( hooks.unqueued == null ) {
7564 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ hooks.unqueued = 0;
7565 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ oldfire = hooks.empty.fire;
7566 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ hooks.empty.fire = function() {
7567 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( !hooks.unqueued ) {
7568 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ oldfire();
7569 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7570 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ };
7571 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7572 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ hooks.unqueued++;
7573
7574 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ anim.always( function() {
7575
7576 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / doing this makes sure that the complete handler will be called
7577 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / before this completes
7578 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ anim.always( function() {
7579 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ hooks.unqueued--;
7580 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( !jQuery.queue( elem, "fx" ).length ) {
7581 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ hooks.empty.fire();
7582 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7583 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } );
7584 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } );
7585 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7586
7587 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / height/
7588 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "height" in "width" in
7589
7590 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Make sure that nothing sneaks out
7591 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Record all 3 overflow attributes because IE does not
7592 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// change the overflow attribute when overflowX and
7593 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// overflowY are set to the same value
7594 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7595
7596 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Set display property to inline-block for height/width
7597 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// animations on inline elements that are having width/height animated
7598 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"display"
7599
7600 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Test default display if display is currently "none"
7601 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"none"
7602 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"olddisplay"
7603
7604 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "inline" "float" "none"
7605
7606 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// inline-level elements accept inline-block;
7607 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// block-level elements need to be inline with layout
7608 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "inline"
7609 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"inline-block"
7610 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
7611 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7612 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7613 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7614 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7615
7616 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7617 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"hidden"
7618 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7619 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7620 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7621 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7622 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7623 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7624 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7625 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7626
7627 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// show/hide pass
7628 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
7629 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7630 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7631 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7632 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"toggle"
7633 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "hide" "show"
7634
7635 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If there is dataShow left over from a stopped hide or show
7636 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// and we are going to proceed with show, we should pretend to be hidden
7637 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "show"
7638 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
7639 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
7640 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/continue
7641 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7642 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7643 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7644
7645 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Any non-fx value stops us from restoring the original display value
7646 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
7647 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7648 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7649 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7650
7651 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7652 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7653 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "hidden" in
7654 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7655 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7656 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
7657 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"fxshow"
7658 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7659
7660 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// store state if its toggle - enables .stop().toggle() to "reverse"
7661 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7662 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7663 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7664 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7665 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7666 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
7667 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7668 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7669 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7670 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7671 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7672 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
7673 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"fxshow"
7674 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
7675 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7676 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7677 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7678 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
7679 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7680
7681 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if in
7682 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7683 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7684 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7685 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"width" "height"
7686 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7687 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7688 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7689
7690 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If this is a noop like .hide().hide(), restore an overwritten display value
7691 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if "none" "inline"
7692 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7693 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7694 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7695
7696 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function propFilter
7697 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
7698
7699 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// camelCase, specialEasing and expand cssHook pass
7700 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
7701 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7702 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7703 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7704 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7705 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7706 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7707 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7708
7709 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7710 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7711 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7712 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7713
7714 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7715 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "expand" in
7716 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7717 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7718
7719 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// not quite $.extend, this wont overwrite keys already present.
7720 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// also - reusing 'index' from above because we have the correct "name"
7721 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
7722 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if in
7723 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7724 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7725 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7726 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7727 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
7728 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7729 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7730 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7731 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7732
7733 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function Animation
7734 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
7735 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7736 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7737 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7738 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7739
7740 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// don't match elem in the :animated selector
7741 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7742 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7743 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
7744 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
7745 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return false
7746 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
7747 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
7748 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/Math
7749
7750 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Android 2.3
7751 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
7752 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;// animation.duration || 0,
7753 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ percent = 1 - temp,
7754 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ index = 0,
7755 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ length = animation.tweens.length;
7756
7757 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ for ( ; index < length ; index++ ) {
7758 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { animation.tweens[ index ].run( percent );
7759 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { }
7760
7761 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { deferred.notifyWith( elem, [ animation, percent, remaining ] );
7762
7763 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { if ( percent < 1 && length ) {
7764 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { return remaining;
7765 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { } else {
7766 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { deferred.resolveWith( elem, [ animation ] );
7767 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { return false;
7768 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { }
7769 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { },
7770 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { animation = deferred.promise( {
7771 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { elem: elem,
7772 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { props: jQuery.extend( {}, properties ),
7773 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { opts: jQuery.extend( true, {
7774 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { specialEasing: {},
7775 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { easing: jQuery.easing._default
7776 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { }, options ),
7777 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { originalProperties: properties,
7778 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { originalOptions: options,
7779 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { startTime: fxNow || createFxNow(),
7780 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { duration: options.duration,
7781 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { tweens: [],
7782 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { createTween: function( prop, end ) {
7783 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { var tween = jQuery.Tween( elem, animation.opts, prop, end,
7784 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { animation.opts.specialEasing[ prop ] || animation.opts.easing );
7785 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { animation.tweens.push( tween );
7786 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { return tween;
7787 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { },
7788 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { stop: function( gotoEnd ) {
7789 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { var index = 0,
7790
7791 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {< 1 && length ) { / / if we are going to the end, we want to run all the tweens
7792 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / otherwise we skip this part
7793 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ length = gotoEnd ? animation.tweens.length : 0;
7794 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( stopped ) {
7795 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return this;
7796 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7797 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ stopped = true;
7798 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ for ( ; index < length ; index++ ) {
7799 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { animation.tweens[ index ].run( 1 );
7800 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { }
7801
7802 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { / / resolve when we played the last frame
7803 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / otherwise, reject
7804 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( gotoEnd ) {
7805 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ deferred.notifyWith( elem, [ animation, 1, 0 ] );
7806 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ deferred.resolveWith( elem, [ animation, gotoEnd ] );
7807 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } else {
7808 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ deferred.rejectWith( elem, [ animation, gotoEnd ] );
7809 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7810 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return this;
7811 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7812 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } ),
7813 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ props = animation.props;
7814
7815 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ propFilter( props, animation.opts.specialEasing );
7816
7817 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ for ( ; index < length ; index++ ) {
7818 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
7819 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { if ( result ) {
7820 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { if ( jQuery.isFunction( result.stop ) ) {
7821 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
7822 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { jQuery.proxy( result.stop, result );
7823 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { }
7824 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { return result;
7825 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { }
7826 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { }
7827
7828 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { jQuery.map( props, createTween, animation );
7829
7830 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { if ( jQuery.isFunction( animation.opts.start ) ) {
7831 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { animation.opts.start.call( elem, animation );
7832 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { }
7833
7834 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { jQuery.fx.timer(
7835 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { jQuery.extend( tick, {
7836 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { elem: elem,
7837 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { anim: animation,
7838 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { queue: animation.opts.queue
7839 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { } )
7840 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { );
7841
7842 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { / / attach callbacks from options
7843 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return animation.progress( animation.opts.progress )
7844 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ .done( animation.opts.done, animation.opts.complete )
7845 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ .fail( animation.opts.fail )
7846 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ .always( animation.opts.always );
7847 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/}
7848
7849 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/jQuery.Animation = jQuery.extend( Animation, {
7850
7851 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ tweeners: {
7852 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ "*": [ function( prop, value ) {
7853 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var tween = this.createTween( prop, value );
7854 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
7855 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return tween;
7856 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } ]
7857 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
7858
7859 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ tweener: function( props, callback ) {
7860 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( jQuery.isFunction( props ) ) {
7861 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ callback = props;
7862 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ props = [ "*" ];
7863 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } else {
7864 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ props = props.match( rnotwhite );
7865 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7866
7867 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var prop,
7868 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ index = 0,
7869 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ length = props.length;
7870
7871 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ for ( ; index < length ; index++ ) {
7872 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { prop = props[ index ];
7873 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
7874 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { Animation.tweeners[ prop ].unshift( callback );
7875 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { }
7876 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { },
7877
7878 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { prefilters: [ defaultPrefilter ],
7879
7880 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { prefilter: function( callback, prepend ) {
7881 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { if ( prepend ) {
7882 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { Animation.prefilters.unshift( callback );
7883 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { } else {
7884 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { Animation.prefilters.push( callback );
7885 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { }
7886 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { }
7887 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {} );
7888
7889 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) {jQuery.speed = function( speed, easing, fn ) {
7890 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
7891 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { complete: fn || !fn && easing ||
7892 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { jQuery.isFunction( speed ) && speed,
7893 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { duration: speed,
7894 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
7895 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { };
7896
7897 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
7898 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { opt.duration in jQuery.fx.speeds ?
7899 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
7900
7901 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length ; index++ ) { / / normalize opt.queue - true/ /null -> "fx"
7902 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( opt.queue == null || opt.queue === true ) {
7903 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ opt.queue = "fx";
7904 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7905
7906 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / Queueing
7907 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ opt.old = opt.complete;
7908
7909 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ opt.complete = function() {
7910 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( jQuery.isFunction( opt.old ) ) {
7911 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ opt.old.call( this );
7912 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7913
7914 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( opt.queue ) {
7915 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.dequeue( this, opt.queue );
7916 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7917 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ };
7918
7919 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return opt;
7920 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/};
7921
7922 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/jQuery.fn.extend( {
7923 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ fadeTo: function( speed, to, easing, callback ) {
7924
7925 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / show any hidden elements after setting opacity to 0
7926 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return this.filter( isHidden ).css( "opacity", 0 ).show()
7927
7928 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / animate to the value specified
7929 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ .end().animate( { opacity: to }, speed, easing, callback );
7930 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
7931 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ animate: function( prop, speed, easing, callback ) {
7932 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var empty = jQuery.isEmptyObject( prop ),
7933 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ optall = jQuery.speed( speed, easing, callback ),
7934 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ doAnimation = function() {
7935
7936 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / Operate on a copy of prop so per-property easing won't be lost
7937 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var anim = Animation( this, jQuery.extend( {}, prop ), optall );
7938
7939 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / Empty animations, or finishing resolves immediately
7940 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( empty || jQuery._data( this, "finish" ) ) {
7941 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ anim.stop( true );
7942 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7943 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ };
7944 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ doAnimation.finish = doAnimation;
7945
7946 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return empty || optall.queue === false ?
7947 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this.each( doAnimation ) :
7948 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this.queue( optall.queue, doAnimation );
7949 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
7950 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ stop: function( type, clearQueue, gotoEnd ) {
7951 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var stopQueue = function( hooks ) {
7952 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var stop = hooks.stop;
7953 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ delete hooks.stop;
7954 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ stop( gotoEnd );
7955 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ };
7956
7957 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( typeof type !== "string" ) {
7958 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ gotoEnd = clearQueue;
7959 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ clearQueue = type;
7960 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ type = undefined;
7961 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7962 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( clearQueue && type !== false ) {
7963 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this.queue( type || "fx", [] );
7964 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7965
7966 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return this.each( function() {
7967 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var dequeue = true,
7968 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ index = type != null && type + "queueHooks",
7969 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ timers = jQuery.timers,
7970 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ data = jQuery._data( this );
7971
7972 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( index ) {
7973 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( data[ index ] && data[ index ].stop ) {
7974 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ stopQueue( data[ index ] );
7975 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7976 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } else {
7977 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ for ( index in data ) {
7978 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
7979 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ stopQueue( data[ index ] );
7980 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7981 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7982 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7983
7984 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ for ( index = timers.length; index--; ) {
7985 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( timers[ index ].elem === this &&
7986 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ ( type == null || timers[ index ].queue === type ) ) {
7987
7988 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ timers[ index ].anim.stop( gotoEnd );
7989 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ dequeue = false;
7990 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ timers.splice( index, 1 );
7991 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7992 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
7993
7994 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / start the next in the queue if the last step wasn't forced
7995 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / timers currently will call their complete callbacks, which will dequeue
7996 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / but only if they were gotoEnd
7997 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( dequeue || !gotoEnd ) {
7998 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.dequeue( this, type );
7999 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
8000 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } );
8001 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ },
8002 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ finish: function( type ) {
8003 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( type !== false ) {
8004 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ type = type || "fx";
8005 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
8006 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return this.each( function() {
8007 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var index,
8008 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ data = jQuery._data( this ),
8009 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ queue = data[ type + "queue" ],
8010 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ hooks = data[ type + "queueHooks" ],
8011 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ timers = jQuery.timers,
8012 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ length = queue ? queue.length : 0;
8013
8014 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / enable finishing flag on private data
8015 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ data.finish = true;
8016
8017 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / empty the queue first
8018 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.queue( this, type, [] );
8019
8020 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( hooks && hooks.stop ) {
8021 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ hooks.stop.call( this, true );
8022 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
8023
8024 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / look for any active animations, and finish them
8025 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ for ( index = timers.length; index--; ) {
8026 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
8027 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ timers[ index ].anim.stop( true );
8028 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ timers.splice( index, 1 );
8029 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
8030 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
8031
8032 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / look for any animations in the old queue and finish them
8033 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ for ( index = 0; index < length; index++ ) {
8034 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length; index++ ) { if ( queue[ index ] && queue[ index ].finish ) {
8035 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length; index++ ) { queue[ index ].finish.call( this );
8036 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length; index++ ) { }
8037 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length; index++ ) { }
8038
8039 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< length; index++ ) { / / turn off finishing flag
8040 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ delete data.finish;
8041 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } );
8042 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
8043 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/} );
8044
8045 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) {
8046 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var cssFn = jQuery.fn[ name ];
8047 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.fn[ name ] = function( speed, easing, callback ) {
8048 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return speed == null || typeof speed === "boolean" ?
8049 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ cssFn.apply( this, arguments ) :
8050 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ this.animate( genFx( name, true ), speed, easing, callback );
8051 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ };
8052 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/} );
8053
8054 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;// / Generate shortcuts for custom animations
8055 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/jQuery.each( {
8056 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ slideDown: genFx( "show" ),
8057 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ slideUp: genFx( "hide" ),
8058 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ slideToggle: genFx( "toggle" ),
8059 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ fadeIn: { opacity: "show" },
8060 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ fadeOut: { opacity: "hide" },
8061 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ fadeToggle: { opacity: "toggle" }
8062 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/}, function( name, props ) {
8063 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.fn[ name ] = function( speed, easing, callback ) {
8064 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ return this.animate( props, speed, easing, callback );
8065 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ };
8066 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/} );
8067
8068 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/jQuery.timers = [];
8069 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/jQuery.fx.tick = function() {
8070 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ var timer,
8071 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ timers = jQuery.timers,
8072 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ i = 0;
8073
8074 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ fxNow = jQuery.now();
8075
8076 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ for ( ; i < timers.length; i++ ) {
8077 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< timers.length; i++ ) { timer = timers[ i ];
8078
8079 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/< timers.length; i++ ) { / / Checks the timer has not already been removed
8080 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( !timer() && timers[ i ] === timer ) {
8081 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ timers.splice( i--, 1 );
8082 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
8083 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
8084
8085 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( !timers.length ) {
8086 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.fx.stop();
8087 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
8088 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ fxNow = undefined;
8089 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/};
8090
8091 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/jQuery.fx.timer = function( timer ) {
8092 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.timers.push( timer );
8093 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( timer() ) {
8094 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.fx.start();
8095 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ } else {
8096 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ jQuery.timers.pop();
8097 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
8098 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/};
8099
8100 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/jQuery.fx.interval = 13;
8101
8102 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/jQuery.fx.start = function() {
8103 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ if ( !timerId ) {
8104 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ timerId = window.setInterval( jQuery.fx.tick, jQuery.fx.interval );
8105 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ }
8106 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/};
8107
8108 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/jQuery.fx.stop = function() {
8109 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ window.clearInterval( timerId );
8110 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ timerId = null;
8111 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/};
8112
8113 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/jQuery.fx.speeds = {
8114 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ slow: 600,
8115 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ fast: 200,
8116
8117 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ / / Default speed
8118 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ _default: 400
8119 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/};
8120
8121
8122 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;// / Based off of the plugin by Clint Helfers, with permission.
8123 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;// / http:/ /web.archive.org/ /20100324014747/ //blindsignals.com/index.php/2009/07/jquery-delay/
8124 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8125 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8126 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"fx"
8127
8128 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
8129 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8130 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8131 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8132 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8133 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8134 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8135
8136
8137 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8138 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8139 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"input"
8140 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"div"
8141 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"select"
8142 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"option"
8143
8144 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Setup
8145 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"div"
8146 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"className" "t"
8147 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/" <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"
8148 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"a"
8149
8150 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Windows Web Apps (WWA)
8151 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// `type` must use .setAttribute for WWA (#14901)
8152 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"type" "checkbox"
8153 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8154
8155 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"a"
8156
8157 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// First batch of tests.
8158 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"top:1px"
8159
8160 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Test setAttribute on camelCase class.
8161 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If it works, we need attrFixes when doing get/setAttribute (ie6/7)
8162 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"t"
8163
8164 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Get the style information from getAttribute
8165 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// (IE uses .cssText instead)
8166 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//top/ "style"
8167
8168 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Make sure that URLs aren't manipulated
8169 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// (IE normalizes it by default)
8170 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"href" "/a"
8171
8172 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Check the default checkbox/radio value ("" on WebKit; "on" elsewhere)
8173 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8174
8175 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Make sure that a selected-by-default option has a working selected property.
8176 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
8177 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8178
8179 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Tests for enctype support on a form (#6743)
8180 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"form"
8181
8182 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Make sure that the options inside disabled selects aren't marked as disabled
8183 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// (WebKit marks them as disabled)
8184 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
8185 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8186
8187 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE8 only
8188 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Check if we can trust getAttribute("value")
8189 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"input"
8190 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"value" ""
8191 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"value" ""
8192
8193 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Check if an input maintains its value after becoming a radio
8194 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"t"
8195 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"type" "radio"
8196 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"t"
8197 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8198
8199
8200 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var /\r/
8201 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//[\x20\t\r\n\f]+/
8202
8203 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8204 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8205 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8206 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
8207
8208 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8209 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8210 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8211 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8212
8213 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8214 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8215 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"get" in
8216 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"value"
8217 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8218 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8219 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8220
8221 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8222
8223 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "string"
8224
8225 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// handle most common string cases
8226 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
8227
8228 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// handle cases where value is null/undef or number
8229 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null ""
8230 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8231
8232 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8233 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8234
8235 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8236
8237 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
8238 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8239
8240 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this
8241 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8242 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8243
8244 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8245 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this
8246 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
8247 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8248 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8249
8250 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Treat null/undefined as ""; convert numbers to string
8251 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if null
8252 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
8253 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if "number"
8254 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
8255 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if
8256 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8257 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return null "" ""
8258 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8259 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8260
8261 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this
8262
8263 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If set returns undefined, fall back to normal setting
8264 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "set" in this "value"
8265 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
8266 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8267 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8268 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8269 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8270
8271 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8272 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8273 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8274 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8275 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var "value"
8276 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return null
8277 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8278
8279 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE10-11+
8280 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// option.text throws exceptions (#14686, #14858)
8281 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Strip and collapse whitespace
8282 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
8283 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/" "
8284 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8285 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8286 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8287 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8288 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8289 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8290 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8291 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"select-one"
8292 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
8293 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8294 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8295 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8296 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8297
8298 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Loop through all the selected options
8299 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for
8300 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8301
8302 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// oldIE doesn't update selected after form reset (#2551)
8303 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8304
8305 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Don't return options that are disabled or in a disabled optgroup
8306 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8307 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8308 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"disabled" null
8309 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8310 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"optgroup"
8311
8312 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Get the specific value for the option
8313 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8314
8315 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// We don't need an array for one selects
8316 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8317 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8318 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8319
8320 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Multi-Selects return an array
8321 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8322 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8323 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8324
8325 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8326 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8327
8328 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8329 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8330 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8331 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8332 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8333
8334 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while
8335 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8336
8337 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8338
8339 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE6
8340 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// When new option element is added to select box we need to
8341 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// force reflow of newly added node in order to workaround delay
8342 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// of initialization properties
8343 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/try
8344 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
8345
8346 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/catch
8347
8348 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Will be executed only in IE6
8349 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8350 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8351
8352 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
8353 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
8354 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8355 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8356
8357 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Force browsers to behave consistently when non-matching value is set
8358 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8359 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8360 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8361
8362 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8363 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8364 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8365 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8366 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8367
8368 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Radios and checkboxes getter/setter
8369 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"radio" "checkbox" function
8370 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
8371 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8372 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8373 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8374 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8375 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8376 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8377 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8378 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this function
8379 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "value" null "on"
8380 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8381 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8382 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8383
8384
8385
8386
8387 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8388 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8389 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//^(?:checked|selected)$/
8390 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8391 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8392
8393 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8394 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8395 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
8396 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8397
8398 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8399 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
8400 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
8401 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8402 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8403 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8404
8405 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8406 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8407 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8408 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8409
8410 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Don't get/set attributes on text, comment and attribute nodes
8411 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8412 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8413 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8414
8415 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Fallback to prop when attributes are not supported
8416 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "undefined"
8417 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8418 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8419
8420 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// All attributes are lowercase
8421 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Grab necessary hook if one is defined
8422 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8423 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8424 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8425 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8426 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8427
8428 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8429 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if null
8430 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8431 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8432 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8433
8434 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "set" in
8435 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8436 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8437 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8438
8439 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
8440 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8441 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8442
8443 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "get" in null
8444 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8445 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8446
8447 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8448
8449 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Non-existent attributes return null, we normalize to undefined
8450 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return null
8451 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8452
8453 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8454 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8455 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8456 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "radio"
8457 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"input"
8458
8459 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Setting the type on a radio button after the value resets the value in IE8-9
8460 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Reset value to default in case type is set after value during creation
8461 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8462 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"type"
8463 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8464 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8465 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8466 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8467 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8468 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8469 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8470 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8471
8472 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8473 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8474 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8475 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8476
8477 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8478 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while
8479 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8480
8481 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Boolean attributes get special treatment (#10870)
8482 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8483
8484 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Set corresponding property to false
8485 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8486 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
8487
8488 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE<9
8489 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Also clear defaultChecked/defaultSelected (if appropriate)
8490 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
8491 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"default-"
8492 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
8493 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8494
8495 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// See #9699 for explanation of this approach (setting first, then removal)
8496 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
8497 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
8498 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8499
8500 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8501 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8502 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8503 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8504 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8505
8506 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Hooks for boolean attributes
8507 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8508 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8509 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if false
8510
8511 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Remove boolean attributes when set to false
8512 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8513 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if
8514
8515 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE<8 needs the *property* name
8516 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8517
8518 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
8519
8520 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE<9
8521 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Use defaultChecked and defaultSelected for oldIE
8522 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"default-" true
8523 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8524 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8525 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8526 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8527
8528 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//\w+/ function
8529 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8530
8531 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8532 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8533 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8534 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8535
8536 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Avoid an infinite loop by temporarily removing this function from the getter
8537 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8538 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8539 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
8540 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8541 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
8542 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8543 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8544 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8545 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8546 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
8547 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8548 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8549 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "default-"
8550 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8551 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
8552 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8553 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8554 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8555 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8556
8557 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// fix oldIE attroperties
8558 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8559 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8560 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8561 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "input"
8562
8563 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Does not return so that setAttribute is also used
8564 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8565 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
8566
8567 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Use nodeHook if defined (#1954); otherwise setAttribute is fine
8568 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8569 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8570 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8571 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8572 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8573
8574 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE6/7 do not support getting/setting some attributes with get/setAttribute
8575 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8576
8577 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Use this for any attribute in IE6/7
8578 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// This fixes almost every IE6/7 issue
8579 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8580 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8581
8582 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Set the existing or create a new attribute node
8583 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8584 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8585 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8586 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8587 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8588 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8589
8590 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
8591
8592 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Break association with cloned elements by also using setAttribute (#9646)
8593 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "value"
8594 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8595 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8596 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8597 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8598
8599 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Some attributes are constructed with empty-string values when not defined
8600 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8601 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8602 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8603 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8604 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return ""
8605 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8606 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
8607 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8608 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8609
8610 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Fixing value retrieval on a button requires this module
8611 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8612 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8613 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8614 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8615 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8616 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8617 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8618 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8619 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8620
8621 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Set contenteditable to false on removals(#10429)
8622 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Setting to empty string throws an error as an invalid value
8623 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8624 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8625 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"" false
8626 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8627 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8628
8629 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Set width and height to auto instead of 0 on empty string( Bug #8150 )
8630 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// This is for removals
8631 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"width" "height" function
8632 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8633 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8634 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if ""
8635 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"auto"
8636 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8637 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8638 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8639 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8640 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8641 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8642
8643 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8644 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8645 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8646
8647 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Return undefined in the case of empty string
8648 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Note: IE uppercases css property names, but if we were to .toLowerCase()
8649 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// .cssText, that would destroy case sensitivity in URL's, like in "background"
8650 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8651 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8652 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8653 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return ""
8654 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8655 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8656 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8657
8658
8659
8660
8661 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var /^(?:input|select|textarea|button|object)$/
8662 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//^(?:a|area)$/
8663
8664 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8665 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8666 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
8667 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8668
8669 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8670 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8671 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
8672
8673 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// try/catch handles cases where IE balks (such as removing a property on window)
8674 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/try
8675 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
8676 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
8677 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/catch
8678 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8679 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8680 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8681
8682 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8683 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8684 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8685 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8686
8687 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Don't get/set properties on text, comment and attribute nodes
8688 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8689 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8690 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8691
8692 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8693
8694 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Fix name and attach hooks
8695 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8696 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8697 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8698
8699 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8700 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "set" in
8701 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8702 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8703 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8704
8705 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8706 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8707
8708 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "get" in null
8709 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8710 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8711
8712 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8713 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8714
8715 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8716 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8717 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8718
8719 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// elem.tabIndex doesn't always return the
8720 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// correct value when it hasn't been explicitly set
8721 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
8722 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Use proper attribute retrieval(#12072)
8723 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var "tabindex"
8724
8725 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8726 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/parseInt
8727 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8728 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8729
8730 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8731 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8732 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8733 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8734
8735 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8736 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"for" "htmlFor"
8737 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"class" "className"
8738 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8739 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8740
8741 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Some attributes require a special call on IE
8742 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
8743 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8744
8745 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// href/src property should get the full normalized URL (#10299/#12915)
8746 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"href" "src" function
8747 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8748 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8749 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8750 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8751 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8752 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8753 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8754
8755 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Safari, IE9+
8756 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Accessing the selectedIndex property
8757 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// forces the browser to respect setting selected
8758 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// on the option
8759 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// The getter ensures a default option is selected
8760 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// when in an optgroup
8761 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8762 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8763 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8764 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8765
8766 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8767 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8768
8769 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Make sure that it also works with optgroups, see #5701
8770 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8771 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8772 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8773 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8774 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return null
8775 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8776 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8777 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8778 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8779 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8780
8781 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8782 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8783 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8784 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8785 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8786 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8787 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8788
8789 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8790 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"tabIndex"
8791 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"readOnly"
8792 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"maxLength"
8793 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"cellSpacing"
8794 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"cellPadding"
8795 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"rowSpan"
8796 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"colSpan"
8797 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"useMap"
8798 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"frameBorder"
8799 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"contentEditable"
8800 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8801 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this
8802 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8803
8804 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE6/7 call enctype encoding
8805 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8806 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"encoding"
8807 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8808
8809
8810
8811
8812 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var /[\t\r\n\f]/
8813
8814 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function getClass
8815 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "class" ""
8816 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8817
8818 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8819 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8820 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8821 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8822
8823 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8824 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
8825 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this this
8826 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8827 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8828
8829 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "string"
8830 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8831
8832 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while this
8833 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8834 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8835 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/" " " " " "
8836
8837 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8838 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8839 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while
8840 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if " " " "
8841 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/" "
8842 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8843 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8844
8845 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// only assign if different to avoid unneeded rendering.
8846 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8847 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8848 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"class"
8849 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8850 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8851 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8852 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8853
8854 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
8855 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8856
8857 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8858 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8859 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8860
8861 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8862 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
8863 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this this
8864 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8865 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8866
8867 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8868 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this "class" ""
8869 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8870
8871 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "string"
8872 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8873
8874 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while this
8875 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8876
8877 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// This expression is here for better compressibility (see addClass)
8878 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8879 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/" " " " " "
8880
8881 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8882 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8883 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while
8884
8885 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Remove *all* instances
8886 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while " " " "
8887 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/" " " " " "
8888 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8889 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8890
8891 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Only assign if different to avoid unneeded rendering.
8892 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8893 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8894 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"class"
8895 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8896 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8897 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8898 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8899
8900 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
8901 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8902
8903 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8904 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8905
8906 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "boolean" "string"
8907 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this this
8908 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8909
8910 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8911 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
8912 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
8913 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this
8914 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8915 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8916 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8917 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8918
8919 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
8920 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8921
8922 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "string"
8923
8924 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Toggle individual class names
8925 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8926 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
8927 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8928
8929 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while
8930
8931 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Check each className given, space separated list
8932 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8933 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8934 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
8935 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8936 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8937 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8938
8939 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Toggle whole class name
8940 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if "boolean"
8941 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
8942 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8943
8944 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// store className if set
8945 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this "__className__"
8946 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8947
8948 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If the element has a class name or if we're passed "false",
8949 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// then remove the whole classname (if there was one, the above saved it).
8950 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Otherwise bring back whatever was previously saved (if anything),
8951 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// falling back to the empty string if nothing was stored.
8952 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this "class"
8953 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
8954 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
8955 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this "__className__" ""
8956 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8957 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8958 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8959 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8960
8961 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8962 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
8963 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8964
8965 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/" " " "
8966 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while this
8967 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
8968 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/" " " " " "
8969 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8970 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8971 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return true
8972 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8973 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8974
8975 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return false
8976 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8977 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8978
8979
8980
8981
8982 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Return jQuery for attributes-only inclusion
8983
8984
8985 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"blur focus focusin focusout load resize scroll unload click dblclick "
8986 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave "
8987 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"change select submit keydown keypress keyup error contextmenu" " "
8988 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8989
8990 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Handle event binding
8991 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
8992 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
8993 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this null
8994 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
8995 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8996 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8997
8998 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
8999 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9000 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
9001 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9002 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9003
9004
9005 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9006
9007 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9008
9009 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var /\?/
9010
9011
9012
9013 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var /(,)|(\[|{)|(}|])|"(?:[^"\\\r\n]|\\["\\\/bfnrt]|\\u[\da-fA-F]{4})*"\s*:?|true|false|null|-?(?!0\d)\d+(?:\.\d+|)(?:[eE][+-]?\d+|)/
9014
9015 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9016
9017 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Attempt to parse using the native JSON parser first
9018 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9019
9020 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Android 2.3
9021 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Workaround failure to string-cast null input
9022 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return ""
9023 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9024
9025 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9026 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
9027 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
9028
9029 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Guard against invalid (and possibly dangerous) input by ensuring that nothing remains
9030 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// after removing valid tokens
9031 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return function
9032
9033 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Force termination if we see a misplaced comma
9034 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9035 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9036 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9037
9038 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Perform no more replacements after returning to outermost depth
9039 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9040 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
9041 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9042
9043 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Commas must not follow "[", "{", or ","
9044 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9045
9046 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Determine new depth
9047 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// array/object open ("[" or "{"): depth += true - false (increment)
9048 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// array/object close ("]" or "}"): depth += false - true (decrement)
9049 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// other cases ("," or primitive): depth += true - true (numeric cast)
9050 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9051
9052 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Remove this token
9053 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return ""
9054 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9055 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"return "
9056 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"Invalid JSON: "
9057 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9058
9059
9060 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Cross-browser xml parsing
9061 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9062 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9063 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "string"
9064 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return null
9065 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9066 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/try
9067 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if // Standard
9068 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/new
9069 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"text/xml"
9070 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else // IE
9071 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/new "Microsoft.XMLDOM"
9072 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"false"
9073 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9074 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9075 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/catch
9076 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9077 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9078 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "parsererror"
9079 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"Invalid XML: "
9080 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9081 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
9082 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9083
9084
9085 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9086 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//#.*$/
9087 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//([?&])_=[^&]*/
9088
9089 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE leaves an \r character at EOL
9090 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//^(.*?):[ \t]*([^\r\n]*)\r?$/
9091
9092 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// #7653, #8125, #8152: local protocol detection
9093 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//^(?:about|app|app-storage|.+-extension|file|res|widget):$/
9094 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//^(?:GET|HEAD)$/
9095 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//^\/\//
9096 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/
9097
9098 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//* Prefilters
9099 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
9100 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * 2) These are called:
9101 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * - BEFORE asking for a transport
9102 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * - AFTER param serialization (s.data is a string if s.processData is true)
9103 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * 3) key is the dataType
9104 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * 4) the catchall symbol "*" can be used
9105 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * 5) execution will start with transport dataType and THEN continue down to "*" if needed
9106 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ */
9107 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9108
9109 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//* Transports bindings
9110 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * 1) key is the dataType
9111 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * 2) the catchall symbol "*" can be used
9112 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * 3) selection will start with transport dataType and THEN go to "*" if needed
9113 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ */
9114 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9115
9116 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
9117 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"*/" "*"
9118
9119 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Document location
9120 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9121
9122 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Segment location into parts
9123 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9124
9125 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
9126 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function addToPrefiltersOrTransports
9127
9128 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// dataTypeExpression is optional and defaults to "*"
9129 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return function
9130
9131 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "string"
9132 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9133 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"*"
9134 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9135
9136 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9137 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9138 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9139
9140 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9141
9142 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// For each dataType in the dataTypeExpression
9143 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while
9144
9145 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Prepend if requested
9146 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "+"
9147 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"*"
9148 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9149
9150 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Otherwise append
9151 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
9152 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9153 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9154 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9155 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9156 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9157 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9158
9159 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Base inspection function for prefilters and transports
9160 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function inspectPrefiltersOrTransports
9161
9162 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9163 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9164
9165 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function inspect
9166 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9167 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
9168 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9169 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9170 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "string"
9171 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9172
9173 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9174 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9175 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return false
9176 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if
9177 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
9178 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9179 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9180 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
9181 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9182
9183 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "*" "*"
9184 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9185
9186 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// A special extend for ajax options
9187 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// that takes "flat" options (not to be deep extended)
9188 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Fixes #9887
9189 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function ajaxExtend
9190 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9191 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9192
9193 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
9194 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9195 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9196 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9197 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9198 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9199 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
9200 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9201
9202 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
9203 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9204
9205 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//* Handles responses to an ajax request:
9206 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * - finds the right dataType (mediates between content-type and expected dataType)
9207 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * - returns the corresponding response
9208 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ */
9209 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function ajaxHandleResponses
9210 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9211 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9212 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9213
9214 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Remove auto dataType and get content-type in the process
9215 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while "*"
9216 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9217 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9218 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"Content-Type"
9219 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9220 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9221
9222 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Check if we're dealing with a known content-type
9223 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9224 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
9225 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9226 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9227 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/break
9228 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9229 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9230 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9231
9232 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Check to see if we have a response for the expected dataType
9233 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if in
9234 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9235 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
9236
9237 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Try convertible dataTypes
9238 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
9239 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if " "
9240 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9241 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/break
9242 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9243 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9244 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9245 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9246 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9247
9248 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Or just use first one
9249 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9250 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9251
9252 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If we found a dataType
9253 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// We add the dataType to the list if needed
9254 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// and return the corresponding response
9255 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9256 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9257 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9258 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9259 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
9260 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9261 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9262
9263 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//* Chain conversions given the request and the original response
9264 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * Also sets the responseXXX fields on the jqXHR instance
9265 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ */
9266 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function ajaxConvert
9267 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9268 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9269
9270 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Work with a copy of dataTypes in case we need to modify it for conversion
9271 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9272
9273 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Create converters map with lowercased keys
9274 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9275 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
9276 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9277 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9278 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9279
9280 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9281
9282 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Convert to each sequential dataType
9283 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while
9284
9285 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9286 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9287 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9288
9289 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Apply the dataFilter if provided
9290 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9291 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9292 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9293
9294 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9295 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9296
9297 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9298
9299 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// There's only work to do if current dataType is non-auto
9300 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "*"
9301
9302 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9303
9304 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Convert response if prev dataType is non-auto and differs from current
9305 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if "*"
9306
9307 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Seek a direct converter
9308 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/" " "* "
9309
9310 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If none found, seek a pair
9311 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9312 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
9313
9314 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If conv2 outputs current
9315 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/" "
9316 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9317
9318 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If prev can be converted to accepted input
9319 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/" "
9320 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"* "
9321 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9322
9323 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Condense equivalence converters
9324 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if true
9325 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9326
9327 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Otherwise, insert the intermediate dataType
9328 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if true
9329 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9330 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9331 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9332 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/break
9333 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9334 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9335 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9336 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9337
9338 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Apply converter (if not an equivalence)
9339 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if true
9340
9341 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Unless errors are allowed to bubble, catch and return them
9342 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "throws" // jscs:ignore requireDotNotation
9343 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9344 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
9345 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/try
9346 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9347 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/catch
9348 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
9349 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"parsererror"
9350 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"No conversion from " " to "
9351 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9352 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9353 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9354 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9355 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9356 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9357 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9358
9359 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "success"
9360 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9361
9362 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9363
9364 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Counter for holding the number of active queries
9365 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9366
9367 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Last-Modified header cache for next request
9368 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9369 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9370
9371 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9372 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9373 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"GET"
9374 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9375 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
9376 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
9377 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
9378 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"application/x-www-form-urlencoded; charset=UTF-8"
9379 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//*
9380 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ timeout: 0,
9381 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ data: null,
9382 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ dataType: null,
9383 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ username: null,
9384 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ password: null,
9385 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ cache: null,
9386 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ throws: false,
9387 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ traditional: false,
9388 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ headers: {},
9389 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ */
9390
9391 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9392 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"*"
9393 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"text/plain"
9394 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"text/html"
9395 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"application/xml, text/xml"
9396 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"application/json, text/javascript"
9397 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9398
9399 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9400 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//\bxml\b/
9401 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//\bhtml/
9402 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//\bjson\b/
9403 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9404
9405 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9406 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"responseXML"
9407 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"responseText"
9408 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"responseJSON"
9409 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9410
9411 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Data converters
9412 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Keys separate source (or catchall "*") and destination types with a single space
9413 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9414
9415 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Convert anything to text
9416 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"* text"
9417
9418 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Text to html (true = no transformation)
9419 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"text html" true
9420
9421 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Evaluate text as a json expression
9422 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"text json"
9423
9424 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Parse text as xml
9425 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"text xml"
9426 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9427
9428 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// For options that shouldn't be deep extended:
9429 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// you can add your own custom options here if
9430 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// and when you create one that shouldn't be
9431 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// deep extended (see ajaxExtend)
9432 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9433 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
9434 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
9435 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9436 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9437
9438 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Creates a full fledged settings object into target
9439 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// with both ajaxSettings and settings fields.
9440 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If target is omitted, writes into ajaxSettings.
9441 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9442 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
9443
9444 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Building a settings object
9445 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9446
9447 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Extending ajaxSettings
9448 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9449 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9450
9451 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9452 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9453
9454 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Main method
9455 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9456
9457 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If url is an object, simulate pre-1.5 signature
9458 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "object"
9459 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9460 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9461 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9462
9463 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Force options to be an object
9464 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9465
9466 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9467
9468 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Cross-domain detection vars
9469 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9470
9471 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Loop variable
9472 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9473
9474 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// URL without anti-cache param
9475 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9476
9477 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Response headers as string
9478 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9479
9480 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// timeout handle
9481 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9482
9483 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// To know if global events are to be dispatched
9484 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9485
9486 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9487
9488 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Response headers
9489 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9490
9491 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Create the final options object
9492 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9493
9494 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Callbacks context
9495 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9496
9497 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Context for global events is callbackContext if it is a DOM node or jQuery collection
9498 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9499 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9500 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9501 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9502
9503 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Deferreds
9504 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9505 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"once memory"
9506
9507 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Status-dependent callbacks
9508 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9509
9510 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Headers (they are sent all at once)
9511 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9512 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9513
9514 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// The jqXHR state
9515 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9516
9517 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Default abort message
9518 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"canceled"
9519
9520 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Fake xhr
9521 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9522 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9523
9524 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Builds headers hashtable if needed
9525 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9526 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9527 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9528 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9529 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9530 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while
9531 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9532 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9533 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9534 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9535 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9536 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return null null
9537 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9538
9539 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Raw string
9540 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9541 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return null
9542 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9543
9544 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Caches the header
9545 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9546 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9547 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9548 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9549 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9550 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9551 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
9552 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9553
9554 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Overrides response content-type header
9555 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9556 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9557 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9558 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9559 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
9560 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9561
9562 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Status-dependent callbacks
9563 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9564 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9565 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9566 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9567 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
9568
9569 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Lazy-add the new callback in a way that preserves old ones
9570 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9571 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9572 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
9573
9574 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Execute the appropriate callbacks
9575 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9576 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9577 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9578 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
9579 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9580
9581 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Cancel the request
9582 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9583 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9584 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9585 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9586 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9587 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9588 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
9589 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9590 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9591
9592 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Attach deferreds
9593 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9594 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9595 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9596
9597 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Remove hash character (#7531: and string promotion)
9598 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
9599 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Handle falsy url in the settings object (#10093: consistency with old signature)
9600 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// We also use the url parameter if available
9601 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
9602 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
9603 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"//"
9604
9605 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Alias method option to type as per ticket #12004
9606 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9607
9608 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Extract dataTypes list
9609 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"*" ""
9610
9611 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// A cross-domain request is in order when we have a protocol:host:port mismatch
9612 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if null
9613 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9614 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9615 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9616 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"http:" "80" "443"
9617 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"http:" "80" "443"
9618 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9619 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9620
9621 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Convert data if not already a string
9622 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "string"
9623 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9624 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9625
9626 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Apply prefilters
9627 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9628
9629 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If request was aborted inside a prefilter, stop there
9630 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9631 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
9632 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9633
9634 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// We can fire global events as of now if asked to
9635 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
9636 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9637
9638 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Watch for a new set of requests
9639 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9640 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"ajaxStart"
9641 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9642
9643 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Uppercase the type
9644 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9645
9646 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Determine if request has content
9647 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9648
9649 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Save the URL in case we're toying with the If-Modified-Since
9650 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// and/or If-None-Match header later on
9651 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9652
9653 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// More options handling for requests with no content
9654 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9655
9656 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If data is available, append data to url
9657 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9658 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"&" "?"
9659
9660 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// #9682: remove data so that it's not used in an eventual retry
9661 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9662 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9663
9664 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Add anti-cache in url if needed
9665 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if false
9666 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9667
9668 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If there is already a '_' parameter, set its value
9669 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"$1_="
9670
9671 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Otherwise add one to the end
9672 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"&" "?" "_="
9673 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9674 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9675
9676 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
9677 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9678 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9679 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"If-Modified-Since"
9680 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9681 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9682 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"If-None-Match"
9683 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9684 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9685
9686 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Set the correct header, if data is being sent
9687 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if false
9688 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"Content-Type"
9689 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9690
9691 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Set the Accepts header for the server, depending on the dataType
9692 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9693 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"Accept"
9694 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9695 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9696 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"*" ", " "; q=0.01" ""
9697 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"*"
9698 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9699
9700 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Check for headers option
9701 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
9702 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9703 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9704
9705 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Allow custom headers/mimetypes and early abort
9706 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9707 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
9708
9709 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Abort if not done already and return
9710 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
9711 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9712
9713 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// aborting is no longer a cancellation
9714 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"abort"
9715
9716 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Install callbacks on deferreds
9717 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
9718 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9719 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9720
9721 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Get transport
9722 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9723
9724 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If no transport, we auto-abort
9725 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9726 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"No Transport"
9727 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
9728 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9729
9730 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Send global event
9731 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9732 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"ajaxSend"
9733 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9734
9735 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If request was aborted inside ajaxSend, stop there
9736 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9737 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
9738 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9739
9740 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Timeout
9741 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9742 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9743 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"timeout"
9744 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9745 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9746
9747 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/try
9748 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9749 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9750 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/catch
9751
9752 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Propagate exception as error if not done
9753 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9754 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9755
9756 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Simply rethrow otherwise
9757 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
9758 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/throw
9759 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9760 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9761 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9762
9763 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Callback for when everything is done
9764 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function done
9765 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9766 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9767
9768 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Called once
9769 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9770 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
9771 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9772
9773 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// State is "done" now
9774 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9775
9776 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Clear timeout if it exists
9777 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9778 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9779 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9780
9781 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Dereference transport for early garbage collection
9782 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// (no matter how long the jqXHR object will be used)
9783 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9784
9785 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Cache response headers
9786 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
9787
9788 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Set readyState
9789 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9790
9791 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Determine if successful
9792 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9793
9794 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Get response data
9795 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9796 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9797 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9798
9799 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Convert no matter what (that way responseXXX fields are always set)
9800 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9801
9802 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If successful, handle type chaining
9803 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9804
9805 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
9806 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9807 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"Last-Modified"
9808 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9809 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9810 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9811 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"etag"
9812 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9813 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9814 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9815 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9816
9817 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// if no content
9818 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "HEAD"
9819 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"nocontent"
9820
9821 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// if not modified
9822 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if
9823 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"notmodified"
9824
9825 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If we have data, let's convert it
9826 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
9827 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9828 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9829 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9830 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9831 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9832 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
9833
9834 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// We extract error from statusText
9835 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// then normalize statusText and status for non-aborts
9836 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9837 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9838 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"error"
9839 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9840 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9841 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9842 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9843 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9844
9845 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Set data for the fake xhr object
9846 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9847 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
9848
9849 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Success/Error
9850 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9851 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9852 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
9853 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9854 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9855
9856 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Status-dependent callbacks
9857 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9858 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9859
9860 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9861 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"ajaxSuccess" "ajaxError"
9862 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9863 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9864
9865 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Complete
9866 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9867
9868 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9869 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"ajaxComplete"
9870
9871 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Handle the global AJAX counter
9872 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9873 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"ajaxStop"
9874 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9875 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9876 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9877
9878 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
9879 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9880
9881 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9882 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "json"
9883 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9884
9885 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9886 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "script"
9887 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9888 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9889
9890 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"get" "post" function
9891 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9892
9893 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// shift arguments if data argument was omitted
9894 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9895 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9896 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9897 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9898 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9899
9900 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// The url can be an options object (which then must have .url)
9901 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
9902 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9903 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9904 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9905 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9906 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9907 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9908 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9909 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9910
9911
9912 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9913 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
9914 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9915
9916 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Make this explicit, since user can override this through ajaxSetup (#11264)
9917 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"GET"
9918 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"script"
9919 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
9920 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
9921 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
9922 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"throws" true
9923 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9924 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9925
9926
9927 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9928 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9929 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9930 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
9931 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this
9932 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9933 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9934
9935 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this
9936
9937 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// The elements to wrap the target around
9938 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var this true
9939
9940 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this
9941 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
9942 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9943
9944 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9945 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var this
9946
9947 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while
9948 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9949 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9950
9951 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
9952 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
9953 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9954
9955 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
9956 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9957
9958 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9959 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9960 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
9961 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this
9962 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9963 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9964
9965 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
9966 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var this
9967 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9968
9969 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
9970 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9971
9972 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
9973 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9974 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9975 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9976 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9977
9978 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9979 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
9980
9981 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
9982 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this
9983 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9984 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9985
9986 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
9987 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
9988 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this "body"
9989 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this
9990 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9991 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9992 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9993 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9994
9995
9996 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function getDisplay
9997 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "display"
9998 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
9999
10000 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function filterHidden
10001
10002 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Disconnected elements are considered hidden
10003 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10004 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return true
10005 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10006 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while
10007 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "none" "hidden"
10008 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return true
10009 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10010 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10011 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10012 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return false
10013 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10014
10015 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10016
10017 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Opera <= 12.12
10018 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Opera reports offsetWidths and offsetHeights less than zero on some elements
10019 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10020 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10021 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10022 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10023 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10024
10025 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10026 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10027 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10028
10029
10030
10031
10032 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var /%20/
10033 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//\[\]$/
10034 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//\r?\n/
10035 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//^(?:submit|button|image|reset|file)$/
10036 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//^(?:input|select|textarea|keygen)/
10037
10038 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function buildParams
10039 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10040
10041 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10042
10043 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Serialize array item.
10044 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10045 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10046
10047 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Treat each array item as a scalar.
10048 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10049
10050 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
10051
10052 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Item is non-scalar (array or object), encode its numeric index.
10053 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10054 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"[" "object" null "" "]"
10055 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10056 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10057 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10058 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10059 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10060 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10061
10062 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if "object"
10063
10064 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Serialize object item.
10065 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
10066 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"[" "]"
10067 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10068
10069 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
10070
10071 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Serialize scalar item.
10072 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10073 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10074 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10075
10076 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Serialize an array of form elements or a set of
10077 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// key/values into a query string
10078 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10079 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10080 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10081 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10082
10083 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If value is a function, invoke it and return its value
10084 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null ""
10085 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"="
10086 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10087
10088 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Set traditional to true for jQuery <= 1.3.2 behavior.
10089 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10090 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10091 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10092
10093 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If an array was passed in, assume that it is an array of form elements.
10094 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10095
10096 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Serialize the form elements
10097 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10098 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this this
10099 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10100
10101 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
10102
10103 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If traditional, encode the "old" way (the way 1.3.2 or older
10104 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// did it), otherwise encode params recursively.
10105 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
10106 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10107 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10108 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10109
10110 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Return the resulting serialization
10111 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "&" "+"
10112 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10113
10114 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10115 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10116 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
10117 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10118 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10119 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
10120
10121 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Can add propHook for "elements" to filter or add form elements
10122 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var this "elements"
10123 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
10124 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10125 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10126 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var this
10127
10128 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Use .is(":disabled") so that fieldset[disabled] works
10129 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this this ":disabled"
10130 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
10131 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
10132 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10133 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10134 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var this
10135
10136 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return null
10137 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
10138 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10139 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10140 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "\r\n"
10141 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10142 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"\r\n"
10143 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10144 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10145 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10146
10147
10148 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Create the request object
10149 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// (This is still attached to ajaxSettings for backward compatibility)
10150 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10151
10152 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE6-IE8
10153 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10154
10155 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// XHR cannot access local files, always use ActiveX for that case
10156 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this
10157 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10158 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10159
10160 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE 9-11
10161 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE seems to error on cross-domain PATCH requests when ActiveX XHR
10162 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// is used. In IE 9+ always use the native XHR.
10163 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Note: this condition won't catch Edge as it doesn't define
10164 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// document.documentMode but it also doesn't support ActiveX so it won't
10165 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// reach this code.
10166 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10167 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10168 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10169
10170 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE<9
10171 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// oldIE XHR does not support non-RFC2616 methods (#13240)
10172 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// See http://msdn.microsoft.com/en-us/library/ie/ms536648(v=vs.85).aspx
10173 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// and http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9
10174 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Although this check for six methods instead of eight
10175 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// since IE also does not support "trace" and "connect"
10176 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return /^(get|post|head|put|delete|options)$/ this
10177 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10178 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10179
10180 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// For all other browsers, use the standard XMLHttpRequest object
10181 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10182
10183 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10184 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10185 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10186
10187 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE<10
10188 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Open requests must be manually aborted on unload (#5280)
10189 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// See https://support.microsoft.com/kb/2856746 for more info
10190 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10191 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"onunload" function
10192 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for var in
10193 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
10194 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10195 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10196 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10197
10198 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Determine support properties
10199 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"withCredentials" in
10200 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10201
10202 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Create transport if the browser can provide an xhr
10203 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10204
10205 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10206
10207 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Cross domain only allowed if supported through XMLHttpRequest
10208 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10209
10210 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10211
10212 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10213 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10214 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10215 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10216 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10217
10218 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Open the socket
10219 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10220 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10221 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10222 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10223 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10224 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10225 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10226
10227 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Apply custom fields if provided
10228 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10229 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
10230 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10231 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10232 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10233
10234 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Override mime type if needed
10235 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10236 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10237 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10238
10239 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// X-Requested-With header
10240 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// For cross-domain requests, seeing as conditions for a preflight are
10241 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// akin to a jigsaw puzzle, we simply never set it to be sure.
10242 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// (it can always be set on a per-request basis or even using ajaxSetup)
10243 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// For same-domain requests, won't change header if already provided.
10244 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "X-Requested-With"
10245 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"X-Requested-With" "XMLHttpRequest"
10246 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10247
10248 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Set headers
10249 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/for in
10250
10251 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE<9
10252 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE's ActiveXObject throws a 'Type Mismatch' exception when setting
10253 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// request header to a null-value.
10254 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;///
10255 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// To keep consistent with other XHR implementations, cast the value
10256 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// to string and ignore `undefined`.
10257 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10258 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
10259 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10260 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10261
10262 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Do send the request
10263 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// This may raise an exception which is actually
10264 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// handled in jQuery.ajax (so no try/catch here)
10265 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
10266
10267 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Listener
10268 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10269 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10270
10271 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Was never called and is aborted or complete
10272 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10273
10274 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Clean up
10275 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10276 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10277 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10278
10279 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Abort manually if needed
10280 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10281 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10282 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10283 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10284 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
10285 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10286 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10287
10288 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: IE<10
10289 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Accessing binary-data responseText throws an exception
10290 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// (#11426)
10291 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "string"
10292 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10293 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10294
10295 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Firefox throws an exception when accessing
10296 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// statusText for faulty cross-domain requests
10297 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/try
10298 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10299 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/catch
10300
10301 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// We normalize with Webkit giving an empty statusText
10302 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
10303 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10304
10305 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Filter status for non standard behaviors
10306
10307 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If the request is local and we have data: assume a success
10308 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// (success with no data won't get notified, that's the best we
10309 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// can do given current implementations)
10310 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10311 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10312
10313 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// IE - #1450: sometimes returns 1223 when it should be 204
10314 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if
10315 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10316 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10317 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10318 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10319
10320 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Call complete if needed
10321 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10322 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10323 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10324 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10325
10326 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Do send the request
10327 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// `xhr.send` may raise an exception, but it will be
10328 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// handled in jQuery.ajax (so no try/catch here)
10329 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10330
10331 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If we're in sync mode we fire the callback
10332 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10333 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if
10334
10335 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// (IE6 & IE7) if it's in cache and has been
10336 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// retrieved directly we need to fire the callback
10337 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10338 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
10339
10340 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Register the callback, but delay it in case `xhr.send` throws
10341 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Add to the list of active xhr callbacks
10342 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10343 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10344 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10345
10346 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10347 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10348 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
10349 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10350 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10351 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10352 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10353 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10354 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10355
10356 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Functions to create xhrs
10357 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function createStandardXHR
10358 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/try
10359 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return new
10360 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/catch
10361 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10362
10363 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function createActiveXHR
10364 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/try
10365 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return new "Microsoft.XMLHTTP"
10366 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/catch
10367 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10368
10369
10370
10371
10372 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Install script dataType
10373 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10374 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10375 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"text/javascript, application/javascript, "
10376 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"application/ecmascript, application/x-ecmascript"
10377 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10378 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10379 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//\b(?:java|ecma)script\b/
10380 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10381 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10382 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"text script" function
10383 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10384 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10385 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10386 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10387 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10388
10389 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Handle cache's special case and global
10390 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"script" function
10391 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10392 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
10393 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10394 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10395 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"GET"
10396 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
10397 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10398 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10399
10400 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Bind script tag hack transport
10401 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"script" function
10402
10403 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// This transport only deals with cross domain requests
10404 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10405
10406 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10407 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"head"
10408
10409 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10410
10411 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10412
10413 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"script"
10414
10415 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
10416
10417 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10418 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10419 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10420
10421 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10422
10423 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Attach handlers for all browsers
10424 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10425
10426 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if /loaded|complete/
10427
10428 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Handle memory leak in IE
10429 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
10430
10431 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Remove the script
10432 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10433 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10434 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10435
10436 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Dereference the script
10437 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
10438
10439 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Callback if not abort
10440 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10441 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"success"
10442 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10443 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10444 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10445
10446 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending
10447 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Use native DOM manipulation to avoid our domManip AJAX trickery
10448 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10449 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10450
10451 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10452 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10453 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true
10454 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10455 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10456 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10457 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10458 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10459
10460 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
10461 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10462 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10463 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
10464 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10465 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10466
10467 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10468 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//(=)\?(?=&|$)|\?\?/
10469
10470 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Default jsonp settings
10471 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10472 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"callback"
10473 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10474 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var "_"
10475 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this true
10476 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10477 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10478 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10479
10480 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Detect, normalize options and install callbacks for jsonp requests
10481 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"json jsonp" function
10482
10483 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10484 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
10485 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"url"
10486 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"string"
10487 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/""
10488 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"application/x-www-form-urlencoded"
10489 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"data"
10490 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10491
10492 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Handle iff the expected data type is "jsonp" or we have a parameter to set
10493 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "jsonp"
10494
10495 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Get callback name, remembering preexisting value associated with it
10496 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10497 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10498 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10499
10500 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Insert callback into url or form data
10501 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10502 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"$1"
10503 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if false
10504 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"&" "?" "="
10505 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10506
10507 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Use data converter to retrieve json after script execution
10508 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"script json" function
10509 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10510 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/" was not called"
10511 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10512 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10513 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10514
10515 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// force json dataType
10516 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"json"
10517
10518 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Install callback
10519 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10520 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10521 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10522 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10523
10524 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Clean-up function (fires after converters)
10525 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10526
10527 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If previous value didn't exist - remove it
10528 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10529 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10530
10531 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Otherwise restore preexisting value
10532 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
10533 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10534 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10535
10536 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Save back as free
10537 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10538
10539 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// make sure that re-using the options doesn't screw things around
10540 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10541
10542 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// save the callback name for future use
10543 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10544 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10545
10546 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Call if it was a function and we have a response
10547 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10548 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10549 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10550
10551 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10552 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10553
10554 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Delegate to script
10555 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "script"
10556 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10557 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10558
10559
10560
10561
10562 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// data: string of html
10563 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// context (optional): If specified, the fragment will be created in this context,
10564 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// defaults to document
10565 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// keepScripts (optional): If true, will include scripts passed in the html string
10566 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10567 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "string"
10568 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return null
10569 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10570 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "boolean"
10571 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10572 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
10573 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10574 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10575
10576 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10577 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10578
10579 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Single tag
10580 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10581 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10582 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10583
10584 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10585
10586 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10587 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10588 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10589
10590 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10591 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10592
10593
10594 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Keep a copy of the old load method
10595 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10596
10597 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//**
10598 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * Load a url into a page
10599 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ */
10600 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10601 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "string"
10602 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
10603 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10604
10605 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10606 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
10607 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/" "
10608
10609 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10610 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10611 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10612 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10613
10614 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If it's a function
10615 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10616
10617 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// We assume that it's the callback
10618 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10619 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10620
10621 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Otherwise, build a param string
10622 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else if "object"
10623 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"POST"
10624 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10625
10626 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If we have elements to modify, make the request
10627 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10628 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10629 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10630
10631 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If "type" variable is undefined, then "GET" method will be used.
10632 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Make value of this field explicit since
10633 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// user can override it through ajaxSetup method
10634 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"GET"
10635 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"html"
10636 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10637 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10638
10639 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Save response for use in complete callback
10640 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10641
10642 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10643
10644 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If a selector was specified, locate the right elements in a dummy div
10645 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Exclude scripts to avoid IE 'Permission Denied' errors
10646 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"<div>"
10647
10648 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Otherwise use the full result
10649 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10650
10651 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If the request succeeds, this function gets "data", "status", "jqXHR"
10652 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// but they are ignored because response was set above.
10653 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If it fails, this function gets "jqXHR", "status", "error"
10654 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10655 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10656 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
10657 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10658 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10659 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10660
10661 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
10662 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10663
10664
10665
10666
10667 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Attach a bunch of functions for handling common AJAX events
10668 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10669 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"ajaxStart"
10670 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"ajaxStop"
10671 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"ajaxComplete"
10672 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"ajaxError"
10673 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"ajaxSuccess"
10674 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"ajaxSend"
10675 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10676 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10677 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
10678 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10679 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10680
10681
10682
10683
10684 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10685 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return function
10686 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10687 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10688 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10689
10690
10691
10692
10693
10694 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;//**
10695 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ * Gets a window from an element
10696 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/ */
10697 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function getWindow
10698 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10699 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10700 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10701 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10702 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/false
10703 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10704
10705 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10706 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10707 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10708 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"position"
10709 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10710 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10711
10712 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// set position first, in-case top/left are set even on static elem
10713 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "static"
10714 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"relative"
10715 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10716
10717 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10718 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"top"
10719 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"left"
10720 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"absolute" "fixed"
10721 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"auto"
10722
10723 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// need to be able to calculate position if either top or left
10724 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// is auto and position is either absolute or fixed
10725 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10726 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10727 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10728 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10729 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
10730 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/parseFloat
10731 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/parseFloat
10732 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10733
10734 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10735
10736 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
10737 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10738 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10739
10740 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if null
10741 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10742 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10743 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if null
10744 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10745 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10746
10747 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "using" in
10748 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10749 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
10750 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10751 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10752 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10753 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10754
10755 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10756 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10757 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10758 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10759 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
10760 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this function
10761 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
10762 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10763 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10764
10765 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10766 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10767 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
10768 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10769
10770 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10771 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10772 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10773
10774 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10775
10776 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Make sure it's not a disconnected DOM node
10777 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10778 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10779 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10780
10781 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// If we don't have gBCR, just use 0,0 rather than error
10782 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// BlackBerry 5, iOS 3 (original iPhone)
10783 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "undefined"
10784 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10785 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10786 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10787 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10788 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10789 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10790 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10791 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10792
10793 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10794 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if this
10795 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10796 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10797
10798 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10799 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10800 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
10801
10802 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Fixed elements are offset from window (parentOffset = {top:0, left: 0},
10803 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// because it is its only offset parent
10804 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "position" "fixed"
10805
10806 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// we assume that getBoundingClientRect is available when computed position is fixed
10807 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10808 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
10809
10810 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Get *real* offsetParent
10811 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
10812
10813 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Get correct offsets
10814 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this
10815 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "html"
10816 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10817 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10818
10819 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Add offsetParent borders
10820 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"borderTopWidth" true
10821 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"borderLeftWidth" true
10822 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10823
10824 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Subtract parent offsets and element margins
10825 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// note: when an element has margin: auto the offsetLeft and marginLeft
10826 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// are the same in Safari causing offset.left to incorrectly be 0
10827 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10828 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"marginTop" true
10829 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"marginLeft" true
10830 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10831 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10832
10833 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10834 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
10835 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var this
10836
10837 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/while "html"
10838 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"position" "static"
10839 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10840 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10841 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10842 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10843 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10844 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10845
10846 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Create scrollLeft and scrollTop methods
10847 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"pageXOffset" "pageYOffset" function
10848 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var /Y/
10849
10850 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10851 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
10852 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10853
10854 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10855 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return in
10856 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10857 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10858 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10859
10860 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10861 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10862 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10863 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10864 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10865
10866 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/else
10867 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10868 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10869 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
10870 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10871 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10872
10873 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Support: Safari<7-8+, Chrome<37-44+
10874 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Add the top/left cssHooks using jQuery.fn.position
10875 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
10876 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// getComputedStyle returns percent when specified for top/left/bottom/right
10877 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// rather than make the css module depend on the offset module, we just check for it here
10878 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"top" "left" function
10879 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10880 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10881 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10882 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10883
10884 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// if curCSS returns percentage, fallback to offset
10885 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10886 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"px"
10887 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10888 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10889 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10890 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10891 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10892
10893
10894 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
10895 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"height" "width" function
10896 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"inner" "" "outer"
10897 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10898
10899 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// margin is only for outerHeight, outerWidth
10900 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10901 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var "boolean"
10902 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/true true "margin" "border"
10903
10904 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this function
10905 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10906
10907 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10908
10909 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
10910 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// isn't a whole lot we can do. See pull request at this URL for discussion:
10911 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// https://github.com/jquery/jquery/pull/764
10912 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return "client"
10913 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10914
10915 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Get document width or height
10916 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
10917 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10918
10919 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
10920 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// whichever is greatest
10921 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// unfortunately, this causes bug #3838 in IE6/8 only,
10922 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// but there is currently no good, small way to fix it.
10923 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return Math
10924 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"scroll" "scroll"
10925 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"offset" "offset"
10926 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"client"
10927 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10928 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10929
10930 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10931
10932 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Get width or height on the element, requesting but not forcing parseFloat
10933 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10934
10935 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Set width or height on the element
10936 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10937 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/null
10938 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10939 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10940 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10941
10942
10943 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10944
10945 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10946 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this null
10947 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10948 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10949 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this null
10950 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10951
10952 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10953 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
10954 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10955 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10956
10957 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// ( namespace ) or ( selector, types [, fn] )
10958 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10959 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this "**"
10960 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/this "**"
10961 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10962 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10963
10964 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// The number of elements contained in the matched element set
10965 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
10966 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return this
10967 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10968
10969 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10970
10971
10972
10973
10974 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Register as a named AMD module, since jQuery can be concatenated with other
10975 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// files that may use define, but not via a proper concatenation script that
10976 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// understands anonymous AMD modules. A named AMD is safest and most robust
10977 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// way to register. Lowercase jquery is used because AMD module names are
10978 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// derived from file names, and jQuery is normally delivered in a lowercase
10979 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// file name. Do this after creating the global so that if an AMD module wants
10980 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// to call noConflict to hide this version of jQuery, it will work.
10981
10982 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Note that for maximum portability, libraries that are not jQuery should
10983 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// declare themselves as anonymous modules, and avoid setting a global if an
10984 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// AMD loader is present. jQuery is a special case. For more information, see
10985 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
10986
10987 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if "function"
10988 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/"jquery" function
10989 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
10990 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10991 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10992
10993
10994
10995 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/var
10996
10997 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Map over jQuery in case of overwrite
10998 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
10999
11000 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Map over the $ in case of overwrite
11001 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
11002
11003 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/function
11004 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
11005 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
11006 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
11007
11008 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
11009 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
11010 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
11011
11012 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
11013 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
11014
11015 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// Expose jQuery and $ identifiers, even in
11016 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// AMD (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
11017 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/// and CommonJS for browser emulators (#13566)
11018 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/if
11019 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
11020 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/
11021
11022 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/return
11023 <([\w-]+)\s*\/?><\/\1><[\w\W]+><([\w:-]+)/<|&#?\w+;/