☰

wnacg-helper

A manga helper for wnacg.com

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