https://umweltprobenbank.de/assets/jquery_global-a2760496.js

31// node_modules/jquery/dist/jquery.js
32var require_jquery = __commonJS({
33  "node_modules/jquery/dist/jquery.js"(exports, module) {
34    (function(global, factory) {
35      "use strict";
36      if (typeof module === "object" && typeof module.exports === "object") {
37        module.exports = global.document ? factory(global, true) : function(w) {
38          if (!w.document) {
39            throw new Error("jQuery requires a window with a document");
40          }
41          return factory(w);
42        };
43      } else {
44        factory(global);
45      }
46    })(typeof window !== "undefined" ? window : exports, function(window2, noGlobal) {
47      "use strict";
48      var arr = [];
49      var getProto = Object.getPrototypeOf;
50      var slice = arr.slice;
51      var flat = arr.flat ? function(array) {
52        return arr.flat.call(array);
53      } : function(array) {
54        return arr.concat.apply([], array);
55      };
56      var push = arr.push;
57      var indexOf = arr.indexOf;
58      var class2type = {};
59      var toString = class2type.toString;
60      var hasOwn = class2type.hasOwnProperty;
61      var fnToString = hasOwn.toString;
62      var ObjectFunctionString = fnToString.call(Object);
63      var support = {};
64      var isFunction = function isFunction2(obj) {
65        return typeof obj === "function" && typeof obj.nodeType !== "number" && typeof obj.item !== "function";
66      };
67      var isWindow = function isWindow2(obj) {
68        return obj != null && obj === obj.window;
69      };
70      var document2 = window2.document;
71      var preservedScriptAttributes = {
72        type: true,
73        src: true,
74        nonce: true,
75        noModule: true
76      };
77      function DOMEval(code, node, doc) {
78        doc = doc || document2;
79        var i, val, script = doc.createElement("script");
80        script.text = code;
81        if (node) {
82          for (i in preservedScriptAttributes) {
83            val = node[i] || node.getAttribute && node.getAttribute(i);
84            if (val) {
85              script.setAttribute(i, val);
86            }
87          }
88        }
89        doc.head.appendChild(script).parentNode.removeChild(script);
90      }
91      function toType(obj) {
92        if (obj == null) {
93          return obj + "";
94        }
95        return typeof obj === "object" || typeof obj === "function" ? class2type[toString.call(obj)] || "object" : typeof obj;
96      }
97      var version = "3.7.1", rhtmlSuffix = /HTML$/i, jQuery3 = function(selector, context) {
98        return new jQuery3.fn.init(selector, context);
99      };
100      jQuery3.fn = jQuery3.prototype = {
101        // The current version of jQuery being used
102        jquery: version,
103        constructor: jQuery3,
104        // The default length of a jQuery object is 0
105        length: 0,
106        toArray: function() {
107          return slice.call(this);
108        },
109        // Get the Nth element in the matched element set OR
110        // Get the whole matched element set as a clean array
111        get: function(num) {
112          if (num == null) {
113            return slice.call(this);
114          }
115          return num < 0 ? this[num + this.length] : this[num];
116        },
117        // Take an array of elements and push it onto the stack
118        // (returning the new matched element set)
119        pushStack: function(elems) {
120          var ret = jQuery3.merge(this.constructor(), elems);
121          ret.prevObject = this;
122          return ret;
123        },
124        // Execute a callback for every element in the matched set.
125        each: function(callback) {
126          return jQuery3.each(this, callback);
127        },
128        map: function(callback) {
129          return this.pushStack(jQuery3.map(this, function(elem, i) {
130            return callback.call(elem, i, elem);
131          }));
132        },
133        slice: function() {
134          return this.pushStack(slice.apply(this, arguments));
135        },
136        first: function() {
137          return this.eq(0);
138        },
139        last: function() {
140          return this.eq(-1);
141        },
142        even: function() {
143          return this.pushStack(jQuery3.grep(this, function(_elem, i) {
144            return (i + 1) % 2;
145          }));
146        },
147        odd: function() {
148          return this.pushStack(jQuery3.grep(this, function(_elem, i) {
149            return i % 2;
150          }));
151        },
152        eq: function(i) {
153          var len = this.length, j = +i + (i < 0 ? len : 0);
154          return this.pushStack(j >= 0 && j < len ? [this[j]] : []);
155        },
156        end: function() {
157          return this.prevObject || this.constructor();
158        },
159        // For internal use only.
160        // Behaves like an Array's method, not like a jQuery method.
161        push,
162        sort: arr.sort,
163        splice: arr.splice
164      };
165      jQuery3.extend = jQuery3.fn.extend = function() {
166        var options, name, src, copy, copyIsArray, clone, target = arguments[0] || {}, i = 1, length = arguments.length, deep = false;
167        if (typeof target === "boolean") {
168          deep = target;
169          target = arguments[i] || {};
170          i++;
171        }
172        if (typeof target !== "object" && !isFunction(target)) {
173          target = {};
174        }
175        if (i === length) {
176          target = this;
177          i--;
178        }
179        for (; i < length; i++) {
180          if ((options = arguments[i]) != null) {
181            for (name in options) {
182              copy = options[name];
183              if (name === "__proto__" || target === copy) {
184                continue;
185              }
186              if (deep && copy && (jQuery3.isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {
187                src = target[name];
188                if (copyIsArray && !Array.isArray(src)) {
189                  clone = [];
190                } else if (!copyIsArray && !jQuery3.isPlainObject(src)) {
191                  clone = {};
192                } else {
193                  clone = src;
194                }
195                copyIsArray = false;
196                target[name] = jQuery3.extend(deep, clone, copy);
197              } else if (copy !== void 0) {
198                target[name] = copy;
199              }
200            }
201          }
202        }
203        return target;
204      };
205      jQuery3.extend({
206        // Unique for each copy of jQuery on the page
207        expando: "jQuery" + (version + Math.random()).replace(/\D/g, ""),
208        // Assume jQuery is ready without the ready module
209        isReady: true,
210        error: function(msg) {
211          throw new Error(msg);
212        },
213        noop: function() {
214        },
215        isPlainObject: function(obj) {
216          var proto, Ctor;
217          if (!obj || toString.call(obj) !== "[object Object]") {
218            return false;
219          }
220          proto = getProto(obj);
221          if (!proto) {
222            return true;
223          }
224          Ctor = hasOwn.call(proto, "constructor") && proto.constructor;
225          return typeof Ctor === "function" && fnToString.call(Ctor) === ObjectFunctionString;
226        },
227        isEmptyObject: function(obj) {
228          var name;
229          for (name in obj) {
230            return false;
231          }
232          return true;
233        },
234        // Evaluates a script in a provided context; falls back to the global one
235        // if not specified.
236        globalEval: function(code, options, doc) {
237          DOMEval(code, { nonce: options && options.nonce }, doc);
238        },
239        each: function(obj, callback) {
240          var length, i = 0;
241          if (isArrayLike(obj)) {
242            length = obj.length;
243            for (; i < length; i++) {
244              if (callback.call(obj[i], i, obj[i]) === false) {
245                break;
246              }
247            }
248          } else {
249            for (i in obj) {
250              if (callback.call(obj[i], i, obj[i]) === false) {
251                break;
252              }
253            }
254          }
255          return obj;
256        },
257        // Retrieve the text value of an array of DOM nodes
258        text: function(elem) {
259          var node, ret = "", i = 0, nodeType = elem.nodeType;
260          if (!nodeType) {
261            while (node = elem[i++]) {
262              ret += jQuery3.text(node);
263            }
264          }
265          if (nodeType === 1 || nodeType === 11) {
266            return elem.textContent;
267          }
268          if (nodeType === 9) {
269            return elem.documentElement.textContent;
270          }
271          if (nodeType === 3 || nodeType === 4) {
272            return elem.nodeValue;
273          }
274          return ret;
275        },
276        // results is for internal usage only
277        makeArray: function(arr2, results) {
278          var ret = results || [];
279          if (arr2 != null) {
280            if (isArrayLike(Object(arr2))) {
281              jQuery3.merge(
282                ret,
283                typeof arr2 === "string" ? [arr2] : arr2
284              );
285            } else {
286              push.call(ret, arr2);
287            }
288          }
289          return ret;
290        },
291        inArray: function(elem, arr2, i) {
292          return arr2 == null ? -1 : indexOf.call(arr2, elem, i);
293        },
294        isXMLDoc: function(elem) {
295          var namespace = elem && elem.namespaceURI, docElem = elem && (elem.ownerDocument || elem).documentElement;
296          return !rhtmlSuffix.test(namespace || docElem && docElem.nodeName || "HTML");
297        },
298        // Support: Android <=4.0 only, PhantomJS 1 only
299        // push.apply(_, arraylike) throws on ancient WebKit
300        merge: function(first, second) {
301          var len = +second.length, j = 0, i = first.length;
302          for (; j < len; j++) {
303            first[i++] = second[j];
304          }
305          first.length = i;
306          return first;
307        },
308        grep: function(elems, callback, invert) {
309          var callbackInverse, matches = [], i = 0, length = elems.length, callbackExpect = !invert;
310          for (; i < length; i++) {
311            callbackInverse = !callback(elems[i], i);
312            if (callbackInverse !== callbackExpect) {
313              matches.push(elems[i]);
314            }
315          }
316          return matches;
317        },
318        // arg is for internal usage only
319        map: function(elems, callback, arg) {
320          var length, value, i = 0, ret = [];
321          if (isArrayLike(elems)) {
322            length = elems.length;
323            for (; i < length; i++) {
324              value = callback(elems[i], i, arg);
325              if (value != null) {
326                ret.push(value);
327              }
328            }
329          } else {
330            for (i in elems) {
331              value = callback(elems[i], i, arg);
332              if (value != null) {
333                ret.push(value);
334              }
335            }
336          }
337          return flat(ret);
338        },
339        // A global GUID counter for objects
340        guid: 1,
341        // jQuery.support is not used in Core but other projects attach their
342        // properties to it so it needs to exist.
343        support
344      });
345      if (typeof Symbol === "function") {
346        jQuery3.fn[Symbol.iterator] = arr[Symbol.iterator];
347      }
348      jQuery3.each(
349        "Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),
350        function(_i, name) {
351          class2type["[object " + name + "]"] = name.toLowerCase();
352        }
353      );
354      function isArrayLike(obj) {
355        var length = !!obj && "length" in obj && obj.length, type = toType(obj);
356        if (isFunction(obj) || isWindow(obj)) {
357          return false;
358        }
359        return type === "array" || length === 0 || typeof length === "number" && length > 0 && length - 1 in obj;
360      }
361      function nodeName(elem, name) {
362        return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
363      }
364      var pop = arr.pop;
365      var sort = arr.sort;
366      var splice = arr.splice;
367      var whitespace = "[\\x20\\t\\r\\n\\f]";
368      var rtrimCSS = new RegExp(
369        "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$",
370        "g"
371      );
372      jQuery3.contains = function(a, b) {
373        var bup = b && b.parentNode;
374        return a === bup || !!(bup && bup.nodeType === 1 && // Support: IE 9 - 11+
375        // IE doesn't have `contains` on SVG.
376        (a.contains ? a.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16));
377      };
378      var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g;
379      function fcssescape(ch, asCodePoint) {
380        if (asCodePoint) {
381          if (ch === "\0") {
382            return "\uFFFD";
383          }
384          return ch.slice(0, -1) + "\\" + ch.charCodeAt(ch.length - 1).toString(16) + " ";
385        }
386        return "\\" + ch;
387      }
388      jQuery3.escapeSelector = function(sel) {
389        return (sel + "").replace(rcssescape, fcssescape);
390      };
391      var preferredDoc = document2, pushNative = push;
392      (function() {
393        var i, Expr, outermostContext, sortInput, hasDuplicate, push2 = pushNative, document3, documentElement2, documentIsHTML, rbuggyQSA, matches, expando = jQuery3.expando, dirruns = 0, done = 0, classCache = createCache(), tokenCache = createCache(), compilerCache = createCache(), nonnativeSelectorCache = createCache(), sortOrder = function(a, b) {
394          if (a === b) {
395            hasDuplicate = true;
396          }
397          return 0;
398        }, booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+", attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + // Operator (capture 2)
399        "*([*^$|!~]?=)" + whitespace + // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
400        `*(?:'((?:\\\\.|[^\\\\'])*)'|"((?:\\\\.|[^\\\\"])*)"|(` + identifier + "))|)" + whitespace + "*\\]", pseudos = ":(" + identifier + `)(?:\\((('((?:\\\\.|[^\\\\'])*)'|"((?:\\\\.|[^\\\\"])*)")|((?:\\\\.|[^\\\\()[\\]]|` + attributes + ")*)|.*)\\)|)", rwhitespace = new RegExp(whitespace + "+", "g"), rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"), rleadingCombinator = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"), rdescend = new RegExp(whitespace + "|>"), rpseudo = new RegExp(pseudos), ridentifier = new RegExp("^" + identifier + "$"), matchExpr = {
401          ID: new RegExp("^#(" + identifier + ")"),
402          CLASS: new RegExp("^\\.(" + identifier + ")"),
403          TAG: new RegExp("^(" + identifier + "|[*])"),
404          ATTR: new RegExp("^" + attributes),
405          PSEUDO: new RegExp("^" + pseudos),
406          CHILD: new RegExp(
407            "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)",
408            "i"
409          ),
410          bool: new RegExp("^(?:" + booleans + ")$", "i"),
411          // For use in libraries implementing .is()
412          // We use this for POS matching in `select`
413          needsContext: new RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i")
414        }, rinputs = /^(?:input|select|textarea|button)$/i, rheader = /^h\d$/i, rquickExpr2 = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, rsibling = /[+~]/, runescape = new RegExp("\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g"), funescape = function(escape, nonHex) {
415          var high = "0x" + escape.slice(1) - 65536;
416          if (nonHex) {
417            return nonHex;
418          }
419          return high < 0 ? String.fromCharCode(high + 65536) : String.fromCharCode(high >> 10 | 55296, high & 1023 | 56320);
420        }, unloadHandler = function() {
421          setDocument();
422        }, inDisabledFieldset = addCombinator(
423          function(elem) {
424            return elem.disabled === true && nodeName(elem, "fieldset");
425          },
426          { dir: "parentNode", next: "legend" }
427        );
428        function safeActiveElement() {
429          try {
430            return document3.activeElement;
431          } catch (err) {
432          }
433        }
434        try {
435          push2.apply(
436            arr = slice.call(preferredDoc.childNodes),
437            preferredDoc.childNodes
438          );
439          arr[preferredDoc.childNodes.length].nodeType;
440        } catch (e) {
441          push2 = {
442            apply: function(target, els) {
443              pushNative.apply(target, slice.call(els));
444            },
445            call: function(target) {
446              pushNative.apply(target, slice.call(arguments, 1));
447            }
448          };
449        }
450        function find(selector, context, results, seed) {
451          var m, i2, elem, nid, match, groups, newSelector, newContext = context && context.ownerDocument, nodeType = context ? context.nodeType : 9;
452          results = results || [];
453          if (typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11) {
454            return results;
455          }
456          if (!seed) {
457            setDocument(context);
458            context = context || document3;
459            if (documentIsHTML) {
460              if (nodeType !== 11 && (match = rquickExpr2.exec(selector))) {
461                if (m = match[1]) {
462                  if (nodeType === 9) {
463                    if (elem = context.getElementById(m)) {
464                      if (elem.id === m) {
465                        push2.call(results, elem);
466                        return results;
467                      }
468                    } else {
469                      return results;
470                    }
471                  } else {
472                    if (newContext && (elem = newContext.getElementById(m)) && find.contains(context, elem) && elem.id === m) {
473                      push2.call(results, elem);
474                      return results;
475                    }
476                  }
477                } else if (match[2]) {
478                  push2.apply(results, context.getElementsByTagName(selector));
479                  return results;
480                } else if ((m = match[3]) && context.getElementsByClassName) {
481                  push2.apply(results, context.getElementsByClassName(m));
482                  return results;
483                }
484              }
485              if (!nonnativeSelectorCache[selector + " "] && (!rbuggyQSA || !rbuggyQSA.test(selector))) {
486                newSelector = selector;
487                newContext = context;
488                if (nodeType === 1 && (rdescend.test(selector) || rleadingCombinator.test(selector))) {
489                  newContext = rsibling.test(selector) && testContext(context.parentNode) || context;
490                  if (newContext != context || !support.scope) {
491                    if (nid = context.getAttribute("id")) {
492                      nid = jQuery3.escapeSelector(nid);
493                    } else {
494                      context.setAttribute("id", nid = expando);
495                    }
496                  }
497                  groups = tokenize(selector);
498                  i2 = groups.length;
499                  while (i2--) {
500                    groups[i2] = (nid ? "#" + nid : ":scope") + " " + toSelector(groups[i2]);
501                  }
502                  newSelector = groups.join(",");
503                }
504                try {
505                  push2.apply(
506                    results,
507                    newContext.querySelectorAll(newSelector)
508                  );
509                  return results;
510                } catch (qsaError) {
511                  nonnativeSelectorCache(selector, true);
512                } finally {
513                  if (nid === expando) {
514                    context.removeAttribute("id");
515                  }
516                }
517              }
518            }
519          }
520          return select(selector.replace(rtrimCSS, "$1"), context, results, seed);
521        }
522        function createCache() {
523          var keys = [];
524          function cache(key, value) {
525            if (keys.push(key + " ") > Expr.cacheLength) {
526              delete cache[keys.shift()];
527            }
528            return cache[key + " "] = value;
529          }
530          return cache;
531        }
532        function markFunction(fn) {
533          fn[expando] = true;
534          return fn;
535        }
536        function assert(fn) {
537          var el = document3.createElement("fieldset");
538          try {
539            return !!fn(el);
540          } catch (e) {
541            return false;
542          } finally {
543            if (el.parentNode) {
544              el.parentNode.removeChild(el);
545            }
546            el = null;
547          }
548        }
549        function createInputPseudo(type) {
550          return function(elem) {
551            return nodeName(elem, "input") && elem.type === type;
552          };
553        }
554        function createButtonPseudo(type) {
555          return function(elem) {
556            return (nodeName(elem, "input") || nodeName(elem, "button")) && elem.type === type;
557          };
558        }
559        function createDisabledPseudo(disabled) {
560          return function(elem) {
561            if ("form" in elem) {
562              if (elem.parentNode && elem.disabled === false) {
563                if ("label" in elem) {
564                  if ("label" in elem.parentNode) {
565                    return elem.parentNode.disabled === disabled;
566                  } else {
567                    return elem.disabled === disabled;
568                  }
569                }
570                return elem.isDisabled === disabled || // Where there is no isDisabled, check manually
571                elem.isDisabled !== !disabled && inDisabledFieldset(elem) === disabled;
572              }
573              return elem.disabled === disabled;
574            } else if ("label" in elem) {
575              return elem.disabled === disabled;
576            }
577            return false;
578          };
579        }
580        function createPositionalPseudo(fn) {
581          return markFunction(function(argument) {
582            argument = +argument;
583            return markFunction(function(seed, matches2) {
584              var j, matchIndexes = fn([], seed.length, argument), i2 = matchIndexes.length;
585              while (i2--) {
586                if (seed[j = matchIndexes[i2]]) {
587                  seed[j] = !(matches2[j] = seed[j]);
588                }
589              }
590            });
591          });
592        }
593        function testContext(context) {
594          return context && typeof context.getElementsByTagName !== "undefined" && context;
595        }
596        function setDocument(node) {
597          var subWindow, doc = node ? node.ownerDocument || node : preferredDoc;
598          if (doc == document3 || doc.nodeType !== 9 || !doc.documentElement) {
599            return document3;
600          }
601          document3 = doc;
602          documentElement2 = document3.documentElement;
603          documentIsHTML = !jQuery3.isXMLDoc(document3);
604          matches = documentElement2.matches || documentElement2.webkitMatchesSelector || documentElement2.msMatchesSelector;
605          if (documentElement2.msMatchesSelector && // Support: IE 11+, Edge 17 - 18+
606          // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
607          // two documents; shallow comparisons work.
608          // eslint-disable-next-line eqeqeq
609          preferredDoc != document3 && (subWindow = document3.defaultView) && subWindow.top !== subWindow) {
610            subWindow.addEventListener("unload", unloadHandler);
611          }
612          support.getById = assert(function(el) {
613            documentElement2.appendChild(el).id = jQuery3.expando;
614            return !document3.getElementsByName || !document3.getElementsByName(jQuery3.expando).length;
615          });
616          support.disconnectedMatch = assert(function(el) {
617            return matches.call(el, "*");
618          });
619          support.scope = assert(function() {
620            return document3.querySelectorAll(":scope");
621          });
622          support.cssHas = assert(function() {
623            try {
624              document3.querySelector(":has(*,:jqfake)");
625              return false;
626            } catch (e) {
627              return true;
628            }
629          });
630          if (support.getById) {
631            Expr.filter.ID = function(id) {
632              var attrId = id.replace(runescape, funescape);
633              return function(elem) {
634                return elem.getAttribute("id") === attrId;
635              };
636            };
637            Expr.find.ID = function(id, context) {
638              if (typeof context.getElementById !== "undefined" && documentIsHTML) {
639                var elem = context.getElementById(id);
640                return elem ? [elem] : [];
641              }
642            };
643          } else {
644            Expr.filter.ID = function(id) {
645              var attrId = id.replace(runescape, funescape);
646              return function(elem) {
647                var node2 = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
648                return node2 && node2.value === attrId;
649              };
650            };
651            Expr.find.ID = function(id, context) {
652              if (typeof context.getElementById !== "undefined" && documentIsHTML) {
653                var node2, i2, elems, elem = context.getElementById(id);
654                if (elem) {
655                  node2 = elem.getAttributeNode("id");
656                  if (node2 && node2.value === id) {
657                    return [elem];
658                  }
659                  elems = context.getElementsByName(id);
660                  i2 = 0;
661                  while (elem = elems[i2++]) {
662                    node2 = elem.getAttributeNode("id");
663                    if (node2 && node2.value === id) {
664                      return [elem];
665                    }
666                  }
667                }
668                return [];
669              }
670            };
671          }
672          Expr.find.TAG = function(tag, context) {
673            if (typeof context.getElementsByTagName !== "undefined") {
674              return context.getElementsByTagName(tag);
675            } else {
676              return context.querySelectorAll(tag);
677            }
678          };
679          Expr.find.CLASS = function(className, context) {
680            if (typeof context.getElementsByClassName !== "undefined" && documentIsHTML) {
681              return context.getElementsByClassName(className);
682            }
683          };
684          rbuggyQSA = [];
685          assert(function(el) {
686            var input;
687            documentElement2.appendChild(el).innerHTML = "<a id='" + expando + "' href='' disabled='disabled'></a><select id='" + expando + "-\r\\' disabled='disabled'><option selected=''></option></select>";
688            if (!el.querySelectorAll("[selected]").length) {
689              rbuggyQSA.push("\\[" + whitespace + "*(?:value|" + booleans + ")");
690            }
691            if (!el.querySelectorAll("[id~=" + expando + "-]").length) {
692              rbuggyQSA.push("~=");
693            }
694            if (!el.querySelectorAll("a#" + expando + "+*").length) {
695              rbuggyQSA.push(".#.+[+~]");
696            }
697            if (!el.querySelectorAll(":checked").length) {
698              rbuggyQSA.push(":checked");
699            }
700            input = document3.createElement("input");
701            input.setAttribute("type", "hidden");
702            el.appendChild(input).setAttribute("name", "D");
703            documentElement2.appendChild(el).disabled = true;
704            if (el.querySelectorAll(":disabled").length !== 2) {
705              rbuggyQSA.push(":enabled", ":disabled");
706            }
707            input = document3.createElement("input");
708            input.setAttribute("name", "");
709            el.appendChild(input);
710            if (!el.querySelectorAll("[name='']").length) {
711              rbuggyQSA.push("\\[" + whitespace + "*name" + whitespace + "*=" + whitespace + `*(?:''|"")`);
712            }
713          });
714          if (!support.cssHas) {
715            rbuggyQSA.push(":has");
716          }
717          rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|"));
718          sortOrder = function(a, b) {
719            if (a === b) {
720              hasDuplicate = true;
721              return 0;
722            }
723            var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
724            if (compare) {
725              return compare;
726            }
727            compare = (a.ownerDocument || a) == (b.ownerDocument || b) ? a.compareDocumentPosition(b) : (
728              // Otherwise we know they are disconnected
729              1
730            );
731            if (compare & 1 || !support.sortDetached && b.compareDocumentPosition(a) === compare) {
732              if (a === document3 || a.ownerDocument == preferredDoc && find.contains(preferredDoc, a)) {
733                return -1;
734              }
735              if (b === document3 || b.ownerDocument == preferredDoc && find.contains(preferredDoc, b)) {
736                return 1;
737              }
738              return sortInput ? indexOf.call(sortInput, a) - indexOf.call(sortInput, b) : 0;
739            }
740            return compare & 4 ? -1 : 1;
741          };
742          return document3;
743        }
744        find.matches = function(expr, elements) {
745          return find(expr, null, null, elements);
746        };
747        find.matchesSelector = function(elem, expr) {
748          setDocument(elem);
749          if (documentIsHTML && !nonnativeSelectorCache[expr + " "] && (!rbuggyQSA || !rbuggyQSA.test(expr))) {
750            try {
751              var ret = matches.call(elem, expr);
752              if (ret || support.disconnectedMatch || // As well, disconnected nodes are said to be in a document
753              // fragment in IE 9
754              elem.document && elem.document.nodeType !== 11) {
755                return ret;
756              }
757            } catch (e) {
758              nonnativeSelectorCache(expr, true);
759            }
760          }
761          return find(expr, document3, null, [elem]).length > 0;
762        };
763        find.contains = function(context, elem) {
764          if ((context.ownerDocument || context) != document3) {
765            setDocument(context);
766          }
767          return jQuery3.contains(context, elem);
768        };
769        find.attr = function(elem, name) {
770          if ((elem.ownerDocument || elem) != document3) {
771            setDocument(elem);
772          }
773          var fn = Expr.attrHandle[name.toLowerCase()], val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : void 0;
774          if (val !== void 0) {
775            return val;
776          }
777          return elem.getAttribute(name);
778        };
779        find.error = function(msg) {
780          throw new Error("Syntax error, unrecognized expression: " + msg);
781        };
782        jQuery3.uniqueSort = function(results) {
783          var elem, duplicates = [], j = 0, i2 = 0;
784          hasDuplicate = !support.sortStable;
785          sortInput = !support.sortStable && slice.call(results, 0);
786          sort.call(results, sortOrder);
787          if (hasDuplicate) {
788            while (elem = results[i2++]) {
789              if (elem === results[i2]) {
790                j = duplicates.push(i2);
791              }
792            }
793            while (j--) {
794              splice.call(results, duplicates[j], 1);
795            }
796          }
797          sortInput = null;
798          return results;
799        };
800        jQuery3.fn.uniqueSort = function() {
801          return this.pushStack(jQuery3.uniqueSort(slice.apply(this)));
802        };
803        Expr = jQuery3.expr = {
804          // Can be adjusted by the user
805          cacheLength: 50,
806          createPseudo: markFunction,
807          match: matchExpr,
808          attrHandle: {},
809          find: {},
810          relative: {
811            ">": { dir: "parentNode", first: true },
812            " ": { dir: "parentNode" },
813            "+": { dir: "previousSibling", first: true },
814            "~": { dir: "previousSibling" }
815          },
816          preFilter: {
817            ATTR: function(match) {
818              match[1] = match[1].replace(runescape, funescape);
819              match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape);
820              if (match[2] === "~=") {
821                match[3] = " " + match[3] + " ";
822              }
823              return match.slice(0, 4);
824            },
825            CHILD: function(match) {
826              match[1] = match[1].toLowerCase();
827              if (match[1].slice(0, 3) === "nth") {
828                if (!match[3]) {
829                  find.error(match[0]);
830                }
831                match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === "even" || match[3] === "odd"));
832                match[5] = +(match[7] + match[8] || match[3] === "odd");
833              } else if (match[3]) {
834                find.error(match[0]);
835              }
836              return match;
837            },
838            PSEUDO: function(match) {
839              var excess, unquoted = !match[6] && match[2];
840              if (matchExpr.CHILD.test(match[0])) {
841                return null;
842              }
843              if (match[3]) {
844                match[2] = match[4] || match[5] || "";
845              } else if (unquoted && rpseudo.test(unquoted) && // Get excess from tokenize (recursively)
846              (excess = tokenize(unquoted, true)) && // advance to the next closing parenthesis
847              (excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) {
848                match[0] = match[0].slice(0, excess);
849                match[2] = unquoted.slice(0, excess);
850              }
851              return match.slice(0, 3);
852            }
853          },
854          filter: {
855            TAG: function(nodeNameSelector) {
856              var expectedNodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();
857              return nodeNameSelector === "*" ? function() {
858                return true;
859              } : function(elem) {
860                return nodeName(elem, expectedNodeName);
861              };
862            },
863            CLASS: function(className) {
864              var pattern = classCache[className + " "];
865              return pattern || (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)")) && classCache(className, function(elem) {
866                return pattern.test(
867                  typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || ""
868                );
869              });
870            },
871            ATTR: function(name, operator, check) {
872              return function(elem) {
873                var result = find.attr(elem, name);
874                if (result == null) {
875                  return operator === "!=";
876                }
877                if (!operator) {
878                  return true;
879                }
880                result += "";
881                if (operator === "=") {
882                  return result === check;
883                }
884                if (operator === "!=") {
885                  return result !== check;
886                }
887                if (operator === "^=") {
888                  return check && result.indexOf(check) === 0;
889                }
890                if (operator === "*=") {
891                  return check && result.indexOf(check) > -1;
892                }
893                if (operator === "$=") {
894                  return check && result.slice(-check.length) === check;
895                }
896                if (operator === "~=") {
897                  return (" " + result.replace(rwhitespace, " ") + " ").indexOf(check) > -1;
898                }
899                if (operator === "|=") {
900                  return result === check || result.slice(0, check.length + 1) === check + "-";
901                }
902                return false;
903              };
904            },
905            CHILD: function(type, what, _argument, first, last) {
906              var simple = type.slice(0, 3) !== "nth", forward = type.slice(-4) !== "last", ofType = what === "of-type";
907              return first === 1 && last === 0 ? (
908                // Shortcut for :nth-*(n)
909                function(elem) {
910                  return !!elem.parentNode;
911                }
912              ) : function(elem, _context, xml) {
913                var cache, outerCache, node, nodeIndex, start, dir2 = simple !== forward ? "nextSibling" : "previousSibling", parent = elem.parentNode, name = ofType && elem.nodeName.toLowerCase(), useCache = !xml && !ofType, diff = false;
914                if (parent) {
915                  if (simple) {
916                    while (dir2) {
917                      node = elem;
918                      while (node = node[dir2]) {
919                        if (ofType ? nodeName(node, name) : node.nodeType === 1) {
920                          return false;
921                        }
922                      }
923                      start = dir2 = type === "only" && !start && "nextSibling";
924                    }
925                    return true;
926                  }
927                  start = [forward ? parent.firstChild : parent.lastChild];
928                  if (forward && useCache) {
929                    outerCache = parent[expando] || (parent[expando] = {});
930                    cache = outerCache[type] || [];
931                    nodeIndex = cache[0] === dirruns && cache[1];
932                    diff = nodeIndex && cache[2];
933                    node = nodeIndex && parent.childNodes[nodeIndex];
934                    while (node = ++nodeIndex && node && node[dir2] || // Fallback to seeking `elem` from the start
935                    (diff = nodeIndex = 0) || start.pop()) {
936                      if (node.nodeType === 1 && ++diff && node === elem) {
937                        outerCache[type] = [dirruns, nodeIndex, diff];
938                        break;
939                      }
940                    }
941                  } else {
942                    if (useCache) {
943                      outerCache = elem[expando] || (elem[expando] = {});
944                      cache = outerCache[type] || [];
945                      nodeIndex = cache[0] === dirruns && cache[1];
946                      diff = nodeIndex;
947                    }
948                    if (diff === false) {
949                      while (node = ++nodeIndex && node && node[dir2] || (diff = nodeIndex = 0) || start.pop()) {
950                        if ((ofType ? nodeName(node, name) : node.nodeType === 1) && ++diff) {
951                          if (useCache) {
952                            outerCache = node[expando] || (node[expando] = {});
953                            outerCache[type] = [dirruns, diff];
954                          }
955                          if (node === elem) {
956                            break;
957                          }
958                        }
959                      }
960                    }
961                  }
962                  diff -= last;
963                  return diff === first || diff % first === 0 && diff / first >= 0;
964                }
965              };
966            },
967            PSEUDO: function(pseudo, argument) {
968              var args, fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || find.error("unsupported pseudo: " + pseudo);
969              if (fn[expando]) {
970                return fn(argument);
971              }
972              if (fn.length > 1) {
973                args = [pseudo, pseudo, "", argument];
974                return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function(seed, matches2) {
975                  var idx, matched = fn(seed, argument), i2 = matched.length;
976                  while (i2--) {
977                    idx = indexOf.call(seed, matched[i2]);
978                    seed[idx] = !(matches2[idx] = matched[i2]);
979                  }
980                }) : function(elem) {
981                  return fn(elem, 0, args);
982                };
983              }
984              return fn;
985            }
986          },
987          pseudos: {
988            // Potentially complex pseudos
989            not: markFunction(function(selector) {
990              var input = [], results = [], matcher = compile(selector.replace(rtrimCSS, "$1"));
991              return matcher[expando] ? markFunction(function(seed, matches2, _context, xml) {
992                var elem, unmatched = matcher(seed, null, xml, []), i2 = seed.length;
993                while (i2--) {
994                  if (elem = unmatched[i2]) {
995                    seed[i2] = !(matches2[i2] = elem);
996                  }
997                }
998              }) : function(elem, _context, xml) {
999                input[0] = elem;
1000                matcher(input, null, xml, results);
1001                input[0] = null;
1002                return !results.pop();
1003              };
1004            }),
1005            has: markFunction(function(selector) {
1006              return function(elem) {
1007                return find(selector, elem).length > 0;
1008              };
1009            }),
1010            contains: markFunction(function(text) {
1011              text = text.replace(runescape, funescape);
1012              return function(elem) {
1013                return (elem.textContent || jQuery3.text(elem)).indexOf(text) > -1;
1014              };
1015            }),
1016            // "Whether an element is represented by a :lang() selector
1017            // is based solely on the element's language value
1018            // being equal to the identifier C,
1019            // or beginning with the identifier C immediately followed by "-".
1020            // The matching of C against the element's language value is performed case-insensitively.
1021            // The identifier C does not have to be a valid language name."
1022            // https://www.w3.org/TR/selectors/#lang-pseudo
1023            lang: markFunction(function(lang) {
1024              if (!ridentifier.test(lang || "")) {
1025                find.error("unsupported lang: " + lang);
1026              }
1027              lang = lang.replace(runescape, funescape).toLowerCase();
1028              return function(elem) {
1029                var elemLang;
1030                do {
1031                  if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) {
1032                    elemLang = elemLang.toLowerCase();
1033                    return elemLang === lang || elemLang.indexOf(lang + "-") === 0;
1034                  }
1035                } while ((elem = elem.parentNode) && elem.nodeType === 1);
1036                return false;
1037              };
1038            }),
1039            // Miscellaneous
1040            target: function(elem) {
1041              var hash = window2.location && window2.location.hash;
1042              return hash && hash.slice(1) === elem.id;
1043            },
1044            root: function(elem) {
1045              return elem === documentElement2;
1046            },
1047            focus: function(elem) {
1048              return elem === safeActiveElement() && document3.hasFocus() && !!(elem.type || elem.href || ~elem.tabIndex);
1049            },
1050            // Boolean properties
1051            enabled: createDisabledPseudo(false),
1052            disabled: createDisabledPseudo(true),
1053            checked: function(elem) {
1054              return nodeName(elem, "input") && !!elem.checked || nodeName(elem, "option") && !!elem.selected;
1055            },
1056            selected: function(elem) {
1057              if (elem.parentNode) {
1058                elem.parentNode.selectedIndex;
1059              }
1060              return elem.selected === true;
1061            },
1062            // Contents
1063            empty: function(elem) {
1064              for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
1065                if (elem.nodeType < 6) {
1066                  return false;
1067                }
1068              }
1069              return true;
1070            },
1071            parent: function(elem) {
1072              return !Expr.pseudos.empty(elem);
1073            },
1074            // Element/input types
1075            header: function(elem) {
1076              return rheader.test(elem.nodeName);
1077            },
1078            input: function(elem) {
1079              return rinputs.test(elem.nodeName);
1080            },
1081            button: function(elem) {
1082              return nodeName(elem, "input") && elem.type === "button" || nodeName(elem, "button");
1083            },
1084            text: function(elem) {
1085              var attr;
1086              return nodeName(elem, "input") && elem.type === "text" && // Support: IE <10 only
1087              // New HTML5 attribute values (e.g., "search") appear
1088              // with elem.type === "text"
1089              ((attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text");
1090            },
1091            // Position-in-collection
1092            first: createPositionalPseudo(function() {
1093              return [0];
1094            }),
1095            last: createPositionalPseudo(function(_matchIndexes, length) {
1096              return [length - 1];
1097            }),
1098            eq: createPositionalPseudo(function(_matchIndexes, length, argument) {
1099              return [argument < 0 ? argument + length : argument];
1100            }),
1101            even: createPositionalPseudo(function(matchIndexes, length) {
1102              var i2 = 0;
1103              for (; i2 < length; i2 += 2) {
1104                matchIndexes.push(i2);
1105              }
1106              return matchIndexes;
1107            }),
1108            odd: createPositionalPseudo(function(matchIndexes, length) {
1109              var i2 = 1;
1110              for (; i2 < length; i2 += 2) {
1111                matchIndexes.push(i2);
1112              }
1113              return matchIndexes;
1114            }),
1115            lt: createPositionalPseudo(function(matchIndexes, length, argument) {
1116              var i2;
1117              if (argument < 0) {
1118                i2 = argument + length;
1119              } else if (argument > length) {
1120                i2 = length;
1121              } else {
1122                i2 = argument;
1123              }
1124              for (; --i2 >= 0; ) {
1125                matchIndexes.push(i2);
1126              }
1127              return matchIndexes;
1128            }),
1129            gt: createPositionalPseudo(function(matchIndexes, length, argument) {
1130              var i2 = argument < 0 ? argument + length : argument;
1131              for (; ++i2 < length; ) {
1132                matchIndexes.push(i2);
1133              }
1134              return matchIndexes;
1135            })
1136          }
1137        };
1138        Expr.pseudos.nth = Expr.pseudos.eq;
1139        for (i in { radio: true, checkbox: true, file: true, password: true, image: true }) {
1140          Expr.pseudos[i] = createInputPseudo(i);
1141        }
1142        for (i in { submit: true, reset: true }) {
1143          Expr.pseudos[i] = createButtonPseudo(i);
1144        }
1145        function setFilters() {
1146        }
1147        setFilters.prototype = Expr.filters = Expr.pseudos;
1148        Expr.setFilters = new setFilters();
1149        function tokenize(selector, parseOnly) {
1150          var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[selector + " "];
1151          if (cached) {
1152            return parseOnly ? 0 : cached.slice(0);
1153          }
1154          soFar = selector;
1155          groups = [];
1156          preFilters = Expr.preFilter;
1157          while (soFar) {
1158            if (!matched || (match = rcomma.exec(soFar))) {
1159              if (match) {
1160                soFar = soFar.slice(match[0].length) || soFar;
1161              }
1162              groups.push(tokens = []);
1163            }
1164            matched = false;
1165            if (match = rleadingCombinator.exec(soFar)) {
1166              matched = match.shift();
1167              tokens.push({
1168                value: matched,
1169                // Cast descendant combinators to space
1170                type: match[0].replace(rtrimCSS, " ")
1171              });
1172              soFar = soFar.slice(matched.length);
1173            }
1174            for (type in Expr.filter) {
1175              if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match)))) {
1176                matched = match.shift();
1177                tokens.push({
1178                  value: matched,
1179                  type,
1180                  matches: match
1181                });
1182                soFar = soFar.slice(matched.length);
1183              }
1184            }
1185            if (!matched) {
1186              break;
1187            }
1188          }
1189          if (parseOnly) {
1190            return soFar.length;
1191          }
1192          return soFar ? find.error(selector) : (
1193            // Cache the tokens
1194            tokenCache(selector, groups).slice(0)
1195          );
1196        }
1197        function toSelector(tokens) {
1198          var i2 = 0, len = tokens.length, selector = "";
1199          for (; i2 < len; i2++) {
1200            selector += tokens[i2].value;
1201          }
1202          return selector;
1203        }
1204        function addCombinator(matcher, combinator, base) {
1205          var dir2 = combinator.dir, skip = combinator.next, key = skip || dir2, checkNonElements = base && key === "parentNode", doneName = done++;
1206          return combinator.first ? (
1207            // Check against closest ancestor/preceding element
1208            function(elem, context, xml) {
1209              while (elem = elem[dir2]) {
1210                if (elem.nodeType === 1 || checkNonElements) {
1211                  return matcher(elem, context, xml);
1212                }
1213              }
1214              return false;
1215            }
1216          ) : (
1217            // Check against all ancestor/preceding elements
1218            function(elem, context, xml) {
1219              var oldCache, outerCache, newCache = [dirruns, doneName];
1220              if (xml) {
1221                while (elem = elem[dir2]) {
1222                  if (elem.nodeType === 1 || checkNonElements) {
1223                    if (matcher(elem, context, xml)) {
1224                      return true;
1225                    }
1226                  }
1227                }
1228              } else {
1229                while (elem = elem[dir2]) {
1230                  if (elem.nodeType === 1 || checkNonElements) {
1231                    outerCache = elem[expando] || (elem[expando] = {});
1232                    if (skip && nodeName(elem, skip)) {
1233                      elem = elem[dir2] || elem;
1234                    } else if ((oldCache = outerCache[key]) && oldCache[0] === dirruns && oldCache[1] === doneName) {
1235                      return newCache[2] = oldCache[2];
1236                    } else {
1237                      outerCache[key] = newCache;
1238                      if (newCache[2] = matcher(elem, context, xml)) {
1239                        return true;
1240                      }
1241                    }
1242                  }
1243                }
1244              }
1245              return false;
1246            }
1247          );
1248        }
1249        function elementMatcher(matchers) {
1250          return matchers.length > 1 ? function(elem, context, xml) {
1251            var i2 = matchers.length;
1252            while (i2--) {
1253              if (!matchers[i2](elem, context, xml)) {
1254                return false;
1255              }
1256            }
1257            return true;
1258          } : matchers[0];
1259        }
1260        function multipleContexts(selector, contexts, results) {
1261          var i2 = 0, len = contexts.length;
1262          for (; i2 < len; i2++) {
1263            find(selector, contexts[i2], results);
1264          }
1265          return results;
1266        }
1267        function condense(unmatched, map, filter, context, xml) {
1268          var elem, newUnmatched = [], i2 = 0, len = unmatched.length, mapped = map != null;
1269          for (; i2 < len; i2++) {
1270            if (elem = unmatched[i2]) {
1271              if (!filter || filter(elem, context, xml)) {
1272                newUnmatched.push(elem);
1273                if (mapped) {
1274                  map.push(i2);
1275                }
1276              }
1277            }
1278          }
1279          return newUnmatched;
1280        }
1281        function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
1282          if (postFilter && !postFilter[expando]) {
1283            postFilter = setMatcher(postFilter);
1284          }
1285          if (postFinder && !postFinder[expando]) {
1286            postFinder = setMatcher(postFinder, postSelector);
1287          }
1288          return markFunction(function(seed, results, context, xml) {
1289            var temp, i2, elem, matcherOut, preMap = [], postMap = [], preexisting = results.length, elems = seed || multipleContexts(
1290              selector || "*",
1291              context.nodeType ? [context] : context,
1292              []
1293            ), matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems;
1294            if (matcher) {
1295              matcherOut = postFinder || (seed ? preFilter : preexisting || postFilter) ? (
1296                // ...intermediate processing is necessary
1297                []
1298              ) : (
1299                // ...otherwise use results directly
1300                results
1301              );
1302              matcher(matcherIn, matcherOut, context, xml);
1303            } else {
1304              matcherOut = matcherIn;
1305            }
1306            if (postFilter) {
1307              temp = condense(matcherOut, postMap);
1308              postFilter(temp, [], context, xml);
1309              i2 = temp.length;
1310              while (i2--) {
1311                if (elem = temp[i2]) {
1312                  matcherOut[postMap[i2]] = !(matcherIn[postMap[i2]] = elem);
1313                }
1314              }
1315            }
1316            if (seed) {
1317              if (postFinder || preFilter) {
1318                if (postFinder) {
1319                  temp = [];
1320                  i2 = matcherOut.length;
1321                  while (i2--) {
1322                    if (elem = matcherOut[i2]) {
1323                      temp.push(matcherIn[i2] = elem);
1324                    }
1325                  }
1326                  postFinder(null, matcherOut = [], temp, xml);
1327                }
1328                i2 = matcherOut.length;
1329                while (i2--) {
1330                  if ((elem = matcherOut[i2]) && (temp = postFinder ? indexOf.call(seed, elem) : preMap[i2]) > -1) {
1331                    seed[temp] = !(results[temp] = elem);
1332                  }
1333                }
1334              }
1335            } else {
1336              matcherOut = condense(
1337                matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut
1338              );
1339              if (postFinder) {
1340                postFinder(null, results, matcherOut, xml);
1341              } else {
1342                push2.apply(results, matcherOut);
1343              }
1344            }
1345          });
1346        }
1347        function matcherFromTokens(tokens) {
1348          var checkContext, matcher, j, len = tokens.length, leadingRelative = Expr.relative[tokens[0].type], implicitRelative = leadingRelative || Expr.relative[" "], i2 = leadingRelative ? 1 : 0, matchContext = addCombinator(function(elem) {
1349            return elem === checkContext;
1350          }, implicitRelative, true), matchAnyContext = addCombinator(function(elem) {
1351            return indexOf.call(checkContext, elem) > -1;
1352          }, implicitRelative, true), matchers = [function(elem, context, xml) {
1353            var ret = !leadingRelative && (xml || context != outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml));
1354            checkContext = null;
1355            return ret;
1356          }];
1357          for (; i2 < len; i2++) {
1358            if (matcher = Expr.relative[tokens[i2].type]) {
1359              matchers = [addCombinator(elementMatcher(matchers), matcher)];
1360            } else {
1361              matcher = Expr.filter[tokens[i2].type].apply(null, tokens[i2].matches);
1362              if (matcher[expando]) {
1363                j = ++i2;
1364                for (; j < len; j++) {
1365                  if (Expr.relative[tokens[j].type]) {
1366                    break;
1367                  }
1368                }
1369                return setMatcher(
1370                  i2 > 1 && elementMatcher(matchers),
1371                  i2 > 1 && toSelector(
1372                    // If the preceding token was a descendant combinator, insert an implicit any-element `*`
1373                    tokens.slice(0, i2 - 1).concat({ value: tokens[i2 - 2].type === " " ? "*" : "" })
1374                  ).replace(rtrimCSS, "$1"),
1375                  matcher,
1376                  i2 < j && matcherFromTokens(tokens.slice(i2, j)),
1377                  j < len && matcherFromTokens(tokens = tokens.slice(j)),
1378                  j < len && toSelector(tokens)
1379                );
1380              }
1381              matchers.push(matcher);
1382            }
1383          }
1384          return elementMatcher(matchers);
1385        }
1386        function matcherFromGroupMatchers(elementMatchers, setMatchers) {
1387          var bySet = setMatchers.length > 0, byElement = elementMatchers.length > 0, superMatcher = function(seed, context, xml, results, outermost) {
1388            var elem, j, matcher, matchedCount = 0, i2 = "0", unmatched = seed && [], setMatched = [], contextBackup = outermostContext, elems = seed || byElement && Expr.find.TAG("*", outermost), dirrunsUnique = dirruns += contextBackup == null ? 1 : Math.random() || 0.1, len = elems.length;
1389            if (outermost) {
1390              outermostContext = context == document3 || context || outermost;
1391            }
1392            for (; i2 !== len && (elem = elems[i2]) != null; i2++) {
1393              if (byElement && elem) {
1394                j = 0;
1395                if (!context && elem.ownerDocument != document3) {
1396                  setDocument(elem);
1397                  xml = !documentIsHTML;
1398                }
1399                while (matcher = elementMatchers[j++]) {
1400                  if (matcher(elem, context || document3, xml)) {
1401                    push2.call(results, elem);
1402                    break;
1403                  }
1404                }
1405                if (outermost) {
1406                  dirruns = dirrunsUnique;
1407                }
1408              }
1409              if (bySet) {
1410                if (elem = !matcher && elem) {
1411                  matchedCount--;
1412                }
1413                if (seed) {
1414                  unmatched.push(elem);
1415                }
1416              }
1417            }
1418            matchedCount += i2;
1419            if (bySet && i2 !== matchedCount) {
1420              j = 0;
1421              while (matcher = setMatchers[j++]) {
1422                matcher(unmatched, setMatched, context, xml);
1423              }
1424              if (seed) {
1425                if (matchedCount > 0) {
1426                  while (i2--) {
1427                    if (!(unmatched[i2] || setMatched[i2])) {
1428                      setMatched[i2] = pop.call(results);
1429                    }
1430                  }
1431                }
1432                setMatched = condense(setMatched);
1433              }
1434              push2.apply(results, setMatched);
1435              if (outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1) {
1436                jQuery3.uniqueSort(results);
1437              }
1438            }
1439            if (outermost) {
1440              dirruns = dirrunsUnique;
1441              outermostContext = contextBackup;
1442            }
1443            return unmatched;
1444          };
1445          return bySet ? markFunction(superMatcher) : superMatcher;
1446        }
1447        function compile(selector, match) {
1448          var i2, setMatchers = [], elementMatchers = [], cached = compilerCache[selector + " "];
1449          if (!cached) {
1450            if (!match) {
1451              match = tokenize(selector);
1452            }
1453            i2 = match.length;
1454            while (i2--) {
1455              cached = matcherFromTokens(match[i2]);
1456              if (cached[expando]) {
1457                setMatchers.push(cached);
1458              } else {
1459                elementMatchers.push(cached);
1460              }
1461            }
1462            cached = compilerCache(
1463              selector,
1464              matcherFromGroupMatchers(elementMatchers, setMatchers)
1465            );
1466            cached.selector = selector;
1467          }
1468          return cached;
1469        }
1470        function select(selector, context, results, seed) {
1471          var i2, tokens, token, type, find2, compiled = typeof selector === "function" && selector, match = !seed && tokenize(selector = compiled.selector || selector);
1472          results = results || [];
1473          if (match.length === 1) {
1474            tokens = match[0] = match[0].slice(0);
1475            if (tokens.length > 2 && (token = tokens[0]).type === "ID" && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) {
1476              context = (Expr.find.ID(
1477                token.matches[0].replace(runescape, funescape),
1478                context
1479              ) || [])[0];
1480              if (!context) {
1481                return results;
1482              } else if (compiled) {
1483                context = context.parentNode;
1484              }
1485              selector = selector.slice(tokens.shift().value.length);
1486            }
1487            i2 = matchExpr.needsContext.test(selector) ? 0 : tokens.length;
1488            while (i2--) {
1489              token = tokens[i2];
1490              if (Expr.relative[type = token.type]) {
1491                break;
1492              }
1493              if (find2 = Expr.find[type]) {
1494                if (seed = find2(
1495                  token.matches[0].replace(runescape, funescape),
1496                  rsibling.test(tokens[0].type) && testContext(context.parentNode) || context
1497                )) {
1498                  tokens.splice(i2, 1);
1499                  selector = seed.length && toSelector(tokens);
1500                  if (!selector) {
1501                    push2.apply(results, seed);
1502                    return results;
1503                  }
1504                  break;
1505                }
1506              }
1507            }
1508          }
1509          (compiled || compile(selector, match))(
1510            seed,
1511            context,
1512            !documentIsHTML,
1513            results,
1514            !context || rsibling.test(selector) && testContext(context.parentNode) || context
1515          );
1516          return results;
1517        }
1518        support.sortStable = expando.split("").sort(sortOrder).join("") === expando;
1519        setDocument();
1520        support.sortDetached = assert(function(el) {
1521          return el.compareDocumentPosition(document3.createElement("fieldset")) & 1;
1522        });
1523        jQuery3.find = find;
1524        jQuery3.expr[":"] = jQuery3.expr.pseudos;
1525        jQuery3.unique = jQuery3.uniqueSort;
1526        find.compile = compile;
1527        find.select = select;
1528        find.setDocument = setDocument;
1529        find.tokenize = tokenize;
1530        find.escape = jQuery3.escapeSelector;
1531        find.getText = jQuery3.text;
1532        find.isXML = jQuery3.isXMLDoc;
1533        find.selectors = jQuery3.expr;
1534        find.support = jQuery3.support;
1535        find.uniqueSort = jQuery3.uniqueSort;
1536      })();
1537      var dir = function(elem, dir2, until) {
1538        var matched = [], truncate = until !== void 0;
1539        while ((elem = elem[dir2]) && elem.nodeType !== 9) {
1540          if (elem.nodeType === 1) {
1541            if (truncate && jQuery3(elem).is(until)) {
1542              break;
1543            }
1544            matched.push(elem);
1545          }
1546        }
1547        return matched;
1548      };
1549      var siblings = function(n, elem) {
1550        var matched = [];
1551        for (; n; n = n.nextSibling) {
1552          if (n.nodeType === 1 && n !== elem) {
1553            matched.push(n);
1554          }
1555        }
1556        return matched;
1557      };
1558      var rneedsContext = jQuery3.expr.match.needsContext;
1559      var rsingleTag = /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;
1560      function winnow(elements, qualifier, not) {
1561        if (isFunction(qualifier)) {
1562          return jQuery3.grep(elements, function(elem, i) {
1563            return !!qualifier.call(elem, i, elem) !== not;
1564          });
1565        }
1566        if (qualifier.nodeType) {
1567          return jQuery3.grep(elements, function(elem) {
1568            return elem === qualifier !== not;
1569          });
1570        }
1571        if (typeof qualifier !== "string") {
1572          return jQuery3.grep(elements, function(elem) {
1573            return indexOf.call(qualifier, elem) > -1 !== not;
1574          });
1575        }
1576        return jQuery3.filter(qualifier, elements, not);
1577      }
1578      jQuery3.filter = function(expr, elems, not) {
1579        var elem = elems[0];
1580        if (not) {
1581          expr = ":not(" + expr + ")";
1582        }
1583        if (elems.length === 1 && elem.nodeType === 1) {
1584          return jQuery3.find.matchesSelector(elem, expr) ? [elem] : [];
1585        }
1586        return jQuery3.find.matches(expr, jQuery3.grep(elems, function(elem2) {
1587          return elem2.nodeType === 1;
1588        }));
1589      };
1590      jQuery3.fn.extend({
1591        find: function(selector) {
1592          var i, ret, len = this.length, self = this;
1593          if (typeof selector !== "string") {
1594            return this.pushStack(jQuery3(selector).filter(function() {
1595              for (i = 0; i < len; i++) {
1596                if (jQuery3.contains(self[i], this)) {
1597                  return true;
1598                }
1599              }
1600            }));
1601          }
1602          ret = this.pushStack([]);
1603          for (i = 0; i < len; i++) {
1604            jQuery3.find(selector, self[i], ret);
1605          }
1606          return len > 1 ? jQuery3.uniqueSort(ret) : ret;
1607        },
1608        filter: function(selector) {
1609          return this.pushStack(winnow(this, selector || [], false));
1610        },
1611        not: function(selector) {
1612          return this.pushStack(winnow(this, selector || [], true));
1613        },
1614        is: function(selector) {
1615          return !!winnow(
1616            this,
1617            // If this is a positional/relative selector, check membership in the returned set
1618            // so $("p:first").is("p:last") won't return true for a doc with two "p".
1619            typeof selector === "string" && rneedsContext.test(selector) ? jQuery3(selector) : selector || [],
1620            false
1621          ).length;
1622        }
1623      });
1624      var rootjQuery, rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, init = jQuery3.fn.init = function(selector, context, root) {
1625        var match, elem;
1626        if (!selector) {
1627          return this;
1628        }
1629        root = root || rootjQuery;
1630        if (typeof selector === "string") {
1631          if (selector[0] === "<" && selector[selector.length - 1] === ">" && selector.length >= 3) {
1632            match = [null, selector, null];
1633          } else {
1634            match = rquickExpr.exec(selector);
1635          }
1636          if (match && (match[1] || !context)) {
1637            if (match[1]) {
1638              context = context instanceof jQuery3 ? context[0] : context;
1639              jQuery3.merge(this, jQuery3.parseHTML(
1640                match[1],
1641                context && context.nodeType ? context.ownerDocument || context : document2,
1642                true
1643              ));
1644              if (rsingleTag.test(match[1]) && jQuery3.isPlainObject(context)) {
1645                for (match in context) {
1646                  if (isFunction(this[match])) {
1647                    this[match](context[match]);
1648                  } else {
1649                    this.attr(match, context[match]);
1650                  }
1651                }
1652              }
1653              return this;
1654            } else {
1655              elem = document2.getElementById(match[2]);
1656              if (elem) {
1657                this[0] = elem;
1658                this.length = 1;
1659              }
1660              return this;
1661            }
1662          } else if (!context || context.jquery) {
1663            return (context || root).find(selector);
1664          } else {
1665            return this.constructor(context).find(selector);
1666          }
1667        } else if (selector.nodeType) {
1668          this[0] = selector;
1669          this.length = 1;
1670          return this;
1671        } else if (isFunction(selector)) {
1672          return root.ready !== void 0 ? root.ready(selector) : (
1673            // Execute immediately if ready is not present
1674            selector(jQuery3)
1675          );
1676        }
1677        return jQuery3.makeArray(selector, this);
1678      };
1679      init.prototype = jQuery3.fn;
1680      rootjQuery = jQuery3(document2);
1681      var rparentsprev = /^(?:parents|prev(?:Until|All))/, guaranteedUnique = {
1682        children: true,
1683        contents: true,
1684        next: true,
1685        prev: true
1686      };
1687      jQuery3.fn.extend({
1688        has: function(target) {
1689          var targets = jQuery3(target, this), l = targets.length;
1690          return this.filter(function() {
1691            var i = 0;
1692            for (; i < l; i++) {
1693              if (jQuery3.contains(this, targets[i])) {
1694                return true;
1695              }
1696            }
1697          });
1698        },
1699        closest: function(selectors, context) {
1700          var cur, i = 0, l = this.length, matched = [], targets = typeof selectors !== "string" && jQuery3(selectors);
1701          if (!rneedsContext.test(selectors)) {
1702            for (; i < l; i++) {
1703              for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) {
1704                if (cur.nodeType < 11 && (targets ? targets.index(cur) > -1 : (
1705                  // Don't pass non-elements to jQuery#find
1706                  cur.nodeType === 1 && jQuery3.find.matchesSelector(cur, selectors)
1707                ))) {
1708                  matched.push(cur);
1709                  break;
1710                }
1711              }
1712            }
1713          }
1714          return this.pushStack(matched.length > 1 ? jQuery3.uniqueSort(matched) : matched);
1715        },
1716        // Determine the position of an element within the set
1717        index: function(elem) {
1718          if (!elem) {
1719            return this[0] && this[0].parentNode ? this.first().prevAll().length : -1;
1720          }
1721          if (typeof elem === "string") {
1722            return indexOf.call(jQuery3(elem), this[0]);
1723          }
1724          return indexOf.call(
1725            this,
1726            // If it receives a jQuery object, the first element is used
1727            elem.jquery ? elem[0] : elem
1728          );
1729        },
1730        add: function(selector, context) {
1731          return this.pushStack(
1732            jQuery3.uniqueSort(
1733              jQuery3.merge(this.get(), jQuery3(selector, context))
1734            )
1735          );
1736        },
1737        addBack: function(selector) {
1738          return this.add(
1739            selector == null ? this.prevObject : this.prevObject.filter(selector)
1740          );
1741        }
1742      });
1743      function sibling(cur, dir2) {
1744        while ((cur = cur[dir2]) && cur.nodeType !== 1) {
1745        }
1746        return cur;
1747      }
1748      jQuery3.each({
1749        parent: function(elem) {
1750          var parent = elem.parentNode;
1751          return parent && parent.nodeType !== 11 ? parent : null;
1752        },
1753        parents: function(elem) {
1754          return dir(elem, "parentNode");
1755        },
1756        parentsUntil: function(elem, _i, until) {
1757          return dir(elem, "parentNode", until);
1758        },
1759        next: function(elem) {
1760          return sibling(elem, "nextSibling");
1761        },
1762        prev: function(elem) {
1763          return sibling(elem, "previousSibling");
1764        },
1765        nextAll: function(elem) {
1766          return dir(elem, "nextSibling");
1767        },
1768        prevAll: function(elem) {
1769          return dir(elem, "previousSibling");
1770        },
1771        nextUntil: function(elem, _i, until) {
1772          return dir(elem, "nextSibling", until);
1773        },
1774        prevUntil: function(elem, _i, until) {
1775          return dir(elem, "previousSibling", until);
1776        },
1777        siblings: function(elem) {
1778          return siblings((elem.parentNode || {}).firstChild, elem);
1779        },
1780        children: function(elem) {
1781          return siblings(elem.firstChild);
1782        },
1783        contents: function(elem) {
1784          if (elem.contentDocument != null && // Support: IE 11+
1785          // <object> elements with no `data` attribute has an object
1786          // `contentDocument` with a `null` prototype.
1787          getProto(elem.contentDocument)) {
1788            return elem.contentDocument;
1789          }
1790          if (nodeName(elem, "template")) {
1791            elem = elem.content || elem;
1792          }
1793          return jQuery3.merge([], elem.childNodes);
1794        }
1795      }, function(name, fn) {
1796        jQuery3.fn[name] = function(until, selector) {
1797          var matched = jQuery3.map(this, fn, until);
1798          if (name.slice(-5) !== "Until") {
1799            selector = until;
1800          }
1801          if (selector && typeof selector === "string") {
1802            matched = jQuery3.filter(selector, matched);
1803          }
1804          if (this.length > 1) {
1805            if (!guaranteedUnique[name]) {
1806              jQuery3.uniqueSort(matched);
1807            }
1808            if (rparentsprev.test(name)) {
1809              matched.reverse();
1810            }
1811          }
1812          return this.pushStack(matched);
1813        };
1814      });
1815      var rnothtmlwhite = /[^\x20\t\r\n\f]+/g;
1816      function createOptions(options) {
1817        var object = {};
1818        jQuery3.each(options.match(rnothtmlwhite) || [], function(_, flag) {
1819          object[flag] = true;
1820        });
1821        return object;
1822      }
1823      jQuery3.Callbacks = function(options) {
1824        options = typeof options === "string" ? createOptions(options) : jQuery3.extend({}, options);
1825        var firing, memory, fired, locked, list = [], queue = [], firingIndex = -1, fire = function() {
1826          locked = locked || options.once;
1827          fired = firing = true;
1828          for (; queue.length; firingIndex = -1) {
1829            memory = queue.shift();
1830            while (++firingIndex < list.length) {
1831              if (list[firingIndex].apply(memory[0], memory[1]) === false && options.stopOnFalse) {
1832                firingIndex = list.length;
1833                memory = false;
1834              }
1835            }
1836          }
1837          if (!options.memory) {
1838            memory = false;
1839          }
1840          firing = false;
1841          if (locked) {
1842            if (memory) {
1843              list = [];
1844            } else {
1845              list = "";
1846            }
1847          }
1848        }, self = {
1849          // Add a callback or a collection of callbacks to the list
1850          add: function() {
1851            if (list) {
1852              if (memory && !firing) {
1853                firingIndex = list.length - 1;
1854                queue.push(memory);
1855              }
1856              (function add(args) {
1857                jQuery3.each(args, function(_, arg) {
1858                  if (isFunction(arg)) {
1859                    if (!options.unique || !self.has(arg)) {
1860                      list.push(arg);
1861                    }
1862                  } else if (arg && arg.length && toType(arg) !== "string") {
1863                    add(arg);
1864                  }
1865                });
1866              })(arguments);
1867              if (memory && !firing) {
1868                fire();
1869              }
1870            }
1871            return this;
1872          },
1873          // Remove a callback from the list
1874          remove: function() {
1875            jQuery3.each(arguments, function(_, arg) {
1876              var index;
1877              while ((index = jQuery3.inArray(arg, list, index)) > -1) {
1878                list.splice(index, 1);
1879                if (index <= firingIndex) {
1880                  firingIndex--;
1881                }
1882              }
1883            });
1884            return this;
1885          },
1886          // Check if a given callback is in the list.
1887          // If no argument is given, return whether or not list has callbacks attached.
1888          has: function(fn) {
1889            return fn ? jQuery3.inArray(fn, list) > -1 : list.length > 0;
1890          },
1891          // Remove all callbacks from the list
1892          empty: function() {
1893            if (list) {
1894              list = [];
1895            }
1896            return this;
1897          },
1898          // Disable .fire and .add
1899          // Abort any current/pending executions
1900          // Clear all callbacks and values
1901          disable: function() {
1902            locked = queue = [];
1903            list = memory = "";
1904            return this;
1905          },
1906          disabled: function() {
1907            return !list;
1908          },
1909          // Disable .fire
1910          // Also disable .add unless we have memory (since it would have no effect)
1911          // Abort any pending executions
1912          lock: function() {
1913            locked = queue = [];
1914            if (!memory && !firing) {
1915              list = memory = "";
1916            }
1917            return this;
1918          },
1919          locked: function() {
1920            return !!locked;
1921          },
1922          // Call all callbacks with the given context and arguments
1923          fireWith: function(context, args) {
1924            if (!locked) {
1925              args = args || [];
1926              args = [context, args.slice ? args.slice() : args];
1927              queue.push(args);
1928              if (!firing) {
1929                fire();
1930              }
1931            }
1932            return this;
1933          },
1934          // Call all the callbacks with the given arguments
1935          fire: function() {
1936            self.fireWith(this, arguments);
1937            return this;
1938          },
1939          // To know if the callbacks have already been called at least once
1940          fired: function() {
1941            return !!fired;
1942          }
1943        };
1944        return self;
1945      };
1946      function Identity(v) {
1947        return v;
1948      }
1949      function Thrower(ex) {
1950        throw ex;
1951      }
1952      function adoptValue(value, resolve, reject, noValue) {
1953        var method;
1954        try {
1955          if (value && isFunction(method = value.promise)) {
1956            method.call(value).done(resolve).fail(reject);
1957          } else if (value && isFunction(method = value.then)) {
1958            method.call(value, resolve, reject);
1959          } else {
1960            resolve.apply(void 0, [value].slice(noValue));
1961          }
1962        } catch (value2) {
1963          reject.apply(void 0, [value2]);
1964        }
1965      }
1966      jQuery3.extend({
1967        Deferred: function(func) {
1968          var tuples = [
1969            // action, add listener, callbacks,
1970            // ... .then handlers, argument index, [final state]
1971            [
1972              "notify",
1973              "progress",
1974              jQuery3.Callbacks("memory"),
1975              jQuery3.Callbacks("memory"),
1976              2
1977            ],
1978            [
1979              "resolve",
1980              "done",
1981              jQuery3.Callbacks("once memory"),
1982              jQuery3.Callbacks("once memory"),
1983              0,
1984              "resolved"
1985            ],
1986            [
1987              "reject",
1988              "fail",
1989              jQuery3.Callbacks("once memory"),
1990              jQuery3.Callbacks("once memory"),
1991              1,
1992              "rejected"
1993            ]
1994          ], state = "pending", promise = {
1995            state: function() {
1996              return state;
1997            },
1998            always: function() {
1999              deferred.done(arguments).fail(arguments);
2000              return this;
2001            },
2002            "catch": function(fn) {
2003              return promise.then(null, fn);
2004            },
2005            // Keep pipe for back-compat
2006            pipe: function() {
2007              var fns = arguments;
2008              return jQuery3.Deferred(function(newDefer) {
2009                jQuery3.each(tuples, function(_i, tuple) {
2010                  var fn = isFunction(fns[tuple[4]]) && fns[tuple[4]];
2011                  deferred[tuple[1]](function() {
2012                    var returned = fn && fn.apply(this, arguments);
2013                    if (returned && isFunction(returned.promise)) {
2014                      returned.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject);
2015                    } else {
2016                      newDefer[tuple[0] + "With"](
2017                        this,
2018                        fn ? [returned] : arguments
2019                      );
2020                    }
2021                  });
2022                });
2023                fns = null;
2024              }).promise();
2025            },
2026            then: function(onFulfilled, onRejected, onProgress) {
2027              var maxDepth = 0;
2028              function resolve(depth, deferred2, handler, special) {
2029                return function() {
2030                  var that = this, args = arguments, mightThrow = function() {
2031                    var returned, then;
2032                    if (depth < maxDepth) {
2033                      return;
2034                    }
2035                    returned = handler.apply(that, args);
2036                    if (returned === deferred2.promise()) {
2037                      throw new TypeError("Thenable self-resolution");
2038                    }
2039                    then = returned && // Support: Promises/A+ section 2.3.4
2040                    // https://promisesaplus.com/#point-64
2041                    // Only check objects and functions for thenability
2042                    (typeof returned === "object" || typeof returned === "function") && returned.then;
2043                    if (isFunction(then)) {
2044                      if (special) {
2045                        then.call(
2046                          returned,
2047                          resolve(maxDepth, deferred2, Identity, special),
2048                          resolve(maxDepth, deferred2, Thrower, special)
2049                        );
2050                      } else {
2051                        maxDepth++;
2052                        then.call(
2053                          returned,
2054                          resolve(maxDepth, deferred2, Identity, special),
2055                          resolve(maxDepth, deferred2, Thrower, special),
2056                          resolve(
2057                            maxDepth,
2058                            deferred2,
2059                            Identity,
2060                            deferred2.notifyWith
2061                          )
2062                        );
2063                      }
2064                    } else {
2065                      if (handler !== Identity) {
2066                        that = void 0;
2067                        args = [returned];
2068                      }
2069                      (special || deferred2.resolveWith)(that, args);
2070                    }
2071                  }, process = special ? mightThrow : function() {
2072                    try {
2073                      mightThrow();
2074                    } catch (e) {
2075                      if (jQuery3.Deferred.exceptionHook) {
2076                        jQuery3.Deferred.exceptionHook(
2077                          e,
2078                          process.error
2079                        );
2080                      }
2081                      if (depth + 1 >= maxDepth) {
2082                        if (handler !== Thrower) {
2083                          that = void 0;
2084                          args = [e];
2085                        }
2086                        deferred2.rejectWith(that, args);
2087                      }
2088                    }
2089                  };
2090                  if (depth) {
2091                    process();
2092                  } else {
2093                    if (jQuery3.Deferred.getErrorHook) {
2094                      process.error = jQuery3.Deferred.getErrorHook();
2095                    } else if (jQuery3.Deferred.getStackHook) {
2096                      process.error = jQuery3.Deferred.getStackHook();
2097                    }
2098                    window2.setTimeout(process);
2099                  }
2100                };
2101              }
2102              return jQuery3.Deferred(function(newDefer) {
2103                tuples[0][3].add(
2104                  resolve(
2105                    0,
2106                    newDefer,
2107                    isFunction(onProgress) ? onProgress : Identity,
2108                    newDefer.notifyWith
2109                  )
2110                );
2111                tuples[1][3].add(
2112                  resolve(
2113                    0,
2114                    newDefer,
2115                    isFunction(onFulfilled) ? onFulfilled : Identity
2116                  )
2117                );
2118                tuples[2][3].add(
2119                  resolve(
2120                    0,
2121                    newDefer,
2122                    isFunction(onRejected) ? onRejected : Thrower
2123                  )
2124                );
2125              }).promise();
2126            },
2127            // Get a promise for this deferred
2128            // If obj is provided, the promise aspect is added to the object
2129            promise: function(obj) {
2130              return obj != null ? jQuery3.extend(obj, promise) : promise;
2131            }
2132          }, deferred = {};
2133          jQuery3.each(tuples, function(i, tuple) {
2134            var list = tuple[2], stateString = tuple[5];
2135            promise[tuple[1]] = list.add;
2136            if (stateString) {
2137              list.add(
2138                function() {
2139                  state = stateString;
2140                },
2141                // rejected_callbacks.disable
2142                // fulfilled_callbacks.disable
2143                tuples[3 - i][2].disable,
2144                // rejected_handlers.disable
2145                // fulfilled_handlers.disable
2146                tuples[3 - i][3].disable,
2147                // progress_callbacks.lock
2148                tuples[0][2].lock,
2149                // progress_handlers.lock
2150                tuples[0][3].lock
2151              );
2152            }
2153            list.add(tuple[3].fire);
2154            deferred[tuple[0]] = function() {
2155              deferred[tuple[0] + "With"](this === deferred ? void 0 : this, arguments);
2156              return this;
2157            };
2158            deferred[tuple[0] + "With"] = list.fireWith;
2159          });
2160          promise.promise(deferred);
2161          if (func) {
2162            func.call(deferred, deferred);
2163          }
2164          return deferred;
2165        },
2166        // Deferred helper
2167        when: function(singleValue) {
2168          var remaining = arguments.length, i = remaining, resolveContexts = Array(i), resolveValues = slice.call(arguments), primary = jQuery3.Deferred(), updateFunc = function(i2) {
2169            return function(value) {
2170              resolveContexts[i2] = this;
2171              resolveValues[i2] = arguments.length > 1 ? slice.call(arguments) : value;
2172              if (!--remaining) {
2173                primary.resolveWith(resolveContexts, resolveValues);
2174              }
2175            };
2176          };
2177          if (remaining <= 1) {
2178            adoptValue(
2179              singleValue,
2180              primary.done(updateFunc(i)).resolve,
2181              primary.reject,
2182              !remaining
2183            );
2184            if (primary.state() === "pending" || isFunction(resolveValues[i] && resolveValues[i].then)) {
2185              return primary.then();
2186            }
2187          }
2188          while (i--) {
2189            adoptValue(resolveValues[i], updateFunc(i), primary.reject);
2190          }
2191          return primary.promise();
2192        }
2193      });
2194      var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
2195      jQuery3.Deferred.exceptionHook = function(error, asyncError) {
2196        if (window2.console && window2.console.warn && error && rerrorNames.test(error.name)) {
2197          window2.console.warn(
2198            "jQuery.Deferred exception: " + error.message,
2199            error.stack,
2200            asyncError
2201          );
2202        }
2203      };
2204      jQuery3.readyException = function(error) {
2205        window2.setTimeout(function() {
2206          throw error;
2207        });
2208      };
2209      var readyList = jQuery3.Deferred();
2210      jQuery3.fn.ready = function(fn) {
2211        readyList.then(fn).catch(function(error) {
2212          jQuery3.readyException(error);
2213        });
2214        return this;
2215      };
2216      jQuery3.extend({
2217        // Is the DOM ready to be used? Set to true once it occurs.
2218        isReady: false,
2219        // A counter to track how many items to wait for before
2220        // the ready event fires. See trac-6781
2221        readyWait: 1,
2222        // Handle when the DOM is ready
2223        ready: function(wait) {
2224          if (wait === true ? --jQuery3.readyWait : jQuery3.isReady) {
2225            return;
2226          }
2227          jQuery3.isReady = true;
2228          if (wait !== true && --jQuery3.readyWait > 0) {
2229            return;
2230          }
2231          readyList.resolveWith(document2, [jQuery3]);
2232        }
2233      });
2234      jQuery3.ready.then = readyList.then;
2235      function completed() {
2236        document2.removeEventListener("DOMContentLoaded", completed);
2237        window2.removeEventListener("load", completed);
2238        jQuery3.ready();
2239      }
2240      if (document2.readyState === "complete" || document2.readyState !== "loading" && !document2.documentElement.doScroll) {
2241        window2.setTimeout(jQuery3.ready);
2242      } else {
2243        document2.addEventListener("DOMContentLoaded", completed);
2244        window2.addEventListener("load", completed);
2245      }
2246      var access = function(elems, fn, key, value, chainable, emptyGet, raw) {
2247        var i = 0, len = elems.length, bulk = key == null;
2248        if (toType(key) === "object") {
2249          chainable = true;
2250          for (i in key) {
2251            access(elems, fn, i, key[i], true, emptyGet, raw);
2252          }
2253        } else if (value !== void 0) {
2254          chainable = true;
2255          if (!isFunction(value)) {
2256            raw = true;
2257          }
2258          if (bulk) {
2259            if (raw) {
2260              fn.call(elems, value);
2261              fn = null;
2262            } else {
2263              bulk = fn;
2264              fn = function(elem, _key, value2) {
2265                return bulk.call(jQuery3(elem), value2);
2266              };
2267            }
2268          }
2269          if (fn) {
2270            for (; i < len; i++) {
2271              fn(
2272                elems[i],
2273                key,
2274                raw ? value : value.call(elems[i], i, fn(elems[i], key))
2275              );
2276            }
2277          }
2278        }
2279        if (chainable) {
2280          return elems;
2281        }
2282        if (bulk) {
2283          return fn.call(elems);
2284        }
2285        return len ? fn(elems[0], key) : emptyGet;
2286      };
2287      var rmsPrefix = /^-ms-/, rdashAlpha = /-([a-z])/g;
2288      function fcamelCase(_all, letter) {
2289        return letter.toUpperCase();
2290      }
2291      function camelCase(string) {
2292        return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
2293      }
2294      var acceptData = function(owner) {
2295        return owner.nodeType === 1 || owner.nodeType === 9 || !+owner.nodeType;
2296      };
2297      function Data() {
2298        this.expando = jQuery3.expando + Data.uid++;
2299      }
2300      Data.uid = 1;
2301      Data.prototype = {
2302        cache: function(owner) {
2303          var value = owner[this.expando];
2304          if (!value) {
2305            value = {};
2306            if (acceptData(owner)) {
2307              if (owner.nodeType) {
2308                owner[this.expando] = value;
2309              } else {
2310                Object.defineProperty(owner, this.expando, {
2311                  value,
2312                  configurable: true
2313                });
2314              }
2315            }
2316          }
2317          return value;
2318        },
2319        set: function(owner, data, value) {
2320          var prop, cache = this.cache(owner);
2321          if (typeof data === "string") {
2322            cache[camelCase(data)] = value;
2323          } else {
2324            for (prop in data) {
2325              cache[camelCase(prop)] = data[prop];
2326            }
2327          }
2328          return cache;
2329        },
2330        get: function(owner, key) {
2331          return key === void 0 ? this.cache(owner) : (
2332            // Always use camelCase key (gh-2257)
2333            owner[this.expando] && owner[this.expando][camelCase(key)]
2334          );
2335        },
2336        access: function(owner, key, value) {
2337          if (key === void 0 || key && typeof key === "string" && value === void 0) {
2338            return this.get(owner, key);
2339          }
2340          this.set(owner, key, value);
2341          return value !== void 0 ? value : key;
2342        },
2343        remove: function(owner, key) {
2344          var i, cache = owner[this.expando];
2345          if (cache === void 0) {
2346            return;
2347          }
2348          if (key !== void 0) {
2349            if (Array.isArray(key)) {
2350              key = key.map(camelCase);
2351            } else {
2352              key = camelCase(key);
2353              key = key in cache ? [key] : key.match(rnothtmlwhite) || [];
2354            }
2355            i = key.length;
2356            while (i--) {
2357              delete cache[key[i]];
2358            }
2359          }
2360          if (key === void 0 || jQuery3.isEmptyObject(cache)) {
2361            if (owner.nodeType) {
2362              owner[this.expando] = void 0;
2363            } else {
2364              delete owner[this.expando];
2365            }
2366          }
2367        },
2368        hasData: function(owner) {
2369          var cache = owner[this.expando];
2370          return cache !== void 0 && !jQuery3.isEmptyObject(cache);
2371        }
2372      };
2373      var dataPriv = new Data();
2374      var dataUser = new Data();
2375      var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, rmultiDash = /[A-Z]/g;
2376      function getData(data) {
2377        if (data === "true") {
2378          return true;
2379        }
2380        if (data === "false") {
2381          return false;
2382        }
2383        if (data === "null") {
2384          return null;
2385        }
2386        if (data === +data + "") {
2387          return +data;
2388        }
2389        if (rbrace.test(data)) {
2390          return JSON.parse(data);
2391        }
2392        return data;
2393      }
2394      function dataAttr(elem, key, data) {
2395        var name;
2396        if (data === void 0 && elem.nodeType === 1) {
2397          name = "data-" + key.replace(rmultiDash, "-$&").toLowerCase();
2398          data = elem.getAttribute(name);
2399          if (typeof data === "string") {
2400            try {
2401              data = getData(data);
2402            } catch (e) {
2403            }
2404            dataUser.set(elem, key, data);
2405          } else {
2406            data = void 0;
2407          }
2408        }
2409        return data;
2410      }
2411      jQuery3.extend({
2412        hasData: function(elem) {
2413          return dataUser.hasData(elem) || dataPriv.hasData(elem);
2414        },
2415        data: function(elem, name, data) {
2416          return dataUser.access(elem, name, data);
2417        },
2418        removeData: function(elem, name) {
2419          dataUser.remove(elem, name);
2420        },
2421        // TODO: Now that all calls to _data and _removeData have been replaced
2422        // with direct calls to dataPriv methods, these can be deprecated.
2423        _data: function(elem, name, data) {
2424          return dataPriv.access(elem, name, data);
2425        },
2426        _removeData: function(elem, name) {
2427          dataPriv.remove(elem, name);
2428        }
2429      });
2430      jQuery3.fn.extend({
2431        data: function(key, value) {
2432          var i, name, data, elem = this[0], attrs = elem && elem.attributes;
2433          if (key === void 0) {
2434            if (this.length) {
2435              data = dataUser.get(elem);
2436              if (elem.nodeType === 1 && !dataPriv.get(elem, "hasDataAttrs")) {
2437                i = attrs.length;
2438                while (i--) {
2439                  if (attrs[i]) {
2440                    name = attrs[i].name;
2441                    if (name.indexOf("data-") === 0) {
2442                      name = camelCase(name.slice(5));
2443                      dataAttr(elem, name, data[name]);
2444                    }
2445                  }
2446                }
2447                dataPriv.set(elem, "hasDataAttrs", true);
2448              }
2449            }
2450            return data;
2451          }
2452          if (typeof key === "object") {
2453            return this.each(function() {
2454              dataUser.set(this, key);
2455            });
2456          }
2457          return access(this, function(value2) {
2458            var data2;
2459            if (elem && value2 === void 0) {
2460              data2 = dataUser.get(elem, key);
2461              if (data2 !== void 0) {
2462                return data2;
2463              }
2464              data2 = dataAttr(elem, key);
2465              if (data2 !== void 0) {
2466                return data2;
2467              }
2468              return;
2469            }
2470            this.each(function() {
2471              dataUser.set(this, key, value2);
2472            });
2473          }, null, value, arguments.length > 1, null, true);
2474        },
2475        removeData: function(key) {
2476          return this.each(function() {
2477            dataUser.remove(this, key);
2478          });
2479        }
2480      });
2481      jQuery3.extend({
2482        queue: function(elem, type, data) {
2483          var queue;
2484          if (elem) {
2485            type = (type || "fx") + "queue";
2486            queue = dataPriv.get(elem, type);
2487            if (data) {
2488              if (!queue || Array.isArray(data)) {
2489                queue = dataPriv.access(elem, type, jQuery3.makeArray(data));
2490              } else {
2491                queue.push(data);
2492              }
2493            }
2494            return queue || [];
2495          }
2496        },
2497        dequeue: function(elem, type) {
2498          type = type || "fx";
2499          var queue = jQuery3.queue(elem, type), startLength = queue.length, fn = queue.shift(), hooks = jQuery3._queueHooks(elem, type), next = function() {
2500            jQuery3.dequeue(elem, type);
2501          };
2502          if (fn === "inprogress") {
2503            fn = queue.shift();
2504            startLength--;
2505          }
2506          if (fn) {
2507            if (type === "fx") {
2508              queue.unshift("inprogress");
2509            }
2510            delete hooks.stop;
2511            fn.call(elem, next, hooks);
2512          }
2513          if (!startLength && hooks) {
2514            hooks.empty.fire();
2515          }
2516        },
2517        // Not public - generate a queueHooks object, or return the current one
2518        _queueHooks: function(elem, type) {
2519          var key = type + "queueHooks";
2520          return dataPriv.get(elem, key) || dataPriv.access(elem, key, {
2521            empty: jQuery3.Callbacks("once memory").add(function() {
2522              dataPriv.remove(elem, [type + "queue", key]);
2523            })
2524          });
2525        }
2526      });
2527      jQuery3.fn.extend({
2528        queue: function(type, data) {
2529          var setter = 2;
2530          if (typeof type !== "string") {
2531            data = type;
2532            type = "fx";
2533            setter--;
2534          }
2535          if (arguments.length < setter) {
2536            return jQuery3.queue(this[0], type);
2537          }
2538          return data === void 0 ? this : this.each(function() {
2539            var queue = jQuery3.queue(this, type, data);
2540            jQuery3._queueHooks(this, type);
2541            if (type === "fx" && queue[0] !== "inprogress") {
2542              jQuery3.dequeue(this, type);
2543            }
2544          });
2545        },
2546        dequeue: function(type) {
2547          return this.each(function() {
2548            jQuery3.dequeue(this, type);
2549          });
2550        },
2551        clearQueue: function(type) {
2552          return this.queue(type || "fx", []);
2553        },
2554        // Get a promise resolved when queues of a certain type
2555        // are emptied (fx is the type by default)
2556        promise: function(type, obj) {
2557          var tmp, count = 1, defer = jQuery3.Deferred(), elements = this, i = this.length, resolve = function() {
2558            if (!--count) {
2559              defer.resolveWith(elements, [elements]);
2560            }
2561          };
2562          if (typeof type !== "string") {
2563            obj = type;
2564            type = void 0;
2565          }
2566          type = type || "fx";
2567          while (i--) {
2568            tmp = dataPriv.get(elements[i], type + "queueHooks");
2569            if (tmp && tmp.empty) {
2570              count++;
2571              tmp.empty.add(resolve);
2572            }
2573          }
2574          resolve();
2575          return defer.promise(obj);
2576        }
2577      });
2578      var pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source;
2579      var rcssNum = new RegExp("^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i");
2580      var cssExpand = ["Top", "Right", "Bottom", "Left"];
2581      var documentElement = document2.documentElement;
2582      var isAttached = function(elem) {
2583        return jQuery3.contains(elem.ownerDocument, elem);
2584      }, composed = { composed: true };
2585      if (documentElement.getRootNode) {
2586        isAttached = function(elem) {
2587          return jQuery3.contains(elem.ownerDocument, elem) || elem.getRootNode(composed) === elem.ownerDocument;
2588        };
2589      }
2590      var isHiddenWithinTree = function(elem, el) {
2591        elem = el || elem;
2592        return elem.style.display === "none" || elem.style.display === "" && // Otherwise, check computed style
2593        // Support: Firefox <=43 - 45
2594        // Disconnected elements can have computed display: none, so first confirm that elem is
2595        // in the document.
2596        isAttached(elem) && jQuery3.css(elem, "display") === "none";
2597      };
2598      function adjustCSS(elem, prop, valueParts, tween) {
2599        var adjusted, scale, maxIterations = 20, currentValue = tween ? function() {
2600          return tween.cur();
2601        } : function() {
2602          return jQuery3.css(elem, prop, "");
2603        }, initial = currentValue(), unit = valueParts && valueParts[3] || (jQuery3.cssNumber[prop] ? "" : "px"), initialInUnit = elem.nodeType && (jQuery3.cssNumber[prop] || unit !== "px" && +initial) && rcssNum.exec(jQuery3.css(elem, prop));
2604        if (initialInUnit && initialInUnit[3] !== unit) {
2605          initial = initial / 2;
2606          unit = unit || initialInUnit[3];
2607          initialInUnit = +initial || 1;
2608          while (maxIterations--) {
2609            jQuery3.style(elem, prop, initialInUnit + unit);
2610            if ((1 - scale) * (1 - (scale = currentValue() / initial || 0.5)) <= 0) {
2611              maxIterations = 0;
2612            }
2613            initialInUnit = initialInUnit / scale;
2614          }
2615          initialInUnit = initialInUnit * 2;
2616          jQuery3.style(elem, prop, initialInUnit + unit);
2617          valueParts = valueParts || [];
2618        }
2619        if (valueParts) {
2620          initialInUnit = +initialInUnit || +initial || 0;
2621          adjusted = valueParts[1] ? initialInUnit + (valueParts[1] + 1) * valueParts[2] : +valueParts[2];
2622          if (tween) {
2623            tween.unit = unit;
2624            tween.start = initialInUnit;
2625            tween.end = adjusted;
2626          }
2627        }
2628        return adjusted;
2629      }
2630      var defaultDisplayMap = {};
2631      function getDefaultDisplay(elem) {
2632        var temp, doc = elem.ownerDocument, nodeName2 = elem.nodeName, display = defaultDisplayMap[nodeName2];
2633        if (display) {
2634          return display;
2635        }
2636        temp = doc.body.appendChild(doc.createElement(nodeName2));
2637        display = jQuery3.css(temp, "display");
2638        temp.parentNode.removeChild(temp);
2639        if (display === "none") {
2640          display = "block";
2641        }
2642        defaultDisplayMap[nodeName2] = display;
2643        return display;
2644      }
2645      function showHide(elements, show) {
2646        var display, elem, values = [], index = 0, length = elements.length;
2647        for (; index < length; index++) {
2648          elem = elements[index];
2649          if (!elem.style) {
2650            continue;
2651          }
2652          display = elem.style.display;
2653          if (show) {
2654            if (display === "none") {
2655              values[index] = dataPriv.get(elem, "display") || null;
2656              if (!values[index]) {
2657                elem.style.display = "";
2658              }
2659            }
2660            if (elem.style.display === "" && isHiddenWithinTree(elem)) {
2661              values[index] = getDefaultDisplay(elem);
2662            }
2663          } else {
2664            if (display !== "none") {
2665              values[index] = "none";
2666              dataPriv.set(elem, "display", display);
2667            }
2668          }
2669        }
2670        for (index = 0; index < length; index++) {
2671          if (values[index] != null) {
2672            elements[index].style.display = values[index];
2673          }
2674        }
2675        return elements;
2676      }
2677      jQuery3.fn.extend({
2678        show: function() {
2679          return showHide(this, true);
2680        },
2681        hide: function() {
2682          return showHide(this);
2683        },
2684        toggle: function(state) {
2685          if (typeof state === "boolean") {
2686            return state ? this.show() : this.hide();
2687          }
2688          return this.each(function() {
2689            if (isHiddenWithinTree(this)) {
2690              jQuery3(this).show();
2691            } else {
2692              jQuery3(this).hide();
2693            }
2694          });
2695        }
2696      });
2697      var rcheckableType = /^(?:checkbox|radio)$/i;
2698      var rtagName = /<([a-z][^\/\0>\x20\t\r\n\f]*)/i;
2699      var rscriptType = /^$|^module$|\/(?:java|ecma)script/i;
2700      (function() {
2701        var fragment = document2.createDocumentFragment(), div = fragment.appendChild(document2.createElement("div")), input = document2.createElement("input");
2702        input.setAttribute("type", "radio");
2703        input.setAttribute("checked", "checked");
2704        input.setAttribute("name", "t");
2705        div.appendChild(input);
2706        support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked;
2707        div.innerHTML = "<textarea>x</textarea>";
2708        support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue;
2709        div.innerHTML = "<option></option>";
2710        support.option = !!div.lastChild;
2711      })();
2712      var wrapMap = {
2713        // XHTML parsers do not magically insert elements in the
2714        // same way that tag soup parsers do. So we cannot shorten
2715        // this by omitting <tbody> or other required elements.
2716        thead: [1, "<table>", "</table>"],
2717        col: [2, "<table><colgroup>", "</colgroup></table>"],
2718        tr: [2, "<table><tbody>", "</tbody></table>"],
2719        td: [3, "<table><tbody><tr>", "</tr></tbody></table>"],
2720        _default: [0, "", ""]
2721      };
2722      wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
2723      wrapMap.th = wrapMap.td;
2724      if (!support.option) {
2725        wrapMap.optgroup = wrapMap.option = [1, "<select multiple='multiple'>", "</select>"];
2726      }
2727      function getAll(context, tag) {
2728        var ret;
2729        if (typeof context.getElementsByTagName !== "undefined") {
2730          ret = context.getElementsByTagName(tag || "*");
2731        } else if (typeof context.querySelectorAll !== "undefined") {
2732          ret = context.querySelectorAll(tag || "*");
2733        } else {
2734          ret = [];
2735        }
2736        if (tag === void 0 || tag && nodeName(context, tag)) {
2737          return jQuery3.merge([context], ret);
2738        }
2739        return ret;
2740      }
2741      function setGlobalEval(elems, refElements) {
2742        var i = 0, l = elems.length;
2743        for (; i < l; i++) {
2744          dataPriv.set(
2745            elems[i],
2746            "globalEval",
2747            !refElements || dataPriv.get(refElements[i], "globalEval")
2748          );
2749        }
2750      }
2751      var rhtml = /<|&#?\w+;/;
2752      function buildFragment(elems, context, scripts, selection, ignored) {
2753        var elem, tmp, tag, wrap, attached, j, fragment = context.createDocumentFragment(), nodes = [], i = 0, l = elems.length;
2754        for (; i < l; i++) {
2755          elem = elems[i];
2756          if (elem || elem === 0) {
2757            if (toType(elem) === "object") {
2758              jQuery3.merge(nodes, elem.nodeType ? [elem] : elem);
2759            } else if (!rhtml.test(elem)) {
2760              nodes.push(context.createTextNode(elem));
2761            } else {
2762              tmp = tmp || fragment.appendChild(context.createElement("div"));
2763              tag = (rtagName.exec(elem) || ["", ""])[1].toLowerCase();
2764              wrap = wrapMap[tag] || wrapMap._default;
2765              tmp.innerHTML = wrap[1] + jQuery3.htmlPrefilter(elem) + wrap[2];
2766              j = wrap[0];
2767              while (j--) {
2768                tmp = tmp.lastChild;
2769              }
2770              jQuery3.merge(nodes, tmp.childNodes);
2771              tmp = fragment.firstChild;
2772              tmp.textContent = "";
2773            }
2774          }
2775        }
2776        fragment.textContent = "";
2777        i = 0;
2778        while (elem = nodes[i++]) {
2779          if (selection && jQuery3.inArray(elem, selection) > -1) {
2780            if (ignored) {
2781              ignored.push(elem);
2782            }
2783            continue;
2784          }
2785          attached = isAttached(elem);
2786          tmp = getAll(fragment.appendChild(elem), "script");
2787          if (attached) {
2788            setGlobalEval(tmp);
2789          }
2790          if (scripts) {
2791            j = 0;
2792            while (elem = tmp[j++]) {
2793              if (rscriptType.test(elem.type || "")) {
2794                scripts.push(elem);
2795              }
2796            }
2797          }
2798        }
2799        return fragment;
2800      }
2801      var rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
2802      function returnTrue() {
2803        return true;
2804      }
2805      function returnFalse() {
2806        return false;
2807      }
2808      function on(elem, types, selector, data, fn, one) {
2809        var origFn, type;
2810        if (typeof types === "object") {
2811          if (typeof selector !== "string") {
2812            data = data || selector;
2813            selector = void 0;
2814          }
2815          for (type in types) {
2816            on(elem, type, selector, data, types[type], one);
2817          }
2818          return elem;
2819        }
2820        if (data == null && fn == null) {
2821          fn = selector;
2822          data = selector = void 0;
2823        } else if (fn == null) {
2824          if (typeof selector === "string") {
2825            fn = data;
2826            data = void 0;
2827          } else {
2828            fn = data;
2829            data = selector;
2830            selector = void 0;
2831          }
2832        }
2833        if (fn === false) {
2834          fn = returnFalse;
2835        } else if (!fn) {
2836          return elem;
2837        }
2838        if (one === 1) {
2839          origFn = fn;
2840          fn = function(event) {
2841            jQuery3().off(event);
2842            return origFn.apply(this, arguments);
2843          };
2844          fn.guid = origFn.guid || (origFn.guid = jQuery3.guid++);
2845        }
2846        return elem.each(function() {
2847          jQuery3.event.add(this, types, fn, data, selector);
2848        });
2849      }
2850      jQuery3.event = {
2851        global: {},
2852        add: function(elem, types, handler, data, selector) {
2853          var handleObjIn, eventHandle, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.get(elem);
2854          if (!acceptData(elem)) {
2855            return;
2856          }
2857          if (handler.handler) {
2858            handleObjIn = handler;
2859            handler = handleObjIn.handler;
2860            selector = handleObjIn.selector;
2861          }
2862          if (selector) {
2863            jQuery3.find.matchesSelector(documentElement, selector);
2864          }
2865          if (!handler.guid) {
2866            handler.guid = jQuery3.guid++;
2867          }
2868          if (!(events = elemData.events)) {
2869            events = elemData.events = /* @__PURE__ */ Object.create(null);
2870          }
2871          if (!(eventHandle = elemData.handle)) {
2872            eventHandle = elemData.handle = function(e) {
2873              return typeof jQuery3 !== "undefined" && jQuery3.event.triggered !== e.type ? jQuery3.event.dispatch.apply(elem, arguments) : void 0;
2874            };
2875          }
2876          types = (types || "").match(rnothtmlwhite) || [""];
2877          t = types.length;
2878          while (t--) {
2879            tmp = rtypenamespace.exec(types[t]) || [];
2880            type = origType = tmp[1];
2881            namespaces = (tmp[2] || "").split(".").sort();
2882            if (!type) {
2883              continue;
2884            }
2885            special = jQuery3.event.special[type] || {};
2886            type = (selector ? special.delegateType : special.bindType) || type;
2887            special = jQuery3.event.special[type] || {};
2888            handleObj = jQuery3.extend({
2889              type,
2890              origType,
2891              data,
2892              handler,
2893              guid: handler.guid,
2894              selector,
2895              needsContext: selector && jQuery3.expr.match.needsContext.test(selector),
2896              namespace: namespaces.join(".")
2897            }, handleObjIn);
2898            if (!(handlers = events[type])) {
2899              handlers = events[type] = [];
2900              handlers.delegateCount = 0;
2901              if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false) {
2902                if (elem.addEventListener) {
2903                  elem.addEventListener(type, eventHandle);
2904                }
2905              }
2906            }
2907            if (special.add) {
2908              special.add.call(elem, handleObj);
2909              if (!handleObj.handler.guid) {
2910                handleObj.handler.guid = handler.guid;
2911              }
2912            }
2913            if (selector) {
2914              handlers.splice(handlers.delegateCount++, 0, handleObj);
2915            } else {
2916              handlers.push(handleObj);
2917            }
2918            jQuery3.event.global[type] = true;
2919          }
2920        },
2921        // Detach an event or set of events from an element
2922        remove: function(elem, types, handler, selector, mappedTypes) {
2923          var j, origCount, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.hasData(elem) && dataPriv.get(elem);
2924          if (!elemData || !(events = elemData.events)) {
2925            return;
2926          }
2927          types = (types || "").match(rnothtmlwhite) || [""];
2928          t = types.length;
2929          while (t--) {
2930            tmp = rtypenamespace.exec(types[t]) || [];
2931            type = origType = tmp[1];
2932            namespaces = (tmp[2] || "").split(".").sort();
2933            if (!type) {
2934              for (type in events) {
2935                jQuery3.event.remove(elem, type + types[t], handler, selector, true);
2936              }
2937              continue;
2938            }
2939            special = jQuery3.event.special[type] || {};
2940            type = (selector ? special.delegateType : special.bindType) || type;
2941            handlers = events[type] || [];
2942            tmp = tmp[2] && new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)");
2943            origCount = j = handlers.length;
2944            while (j--) {
2945              handleObj = handlers[j];
2946              if ((mappedTypes || origType === handleObj.origType) && (!handler || handler.guid === handleObj.guid) && (!tmp || tmp.test(handleObj.namespace)) && (!selector || selector === handleObj.selector || selector === "**" && handleObj.selector)) {
2947                handlers.splice(j, 1);
2948                if (handleObj.selector) {
2949                  handlers.delegateCount--;
2950                }
2951                if (special.remove) {
2952                  special.remove.call(elem, handleObj);
2953                }
2954              }
2955            }
2956            if (origCount && !handlers.length) {
2957              if (!special.teardown || special.teardown.call(elem, namespaces, elemData.handle) === false) {
2958                jQuery3.removeEvent(elem, type, elemData.handle);
2959              }
2960              delete events[type];
2961            }
2962          }
2963          if (jQuery3.isEmptyObject(events)) {
2964            dataPriv.remove(elem, "handle events");
2965          }
2966        },
2967        dispatch: function(nativeEvent) {
2968          var i, j, ret, matched, handleObj, handlerQueue, args = new Array(arguments.length), event = jQuery3.event.fix(nativeEvent), handlers = (dataPriv.get(this, "events") || /* @__PURE__ */ Object.create(null))[event.type] || [], special = jQuery3.event.special[event.type] || {};
2969          args[0] = event;
2970          for (i = 1; i < arguments.length; i++) {
2971            args[i] = arguments[i];
2972          }
2973          event.delegateTarget = this;
2974          if (special.preDispatch && special.preDispatch.call(this, event) === false) {
2975            return;
2976          }
2977          handlerQueue = jQuery3.event.handlers.call(this, event, handlers);
2978          i = 0;
2979          while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) {
2980            event.currentTarget = matched.elem;
2981            j = 0;
2982            while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) {
2983              if (!event.rnamespace || handleObj.namespace === false || event.rnamespace.test(handleObj.namespace)) {
2984                event.handleObj = handleObj;
2985                event.data = handleObj.data;
2986                ret = ((jQuery3.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args);
2987                if (ret !== void 0) {
2988                  if ((event.result = ret) === false) {
2989                    event.preventDefault();
2990                    event.stopPropagation();
2991                  }
2992                }
2993              }
2994            }
2995          }
2996          if (special.postDispatch) {
2997            special.postDispatch.call(this, event);
2998          }
2999          return event.result;
3000        },
3001        handlers: function(event, handlers) {
3002          var i, handleObj, sel, matchedHandlers, matchedSelectors, handlerQueue = [], delegateCount = handlers.delegateCount, cur = event.target;
3003          if (delegateCount && // Support: IE <=9
3004          // Black-hole SVG <use> instance trees (trac-13180)
3005          cur.nodeType && // Support: Firefox <=42
3006          // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
3007          // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
3008          // Support: IE 11 only
3009          // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
3010          !(event.type === "click" && event.button >= 1)) {
3011            for (; cur !== this; cur = cur.parentNode || this) {
3012              if (cur.nodeType === 1 && !(event.type === "click" && cur.disabled === true)) {
3013                matchedHandlers = [];
3014                matchedSelectors = {};
3015                for (i = 0; i < delegateCount; i++) {
3016                  handleObj = handlers[i];
3017                  sel = handleObj.selector + " ";
3018                  if (matchedSelectors[sel] === void 0) {
3019                    matchedSelectors[sel] = handleObj.needsContext ? jQuery3(sel, this).index(cur) > -1 : jQuery3.find(sel, this, null, [cur]).length;
3020                  }
3021                  if (matchedSelectors[sel]) {
3022                    matchedHandlers.push(handleObj);
3023                  }
3024                }
3025                if (matchedHandlers.length) {
3026                  handlerQueue.push({ elem: cur, handlers: matchedHandlers });
3027                }
3028              }
3029            }
3030          }
3031          cur = this;
3032          if (delegateCount < handlers.length) {
3033            handlerQueue.push({ elem: cur, handlers: handlers.slice(delegateCount) });
3034          }
3035          return handlerQueue;
3036        },
3037        addProp: function(name, hook) {
3038          Object.defineProperty(jQuery3.Event.prototype, name, {
3039            enumerable: true,
3040            configurable: true,
3041            get: isFunction(hook) ? function() {
3042              if (this.originalEvent) {
3043                return hook(this.originalEvent);
3044              }
3045            } : function() {
3046              if (this.originalEvent) {
3047                return this.originalEvent[name];
3048              }
3049            },
3050            set: function(value) {
3051              Object.defineProperty(this, name, {
3052                enumerable: true,
3053                configurable: true,
3054                writable: true,
3055                value
3056              });
3057            }
3058          });
3059        },
3060        fix: function(originalEvent) {
3061          return originalEvent[jQuery3.expando] ? originalEvent : new jQuery3.Event(originalEvent);
3062        },
3063        special: {
3064          load: {
3065            // Prevent triggered image.load events from bubbling to window.load
3066            noBubble: true
3067          },
3068          click: {
3069            // Utilize native event to ensure correct state for checkable inputs
3070            setup: function(data) {
3071              var el = this || data;
3072              if (rcheckableType.test(el.type) && el.click && nodeName(el, "input")) {
3073                leverageNative(el, "click", true);
3074              }
3075              return false;
3076            },
3077            trigger: function(data) {
3078              var el = this || data;
3079              if (rcheckableType.test(el.type) && el.click && nodeName(el, "input")) {
3080                leverageNative(el, "click");
3081              }
3082              return true;
3083            },
3084            // For cross-browser consistency, suppress native .click() on links
3085            // Also prevent it if we're currently inside a leveraged native-event stack
3086            _default: function(event) {
3087              var target = event.target;
3088              return rcheckableType.test(target.type) && target.click && nodeName(target, "input") && dataPriv.get(target, "click") || nodeName(target, "a");
3089            }
3090          },
3091          beforeunload: {
3092            postDispatch: function(event) {
3093              if (event.result !== void 0 && event.originalEvent) {
3094                event.originalEvent.returnValue = event.result;
3095              }
3096            }
3097          }
3098        }
3099      };
3100      function leverageNative(el, type, isSetup) {
3101        if (!isSetup) {
3102          if (dataPriv.get(el, type) === void 0) {
3103            jQuery3.event.add(el, type, returnTrue);
3104          }
3105          return;
3106        }
3107        dataPriv.set(el, type, false);
3108        jQuery3.event.add(el, type, {
3109          namespace: false,
3110          handler: function(event) {
3111            var result, saved = dataPriv.get(this, type);
3112            if (event.isTrigger & 1 && this[type]) {
3113              if (!saved) {
3114                saved = slice.call(arguments);
3115                dataPriv.set(this, type, saved);
3116                this[type]();
3117                result = dataPriv.get(this, type);
3118                dataPriv.set(this, type, false);
3119                if (saved !== result) {
3120                  event.stopImmediatePropagation();
3121                  event.preventDefault();
3122                  return result;
3123                }
3124              } else if ((jQuery3.event.special[type] || {}).delegateType) {
3125                event.stopPropagation();
3126              }
3127            } else if (saved) {
3128              dataPriv.set(this, type, jQuery3.event.trigger(
3129                saved[0],
3130                saved.slice(1),
3131                this
3132              ));
3133              event.stopPropagation();
3134              event.isImmediatePropagationStopped = returnTrue;
3135            }
3136          }
3137        });
3138      }
3139      jQuery3.removeEvent = function(elem, type, handle) {
3140        if (elem.removeEventListener) {
3141          elem.removeEventListener(type, handle);
3142        }
3143      };
3144      jQuery3.Event = function(src, props) {
3145        if (!(this instanceof jQuery3.Event)) {
3146          return new jQuery3.Event(src, props);
3147        }
3148        if (src && src.type) {
3149          this.originalEvent = src;
3150          this.type = src.type;
3151          this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === void 0 && // Support: Android <=2.3 only
3152          src.returnValue === false ? returnTrue : returnFalse;
3153          this.target = src.target && src.target.nodeType === 3 ? src.target.parentNode : src.target;
3154          this.currentTarget = src.currentTarget;
3155          this.relatedTarget = src.relatedTarget;
3156        } else {
3157          this.type = src;
3158        }
3159        if (props) {
3160          jQuery3.extend(this, props);
3161        }
3162        this.timeStamp = src && src.timeStamp || Date.now();
3163        this[jQuery3.expando] = true;
3164      };
3165      jQuery3.Event.prototype = {
3166        constructor: jQuery3.Event,
3167        isDefaultPrevented: returnFalse,
3168        isPropagationStopped: returnFalse,
3169        isImmediatePropagationStopped: returnFalse,
3170        isSimulated: false,
3171        preventDefault: function() {
3172          var e = this.originalEvent;
3173          this.isDefaultPrevented = returnTrue;
3174          if (e && !this.isSimulated) {
3175            e.preventDefault();
3176          }
3177        },
3178        stopPropagation: function() {
3179          var e = this.originalEvent;
3180          this.isPropagationStopped = returnTrue;
3181          if (e && !this.isSimulated) {
3182            e.stopPropagation();
3183          }
3184        },
3185        stopImmediatePropagation: function() {
3186          var e = this.originalEvent;
3187          this.isImmediatePropagationStopped = returnTrue;
3188          if (e && !this.isSimulated) {
3189            e.stopImmediatePropagation();
3190          }
3191          this.stopPropagation();
3192        }
3193      };
3194      jQuery3.each({
3195        altKey: true,
3196        bubbles: true,
3197        cancelable: true,
3198        changedTouches: true,
3199        ctrlKey: true,
3200        detail: true,
3201        eventPhase: true,
3202        metaKey: true,
3203        pageX: true,
3204        pageY: true,
3205        shiftKey: true,
3206        view: true,
3207        "char": true,
3208        code: true,
3209        charCode: true,
3210        key: true,
3211        keyCode: true,
3212        button: true,
3213        buttons: true,
3214        clientX: true,
3215        clientY: true,
3216        offsetX: true,
3217        offsetY: true,
3218        pointerId: true,
3219        pointerType: true,
3220        screenX: true,
3221        screenY: true,
3222        targetTouches: true,
3223        toElement: true,
3224        touches: true,
3225        which: true
3226      }, jQuery3.event.addProp);
3227      jQuery3.each({ focus: "focusin", blur: "focusout" }, function(type, delegateType) {
3228        function focusMappedHandler(nativeEvent) {
3229          if (document2.documentMode) {
3230            var handle = dataPriv.get(this, "handle"), event = jQuery3.event.fix(nativeEvent);
3231            event.type = nativeEvent.type === "focusin" ? "focus" : "blur";
3232            event.isSimulated = true;
3233            handle(nativeEvent);
3234            if (event.target === event.currentTarget) {
3235              handle(event);
3236            }
3237          } else {
3238            jQuery3.event.simulate(
3239              delegateType,
3240              nativeEvent.target,
3241              jQuery3.event.fix(nativeEvent)
3242            );
3243          }
3244        }
3245        jQuery3.event.special[type] = {
3246          // Utilize native event if possible so blur/focus sequence is correct
3247          setup: function() {
3248            var attaches;
3249            leverageNative(this, type, true);
3250            if (document2.documentMode) {
3251              attaches = dataPriv.get(this, delegateType);
3252              if (!attaches) {
3253                this.addEventListener(delegateType, focusMappedHandler);
3254              }
3255              dataPriv.set(this, delegateType, (attaches || 0) + 1);
3256            } else {
3257              return false;
3258            }
3259          },
3260          trigger: function() {
3261            leverageNative(this, type);
3262            return true;
3263          },
3264          teardown: function() {
3265            var attaches;
3266            if (document2.documentMode) {
3267              attaches = dataPriv.get(this, delegateType) - 1;
3268              if (!attaches) {
3269                this.removeEventListener(delegateType, focusMappedHandler);
3270                dataPriv.remove(this, delegateType);
3271              } else {
3272                dataPriv.set(this, delegateType, attaches);
3273              }
3274            } else {
3275              return false;
3276            }
3277          },
3278          // Suppress native focus or blur if we're currently inside
3279          // a leveraged native-event stack
3280          _default: function(event) {
3281            return dataPriv.get(event.target, type);
3282          },
3283          delegateType
3284        };
3285        jQuery3.event.special[delegateType] = {
3286          setup: function() {
3287            var doc = this.ownerDocument || this.document || this, dataHolder = document2.documentMode ? this : doc, attaches = dataPriv.get(dataHolder, delegateType);
3288            if (!attaches) {
3289              if (document2.documentMode) {
3290                this.addEventListener(delegateType, focusMappedHandler);
3291              } else {
3292                doc.addEventListener(type, focusMappedHandler, true);
3293              }
3294            }
3295            dataPriv.set(dataHolder, delegateType, (attaches || 0) + 1);
3296          },
3297          teardown: function() {
3298            var doc = this.ownerDocument || this.document || this, dataHolder = document2.documentMode ? this : doc, attaches = dataPriv.get(dataHolder, delegateType) - 1;
3299            if (!attaches) {
3300              if (document2.documentMode) {
3301                this.removeEventListener(delegateType, focusMappedHandler);
3302              } else {
3303                doc.removeEventListener(type, focusMappedHandler, true);
3304              }
3305              dataPriv.remove(dataHolder, delegateType);
3306            } else {
3307              dataPriv.set(dataHolder, delegateType, attaches);
3308            }
3309          }
3310        };
3311      });
3312      jQuery3.each({
3313        mouseenter: "mouseover",
3314        mouseleave: "mouseout",
3315        pointerenter: "pointerover",
3316        pointerleave: "pointerout"
3317      }, function(orig, fix) {
3318        jQuery3.event.special[orig] = {
3319          delegateType: fix,
3320          bindType: fix,
3321          handle: function(event) {
3322            var ret, target = this, related = event.relatedTarget, handleObj = event.handleObj;
3323            if (!related || related !== target && !jQuery3.contains(target, related)) {
3324              event.type = handleObj.origType;
3325              ret = handleObj.handler.apply(this, arguments);
3326              event.type = fix;
3327            }
3328            return ret;
3329          }
3330        };
3331      });
3332      jQuery3.fn.extend({
3333        on: function(types, selector, data, fn) {
3334          return on(this, types, selector, data, fn);
3335        },
3336        one: function(types, selector, data, fn) {
3337          return on(this, types, selector, data, fn, 1);
3338        },
3339        off: function(types, selector, fn) {
3340          var handleObj, type;
3341          if (types && types.preventDefault && types.handleObj) {
3342            handleObj = types.handleObj;
3343            jQuery3(types.delegateTarget).off(
3344              handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
3345              handleObj.selector,
3346              handleObj.handler
3347            );
3348            return this;
3349          }
3350          if (typeof types === "object") {
3351            for (type in types) {
3352              this.off(type, selector, types[type]);
3353            }
3354            return this;
3355          }
3356          if (selector === false || typeof selector === "function") {
3357            fn = selector;
3358            selector = void 0;
3359          }
3360          if (fn === false) {
3361            fn = returnFalse;
3362          }
3363          return this.each(function() {
3364            jQuery3.event.remove(this, types, fn, selector);
3365          });
3366        }
3367      });
3368      var rnoInnerhtml = /<script|<style|<link/i, rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, rcleanScript = /^\s*<!\[CDATA\[|\]\]>\s*$/g;
3369      function manipulationTarget(elem, content) {
3370        if (nodeName(elem, "table") && nodeName(content.nodeType !== 11 ? content : content.firstChild, "tr")) {
3371          return jQuery3(elem).children("tbody")[0] || elem;
3372        }
3373        return elem;
3374      }
3375      function disableScript(elem) {
3376        elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type;
3377        return elem;
3378      }
3379      function restoreScript(elem) {
3380        if ((elem.type || "").slice(0, 5) === "true/") {
3381          elem.type = elem.type.slice(5);
3382        } else {
3383          elem.removeAttribute("type");
3384        }
3385        return elem;
3386      }
3387      function cloneCopyEvent(src, dest) {
3388        var i, l, type, pdataOld, udataOld, udataCur, events;
3389        if (dest.nodeType !== 1) {
3390          return;
3391        }
3392        if (dataPriv.hasData(src)) {
3393          pdataOld = dataPriv.get(src);
3394          events = pdataOld.events;
3395          if (events) {
3396            dataPriv.remove(dest, "handle events");
3397            for (type in events) {
3398              for (i = 0, l = events[type].length; i < l; i++) {
3399                jQuery3.event.add(dest, type, events[type][i]);
3400              }
3401            }
3402          }
3403        }
3404        if (dataUser.hasData(src)) {
3405          udataOld = dataUser.access(src);
3406          udataCur = jQuery3.extend({}, udataOld);
3407          dataUser.set(dest, udataCur);
3408        }
3409      }
3410      function fixInput(src, dest) {
3411        var nodeName2 = dest.nodeName.toLowerCase();
3412        if (nodeName2 === "input" && rcheckableType.test(src.type)) {
3413          dest.checked = src.checked;
3414        } else if (nodeName2 === "input" || nodeName2 === "textarea") {
3415          dest.defaultValue = src.defaultValue;
3416        }
3417      }
3418      function domManip(collection, args, callback, ignored) {
3419        args = flat(args);
3420        var fragment, first, scripts, hasScripts, node, doc, i = 0, l = collection.length, iNoClone = l - 1, value = args[0], valueIsFunction = isFunction(value);
3421        if (valueIsFunction || l > 1 && typeof value === "string" && !support.checkClone && rchecked.test(value)) {
3422          return collection.each(function(index) {
3423            var self = collection.eq(index);
3424            if (valueIsFunction) {
3425              args[0] = value.call(this, index, self.html());
3426            }
3427            domManip(self, args, callback, ignored);
3428          });
3429        }
3430        if (l) {
3431          fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored);
3432          first = fragment.firstChild;
3433          if (fragment.childNodes.length === 1) {
3434            fragment = first;
3435          }
3436          if (first || ignored) {
3437            scripts = jQuery3.map(getAll(fragment, "script"), disableScript);
3438            hasScripts = scripts.length;
3439            for (; i < l; i++) {
3440              node = fragment;
3441              if (i !== iNoClone) {
3442                node = jQuery3.clone(node, true, true);
3443                if (hasScripts) {
3444                  jQuery3.merge(scripts, getAll(node, "script"));
3445                }
3446              }
3447              callback.call(collection[i], node, i);
3448            }
3449            if (hasScripts) {
3450              doc = scripts[scripts.length - 1].ownerDocument;
3451              jQuery3.map(scripts, restoreScript);
3452              for (i = 0; i < hasScripts; i++) {
3453                node = scripts[i];
3454                if (rscriptType.test(node.type || "") && !dataPriv.access(node, "globalEval") && jQuery3.contains(doc, node)) {
3455                  if (node.src && (node.type || "").toLowerCase() !== "module") {
3456                    if (jQuery3._evalUrl && !node.noModule) {
3457                      jQuery3._evalUrl(node.src, {
3458                        nonce: node.nonce || node.getAttribute("nonce")
3459                      }, doc);
3460                    }
3461                  } else {
3462                    DOMEval(node.textContent.replace(rcleanScript, ""), node, doc);
3463                  }
3464                }
3465              }
3466            }
3467          }
3468        }
3469        return collection;
3470      }
3471      function remove(elem, selector, keepData) {
3472        var node, nodes = selector ? jQuery3.filter(selector, elem) : elem, i = 0;
3473        for (; (node = nodes[i]) != null; i++) {
3474          if (!keepData && node.nodeType === 1) {
3475            jQuery3.cleanData(getAll(node));
3476          }
3477          if (node.parentNode) {
3478            if (keepData && isAttached(node)) {
3479              setGlobalEval(getAll(node, "script"));
3480            }
3481            node.parentNode.removeChild(node);
3482          }
3483        }
3484        return elem;
3485      }
3486      jQuery3.extend({
3487        htmlPrefilter: function(html) {
3488          return html;
3489        },
3490        clone: function(elem, dataAndEvents, deepDataAndEvents) {
3491          var i, l, srcElements, destElements, clone = elem.cloneNode(true), inPage = isAttached(elem);
3492          if (!support.noCloneChecked && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery3.isXMLDoc(elem)) {
3493            destElements = getAll(clone);
3494            srcElements = getAll(elem);
3495            for (i = 0, l = srcElements.length; i < l; i++) {
3496              fixInput(srcElements[i], destElements[i]);
3497            }
3498          }
3499          if (dataAndEvents) {
3500            if (deepDataAndEvents) {
3501              srcElements = srcElements || getAll(elem);
3502              destElements = destElements || getAll(clone);
3503              for (i = 0, l = srcElements.length; i < l; i++) {
3504                cloneCopyEvent(srcElements[i], destElements[i]);
3505              }
3506            } else {
3507              cloneCopyEvent(elem, clone);
3508            }
3509          }
3510          destElements = getAll(clone, "script");
3511          if (destElements.length > 0) {
3512            setGlobalEval(destElements, !inPage && getAll(elem, "script"));
3513          }
3514          return clone;
3515        },
3516        cleanData: function(elems) {
3517          var data, elem, type, special = jQuery3.event.special, i = 0;
3518          for (; (elem = elems[i]) !== void 0; i++) {
3519            if (acceptData(elem)) {
3520              if (data = elem[dataPriv.expando]) {
3521                if (data.events) {
3522                  for (type in data.events) {
3523                    if (special[type]) {
3524                      jQuery3.event.remove(elem, type);
3525                    } else {
3526                      jQuery3.removeEvent(elem, type, data.handle);
3527                    }
3528                  }
3529                }
3530                elem[dataPriv.expando] = void 0;
3531              }
3532              if (elem[dataUser.expando]) {
3533                elem[dataUser.expando] = void 0;
3534              }
3535            }
3536          }
3537        }
3538      });
3539      jQuery3.fn.extend({
3540        detach: function(selector) {
3541          return remove(this, selector, true);
3542        },
3543        remove: function(selector) {
3544          return remove(this, selector);
3545        },
3546        text: function(value) {
3547          return access(this, function(value2) {
3548            return value2 === void 0 ? jQuery3.text(this) : this.empty().each(function() {
3549              if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
3550                this.textContent = value2;
3551              }
3552            });
3553          }, null, value, arguments.length);
3554        },
3555        append: function() {
3556          return domManip(this, arguments, function(elem) {
3557            if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
3558              var target = manipulationTarget(this, elem);
3559              target.appendChild(elem);
3560            }
3561          });
3562        },
3563        prepend: function() {
3564          return domManip(this, arguments, function(elem) {
3565            if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
3566              var target = manipulationTarget(this, elem);
3567              target.insertBefore(elem, target.firstChild);
3568            }
3569          });
3570        },
3571        before: function() {
3572          return domManip(this, arguments, function(elem) {
3573            if (this.parentNode) {
3574              this.parentNode.insertBefore(elem, this);
3575            }
3576          });
3577        },
3578        after: function() {
3579          return domManip(this, arguments, function(elem) {
3580            if (this.parentNode) {
3581              this.parentNode.insertBefore(elem, this.nextSibling);
3582            }
3583          });
3584        },
3585        empty: function() {
3586          var elem, i = 0;
3587          for (; (elem = this[i]) != null; i++) {
3588            if (elem.nodeType === 1) {
3589              jQuery3.cleanData(getAll(elem, false));
3590              elem.textContent = "";
3591            }
3592          }
3593          return this;
3594        },
3595        clone: function(dataAndEvents, deepDataAndEvents) {
3596          dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
3597          deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
3598          return this.map(function() {
3599            return jQuery3.clone(this, dataAndEvents, deepDataAndEvents);
3600          });
3601        },
3602        html: function(value) {
3603          return access(this, function(value2) {
3604            var elem = this[0] || {}, i = 0, l = this.length;
3605            if (value2 === void 0 && elem.nodeType === 1) {
3606              return elem.innerHTML;
3607            }
3608            if (typeof value2 === "string" && !rnoInnerhtml.test(value2) && !wrapMap[(rtagName.exec(value2) || ["", ""])[1].toLowerCase()]) {
3609              value2 = jQuery3.htmlPrefilter(value2);
3610              try {
3611                for (; i < l; i++) {
3612                  elem = this[i] || {};
3613                  if (elem.nodeType === 1) {
3614                    jQuery3.cleanData(getAll(elem, false));
3615                    elem.innerHTML = value2;
3616                  }
3617                }
3618                elem = 0;
3619              } catch (e) {
3620              }
3621            }
3622            if (elem) {
3623              this.empty().append(value2);
3624            }
3625          }, null, value, arguments.length);
3626        },
3627        replaceWith: function() {
3628          var ignored = [];
3629          return domManip(this, arguments, function(elem) {
3630            var parent = this.parentNode;
3631            if (jQuery3.inArray(this, ignored) < 0) {
3632              jQuery3.cleanData(getAll(this));
3633              if (parent) {
3634                parent.replaceChild(elem, this);
3635              }
3636            }
3637          }, ignored);
3638        }
3639      });
3640      jQuery3.each({
3641        appendTo: "append",
3642        prependTo: "prepend",
3643        insertBefore: "before",
3644        insertAfter: "after",
3645        replaceAll: "replaceWith"
3646      }, function(name, original) {
3647        jQuery3.fn[name] = function(selector) {
3648          var elems, ret = [], insert = jQuery3(selector), last = insert.length - 1, i = 0;
3649          for (; i <= last; i++) {
3650            elems = i === last ? this : this.clone(true);
3651            jQuery3(insert[i])[original](elems);
3652            push.apply(ret, elems.get());
3653          }
3654          return this.pushStack(ret);
3655        };
3656      });
3657      var rnumnonpx = new RegExp("^(" + pnum + ")(?!px)[a-z%]+$", "i");
3658      var rcustomProp = /^--/;
3659      var getStyles = function(elem) {
3660        var view = elem.ownerDocument.defaultView;
3661        if (!view || !view.opener) {
3662          view = window2;
3663        }
3664        return view.getComputedStyle(elem);
3665      };
3666      var swap = function(elem, options, callback) {
3667        var ret, name, old = {};
3668        for (name in options) {
3669          old[name] = elem.style[name];
3670          elem.style[name] = options[name];
3671        }
3672        ret = callback.call(elem);
3673        for (name in options) {
3674          elem.style[name] = old[name];
3675        }
3676        return ret;
3677      };
3678      var rboxStyle = new RegExp(cssExpand.join("|"), "i");
3679      (function() {
3680        function computeStyleTests() {
3681          if (!div) {
3682            return;
3683          }
3684          container.style.cssText = "position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0";
3685          div.style.cssText = "position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%";
3686          documentElement.appendChild(container).appendChild(div);
3687          var divStyle = window2.getComputedStyle(div);
3688          pixelPositionVal = divStyle.top !== "1%";
3689          reliableMarginLeftVal = roundPixelMeasures(divStyle.marginLeft) === 12;
3690          div.style.right = "60%";
3691          pixelBoxStylesVal = roundPixelMeasures(divStyle.right) === 36;
3692          boxSizingReliableVal = roundPixelMeasures(divStyle.width) === 36;
3693          div.style.position = "absolute";
3694          scrollboxSizeVal = roundPixelMeasures(div.offsetWidth / 3) === 12;
3695          documentElement.removeChild(container);
3696          div = null;
3697        }
3698        function roundPixelMeasures(measure) {
3699          return Math.round(parseFloat(measure));
3700        }
3701        var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal, reliableTrDimensionsVal, reliableMarginLeftVal, container = document2.createElement("div"), div = document2.createElement("div");
3702        if (!div.style) {
3703          return;
3704        }
3705        div.style.backgroundClip = "content-box";
3706        div.cloneNode(true).style.backgroundClip = "";
3707        support.clearCloneStyle = div.style.backgroundClip === "content-box";
3708        jQuery3.extend(support, {
3709          boxSizingReliable: function() {
3710            computeStyleTests();
3711            return boxSizingReliableVal;
3712          },
3713          pixelBoxStyles: function() {
3714            computeStyleTests();
3715            return pixelBoxStylesVal;
3716          },
3717          pixelPosition: function() {
3718            computeStyleTests();
3719            return pixelPositionVal;
3720          },
3721          reliableMarginLeft: function() {
3722            computeStyleTests();
3723            return reliableMarginLeftVal;
3724          },
3725          scrollboxSize: function() {
3726            computeStyleTests();
3727            return scrollboxSizeVal;
3728          },
3729          // Support: IE 9 - 11+, Edge 15 - 18+
3730          // IE/Edge misreport `getComputedStyle` of table rows with width/height
3731          // set in CSS while `offset*` properties report correct values.
3732          // Behavior in IE 9 is more subtle than in newer versions & it passes
3733          // some versions of this test; make sure not to make it pass there!
3734          //
3735          // Support: Firefox 70+
3736          // Only Firefox includes border widths
3737          // in computed dimensions. (gh-4529)
3738          reliableTrDimensions: function() {
3739            var table, tr, trChild, trStyle;
3740            if (reliableTrDimensionsVal == null) {
3741              table = document2.createElement("table");
3742              tr = document2.createElement("tr");
3743              trChild = document2.createElement("div");
3744              table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate";
3745              tr.style.cssText = "box-sizing:content-box;border:1px solid";
3746              tr.style.height = "1px";
3747              trChild.style.height = "9px";
3748              trChild.style.display = "block";
3749              documentElement.appendChild(table).appendChild(tr).appendChild(trChild);
3750              trStyle = window2.getComputedStyle(tr);
3751              reliableTrDimensionsVal = parseInt(trStyle.height, 10) + parseInt(trStyle.borderTopWidth, 10) + parseInt(trStyle.borderBottomWidth, 10) === tr.offsetHeight;
3752              documentElement.removeChild(table);
3753            }
3754            return reliableTrDimensionsVal;
3755          }
3756        });
3757      })();
3758      function curCSS(elem, name, computed) {
3759        var width, minWidth, maxWidth, ret, isCustomProp = rcustomProp.test(name), style = elem.style;
3760        computed = computed || getStyles(elem);
3761        if (computed) {
3762          ret = computed.getPropertyValue(name) || computed[name];
3763          if (isCustomProp && ret) {
3764            ret = ret.replace(rtrimCSS, "$1") || void 0;
3765          }
3766          if (ret === "" && !isAttached(elem)) {
3767            ret = jQuery3.style(elem, name);
3768          }
3769          if (!support.pixelBoxStyles() && rnumnonpx.test(ret) && rboxStyle.test(name)) {
3770            width = style.width;
3771            minWidth = style.minWidth;
3772            maxWidth = style.maxWidth;
3773            style.minWidth = style.maxWidth = style.width = ret;
3774            ret = computed.width;
3775            style.width = width;
3776            style.minWidth = minWidth;
3777            style.maxWidth = maxWidth;
3778          }
3779        }
3780        return ret !== void 0 ? (
3781          // Support: IE <=9 - 11 only
3782          // IE returns zIndex value as an integer.
3783          ret + ""
3784        ) : ret;
3785      }
3786      function addGetHookIf(conditionFn, hookFn) {
3787        return {
3788          get: function() {
3789            if (conditionFn()) {
3790              delete this.get;
3791              return;
3792            }
3793            return (this.get = hookFn).apply(this, arguments);
3794          }
3795        };
3796      }
3797      var cssPrefixes = ["Webkit", "Moz", "ms"], emptyStyle = document2.createElement("div").style, vendorProps = {};
3798      function vendorPropName(name) {
3799        var capName = name[0].toUpperCase() + name.slice(1), i = cssPrefixes.length;
3800        while (i--) {
3801          name = cssPrefixes[i] + capName;
3802          if (name in emptyStyle) {
3803            return name;
3804          }
3805        }
3806      }
3807      function finalPropName(name) {
3808        var final = jQuery3.cssProps[name] || vendorProps[name];
3809        if (final) {
3810          return final;
3811        }
3812        if (name in emptyStyle) {
3813          return name;
3814        }
3815        return vendorProps[name] = vendorPropName(name) || name;
3816      }
3817      var rdisplayswap = /^(none|table(?!-c[ea]).+)/, cssShow = { position: "absolute", visibility: "hidden", display: "block" }, cssNormalTransform = {
3818        letterSpacing: "0",
3819        fontWeight: "400"
3820      };
3821      function setPositiveNumber(_elem, value, subtract) {
3822        var matches = rcssNum.exec(value);
3823        return matches ? (
3824          // Guard against undefined "subtract", e.g., when used as in cssHooks
3825          Math.max(0, matches[2] - (subtract || 0)) + (matches[3] || "px")
3826        ) : value;
3827      }
3828      function boxModelAdjustment(elem, dimension, box, isBorderBox, styles, computedVal) {
3829        var i = dimension === "width" ? 1 : 0, extra = 0, delta = 0, marginDelta = 0;
3830        if (box === (isBorderBox ? "border" : "content")) {
3831          return 0;
3832        }
3833        for (; i < 4; i += 2) {
3834          if (box === "margin") {
3835            marginDelta += jQuery3.css(elem, box + cssExpand[i], true, styles);
3836          }
3837          if (!isBorderBox) {
3838            delta += jQuery3.css(elem, "padding" + cssExpand[i], true, styles);
3839            if (box !== "padding") {
3840              delta += jQuery3.css(elem, "border" + cssExpand[i] + "Width", true, styles);
3841            } else {
3842              extra += jQuery3.css(elem, "border" + cssExpand[i] + "Width", true, styles);
3843            }
3844          } else {
3845            if (box === "content") {
3846              delta -= jQuery3.css(elem, "padding" + cssExpand[i], true, styles);
3847            }
3848            if (box !== "margin") {
3849              delta -= jQuery3.css(elem, "border" + cssExpand[i] + "Width", true, styles);
3850            }
3851          }
3852        }
3853        if (!isBorderBox && computedVal >= 0) {
3854          delta += Math.max(0, Math.ceil(
3855            elem["offset" + dimension[0].toUpperCase() + dimension.slice(1)] - computedVal - delta - extra - 0.5
3856            // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter
3857            // Use an explicit zero to avoid NaN (gh-3964)
3858          )) || 0;
3859        }
3860        return delta + marginDelta;
3861      }
3862      function getWidthOrHeight(elem, dimension, extra) {
3863        var styles = getStyles(elem), boxSizingNeeded = !support.boxSizingReliable() || extra, isBorderBox = boxSizingNeeded && jQuery3.css(elem, "boxSizing", false, styles) === "border-box", valueIsBorderBox = isBorderBox, val = curCSS(elem, dimension, styles), offsetProp = "offset" + dimension[0].toUpperCase() + dimension.slice(1);
3864        if (rnumnonpx.test(val)) {
3865          if (!extra) {
3866            return val;
3867          }
3868          val = "auto";
3869        }
3870        if ((!support.boxSizingReliable() && isBorderBox || // Support: IE 10 - 11+, Edge 15 - 18+
3871        // IE/Edge misreport `getComputedStyle` of table rows with width/height
3872        // set in CSS while `offset*` properties report correct values.
3873        // Interestingly, in some cases IE 9 doesn't suffer from this issue.
3874        !support.reliableTrDimensions() && nodeName(elem, "tr") || // Fall back to offsetWidth/offsetHeight when value is "auto"
3875        // This happens for inline elements with no explicit setting (gh-3571)
3876        val === "auto" || // Support: Android <=4.1 - 4.3 only
3877        // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
3878        !parseFloat(val) && jQuery3.css(elem, "display", false, styles) === "inline") && // Make sure the element is visible & connected
3879        elem.getClientRects().length) {
3880          isBorderBox = jQuery3.css(elem, "boxSizing", false, styles) === "border-box";
3881          valueIsBorderBox = offsetProp in elem;
3882          if (valueIsBorderBox) {
3883            val = elem[offsetProp];
3884          }
3885        }
3886        val = parseFloat(val) || 0;
3887        return val + boxModelAdjustment(
3888          elem,
3889          dimension,
3890          extra || (isBorderBox ? "border" : "content"),
3891          valueIsBorderBox,
3892          styles,
3893          // Provide the current computed size to request scroll gutter calculation (gh-3589)
3894          val
3895        ) + "px";
3896      }
3897      jQuery3.extend({
3898        // Add in style property hooks for overriding the default
3899        // behavior of getting and setting a style property
3900        cssHooks: {
3901          opacity: {
3902            get: function(elem, computed) {
3903              if (computed) {
3904                var ret = curCSS(elem, "opacity");
3905                return ret === "" ? "1" : ret;
3906              }
3907            }
3908          }
3909        },
3910        // Don't automatically add "px" to these possibly-unitless properties
3911        cssNumber: {
3912          animationIterationCount: true,
3913          aspectRatio: true,
3914          borderImageSlice: true,
3915          columnCount: true,
3916          flexGrow: true,
3917          flexShrink: true,
3918          fontWeight: true,
3919          gridArea: true,
3920          gridColumn: true,
3921          gridColumnEnd: true,
3922          gridColumnStart: true,
3923          gridRow: true,
3924          gridRowEnd: true,
3925          gridRowStart: true,
3926          lineHeight: true,
3927          opacity: true,
3928          order: true,
3929          orphans: true,
3930          scale: true,
3931          widows: true,
3932          zIndex: true,
3933          zoom: true,
3934          // SVG-related
3935          fillOpacity: true,
3936          floodOpacity: true,
3937          stopOpacity: true,
3938          strokeMiterlimit: true,
3939          strokeOpacity: true
3940        },
3941        // Add in properties whose names you wish to fix before
3942        // setting or getting the value
3943        cssProps: {},
3944        // Get and set the style property on a DOM Node
3945        style: function(elem, name, value, extra) {
3946          if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) {
3947            return;
3948          }
3949          var ret, type, hooks, origName = camelCase(name), isCustomProp = rcustomProp.test(name), style = elem.style;
3950          if (!isCustomProp) {
3951            name = finalPropName(origName);
3952          }
3953          hooks = jQuery3.cssHooks[name] || jQuery3.cssHooks[origName];
3954          if (value !== void 0) {
3955            type = typeof value;
3956            if (type === "string" && (ret = rcssNum.exec(value)) && ret[1]) {
3957              value = adjustCSS(elem, name, ret);
3958              type = "number";
3959            }
3960            if (value == null || value !== value) {
3961              return;
3962            }
3963            if (type === "number" && !isCustomProp) {
3964              value += ret && ret[3] || (jQuery3.cssNumber[origName] ? "" : "px");
3965            }
3966            if (!support.clearCloneStyle && value === "" && name.indexOf("background") === 0) {
3967              style[name] = "inherit";
3968            }
3969            if (!hooks || !("set" in hooks) || (value = hooks.set(elem, value, extra)) !== void 0) {
3970              if (isCustomProp) {
3971                style.setProperty(name, value);
3972              } else {
3973                style[name] = value;
3974              }
3975            }
3976          } else {
3977            if (hooks && "get" in hooks && (ret = hooks.get(elem, false, extra)) !== void 0) {
3978              return ret;
3979            }
3980            return style[name];
3981          }
3982        },
3983        css: function(elem, name, extra, styles) {
3984          var val, num, hooks, origName = camelCase(name), isCustomProp = rcustomProp.test(name);
3985          if (!isCustomProp) {
3986            name = finalPropName(origName);
3987          }
3988          hooks = jQuery3.cssHooks[name] || jQuery3.cssHooks[origName];
3989          if (hooks && "get" in hooks) {
3990            val = hooks.get(elem, true, extra);
3991          }
3992          if (val === void 0) {
3993            val = curCSS(elem, name, styles);
3994          }
3995          if (val === "normal" && name in cssNormalTransform) {
3996            val = cssNormalTransform[name];
3997          }
3998          if (extra === "" || extra) {
3999            num = parseFloat(val);
4000            return extra === true || isFinite(num) ? num || 0 : val;
4001          }
4002          return val;
4003        }
4004      });
4005      jQuery3.each(["height", "width"], function(_i, dimension) {
4006        jQuery3.cssHooks[dimension] = {
4007          get: function(elem, computed, extra) {
4008            if (computed) {
4009              return rdisplayswap.test(jQuery3.css(elem, "display")) && // Support: Safari 8+
4010              // Table columns in Safari have non-zero offsetWidth & zero
4011              // getBoundingClientRect().width unless display is changed.
4012              // Support: IE <=11 only
4013              // Running getBoundingClientRect on a disconnected node
4014              // in IE throws an error.
4015              (!elem.getClientRects().length || !elem.getBoundingClientRect().width) ? swap(elem, cssShow, function() {
4016                return getWidthOrHeight(elem, dimension, extra);
4017              }) : getWidthOrHeight(elem, dimension, extra);
4018            }
4019          },
4020          set: function(elem, value, extra) {
4021            var matches, styles = getStyles(elem), scrollboxSizeBuggy = !support.scrollboxSize() && styles.position === "absolute", boxSizingNeeded = scrollboxSizeBuggy || extra, isBorderBox = boxSizingNeeded && jQuery3.css(elem, "boxSizing", false, styles) === "border-box", subtract = extra ? boxModelAdjustment(
4022              elem,
4023              dimension,
4024              extra,
4025              isBorderBox,
4026              styles
4027            ) : 0;
4028            if (isBorderBox && scrollboxSizeBuggy) {
4029              subtract -= Math.ceil(
4030                elem["offset" + dimension[0].toUpperCase() + dimension.slice(1)] - parseFloat(styles[dimension]) - boxModelAdjustment(elem, dimension, "border", false, styles) - 0.5
4031              );
4032            }
4033            if (subtract && (matches = rcssNum.exec(value)) && (matches[3] || "px") !== "px") {
4034              elem.style[dimension] = value;
4035              value = jQuery3.css(elem, dimension);
4036            }
4037            return setPositiveNumber(elem, value, subtract);
4038          }
4039        };
4040      });
4041      jQuery3.cssHooks.marginLeft = addGetHookIf(
4042        support.reliableMarginLeft,
4043        function(elem, computed) {
4044          if (computed) {
4045            return (parseFloat(curCSS(elem, "marginLeft")) || elem.getBoundingClientRect().left - swap(elem, { marginLeft: 0 }, function() {
4046              return elem.getBoundingClientRect().left;
4047            })) + "px";
4048          }
4049        }
4050      );
4051      jQuery3.each({
4052        margin: "",
4053        padding: "",
4054        border: "Width"
4055      }, function(prefix, suffix) {
4056        jQuery3.cssHooks[prefix + suffix] = {
4057          expand: function(value) {
4058            var i = 0, expanded = {}, parts = typeof value === "string" ? value.split(" ") : [value];
4059            for (; i < 4; i++) {
4060              expanded[prefix + cssExpand[i] + suffix] = parts[i] || parts[i - 2] || parts[0];
4061            }
4062            return expanded;
4063          }
4064        };
4065        if (prefix !== "margin") {
4066          jQuery3.cssHooks[prefix + suffix].set = setPositiveNumber;
4067        }
4068      });
4069      jQuery3.fn.extend({
4070        css: function(name, value) {
4071          return access(this, function(elem, name2, value2) {
4072            var styles, len, map = {}, i = 0;
4073            if (Array.isArray(name2)) {
4074              styles = getStyles(elem);
4075              len = name2.length;
4076              for (; i < len; i++) {
4077                map[name2[i]] = jQuery3.css(elem, name2[i], false, styles);
4078              }
4079              return map;
4080            }
4081            return value2 !== void 0 ? jQuery3.style(elem, name2, value2) : jQuery3.css(elem, name2);
4082          }, name, value, arguments.length > 1);
4083        }
4084      });
4085      function Tween(elem, options, prop, end, easing) {
4086        return new Tween.prototype.init(elem, options, prop, end, easing);
4087      }
4088      jQuery3.Tween = Tween;
4089      Tween.prototype = {
4090        constructor: Tween,
4091        init: function(elem, options, prop, end, easing, unit) {
4092          this.elem = elem;
4093          this.prop = prop;
4094          this.easing = easing || jQuery3.easing._default;
4095          this.options = options;
4096          this.start = this.now = this.cur();
4097          this.end = end;
4098          this.unit = unit || (jQuery3.cssNumber[prop] ? "" : "px");
4099        },
4100        cur: function() {
4101          var hooks = Tween.propHooks[this.prop];
4102          return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this);
4103        },
4104        run: function(percent) {
4105          var eased, hooks = Tween.propHooks[this.prop];
4106          if (this.options.duration) {
4107            this.pos = eased = jQuery3.easing[this.easing](
4108              percent,
4109              this.options.duration * percent,
4110              0,
4111              1,
4112              this.options.duration
4113            );
4114          } else {
4115            this.pos = eased = percent;
4116          }
4117          this.now = (this.end - this.start) * eased + this.start;
4118          if (this.options.step) {
4119            this.options.step.call(this.elem, this.now, this);
4120          }
4121          if (hooks && hooks.set) {
4122            hooks.set(this);
4123          } else {
4124            Tween.propHooks._default.set(this);
4125          }
4126          return this;
4127        }
4128      };
4129      Tween.prototype.init.prototype = Tween.prototype;
4130      Tween.propHooks = {
4131        _default: {
4132          get: function(tween) {
4133            var result;
4134            if (tween.elem.nodeType !== 1 || tween.elem[tween.prop] != null && tween.elem.style[tween.prop] == null) {
4135              return tween.elem[tween.prop];
4136            }
4137            result = jQuery3.css(tween.elem, tween.prop, "");
4138            return !result || result === "auto" ? 0 : result;
4139          },
4140          set: function(tween) {
4141            if (jQuery3.fx.step[tween.prop]) {
4142              jQuery3.fx.step[tween.prop](tween);
4143            } else if (tween.elem.nodeType === 1 && (jQuery3.cssHooks[tween.prop] || tween.elem.style[finalPropName(tween.prop)] != null)) {
4144              jQuery3.style(tween.elem, tween.prop, tween.now + tween.unit);
4145            } else {
4146              tween.elem[tween.prop] = tween.now;
4147            }
4148          }
4149        }
4150      };
4151      Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
4152        set: function(tween) {
4153          if (tween.elem.nodeType && tween.elem.parentNode) {
4154            tween.elem[tween.prop] = tween.now;
4155          }
4156        }
4157      };
4158      jQuery3.easing = {
4159        linear: function(p) {
4160          return p;
4161        },
4162        swing: function(p) {
4163          return 0.5 - Math.cos(p * Math.PI) / 2;
4164        },
4165        _default: "swing"
4166      };
4167      jQuery3.fx = Tween.prototype.init;
4168      jQuery3.fx.step = {};
4169      var fxNow, inProgress, rfxtypes = /^(?:toggle|show|hide)$/, rrun = /queueHooks$/;
4170      function schedule() {
4171        if (inProgress) {
4172          if (document2.hidden === false && window2.requestAnimationFrame) {
4173            window2.requestAnimationFrame(schedule);
4174          } else {
4175            window2.setTimeout(schedule, jQuery3.fx.interval);
4176          }
4177          jQuery3.fx.tick();
4178        }
4179      }
4180      function createFxNow() {
4181        window2.setTimeout(function() {
4182          fxNow = void 0;
4183        });
4184        return fxNow = Date.now();
4185      }
4186      function genFx(type, includeWidth) {
4187        var which, i = 0, attrs = { height: type };
4188        includeWidth = includeWidth ? 1 : 0;
4189        for (; i < 4; i += 2 - includeWidth) {
4190          which = cssExpand[i];
4191          attrs["margin" + which] = attrs["padding" + which] = type;
4192        }
4193        if (includeWidth) {
4194          attrs.opacity = attrs.width = type;
4195        }
4196        return attrs;
4197      }
4198      function createTween(value, prop, animation) {
4199        var tween, collection = (Animation.tweeners[prop] || []).concat(Animation.tweeners["*"]), index = 0, length = collection.length;
4200        for (; index < length; index++) {
4201          if (tween = collection[index].call(animation, prop, value)) {
4202            return tween;
4203          }
4204        }
4205      }
4206      function defaultPrefilter(elem, props, opts) {
4207        var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, isBox = "width" in props || "height" in props, anim = this, orig = {}, style = elem.style, hidden = elem.nodeType && isHiddenWithinTree(elem), dataShow = dataPriv.get(elem, "fxshow");
4208        if (!opts.queue) {
4209          hooks = jQuery3._queueHooks(elem, "fx");
4210          if (hooks.unqueued == null) {
4211            hooks.unqueued = 0;
4212            oldfire = hooks.empty.fire;
4213            hooks.empty.fire = function() {
4214              if (!hooks.unqueued) {
4215                oldfire();
4216              }
4217            };
4218          }
4219          hooks.unqueued++;
4220          anim.always(function() {
4221            anim.always(function() {
4222              hooks.unqueued--;
4223              if (!jQuery3.queue(elem, "fx").length) {
4224                hooks.empty.fire();
4225              }
4226            });
4227          });
4228        }
4229        for (prop in props) {
4230          value = props[prop];
4231          if (rfxtypes.test(value)) {
4232            delete props[prop];
4233            toggle = toggle || value === "toggle";
4234            if (value === (hidden ? "hide" : "show")) {
4235              if (value === "show" && dataShow && dataShow[prop] !== void 0) {
4236                hidden = true;
4237              } else {
4238                continue;
4239              }
4240            }
4241            orig[prop] = dataShow && dataShow[prop] || jQuery3.style(elem, prop);
4242          }
4243        }
4244        propTween = !jQuery3.isEmptyObject(props);
4245        if (!propTween && jQuery3.isEmptyObject(orig)) {
4246          return;
4247        }
4248        if (isBox && elem.nodeType === 1) {
4249          opts.overflow = [style.overflow, style.overflowX, style.overflowY];
4250          restoreDisplay = dataShow && dataShow.display;
4251          if (restoreDisplay == null) {
4252            restoreDisplay = dataPriv.get(elem, "display");
4253          }
4254          display = jQuery3.css(elem, "display");
4255          if (display === "none") {
4256            if (restoreDisplay) {
4257              display = restoreDisplay;
4258            } else {
4259              showHide([elem], true);
4260              restoreDisplay = elem.style.display || restoreDisplay;
4261              display = jQuery3.css(elem, "display");
4262              showHide([elem]);
4263            }
4264          }
4265          if (display === "inline" || display === "inline-block" && restoreDisplay != null) {
4266            if (jQuery3.css(elem, "float") === "none") {
4267              if (!propTween) {
4268                anim.done(function() {
4269                  style.display = restoreDisplay;
4270                });
4271                if (restoreDisplay == null) {
4272                  display = style.display;
4273                  restoreDisplay = display === "none" ? "" : display;
4274                }
4275              }
4276              style.display = "inline-block";
4277            }
4278          }
4279        }
4280        if (opts.overflow) {
4281          style.overflow = "hidden";
4282          anim.always(function() {
4283            style.overflow = opts.overflow[0];
4284            style.overflowX = opts.overflow[1];
4285            style.overflowY = opts.overflow[2];
4286          });
4287        }
4288        propTween = false;
4289        for (prop in orig) {
4290          if (!propTween) {
4291            if (dataShow) {
4292              if ("hidden" in dataShow) {
4293                hidden = dataShow.hidden;
4294              }
4295            } else {
4296              dataShow = dataPriv.access(elem, "fxshow", { display: restoreDisplay });
4297            }
4298            if (toggle) {
4299              dataShow.hidden = !hidden;
4300            }
4301            if (hidden) {
4302              showHide([elem], true);
4303            }
4304            anim.done(function() {
4305              if (!hidden) {
4306                showHide([elem]);
4307              }
4308              dataPriv.remove(elem, "fxshow");
4309              for (prop in orig) {
4310                jQuery3.style(elem, prop, orig[prop]);
4311              }
4312            });
4313          }
4314          propTween = createTween(hidden ? dataShow[prop] : 0, prop, anim);
4315          if (!(prop in dataShow)) {
4316            dataShow[prop] = propTween.start;
4317            if (hidden) {
4318              propTween.end = propTween.start;
4319              propTween.start = 0;
4320            }
4321          }
4322        }
4323      }
4324      function propFilter(props, specialEasing) {
4325        var index, name, easing, value, hooks;
4326        for (index in props) {
4327          name = camelCase(index);
4328          easing = specialEasing[name];
4329          value = props[index];
4330          if (Array.isArray(value)) {
4331            easing = value[1];
4332            value = props[index] = value[0];
4333          }
4334          if (index !== name) {
4335            props[name] = value;
4336            delete props[index];
4337          }
4338          hooks = jQuery3.cssHooks[name];
4339          if (hooks && "expand" in hooks) {
4340            value = hooks.expand(value);
4341            delete props[name];
4342            for (index in value) {
4343              if (!(index in props)) {
4344                props[index] = value[index];
4345                specialEasing[index] = easing;
4346              }
4347            }
4348          } else {
4349            specialEasing[name] = easing;
4350          }
4351        }
4352      }
4353      function Animation(elem, properties, options) {
4354        var result, stopped, index = 0, length = Animation.prefilters.length, deferred = jQuery3.Deferred().always(function() {
4355          delete tick.elem;
4356        }), tick = function() {
4357          if (stopped) {
4358            return false;
4359          }
4360          var currentTime = fxNow || createFxNow(), remaining = Math.max(0, animation.startTime + animation.duration - currentTime), temp = remaining / animation.duration || 0, percent = 1 - temp, index2 = 0, length2 = animation.tweens.length;
4361          for (; index2 < length2; index2++) {
4362            animation.tweens[index2].run(percent);
4363          }
4364          deferred.notifyWith(elem, [animation, percent, remaining]);
4365          if (percent < 1 && length2) {
4366            return remaining;
4367          }
4368          if (!length2) {
4369            deferred.notifyWith(elem, [animation, 1, 0]);
4370          }
4371          deferred.resolveWith(elem, [animation]);
4372          return false;
4373        }, animation = deferred.promise({
4374          elem,
4375          props: jQuery3.extend({}, properties),
4376          opts: jQuery3.extend(true, {
4377            specialEasing: {},
4378            easing: jQuery3.easing._default
4379          }, options),
4380          originalProperties: properties,
4381          originalOptions: options,
4382          startTime: fxNow || createFxNow(),
4383          duration: options.duration,
4384          tweens: [],
4385          createTween: function(prop, end) {
4386            var tween = jQuery3.Tween(
4387              elem,
4388              animation.opts,
4389              prop,
4390              end,
4391              animation.opts.specialEasing[prop] || animation.opts.easing
4392            );
4393            animation.tweens.push(tween);
4394            return tween;
4395          },
4396          stop: function(gotoEnd) {
4397            var index2 = 0, length2 = gotoEnd ? animation.tweens.length : 0;
4398            if (stopped) {
4399              return this;
4400            }
4401            stopped = true;
4402            for (; index2 < length2; index2++) {
4403              animation.tweens[index2].run(1);
4404            }
4405            if (gotoEnd) {
4406              deferred.notifyWith(elem, [animation, 1, 0]);
4407              deferred.resolveWith(elem, [animation, gotoEnd]);
4408            } else {
4409              deferred.rejectWith(elem, [animation, gotoEnd]);
4410            }
4411            return this;
4412          }
4413        }), props = animation.props;
4414        propFilter(props, animation.opts.specialEasing);
4415        for (; index < length; index++) {
4416          result = Animation.prefilters[index].call(animation, elem, props, animation.opts);
4417          if (result) {
4418            if (isFunction(result.stop)) {
4419              jQuery3._queueHooks(animation.elem, animation.opts.queue).stop = result.stop.bind(result);
4420            }
4421            return result;
4422          }
4423        }
4424        jQuery3.map(props, createTween, animation);
4425        if (isFunction(animation.opts.start)) {
4426          animation.opts.start.call(elem, animation);
4427        }
4428        animation.progress(animation.opts.progress).done(animation.opts.done, animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always);
4429        jQuery3.fx.timer(
4430          jQuery3.extend(tick, {
4431            elem,
4432            anim: animation,
4433            queue: animation.opts.queue
4434          })
4435        );
4436        return animation;
4437      }
4438      jQuery3.Animation = jQuery3.extend(Animation, {
4439        tweeners: {
4440          "*": [function(prop, value) {
4441            var tween = this.createTween(prop, value);
4442            adjustCSS(tween.elem, prop, rcssNum.exec(value), tween);
4443            return tween;
4444          }]
4445        },
4446        tweener: function(props, callback) {
4447          if (isFunction(props)) {
4448            callback = props;
4449            props = ["*"];
4450          } else {
4451            props = props.match(rnothtmlwhite);
4452          }
4453          var prop, index = 0, length = props.length;
4454          for (; index < length; index++) {
4455            prop = props[index];
4456            Animation.tweeners[prop] = Animation.tweeners[prop] || [];
4457            Animation.tweeners[prop].unshift(callback);
4458          }
4459        },
4460        prefilters: [defaultPrefilter],
4461        prefilter: function(callback, prepend) {
4462          if (prepend) {
4463            Animation.prefilters.unshift(callback);
4464          } else {
4465            Animation.prefilters.push(callback);
4466          }
4467        }
4468      });
4469      jQuery3.speed = function(speed, easing, fn) {
4470        var opt = speed && typeof speed === "object" ? jQuery3.extend({}, speed) : {
4471          complete: fn || !fn && easing || isFunction(speed) && speed,
4472          duration: speed,
4473          easing: fn && easing || easing && !isFunction(easing) && easing
4474        };
4475        if (jQuery3.fx.off) {
4476          opt.duration = 0;
4477        } else {
4478          if (typeof opt.duration !== "number") {
4479            if (opt.duration in jQuery3.fx.speeds) {
4480              opt.duration = jQuery3.fx.speeds[opt.duration];
4481            } else {
4482              opt.duration = jQuery3.fx.speeds._default;
4483            }
4484          }
4485        }
4486        if (opt.queue == null || opt.queue === true) {
4487          opt.queue = "fx";
4488        }
4489        opt.old = opt.complete;
4490        opt.complete = function() {
4491          if (isFunction(opt.old)) {
4492            opt.old.call(this);
4493          }
4494          if (opt.queue) {
4495            jQuery3.dequeue(this, opt.queue);
4496          }
4497        };
4498        return opt;
4499      };
4500      jQuery3.fn.extend({
4501        fadeTo: function(speed, to, easing, callback) {
4502          return this.filter(isHiddenWithinTree).css("opacity", 0).show().end().animate({ opacity: to }, speed, easing, callback);
4503        },
4504        animate: function(prop, speed, easing, callback) {
4505          var empty = jQuery3.isEmptyObject(prop), optall = jQuery3.speed(speed, easing, callback), doAnimation = function() {
4506            var anim = Animation(this, jQuery3.extend({}, prop), optall);
4507            if (empty || dataPriv.get(this, "finish")) {
4508              anim.stop(true);
4509            }
4510          };
4511          doAnimation.finish = doAnimation;
4512          return empty || optall.queue === false ? this.each(doAnimation) : this.queue(optall.queue, doAnimation);
4513        },
4514        stop: function(type, clearQueue, gotoEnd) {
4515          var stopQueue = function(hooks) {
4516            var stop = hooks.stop;
4517            delete hooks.stop;
4518            stop(gotoEnd);
4519          };
4520          if (typeof type !== "string") {
4521            gotoEnd = clearQueue;
4522            clearQueue = type;
4523            type = void 0;
4524          }
4525          if (clearQueue) {
4526            this.queue(type || "fx", []);
4527          }
4528          return this.each(function() {
4529            var dequeue = true, index = type != null && type + "queueHooks", timers = jQuery3.timers, data = dataPriv.get(this);
4530            if (index) {
4531              if (data[index] && data[index].stop) {
4532                stopQueue(data[index]);
4533              }
4534            } else {
4535              for (index in data) {
4536                if (data[index] && data[index].stop && rrun.test(index)) {
4537                  stopQueue(data[index]);
4538                }
4539              }
4540            }
4541            for (index = timers.length; index--; ) {
4542              if (timers[index].elem === this && (type == null || timers[index].queue === type)) {
4543                timers[index].anim.stop(gotoEnd);
4544                dequeue = false;
4545                timers.splice(index, 1);
4546              }
4547            }
4548            if (dequeue || !gotoEnd) {
4549              jQuery3.dequeue(this, type);
4550            }
4551          });
4552        },
4553        finish: function(type) {
4554          if (type !== false) {
4555            type = type || "fx";
4556          }
4557          return this.each(function() {
4558            var index, data = dataPriv.get(this), queue = data[type + "queue"], hooks = data[type + "queueHooks"], timers = jQuery3.timers, length = queue ? queue.length : 0;
4559            data.finish = true;
4560            jQuery3.queue(this, type, []);
4561            if (hooks && hooks.stop) {
4562              hooks.stop.call(this, true);
4563            }
4564            for (index = timers.length; index--; ) {
4565              if (timers[index].elem === this && timers[index].queue === type) {
4566                timers[index].anim.stop(true);
4567                timers.splice(index, 1);
4568              }
4569            }
4570            for (index = 0; index < length; index++) {
4571              if (queue[index] && queue[index].finish) {
4572                queue[index].finish.call(this);
4573              }
4574            }
4575            delete data.finish;
4576          });
4577        }
4578      });
4579      jQuery3.each(["toggle", "show", "hide"], function(_i, name) {
4580        var cssFn = jQuery3.fn[name];
4581        jQuery3.fn[name] = function(speed, easing, callback) {
4582          return speed == null || typeof speed === "boolean" ? cssFn.apply(this, arguments) : this.animate(genFx(name, true), speed, easing, callback);
4583        };
4584      });
4585      jQuery3.each({
4586        slideDown: genFx("show"),
4587        slideUp: genFx("hide"),
4588        slideToggle: genFx("toggle"),
4589        fadeIn: { opacity: "show" },
4590        fadeOut: { opacity: "hide" },
4591        fadeToggle: { opacity: "toggle" }
4592      }, function(name, props) {
4593        jQuery3.fn[name] = function(speed, easing, callback) {
4594          return this.animate(props, speed, easing, callback);
4595        };
4596      });
4597      jQuery3.timers = [];
4598      jQuery3.fx.tick = function() {
4599        var timer, i = 0, timers = jQuery3.timers;
4600        fxNow = Date.now();
4601        for (; i < timers.length; i++) {
4602          timer = timers[i];
4603          if (!timer() && timers[i] === timer) {
4604            timers.splice(i--, 1);
4605          }
4606        }
4607        if (!timers.length) {
4608          jQuery3.fx.stop();
4609        }
4610        fxNow = void 0;
4611      };
4612      jQuery3.fx.timer = function(timer) {
4613        jQuery3.timers.push(timer);
4614        jQuery3.fx.start();
4615      };
4616      jQuery3.fx.interval = 13;
4617      jQuery3.fx.start = function() {
4618        if (inProgress) {
4619          return;
4620        }
4621        inProgress = true;
4622        schedule();
4623      };
4624      jQuery3.fx.stop = function() {
4625        inProgress = null;
4626      };
4627      jQuery3.fx.speeds = {
4628        slow: 600,
4629        fast: 200,
4630        // Default speed
4631        _default: 400
4632      };
4633      jQuery3.fn.delay = function(time, type) {
4634        time = jQuery3.fx ? jQuery3.fx.speeds[time] || time : time;
4635        type = type || "fx";
4636        return this.queue(type, function(next, hooks) {
4637          var timeout = window2.setTimeout(next, time);
4638          hooks.stop = function() {
4639            window2.clearTimeout(timeout);
4640          };
4641        });
4642      };
4643      (function() {
4644        var input = document2.createElement("input"), select = document2.createElement("select"), opt = select.appendChild(document2.createElement("option"));
4645        input.type = "checkbox";
4646        support.checkOn = input.value !== "";
4647        support.optSelected = opt.selected;
4648        input = document2.createElement("input");
4649        input.value = "t";
4650        input.type = "radio";
4651        support.radioValue = input.value === "t";
4652      })();
4653      var boolHook, attrHandle = jQuery3.expr.attrHandle;
4654      jQuery3.fn.extend({
4655        attr: function(name, value) {
4656          return access(this, jQuery3.attr, name, value, arguments.length > 1);
4657        },
4658        removeAttr: function(name) {
4659          return this.each(function() {
4660            jQuery3.removeAttr(this, name);
4661          });
4662        }
4663      });
4664      jQuery3.extend({
4665        attr: function(elem, name, value) {
4666          var ret, hooks, nType = elem.nodeType;
4667          if (nType === 3 || nType === 8 || nType === 2) {
4668            return;
4669          }
4670          if (typeof elem.getAttribute === "undefined") {
4671            return jQuery3.prop(elem, name, value);
4672          }
4673          if (nType !== 1 || !jQuery3.isXMLDoc(elem)) {
4674            hooks = jQuery3.attrHooks[name.toLowerCase()] || (jQuery3.expr.match.bool.test(name) ? boolHook : void 0);
4675          }
4676          if (value !== void 0) {
4677            if (value === null) {
4678              jQuery3.removeAttr(elem, name);
4679              return;
4680            }
4681            if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== void 0) {
4682              return ret;
4683            }
4684            elem.setAttribute(name, value + "");
4685            return value;
4686          }
4687          if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) {
4688            return ret;
4689          }
4690          ret = jQuery3.find.attr(elem, name);
4691          return ret == null ? void 0 : ret;
4692        },
4693        attrHooks: {
4694          type: {
4695            set: function(elem, value) {
4696              if (!support.radioValue && value === "radio" && nodeName(elem, "input")) {
4697                var val = elem.value;
4698                elem.setAttribute("type", value);
4699                if (val) {
4700                  elem.value = val;
4701                }
4702                return value;
4703              }
4704            }
4705          }
4706        },
4707        removeAttr: function(elem, value) {
4708          var name, i = 0, attrNames = value && value.match(rnothtmlwhite);
4709          if (attrNames && elem.nodeType === 1) {
4710            while (name = attrNames[i++]) {
4711              elem.removeAttribute(name);
4712            }
4713          }
4714        }
4715      });
4716      boolHook = {
4717        set: function(elem, value, name) {
4718          if (value === false) {
4719            jQuery3.removeAttr(elem, name);
4720          } else {
4721            elem.setAttribute(name, name);
4722          }
4723          return name;
4724        }
4725      };
4726      jQuery3.each(jQuery3.expr.match.bool.source.match(/\w+/g), function(_i, name) {
4727        var getter = attrHandle[name] || jQuery3.find.attr;
4728        attrHandle[name] = function(elem, name2, isXML) {
4729          var ret, handle, lowercaseName = name2.toLowerCase();
4730          if (!isXML) {
4731            handle = attrHandle[lowercaseName];
4732            attrHandle[lowercaseName] = ret;
4733            ret = getter(elem, name2, isXML) != null ? lowercaseName : null;
4734            attrHandle[lowercaseName] = handle;
4735          }
4736          return ret;
4737        };
4738      });
4739      var rfocusable = /^(?:input|select|textarea|button)$/i, rclickable = /^(?:a|area)$/i;
4740      jQuery3.fn.extend({
4741        prop: function(name, value) {
4742          return access(this, jQuery3.prop, name, value, arguments.length > 1);
4743        },
4744        removeProp: function(name) {
4745          return this.each(function() {
4746            delete this[jQuery3.propFix[name] || name];
4747          });
4748        }
4749      });
4750      jQuery3.extend({
4751        prop: function(elem, name, value) {
4752          var ret, hooks, nType = elem.nodeType;
4753          if (nType === 3 || nType === 8 || nType === 2) {
4754            return;
4755          }
4756          if (nType !== 1 || !jQuery3.isXMLDoc(elem)) {
4757            name = jQuery3.propFix[name] || name;
4758            hooks = jQuery3.propHooks[name];
4759          }
4760          if (value !== void 0) {
4761            if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== void 0) {
4762              return ret;
4763            }
4764            return elem[name] = value;
4765          }
4766          if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) {
4767            return ret;
4768          }
4769          return elem[name];
4770        },
4771        propHooks: {
4772          tabIndex: {
4773            get: function(elem) {
4774              var tabindex = jQuery3.find.attr(elem, "tabindex");
4775              if (tabindex) {
4776                return parseInt(tabindex, 10);
4777              }
4778              if (rfocusable.test(elem.nodeName) || rclickable.test(elem.nodeName) && elem.href) {
4779                return 0;
4780              }
4781              return -1;
4782            }
4783          }
4784        },
4785        propFix: {
4786          "for": "htmlFor",
4787          "class": "className"
4788        }
4789      });
4790      if (!support.optSelected) {
4791        jQuery3.propHooks.selected = {
4792          get: function(elem) {
4793            var parent = elem.parentNode;
4794            if (parent && parent.parentNode) {
4795              parent.parentNode.selectedIndex;
4796            }
4797            return null;
4798          },
4799          set: function(elem) {
4800            var parent = elem.parentNode;
4801            if (parent) {
4802              parent.selectedIndex;
4803              if (parent.parentNode) {
4804                parent.parentNode.selectedIndex;
4805              }
4806            }
4807          }
4808        };
4809      }
4810      jQuery3.each([
4811        "tabIndex",
4812        "readOnly",
4813        "maxLength",
4814        "cellSpacing",
4815        "cellPadding",
4816        "rowSpan",
4817        "colSpan",
4818        "useMap",
4819        "frameBorder",
4820        "contentEditable"
4821      ], function() {
4822        jQuery3.propFix[this.toLowerCase()] = this;
4823      });
4824      function stripAndCollapse(value) {
4825        var tokens = value.match(rnothtmlwhite) || [];
4826        return tokens.join(" ");
4827      }
4828      function getClass(elem) {
4829        return elem.getAttribute && elem.getAttribute("class") || "";
4830      }
4831      function classesToArray(value) {
4832        if (Array.isArray(value)) {
4833          return value;
4834        }
4835        if (typeof value === "string") {
4836          return value.match(rnothtmlwhite) || [];
4837        }
4838        return [];
4839      }
4840      jQuery3.fn.extend({
4841        addClass: function(value) {
4842          var classNames, cur, curValue, className, i, finalValue;
4843          if (isFunction(value)) {
4844            return this.each(function(j) {
4845              jQuery3(this).addClass(value.call(this, j, getClass(this)));
4846            });
4847          }
4848          classNames = classesToArray(value);
4849          if (classNames.length) {
4850            return this.each(function() {
4851              curValue = getClass(this);
4852              cur = this.nodeType === 1 && " " + stripAndCollapse(curValue) + " ";
4853              if (cur) {
4854                for (i = 0; i < classNames.length; i++) {
4855                  className = classNames[i];
4856                  if (cur.indexOf(" " + className + " ") < 0) {
4857                    cur += className + " ";
4858                  }
4859                }
4860                finalValue = stripAndCollapse(cur);
4861                if (curValue !== finalValue) {
4862                  this.setAttribute("class", finalValue);
4863                }
4864              }
4865            });
4866          }
4867          return this;
4868        },
4869        removeClass: function(value) {
4870          var classNames, cur, curValue, className, i, finalValue;
4871          if (isFunction(value)) {
4872            return this.each(function(j) {
4873              jQuery3(this).removeClass(value.call(this, j, getClass(this)));
4874            });
4875          }
4876          if (!arguments.length) {
4877            return this.attr("class", "");
4878          }
4879          classNames = classesToArray(value);
4880          if (classNames.length) {
4881            return this.each(function() {
4882              curValue = getClass(this);
4883              cur = this.nodeType === 1 && " " + stripAndCollapse(curValue) + " ";
4884              if (cur) {
4885                for (i = 0; i < classNames.length; i++) {
4886                  className = classNames[i];
4887                  while (cur.indexOf(" " + className + " ") > -1) {
4888                    cur = cur.replace(" " + className + " ", " ");
4889                  }
4890                }
4891                finalValue = stripAndCollapse(cur);
4892                if (curValue !== finalValue) {
4893                  this.setAttribute("class", finalValue);
4894                }
4895              }
4896            });
4897          }
4898          return this;
4899        },
4900        toggleClass: function(value, stateVal) {
4901          var classNames, className, i, self, type = typeof value, isValidValue = type === "string" || Array.isArray(value);
4902          if (isFunction(value)) {
4903            return this.each(function(i2) {
4904              jQuery3(this).toggleClass(
4905                value.call(this, i2, getClass(this), stateVal),
4906                stateVal
4907              );
4908            });
4909          }
4910          if (typeof stateVal === "boolean" && isValidValue) {
4911            return stateVal ? this.addClass(value) : this.removeClass(value);
4912          }
4913          classNames = classesToArray(value);
4914          return this.each(function() {
4915            if (isValidValue) {
4916              self = jQuery3(this);
4917              for (i = 0; i < classNames.length; i++) {
4918                className = classNames[i];
4919                if (self.hasClass(className)) {
4920                  self.removeClass(className);
4921                } else {
4922                  self.addClass(className);
4923                }
4924              }
4925            } else if (value === void 0 || type === "boolean") {
4926              className = getClass(this);
4927              if (className) {
4928                dataPriv.set(this, "__className__", className);
4929              }
4930              if (this.setAttribute) {
4931                this.setAttribute(
4932                  "class",
4933                  className || value === false ? "" : dataPriv.get(this, "__className__") || ""
4934                );
4935              }
4936            }
4937          });
4938        },
4939        hasClass: function(selector) {
4940          var className, elem, i = 0;
4941          className = " " + selector + " ";
4942          while (elem = this[i++]) {
4943            if (elem.nodeType === 1 && (" " + stripAndCollapse(getClass(elem)) + " ").indexOf(className) > -1) {
4944              return true;
4945            }
4946          }
4947          return false;
4948        }
4949      });
4950      var rreturn = /\r/g;
4951      jQuery3.fn.extend({
4952        val: function(value) {
4953          var hooks, ret, valueIsFunction, elem = this[0];
4954          if (!arguments.length) {
4955            if (elem) {
4956              hooks = jQuery3.valHooks[elem.type] || jQuery3.valHooks[elem.nodeName.toLowerCase()];
4957              if (hooks && "get" in hooks && (ret = hooks.get(elem, "value")) !== void 0) {
4958                return ret;
4959              }
4960              ret = elem.value;
4961              if (typeof ret === "string") {
4962                return ret.replace(rreturn, "");
4963              }
4964              return ret == null ? "" : ret;
4965            }
4966            return;
4967          }
4968          valueIsFunction = isFunction(value);
4969          return this.each(function(i) {
4970            var val;
4971            if (this.nodeType !== 1) {
4972              return;
4973            }
4974            if (valueIsFunction) {
4975              val = value.call(this, i, jQuery3(this).val());
4976            } else {
4977              val = value;
4978            }
4979            if (val == null) {
4980              val = "";
4981            } else if (typeof val === "number") {
4982              val += "";
4983            } else if (Array.isArray(val)) {
4984              val = jQuery3.map(val, function(value2) {
4985                return value2 == null ? "" : value2 + "";
4986              });
4987            }
4988            hooks = jQuery3.valHooks[this.type] || jQuery3.valHooks[this.nodeName.toLowerCase()];
4989            if (!hooks || !("set" in hooks) || hooks.set(this, val, "value") === void 0) {
4990              this.value = val;
4991            }
4992          });
4993        }
4994      });
4995      jQuery3.extend({
4996        valHooks: {
4997          option: {
4998            get: function(elem) {
4999              var val = jQuery3.find.attr(elem, "value");
5000              return val != null ? val : (
5001                // Support: IE <=10 - 11 only
5002                // option.text throws exceptions (trac-14686, trac-14858)
5003                // Strip and collapse whitespace
5004                // https://html.spec.whatwg.org/#strip-and-collapse-whitespace
5005                stripAndCollapse(jQuery3.text(elem))
5006              );
5007            }
5008          },
5009          select: {
5010            get: function(elem) {
5011              var value, option, i, options = elem.options, index = elem.selectedIndex, one = elem.type === "select-one", values = one ? null : [], max = one ? index + 1 : options.length;
5012              if (index < 0) {
5013                i = max;
5014              } else {
5015                i = one ? index : 0;
5016              }
5017              for (; i < max; i++) {
5018                option = options[i];
5019                if ((option.selected || i === index) && // Don't return options that are disabled or in a disabled optgroup
5020                !option.disabled && (!option.parentNode.disabled || !nodeName(option.parentNode, "optgroup"))) {
5021                  value = jQuery3(option).val();
5022                  if (one) {
5023                    return value;
5024                  }
5025                  values.push(value);
5026                }
5027              }
5028              return values;
5029            },
5030            set: function(elem, value) {
5031              var optionSet, option, options = elem.options, values = jQuery3.makeArray(value), i = options.length;
5032              while (i--) {
5033                option = options[i];
5034                if (option.selected = jQuery3.inArray(jQuery3.valHooks.option.get(option), values) > -1) {
5035                  optionSet = true;
5036                }
5037              }
5038              if (!optionSet) {
5039                elem.selectedIndex = -1;
5040              }
5041              return values;
5042            }
5043          }
5044        }
5045      });
5046      jQuery3.each(["radio", "checkbox"], function() {
5047        jQuery3.valHooks[this] = {
5048          set: function(elem, value) {
5049            if (Array.isArray(value)) {
5050              return elem.checked = jQuery3.inArray(jQuery3(elem).val(), value) > -1;
5051            }
5052          }
5053        };
5054        if (!support.checkOn) {
5055          jQuery3.valHooks[this].get = function(elem) {
5056            return elem.getAttribute("value") === null ? "on" : elem.value;
5057          };
5058        }
5059      });
5060      var location2 = window2.location;
5061      var nonce = { guid: Date.now() };
5062      var rquery = /\?/;
5063      jQuery3.parseXML = function(data) {
5064        var xml, parserErrorElem;
5065        if (!data || typeof data !== "string") {
5066          return null;
5067        }
5068        try {
5069          xml = new window2.DOMParser().parseFromString(data, "text/xml");
5070        } catch (e) {
5071        }
5072        parserErrorElem = xml && xml.getElementsByTagName("parsererror")[0];
5073        if (!xml || parserErrorElem) {
5074          jQuery3.error("Invalid XML: " + (parserErrorElem ? jQuery3.map(parserErrorElem.childNodes, function(el) {
5075            return el.textContent;
5076          }).join("\n") : data));
5077        }
5078        return xml;
5079      };
5080      var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, stopPropagationCallback = function(e) {
5081        e.stopPropagation();
5082      };
5083      jQuery3.extend(jQuery3.event, {
5084        trigger: function(event, data, elem, onlyHandlers) {
5085          var i, cur, tmp, bubbleType, ontype, handle, special, lastElement, eventPath = [elem || document2], type = hasOwn.call(event, "type") ? event.type : event, namespaces = hasOwn.call(event, "namespace") ? event.namespace.split(".") : [];
5086          cur = lastElement = tmp = elem = elem || document2;
5087          if (elem.nodeType === 3 || elem.nodeType === 8) {
5088            return;
5089          }
5090          if (rfocusMorph.test(type + jQuery3.event.triggered)) {
5091            return;
5092          }
5093          if (type.indexOf(".") > -1) {
5094            namespaces = type.split(".");
5095            type = namespaces.shift();
5096            namespaces.sort();
5097          }
5098          ontype = type.indexOf(":") < 0 && "on" + type;
5099          event = event[jQuery3.expando] ? event : new jQuery3.Event(type, typeof event === "object" && event);
5100          event.isTrigger = onlyHandlers ? 2 : 3;
5101          event.namespace = namespaces.join(".");
5102          event.rnamespace = event.namespace ? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
5103          event.result = void 0;
5104          if (!event.target) {
5105            event.target = elem;
5106          }
5107          data = data == null ? [event] : jQuery3.makeArray(data, [event]);
5108          special = jQuery3.event.special[type] || {};
5109          if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) {
5110            return;
5111          }
5112          if (!onlyHandlers && !special.noBubble && !isWindow(elem)) {
5113            bubbleType = special.delegateType || type;
5114            if (!rfocusMorph.test(bubbleType + type)) {
5115              cur = cur.parentNode;
5116            }
5117            for (; cur; cur = cur.parentNode) {
5118              eventPath.push(cur);
5119              tmp = cur;
5120            }
5121            if (tmp === (elem.ownerDocument || document2)) {
5122              eventPath.push(tmp.defaultView || tmp.parentWindow || window2);
5123            }
5124          }
5125          i = 0;
5126          while ((cur = eventPath[i++]) && !event.isPropagationStopped()) {
5127            lastElement = cur;
5128            event.type = i > 1 ? bubbleType : special.bindType || type;
5129            handle = (dataPriv.get(cur, "events") || /* @__PURE__ */ Object.create(null))[event.type] && dataPriv.get(cur, "handle");
5130            if (handle) {
5131              handle.apply(cur, data);
5132            }
5133            handle = ontype && cur[ontype];
5134            if (handle && handle.apply && acceptData(cur)) {
5135              event.result = handle.apply(cur, data);
5136              if (event.result === false) {
5137                event.preventDefault();
5138              }
5139            }
5140          }
5141          event.type = type;
5142          if (!onlyHandlers && !event.isDefaultPrevented()) {
5143            if ((!special._default || special._default.apply(eventPath.pop(), data) === false) && acceptData(elem)) {
5144              if (ontype && isFunction(elem[type]) && !isWindow(elem)) {
5145                tmp = elem[ontype];
5146                if (tmp) {
5147                  elem[ontype] = null;
5148                }
5149                jQuery3.event.triggered = type;
5150                if (event.isPropagationStopped()) {
5151                  lastElement.addEventListener(type, stopPropagationCallback);
5152                }
5153                elem[type]();
5154                if (event.isPropagationStopped()) {
5155                  lastElement.removeEventListener(type, stopPropagationCallback);
5156                }
5157                jQuery3.event.triggered = void 0;
5158                if (tmp) {
5159                  elem[ontype] = tmp;
5160                }
5161              }
5162            }
5163          }
5164          return event.result;
5165        },
5166        // Piggyback on a donor event to simulate a different one
5167        // Used only for `focus(in | out)` events
5168        simulate: function(type, elem, event) {
5169          var e = jQuery3.extend(
5170            new jQuery3.Event(),
5171            event,
5172            {
5173              type,
5174              isSimulated: true
5175            }
5176          );
5177          jQuery3.event.trigger(e, null, elem);
5178        }
5179      });
5180      jQuery3.fn.extend({
5181        trigger: function(type, data) {
5182          return this.each(function() {
5183            jQuery3.event.trigger(type, data, this);
5184          });
5185        },
5186        triggerHandler: function(type, data) {
5187          var elem = this[0];
5188          if (elem) {
5189            return jQuery3.event.trigger(type, data, elem, true);
5190          }
5191        }
5192      });
5193      var rbracket = /\[\]$/, rCRLF = /\r?\n/g, rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, rsubmittable = /^(?:input|select|textarea|keygen)/i;
5194      function buildParams(prefix, obj, traditional, add) {
5195        var name;
5196        if (Array.isArray(obj)) {
5197          jQuery3.each(obj, function(i, v) {
5198            if (traditional || rbracket.test(prefix)) {
5199              add(prefix, v);
5200            } else {
5201              buildParams(
5202                prefix + "[" + (typeof v === "object" && v != null ? i : "") + "]",
5203                v,
5204                traditional,
5205                add
5206              );
5207            }
5208          });
5209        } else if (!traditional && toType(obj) === "object") {
5210          for (name in obj) {
5211            buildParams(prefix + "[" + name + "]", obj[name], traditional, add);
5212          }
5213        } else {
5214          add(prefix, obj);
5215        }
5216      }
5217      jQuery3.param = function(a, traditional) {
5218        var prefix, s = [], add = function(key, valueOrFunction) {
5219          var value = isFunction(valueOrFunction) ? valueOrFunction() : valueOrFunction;
5220          s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value == null ? "" : value);
5221        };
5222        if (a == null) {
5223          return "";
5224        }
5225        if (Array.isArray(a) || a.jquery && !jQuery3.isPlainObject(a)) {
5226          jQuery3.each(a, function() {
5227            add(this.name, this.value);
5228          });
5229        } else {
5230          for (prefix in a) {
5231            buildParams(prefix, a[prefix], traditional, add);
5232          }
5233        }
5234        return s.join("&");
5235      };
5236      jQuery3.fn.extend({
5237        serialize: function() {
5238          return jQuery3.param(this.serializeArray());
5239        },
5240        serializeArray: function() {
5241          return this.map(function() {
5242            var elements = jQuery3.prop(this, "elements");
5243            return elements ? jQuery3.makeArray(elements) : this;
5244          }).filter(function() {
5245            var type = this.type;
5246            return this.name && !jQuery3(this).is(":disabled") && rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) && (this.checked || !rcheckableType.test(type));
5247          }).map(function(_i, elem) {
5248            var val = jQuery3(this).val();
5249            if (val == null) {
5250              return null;
5251            }
5252            if (Array.isArray(val)) {
5253              return jQuery3.map(val, function(val2) {
5254                return { name: elem.name, value: val2.replace(rCRLF, "\r\n") };
5255              });
5256            }
5257            return { name: elem.name, value: val.replace(rCRLF, "\r\n") };
5258          }).get();
5259        }
5260      });
5261      var r20 = /%20/g, rhash = /#.*$/, rantiCache = /([?&])_=[^&]*/, rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, rnoContent = /^(?:GET|HEAD)$/, rprotocol = /^\/\//, prefilters = {}, transports = {}, allTypes = "*/".concat("*"), originAnchor = document2.createElement("a");
5262      originAnchor.href = location2.href;
5263      function addToPrefiltersOrTransports(structure) {
5264        return function(dataTypeExpression, func) {
5265          if (typeof dataTypeExpression !== "string") {
5266            func = dataTypeExpression;
5267            dataTypeExpression = "*";
5268          }
5269          var dataType, i = 0, dataTypes = dataTypeExpression.toLowerCase().match(rnothtmlwhite) || [];
5270          if (isFunction(func)) {
5271            while (dataType = dataTypes[i++]) {
5272              if (dataType[0] === "+") {
5273                dataType = dataType.slice(1) || "*";
5274                (structure[dataType] = structure[dataType] || []).unshift(func);
5275              } else {
5276                (structure[dataType] = structure[dataType] || []).push(func);
5277              }
5278            }
5279          }
5280        };
5281      }
5282      function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {
5283        var inspected = {}, seekingTransport = structure === transports;
5284        function inspect(dataType) {
5285          var selected;
5286          inspected[dataType] = true;
5287          jQuery3.each(structure[dataType] || [], function(_, prefilterOrFactory) {
5288            var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);
5289            if (typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[dataTypeOrTransport]) {
5290              options.dataTypes.unshift(dataTypeOrTransport);
5291              inspect(dataTypeOrTransport);
5292              return false;
5293            } else if (seekingTransport) {
5294              return !(selected = dataTypeOrTransport);
5295            }
5296          });
5297          return selected;
5298        }
5299        return inspect(options.dataTypes[0]) || !inspected["*"] && inspect("*");
5300      }
5301      function ajaxExtend(target, src) {
5302        var key, deep, flatOptions = jQuery3.ajaxSettings.flatOptions || {};
5303        for (key in src) {
5304          if (src[key] !== void 0) {
5305            (flatOptions[key] ? target : deep || (deep = {}))[key] = src[key];
5306          }
5307        }
5308        if (deep) {
5309          jQuery3.extend(true, target, deep);
5310        }
5311        return target;
5312      }
5313      function ajaxHandleResponses(s, jqXHR, responses) {
5314        var ct, type, finalDataType, firstDataType, contents = s.contents, dataTypes = s.dataTypes;
5315        while (dataTypes[0] === "*") {
5316          dataTypes.shift();
5317          if (ct === void 0) {
5318            ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
5319          }
5320        }
5321        if (ct) {
5322          for (type in contents) {
5323            if (contents[type] && contents[type].test(ct)) {
5324              dataTypes.unshift(type);
5325              break;
5326            }
5327          }
5328        }
5329        if (dataTypes[0] in responses) {
5330          finalDataType = dataTypes[0];
5331        } else {
5332          for (type in responses) {
5333            if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) {
5334              finalDataType = type;
5335              break;
5336            }
5337            if (!firstDataType) {
5338              firstDataType = type;
5339            }
5340          }
5341          finalDataType = finalDataType || firstDataType;
5342        }
5343        if (finalDataType) {
5344          if (finalDataType !== dataTypes[0]) {
5345            dataTypes.unshift(finalDataType);
5346          }
5347          return responses[finalDataType];
5348        }
5349      }
5350      function ajaxConvert(s, response, jqXHR, isSuccess) {
5351        var conv2, current, conv, tmp, prev, converters = {}, dataTypes = s.dataTypes.slice();
5352        if (dataTypes[1]) {
5353          for (conv in s.converters) {
5354            converters[conv.toLowerCase()] = s.converters[conv];
5355          }
5356        }
5357        current = dataTypes.shift();
5358        while (current) {
5359          if (s.responseFields[current]) {
5360            jqXHR[s.responseFields[current]] = response;
5361          }
5362          if (!prev && isSuccess && s.dataFilter) {
5363            response = s.dataFilter(response, s.dataType);
5364          }
5365          prev = current;
5366          current = dataTypes.shift();
5367          if (current) {
5368            if (current === "*") {
5369              current = prev;
5370            } else if (prev !== "*" && prev !== current) {
5371              conv = converters[prev + " " + current] || converters["* " + current];
5372              if (!conv) {
5373                for (conv2 in converters) {
5374                  tmp = conv2.split(" ");
5375                  if (tmp[1] === current) {
5376                    conv = converters[prev + " " + tmp[0]] || converters["* " + tmp[0]];
5377                    if (conv) {
5378                      if (conv === true) {
5379                        conv = converters[conv2];
5380                      } else if (converters[conv2] !== true) {
5381                        current = tmp[0];
5382                        dataTypes.unshift(tmp[1]);
5383                      }
5384                      break;
5385                    }
5386                  }
5387                }
5388              }
5389              if (conv !== true) {
5390                if (conv && s.throws) {
5391                  response = conv(response);
5392                } else {
5393                  try {
5394                    response = conv(response);
5395                  } catch (e) {
5396                    return {
5397                      state: "parsererror",
5398                      error: conv ? e : "No conversion from " + prev + " to " + current
5399                    };
5400                  }
5401                }
5402              }
5403            }
5404          }
5405        }
5406        return { state: "success", data: response };
5407      }
5408      jQuery3.extend({
5409        // Counter for holding the number of active queries
5410        active: 0,
5411        // Last-Modified header cache for next request
5412        lastModified: {},
5413        etag: {},
5414        ajaxSettings: {
5415          url: location2.href,
5416          type: "GET",
5417          isLocal: rlocalProtocol.test(location2.protocol),
5418          global: true,
5419          processData: true,
5420          async: true,
5421          contentType: "application/x-www-form-urlencoded; charset=UTF-8",
5422          /*
5423          timeout: 0,
5424          data: null,
5425          dataType: null,
5426          username: null,
5427          password: null,
5428          cache: null,
5429          throws: false,
5430          traditional: false,
5431          headers: {},
5432          */
5433          accepts: {
5434            "*": allTypes,
5435            text: "text/plain",
5436            html: "text/html",
5437            xml: "application/xml, text/xml",
5438            json: "application/json, text/javascript"
5439          },
5440          contents: {
5441            xml: /\bxml\b/,
5442            html: /\bhtml/,
5443            json: /\bjson\b/
5444          },
5445          responseFields: {
5446            xml: "responseXML",
5447            text: "responseText",
5448            json: "responseJSON"
5449          },
5450          // Data converters
5451          // Keys separate source (or catchall "*") and destination types with a single space
5452          converters: {
5453            // Convert anything to text
5454            "* text": String,
5455            // Text to html (true = no transformation)
5456            "text html": true,
5457            // Evaluate text as a json expression
5458            "text json": JSON.parse,
5459            // Parse text as xml
5460            "text xml": jQuery3.parseXML
5461          },
5462          // For options that shouldn't be deep extended:
5463          // you can add your own custom options here if
5464          // and when you create one that shouldn't be
5465          // deep extended (see ajaxExtend)
5466          flatOptions: {
5467            url: true,
5468            context: true
5469          }
5470        },
5471        // Creates a full fledged settings object into target
5472        // with both ajaxSettings and settings fields.
5473        // If target is omitted, writes into ajaxSettings.
5474        ajaxSetup: function(target, settings) {
5475          return settings ? (
5476            // Building a settings object
5477            ajaxExtend(ajaxExtend(target, jQuery3.ajaxSettings), settings)
5478          ) : (
5479            // Extending ajaxSettings
5480            ajaxExtend(jQuery3.ajaxSettings, target)
5481          );
5482        },
5483        ajaxPrefilter: addToPrefiltersOrTransports(prefilters),
5484        ajaxTransport: addToPrefiltersOrTransports(transports),
5485        // Main method
5486        ajax: function(url, options) {
5487          if (typeof url === "object") {
5488            options = url;
5489            url = void 0;
5490          }
5491          options = options || {};
5492          var transport, cacheURL, responseHeadersString, responseHeaders, timeoutTimer, urlAnchor, completed2, fireGlobals, i, uncached, s = jQuery3.ajaxSetup({}, options), callbackContext = s.context || s, globalEventContext = s.context && (callbackContext.nodeType || callbackContext.jquery) ? jQuery3(callbackContext) : jQuery3.event, deferred = jQuery3.Deferred(), completeDeferred = jQuery3.Callbacks("once memory"), statusCode = s.statusCode || {}, requestHeaders = {}, requestHeadersNames = {}, strAbort = "canceled", jqXHR = {
5493            readyState: 0,
5494            // Builds headers hashtable if needed
5495            getResponseHeader: function(key) {
5496              var match;
5497              if (completed2) {
5498                if (!responseHeaders) {
5499                  responseHeaders = {};
5500                  while (match = rheaders.exec(responseHeadersString)) {
5501                    responseHeaders[match[1].toLowerCase() + " "] = (responseHeaders[match[1].toLowerCase() + " "] || []).concat(match[2]);
5502                  }
5503                }
5504                match = responseHeaders[key.toLowerCase() + " "];
5505              }
5506              return match == null ? null : match.join(", ");
5507            },
5508            // Raw string
5509            getAllResponseHeaders: function() {
5510              return completed2 ? responseHeadersString : null;
5511            },
5512            // Caches the header
5513            setRequestHeader: function(name, value) {
5514              if (completed2 == null) {
5515                name = requestHeadersNames[name.toLowerCase()] = requestHeadersNames[name.toLowerCase()] || name;
5516                requestHeaders[name] = value;
5517              }
5518              return this;
5519            },
5520            // Overrides response content-type header
5521            overrideMimeType: function(type) {
5522              if (completed2 == null) {
5523                s.mimeType = type;
5524              }
5525              return this;
5526            },
5527            // Status-dependent callbacks
5528            statusCode: function(map) {
5529              var code;
5530              if (map) {
5531                if (completed2) {
5532                  jqXHR.always(map[jqXHR.status]);
5533                } else {
5534                  for (code in map) {
5535                    statusCode[code] = [statusCode[code], map[code]];
5536                  }
5537                }
5538              }
5539              return this;
5540            },
5541            // Cancel the request
5542            abort: function(statusText) {
5543              var finalText = statusText || strAbort;
5544              if (transport) {
5545                transport.abort(finalText);
5546              }
5547              done(0, finalText);
5548              return this;
5549            }
5550          };
5551          deferred.promise(jqXHR);
5552          s.url = ((url || s.url || location2.href) + "").replace(rprotocol, location2.protocol + "//");
5553          s.type = options.method || options.type || s.method || s.type;
5554          s.dataTypes = (s.dataType || "*").toLowerCase().match(rnothtmlwhite) || [""];
5555          if (s.crossDomain == null) {
5556            urlAnchor = document2.createElement("a");
5557            try {
5558              urlAnchor.href = s.url;
5559              urlAnchor.href = urlAnchor.href;
5560              s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== urlAnchor.protocol + "//" + urlAnchor.host;
5561            } catch (e) {
5562              s.crossDomain = true;
5563            }
5564          }
5565          if (s.data && s.processData && typeof s.data !== "string") {
5566            s.data = jQuery3.param(s.data, s.traditional);
5567          }
5568          inspectPrefiltersOrTransports(prefilters, s, options, jqXHR);
5569          if (completed2) {
5570            return jqXHR;
5571          }
5572          fireGlobals = jQuery3.event && s.global;
5573          if (fireGlobals && jQuery3.active++ === 0) {
5574            jQuery3.event.trigger("ajaxStart");
5575          }
5576          s.type = s.type.toUpperCase();
5577          s.hasContent = !rnoContent.test(s.type);
5578          cacheURL = s.url.replace(rhash, "");
5579          if (!s.hasContent) {
5580            uncached = s.url.slice(cacheURL.length);
5581            if (s.data && (s.processData || typeof s.data === "string")) {
5582              cacheURL += (rquery.test(cacheURL) ? "&" : "?") + s.data;
5583              delete s.data;
5584            }
5585            if (s.cache === false) {
5586              cacheURL = cacheURL.replace(rantiCache, "$1");
5587              uncached = (rquery.test(cacheURL) ? "&" : "?") + "_=" + nonce.guid++ + uncached;
5588            }
5589            s.url = cacheURL + uncached;
5590          } else if (s.data && s.processData && (s.contentType || "").indexOf("application/x-www-form-urlencoded") === 0) {
5591            s.data = s.data.replace(r20, "+");
5592          }
5593          if (s.ifModified) {
5594            if (jQuery3.lastModified[cacheURL]) {
5595              jqXHR.setRequestHeader("If-Modified-Since", jQuery3.lastModified[cacheURL]);
5596            }
5597            if (jQuery3.etag[cacheURL]) {
5598              jqXHR.setRequestHeader("If-None-Match", jQuery3.etag[cacheURL]);
5599            }
5600          }
5601          if (s.data && s.hasContent && s.contentType !== false || options.contentType) {
5602            jqXHR.setRequestHeader("Content-Type", s.contentType);
5603          }
5604          jqXHR.setRequestHeader(
5605            "Accept",
5606            s.dataTypes[0] && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] + (s.dataTypes[0] !== "*" ? ", " + allTypes + "; q=0.01" : "") : s.accepts["*"]
5607          );
5608          for (i in s.headers) {
5609            jqXHR.setRequestHeader(i, s.headers[i]);
5610          }
5611          if (s.beforeSend && (s.beforeSend.call(callbackContext, jqXHR, s) === false || completed2)) {
5612            return jqXHR.abort();
5613          }
5614          strAbort = "abort";
5615          completeDeferred.add(s.complete);
5616          jqXHR.done(s.success);
5617          jqXHR.fail(s.error);
5618          transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR);
5619          if (!transport) {
5620            done(-1, "No Transport");
5621          } else {
5622            jqXHR.readyState = 1;
5623            if (fireGlobals) {
5624              globalEventContext.trigger("ajaxSend", [jqXHR, s]);
5625            }
5626            if (completed2) {
5627              return jqXHR;
5628            }
5629            if (s.async && s.timeout > 0) {
5630              timeoutTimer = window2.setTimeout(function() {
5631                jqXHR.abort("timeout");
5632              }, s.timeout);
5633            }
5634            try {
5635              completed2 = false;
5636              transport.send(requestHeaders, done);
5637            } catch (e) {
5638              if (completed2) {
5639                throw e;
5640              }
5641              done(-1, e);
5642            }
5643          }
5644          function done(status, nativeStatusText, responses, headers) {
5645            var isSuccess, success, error, response, modified, statusText = nativeStatusText;
5646            if (completed2) {
5647              return;
5648            }
5649            completed2 = true;
5650            if (timeoutTimer) {
5651              window2.clearTimeout(timeoutTimer);
5652            }
5653            transport = void 0;
5654            responseHeadersString = headers || "";
5655            jqXHR.readyState = status > 0 ? 4 : 0;
5656            isSuccess = status >= 200 && status < 300 || status === 304;
5657            if (responses) {
5658              response = ajaxHandleResponses(s, jqXHR, responses);
5659            }
5660            if (!isSuccess && jQuery3.inArray("script", s.dataTypes) > -1 && jQuery3.inArray("json", s.dataTypes) < 0) {
5661              s.converters["text script"] = function() {
5662              };
5663            }
5664            response = ajaxConvert(s, response, jqXHR, isSuccess);
5665            if (isSuccess) {
5666              if (s.ifModified) {
5667                modified = jqXHR.getResponseHeader("Last-Modified");
5668                if (modified) {
5669                  jQuery3.lastModified[cacheURL] = modified;
5670                }
5671                modified = jqXHR.getResponseHeader("etag");
5672                if (modified) {
5673                  jQuery3.etag[cacheURL] = modified;
5674                }
5675              }
5676              if (status === 204 || s.type === "HEAD") {
5677                statusText = "nocontent";
5678              } else if (status === 304) {
5679                statusText = "notmodified";
5680              } else {
5681                statusText = response.state;
5682                success = response.data;
5683                error = response.error;
5684                isSuccess = !error;
5685              }
5686            } else {
5687              error = statusText;
5688              if (status || !statusText) {
5689                statusText = "error";
5690                if (status < 0) {
5691                  status = 0;
5692                }
5693              }
5694            }
5695            jqXHR.status = status;
5696            jqXHR.statusText = (nativeStatusText || statusText) + "";
5697            if (isSuccess) {
5698              deferred.resolveWith(callbackContext, [success, statusText, jqXHR]);
5699            } else {
5700              deferred.rejectWith(callbackContext, [jqXHR, statusText, error]);
5701            }
5702            jqXHR.statusCode(statusCode);
5703            statusCode = void 0;
5704            if (fireGlobals) {
5705              globalEventContext.trigger(
5706                isSuccess ? "ajaxSuccess" : "ajaxError",
5707                [jqXHR, s, isSuccess ? success : error]
5708              );
5709            }
5710            completeDeferred.fireWith(callbackContext, [jqXHR, statusText]);
5711            if (fireGlobals) {
5712              globalEventContext.trigger("ajaxComplete", [jqXHR, s]);
5713              if (!--jQuery3.active) {
5714                jQuery3.event.trigger("ajaxStop");
5715              }
5716            }
5717          }
5718          return jqXHR;
5719        },
5720        getJSON: function(url, data, callback) {
5721          return jQuery3.get(url, data, callback, "json");
5722        },
5723        getScript: function(url, callback) {
5724          return jQuery3.get(url, void 0, callback, "script");
5725        }
5726      });
5727      jQuery3.each(["get", "post"], function(_i, method) {
5728        jQuery3[method] = function(url, data, callback, type) {
5729          if (isFunction(data)) {
5730            type = type || callback;
5731            callback = data;
5732            data = void 0;
5733          }
5734          return jQuery3.ajax(jQuery3.extend({
5735            url,
5736            type: method,
5737            dataType: type,
5738            data,
5739            success: callback
5740          }, jQuery3.isPlainObject(url) && url));
5741        };
5742      });
5743      jQuery3.ajaxPrefilter(function(s) {
5744        var i;
5745        for (i in s.headers) {
5746          if (i.toLowerCase() === "content-type") {
5747            s.contentType = s.headers[i] || "";
5748          }
5749        }
5750      });
5751      jQuery3._evalUrl = function(url, options, doc) {
5752        return jQuery3.ajax({
5753          url,
5754          // Make this explicit, since user can override this through ajaxSetup (trac-11264)
5755          type: "GET",
5756          dataType: "script",
5757          cache: true,
5758          async: false,
5759          global: false,
5760          // Only evaluate the response if it is successful (gh-4126)
5761          // dataFilter is not invoked for failure responses, so using it instead
5762          // of the default converter is kludgy but it works.
5763          converters: {
5764            "text script": function() {
5765            }
5766          },
5767          dataFilter: function(response) {
5768            jQuery3.globalEval(response, options, doc);
5769          }
5770        });
5771      };
5772      jQuery3.fn.extend({
5773        wrapAll: function(html) {
5774          var wrap;
5775          if (this[0]) {
5776            if (isFunction(html)) {
5777              html = html.call(this[0]);
5778            }
5779            wrap = jQuery3(html, this[0].ownerDocument).eq(0).clone(true);
5780            if (this[0].parentNode) {
5781              wrap.insertBefore(this[0]);
5782            }
5783            wrap.map(function() {
5784              var elem = this;
5785              while (elem.firstElementChild) {
5786                elem = elem.firstElementChild;
5787              }
5788              return elem;
5789            }).append(this);
5790          }
5791          return this;
5792        },
5793        wrapInner: function(html) {
5794          if (isFunction(html)) {
5795            return this.each(function(i) {
5796              jQuery3(this).wrapInner(html.call(this, i));
5797            });
5798          }
5799          return this.each(function() {
5800            var self = jQuery3(this), contents = self.contents();
5801            if (contents.length) {
5802              contents.wrapAll(html);
5803            } else {
5804              self.append(html);
5805            }
5806          });
5807        },
5808        wrap: function(html) {
5809          var htmlIsFunction = isFunction(html);
5810          return this.each(function(i) {
5811            jQuery3(this).wrapAll(htmlIsFunction ? html.call(this, i) : html);
5812          });
5813        },
5814        unwrap: function(selector) {
5815          this.parent(selector).not("body").each(function() {
5816            jQuery3(this).replaceWith(this.childNodes);
5817          });
5818          return this;
5819        }
5820      });
5821      jQuery3.expr.pseudos.hidden = function(elem) {
5822        return !jQuery3.expr.pseudos.visible(elem);
5823      };
5824      jQuery3.expr.pseudos.visible = function(elem) {
5825        return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);
5826      };
5827      jQuery3.ajaxSettings.xhr = function() {
5828        try {
5829          return new window2.XMLHttpRequest();
5830        } catch (e) {
5831        }
5832      };
5833      var xhrSuccessStatus = {
5834        // File protocol always yields status code 0, assume 200
5835        0: 200,
5836        // Support: IE <=9 only
5837        // trac-1450: sometimes IE returns 1223 when it should be 204
5838        1223: 204
5839      }, xhrSupported = jQuery3.ajaxSettings.xhr();
5840      support.cors = !!xhrSupported && "withCredentials" in xhrSupported;
5841      support.ajax = xhrSupported = !!xhrSupported;
5842      jQuery3.ajaxTransport(function(options) {
5843        var callback, errorCallback;
5844        if (support.cors || xhrSupported && !options.crossDomain) {
5845          return {
5846            send: function(headers, complete) {
5847              var i, xhr = options.xhr();
5848              xhr.open(
5849                options.type,
5850                options.url,
5851                options.async,
5852                options.username,
5853                options.password
5854              );
5855              if (options.xhrFields) {
5856                for (i in options.xhrFields) {
5857                  xhr[i] = options.xhrFields[i];
5858                }
5859              }
5860              if (options.mimeType && xhr.overrideMimeType) {
5861                xhr.overrideMimeType(options.mimeType);
5862              }
5863              if (!options.crossDomain && !headers["X-Requested-With"]) {
5864                headers["X-Requested-With"] = "XMLHttpRequest";
5865              }
5866              for (i in headers) {
5867                xhr.setRequestHeader(i, headers[i]);
5868              }
5869              callback = function(type) {
5870                return function() {
5871                  if (callback) {
5872                    callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.ontimeout = xhr.onreadystatechange = null;
5873                    if (type === "abort") {
5874                      xhr.abort();
5875                    } else if (type === "error") {
5876                      if (typeof xhr.status !== "number") {
5877                        complete(0, "error");
5878                      } else {
5879                        complete(
5880                          // File: protocol always yields status 0; see trac-8605, trac-14207
5881                          xhr.status,
5882                          xhr.statusText
5883                        );
5884                      }
5885                    } else {
5886                      complete(
5887                        xhrSuccessStatus[xhr.status] || xhr.status,
5888                        xhr.statusText,
5889                        // Support: IE <=9 only
5890                        // IE9 has no XHR2 but throws on binary (trac-11426)
5891                        // For XHR2 non-text, let the caller handle it (gh-2498)
5892                        (xhr.responseType || "text") !== "text" || typeof xhr.responseText !== "string" ? { binary: xhr.response } : { text: xhr.responseText },
5893                        xhr.getAllResponseHeaders()
5894                      );
5895                    }
5896                  }
5897                };
5898              };
5899              xhr.onload = callback();
5900              errorCallback = xhr.onerror = xhr.ontimeout = callback("error");
5901              if (xhr.onabort !== void 0) {
5902                xhr.onabort = errorCallback;
5903              } else {
5904                xhr.onreadystatechange = function() {
5905                  if (xhr.readyState === 4) {
5906                    window2.setTimeout(function() {
5907                      if (callback) {
5908                        errorCallback();
5909                      }
5910                    });
5911                  }
5912                };
5913              }
5914              callback = callback("abort");
5915              try {
5916                xhr.send(options.hasContent && options.data || null);
5917              } catch (e) {
5918                if (callback) {
5919                  throw e;
5920                }
5921              }
5922            },
5923            abort: function() {
5924              if (callback) {
5925                callback();
5926              }
5927            }
5928          };
5929        }
5930      });
5931      jQuery3.ajaxPrefilter(function(s) {
5932        if (s.crossDomain) {
5933          s.contents.script = false;
5934        }
5935      });
5936      jQuery3.ajaxSetup({
5937        accepts: {
5938          script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
5939        },
5940        contents: {
5941          script: /\b(?:java|ecma)script\b/
5942        },
5943        converters: {
5944          "text script": function(text) {
5945            jQuery3.globalEval(text);
5946            return text;
5947          }
5948        }
5949      });
5950      jQuery3.ajaxPrefilter("script", function(s) {
5951        if (s.cache === void 0) {
5952          s.cache = false;
5953        }
5954        if (s.crossDomain) {
5955          s.type = "GET";
5956        }
5957      });
5958      jQuery3.ajaxTransport("script", function(s) {
5959        if (s.crossDomain || s.scriptAttrs) {
5960          var script, callback;
5961          return {
5962            send: function(_, complete) {
5963              script = jQuery3("<script>").attr(s.scriptAttrs || {}).prop({ charset: s.scriptCharset, src: s.url }).on("load error", callback = function(evt) {
5964                script.remove();
5965                callback = null;
5966                if (evt) {
5967                  complete(evt.type === "error" ? 404 : 200, evt.type);
5968                }
5969              });
5970              document2.head.appendChild(script[0]);
5971            },
5972            abort: function() {
5973              if (callback) {
5974                callback();
5975              }
5976            }
5977          };
5978        }
5979      });
5980      var oldCallbacks = [], rjsonp = /(=)\?(?=&|$)|\?\?/;
5981      jQuery3.ajaxSetup({
5982        jsonp: "callback",
5983        jsonpCallback: function() {
5984          var callback = oldCallbacks.pop() || jQuery3.expando + "_" + nonce.guid++;
5985          this[callback] = true;
5986          return callback;
5987        }
5988      });
5989      jQuery3.ajaxPrefilter("json jsonp", function(s, originalSettings, jqXHR) {
5990        var callbackName, overwritten, responseContainer, jsonProp = s.jsonp !== false && (rjsonp.test(s.url) ? "url" : typeof s.data === "string" && (s.contentType || "").indexOf("application/x-www-form-urlencoded") === 0 && rjsonp.test(s.data) && "data");
5991        if (jsonProp || s.dataTypes[0] === "jsonp") {
5992          callbackName = s.jsonpCallback = isFunction(s.jsonpCallback) ? s.jsonpCallback() : s.jsonpCallback;
5993          if (jsonProp) {
5994            s[jsonProp] = s[jsonProp].replace(rjsonp, "$1" + callbackName);
5995          } else if (s.jsonp !== false) {
5996            s.url += (rquery.test(s.url) ? "&" : "?") + s.jsonp + "=" + callbackName;
5997          }
5998          s.converters["script json"] = function() {
5999            if (!responseContainer) {
6000              jQuery3.error(callbackName + " was not called");
6001            }
6002            return responseContainer[0];
6003          };
6004          s.dataTypes[0] = "json";
6005          overwritten = window2[callbackName];
6006          window2[callbackName] = function() {
6007            responseContainer = arguments;
6008          };
6009          jqXHR.always(function() {
6010            if (overwritten === void 0) {
6011              jQuery3(window2).removeProp(callbackName);
6012            } else {
6013              window2[callbackName] = overwritten;
6014            }
6015            if (s[callbackName]) {
6016              s.jsonpCallback = originalSettings.jsonpCallback;
6017              oldCallbacks.push(callbackName);
6018            }
6019            if (responseContainer && isFunction(overwritten)) {
6020              overwritten(responseContainer[0]);
6021            }
6022            responseContainer = overwritten = void 0;
6023          });
6024          return "script";
6025        }
6026      });
6027      support.createHTMLDocument = (function() {
6028        var body = document2.implementation.createHTMLDocument("").body;
6029        body.innerHTML = "<form></form><form></form>";
6030        return body.childNodes.length === 2;
6031      })();
6032      jQuery3.parseHTML = function(data, context, keepScripts) {
6033        if (typeof data !== "string") {
6034          return [];
6035        }
6036        if (typeof context === "boolean") {
6037          keepScripts = context;
6038          context = false;
6039        }
6040        var base, parsed, scripts;
6041        if (!context) {
6042          if (support.createHTMLDocument) {
6043            context = document2.implementation.createHTMLDocument("");
6044            base = context.createElement("base");
6045            base.href = document2.location.href;
6046            context.head.appendChild(base);
6047          } else {
6048            context = document2;
6049          }
6050        }
6051        parsed = rsingleTag.exec(data);
6052        scripts = !keepScripts && [];
6053        if (parsed) {
6054          return [context.createElement(parsed[1])];
6055        }
6056        parsed = buildFragment([data], context, scripts);
6057        if (scripts && scripts.length) {
6058          jQuery3(scripts).remove();
6059        }
6060        return jQuery3.merge([], parsed.childNodes);
6061      };
6062      jQuery3.fn.load = function(url, params, callback) {
6063        var selector, type, response, self = this, off = url.indexOf(" ");
6064        if (off > -1) {
6065          selector = stripAndCollapse(url.slice(off));
6066          url = url.slice(0, off);
6067        }
6068        if (isFunction(params)) {
6069          callback = params;
6070          params = void 0;
6071        } else if (params && typeof params === "object") {
6072          type = "POST";
6073        }
6074        if (self.length > 0) {
6075          jQuery3.ajax({
6076            url,
6077            // If "type" variable is undefined, then "GET" method will be used.
6078            // Make value of this field explicit since
6079            // user can override it through ajaxSetup method
6080            type: type || "GET",
6081            dataType: "html",
6082            data: params
6083          }).done(function(responseText) {
6084            response = arguments;
6085            self.html(selector ? (
6086              // If a selector was specified, locate the right elements in a dummy div
6087              // Exclude scripts to avoid IE 'Permission Denied' errors
6088              jQuery3("<div>").append(jQuery3.parseHTML(responseText)).find(selector)
6089            ) : (
6090              // Otherwise use the full result
6091              responseText
6092            ));
6093          }).always(callback && function(jqXHR, status) {
6094            self.each(function() {
6095              callback.apply(this, response || [jqXHR.responseText, status, jqXHR]);
6096            });
6097          });
6098        }
6099        return this;
6100      };
6101      jQuery3.expr.pseudos.animated = function(elem) {
6102        return jQuery3.grep(jQuery3.timers, function(fn) {
6103          return elem === fn.elem;
6104        }).length;
6105      };
6106      jQuery3.offset = {
6107        setOffset: function(elem, options, i) {
6108          var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition, position = jQuery3.css(elem, "position"), curElem = jQuery3(elem), props = {};
6109          if (position === "static") {
6110            elem.style.position = "relative";
6111          }
6112          curOffset = curElem.offset();
6113          curCSSTop = jQuery3.css(elem, "top");
6114          curCSSLeft = jQuery3.css(elem, "left");
6115          calculatePosition = (position === "absolute" || position === "fixed") && (curCSSTop + curCSSLeft).indexOf("auto") > -1;
6116          if (calculatePosition) {
6117            curPosition = curElem.position();
6118            curTop = curPosition.top;
6119            curLeft = curPosition.left;
6120          } else {
6121            curTop = parseFloat(curCSSTop) || 0;
6122            curLeft = parseFloat(curCSSLeft) || 0;
6123          }
6124          if (isFunction(options)) {
6125            options = options.call(elem, i, jQuery3.extend({}, curOffset));
6126          }
6127          if (options.top != null) {
6128            props.top = options.top - curOffset.top + curTop;
6129          }
6130          if (options.left != null) {
6131            props.left = options.left - curOffset.left + curLeft;
6132          }
6133          if ("using" in options) {
6134            options.using.call(elem, props);
6135          } else {
6136            curElem.css(props);
6137          }
6138        }
6139      };
6140      jQuery3.fn.extend({
6141        // offset() relates an element's border box to the document origin
6142        offset: function(options) {
6143          if (arguments.length) {
6144            return options === void 0 ? this : this.each(function(i) {
6145              jQuery3.offset.setOffset(this, options, i);
6146            });
6147          }
6148          var rect, win, elem = this[0];
6149          if (!elem) {
6150            return;
6151          }
6152          if (!elem.getClientRects().length) {
6153            return { top: 0, left: 0 };
6154          }
6155          rect = elem.getBoundingClientRect();
6156          win = elem.ownerDocument.defaultView;
6157          return {
6158            top: rect.top + win.pageYOffset,
6159            left: rect.left + win.pageXOffset
6160          };
6161        },
6162        // position() relates an element's margin box to its offset parent's padding box
6163        // This corresponds to the behavior of CSS absolute positioning
6164        position: function() {
6165          if (!this[0]) {
6166            return;
6167          }
6168          var offsetParent, offset, doc, elem = this[0], parentOffset = { top: 0, left: 0 };
6169          if (jQuery3.css(elem, "position") === "fixed") {
6170            offset = elem.getBoundingClientRect();
6171          } else {
6172            offset = this.offset();
6173            doc = elem.ownerDocument;
6174            offsetParent = elem.offsetParent || doc.documentElement;
6175            while (offsetParent && (offsetParent === doc.body || offsetParent === doc.documentElement) && jQuery3.css(offsetParent, "position") === "static") {
6176              offsetParent = offsetParent.parentNode;
6177            }
6178            if (offsetParent && offsetParent !== elem && offsetParent.nodeType === 1) {
6179              parentOffset = jQuery3(offsetParent).offset();
6180              parentOffset.top += jQuery3.css(offsetParent, "borderTopWidth", true);
6181              parentOffset.left += jQuery3.css(offsetParent, "borderLeftWidth", true);
6182            }
6183          }
6184          return {
6185            top: offset.top - parentOffset.top - jQuery3.css(elem, "marginTop", true),
6186            left: offset.left - parentOffset.left - jQuery3.css(elem, "marginLeft", true)
6187          };
6188        },
6189        // This method will return documentElement in the following cases:
6190        // 1) For the element inside the iframe without offsetParent, this method will return
6191        //    documentElement of the parent window
6192        // 2) For the hidden or detached element
6193        // 3) For body or html element, i.e. in case of the html node - it will return itself
6194        //
6195        // but those exceptions were never presented as a real life use-cases
6196        // and might be considered as more preferable results.
6197        //
6198        // This logic, however, is not guaranteed and can change at any point in the future
6199        offsetParent: function() {
6200          return this.map(function() {
6201            var offsetParent = this.offsetParent;
6202            while (offsetParent && jQuery3.css(offsetParent, "position") === "static") {
6203              offsetParent = offsetParent.offsetParent;
6204            }
6205            return offsetParent || documentElement;
6206          });
6207        }
6208      });
6209      jQuery3.each({ scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function(method, prop) {
6210        var top = "pageYOffset" === prop;
6211        jQuery3.fn[method] = function(val) {
6212          return access(this, function(elem, method2, val2) {
6213            var win;
6214            if (isWindow(elem)) {
6215              win = elem;
6216            } else if (elem.nodeType === 9) {
6217              win = elem.defaultView;
6218            }
6219            if (val2 === void 0) {
6220              return win ? win[prop] : elem[method2];
6221            }
6222            if (win) {
6223              win.scrollTo(
6224                !top ? val2 : win.pageXOffset,
6225                top ? val2 : win.pageYOffset
6226              );
6227            } else {
6228              elem[method2] = val2;
6229            }
6230          }, method, val, arguments.length);
6231        };
6232      });
6233      jQuery3.each(["top", "left"], function(_i, prop) {
6234        jQuery3.cssHooks[prop] = addGetHookIf(
6235          support.pixelPosition,
6236          function(elem, computed) {
6237            if (computed) {
6238              computed = curCSS(elem, prop);
6239              return rnumnonpx.test(computed) ? jQuery3(elem).position()[prop] + "px" : computed;
6240            }
6241          }
6242        );
6243      });
6244      jQuery3.each({ Height: "height", Width: "width" }, function(name, type) {
6245        jQuery3.each({
6246          padding: "inner" + name,
6247          content: type,
6248          "": "outer" + name
6249        }, function(defaultExtra, funcName) {
6250          jQuery3.fn[funcName] = function(margin, value) {
6251            var chainable = arguments.length && (defaultExtra || typeof margin !== "boolean"), extra = defaultExtra || (margin === true || value === true ? "margin" : "border");
6252            return access(this, function(elem, type2, value2) {
6253              var doc;
6254              if (isWindow(elem)) {
6255                return funcName.indexOf("outer") === 0 ? elem["inner" + name] : elem.document.documentElement["client" + name];
6256              }
6257              if (elem.nodeType === 9) {
6258                doc = elem.documentElement;
6259                return Math.max(
6260                  elem.body["scroll" + name],
6261                  doc["scroll" + name],
6262                  elem.body["offset" + name],
6263                  doc["offset" + name],
6264                  doc["client" + name]
6265                );
6266              }
6267              return value2 === void 0 ? (
6268                // Get width or height on the element, requesting but not forcing parseFloat
6269                jQuery3.css(elem, type2, extra)
6270              ) : (
6271                // Set width or height on the element
6272                jQuery3.style(elem, type2, value2, extra)
6273              );
6274            }, type, chainable ? margin : void 0, chainable);
6275          };
6276        });
6277      });
6278      jQuery3.each([
6279        "ajaxStart",
6280        "ajaxStop",
6281        "ajaxComplete",
6282        "ajaxError",
6283        "ajaxSuccess",
6284        "ajaxSend"
6285      ], function(_i, type) {
6286        jQuery3.fn[type] = function(fn) {
6287          return this.on(type, fn);
6288        };
6289      });
6290      jQuery3.fn.extend({
6291        bind: function(types, data, fn) {
6292          return this.on(types, null, data, fn);
6293        },
6294        unbind: function(types, fn) {
6295          return this.off(types, null, fn);
6296        },
6297        delegate: function(selector, types, data, fn) {
6298          return this.on(types, selector, data, fn);
6299        },
6300        undelegate: function(selector, types, fn) {
6301          return arguments.length === 1 ? this.off(selector, "**") : this.off(types, selector || "**", fn);
6302        },
6303        hover: function(fnOver, fnOut) {
6304          return this.on("mouseenter", fnOver).on("mouseleave", fnOut || fnOver);
6305        }
6306      });
6307      jQuery3.each(
6308        "blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),
6309        function(_i, name) {
6310          jQuery3.fn[name] = function(data, fn) {
6311            return arguments.length > 0 ? this.on(name, null, data, fn) : this.trigger(name);
6312          };
6313        }
6314      );
6315      var rtrim = /^[\s\uFEFF\xA0]+|([^\s\uFEFF\xA0])[\s\uFEFF\xA0]+$/g;
6316      jQuery3.proxy = function(fn, context) {
6317        var tmp, args, proxy;
6318        if (typeof context === "string") {
6319          tmp = fn[context];
6320          context = fn;
6321          fn = tmp;
6322        }
6323        if (!isFunction(fn)) {
6324          return void 0;
6325        }
6326        args = slice.call(arguments, 2);
6327        proxy = function() {
6328          return fn.apply(context || this, args.concat(slice.call(arguments)));
6329        };
6330        proxy.guid = fn.guid = fn.guid || jQuery3.guid++;
6331        return proxy;
6332      };
6333      jQuery3.holdReady = function(hold) {
6334        if (hold) {
6335          jQuery3.readyWait++;
6336        } else {
6337          jQuery3.ready(true);
6338        }
6339      };
6340      jQuery3.isArray = Array.isArray;
6341      jQuery3.parseJSON = JSON.parse;
6342      jQuery3.nodeName = nodeName;
6343      jQuery3.isFunction = isFunction;
6344      jQuery3.isWindow = isWindow;
6345      jQuery3.camelCase = camelCase;
6346      jQuery3.type = toType;
6347      jQuery3.now = Date.now;
6348      jQuery3.isNumeric = function(obj) {
6349        var type = jQuery3.type(obj);
6350        return (type === "number" || type === "string") && // parseFloat NaNs numeric-cast false positives ("")
6351        // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
6352        // subtraction forces infinities to NaN
6353        !isNaN(obj - parseFloat(obj));
6354      };
6355      jQuery3.trim = function(text) {
6356        return text == null ? "" : (text + "").replace(rtrim, "$1");
6357      };
6358      if (typeof define === "function" && define.amd) {
6359        define("jquery", [], function() {
6360          return jQuery3;
6361        });
6362      }
6363      var _jQuery = window2.jQuery, _$ = window2.$;
6364      jQuery3.noConflict = function(deep) {
6365        if (window2.$ === jQuery3) {
6366          window2.$ = _$;
6367        }
6368        if (deep && window2.jQuery === jQuery3) {
6369          window2.jQuery = _jQuery;
6370        }
6371        return jQuery3;
6372      };
6373      if (typeof noGlobal === "undefined") {
6374        window2.jQuery = window2.$ = jQuery3;
6375      }
6376      return jQuery3;
6377    });
6378  }
6379});
6380