https://alhoukoul.com/assets/frappe/dist/js/frappe-web.bundle.M4ZMZZX7.js

1(() => {
2  var __create = Object.create;
3  var __defProp = Object.defineProperty;
4  var __defProps = Object.defineProperties;
5  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
6  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
7  var __getOwnPropNames = Object.getOwnPropertyNames;
8  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
9  var __getProtoOf = Object.getPrototypeOf;
10  var __hasOwnProp = Object.prototype.hasOwnProperty;
11  var __propIsEnum = Object.prototype.propertyIsEnumerable;
12  var __defNormalProp = (obj, key, value2) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value: value2 }) : obj[key] = value2;
13  var __spreadValues = (a, b) => {
14    for (var prop in b || (b = {}))
15      if (__hasOwnProp.call(b, prop))
16        __defNormalProp(a, prop, b[prop]);
17    if (__getOwnPropSymbols)
18      for (var prop of __getOwnPropSymbols(b)) {
19        if (__propIsEnum.call(b, prop))
20          __defNormalProp(a, prop, b[prop]);
21      }
22    return a;
23  };
24  var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
25  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
26    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
27  }) : x)(function(x) {
28    if (typeof require !== "undefined")
29      return require.apply(this, arguments);
30    throw new Error('Dynamic require of "' + x + '" is not supported');
31  });
32  var __commonJS = (cb, mod) => function __require2() {
33    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
34  };
35  var __export = (target, all) => {
36    for (var name2 in all)
37      __defProp(target, name2, { get: all[name2], enumerable: true });
38  };
39  var __copyProps = (to, from, except, desc) => {
40    if (from && typeof from === "object" || typeof from === "function") {
41      for (let key of __getOwnPropNames(from))
42        if (!__hasOwnProp.call(to, key) && key !== except)
43          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
44    }
45    return to;
46  };
47  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
48    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
49    mod
50  ));
51
52  

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