https://www.prime1studio.com/on/demandware.static/Sites-Prime1Stud…/js/jquery.magnific-popup.min.js

1/******/ (() => { // webpackBootstrap
2/******/ 	var __webpack_modules__ = ({
3
4/***/ "./

692/***/ "./node_modules/jquery/dist/jquery.js":
693/*!********************************************!*\
694  !*** ./node_modules/jquery/dist/jquery.js ***!
695  \********************************************/
696/***/ (function(module, exports, __webpack_require__) {
697
698/* module decorator */ module = __webpack_require__.nmd(module);
699var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
700/*!
701 * jQuery JavaScript Library v3.7.1
702 * https://jquery.com/
703 *
704 * Copyright OpenJS Foundation and other contributors
705 * Released under the MIT license
706 * https://jquery.org/license
707 *
708 * Date: 2023-08-28T13:37Z
709 */
710(function (global, factory) {
711  "use strict";
712
713  if (( false ? 0 : _typeof(module)) === "object" && _typeof(module.exports) === "object") {
714    // For CommonJS and CommonJS-like environments where a proper `window`
715    // is present, execute the factory and get jQuery.
716    // For environments that do not have a `window` with a `document`
717    // (such as Node.js), expose a factory as module.exports.
718    // This accentuates the need for the creation of a real `window`.
719    // e.g. var jQuery = require("jquery")(window);
720    // See ticket trac-14549 for more info.
721    module.exports = global.document ? factory(global, true) : function (w) {
722      if (!w.document) {
723        throw new Error("jQuery requires a window with a document");
724      }
725      return factory(w);
726    };
727  } else {
728    factory(global);
729  }
730
731  // Pass this if window is not defined yet
732})(typeof window !== "undefined" ? window : this, function (window, noGlobal) {
733  // Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
734  // throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
735  // arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
736  // enough that all such attempts are guarded in a try block.
737  "use strict";
738
739  var arr = [];
740  var getProto = Object.getPrototypeOf;
741  var _slice = arr.slice;
742  var flat = arr.flat ? function (array) {
743    return arr.flat.call(array);
744  } : function (array) {
745    return arr.concat.apply([], array);
746  };
747  var push = arr.push;
748  var indexOf = arr.indexOf;
749  var class2type = {};
750  var toString = class2type.toString;
751  var hasOwn = class2type.hasOwnProperty;
752  var fnToString = hasOwn.toString;
753  var ObjectFunctionString = fnToString.call(Object);
754  var support = {};
755  var isFunction = function isFunction(obj) {
756    // Support: Chrome <=57, Firefox <=52
757    // In some browsers, typeof returns "function" for HTML <object> elements
758    // (i.e., `typeof document.createElement( "object" ) === "function"`).
759    // We don't want to classify *any* DOM node as a function.
760    // Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5
761    // Plus for old WebKit, typeof returns "function" for HTML collections
762    // (e.g., `typeof document.getElementsByTagName("div") === "function"`). (gh-4756)
763    return typeof obj === "function" && typeof obj.nodeType !== "number" && typeof obj.item !== "function";
764  };
765  var isWindow = function isWindow(obj) {
766    return obj != null && obj === obj.window;
767  };
768  var document = window.document;
769  var preservedScriptAttributes = {
770    type: true,
771    src: true,
772    nonce: true,
773    noModule: true
774  };
775  function DOMEval(code, node, doc) {
776    doc = doc || document;
777    var i,
778      val,
779      script = doc.createElement("script");
780    script.text = code;
781    if (node) {
782      for (i in preservedScriptAttributes) {
783        // Support: Firefox 64+, Edge 18+
784        // Some browsers don't support the "nonce" property on scripts.
785        // On the other hand, just using `getAttribute` is not enough as
786        // the `nonce` attribute is reset to an empty string whenever it
787        // becomes browsing-context connected.
788        // See https://github.com/whatwg/html/issues/2369
789        // See https://html.spec.whatwg.org/#nonce-attributes
790        // The `node.getAttribute` check was added for the sake of
791        // `jQuery.globalEval` so that it can fake a nonce-containing node
792        // via an object.
793        val = node[i] || node.getAttribute && node.getAttribute(i);
794        if (val) {
795          script.setAttribute(i, val);
796        }
797      }
798    }
799    doc.head.appendChild(script).parentNode.removeChild(script);
800  }
801  function toType(obj) {
802    if (obj == null) {
803      return obj + "";
804    }
805
806    // Support: Android <=2.3 only (functionish RegExp)
807    return _typeof(obj) === "object" || typeof obj === "function" ? class2type[toString.call(obj)] || "object" : _typeof(obj);
808  }
809  /* global Symbol */
810  // Defining this global in .eslintrc.json would create a danger of using the global
811  // unguarded in another place, it seems safer to define global only for this module
812
813  var version = "3.7.1",
814    rhtmlSuffix = /HTML$/i,
815    // Define a local copy of jQuery
816    _jQuery2 = function jQuery(selector, context) {
817      // The jQuery object is actually just the init constructor 'enhanced'
818      // Need init if jQuery is called (just allow error to be thrown if not included)
819      return new _jQuery2.fn.init(selector, context);
820    };
821  _jQuery2.fn = _jQuery2.prototype = {
822    // The current version of jQuery being used
823    jquery: version,
824    constructor: _jQuery2,
825    // The default length of a jQuery object is 0
826    length: 0,
827    toArray: function toArray() {
828      return _slice.call(this);
829    },
830    // Get the Nth element in the matched element set OR
831    // Get the whole matched element set as a clean array
832    get: function get(num) {
833      // Return all the elements in a clean array
834      if (num == null) {
835        return _slice.call(this);
836      }
837
838      // Return just the one element from the set
839      return num < 0 ? this[num + this.length] : this[num];
840    },
841    // Take an array of elements and push it onto the stack
842    // (returning the new matched element set)
843    pushStack: function pushStack(elems) {
844      // Build a new jQuery matched element set
845      var ret = _jQuery2.merge(this.constructor(), elems);
846
847      // Add the old object onto the stack (as a reference)
848      ret.prevObject = this;
849
850      // Return the newly-formed element set
851      return ret;
852    },
853    // Execute a callback for every element in the matched set.
854    each: function each(callback) {
855      return _jQuery2.each(this, callback);
856    },
857    map: function map(callback) {
858      return this.pushStack(_jQuery2.map(this, function (elem, i) {
859        return callback.call(elem, i, elem);
860      }));
861    },
862    slice: function slice() {
863      return this.pushStack(_slice.apply(this, arguments));
864    },
865    first: function first() {
866      return this.eq(0);
867    },
868    last: function last() {
869      return this.eq(-1);
870    },
871    even: function even() {
872      return this.pushStack(_jQuery2.grep(this, function (_elem, i) {
873        return (i + 1) % 2;
874      }));
875    },
876    odd: function odd() {
877      return this.pushStack(_jQuery2.grep(this, function (_elem, i) {
878        return i % 2;
879      }));
880    },
881    eq: function eq(i) {
882      var len = this.length,
883        j = +i + (i < 0 ? len : 0);
884      return this.pushStack(j >= 0 && j < len ? [this[j]] : []);
885    },
886    end: function end() {
887      return this.prevObject || this.constructor();
888    },
889    // For internal use only.
890    // Behaves like an Array's method, not like a jQuery method.
891    push: push,
892    sort: arr.sort,
893    splice: arr.splice
894  };
895  _jQuery2.extend = _jQuery2.fn.extend = function () {
896    var options,
897      name,
898      src,
899      copy,
900      copyIsArray,
901      clone,
902      target = arguments[0] || {},
903      i = 1,
904      length = arguments.length,
905      deep = false;
906
907    // Handle a deep copy situation
908    if (typeof target === "boolean") {
909      deep = target;
910
911      // Skip the boolean and the target
912      target = arguments[i] || {};
913      i++;
914    }
915
916    // Handle case when target is a string or something (possible in deep copy)
917    if (_typeof(target) !== "object" && !isFunction(target)) {
918      target = {};
919    }
920
921    // Extend jQuery itself if only one argument is passed
922    if (i === length) {
923      target = this;
924      i--;
925    }
926    for (; i < length; i++) {
927      // Only deal with non-null/undefined values
928      if ((options = arguments[i]) != null) {
929        // Extend the base object
930        for (name in options) {
931          copy = options[name];
932
933          // Prevent Object.prototype pollution
934          // Prevent never-ending loop
935          if (name === "__proto__" || target === copy) {
936            continue;
937          }
938
939          // Recurse if we're merging plain objects or arrays
940          if (deep && copy && (_jQuery2.isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {
941            src = target[name];
942
943            // Ensure proper type for the source value
944            if (copyIsArray && !Array.isArray(src)) {
945              clone = [];
946            } else if (!copyIsArray && !_jQuery2.isPlainObject(src)) {
947              clone = {};
948            } else {
949              clone = src;
950            }
951            copyIsArray = false;
952
953            // Never move original objects, clone them
954            target[name] = _jQuery2.extend(deep, clone, copy);
955
956            // Don't bring in undefined values
957          } else if (copy !== undefined) {
958            target[name] = copy;
959          }
960        }
961      }
962    }
963
964    // Return the modified object
965    return target;
966  };
967  _jQuery2.extend({
968    // Unique for each copy of jQuery on the page
969    expando: "jQuery" + (version + Math.random()).replace(/\D/g, ""),
970    // Assume jQuery is ready without the ready module
971    isReady: true,
972    error: function error(msg) {
973      throw new Error(msg);
974    },
975    noop: function noop() {},
976    isPlainObject: function isPlainObject(obj) {
977      var proto, Ctor;
978
979      // Detect obvious negatives
980      // Use toString instead of jQuery.type to catch host objects
981      if (!obj || toString.call(obj) !== "[object Object]") {
982        return false;
983      }
984      proto = getProto(obj);
985
986      // Objects with no prototype (e.g., `Object.create( null )`) are plain
987      if (!proto) {
988        return true;
989      }
990
991      // Objects with prototype are plain iff they were constructed by a global Object function
992      Ctor = hasOwn.call(proto, "constructor") && proto.constructor;
993      return typeof Ctor === "function" && fnToString.call(Ctor) === ObjectFunctionString;
994    },
995    isEmptyObject: function isEmptyObject(obj) {
996      var name;
997      for (name in obj) {
998        return false;
999      }
1000      return true;
1001    },
1002    // Evaluates a script in a provided context; falls back to the global one
1003    // if not specified.
1004    globalEval: function globalEval(code, options, doc) {
1005      DOMEval(code, {
1006        nonce: options && options.nonce
1007      }, doc);
1008    },
1009    each: function each(obj, callback) {
1010      var length,
1011        i = 0;
1012      if (isArrayLike(obj)) {
1013        length = obj.length;
1014        for (; i < length; i++) {
1015          if (callback.call(obj[i], i, obj[i]) === false) {
1016            break;
1017          }
1018        }
1019      } else {
1020        for (i in obj) {
1021          if (callback.call(obj[i], i, obj[i]) === false) {
1022            break;
1023          }
1024        }
1025      }
1026      return obj;
1027    },
1028    // Retrieve the text value of an array of DOM nodes
1029    text: function text(elem) {
1030      var node,
1031        ret = "",
1032        i = 0,
1033        nodeType = elem.nodeType;
1034      if (!nodeType) {
1035        // If no nodeType, this is expected to be an array
1036        while (node = elem[i++]) {
1037          // Do not traverse comment nodes
1038          ret += _jQuery2.text(node);
1039        }
1040      }
1041      if (nodeType === 1 || nodeType === 11) {
1042        return elem.textContent;
1043      }
1044      if (nodeType === 9) {
1045        return elem.documentElement.textContent;
1046      }
1047      if (nodeType === 3 || nodeType === 4) {
1048        return elem.nodeValue;
1049      }
1050
1051      // Do not include comment or processing instruction nodes
1052
1053      return ret;
1054    },
1055    // results is for internal usage only
1056    makeArray: function makeArray(arr, results) {
1057      var ret = results || [];
1058      if (arr != null) {
1059        if (isArrayLike(Object(arr))) {
1060          _jQuery2.merge(ret, typeof arr === "string" ? [arr] : arr);
1061        } else {
1062          push.call(ret, arr);
1063        }
1064      }
1065      return ret;
1066    },
1067    inArray: function inArray(elem, arr, i) {
1068      return arr == null ? -1 : indexOf.call(arr, elem, i);
1069    },
1070    isXMLDoc: function isXMLDoc(elem) {
1071      var namespace = elem && elem.namespaceURI,
1072        docElem = elem && (elem.ownerDocument || elem).documentElement;
1073
1074      // Assume HTML when documentElement doesn't yet exist, such as inside
1075      // document fragments.
1076      return !rhtmlSuffix.test(namespace || docElem && docElem.nodeName || "HTML");
1077    },
1078    // Support: Android <=4.0 only, PhantomJS 1 only
1079    // push.apply(_, arraylike) throws on ancient WebKit
1080    merge: function merge(first, second) {
1081      var len = +second.length,
1082        j = 0,
1083        i = first.length;
1084      for (; j < len; j++) {
1085        first[i++] = second[j];
1086      }
1087      first.length = i;
1088      return first;
1089    },
1090    grep: function grep(elems, callback, invert) {
1091      var callbackInverse,
1092        matches = [],
1093        i = 0,
1094        length = elems.length,
1095        callbackExpect = !invert;
1096
1097      // Go through the array, only saving the items
1098      // that pass the validator function
1099      for (; i < length; i++) {
1100        callbackInverse = !callback(elems[i], i);
1101        if (callbackInverse !== callbackExpect) {
1102          matches.push(elems[i]);
1103        }
1104      }
1105      return matches;
1106    },
1107    // arg is for internal usage only
1108    map: function map(elems, callback, arg) {
1109      var length,
1110        value,
1111        i = 0,
1112        ret = [];
1113
1114      // Go through the array, translating each of the items to their new values
1115      if (isArrayLike(elems)) {
1116        length = elems.length;
1117        for (; i < length; i++) {
1118          value = callback(elems[i], i, arg);
1119          if (value != null) {
1120            ret.push(value);
1121          }
1122        }
1123
1124        // Go through every key on the object,
1125      } else {
1126        for (i in elems) {
1127          value = callback(elems[i], i, arg);
1128          if (value != null) {
1129            ret.push(value);
1130          }
1131        }
1132      }
1133
1134      // Flatten any nested arrays
1135      return flat(ret);
1136    },
1137    // A global GUID counter for objects
1138    guid: 1,
1139    // jQuery.support is not used in Core but other projects attach their
1140    // properties to it so it needs to exist.
1141    support: support
1142  });
1143  if (typeof Symbol === "function") {
1144    _jQuery2.fn[Symbol.iterator] = arr[Symbol.iterator];
1145  }
1146
1147  // Populate the class2type map
1148  _jQuery2.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "), function (_i, name) {
1149    class2type["[object " + name + "]"] = name.toLowerCase();
1150  });
1151  function isArrayLike(obj) {
1152    // Support: real iOS 8.2 only (not reproducible in simulator)
1153    // `in` check used to prevent JIT error (gh-2145)
1154    // hasOwn isn't used here due to false negatives
1155    // regarding Nodelist length in IE
1156    var length = !!obj && "length" in obj && obj.length,
1157      type = toType(obj);
1158    if (isFunction(obj) || isWindow(obj)) {
1159      return false;
1160    }
1161    return type === "array" || length === 0 || typeof length === "number" && length > 0 && length - 1 in obj;
1162  }
1163  function nodeName(elem, name) {
1164    return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
1165  }
1166  var pop = arr.pop;
1167  var sort = arr.sort;
1168  var splice = arr.splice;
1169  var whitespace = "[\\x20\\t\\r\\n\\f]";
1170  var rtrimCSS = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g");
1171
1172  // Note: an element does not contain itself
1173  _jQuery2.contains = function (a, b) {
1174    var bup = b && b.parentNode;
1175    return a === bup || !!(bup && bup.nodeType === 1 && (
1176    // Support: IE 9 - 11+
1177    // IE doesn't have `contains` on SVG.
1178    a.contains ? a.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16));
1179  };
1180
1181  // CSS string/identifier serialization
1182  // https://drafts.csswg.org/cssom/#common-serializing-idioms
1183  var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g;
1184  function fcssescape(ch, asCodePoint) {
1185    if (asCodePoint) {
1186      // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
1187      if (ch === "\0") {
1188        return "\uFFFD";
1189      }
1190
1191      // Control characters and (dependent upon position) numbers get escaped as code points
1192      return ch.slice(0, -1) + "\\" + ch.charCodeAt(ch.length - 1).toString(16) + " ";
1193    }
1194
1195    // Other potentially-special ASCII characters get backslash-escaped
1196    return "\\" + ch;
1197  }
1198  _jQuery2.escapeSelector = function (sel) {
1199    return (sel + "").replace(rcssescape, fcssescape);
1200  };
1201  var preferredDoc = document,
1202    pushNative = push;
1203  (function () {
1204    var i,
1205      Expr,
1206      outermostContext,
1207      sortInput,
1208      hasDuplicate,
1209      push = pushNative,
1210      // Local document vars
1211      document,
1212      documentElement,
1213      documentIsHTML,
1214      rbuggyQSA,
1215      matches,
1216      // Instance-specific data
1217      expando = _jQuery2.expando,
1218      dirruns = 0,
1219      done = 0,
1220      classCache = createCache(),
1221      tokenCache = createCache(),
1222      compilerCache = createCache(),
1223      nonnativeSelectorCache = createCache(),
1224      sortOrder = function sortOrder(a, b) {
1225        if (a === b) {
1226          hasDuplicate = true;
1227        }
1228        return 0;
1229      },
1230      booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|" + "loop|multiple|open|readonly|required|scoped",
1231      // Regular expressions
1232
1233      // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
1234      identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
1235      // Attribute selectors: https://www.w3.org/TR/selectors/#attribute-selectors
1236      attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
1237      // Operator (capture 2)
1238      "*([*^$|!~]?=)" + whitespace +
1239      // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
1240      "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + "*\\]",
1241      pseudos = ":(" + identifier + ")(?:\\((" +
1242      // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
1243      // 1. quoted (capture 3; capture 4 or capture 5)
1244      "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
1245      // 2. simple (capture 6)
1246      "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
1247      // 3. anything else (capture 2)
1248      ".*" + ")\\)|)",
1249      // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
1250      rwhitespace = new RegExp(whitespace + "+", "g"),
1251      rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"),
1252      rleadingCombinator = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"),
1253      rdescend = new RegExp(whitespace + "|>"),
1254      rpseudo = new RegExp(pseudos),
1255      ridentifier = new RegExp("^" + identifier + "$"),
1256      matchExpr = {
1257        ID: new RegExp("^#(" + identifier + ")"),
1258        CLASS: new RegExp("^\\.(" + identifier + ")"),
1259        TAG: new RegExp("^(" + identifier + "|[*])"),
1260        ATTR: new RegExp("^" + attributes),
1261        PSEUDO: new RegExp("^" + pseudos),
1262        CHILD: new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i"),
1263        bool: new RegExp("^(?:" + booleans + ")$", "i"),
1264        // For use in libraries implementing .is()
1265        // We use this for POS matching in `select`
1266        needsContext: new RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i")
1267      },
1268      rinputs = /^(?:input|select|textarea|button)$/i,
1269      rheader = /^h\d$/i,
1270      // Easily-parseable/retrievable ID or TAG or CLASS selectors
1271      rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
1272      rsibling = /[+~]/,
1273      // CSS escapes
1274      // https://www.w3.org/TR/CSS21/syndata.html#escaped-characters
1275      runescape = new RegExp("\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g"),
1276      funescape = function funescape(escape, nonHex) {
1277        var high = "0x" + escape.slice(1) - 0x10000;
1278        if (nonHex) {
1279          // Strip the backslash prefix from a non-hex escape sequence
1280          return nonHex;
1281        }
1282
1283        // Replace a hexadecimal escape sequence with the encoded Unicode code point
1284        // Support: IE <=11+
1285        // For values outside the Basic Multilingual Plane (BMP), manually construct a
1286        // surrogate pair
1287        return high < 0 ? String.fromCharCode(high + 0x10000) : String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00);
1288      },
1289      // Used for iframes; see `setDocument`.
1290      // Support: IE 9 - 11+, Edge 12 - 18+
1291      // Removing the function wrapper causes a "Permission Denied"
1292      // error in IE/Edge.
1293      unloadHandler = function unloadHandler() {
1294        setDocument();
1295      },
1296      inDisabledFieldset = addCombinator(function (elem) {
1297        return elem.disabled === true && nodeName(elem, "fieldset");
1298      }, {
1299        dir: "parentNode",
1300        next: "legend"
1301      });
1302
1303    // Support: IE <=9 only
1304    // Accessing document.activeElement can throw unexpectedly
1305    // https://bugs.jquery.com/ticket/13393
1306    function safeActiveElement() {
1307      try {
1308        return document.activeElement;
1309      } catch (err) {}
1310    }
1311
1312    // Optimize for push.apply( _, NodeList )
1313    try {
1314      push.apply(arr = _slice.call(preferredDoc.childNodes), preferredDoc.childNodes);
1315
1316      // Support: Android <=4.0
1317      // Detect silently failing push.apply
1318      // eslint-disable-next-line no-unused-expressions
1319      arr[preferredDoc.childNodes.length].nodeType;
1320    } catch (e) {
1321      push = {
1322        apply: function apply(target, els) {
1323          pushNative.apply(target, _slice.call(els));
1324        },
1325        call: function call(target) {
1326          pushNative.apply(target, _slice.call(arguments, 1));
1327        }
1328      };
1329    }
1330    function find(selector, context, results, seed) {
1331      var m,
1332        i,
1333        elem,
1334        nid,
1335        match,
1336        groups,
1337        newSelector,
1338        newContext = context && context.ownerDocument,
1339        // nodeType defaults to 9, since context defaults to document
1340        nodeType = context ? context.nodeType : 9;
1341      results = results || [];
1342
1343      // Return early from calls with invalid selector or context
1344      if (typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11) {
1345        return results;
1346      }
1347
1348      // Try to shortcut find operations (as opposed to filters) in HTML documents
1349      if (!seed) {
1350        setDocument(context);
1351        context = context || document;
1352        if (documentIsHTML) {
1353          // If the selector is sufficiently simple, try using a "get*By*" DOM method
1354          // (excepting DocumentFragment context, where the methods don't exist)
1355          if (nodeType !== 11 && (match = rquickExpr.exec(selector))) {
1356            // ID selector
1357            if (m = match[1]) {
1358              // Document context
1359              if (nodeType === 9) {
1360                if (elem = context.getElementById(m)) {
1361                  // Support: IE 9 only
1362                  // getElementById can match elements by name instead of ID
1363                  if (elem.id === m) {
1364                    push.call(results, elem);
1365                    return results;
1366                  }
1367                } else {
1368                  return results;
1369                }
1370
1371                // Element context
1372              } else {
1373                // Support: IE 9 only
1374                // getElementById can match elements by name instead of ID
1375                if (newContext && (elem = newContext.getElementById(m)) && find.contains(context, elem) && elem.id === m) {
1376                  push.call(results, elem);
1377                  return results;
1378                }
1379              }
1380
1381              // Type selector
1382            } else if (match[2]) {
1383              push.apply(results, context.getElementsByTagName(selector));
1384              return results;
1385
1386              // Class selector
1387            } else if ((m = match[3]) && context.getElementsByClassName) {
1388              push.apply(results, context.getElementsByClassName(m));
1389              return results;
1390            }
1391          }
1392
1393          // Take advantage of querySelectorAll
1394          if (!nonnativeSelectorCache[selector + " "] && (!rbuggyQSA || !rbuggyQSA.test(selector))) {
1395            newSelector = selector;
1396            newContext = context;
1397
1398            // qSA considers elements outside a scoping root when evaluating child or
1399            // descendant combinators, which is not what we want.
1400            // In such cases, we work around the behavior by prefixing every selector in the
1401            // list with an ID selector referencing the scope context.
1402            // The technique has to be used as well when a leading combinator is used
1403            // as such selectors are not recognized by querySelectorAll.
1404            // Thanks to Andrew Dupont for this technique.
1405            if (nodeType === 1 && (rdescend.test(selector) || rleadingCombinator.test(selector))) {
1406              // Expand context for sibling selectors
1407              newContext = rsibling.test(selector) && testContext(context.parentNode) || context;
1408
1409              // We can use :scope instead of the ID hack if the browser
1410              // supports it & if we're not changing the context.
1411              // Support: IE 11+, Edge 17 - 18+
1412              // IE/Edge sometimes throw a "Permission denied" error when
1413              // strict-comparing two documents; shallow comparisons work.
1414              // eslint-disable-next-line eqeqeq
1415              if (newContext != context || !support.scope) {
1416                // Capture the context ID, setting it first if necessary
1417                if (nid = context.getAttribute("id")) {
1418                  nid = _jQuery2.escapeSelector(nid);
1419                } else {
1420                  context.setAttribute("id", nid = expando);
1421                }
1422              }
1423
1424              // Prefix every selector in the list
1425              groups = tokenize(selector);
1426              i = groups.length;
1427              while (i--) {
1428                groups[i] = (nid ? "#" + nid : ":scope") + " " + toSelector(groups[i]);
1429              }
1430              newSelector = groups.join(",");
1431            }
1432            try {
1433              push.apply(results, newContext.querySelectorAll(newSelector));
1434              return results;
1435            } catch (qsaError) {
1436              nonnativeSelectorCache(selector, true);
1437            } finally {
1438              if (nid === expando) {
1439                context.removeAttribute("id");
1440              }
1441            }
1442          }
1443        }
1444      }
1445
1446      // All others
1447      return select(selector.replace(rtrimCSS, "$1"), context, results, seed);
1448    }
1449
1450    /**
1451     * Create key-value caches of limited size
1452     * @returns {function(string, object)} Returns the Object data after storing it on itself with
1453     *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
1454     *	deleting the oldest entry
1455     */
1456    function createCache() {
1457      var keys = [];
1458      function cache(key, value) {
1459        // Use (key + " ") to avoid collision with native prototype properties
1460        // (see https://github.com/jquery/sizzle/issues/157)
1461        if (keys.push(key + " ") > Expr.cacheLength) {
1462          // Only keep the most recent entries
1463          delete cache[keys.shift()];
1464        }
1465        return cache[key + " "] = value;
1466      }
1467      return cache;
1468    }
1469
1470    /**
1471     * Mark a function for special use by jQuery selector module
1472     * @param {Function} fn The function to mark
1473     */
1474    function markFunction(fn) {
1475      fn[expando] = true;
1476      return fn;
1477    }
1478
1479    /**
1480     * Support testing using an element
1481     * @param {Function} fn Passed the created element and returns a boolean result
1482     */
1483    function assert(fn) {
1484      var el = document.createElement("fieldset");
1485      try {
1486        return !!fn(el);
1487      } catch (e) {
1488        return false;
1489      } finally {
1490        // Remove from its parent by default
1491        if (el.parentNode) {
1492          el.parentNode.removeChild(el);
1493        }
1494
1495        // release memory in IE
1496        el = null;
1497      }
1498    }
1499
1500    /**
1501     * Returns a function to use in pseudos for input types
1502     * @param {String} type
1503     */
1504    function createInputPseudo(type) {
1505      return function (elem) {
1506        return nodeName(elem, "input") && elem.type === type;
1507      };
1508    }
1509
1510    /**
1511     * Returns a function to use in pseudos for buttons
1512     * @param {String} type
1513     */
1514    function createButtonPseudo(type) {
1515      return function (elem) {
1516        return (nodeName(elem, "input") || nodeName(elem, "button")) && elem.type === type;
1517      };
1518    }
1519
1520    /**
1521     * Returns a function to use in pseudos for :enabled/:disabled
1522     * @param {Boolean} disabled true for :disabled; false for :enabled
1523     */
1524    function createDisabledPseudo(disabled) {
1525      // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
1526      return function (elem) {
1527        // Only certain elements can match :enabled or :disabled
1528        // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
1529        // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
1530        if ("form" in elem) {
1531          // Check for inherited disabledness on relevant non-disabled elements:
1532          // * listed form-associated elements in a disabled fieldset
1533          //   https://html.spec.whatwg.org/multipage/forms.html#category-listed
1534          //   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
1535          // * option elements in a disabled optgroup
1536          //   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
1537          // All such elements have a "form" property.
1538          if (elem.parentNode && elem.disabled === false) {
1539            // Option elements defer to a parent optgroup if present
1540            if ("label" in elem) {
1541              if ("label" in elem.parentNode) {
1542                return elem.parentNode.disabled === disabled;
1543              } else {
1544                return elem.disabled === disabled;
1545              }
1546            }
1547
1548            // Support: IE 6 - 11+
1549            // Use the isDisabled shortcut property to check for disabled fieldset ancestors
1550            return elem.isDisabled === disabled ||
1551            // Where there is no isDisabled, check manually
1552            elem.isDisabled !== !disabled && inDisabledFieldset(elem) === disabled;
1553          }
1554          return elem.disabled === disabled;
1555
1556          // Try to winnow out elements that can't be disabled before trusting the disabled property.
1557          // Some victims get caught in our net (label, legend, menu, track), but it shouldn't
1558          // even exist on them, let alone have a boolean value.
1559        } else if ("label" in elem) {
1560          return elem.disabled === disabled;
1561        }
1562
1563        // Remaining elements are neither :enabled nor :disabled
1564        return false;
1565      };
1566    }
1567
1568    /**
1569     * Returns a function to use in pseudos for positionals
1570     * @param {Function} fn
1571     */
1572    function createPositionalPseudo(fn) {
1573      return markFunction(function (argument) {
1574        argument = +argument;
1575        return markFunction(function (seed, matches) {
1576          var j,
1577            matchIndexes = fn([], seed.length, argument),
1578            i = matchIndexes.length;
1579
1580          // Match elements found at the specified indexes
1581          while (i--) {
1582            if (seed[j = matchIndexes[i]]) {
1583              seed[j] = !(matches[j] = seed[j]);
1584            }
1585          }
1586        });
1587      });
1588    }
1589
1590    /**
1591     * Checks a node for validity as a jQuery selector context
1592     * @param {Element|Object=} context
1593     * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1594     */
1595    function testContext(context) {
1596      return context && typeof context.getElementsByTagName !== "undefined" && context;
1597    }
1598
1599    /**
1600     * Sets document-related variables once based on the current document
1601     * @param {Element|Object} [node] An element or document object to use to set the document
1602     * @returns {Object} Returns the current document
1603     */
1604    function setDocument(node) {
1605      var subWindow,
1606        doc = node ? node.ownerDocument || node : preferredDoc;
1607
1608      // Return early if doc is invalid or already selected
1609      // Support: IE 11+, Edge 17 - 18+
1610      // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1611      // two documents; shallow comparisons work.
1612      // eslint-disable-next-line eqeqeq
1613      if (doc == document || doc.nodeType !== 9 || !doc.documentElement) {
1614        return document;
1615      }
1616
1617      // Update global variables
1618      document = doc;
1619      documentElement = document.documentElement;
1620      documentIsHTML = !_jQuery2.isXMLDoc(document);
1621
1622      // Support: iOS 7 only, IE 9 - 11+
1623      // Older browsers didn't support unprefixed `matches`.
1624      matches = documentElement.matches || documentElement.webkitMatchesSelector || documentElement.msMatchesSelector;
1625
1626      // Support: IE 9 - 11+, Edge 12 - 18+
1627      // Accessing iframe documents after unload throws "permission denied" errors
1628      // (see trac-13936).
1629      // Limit the fix to IE & Edge Legacy; despite Edge 15+ implementing `matches`,
1630      // all IE 9+ and Edge Legacy versions implement `msMatchesSelector` as well.
1631      if (documentElement.msMatchesSelector &&
1632      // Support: IE 11+, Edge 17 - 18+
1633      // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1634      // two documents; shallow comparisons work.
1635      // eslint-disable-next-line eqeqeq
1636      preferredDoc != document && (subWindow = document.defaultView) && subWindow.top !== subWindow) {
1637        // Support: IE 9 - 11+, Edge 12 - 18+
1638        subWindow.addEventListener("unload", unloadHandler);
1639      }
1640
1641      // Support: IE <10
1642      // Check if getElementById returns elements by name
1643      // The broken getElementById methods don't pick up programmatically-set names,
1644      // so use a roundabout getElementsByName test
1645      support.getById = assert(function (el) {
1646        documentElement.appendChild(el).id = _jQuery2.expando;
1647        return !document.getElementsByName || !document.getElementsByName(_jQuery2.expando).length;
1648      });
1649
1650      // Support: IE 9 only
1651      // Check to see if it's possible to do matchesSelector
1652      // on a disconnected node.
1653      support.disconnectedMatch = assert(function (el) {
1654        return matches.call(el, "*");
1655      });
1656
1657      // Support: IE 9 - 11+, Edge 12 - 18+
1658      // IE/Edge don't support the :scope pseudo-class.
1659      support.scope = assert(function () {
1660        return document.querySelectorAll(":scope");
1661      });
1662
1663      // Support: Chrome 105 - 111 only, Safari 15.4 - 16.3 only
1664      // Make sure the `:has()` argument is parsed unforgivingly.
1665      // We include `*` in the test to detect buggy implementations that are
1666      // _selectively_ forgiving (specifically when the list includes at least
1667      // one valid selector).
1668      // Note that we treat complete lack of support for `:has()` as if it were
1669      // spec-compliant support, which is fine because use of `:has()` in such
1670      // environments will fail in the qSA path and fall back to jQuery traversal
1671      // anyway.
1672      support.cssHas = assert(function () {
1673        try {
1674          document.querySelector(":has(*,:jqfake)");
1675          return false;
1676        } catch (e) {
1677          return true;
1678        }
1679      });
1680
1681      // ID filter and find
1682      if (support.getById) {
1683        Expr.filter.ID = function (id) {
1684          var attrId = id.replace(runescape, funescape);
1685          return function (elem) {
1686            return elem.getAttribute("id") === attrId;
1687          };
1688        };
1689        Expr.find.ID = function (id, context) {
1690          if (typeof context.getElementById !== "undefined" && documentIsHTML) {
1691            var elem = context.getElementById(id);
1692            return elem ? [elem] : [];
1693          }
1694        };
1695      } else {
1696        Expr.filter.ID = function (id) {
1697          var attrId = id.replace(runescape, funescape);
1698          return function (elem) {
1699            var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
1700            return node && node.value === attrId;
1701          };
1702        };
1703
1704        // Support: IE 6 - 7 only
1705        // getElementById is not reliable as a find shortcut
1706        Expr.find.ID = function (id, context) {
1707          if (typeof context.getElementById !== "undefined" && documentIsHTML) {
1708            var node,
1709              i,
1710              elems,
1711              elem = context.getElementById(id);
1712            if (elem) {
1713              // Verify the id attribute
1714              node = elem.getAttributeNode("id");
1715              if (node && node.value === id) {
1716                return [elem];
1717              }
1718
1719              // Fall back on getElementsByName
1720              elems = context.getElementsByName(id);
1721              i = 0;
1722              while (elem = elems[i++]) {
1723                node = elem.getAttributeNode("id");
1724                if (node && node.value === id) {
1725                  return [elem];
1726                }
1727              }
1728            }
1729            return [];
1730          }
1731        };
1732      }
1733
1734      // Tag
1735      Expr.find.TAG = function (tag, context) {
1736        if (typeof context.getElementsByTagName !== "undefined") {
1737          return context.getElementsByTagName(tag);
1738
1739          // DocumentFragment nodes don't have gEBTN
1740        } else {
1741          return context.querySelectorAll(tag);
1742        }
1743      };
1744
1745      // Class
1746      Expr.find.CLASS = function (className, context) {
1747        if (typeof context.getElementsByClassName !== "undefined" && documentIsHTML) {
1748          return context.getElementsByClassName(className);
1749        }
1750      };
1751
1752      /* QSA/matchesSelector
1753      ---------------------------------------------------------------------- */
1754
1755      // QSA and matchesSelector support
1756
1757      rbuggyQSA = [];
1758
1759      // Build QSA regex
1760      // Regex strategy adopted from Diego Perini
1761      assert(function (el) {
1762        var input;
1763        documentElement.appendChild(el).innerHTML = "<a id='" + expando + "' href='' disabled='disabled'></a>" + "<select id='" + expando + "-\r\\' disabled='disabled'>" + "<option selected=''></option></select>";
1764
1765        // Support: iOS <=7 - 8 only
1766        // Boolean attributes and "value" are not treated correctly in some XML documents
1767        if (!el.querySelectorAll("[selected]").length) {
1768          rbuggyQSA.push("\\[" + whitespace + "*(?:value|" + booleans + ")");
1769        }
1770
1771        // Support: iOS <=7 - 8 only
1772        if (!el.querySelectorAll("[id~=" + expando + "-]").length) {
1773          rbuggyQSA.push("~=");
1774        }
1775
1776        // Support: iOS 8 only
1777        // https://bugs.webkit.org/show_bug.cgi?id=136851
1778        // In-page `selector#id sibling-combinator selector` fails
1779        if (!el.querySelectorAll("a#" + expando + "+*").length) {
1780          rbuggyQSA.push(".#.+[+~]");
1781        }
1782
1783        // Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+
1784        // In some of the document kinds, these selectors wouldn't work natively.
1785        // This is probably OK but for backwards compatibility we want to maintain
1786        // handling them through jQuery traversal in jQuery 3.x.
1787        if (!el.querySelectorAll(":checked").length) {
1788          rbuggyQSA.push(":checked");
1789        }
1790
1791        // Support: Windows 8 Native Apps
1792        // The type and name attributes are restricted during .innerHTML assignment
1793        input = document.createElement("input");
1794        input.setAttribute("type", "hidden");
1795        el.appendChild(input).setAttribute("name", "D");
1796
1797        // Support: IE 9 - 11+
1798        // IE's :disabled selector does not pick up the children of disabled fieldsets
1799        // Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+
1800        // In some of the document kinds, these selectors wouldn't work natively.
1801        // This is probably OK but for backwards compatibility we want to maintain
1802        // handling them through jQuery traversal in jQuery 3.x.
1803        documentElement.appendChild(el).disabled = true;
1804        if (el.querySelectorAll(":disabled").length !== 2) {
1805          rbuggyQSA.push(":enabled", ":disabled");
1806        }
1807
1808        // Support: IE 11+, Edge 15 - 18+
1809        // IE 11/Edge don't find elements on a `[name='']` query in some cases.
1810        // Adding a temporary attribute to the document before the selection works
1811        // around the issue.
1812        // Interestingly, IE 10 & older don't seem to have the issue.
1813        input = document.createElement("input");
1814        input.setAttribute("name", "");
1815        el.appendChild(input);
1816        if (!el.querySelectorAll("[name='']").length) {
1817          rbuggyQSA.push("\\[" + whitespace + "*name" + whitespace + "*=" + whitespace + "*(?:''|\"\")");
1818        }
1819      });
1820      if (!support.cssHas) {
1821        // Support: Chrome 105 - 110+, Safari 15.4 - 16.3+
1822        // Our regular `try-catch` mechanism fails to detect natively-unsupported
1823        // pseudo-classes inside `:has()` (such as `:has(:contains("Foo"))`)
1824        // in browsers that parse the `:has()` argument as a forgiving selector list.
1825        // https://drafts.csswg.org/selectors/#relational now requires the argument
1826        // to be parsed unforgivingly, but browsers have not yet fully adjusted.
1827        rbuggyQSA.push(":has");
1828      }
1829      rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|"));
1830
1831      /* Sorting
1832      ---------------------------------------------------------------------- */
1833
1834      // Document order sorting
1835      sortOrder = function sortOrder(a, b) {
1836        // Flag for duplicate removal
1837        if (a === b) {
1838          hasDuplicate = true;
1839          return 0;
1840        }
1841
1842        // Sort on method existence if only one input has compareDocumentPosition
1843        var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1844        if (compare) {
1845          return compare;
1846        }
1847
1848        // Calculate position if both inputs belong to the same document
1849        // Support: IE 11+, Edge 17 - 18+
1850        // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1851        // two documents; shallow comparisons work.
1852        // eslint-disable-next-line eqeqeq
1853        compare = (a.ownerDocument || a) == (b.ownerDocument || b) ? a.compareDocumentPosition(b) :
1854        // Otherwise we know they are disconnected
1855        1;
1856
1857        // Disconnected nodes
1858        if (compare & 1 || !support.sortDetached && b.compareDocumentPosition(a) === compare) {
1859          // Choose the first element that is related to our preferred document
1860          // Support: IE 11+, Edge 17 - 18+
1861          // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1862          // two documents; shallow comparisons work.
1863          // eslint-disable-next-line eqeqeq
1864          if (a === document || a.ownerDocument == preferredDoc && find.contains(preferredDoc, a)) {
1865            return -1;
1866          }
1867
1868          // Support: IE 11+, Edge 17 - 18+
1869          // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1870          // two documents; shallow comparisons work.
1871          // eslint-disable-next-line eqeqeq
1872          if (b === document || b.ownerDocument == preferredDoc && find.contains(preferredDoc, b)) {
1873            return 1;
1874          }
1875
1876          // Maintain original order
1877          return sortInput ? indexOf.call(sortInput, a) - indexOf.call(sortInput, b) : 0;
1878        }
1879        return compare & 4 ? -1 : 1;
1880      };
1881      return document;
1882    }
1883    find.matches = function (expr, elements) {
1884      return find(expr, null, null, elements);
1885    };
1886    find.matchesSelector = function (elem, expr) {
1887      setDocument(elem);
1888      if (documentIsHTML && !nonnativeSelectorCache[expr + " "] && (!rbuggyQSA || !rbuggyQSA.test(expr))) {
1889        try {
1890          var ret = matches.call(elem, expr);
1891
1892          // IE 9's matchesSelector returns false on disconnected nodes
1893          if (ret || support.disconnectedMatch ||
1894          // As well, disconnected nodes are said to be in a document
1895          // fragment in IE 9
1896          elem.document && elem.document.nodeType !== 11) {
1897            return ret;
1898          }
1899        } catch (e) {
1900          nonnativeSelectorCache(expr, true);
1901        }
1902      }
1903      return find(expr, document, null, [elem]).length > 0;
1904    };
1905    find.contains = function (context, elem) {
1906      // Set document vars if needed
1907      // Support: IE 11+, Edge 17 - 18+
1908      // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1909      // two documents; shallow comparisons work.
1910      // eslint-disable-next-line eqeqeq
1911      if ((context.ownerDocument || context) != document) {
1912        setDocument(context);
1913      }
1914      return _jQuery2.contains(context, elem);
1915    };
1916    find.attr = function (elem, name) {
1917      // Set document vars if needed
1918      // Support: IE 11+, Edge 17 - 18+
1919      // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1920      // two documents; shallow comparisons work.
1921      // eslint-disable-next-line eqeqeq
1922      if ((elem.ownerDocument || elem) != document) {
1923        setDocument(elem);
1924      }
1925      var fn = Expr.attrHandle[name.toLowerCase()],
1926        // Don't get fooled by Object.prototype properties (see trac-13807)
1927        val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : undefined;
1928      if (val !== undefined) {
1929        return val;
1930      }
1931      return elem.getAttribute(name);
1932    };
1933    find.error = function (msg) {
1934      throw new Error("Syntax error, unrecognized expression: " + msg);
1935    };
1936
1937    /**
1938     * Document sorting and removing duplicates
1939     * @param {ArrayLike} results
1940     */
1941    _jQuery2.uniqueSort = function (results) {
1942      var elem,
1943        duplicates = [],
1944        j = 0,
1945        i = 0;
1946
1947      // Unless we *know* we can detect duplicates, assume their presence
1948      //
1949      // Support: Android <=4.0+
1950      // Testing for detecting duplicates is unpredictable so instead assume we can't
1951      // depend on duplicate detection in all browsers without a stable sort.
1952      hasDuplicate = !support.sortStable;
1953      sortInput = !support.sortStable && _slice.call(results, 0);
1954      sort.call(results, sortOrder);
1955      if (hasDuplicate) {
1956        while (elem = results[i++]) {
1957          if (elem === results[i]) {
1958            j = duplicates.push(i);
1959          }
1960        }
1961        while (j--) {
1962          splice.call(results, duplicates[j], 1);
1963        }
1964      }
1965
1966      // Clear input after sorting to release objects
1967      // See https://github.com/jquery/sizzle/pull/225
1968      sortInput = null;
1969      return results;
1970    };
1971    _jQuery2.fn.uniqueSort = function () {
1972      return this.pushStack(_jQuery2.uniqueSort(_slice.apply(this)));
1973    };
1974    Expr = _jQuery2.expr = {
1975      // Can be adjusted by the user
1976      cacheLength: 50,
1977      createPseudo: markFunction,
1978      match: matchExpr,
1979      attrHandle: {},
1980      find: {},
1981      relative: {
1982        ">": {
1983          dir: "parentNode",
1984          first: true
1985        },
1986        " ": {
1987          dir: "parentNode"
1988        },
1989        "+": {
1990          dir: "previousSibling",
1991          first: true
1992        },
1993        "~": {
1994          dir: "previousSibling"
1995        }
1996      },
1997      preFilter: {
1998        ATTR: function ATTR(match) {
1999          match[1] = match[1].replace(runescape, funescape);
2000
2001          // Move the given value to match[3] whether quoted or unquoted
2002          match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape);
2003          if (match[2] === "~=") {
2004            match[3] = " " + match[3] + " ";
2005          }
2006          return match.slice(0, 4);
2007        },
2008        CHILD: function CHILD(match) {
2009          /* matches from matchExpr["CHILD"]
2010          	1 type (only|nth|...)
2011          	2 what (child|of-type)
2012          	3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
2013          	4 xn-component of xn+y argument ([+-]?\d*n|)
2014          	5 sign of xn-component
2015          	6 x of xn-component
2016          	7 sign of y-component
2017          	8 y of y-component
2018          */
2019          match[1] = match[1].toLowerCase();
2020          if (match[1].slice(0, 3) === "nth") {
2021            // nth-* requires argument
2022            if (!match[3]) {
2023              find.error(match[0]);
2024            }
2025
2026            // numeric x and y parameters for Expr.filter.CHILD
2027            // remember that false/true cast respectively to 0/1
2028            match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === "even" || match[3] === "odd"));
2029            match[5] = +(match[7] + match[8] || match[3] === "odd");
2030
2031            // other types prohibit arguments
2032          } else if (match[3]) {
2033            find.error(match[0]);
2034          }
2035          return match;
2036        },
2037        PSEUDO: function PSEUDO(match) {
2038          var excess,
2039            unquoted = !match[6] && match[2];
2040          if (matchExpr.CHILD.test(match[0])) {
2041            return null;
2042          }
2043
2044          // Accept quoted arguments as-is
2045          if (match[3]) {
2046            match[2] = match[4] || match[5] || "";
2047
2048            // Strip excess characters from unquoted arguments
2049          } else if (unquoted && rpseudo.test(unquoted) && (
2050          // Get excess from tokenize (recursively)
2051          excess = tokenize(unquoted, true)) && (
2052          // advance to the next closing parenthesis
2053          excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) {
2054            // excess is a negative index
2055            match[0] = match[0].slice(0, excess);
2056            match[2] = unquoted.slice(0, excess);
2057          }
2058
2059          // Return only captures needed by the pseudo filter method (type and argument)
2060          return match.slice(0, 3);
2061        }
2062      },
2063      filter: {
2064        TAG: function TAG(nodeNameSelector) {
2065          var expectedNodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();
2066          return nodeNameSelector === "*" ? function () {
2067            return true;
2068          } : function (elem) {
2069            return nodeName(elem, expectedNodeName);
2070          };
2071        },
2072        CLASS: function CLASS(className) {
2073          var pattern = classCache[className + " "];
2074          return pattern || (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)")) && classCache(className, function (elem) {
2075            return pattern.test(typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "");
2076          });
2077        },
2078        ATTR: function ATTR(name, operator, check) {
2079          return function (elem) {
2080            var result = find.attr(elem, name);
2081            if (result == null) {
2082              return operator === "!=";
2083            }
2084            if (!operator) {
2085              return true;
2086            }
2087            result += "";
2088            if (operator === "=") {
2089              return result === check;
2090            }
2091            if (operator === "!=") {
2092              return result !== check;
2093            }
2094            if (operator === "^=") {
2095              return check && result.indexOf(check) === 0;
2096            }
2097            if (operator === "*=") {
2098              return check && result.indexOf(check) > -1;
2099            }
2100            if (operator === "$=") {
2101              return check && result.slice(-check.length) === check;
2102            }
2103            if (operator === "~=") {
2104              return (" " + result.replace(rwhitespace, " ") + " ").indexOf(check) > -1;
2105            }
2106            if (operator === "|=") {
2107              return result === check || result.slice(0, check.length + 1) === check + "-";
2108            }
2109            return false;
2110          };
2111        },
2112        CHILD: function CHILD(type, what, _argument, first, last) {
2113          var simple = type.slice(0, 3) !== "nth",
2114            forward = type.slice(-4) !== "last",
2115            ofType = what === "of-type";
2116          return first === 1 && last === 0 ?
2117          // Shortcut for :nth-*(n)
2118          function (elem) {
2119            return !!elem.parentNode;
2120          } : function (elem, _context, xml) {
2121            var cache,
2122              outerCache,
2123              node,
2124              nodeIndex,
2125              start,
2126              dir = simple !== forward ? "nextSibling" : "previousSibling",
2127              parent = elem.parentNode,
2128              name = ofType && elem.nodeName.toLowerCase(),
2129              useCache = !xml && !ofType,
2130              diff = false;
2131            if (parent) {
2132              // :(first|last|only)-(child|of-type)
2133              if (simple) {
2134                while (dir) {
2135                  node = elem;
2136                  while (node = node[dir]) {
2137                    if (ofType ? nodeName(node, name) : node.nodeType === 1) {
2138                      return false;
2139                    }
2140                  }
2141
2142                  // Reverse direction for :only-* (if we haven't yet done so)
2143                  start = dir = type === "only" && !start && "nextSibling";
2144                }
2145                return true;
2146              }
2147              start = [forward ? parent.firstChild : parent.lastChild];
2148
2149              // non-xml :nth-child(...) stores cache data on `parent`
2150              if (forward && useCache) {
2151                // Seek `elem` from a previously-cached index
2152                outerCache = parent[expando] || (parent[expando] = {});
2153                cache = outerCache[type] || [];
2154                nodeIndex = cache[0] === dirruns && cache[1];
2155                diff = nodeIndex && cache[2];
2156                node = nodeIndex && parent.childNodes[nodeIndex];
2157                while (node = ++nodeIndex && node && node[dir] || (
2158                // Fallback to seeking `elem` from the start
2159                diff = nodeIndex = 0) || start.pop()) {
2160                  // When found, cache indexes on `parent` and break
2161                  if (node.nodeType === 1 && ++diff && node === elem) {
2162                    outerCache[type] = [dirruns, nodeIndex, diff];
2163                    break;
2164                  }
2165                }
2166              } else {
2167                // Use previously-cached element index if available
2168                if (useCache) {
2169                  outerCache = elem[expando] || (elem[expando] = {});
2170                  cache = outerCache[type] || [];
2171                  nodeIndex = cache[0] === dirruns && cache[1];
2172                  diff = nodeIndex;
2173                }
2174
2175                // xml :nth-child(...)
2176                // or :nth-last-child(...) or :nth(-last)?-of-type(...)
2177                if (diff === false) {
2178                  // Use the same loop as above to seek `elem` from the start
2179                  while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) {
2180                    if ((ofType ? nodeName(node, name) : node.nodeType === 1) && ++diff) {
2181                      // Cache the index of each encountered element
2182                      if (useCache) {
2183                        outerCache = node[expando] || (node[expando] = {});
2184                        outerCache[type] = [dirruns, diff];
2185                      }
2186                      if (node === elem) {
2187                        break;
2188                      }
2189                    }
2190                  }
2191                }
2192              }
2193
2194              // Incorporate the offset, then check against cycle size
2195              diff -= last;
2196              return diff === first || diff % first === 0 && diff / first >= 0;
2197            }
2198          };
2199        },
2200        PSEUDO: function PSEUDO(pseudo, argument) {
2201          // pseudo-class names are case-insensitive
2202          // https://www.w3.org/TR/selectors/#pseudo-classes
2203          // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2204          // Remember that setFilters inherits from pseudos
2205          var args,
2206            fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || find.error("unsupported pseudo: " + pseudo);
2207
2208          // The user may use createPseudo to indicate that
2209          // arguments are needed to create the filter function
2210          // just as jQuery does
2211          if (fn[expando]) {
2212            return fn(argument);
2213          }
2214
2215          // But maintain support for old signatures
2216          if (fn.length > 1) {
2217            args = [pseudo, pseudo, "", argument];
2218            return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function (seed, matches) {
2219              var idx,
2220                matched = fn(seed, argument),
2221                i = matched.length;
2222              while (i--) {
2223                idx = indexOf.call(seed, matched[i]);
2224                seed[idx] = !(matches[idx] = matched[i]);
2225              }
2226            }) : function (elem) {
2227              return fn(elem, 0, args);
2228            };
2229          }
2230          return fn;
2231        }
2232      },
2233      pseudos: {
2234        // Potentially complex pseudos
2235        not: markFunction(function (selector) {
2236          // Trim the selector passed to compile
2237          // to avoid treating leading and trailing
2238          // spaces as combinators
2239          var input = [],
2240            results = [],
2241            matcher = compile(selector.replace(rtrimCSS, "$1"));
2242          return matcher[expando] ? markFunction(function (seed, matches, _context, xml) {
2243            var elem,
2244              unmatched = matcher(seed, null, xml, []),
2245              i = seed.length;
2246
2247            // Match elements unmatched by `matcher`
2248            while (i--) {
2249              if (elem = unmatched[i]) {
2250                seed[i] = !(matches[i] = elem);
2251              }
2252            }
2253          }) : function (elem, _context, xml) {
2254            input[0] = elem;
2255            matcher(input, null, xml, results);
2256
2257            // Don't keep the element
2258            // (see https://github.com/jquery/sizzle/issues/299)
2259            input[0] = null;
2260            return !results.pop();
2261          };
2262        }),
2263        has: markFunction(function (selector) {
2264          return function (elem) {
2265            return find(selector, elem).length > 0;
2266          };
2267        }),
2268        contains: markFunction(function (text) {
2269          text = text.replace(runescape, funescape);
2270          return function (elem) {
2271            return (elem.textContent || _jQuery2.text(elem)).indexOf(text) > -1;
2272          };
2273        }),
2274        // "Whether an element is represented by a :lang() selector
2275        // is based solely on the element's language value
2276        // being equal to the identifier C,
2277        // or beginning with the identifier C immediately followed by "-".
2278        // The matching of C against the element's language value is performed case-insensitively.
2279        // The identifier C does not have to be a valid language name."
2280        // https://www.w3.org/TR/selectors/#lang-pseudo
2281        lang: markFunction(function (lang) {
2282          // lang value must be a valid identifier
2283          if (!ridentifier.test(lang || "")) {
2284            find.error("unsupported lang: " + lang);
2285          }
2286          lang = lang.replace(runescape, funescape).toLowerCase();
2287          return function (elem) {
2288            var elemLang;
2289            do {
2290              if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) {
2291                elemLang = elemLang.toLowerCase();
2292                return elemLang === lang || elemLang.indexOf(lang + "-") === 0;
2293              }
2294            } while ((elem = elem.parentNode) && elem.nodeType === 1);
2295            return false;
2296          };
2297        }),
2298        // Miscellaneous
2299        target: function target(elem) {
2300          var hash = window.location && window.location.hash;
2301          return hash && hash.slice(1) === elem.id;
2302        },
2303        root: function root(elem) {
2304          return elem === documentElement;
2305        },
2306        focus: function focus(elem) {
2307          return elem === safeActiveElement() && document.hasFocus() && !!(elem.type || elem.href || ~elem.tabIndex);
2308        },
2309        // Boolean properties
2310        enabled: createDisabledPseudo(false),
2311        disabled: createDisabledPseudo(true),
2312        checked: function checked(elem) {
2313          // In CSS3, :checked should return both checked and selected elements
2314          // https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2315          return nodeName(elem, "input") && !!elem.checked || nodeName(elem, "option") && !!elem.selected;
2316        },
2317        selected: function selected(elem) {
2318          // Support: IE <=11+
2319          // Accessing the selectedIndex property
2320          // forces the browser to treat the default option as
2321          // selected when in an optgroup.
2322          if (elem.parentNode) {
2323            // eslint-disable-next-line no-unused-expressions
2324            elem.parentNode.selectedIndex;
2325          }
2326          return elem.selected === true;
2327        },
2328        // Contents
2329        empty: function empty(elem) {
2330          // https://www.w3.org/TR/selectors/#empty-pseudo
2331          // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
2332          //   but not by others (comment: 8; processing instruction: 7; etc.)
2333          // nodeType < 6 works because attributes (2) do not appear as children
2334          for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
2335            if (elem.nodeType < 6) {
2336              return false;
2337            }
2338          }
2339          return true;
2340        },
2341        parent: function parent(elem) {
2342          return !Expr.pseudos.empty(elem);
2343        },
2344        // Element/input types
2345        header: function header(elem) {
2346          return rheader.test(elem.nodeName);
2347        },
2348        input: function input(elem) {
2349          return rinputs.test(elem.nodeName);
2350        },
2351        button: function button(elem) {
2352          return nodeName(elem, "input") && elem.type === "button" || nodeName(elem, "button");
2353        },
2354        text: function text(elem) {
2355          var attr;
2356          return nodeName(elem, "input") && elem.type === "text" && (
2357          // Support: IE <10 only
2358          // New HTML5 attribute values (e.g., "search") appear
2359          // with elem.type === "text"
2360          (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text");
2361        },
2362        // Position-in-collection
2363        first: createPositionalPseudo(function () {
2364          return [0];
2365        }),
2366        last: createPositionalPseudo(function (_matchIndexes, length) {
2367          return [length - 1];
2368        }),
2369        eq: createPositionalPseudo(function (_matchIndexes, length, argument) {
2370          return [argument < 0 ? argument + length : argument];
2371        }),
2372        even: createPositionalPseudo(function (matchIndexes, length) {
2373          var i = 0;
2374          for (; i < length; i += 2) {
2375            matchIndexes.push(i);
2376          }
2377          return matchIndexes;
2378        }),
2379        odd: createPositionalPseudo(function (matchIndexes, length) {
2380          var i = 1;
2381          for (; i < length; i += 2) {
2382            matchIndexes.push(i);
2383          }
2384          return matchIndexes;
2385        }),
2386        lt: createPositionalPseudo(function (matchIndexes, length, argument) {
2387          var i;
2388          if (argument < 0) {
2389            i = argument + length;
2390          } else if (argument > length) {
2391            i = length;
2392          } else {
2393            i = argument;
2394          }
2395          for (; --i >= 0;) {
2396            matchIndexes.push(i);
2397          }
2398          return matchIndexes;
2399        }),
2400        gt: createPositionalPseudo(function (matchIndexes, length, argument) {
2401          var i = argument < 0 ? argument + length : argument;
2402          for (; ++i < length;) {
2403            matchIndexes.push(i);
2404          }
2405          return matchIndexes;
2406        })
2407      }
2408    };
2409    Expr.pseudos.nth = Expr.pseudos.eq;
2410
2411    // Add button/input type pseudos
2412    for (i in {
2413      radio: true,
2414      checkbox: true,
2415      file: true,
2416      password: true,
2417      image: true
2418    }) {
2419      Expr.pseudos[i] = createInputPseudo(i);
2420    }
2421    for (i in {
2422      submit: true,
2423      reset: true
2424    }) {
2425      Expr.pseudos[i] = createButtonPseudo(i);
2426    }
2427
2428    // Easy API for creating new setFilters
2429    function setFilters() {}
2430    setFilters.prototype = Expr.filters = Expr.pseudos;
2431    Expr.setFilters = new setFilters();
2432    function tokenize(selector, parseOnly) {
2433      var matched,
2434        match,
2435        tokens,
2436        type,
2437        soFar,
2438        groups,
2439        preFilters,
2440        cached = tokenCache[selector + " "];
2441      if (cached) {
2442        return parseOnly ? 0 : cached.slice(0);
2443      }
2444      soFar = selector;
2445      groups = [];
2446      preFilters = Expr.preFilter;
2447      while (soFar) {
2448        // Comma and first run
2449        if (!matched || (match = rcomma.exec(soFar))) {
2450          if (match) {
2451            // Don't consume trailing commas as valid
2452            soFar = soFar.slice(match[0].length) || soFar;
2453          }
2454          groups.push(tokens = []);
2455        }
2456        matched = false;
2457
2458        // Combinators
2459        if (match = rleadingCombinator.exec(soFar)) {
2460          matched = match.shift();
2461          tokens.push({
2462            value: matched,
2463            // Cast descendant combinators to space
2464            type: match[0].replace(rtrimCSS, " ")
2465          });
2466          soFar = soFar.slice(matched.length);
2467        }
2468
2469        // Filters
2470        for (type in Expr.filter) {
2471          if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match)))) {
2472            matched = match.shift();
2473            tokens.push({
2474              value: matched,
2475              type: type,
2476              matches: match
2477            });
2478            soFar = soFar.slice(matched.length);
2479          }
2480        }
2481        if (!matched) {
2482          break;
2483        }
2484      }
2485
2486      // Return the length of the invalid excess
2487      // if we're just parsing
2488      // Otherwise, throw an error or return tokens
2489      if (parseOnly) {
2490        return soFar.length;
2491      }
2492      return soFar ? find.error(selector) :
2493      // Cache the tokens
2494      tokenCache(selector, groups).slice(0);
2495    }
2496    function toSelector(tokens) {
2497      var i = 0,
2498        len = tokens.length,
2499        selector = "";
2500      for (; i < len; i++) {
2501        selector += tokens[i].value;
2502      }
2503      return selector;
2504    }
2505    function addCombinator(matcher, combinator, base) {
2506      var dir = combinator.dir,
2507        skip = combinator.next,
2508        key = skip || dir,
2509        checkNonElements = base && key === "parentNode",
2510        doneName = done++;
2511      return combinator.first ?
2512      // Check against closest ancestor/preceding element
2513      function (elem, context, xml) {
2514        while (elem = elem[dir]) {
2515          if (elem.nodeType === 1 || checkNonElements) {
2516            return matcher(elem, context, xml);
2517          }
2518        }
2519        return false;
2520      } :
2521      // Check against all ancestor/preceding elements
2522      function (elem, context, xml) {
2523        var oldCache,
2524          outerCache,
2525          newCache = [dirruns, doneName];
2526
2527        // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2528        if (xml) {
2529          while (elem = elem[dir]) {
2530            if (elem.nodeType === 1 || checkNonElements) {
2531              if (matcher(elem, context, xml)) {
2532                return true;
2533              }
2534            }
2535          }
2536        } else {
2537          while (elem = elem[dir]) {
2538            if (elem.nodeType === 1 || checkNonElements) {
2539              outerCache = elem[expando] || (elem[expando] = {});
2540              if (skip && nodeName(elem, skip)) {
2541                elem = elem[dir] || elem;
2542              } else if ((oldCache = outerCache[key]) && oldCache[0] === dirruns && oldCache[1] === doneName) {
2543                // Assign to newCache so results back-propagate to previous elements
2544                return newCache[2] = oldCache[2];
2545              } else {
2546                // Reuse newcache so results back-propagate to previous elements
2547                outerCache[key] = newCache;
2548
2549                // A match means we're done; a fail means we have to keep checking
2550                if (newCache[2] = matcher(elem, context, xml)) {
2551                  return true;
2552                }
2553              }
2554            }
2555          }
2556        }
2557        return false;
2558      };
2559    }
2560    function elementMatcher(matchers) {
2561      return matchers.length > 1 ? function (elem, context, xml) {
2562        var i = matchers.length;
2563        while (i--) {
2564          if (!matchers[i](elem, context, xml)) {
2565            return false;
2566          }
2567        }
2568        return true;
2569      } : matchers[0];
2570    }
2571    function multipleContexts(selector, contexts, results) {
2572      var i = 0,
2573        len = contexts.length;
2574      for (; i < len; i++) {
2575        find(selector, contexts[i], results);
2576      }
2577      return results;
2578    }
2579    function condense(unmatched, map, filter, context, xml) {
2580      var elem,
2581        newUnmatched = [],
2582        i = 0,
2583        len = unmatched.length,
2584        mapped = map != null;
2585      for (; i < len; i++) {
2586        if (elem = unmatched[i]) {
2587          if (!filter || filter(elem, context, xml)) {
2588            newUnmatched.push(elem);
2589            if (mapped) {
2590              map.push(i);
2591            }
2592          }
2593        }
2594      }
2595      return newUnmatched;
2596    }
2597    function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
2598      if (postFilter && !postFilter[expando]) {
2599        postFilter = setMatcher(postFilter);
2600      }
2601      if (postFinder && !postFinder[expando]) {
2602        postFinder = setMatcher(postFinder, postSelector);
2603      }
2604      return markFunction(function (seed, results, context, xml) {
2605        var temp,
2606          i,
2607          elem,
2608          matcherOut,
2609          preMap = [],
2610          postMap = [],
2611          preexisting = results.length,
2612          // Get initial elements from seed or context
2613          elems = seed || multipleContexts(selector || "*", context.nodeType ? [context] : context, []),
2614          // Prefilter to get matcher input, preserving a map for seed-results synchronization
2615          matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems;
2616        if (matcher) {
2617          // If we have a postFinder, or filtered seed, or non-seed postFilter
2618          // or preexisting results,
2619          matcherOut = postFinder || (seed ? preFilter : preexisting || postFilter) ?
2620          // ...intermediate processing is necessary
2621          [] :
2622          // ...otherwise use results directly
2623          results;
2624
2625          // Find primary matches
2626          matcher(matcherIn, matcherOut, context, xml);
2627        } else {
2628          matcherOut = matcherIn;
2629        }
2630
2631        // Apply postFilter
2632        if (postFilter) {
2633          temp = condense(matcherOut, postMap);
2634          postFilter(temp, [], context, xml);
2635
2636          // Un-match failing elements by moving them back to matcherIn
2637          i = temp.length;
2638          while (i--) {
2639            if (elem = temp[i]) {
2640              matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);
2641            }
2642          }
2643        }
2644        if (seed) {
2645          if (postFinder || preFilter) {
2646            if (postFinder) {
2647              // Get the final matcherOut by condensing this intermediate into postFinder contexts
2648              temp = [];
2649              i = matcherOut.length;
2650              while (i--) {
2651                if (elem = matcherOut[i]) {
2652                  // Restore matcherIn since elem is not yet a final match
2653                  temp.push(matcherIn[i] = elem);
2654                }
2655              }
2656              postFinder(null, matcherOut = [], temp, xml);
2657            }
2658
2659            // Move matched elements from seed to results to keep them synchronized
2660            i = matcherOut.length;
2661            while (i--) {
2662              if ((elem = matcherOut[i]) && (temp = postFinder ? indexOf.call(seed, elem) : preMap[i]) > -1) {
2663                seed[temp] = !(results[temp] = elem);
2664              }
2665            }
2666          }
2667
2668          // Add elements to results, through postFinder if defined
2669        } else {
2670          matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut);
2671          if (postFinder) {
2672            postFinder(null, results, matcherOut, xml);
2673          } else {
2674            push.apply(results, matcherOut);
2675          }
2676        }
2677      });
2678    }
2679    function matcherFromTokens(tokens) {
2680      var checkContext,
2681        matcher,
2682        j,
2683        len = tokens.length,
2684        leadingRelative = Expr.relative[tokens[0].type],
2685        implicitRelative = leadingRelative || Expr.relative[" "],
2686        i = leadingRelative ? 1 : 0,
2687        // The foundational matcher ensures that elements are reachable from top-level context(s)
2688        matchContext = addCombinator(function (elem) {
2689          return elem === checkContext;
2690        }, implicitRelative, true),
2691        matchAnyContext = addCombinator(function (elem) {
2692          return indexOf.call(checkContext, elem) > -1;
2693        }, implicitRelative, true),
2694        matchers = [function (elem, context, xml) {
2695          // Support: IE 11+, Edge 17 - 18+
2696          // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2697          // two documents; shallow comparisons work.
2698          // eslint-disable-next-line eqeqeq
2699          var ret = !leadingRelative && (xml || context != outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml));
2700
2701          // Avoid hanging onto element
2702          // (see https://github.com/jquery/sizzle/issues/299)
2703          checkContext = null;
2704          return ret;
2705        }];
2706      for (; i < len; i++) {
2707        if (matcher = Expr.relative[tokens[i].type]) {
2708          matchers = [addCombinator(elementMatcher(matchers), matcher)];
2709        } else {
2710          matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches);
2711
2712          // Return special upon seeing a positional matcher
2713          if (matcher[expando]) {
2714            // Find the next relative operator (if any) for proper handling
2715            j = ++i;
2716            for (; j < len; j++) {
2717              if (Expr.relative[tokens[j].type]) {
2718                break;
2719              }
2720            }
2721            return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector(
2722            // If the preceding token was a descendant combinator, insert an implicit any-element `*`
2723            tokens.slice(0, i - 1).concat({
2724              value: tokens[i - 2].type === " " ? "*" : ""
2725            })).replace(rtrimCSS, "$1"), matcher, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens(tokens = tokens.slice(j)), j < len && toSelector(tokens));
2726          }
2727          matchers.push(matcher);
2728        }
2729      }
2730      return elementMatcher(matchers);
2731    }
2732    function matcherFromGroupMatchers(elementMatchers, setMatchers) {
2733      var bySet = setMatchers.length > 0,
2734        byElement = elementMatchers.length > 0,
2735        superMatcher = function superMatcher(seed, context, xml, results, outermost) {
2736          var elem,
2737            j,
2738            matcher,
2739            matchedCount = 0,
2740            i = "0",
2741            unmatched = seed && [],
2742            setMatched = [],
2743            contextBackup = outermostContext,
2744            // We must always have either seed elements or outermost context
2745            elems = seed || byElement && Expr.find.TAG("*", outermost),
2746            // Use integer dirruns iff this is the outermost matcher
2747            dirrunsUnique = dirruns += contextBackup == null ? 1 : Math.random() || 0.1,
2748            len = elems.length;
2749          if (outermost) {
2750            // Support: IE 11+, Edge 17 - 18+
2751            // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2752            // two documents; shallow comparisons work.
2753            // eslint-disable-next-line eqeqeq
2754            outermostContext = context == document || context || outermost;
2755          }
2756
2757          // Add elements passing elementMatchers directly to results
2758          // Support: iOS <=7 - 9 only
2759          // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching
2760          // elements by id. (see trac-14142)
2761          for (; i !== len && (elem = elems[i]) != null; i++) {
2762            if (byElement && elem) {
2763              j = 0;
2764
2765              // Support: IE 11+, Edge 17 - 18+
2766              // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2767              // two documents; shallow comparisons work.
2768              // eslint-disable-next-line eqeqeq
2769              if (!context && elem.ownerDocument != document) {
2770                setDocument(elem);
2771                xml = !documentIsHTML;
2772              }
2773              while (matcher = elementMatchers[j++]) {
2774                if (matcher(elem, context || document, xml)) {
2775                  push.call(results, elem);
2776                  break;
2777                }
2778              }
2779              if (outermost) {
2780                dirruns = dirrunsUnique;
2781              }
2782            }
2783
2784            // Track unmatched elements for set filters
2785            if (bySet) {
2786              // They will have gone through all possible matchers
2787              if (elem = !matcher && elem) {
2788                matchedCount--;
2789              }
2790
2791              // Lengthen the array for every element, matched or not
2792              if (seed) {
2793                unmatched.push(elem);
2794              }
2795            }
2796          }
2797
2798          // `i` is now the count of elements visited above, and adding it to `matchedCount`
2799          // makes the latter nonnegative.
2800          matchedCount += i;
2801
2802          // Apply set filters to unmatched elements
2803          // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2804          // equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2805          // no element matchers and no seed.
2806          // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2807          // case, which will result in a "00" `matchedCount` that differs from `i` but is also
2808          // numerically zero.
2809          if (bySet && i !== matchedCount) {
2810            j = 0;
2811            while (matcher = setMatchers[j++]) {
2812              matcher(unmatched, setMatched, context, xml);
2813            }
2814            if (seed) {
2815              // Reintegrate element matches to eliminate the need for sorting
2816              if (matchedCount > 0) {
2817                while (i--) {
2818                  if (!(unmatched[i] || setMatched[i])) {
2819                    setMatched[i] = pop.call(results);
2820                  }
2821                }
2822              }
2823
2824              // Discard index placeholder values to get only actual matches
2825              setMatched = condense(setMatched);
2826            }
2827
2828            // Add matches to results
2829            push.apply(results, setMatched);
2830
2831            // Seedless set matches succeeding multiple successful matchers stipulate sorting
2832            if (outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1) {
2833              _jQuery2.uniqueSort(results);
2834            }
2835          }
2836
2837          // Override manipulation of globals by nested matchers
2838          if (outermost) {
2839            dirruns = dirrunsUnique;
2840            outermostContext = contextBackup;
2841          }
2842          return unmatched;
2843        };
2844      return bySet ? markFunction(superMatcher) : superMatcher;
2845    }
2846    function compile(selector, match /* Internal Use Only */) {
2847      var i,
2848        setMatchers = [],
2849        elementMatchers = [],
2850        cached = compilerCache[selector + " "];
2851      if (!cached) {
2852        // Generate a function of recursive functions that can be used to check each element
2853        if (!match) {
2854          match = tokenize(selector);
2855        }
2856        i = match.length;
2857        while (i--) {
2858          cached = matcherFromTokens(match[i]);
2859          if (cached[expando]) {
2860            setMatchers.push(cached);
2861          } else {
2862            elementMatchers.push(cached);
2863          }
2864        }
2865
2866        // Cache the compiled function
2867        cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers));
2868
2869        // Save selector and tokenization
2870        cached.selector = selector;
2871      }
2872      return cached;
2873    }
2874
2875    /**
2876     * A low-level selection function that works with jQuery's compiled
2877     *  selector functions
2878     * @param {String|Function} selector A selector or a pre-compiled
2879     *  selector function built with jQuery selector compile
2880     * @param {Element} context
2881     * @param {Array} [results]
2882     * @param {Array} [seed] A set of elements to match against
2883     */
2884    function select(selector, context, results, seed) {
2885      var i,
2886        tokens,
2887        token,
2888        type,
2889        find,
2890        compiled = typeof selector === "function" && selector,
2891        match = !seed && tokenize(selector = compiled.selector || selector);
2892      results = results || [];
2893
2894      // Try to minimize operations if there is only one selector in the list and no seed
2895      // (the latter of which guarantees us context)
2896      if (match.length === 1) {
2897        // Reduce context if the leading compound selector is an ID
2898        tokens = match[0] = match[0].slice(0);
2899        if (tokens.length > 2 && (token = tokens[0]).type === "ID" && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) {
2900          context = (Expr.find.ID(token.matches[0].replace(runescape, funescape), context) || [])[0];
2901          if (!context) {
2902            return results;
2903
2904            // Precompiled matchers will still verify ancestry, so step up a level
2905          } else if (compiled) {
2906            context = context.parentNode;
2907          }
2908          selector = selector.slice(tokens.shift().value.length);
2909        }
2910
2911        // Fetch a seed set for right-to-left matching
2912        i = matchExpr.needsContext.test(selector) ? 0 : tokens.length;
2913        while (i--) {
2914          token = tokens[i];
2915
2916          // Abort if we hit a combinator
2917          if (Expr.relative[type = token.type]) {
2918            break;
2919          }
2920          if (find = Expr.find[type]) {
2921            // Search, expanding context for leading sibling combinators
2922            if (seed = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && testContext(context.parentNode) || context)) {
2923              // If seed is empty or no tokens remain, we can return early
2924              tokens.splice(i, 1);
2925              selector = seed.length && toSelector(tokens);
2926              if (!selector) {
2927                push.apply(results, seed);
2928                return results;
2929              }
2930              break;
2931            }
2932          }
2933        }
2934      }
2935
2936      // Compile and execute a filtering function if one is not provided
2937      // Provide `match` to avoid retokenization if we modified the selector above
2938      (compiled || compile(selector, match))(seed, context, !documentIsHTML, results, !context || rsibling.test(selector) && testContext(context.parentNode) || context);
2939      return results;
2940    }
2941
2942    // One-time assignments
2943
2944    // Support: Android <=4.0 - 4.1+
2945    // Sort stability
2946    support.sortStable = expando.split("").sort(sortOrder).join("") === expando;
2947
2948    // Initialize against the default document
2949    setDocument();
2950
2951    // Support: Android <=4.0 - 4.1+
2952    // Detached nodes confoundingly follow *each other*
2953    support.sortDetached = assert(function (el) {
2954      // Should return 1, but returns 4 (following)
2955      return el.compareDocumentPosition(document.createElement("fieldset")) & 1;
2956    });
2957    _jQuery2.find = find;
2958
2959    // Deprecated
2960    _jQuery2.expr[":"] = _jQuery2.expr.pseudos;
2961    _jQuery2.unique = _jQuery2.uniqueSort;
2962
2963    // These have always been private, but they used to be documented as part of
2964    // Sizzle so let's maintain them for now for backwards compatibility purposes.
2965    find.compile = compile;
2966    find.select = select;
2967    find.setDocument = setDocument;
2968    find.tokenize = tokenize;
2969    find.escape = _jQuery2.escapeSelector;
2970    find.getText = _jQuery2.text;
2971    find.isXML = _jQuery2.isXMLDoc;
2972    find.selectors = _jQuery2.expr;
2973    find.support = _jQuery2.support;
2974    find.uniqueSort = _jQuery2.uniqueSort;
2975
2976    /* eslint-enable */
2977  })();
2978  var dir = function dir(elem, _dir, until) {
2979    var matched = [],
2980      truncate = until !== undefined;
2981    while ((elem = elem[_dir]) && elem.nodeType !== 9) {
2982      if (elem.nodeType === 1) {
2983        if (truncate && _jQuery2(elem).is(until)) {
2984          break;
2985        }
2986        matched.push(elem);
2987      }
2988    }
2989    return matched;
2990  };
2991  var _siblings = function siblings(n, elem) {
2992    var matched = [];
2993    for (; n; n = n.nextSibling) {
2994      if (n.nodeType === 1 && n !== elem) {
2995        matched.push(n);
2996      }
2997    }
2998    return matched;
2999  };
3000  var rneedsContext = _jQuery2.expr.match.needsContext;
3001  var rsingleTag = /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;
3002
3003  // Implement the identical functionality for filter and not
3004  function winnow(elements, qualifier, not) {
3005    if (isFunction(qualifier)) {
3006      return _jQuery2.grep(elements, function (elem, i) {
3007        return !!qualifier.call(elem, i, elem) !== not;
3008      });
3009    }
3010
3011    // Single element
3012    if (qualifier.nodeType) {
3013      return _jQuery2.grep(elements, function (elem) {
3014        return elem === qualifier !== not;
3015      });
3016    }
3017
3018    // Arraylike of elements (jQuery, arguments, Array)
3019    if (typeof qualifier !== "string") {
3020      return _jQuery2.grep(elements, function (elem) {
3021        return indexOf.call(qualifier, elem) > -1 !== not;
3022      });
3023    }
3024
3025    // Filtered directly for both simple and complex selectors
3026    return _jQuery2.filter(qualifier, elements, not);
3027  }
3028  _jQuery2.filter = function (expr, elems, not) {
3029    var elem = elems[0];
3030    if (not) {
3031      expr = ":not(" + expr + ")";
3032    }
3033    if (elems.length === 1 && elem.nodeType === 1) {
3034      return _jQuery2.find.matchesSelector(elem, expr) ? [elem] : [];
3035    }
3036    return _jQuery2.find.matches(expr, _jQuery2.grep(elems, function (elem) {
3037      return elem.nodeType === 1;
3038    }));
3039  };
3040  _jQuery2.fn.extend({
3041    find: function find(selector) {
3042      var i,
3043        ret,
3044        len = this.length,
3045        self = this;
3046      if (typeof selector !== "string") {
3047        return this.pushStack(_jQuery2(selector).filter(function () {
3048          for (i = 0; i < len; i++) {
3049            if (_jQuery2.contains(self[i], this)) {
3050              return true;
3051            }
3052          }
3053        }));
3054      }
3055      ret = this.pushStack([]);
3056      for (i = 0; i < len; i++) {
3057        _jQuery2.find(selector, self[i], ret);
3058      }
3059      return len > 1 ? _jQuery2.uniqueSort(ret) : ret;
3060    },
3061    filter: function filter(selector) {
3062      return this.pushStack(winnow(this, selector || [], false));
3063    },
3064    not: function not(selector) {
3065      return this.pushStack(winnow(this, selector || [], true));
3066    },
3067    is: function is(selector) {
3068      return !!winnow(this,
3069      // If this is a positional/relative selector, check membership in the returned set
3070      // so $("p:first").is("p:last") won't return true for a doc with two "p".
3071      typeof selector === "string" && rneedsContext.test(selector) ? _jQuery2(selector) : selector || [], false).length;
3072    }
3073  });
3074
3075  // Initialize a jQuery object
3076
3077  // A central reference to the root jQuery(document)
3078  var rootjQuery,
3079    // A simple way to check for HTML strings
3080    // Prioritize #id over <tag> to avoid XSS via location.hash (trac-9521)
3081    // Strict HTML recognition (trac-11290: must start with <)
3082    // Shortcut simple #id case for speed
3083    rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
3084    init = _jQuery2.fn.init = function (selector, context, root) {
3085      var match, elem;
3086
3087      // HANDLE: $(""), $(null), $(undefined), $(false)
3088      if (!selector) {
3089        return this;
3090      }
3091
3092      // Method init() accepts an alternate rootjQuery
3093      // so migrate can support jQuery.sub (gh-2101)
3094      root = root || rootjQuery;
3095
3096      // Handle HTML strings
3097      if (typeof selector === "string") {
3098        if (selector[0] === "<" && selector[selector.length - 1] === ">" && selector.length >= 3) {
3099          // Assume that strings that start and end with <> are HTML and skip the regex check
3100          match = [null, selector, null];
3101        } else {
3102          match = rquickExpr.exec(selector);
3103        }
3104
3105        // Match html or make sure no context is specified for #id
3106        if (match && (match[1] || !context)) {
3107          // HANDLE: $(html) -> $(array)
3108          if (match[1]) {
3109            context = context instanceof _jQuery2 ? context[0] : context;
3110
3111            // Option to run scripts is true for back-compat
3112            // Intentionally let the error be thrown if parseHTML is not present
3113            _jQuery2.merge(this, _jQuery2.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : document, true));
3114
3115            // HANDLE: $(html, props)
3116            if (rsingleTag.test(match[1]) && _jQuery2.isPlainObject(context)) {
3117              for (match in context) {
3118                // Properties of context are called as methods if possible
3119                if (isFunction(this[match])) {
3120                  this[match](context[match]);
3121
3122                  // ...and otherwise set as attributes
3123                } else {
3124                  this.attr(match, context[match]);
3125                }
3126              }
3127            }
3128            return this;
3129
3130            // HANDLE: $(#id)
3131          } else {
3132            elem = document.getElementById(match[2]);
3133            if (elem) {
3134              // Inject the element directly into the jQuery object
3135              this[0] = elem;
3136              this.length = 1;
3137            }
3138            return this;
3139          }
3140
3141          // HANDLE: $(expr, $(...))
3142        } else if (!context || context.jquery) {
3143          return (context || root).find(selector);
3144
3145          // HANDLE: $(expr, context)
3146          // (which is just equivalent to: $(context).find(expr)
3147        } else {
3148          return this.constructor(context).find(selector);
3149        }
3150
3151        // HANDLE: $(DOMElement)
3152      } else if (selector.nodeType) {
3153        this[0] = selector;
3154        this.length = 1;
3155        return this;
3156
3157        // HANDLE: $(function)
3158        // Shortcut for document ready
3159      } else if (isFunction(selector)) {
3160        return root.ready !== undefined ? root.ready(selector) :
3161        // Execute immediately if ready is not present
3162        selector(_jQuery2);
3163      }
3164      return _jQuery2.makeArray(selector, this);
3165    };
3166
3167  // Give the init function the jQuery prototype for later instantiation
3168  init.prototype = _jQuery2.fn;
3169
3170  // Initialize central reference
3171  rootjQuery = _jQuery2(document);
3172  var rparentsprev = /^(?:parents|prev(?:Until|All))/,
3173    // Methods guaranteed to produce a unique set when starting from a unique set
3174    guaranteedUnique = {
3175      children: true,
3176      contents: true,
3177      next: true,
3178      prev: true
3179    };
3180  _jQuery2.fn.extend({
3181    has: function has(target) {
3182      var targets = _jQuery2(target, this),
3183        l = targets.length;
3184      return this.filter(function () {
3185        var i = 0;
3186        for (; i < l; i++) {
3187          if (_jQuery2.contains(this, targets[i])) {
3188            return true;
3189          }
3190        }
3191      });
3192    },
3193    closest: function closest(selectors, context) {
3194      var cur,
3195        i = 0,
3196        l = this.length,
3197        matched = [],
3198        targets = typeof selectors !== "string" && _jQuery2(selectors);
3199
3200      // Positional selectors never match, since there's no _selection_ context
3201      if (!rneedsContext.test(selectors)) {
3202        for (; i < l; i++) {
3203          for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) {
3204            // Always skip document fragments
3205            if (cur.nodeType < 11 && (targets ? targets.index(cur) > -1 :
3206            // Don't pass non-elements to jQuery#find
3207            cur.nodeType === 1 && _jQuery2.find.matchesSelector(cur, selectors))) {
3208              matched.push(cur);
3209              break;
3210            }
3211          }
3212        }
3213      }
3214      return this.pushStack(matched.length > 1 ? _jQuery2.uniqueSort(matched) : matched);
3215    },
3216    // Determine the position of an element within the set
3217    index: function index(elem) {
3218      // No argument, return index in parent
3219      if (!elem) {
3220        return this[0] && this[0].parentNode ? this.first().prevAll().length : -1;
3221      }
3222
3223      // Index in selector
3224      if (typeof elem === "string") {
3225        return indexOf.call(_jQuery2(elem), this[0]);
3226      }
3227
3228      // Locate the position of the desired element
3229      return indexOf.call(this,
3230      // If it receives a jQuery object, the first element is used
3231      elem.jquery ? elem[0] : elem);
3232    },
3233    add: function add(selector, context) {
3234      return this.pushStack(_jQuery2.uniqueSort(_jQuery2.merge(this.get(), _jQuery2(selector, context))));
3235    },
3236    addBack: function addBack(selector) {
3237      return this.add(selector == null ? this.prevObject : this.prevObject.filter(selector));
3238    }
3239  });
3240  function sibling(cur, dir) {
3241    while ((cur = cur[dir]) && cur.nodeType !== 1) {}
3242    return cur;
3243  }
3244  _jQuery2.each({
3245    parent: function parent(elem) {
3246      var parent = elem.parentNode;
3247      return parent && parent.nodeType !== 11 ? parent : null;
3248    },
3249    parents: function parents(elem) {
3250      return dir(elem, "parentNode");
3251    },
3252    parentsUntil: function parentsUntil(elem, _i, until) {
3253      return dir(elem, "parentNode", until);
3254    },
3255    next: function next(elem) {
3256      return sibling(elem, "nextSibling");
3257    },
3258    prev: function prev(elem) {
3259      return sibling(elem, "previousSibling");
3260    },
3261    nextAll: function nextAll(elem) {
3262      return dir(elem, "nextSibling");
3263    },
3264    prevAll: function prevAll(elem) {
3265      return dir(elem, "previousSibling");
3266    },
3267    nextUntil: function nextUntil(elem, _i, until) {
3268      return dir(elem, "nextSibling", until);
3269    },
3270    prevUntil: function prevUntil(elem, _i, until) {
3271      return dir(elem, "previousSibling", until);
3272    },
3273    siblings: function siblings(elem) {
3274      return _siblings((elem.parentNode || {}).firstChild, elem);
3275    },
3276    children: function children(elem) {
3277      return _siblings(elem.firstChild);
3278    },
3279    contents: function contents(elem) {
3280      if (elem.contentDocument != null &&
3281      // Support: IE 11+
3282      // <object> elements with no `data` attribute has an object
3283      // `contentDocument` with a `null` prototype.
3284      getProto(elem.contentDocument)) {
3285        return elem.contentDocument;
3286      }
3287
3288      // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
3289      // Treat the template element as a regular one in browsers that
3290      // don't support it.
3291      if (nodeName(elem, "template")) {
3292        elem = elem.content || elem;
3293      }
3294      return _jQuery2.merge([], elem.childNodes);
3295    }
3296  }, function (name, fn) {
3297    _jQuery2.fn[name] = function (until, selector) {
3298      var matched = _jQuery2.map(this, fn, until);
3299      if (name.slice(-5) !== "Until") {
3300        selector = until;
3301      }
3302      if (selector && typeof selector === "string") {
3303        matched = _jQuery2.filter(selector, matched);
3304      }
3305      if (this.length > 1) {
3306        // Remove duplicates
3307        if (!guaranteedUnique[name]) {
3308          _jQuery2.uniqueSort(matched);
3309        }
3310
3311        // Reverse order for parents* and prev-derivatives
3312        if (rparentsprev.test(name)) {
3313          matched.reverse();
3314        }
3315      }
3316      return this.pushStack(matched);
3317    };
3318  });
3319  var rnothtmlwhite = /[^\x20\t\r\n\f]+/g;
3320
3321  // Convert String-formatted options into Object-formatted ones
3322  function createOptions(options) {
3323    var object = {};
3324    _jQuery2.each(options.match(rnothtmlwhite) || [], function (_, flag) {
3325      object[flag] = true;
3326    });
3327    return object;
3328  }
3329
3330  /*
3331   * Create a callback list using the following parameters:
3332   *
3333   *	options: an optional list of space-separated options that will change how
3334   *			the callback list behaves or a more traditional option object
3335   *
3336   * By default a callback list will act like an event callback list and can be
3337   * "fired" multiple times.
3338   *
3339   * Possible options:
3340   *
3341   *	once:			will ensure the callback list can only be fired once (like a Deferred)
3342   *
3343   *	memory:			will keep track of previous values and will call any callback added
3344   *					after the list has been fired right away with the latest "memorized"
3345   *					values (like a Deferred)
3346   *
3347   *	unique:			will ensure a callback can only be added once (no duplicate in the list)
3348   *
3349   *	stopOnFalse:	interrupt callings when a callback returns false
3350   *
3351   */
3352  _jQuery2.Callbacks = function (options) {
3353    // Convert options from String-formatted to Object-formatted if needed
3354    // (we check in cache first)
3355    options = typeof options === "string" ? createOptions(options) : _jQuery2.extend({}, options);
3356    var
3357      // Flag to know if list is currently firing
3358      firing,
3359      // Last fire value for non-forgettable lists
3360      memory,
3361      // Flag to know if list was already fired
3362      _fired,
3363      // Flag to prevent firing
3364      _locked,
3365      // Actual callback list
3366      list = [],
3367      // Queue of execution data for repeatable lists
3368      queue = [],
3369      // Index of currently firing callback (modified by add/remove as needed)
3370      firingIndex = -1,
3371      // Fire callbacks
3372      fire = function fire() {
3373        // Enforce single-firing
3374        _locked = _locked || options.once;
3375
3376        // Execute callbacks for all pending executions,
3377        // respecting firingIndex overrides and runtime changes
3378        _fired = firing = true;
3379        for (; queue.length; firingIndex = -1) {
3380          memory = queue.shift();
3381          while (++firingIndex < list.length) {
3382            // Run callback and check for early termination
3383            if (list[firingIndex].apply(memory[0], memory[1]) === false && options.stopOnFalse) {
3384              // Jump to end and forget the data so .add doesn't re-fire
3385              firingIndex = list.length;
3386              memory = false;
3387            }
3388          }
3389        }
3390
3391        // Forget the data if we're done with it
3392        if (!options.memory) {
3393          memory = false;
3394        }
3395        firing = false;
3396
3397        // Clean up if we're done firing for good
3398        if (_locked) {
3399          // Keep an empty list if we have data for future add calls
3400          if (memory) {
3401            list = [];
3402
3403            // Otherwise, this object is spent
3404          } else {
3405            list = "";
3406          }
3407        }
3408      },
3409      // Actual Callbacks object
3410      self = {
3411        // Add a callback or a collection of callbacks to the list
3412        add: function add() {
3413          if (list) {
3414            // If we have memory from a past run, we should fire after adding
3415            if (memory && !firing) {
3416              firingIndex = list.length - 1;
3417              queue.push(memory);
3418            }
3419            (function add(args) {
3420              _jQuery2.each(args, function (_, arg) {
3421                if (isFunction(arg)) {
3422                  if (!options.unique || !self.has(arg)) {
3423                    list.push(arg);
3424                  }
3425                } else if (arg && arg.length && toType(arg) !== "string") {
3426                  // Inspect recursively
3427                  add(arg);
3428                }
3429              });
3430            })(arguments);
3431            if (memory && !firing) {
3432              fire();
3433            }
3434          }
3435          return this;
3436        },
3437        // Remove a callback from the list
3438        remove: function remove() {
3439          _jQuery2.each(arguments, function (_, arg) {
3440            var index;
3441            while ((index = _jQuery2.inArray(arg, list, index)) > -1) {
3442              list.splice(index, 1);
3443
3444              // Handle firing indexes
3445              if (index <= firingIndex) {
3446                firingIndex--;
3447              }
3448            }
3449          });
3450          return this;
3451        },
3452        // Check if a given callback is in the list.
3453        // If no argument is given, return whether or not list has callbacks attached.
3454        has: function has(fn) {
3455          return fn ? _jQuery2.inArray(fn, list) > -1 : list.length > 0;
3456        },
3457        // Remove all callbacks from the list
3458        empty: function empty() {
3459          if (list) {
3460            list = [];
3461          }
3462          return this;
3463        },
3464        // Disable .fire and .add
3465        // Abort any current/pending executions
3466        // Clear all callbacks and values
3467        disable: function disable() {
3468          _locked = queue = [];
3469          list = memory = "";
3470          return this;
3471        },
3472        disabled: function disabled() {
3473          return !list;
3474        },
3475        // Disable .fire
3476        // Also disable .add unless we have memory (since it would have no effect)
3477        // Abort any pending executions
3478        lock: function lock() {
3479          _locked = queue = [];
3480          if (!memory && !firing) {
3481            list = memory = "";
3482          }
3483          return this;
3484        },
3485        locked: function locked() {
3486          return !!_locked;
3487        },
3488        // Call all callbacks with the given context and arguments
3489        fireWith: function fireWith(context, args) {
3490          if (!_locked) {
3491            args = args || [];
3492            args = [context, args.slice ? args.slice() : args];
3493            queue.push(args);
3494            if (!firing) {
3495              fire();
3496            }
3497          }
3498          return this;
3499        },
3500        // Call all the callbacks with the given arguments
3501        fire: function fire() {
3502          self.fireWith(this, arguments);
3503          return this;
3504        },
3505        // To know if the callbacks have already been called at least once
3506        fired: function fired() {
3507          return !!_fired;
3508        }
3509      };
3510    return self;
3511  };
3512  function Identity(v) {
3513    return v;
3514  }
3515  function Thrower(ex) {
3516    throw ex;
3517  }
3518  function adoptValue(value, resolve, reject, noValue) {
3519    var method;
3520    try {
3521      // Check for promise aspect first to privilege synchronous behavior
3522      if (value && isFunction(method = value.promise)) {
3523        method.call(value).done(resolve).fail(reject);
3524
3525        // Other thenables
3526      } else if (value && isFunction(method = value.then)) {
3527        method.call(value, resolve, reject);
3528
3529        // Other non-thenables
3530      } else {
3531        // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
3532        // * false: [ value ].slice( 0 ) => resolve( value )
3533        // * true: [ value ].slice( 1 ) => resolve()
3534        resolve.apply(undefined, [value].slice(noValue));
3535      }
3536
3537      // For Promises/A+, convert exceptions into rejections
3538      // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
3539      // Deferred#then to conditionally suppress rejection.
3540    } catch (value) {
3541      // Support: Android 4.0 only
3542      // Strict mode functions invoked without .call/.apply get global-object context
3543      reject.apply(undefined, [value]);
3544    }
3545  }
3546  _jQuery2.extend({
3547    Deferred: function Deferred(func) {
3548      var tuples = [
3549        // action, add listener, callbacks,
3550        // ... .then handlers, argument index, [final state]
3551        ["notify", "progress", _jQuery2.Callbacks("memory"), _jQuery2.Callbacks("memory"), 2], ["resolve", "done", _jQuery2.Callbacks("once memory"), _jQuery2.Callbacks("once memory"), 0, "resolved"], ["reject", "fail", _jQuery2.Callbacks("once memory"), _jQuery2.Callbacks("once memory"), 1, "rejected"]],
3552        _state = "pending",
3553        _promise = {
3554          state: function state() {
3555            return _state;
3556          },
3557          always: function always() {
3558            deferred.done(arguments).fail(arguments);
3559            return this;
3560          },
3561          "catch": function _catch(fn) {
3562            return _promise.then(null, fn);
3563          },
3564          // Keep pipe for back-compat
3565          pipe: function pipe(/* fnDone, fnFail, fnProgress */
3566          ) {
3567            var fns = arguments;
3568            return _jQuery2.Deferred(function (newDefer) {
3569              _jQuery2.each(tuples, function (_i, tuple) {
3570                // Map tuples (progress, done, fail) to arguments (done, fail, progress)
3571                var fn = isFunction(fns[tuple[4]]) && fns[tuple[4]];
3572
3573                // deferred.progress(function() { bind to newDefer or newDefer.notify })
3574                // deferred.done(function() { bind to newDefer or newDefer.resolve })
3575                // deferred.fail(function() { bind to newDefer or newDefer.reject })
3576                deferred[tuple[1]](function () {
3577                  var returned = fn && fn.apply(this, arguments);
3578                  if (returned && isFunction(returned.promise)) {
3579                    returned.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject);
3580                  } else {
3581                    newDefer[tuple[0] + "With"](this, fn ? [returned] : arguments);
3582                  }
3583                });
3584              });
3585              fns = null;
3586            }).promise();
3587          },
3588          then: function then(onFulfilled, onRejected, onProgress) {
3589            var maxDepth = 0;
3590            function resolve(depth, deferred, handler, special) {
3591              return function () {
3592                var that = this,
3593                  args = arguments,
3594                  mightThrow = function mightThrow() {
3595                    var returned, then;
3596
3597                    // Support: Promises/A+ section 2.3.3.3.3
3598                    // https://promisesaplus.com/#point-59
3599                    // Ignore double-resolution attempts
3600                    if (depth < maxDepth) {
3601                      return;
3602                    }
3603                    returned = handler.apply(that, args);
3604
3605                    // Support: Promises/A+ section 2.3.1
3606                    // https://promisesaplus.com/#point-48
3607                    if (returned === deferred.promise()) {
3608                      throw new TypeError("Thenable self-resolution");
3609                    }
3610
3611                    // Support: Promises/A+ sections 2.3.3.1, 3.5
3612                    // https://promisesaplus.com/#point-54
3613                    // https://promisesaplus.com/#point-75
3614                    // Retrieve `then` only once
3615                    then = returned && (
3616                    // Support: Promises/A+ section 2.3.4
3617                    // https://promisesaplus.com/#point-64
3618                    // Only check objects and functions for thenability
3619                    _typeof(returned) === "object" || typeof returned === "function") && returned.then;
3620
3621                    // Handle a returned thenable
3622                    if (isFunction(then)) {
3623                      // Special processors (notify) just wait for resolution
3624                      if (special) {
3625                        then.call(returned, resolve(maxDepth, deferred, Identity, special), resolve(maxDepth, deferred, Thrower, special));
3626
3627                        // Normal processors (resolve) also hook into progress
3628                      } else {
3629                        // ...and disregard older resolution values
3630                        maxDepth++;
3631                        then.call(returned, resolve(maxDepth, deferred, Identity, special), resolve(maxDepth, deferred, Thrower, special), resolve(maxDepth, deferred, Identity, deferred.notifyWith));
3632                      }
3633
3634                      // Handle all other returned values
3635                    } else {
3636                      // Only substitute handlers pass on context
3637                      // and multiple values (non-spec behavior)
3638                      if (handler !== Identity) {
3639                        that = undefined;
3640                        args = [returned];
3641                      }
3642
3643                      // Process the value(s)
3644                      // Default process is resolve
3645                      (special || deferred.resolveWith)(that, args);
3646                    }
3647                  },
3648                  // Only normal processors (resolve) catch and reject exceptions
3649                  process = special ? mightThrow : function () {
3650                    try {
3651                      mightThrow();
3652                    } catch (e) {
3653                      if (_jQuery2.Deferred.exceptionHook) {
3654                        _jQuery2.Deferred.exceptionHook(e, process.error);
3655                      }
3656
3657                      // Support: Promises/A+ section 2.3.3.3.4.1
3658                      // https://promisesaplus.com/#point-61
3659                      // Ignore post-resolution exceptions
3660                      if (depth + 1 >= maxDepth) {
3661                        // Only substitute handlers pass on context
3662                        // and multiple values (non-spec behavior)
3663                        if (handler !== Thrower) {
3664                          that = undefined;
3665                          args = [e];
3666                        }
3667                        deferred.rejectWith(that, args);
3668                      }
3669                    }
3670                  };
3671
3672                // Support: Promises/A+ section 2.3.3.3.1
3673                // https://promisesaplus.com/#point-57
3674                // Re-resolve promises immediately to dodge false rejection from
3675                // subsequent errors
3676                if (depth) {
3677                  process();
3678                } else {
3679                  // Call an optional hook to record the error, in case of exception
3680                  // since it's otherwise lost when execution goes async
3681                  if (_jQuery2.Deferred.getErrorHook) {
3682                    process.error = _jQuery2.Deferred.getErrorHook();
3683
3684                    // The deprecated alias of the above. While the name suggests
3685                    // returning the stack, not an error instance, jQuery just passes
3686                    // it directly to `console.warn` so both will work; an instance
3687                    // just better cooperates with source maps.
3688                  } else if (_jQuery2.Deferred.getStackHook) {
3689                    process.error = _jQuery2.Deferred.getStackHook();
3690                  }
3691                  window.setTimeout(process);
3692                }
3693              };
3694            }
3695            return _jQuery2.Deferred(function (newDefer) {
3696              // progress_handlers.add( ... )
3697              tuples[0][3].add(resolve(0, newDefer, isFunction(onProgress) ? onProgress : Identity, newDefer.notifyWith));
3698
3699              // fulfilled_handlers.add( ... )
3700              tuples[1][3].add(resolve(0, newDefer, isFunction(onFulfilled) ? onFulfilled : Identity));
3701
3702              // rejected_handlers.add( ... )
3703              tuples[2][3].add(resolve(0, newDefer, isFunction(onRejected) ? onRejected : Thrower));
3704            }).promise();
3705          },
3706          // Get a promise for this deferred
3707          // If obj is provided, the promise aspect is added to the object
3708          promise: function promise(obj) {
3709            return obj != null ? _jQuery2.extend(obj, _promise) : _promise;
3710          }
3711        },
3712        deferred = {};
3713
3714      // Add list-specific methods
3715      _jQuery2.each(tuples, function (i, tuple) {
3716        var list = tuple[2],
3717          stateString = tuple[5];
3718
3719        // promise.progress = list.add
3720        // promise.done = list.add
3721        // promise.fail = list.add
3722        _promise[tuple[1]] = list.add;
3723
3724        // Handle state
3725        if (stateString) {
3726          list.add(function () {
3727            // state = "resolved" (i.e., fulfilled)
3728            // state = "rejected"
3729            _state = stateString;
3730          },
3731          // rejected_callbacks.disable
3732          // fulfilled_callbacks.disable
3733          tuples[3 - i][2].disable,
3734          // rejected_handlers.disable
3735          // fulfilled_handlers.disable
3736          tuples[3 - i][3].disable,
3737          // progress_callbacks.lock
3738          tuples[0][2].lock,
3739          // progress_handlers.lock
3740          tuples[0][3].lock);
3741        }
3742
3743        // progress_handlers.fire
3744        // fulfilled_handlers.fire
3745        // rejected_handlers.fire
3746        list.add(tuple[3].fire);
3747
3748        // deferred.notify = function() { deferred.notifyWith(...) }
3749        // deferred.resolve = function() { deferred.resolveWith(...) }
3750        // deferred.reject = function() { deferred.rejectWith(...) }
3751        deferred[tuple[0]] = function () {
3752          deferred[tuple[0] + "With"](this === deferred ? undefined : this, arguments);
3753          return this;
3754        };
3755
3756        // deferred.notifyWith = list.fireWith
3757        // deferred.resolveWith = list.fireWith
3758        // deferred.rejectWith = list.fireWith
3759        deferred[tuple[0] + "With"] = list.fireWith;
3760      });
3761
3762      // Make the deferred a promise
3763      _promise.promise(deferred);
3764
3765      // Call given func if any
3766      if (func) {
3767        func.call(deferred, deferred);
3768      }
3769
3770      // All done!
3771      return deferred;
3772    },
3773    // Deferred helper
3774    when: function when(singleValue) {
3775      var
3776        // count of uncompleted subordinates
3777        remaining = arguments.length,
3778        // count of unprocessed arguments
3779        i = remaining,
3780        // subordinate fulfillment data
3781        resolveContexts = Array(i),
3782        resolveValues = _slice.call(arguments),
3783        // the primary Deferred
3784        primary = _jQuery2.Deferred(),
3785        // subordinate callback factory
3786        updateFunc = function updateFunc(i) {
3787          return function (value) {
3788            resolveContexts[i] = this;
3789            resolveValues[i] = arguments.length > 1 ? _slice.call(arguments) : value;
3790            if (! --remaining) {
3791              primary.resolveWith(resolveContexts, resolveValues);
3792            }
3793          };
3794        };
3795
3796      // Single- and empty arguments are adopted like Promise.resolve
3797      if (remaining <= 1) {
3798        adoptValue(singleValue, primary.done(updateFunc(i)).resolve, primary.reject, !remaining);
3799
3800        // Use .then() to unwrap secondary thenables (cf. gh-3000)
3801        if (primary.state() === "pending" || isFunction(resolveValues[i] && resolveValues[i].then)) {
3802          return primary.then();
3803        }
3804      }
3805
3806      // Multiple arguments are aggregated like Promise.all array elements
3807      while (i--) {
3808        adoptValue(resolveValues[i], updateFunc(i), primary.reject);
3809      }
3810      return primary.promise();
3811    }
3812  });
3813
3814  // These usually indicate a programmer mistake during development,
3815  // warn about them ASAP rather than swallowing them by default.
3816  var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
3817
3818  // If `jQuery.Deferred.getErrorHook` is defined, `asyncError` is an error
3819  // captured before the async barrier to get the original error cause
3820  // which may otherwise be hidden.
3821  _jQuery2.Deferred.exceptionHook = function (error, asyncError) {
3822    // Support: IE 8 - 9 only
3823    // Console exists when dev tools are open, which can happen at any time
3824    if (window.console && window.console.warn && error && rerrorNames.test(error.name)) {
3825      window.console.warn("jQuery.Deferred exception: " + error.message, error.stack, asyncError);
3826    }
3827  };
3828  _jQuery2.readyException = function (error) {
3829    window.setTimeout(function () {
3830      throw error;
3831    });
3832  };
3833
3834  // The deferred used on DOM ready
3835  var readyList = _jQuery2.Deferred();
3836  _jQuery2.fn.ready = function (fn) {
3837    readyList.then(fn)
3838
3839    // Wrap jQuery.readyException in a function so that the lookup
3840    // happens at the time of error handling instead of callback
3841    // registration.
3842    ["catch"](function (error) {
3843      _jQuery2.readyException(error);
3844    });
3845    return this;
3846  };
3847  _jQuery2.extend({
3848    // Is the DOM ready to be used? Set to true once it occurs.
3849    isReady: false,
3850    // A counter to track how many items to wait for before
3851    // the ready event fires. See trac-6781
3852    readyWait: 1,
3853    // Handle when the DOM is ready
3854    ready: function ready(wait) {
3855      // Abort if there are pending holds or we're already ready
3856      if (wait === true ? --_jQuery2.readyWait : _jQuery2.isReady) {
3857        return;
3858      }
3859
3860      // Remember that the DOM is ready
3861      _jQuery2.isReady = true;
3862
3863      // If a normal DOM Ready event fired, decrement, and wait if need be
3864      if (wait !== true && --_jQuery2.readyWait > 0) {
3865        return;
3866      }
3867
3868      // If there are functions bound, to execute
3869      readyList.resolveWith(document, [_jQuery2]);
3870    }
3871  });
3872  _jQuery2.ready.then = readyList.then;
3873
3874  // The ready event handler and self cleanup method
3875  function completed() {
3876    document.removeEventListener("DOMContentLoaded", completed);
3877    window.removeEventListener("load", completed);
3878    _jQuery2.ready();
3879  }
3880
3881  // Catch cases where $(document).ready() is called
3882  // after the browser event has already occurred.
3883  // Support: IE <=9 - 10 only
3884  // Older IE sometimes signals "interactive" too soon
3885  if (document.readyState === "complete" || document.readyState !== "loading" && !document.documentElement.doScroll) {
3886    // Handle it asynchronously to allow scripts the opportunity to delay ready
3887    window.setTimeout(_jQuery2.ready);
3888  } else {
3889    // Use the handy event callback
3890    document.addEventListener("DOMContentLoaded", completed);
3891
3892    // A fallback to window.onload, that will always work
3893    window.addEventListener("load", completed);
3894  }
3895
3896  // Multifunctional method to get and set values of a collection
3897  // The value/s can optionally be executed if it's a function
3898  var _access = function access(elems, fn, key, value, chainable, emptyGet, raw) {
3899    var i = 0,
3900      len = elems.length,
3901      bulk = key == null;
3902
3903    // Sets many values
3904    if (toType(key) === "object") {
3905      chainable = true;
3906      for (i in key) {
3907        _access(elems, fn, i, key[i], true, emptyGet, raw);
3908      }
3909
3910      // Sets one value
3911    } else if (value !== undefined) {
3912      chainable = true;
3913      if (!isFunction(value)) {
3914        raw = true;
3915      }
3916      if (bulk) {
3917        // Bulk operations run against the entire set
3918        if (raw) {
3919          fn.call(elems, value);
3920          fn = null;
3921
3922          // ...except when executing function values
3923        } else {
3924          bulk = fn;
3925          fn = function fn(elem, _key, value) {
3926            return bulk.call(_jQuery2(elem), value);
3927          };
3928        }
3929      }
3930      if (fn) {
3931        for (; i < len; i++) {
3932          fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key)));
3933        }
3934      }
3935    }
3936    if (chainable) {
3937      return elems;
3938    }
3939
3940    // Gets
3941    if (bulk) {
3942      return fn.call(elems);
3943    }
3944    return len ? fn(elems[0], key) : emptyGet;
3945  };
3946
3947  // Matches dashed string for camelizing
3948  var rmsPrefix = /^-ms-/,
3949    rdashAlpha = /-([a-z])/g;
3950
3951  // Used by camelCase as callback to replace()
3952  function fcamelCase(_all, letter) {
3953    return letter.toUpperCase();
3954  }
3955
3956  // Convert dashed to camelCase; used by the css and data modules
3957  // Support: IE <=9 - 11, Edge 12 - 15
3958  // Microsoft forgot to hump their vendor prefix (trac-9572)
3959  function camelCase(string) {
3960    return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
3961  }
3962  var acceptData = function acceptData(owner) {
3963    // Accepts only:
3964    //  - Node
3965    //    - Node.ELEMENT_NODE
3966    //    - Node.DOCUMENT_NODE
3967    //  - Object
3968    //    - Any
3969    return owner.nodeType === 1 || owner.nodeType === 9 || !+owner.nodeType;
3970  };
3971  function Data() {
3972    this.expando = _jQuery2.expando + Data.uid++;
3973  }
3974  Data.uid = 1;
3975  Data.prototype = {
3976    cache: function cache(owner) {
3977      // Check if the owner object already has a cache
3978      var value = owner[this.expando];
3979
3980      // If not, create one
3981      if (!value) {
3982        value = {};
3983
3984        // We can accept data for non-element nodes in modern browsers,
3985        // but we should not, see trac-8335.
3986        // Always return an empty object.
3987        if (acceptData(owner)) {
3988          // If it is a node unlikely to be stringify-ed or looped over
3989          // use plain assignment
3990          if (owner.nodeType) {
3991            owner[this.expando] = value;
3992
3993            // Otherwise secure it in a non-enumerable property
3994            // configurable must be true to allow the property to be
3995            // deleted when data is removed
3996          } else {
3997            Object.defineProperty(owner, this.expando, {
3998              value: value,
3999              configurable: true
4000            });
4001          }
4002        }
4003      }
4004      return value;
4005    },
4006    set: function set(owner, data, value) {
4007      var prop,
4008        cache = this.cache(owner);
4009
4010      // Handle: [ owner, key, value ] args
4011      // Always use camelCase key (gh-2257)
4012      if (typeof data === "string") {
4013        cache[camelCase(data)] = value;
4014
4015        // Handle: [ owner, { properties } ] args
4016      } else {
4017        // Copy the properties one-by-one to the cache object
4018        for (prop in data) {
4019          cache[camelCase(prop)] = data[prop];
4020        }
4021      }
4022      return cache;
4023    },
4024    get: function get(owner, key) {
4025      return key === undefined ? this.cache(owner) :
4026      // Always use camelCase key (gh-2257)
4027      owner[this.expando] && owner[this.expando][camelCase(key)];
4028    },
4029    access: function access(owner, key, value) {
4030      // In cases where either:
4031      //
4032      //   1. No key was specified
4033      //   2. A string key was specified, but no value provided
4034      //
4035      // Take the "read" path and allow the get method to determine
4036      // which value to return, respectively either:
4037      //
4038      //   1. The entire cache object
4039      //   2. The data stored at the key
4040      //
4041      if (key === undefined || key && typeof key === "string" && value === undefined) {
4042        return this.get(owner, key);
4043      }
4044
4045      // When the key is not a string, or both a key and value
4046      // are specified, set or extend (existing objects) with either:
4047      //
4048      //   1. An object of properties
4049      //   2. A key and value
4050      //
4051      this.set(owner, key, value);
4052
4053      // Since the "set" path can have two possible entry points
4054      // return the expected data based on which path was taken[*]
4055      return value !== undefined ? value : key;
4056    },
4057    remove: function remove(owner, key) {
4058      var i,
4059        cache = owner[this.expando];
4060      if (cache === undefined) {
4061        return;
4062      }
4063      if (key !== undefined) {
4064        // Support array or space separated string of keys
4065        if (Array.isArray(key)) {
4066          // If key is an array of keys...
4067          // We always set camelCase keys, so remove that.
4068          key = key.map(camelCase);
4069        } else {
4070          key = camelCase(key);
4071
4072          // If a key with the spaces exists, use it.
4073          // Otherwise, create an array by matching non-whitespace
4074          key = key in cache ? [key] : key.match(rnothtmlwhite) || [];
4075        }
4076        i = key.length;
4077        while (i--) {
4078          delete cache[key[i]];
4079        }
4080      }
4081
4082      // Remove the expando if there's no more data
4083      if (key === undefined || _jQuery2.isEmptyObject(cache)) {
4084        // Support: Chrome <=35 - 45
4085        // Webkit & Blink performance suffers when deleting properties
4086        // from DOM nodes, so set to undefined instead
4087        // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
4088        if (owner.nodeType) {
4089          owner[this.expando] = undefined;
4090        } else {
4091          delete owner[this.expando];
4092        }
4093      }
4094    },
4095    hasData: function hasData(owner) {
4096      var cache = owner[this.expando];
4097      return cache !== undefined && !_jQuery2.isEmptyObject(cache);
4098    }
4099  };
4100  var dataPriv = new Data();
4101  var dataUser = new Data();
4102
4103  //	Implementation Summary
4104  //
4105  //	1. Enforce API surface and semantic compatibility with 1.9.x branch
4106  //	2. Improve the module's maintainability by reducing the storage
4107  //		paths to a single mechanism.
4108  //	3. Use the same single mechanism to support "private" and "user" data.
4109  //	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
4110  //	5. Avoid exposing implementation details on user objects (eg. expando properties)
4111  //	6. Provide a clear path for implementation upgrade to WeakMap in 2014
4112
4113  var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
4114    rmultiDash = /[A-Z]/g;
4115  function getData(data) {
4116    if (data === "true") {
4117      return true;
4118    }
4119    if (data === "false") {
4120      return false;
4121    }
4122    if (data === "null") {
4123      return null;
4124    }
4125
4126    // Only convert to a number if it doesn't change the string
4127    if (data === +data + "") {
4128      return +data;
4129    }
4130    if (rbrace.test(data)) {
4131      return JSON.parse(data);
4132    }
4133    return data;
4134  }
4135  function dataAttr(elem, key, data) {
4136    var name;
4137
4138    // If nothing was found internally, try to fetch any
4139    // data from the HTML5 data-* attribute
4140    if (data === undefined && elem.nodeType === 1) {
4141      name = "data-" + key.replace(rmultiDash, "-$&").toLowerCase();
4142      data = elem.getAttribute(name);
4143      if (typeof data === "string") {
4144        try {
4145          data = getData(data);
4146        } catch (e) {}
4147
4148        // Make sure we set the data so it isn't changed later
4149        dataUser.set(elem, key, data);
4150      } else {
4151        data = undefined;
4152      }
4153    }
4154    return data;
4155  }
4156  _jQuery2.extend({
4157    hasData: function hasData(elem) {
4158      return dataUser.hasData(elem) || dataPriv.hasData(elem);
4159    },
4160    data: function data(elem, name, _data) {
4161      return dataUser.access(elem, name, _data);
4162    },
4163    removeData: function removeData(elem, name) {
4164      dataUser.remove(elem, name);
4165    },
4166    // TODO: Now that all calls to _data and _removeData have been replaced
4167    // with direct calls to dataPriv methods, these can be deprecated.
4168    _data: function _data(elem, name, data) {
4169      return dataPriv.access(elem, name, data);
4170    },
4171    _removeData: function _removeData(elem, name) {
4172      dataPriv.remove(elem, name);
4173    }
4174  });
4175  _jQuery2.fn.extend({
4176    data: function data(key, value) {
4177      var i,
4178        name,
4179        data,
4180        elem = this[0],
4181        attrs = elem && elem.attributes;
4182
4183      // Gets all values
4184      if (key === undefined) {
4185        if (this.length) {
4186          data = dataUser.get(elem);
4187          if (elem.nodeType === 1 && !dataPriv.get(elem, "hasDataAttrs")) {
4188            i = attrs.length;
4189            while (i--) {
4190              // Support: IE 11 only
4191              // The attrs elements can be null (trac-14894)
4192              if (attrs[i]) {
4193                name = attrs[i].name;
4194                if (name.indexOf("data-") === 0) {
4195                  name = camelCase(name.slice(5));
4196                  dataAttr(elem, name, data[name]);
4197                }
4198              }
4199            }
4200            dataPriv.set(elem, "hasDataAttrs", true);
4201          }
4202        }
4203        return data;
4204      }
4205
4206      // Sets multiple values
4207      if (_typeof(key) === "object") {
4208        return this.each(function () {
4209          dataUser.set(this, key);
4210        });
4211      }
4212      return _access(this, function (value) {
4213        var data;
4214
4215        // The calling jQuery object (element matches) is not empty
4216        // (and therefore has an element appears at this[ 0 ]) and the
4217        // `value` parameter was not undefined. An empty jQuery object
4218        // will result in `undefined` for elem = this[ 0 ] which will
4219        // throw an exception if an attempt to read a data cache is made.
4220        if (elem && value === undefined) {
4221          // Attempt to get data from the cache
4222          // The key will always be camelCased in Data
4223          data = dataUser.get(elem, key);
4224          if (data !== undefined) {
4225            return data;
4226          }
4227
4228          // Attempt to "discover" the data in
4229          // HTML5 custom data-* attrs
4230          data = dataAttr(elem, key);
4231          if (data !== undefined) {
4232            return data;
4233          }
4234
4235          // We tried really hard, but the data doesn't exist.
4236          return;
4237        }
4238
4239        // Set the data...
4240        this.each(function () {
4241          // We always store the camelCased key
4242          dataUser.set(this, key, value);
4243        });
4244      }, null, value, arguments.length > 1, null, true);
4245    },
4246    removeData: function removeData(key) {
4247      return this.each(function () {
4248        dataUser.remove(this, key);
4249      });
4250    }
4251  });
4252  _jQuery2.extend({
4253    queue: function queue(elem, type, data) {
4254      var queue;
4255      if (elem) {
4256        type = (type || "fx") + "queue";
4257        queue = dataPriv.get(elem, type);
4258
4259        // Speed up dequeue by getting out quickly if this is just a lookup
4260        if (data) {
4261          if (!queue || Array.isArray(data)) {
4262            queue = dataPriv.access(elem, type, _jQuery2.makeArray(data));
4263          } else {
4264            queue.push(data);
4265          }
4266        }
4267        return queue || [];
4268      }
4269    },
4270    dequeue: function dequeue(elem, type) {
4271      type = type || "fx";
4272      var queue = _jQuery2.queue(elem, type),
4273        startLength = queue.length,
4274        fn = queue.shift(),
4275        hooks = _jQuery2._queueHooks(elem, type),
4276        next = function next() {
4277          _jQuery2.dequeue(elem, type);
4278        };
4279
4280      // If the fx queue is dequeued, always remove the progress sentinel
4281      if (fn === "inprogress") {
4282        fn = queue.shift();
4283        startLength--;
4284      }
4285      if (fn) {
4286        // Add a progress sentinel to prevent the fx queue from being
4287        // automatically dequeued
4288        if (type === "fx") {
4289          queue.unshift("inprogress");
4290        }
4291
4292        // Clear up the last queue stop function
4293        delete hooks.stop;
4294        fn.call(elem, next, hooks);
4295      }
4296      if (!startLength && hooks) {
4297        hooks.empty.fire();
4298      }
4299    },
4300    // Not public - generate a queueHooks object, or return the current one
4301    _queueHooks: function _queueHooks(elem, type) {
4302      var key = type + "queueHooks";
4303      return dataPriv.get(elem, key) || dataPriv.access(elem, key, {
4304        empty: _jQuery2.Callbacks("once memory").add(function () {
4305          dataPriv.remove(elem, [type + "queue", key]);
4306        })
4307      });
4308    }
4309  });
4310  _jQuery2.fn.extend({
4311    queue: function queue(type, data) {
4312      var setter = 2;
4313      if (typeof type !== "string") {
4314        data = type;
4315        type = "fx";
4316        setter--;
4317      }
4318      if (arguments.length < setter) {
4319        return _jQuery2.queue(this[0], type);
4320      }
4321      return data === undefined ? this : this.each(function () {
4322        var queue = _jQuery2.queue(this, type, data);
4323
4324        // Ensure a hooks for this queue
4325        _jQuery2._queueHooks(this, type);
4326        if (type === "fx" && queue[0] !== "inprogress") {
4327          _jQuery2.dequeue(this, type);
4328        }
4329      });
4330    },
4331    dequeue: function dequeue(type) {
4332      return this.each(function () {
4333        _jQuery2.dequeue(this, type);
4334      });
4335    },
4336    clearQueue: function clearQueue(type) {
4337      return this.queue(type || "fx", []);
4338    },
4339    // Get a promise resolved when queues of a certain type
4340    // are emptied (fx is the type by default)
4341    promise: function promise(type, obj) {
4342      var tmp,
4343        count = 1,
4344        defer = _jQuery2.Deferred(),
4345        elements = this,
4346        i = this.length,
4347        resolve = function resolve() {
4348          if (! --count) {
4349            defer.resolveWith(elements, [elements]);
4350          }
4351        };
4352      if (typeof type !== "string") {
4353        obj = type;
4354        type = undefined;
4355      }
4356      type = type || "fx";
4357      while (i--) {
4358        tmp = dataPriv.get(elements[i], type + "queueHooks");
4359        if (tmp && tmp.empty) {
4360          count++;
4361          tmp.empty.add(resolve);
4362        }
4363      }
4364      resolve();
4365      return defer.promise(obj);
4366    }
4367  });
4368  var pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source;
4369  var rcssNum = new RegExp("^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i");
4370  var cssExpand = ["Top", "Right", "Bottom", "Left"];
4371  var documentElement = document.documentElement;
4372  var isAttached = function isAttached(elem) {
4373      return _jQuery2.contains(elem.ownerDocument, elem);
4374    },
4375    composed = {
4376      composed: true
4377    };
4378
4379  // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only
4380  // Check attachment across shadow DOM boundaries when possible (gh-3504)
4381  // Support: iOS 10.0-10.2 only
4382  // Early iOS 10 versions support `attachShadow` but not `getRootNode`,
4383  // leading to errors. We need to check for `getRootNode`.
4384  if (documentElement.getRootNode) {
4385    isAttached = function isAttached(elem) {
4386      return _jQuery2.contains(elem.ownerDocument, elem) || elem.getRootNode(composed) === elem.ownerDocument;
4387    };
4388  }
4389  var isHiddenWithinTree = function isHiddenWithinTree(elem, el) {
4390    // isHiddenWithinTree might be called from jQuery#filter function;
4391    // in that case, element will be second argument
4392    elem = el || elem;
4393
4394    // Inline style trumps all
4395    return elem.style.display === "none" || elem.style.display === "" &&
4396    // Otherwise, check computed style
4397    // Support: Firefox <=43 - 45
4398    // Disconnected elements can have computed display: none, so first confirm that elem is
4399    // in the document.
4400    isAttached(elem) && _jQuery2.css(elem, "display") === "none";
4401  };
4402  function adjustCSS(elem, prop, valueParts, tween) {
4403    var adjusted,
4404      scale,
4405      maxIterations = 20,
4406      currentValue = tween ? function () {
4407        return tween.cur();
4408      } : function () {
4409        return _jQuery2.css(elem, prop, "");
4410      },
4411      initial = currentValue(),
4412      unit = valueParts && valueParts[3] || (_jQuery2.cssNumber[prop] ? "" : "px"),
4413      // Starting value computation is required for potential unit mismatches
4414      initialInUnit = elem.nodeType && (_jQuery2.cssNumber[prop] || unit !== "px" && +initial) && rcssNum.exec(_jQuery2.css(elem, prop));
4415    if (initialInUnit && initialInUnit[3] !== unit) {
4416      // Support: Firefox <=54
4417      // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)
4418      initial = initial / 2;
4419
4420      // Trust units reported by jQuery.css
4421      unit = unit || initialInUnit[3];
4422
4423      // Iteratively approximate from a nonzero starting point
4424      initialInUnit = +initial || 1;
4425      while (maxIterations--) {
4426        // Evaluate and update our best guess (doubling guesses that zero out).
4427        // Finish if the scale equals or crosses 1 (making the old*new product non-positive).
4428        _jQuery2.style(elem, prop, initialInUnit + unit);
4429        if ((1 - scale) * (1 - (scale = currentValue() / initial || 0.5)) <= 0) {
4430          maxIterations = 0;
4431        }
4432        initialInUnit = initialInUnit / scale;
4433      }
4434      initialInUnit = initialInUnit * 2;
4435      _jQuery2.style(elem, prop, initialInUnit + unit);
4436
4437      // Make sure we update the tween properties later on
4438      valueParts = valueParts || [];
4439    }
4440    if (valueParts) {
4441      initialInUnit = +initialInUnit || +initial || 0;
4442
4443      // Apply relative offset (+=/-=) if specified
4444      adjusted = valueParts[1] ? initialInUnit + (valueParts[1] + 1) * valueParts[2] : +valueParts[2];
4445      if (tween) {
4446        tween.unit = unit;
4447        tween.start = initialInUnit;
4448        tween.end = adjusted;
4449      }
4450    }
4451    return adjusted;
4452  }
4453  var defaultDisplayMap = {};
4454  function getDefaultDisplay(elem) {
4455    var temp,
4456      doc = elem.ownerDocument,
4457      nodeName = elem.nodeName,
4458      display = defaultDisplayMap[nodeName];
4459    if (display) {
4460      return display;
4461    }
4462    temp = doc.body.appendChild(doc.createElement(nodeName));
4463    display = _jQuery2.css(temp, "display");
4464    temp.parentNode.removeChild(temp);
4465    if (display === "none") {
4466      display = "block";
4467    }
4468    defaultDisplayMap[nodeName] = display;
4469    return display;
4470  }
4471  function showHide(elements, show) {
4472    var display,
4473      elem,
4474      values = [],
4475      index = 0,
4476      length = elements.length;
4477
4478    // Determine new display value for elements that need to change
4479    for (; index < length; index++) {
4480      elem = elements[index];
4481      if (!elem.style) {
4482        continue;
4483      }
4484      display = elem.style.display;
4485      if (show) {
4486        // Since we force visibility upon cascade-hidden elements, an immediate (and slow)
4487        // check is required in this first loop unless we have a nonempty display value (either
4488        // inline or about-to-be-restored)
4489        if (display === "none") {
4490          values[index] = dataPriv.get(elem, "display") || null;
4491          if (!values[index]) {
4492            elem.style.display = "";
4493          }
4494        }
4495        if (elem.style.display === "" && isHiddenWithinTree(elem)) {
4496          values[index] = getDefaultDisplay(elem);
4497        }
4498      } else {
4499        if (display !== "none") {
4500          values[index] = "none";
4501
4502          // Remember what we're overwriting
4503          dataPriv.set(elem, "display", display);
4504        }
4505      }
4506    }
4507
4508    // Set the display of the elements in a second loop to avoid constant reflow
4509    for (index = 0; index < length; index++) {
4510      if (values[index] != null) {
4511        elements[index].style.display = values[index];
4512      }
4513    }
4514    return elements;
4515  }
4516  _jQuery2.fn.extend({
4517    show: function show() {
4518      return showHide(this, true);
4519    },
4520    hide: function hide() {
4521      return showHide(this);
4522    },
4523    toggle: function toggle(state) {
4524      if (typeof state === "boolean") {
4525        return state ? this.show() : this.hide();
4526      }
4527      return this.each(function () {
4528        if (isHiddenWithinTree(this)) {
4529          _jQuery2(this).show();
4530        } else {
4531          _jQuery2(this).hide();
4532        }
4533      });
4534    }
4535  });
4536  var rcheckableType = /^(?:checkbox|radio)$/i;
4537  var rtagName = /<([a-z][^\/\0>\x20\t\r\n\f]*)/i;
4538  var rscriptType = /^$|^module$|\/(?:java|ecma)script/i;
4539  (function () {
4540    var fragment = document.createDocumentFragment(),
4541      div = fragment.appendChild(document.createElement("div")),
4542      input = document.createElement("input");
4543
4544    // Support: Android 4.0 - 4.3 only
4545    // Check state lost if the name is set (trac-11217)
4546    // Support: Windows Web Apps (WWA)
4547    // `name` and `type` must use .setAttribute for WWA (trac-14901)
4548    input.setAttribute("type", "radio");
4549    input.setAttribute("checked", "checked");
4550    input.setAttribute("name", "t");
4551    div.appendChild(input);
4552
4553    // Support: Android <=4.1 only
4554    // Older WebKit doesn't clone checked state correctly in fragments
4555    support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked;
4556
4557    // Support: IE <=11 only
4558    // Make sure textarea (and checkbox) defaultValue is properly cloned
4559    div.innerHTML = "<textarea>x</textarea>";
4560    support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue;
4561
4562    // Support: IE <=9 only
4563    // IE <=9 replaces <option> tags with their contents when inserted outside of
4564    // the select element.
4565    div.innerHTML = "<option></option>";
4566    support.option = !!div.lastChild;
4567  })();
4568
4569  // We have to close these tags to support XHTML (trac-13200)
4570  var wrapMap = {
4571    // XHTML parsers do not magically insert elements in the
4572    // same way that tag soup parsers do. So we cannot shorten
4573    // this by omitting <tbody> or other required elements.
4574    thead: [1, "<table>", "</table>"],
4575    col: [2, "<table><colgroup>", "</colgroup></table>"],
4576    tr: [2, "<table><tbody>", "</tbody></table>"],
4577    td: [3, "<table><tbody><tr>", "</tr></tbody></table>"],
4578    _default: [0, "", ""]
4579  };
4580  wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
4581  wrapMap.th = wrapMap.td;
4582
4583  // Support: IE <=9 only
4584  if (!support.option) {
4585    wrapMap.optgroup = wrapMap.option = [1, "<select multiple='multiple'>", "</select>"];
4586  }
4587  function getAll(context, tag) {
4588    // Support: IE <=9 - 11 only
4589    // Use typeof to avoid zero-argument method invocation on host objects (trac-15151)
4590    var ret;
4591    if (typeof context.getElementsByTagName !== "undefined") {
4592      ret = context.getElementsByTagName(tag || "*");
4593    } else if (typeof context.querySelectorAll !== "undefined") {
4594      ret = context.querySelectorAll(tag || "*");
4595    } else {
4596      ret = [];
4597    }
4598    if (tag === undefined || tag && nodeName(context, tag)) {
4599      return _jQuery2.merge([context], ret);
4600    }
4601    return ret;
4602  }
4603
4604  // Mark scripts as having already been evaluated
4605  function setGlobalEval(elems, refElements) {
4606    var i = 0,
4607      l = elems.length;
4608    for (; i < l; i++) {
4609      dataPriv.set(elems[i], "globalEval", !refElements || dataPriv.get(refElements[i], "globalEval"));
4610    }
4611  }
4612  var rhtml = /<|&#?\w+;/;
4613  function buildFragment(elems, context, scripts, selection, ignored) {
4614    var elem,
4615      tmp,
4616      tag,
4617      wrap,
4618      attached,
4619      j,
4620      fragment = context.createDocumentFragment(),
4621      nodes = [],
4622      i = 0,
4623      l = elems.length;
4624    for (; i < l; i++) {
4625      elem = elems[i];
4626      if (elem || elem === 0) {
4627        // Add nodes directly
4628        if (toType(elem) === "object") {
4629          // Support: Android <=4.0 only, PhantomJS 1 only
4630          // push.apply(_, arraylike) throws on ancient WebKit
4631          _jQuery2.merge(nodes, elem.nodeType ? [elem] : elem);
4632
4633          // Convert non-html into a text node
4634        } else if (!rhtml.test(elem)) {
4635          nodes.push(context.createTextNode(elem));
4636
4637          // Convert html into DOM nodes
4638        } else {
4639          tmp = tmp || fragment.appendChild(context.createElement("div"));
4640
4641          // Deserialize a standard representation
4642          tag = (rtagName.exec(elem) || ["", ""])[1].toLowerCase();
4643          wrap = wrapMap[tag] || wrapMap._default;
4644          tmp.innerHTML = wrap[1] + _jQuery2.htmlPrefilter(elem) + wrap[2];
4645
4646          // Descend through wrappers to the right content
4647          j = wrap[0];
4648          while (j--) {
4649            tmp = tmp.lastChild;
4650          }
4651
4652          // Support: Android <=4.0 only, PhantomJS 1 only
4653          // push.apply(_, arraylike) throws on ancient WebKit
4654          _jQuery2.merge(nodes, tmp.childNodes);
4655
4656          // Remember the top-level container
4657          tmp = fragment.firstChild;
4658
4659          // Ensure the created nodes are orphaned (trac-12392)
4660          tmp.textContent = "";
4661        }
4662      }
4663    }
4664
4665    // Remove wrapper from fragment
4666    fragment.textContent = "";
4667    i = 0;
4668    while (elem = nodes[i++]) {
4669      // Skip elements already in the context collection (trac-4087)
4670      if (selection && _jQuery2.inArray(elem, selection) > -1) {
4671        if (ignored) {
4672          ignored.push(elem);
4673        }
4674        continue;
4675      }
4676      attached = isAttached(elem);
4677
4678      // Append to fragment
4679      tmp = getAll(fragment.appendChild(elem), "script");
4680
4681      // Preserve script evaluation history
4682      if (attached) {
4683        setGlobalEval(tmp);
4684      }
4685
4686      // Capture executables
4687      if (scripts) {
4688        j = 0;
4689        while (elem = tmp[j++]) {
4690          if (rscriptType.test(elem.type || "")) {
4691            scripts.push(elem);
4692          }
4693        }
4694      }
4695    }
4696    return fragment;
4697  }
4698  var rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
4699  function returnTrue() {
4700    return true;
4701  }
4702  function returnFalse() {
4703    return false;
4704  }
4705  function _on(elem, types, selector, data, fn, one) {
4706    var origFn, type;
4707
4708    // Types can be a map of types/handlers
4709    if (_typeof(types) === "object") {
4710      // ( types-Object, selector, data )
4711      if (typeof selector !== "string") {
4712        // ( types-Object, data )
4713        data = data || selector;
4714        selector = undefined;
4715      }
4716      for (type in types) {
4717        _on(elem, type, selector, data, types[type], one);
4718      }
4719      return elem;
4720    }
4721    if (data == null && fn == null) {
4722      // ( types, fn )
4723      fn = selector;
4724      data = selector = undefined;
4725    } else if (fn == null) {
4726      if (typeof selector === "string") {
4727        // ( types, selector, fn )
4728        fn = data;
4729        data = undefined;
4730      } else {
4731        // ( types, data, fn )
4732        fn = data;
4733        data = selector;
4734        selector = undefined;
4735      }
4736    }
4737    if (fn === false) {
4738      fn = returnFalse;
4739    } else if (!fn) {
4740      return elem;
4741    }
4742    if (one === 1) {
4743      origFn = fn;
4744      fn = function fn(event) {
4745        // Can use an empty set, since event contains the info
4746        _jQuery2().off(event);
4747        return origFn.apply(this, arguments);
4748      };
4749
4750      // Use same guid so caller can remove using origFn
4751      fn.guid = origFn.guid || (origFn.guid = _jQuery2.guid++);
4752    }
4753    return elem.each(function () {
4754      _jQuery2.event.add(this, types, fn, data, selector);
4755    });
4756  }
4757
4758  /*
4759   * Helper functions for managing events -- not part of the public interface.
4760   * Props to Dean Edwards' addEvent library for many of the ideas.
4761   */
4762  _jQuery2.event = {
4763    global: {},
4764    add: function add(elem, types, handler, data, selector) {
4765      var handleObjIn,
4766        eventHandle,
4767        tmp,
4768        events,
4769        t,
4770        handleObj,
4771        special,
4772        handlers,
4773        type,
4774        namespaces,
4775        origType,
4776        elemData = dataPriv.get(elem);
4777
4778      // Only attach events to objects that accept data
4779      if (!acceptData(elem)) {
4780        return;
4781      }
4782
4783      // Caller can pass in an object of custom data in lieu of the handler
4784      if (handler.handler) {
4785        handleObjIn = handler;
4786        handler = handleObjIn.handler;
4787        selector = handleObjIn.selector;
4788      }
4789
4790      // Ensure that invalid selectors throw exceptions at attach time
4791      // Evaluate against documentElement in case elem is a non-element node (e.g., document)
4792      if (selector) {
4793        _jQuery2.find.matchesSelector(documentElement, selector);
4794      }
4795
4796      // Make sure that the handler has a unique ID, used to find/remove it later
4797      if (!handler.guid) {
4798        handler.guid = _jQuery2.guid++;
4799      }
4800
4801      // Init the element's event structure and main handler, if this is the first
4802      if (!(events = elemData.events)) {
4803        events = elemData.events = Object.create(null);
4804      }
4805      if (!(eventHandle = elemData.handle)) {
4806        eventHandle = elemData.handle = function (e) {
4807          // Discard the second event of a jQuery.event.trigger() and
4808          // when an event is called after a page has unloaded
4809          return typeof _jQuery2 !== "undefined" && _jQuery2.event.triggered !== e.type ? _jQuery2.event.dispatch.apply(elem, arguments) : undefined;
4810        };
4811      }
4812
4813      // Handle multiple events separated by a space
4814      types = (types || "").match(rnothtmlwhite) || [""];
4815      t = types.length;
4816      while (t--) {
4817        tmp = rtypenamespace.exec(types[t]) || [];
4818        type = origType = tmp[1];
4819        namespaces = (tmp[2] || "").split(".").sort();
4820
4821        // There *must* be a type, no attaching namespace-only handlers
4822        if (!type) {
4823          continue;
4824        }
4825
4826        // If event changes its type, use the special event handlers for the changed type
4827        special = _jQuery2.event.special[type] || {};
4828
4829        // If selector defined, determine special event api type, otherwise given type
4830        type = (selector ? special.delegateType : special.bindType) || type;
4831
4832        // Update special based on newly reset type
4833        special = _jQuery2.event.special[type] || {};
4834
4835        // handleObj is passed to all event handlers
4836        handleObj = _jQuery2.extend({
4837          type: type,
4838          origType: origType,
4839          data: data,
4840          handler: handler,
4841          guid: handler.guid,
4842          selector: selector,
4843          needsContext: selector && _jQuery2.expr.match.needsContext.test(selector),
4844          namespace: namespaces.join(".")
4845        }, handleObjIn);
4846
4847        // Init the event handler queue if we're the first
4848        if (!(handlers = events[type])) {
4849          handlers = events[type] = [];
4850          handlers.delegateCount = 0;
4851
4852          // Only use addEventListener if the special events handler returns false
4853          if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false) {
4854            if (elem.addEventListener) {
4855              elem.addEventListener(type, eventHandle);
4856            }
4857          }
4858        }
4859        if (special.add) {
4860          special.add.call(elem, handleObj);
4861          if (!handleObj.handler.guid) {
4862            handleObj.handler.guid = handler.guid;
4863          }
4864        }
4865
4866        // Add to the element's handler list, delegates in front
4867        if (selector) {
4868          handlers.splice(handlers.delegateCount++, 0, handleObj);
4869        } else {
4870          handlers.push(handleObj);
4871        }
4872
4873        // Keep track of which events have ever been used, for event optimization
4874        _jQuery2.event.global[type] = true;
4875      }
4876    },
4877    // Detach an event or set of events from an element
4878    remove: function remove(elem, types, handler, selector, mappedTypes) {
4879      var j,
4880        origCount,
4881        tmp,
4882        events,
4883        t,
4884        handleObj,
4885        special,
4886        handlers,
4887        type,
4888        namespaces,
4889        origType,
4890        elemData = dataPriv.hasData(elem) && dataPriv.get(elem);
4891      if (!elemData || !(events = elemData.events)) {
4892        return;
4893      }
4894
4895      // Once for each type.namespace in types; type may be omitted
4896      types = (types || "").match(rnothtmlwhite) || [""];
4897      t = types.length;
4898      while (t--) {
4899        tmp = rtypenamespace.exec(types[t]) || [];
4900        type = origType = tmp[1];
4901        namespaces = (tmp[2] || "").split(".").sort();
4902
4903        // Unbind all events (on this namespace, if provided) for the element
4904        if (!type) {
4905          for (type in events) {
4906            _jQuery2.event.remove(elem, type + types[t], handler, selector, true);
4907          }
4908          continue;
4909        }
4910        special = _jQuery2.event.special[type] || {};
4911        type = (selector ? special.delegateType : special.bindType) || type;
4912        handlers = events[type] || [];
4913        tmp = tmp[2] && new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)");
4914
4915        // Remove matching events
4916        origCount = j = handlers.length;
4917        while (j--) {
4918          handleObj = handlers[j];
4919          if ((mappedTypes || origType === handleObj.origType) && (!handler || handler.guid === handleObj.guid) && (!tmp || tmp.test(handleObj.namespace)) && (!selector || selector === handleObj.selector || selector === "**" && handleObj.selector)) {
4920            handlers.splice(j, 1);
4921            if (handleObj.selector) {
4922              handlers.delegateCount--;
4923            }
4924            if (special.remove) {
4925              special.remove.call(elem, handleObj);
4926            }
4927          }
4928        }
4929
4930        // Remove generic event handler if we removed something and no more handlers exist
4931        // (avoids potential for endless recursion during removal of special event handlers)
4932        if (origCount && !handlers.length) {
4933          if (!special.teardown || special.teardown.call(elem, namespaces, elemData.handle) === false) {
4934            _jQuery2.removeEvent(elem, type, elemData.handle);
4935          }
4936          delete events[type];
4937        }
4938      }
4939
4940      // Remove data and the expando if it's no longer used
4941      if (_jQuery2.isEmptyObject(events)) {
4942        dataPriv.remove(elem, "handle events");
4943      }
4944    },
4945    dispatch: function dispatch(nativeEvent) {
4946      var i,
4947        j,
4948        ret,
4949        matched,
4950        handleObj,
4951        handlerQueue,
4952        args = new Array(arguments.length),
4953        // Make a writable jQuery.Event from the native event object
4954        event = _jQuery2.event.fix(nativeEvent),
4955        handlers = (dataPriv.get(this, "events") || Object.create(null))[event.type] || [],
4956        special = _jQuery2.event.special[event.type] || {};
4957
4958      // Use the fix-ed jQuery.Event rather than the (read-only) native event
4959      args[0] = event;
4960      for (i = 1; i < arguments.length; i++) {
4961        args[i] = arguments[i];
4962      }
4963      event.delegateTarget = this;
4964
4965      // Call the preDispatch hook for the mapped type, and let it bail if desired
4966      if (special.preDispatch && special.preDispatch.call(this, event) === false) {
4967        return;
4968      }
4969
4970      // Determine handlers
4971      handlerQueue = _jQuery2.event.handlers.call(this, event, handlers);
4972
4973      // Run delegates first; they may want to stop propagation beneath us
4974      i = 0;
4975      while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) {
4976        event.currentTarget = matched.elem;
4977        j = 0;
4978        while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) {
4979          // If the event is namespaced, then each handler is only invoked if it is
4980          // specially universal or its namespaces are a superset of the event's.
4981          if (!event.rnamespace || handleObj.namespace === false || event.rnamespace.test(handleObj.namespace)) {
4982            event.handleObj = handleObj;
4983            event.data = handleObj.data;
4984            ret = ((_jQuery2.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args);
4985            if (ret !== undefined) {
4986              if ((event.result = ret) === false) {
4987                event.preventDefault();
4988                event.stopPropagation();
4989              }
4990            }
4991          }
4992        }
4993      }
4994
4995      // Call the postDispatch hook for the mapped type
4996      if (special.postDispatch) {
4997        special.postDispatch.call(this, event);
4998      }
4999      return event.result;
5000    },
5001    handlers: function handlers(event, _handlers) {
5002      var i,
5003        handleObj,
5004        sel,
5005        matchedHandlers,
5006        matchedSelectors,
5007        handlerQueue = [],
5008        delegateCount = _handlers.delegateCount,
5009        cur = event.target;
5010
5011      // Find delegate handlers
5012      if (delegateCount &&
5013      // Support: IE <=9
5014      // Black-hole SVG <use> instance trees (trac-13180)
5015      cur.nodeType &&
5016      // Support: Firefox <=42
5017      // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
5018      // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
5019      // Support: IE 11 only
5020      // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
5021      !(event.type === "click" && event.button >= 1)) {
5022        for (; cur !== this; cur = cur.parentNode || this) {
5023          // Don't check non-elements (trac-13208)
5024          // Don't process clicks on disabled elements (trac-6911, trac-8165, trac-11382, trac-11764)
5025          if (cur.nodeType === 1 && !(event.type === "click" && cur.disabled === true)) {
5026            matchedHandlers = [];
5027            matchedSelectors = {};
5028            for (i = 0; i < delegateCount; i++) {
5029              handleObj = _handlers[i];
5030
5031              // Don't conflict with Object.prototype properties (trac-13203)
5032              sel = handleObj.selector + " ";
5033              if (matchedSelectors[sel] === undefined) {
5034                matchedSelectors[sel] = handleObj.needsContext ? _jQuery2(sel, this).index(cur) > -1 : _jQuery2.find(sel, this, null, [cur]).length;
5035              }
5036              if (matchedSelectors[sel]) {
5037                matchedHandlers.push(handleObj);
5038              }
5039            }
5040            if (matchedHandlers.length) {
5041              handlerQueue.push({
5042                elem: cur,
5043                handlers: matchedHandlers
5044              });
5045            }
5046          }
5047        }
5048      }
5049
5050      // Add the remaining (directly-bound) handlers
5051      cur = this;
5052      if (delegateCount < _handlers.length) {
5053        handlerQueue.push({
5054          elem: cur,
5055          handlers: _handlers.slice(delegateCount)
5056        });
5057      }
5058      return handlerQueue;
5059    },
5060    addProp: function addProp(name, hook) {
5061      Object.defineProperty(_jQuery2.Event.prototype, name, {
5062        enumerable: true,
5063        configurable: true,
5064        get: isFunction(hook) ? function () {
5065          if (this.originalEvent) {
5066            return hook(this.originalEvent);
5067          }
5068        } : function () {
5069          if (this.originalEvent) {
5070            return this.originalEvent[name];
5071          }
5072        },
5073        set: function set(value) {
5074          Object.defineProperty(this, name, {
5075            enumerable: true,
5076            configurable: true,
5077            writable: true,
5078            value: value
5079          });
5080        }
5081      });
5082    },
5083    fix: function fix(originalEvent) {
5084      return originalEvent[_jQuery2.expando] ? originalEvent : new _jQuery2.Event(originalEvent);
5085    },
5086    special: {
5087      load: {
5088        // Prevent triggered image.load events from bubbling to window.load
5089        noBubble: true
5090      },
5091      click: {
5092        // Utilize native event to ensure correct state for checkable inputs
5093        setup: function setup(data) {
5094          // For mutual compressibility with _default, replace `this` access with a local var.
5095          // `|| data` is dead code meant only to preserve the variable through minification.
5096          var el = this || data;
5097
5098          // Claim the first handler
5099          if (rcheckableType.test(el.type) && el.click && nodeName(el, "input")) {
5100            // dataPriv.set( el, "click", ... )
5101            leverageNative(el, "click", true);
5102          }
5103
5104          // Return false to allow normal processing in the caller
5105          return false;
5106        },
5107        trigger: function trigger(data) {
5108          // For mutual compressibility with _default, replace `this` access with a local var.
5109          // `|| data` is dead code meant only to preserve the variable through minification.
5110          var el = this || data;
5111
5112          // Force setup before triggering a click
5113          if (rcheckableType.test(el.type) && el.click && nodeName(el, "input")) {
5114            leverageNative(el, "click");
5115          }
5116
5117          // Return non-false to allow normal event-path propagation
5118          return true;
5119        },
5120        // For cross-browser consistency, suppress native .click() on links
5121        // Also prevent it if we're currently inside a leveraged native-event stack
5122        _default: function _default(event) {
5123          var target = event.target;
5124          return rcheckableType.test(target.type) && target.click && nodeName(target, "input") && dataPriv.get(target, "click") || nodeName(target, "a");
5125        }
5126      },
5127      beforeunload: {
5128        postDispatch: function postDispatch(event) {
5129          // Support: Firefox 20+
5130          // Firefox doesn't alert if the returnValue field is not set.
5131          if (event.result !== undefined && event.originalEvent) {
5132            event.originalEvent.returnValue = event.result;
5133          }
5134        }
5135      }
5136    }
5137  };
5138
5139  // Ensure the presence of an event listener that handles manually-triggered
5140  // synthetic events by interrupting progress until reinvoked in response to
5141  // *native* events that it fires directly, ensuring that state changes have
5142  // already occurred before other listeners are invoked.
5143  function leverageNative(el, type, isSetup) {
5144    // Missing `isSetup` indicates a trigger call, which must force setup through jQuery.event.add
5145    if (!isSetup) {
5146      if (dataPriv.get(el, type) === undefined) {
5147        _jQuery2.event.add(el, type, returnTrue);
5148      }
5149      return;
5150    }
5151
5152    // Register the controller as a special universal handler for all event namespaces
5153    dataPriv.set(el, type, false);
5154    _jQuery2.event.add(el, type, {
5155      namespace: false,
5156      handler: function handler(event) {
5157        var result,
5158          saved = dataPriv.get(this, type);
5159        if (event.isTrigger & 1 && this[type]) {
5160          // Interrupt processing of the outer synthetic .trigger()ed event
5161          if (!saved) {
5162            // Store arguments for use when handling the inner native event
5163            // There will always be at least one argument (an event object), so this array
5164            // will not be confused with a leftover capture object.
5165            saved = _slice.call(arguments);
5166            dataPriv.set(this, type, saved);
5167
5168            // Trigger the native event and capture its result
5169            this[type]();
5170            result = dataPriv.get(this, type);
5171            dataPriv.set(this, type, false);
5172            if (saved !== result) {
5173              // Cancel the outer synthetic event
5174              event.stopImmediatePropagation();
5175              event.preventDefault();
5176              return result;
5177            }
5178
5179            // If this is an inner synthetic event for an event with a bubbling surrogate
5180            // (focus or blur), assume that the surrogate already propagated from triggering
5181            // the native event and prevent that from happening again here.
5182            // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the
5183            // bubbling surrogate propagates *after* the non-bubbling base), but that seems
5184            // less bad than duplication.
5185          } else if ((_jQuery2.event.special[type] || {}).delegateType) {
5186            event.stopPropagation();
5187          }
5188
5189          // If this is a native event triggered above, everything is now in order
5190          // Fire an inner synthetic event with the original arguments
5191        } else if (saved) {
5192          // ...and capture the result
5193          dataPriv.set(this, type, _jQuery2.event.trigger(saved[0], saved.slice(1), this));
5194
5195          // Abort handling of the native event by all jQuery handlers while allowing
5196          // native handlers on the same element to run. On target, this is achieved
5197          // by stopping immediate propagation just on the jQuery event. However,
5198          // the native event is re-wrapped by a jQuery one on each level of the
5199          // propagation so the only way to stop it for jQuery is to stop it for
5200          // everyone via native `stopPropagation()`. This is not a problem for
5201          // focus/blur which don't bubble, but it does also stop click on checkboxes
5202          // and radios. We accept this limitation.
5203          event.stopPropagation();
5204          event.isImmediatePropagationStopped = returnTrue;
5205        }
5206      }
5207    });
5208  }
5209  _jQuery2.removeEvent = function (elem, type, handle) {
5210    // This "if" is needed for plain objects
5211    if (elem.removeEventListener) {
5212      elem.removeEventListener(type, handle);
5213    }
5214  };
5215  _jQuery2.Event = function (src, props) {
5216    // Allow instantiation without the 'new' keyword
5217    if (!(this instanceof _jQuery2.Event)) {
5218      return new _jQuery2.Event(src, props);
5219    }
5220
5221    // Event object
5222    if (src && src.type) {
5223      this.originalEvent = src;
5224      this.type = src.type;
5225
5226      // Events bubbling up the document may have been marked as prevented
5227      // by a handler lower down the tree; reflect the correct value.
5228      this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === undefined &&
5229      // Support: Android <=2.3 only
5230      src.returnValue === false ? returnTrue : returnFalse;
5231
5232      // Create target properties
5233      // Support: Safari <=6 - 7 only
5234      // Target should not be a text node (trac-504, trac-13143)
5235      this.target = src.target && src.target.nodeType === 3 ? src.target.parentNode : src.target;
5236      this.currentTarget = src.currentTarget;
5237      this.relatedTarget = src.relatedTarget;
5238
5239      // Event type
5240    } else {
5241      this.type = src;
5242    }
5243
5244    // Put explicitly provided properties onto the event object
5245    if (props) {
5246      _jQuery2.extend(this, props);
5247    }
5248
5249    // Create a timestamp if incoming event doesn't have one
5250    this.timeStamp = src && src.timeStamp || Date.now();
5251
5252    // Mark it as fixed
5253    this[_jQuery2.expando] = true;
5254  };
5255
5256  // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
5257  // https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
5258  _jQuery2.Event.prototype = {
5259    constructor: _jQuery2.Event,
5260    isDefaultPrevented: returnFalse,
5261    isPropagationStopped: returnFalse,
5262    isImmediatePropagationStopped: returnFalse,
5263    isSimulated: false,
5264    preventDefault: function preventDefault() {
5265      var e = this.originalEvent;
5266      this.isDefaultPrevented = returnTrue;
5267      if (e && !this.isSimulated) {
5268        e.preventDefault();
5269      }
5270    },
5271    stopPropagation: function stopPropagation() {
5272      var e = this.originalEvent;
5273      this.isPropagationStopped = returnTrue;
5274      if (e && !this.isSimulated) {
5275        e.stopPropagation();
5276      }
5277    },
5278    stopImmediatePropagation: function stopImmediatePropagation() {
5279      var e = this.originalEvent;
5280      this.isImmediatePropagationStopped = returnTrue;
5281      if (e && !this.isSimulated) {
5282        e.stopImmediatePropagation();
5283      }
5284      this.stopPropagation();
5285    }
5286  };
5287
5288  // Includes all common event props including KeyEvent and MouseEvent specific props
5289  _jQuery2.each({
5290    altKey: true,
5291    bubbles: true,
5292    cancelable: true,
5293    changedTouches: true,
5294    ctrlKey: true,
5295    detail: true,
5296    eventPhase: true,
5297    metaKey: true,
5298    pageX: true,
5299    pageY: true,
5300    shiftKey: true,
5301    view: true,
5302    "char": true,
5303    code: true,
5304    charCode: true,
5305    key: true,
5306    keyCode: true,
5307    button: true,
5308    buttons: true,
5309    clientX: true,
5310    clientY: true,
5311    offsetX: true,
5312    offsetY: true,
5313    pointerId: true,
5314    pointerType: true,
5315    screenX: true,
5316    screenY: true,
5317    targetTouches: true,
5318    toElement: true,
5319    touches: true,
5320    which: true
5321  }, _jQuery2.event.addProp);
5322  _jQuery2.each({
5323    focus: "focusin",
5324    blur: "focusout"
5325  }, function (type, delegateType) {
5326    function focusMappedHandler(nativeEvent) {
5327      if (document.documentMode) {
5328        // Support: IE 11+
5329        // Attach a single focusin/focusout handler on the document while someone wants
5330        // focus/blur. This is because the former are synchronous in IE while the latter
5331        // are async. In other browsers, all those handlers are invoked synchronously.
5332
5333        // `handle` from private data would already wrap the event, but we need
5334        // to change the `type` here.
5335        var handle = dataPriv.get(this, "handle"),
5336          event = _jQuery2.event.fix(nativeEvent);
5337        event.type = nativeEvent.type === "focusin" ? "focus" : "blur";
5338        event.isSimulated = true;
5339
5340        // First, handle focusin/focusout
5341        handle(nativeEvent);
5342
5343        // ...then, handle focus/blur
5344        //
5345        // focus/blur don't bubble while focusin/focusout do; simulate the former by only
5346        // invoking the handler at the lower level.
5347        if (event.target === event.currentTarget) {
5348          // The setup part calls `leverageNative`, which, in turn, calls
5349          // `jQuery.event.add`, so event handle will already have been set
5350          // by this point.
5351          handle(event);
5352        }
5353      } else {
5354        // For non-IE browsers, attach a single capturing handler on the document
5355        // while someone wants focusin/focusout.
5356        _jQuery2.event.simulate(delegateType, nativeEvent.target, _jQuery2.event.fix(nativeEvent));
5357      }
5358    }
5359    _jQuery2.event.special[type] = {
5360      // Utilize native event if possible so blur/focus sequence is correct
5361      setup: function setup() {
5362        var attaches;
5363
5364        // Claim the first handler
5365        // dataPriv.set( this, "focus", ... )
5366        // dataPriv.set( this, "blur", ... )
5367        leverageNative(this, type, true);
5368        if (document.documentMode) {
5369          // Support: IE 9 - 11+
5370          // We use the same native handler for focusin & focus (and focusout & blur)
5371          // so we need to coordinate setup & teardown parts between those events.
5372          // Use `delegateType` as the key as `type` is already used by `leverageNative`.
5373          attaches = dataPriv.get(this, delegateType);
5374          if (!attaches) {
5375            this.addEventListener(delegateType, focusMappedHandler);
5376          }
5377          dataPriv.set(this, delegateType, (attaches || 0) + 1);
5378        } else {
5379          // Return false to allow normal processing in the caller
5380          return false;
5381        }
5382      },
5383      trigger: function trigger() {
5384        // Force setup before trigger
5385        leverageNative(this, type);
5386
5387        // Return non-false to allow normal event-path propagation
5388        return true;
5389      },
5390      teardown: function teardown() {
5391        var attaches;
5392        if (document.documentMode) {
5393          attaches = dataPriv.get(this, delegateType) - 1;
5394          if (!attaches) {
5395            this.removeEventListener(delegateType, focusMappedHandler);
5396            dataPriv.remove(this, delegateType);
5397          } else {
5398            dataPriv.set(this, delegateType, attaches);
5399          }
5400        } else {
5401          // Return false to indicate standard teardown should be applied
5402          return false;
5403        }
5404      },
5405      // Suppress native focus or blur if we're currently inside
5406      // a leveraged native-event stack
5407      _default: function _default(event) {
5408        return dataPriv.get(event.target, type);
5409      },
5410      delegateType: delegateType
5411    };
5412
5413    // Support: Firefox <=44
5414    // Firefox doesn't have focus(in | out) events
5415    // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
5416    //
5417    // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
5418    // focus(in | out) events fire after focus & blur events,
5419    // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
5420    // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
5421    //
5422    // Support: IE 9 - 11+
5423    // To preserve relative focusin/focus & focusout/blur event order guaranteed on the 3.x branch,
5424    // attach a single handler for both events in IE.
5425    _jQuery2.event.special[delegateType] = {
5426      setup: function setup() {
5427        // Handle: regular nodes (via `this.ownerDocument`), window
5428        // (via `this.document`) & document (via `this`).
5429        var doc = this.ownerDocument || this.document || this,
5430          dataHolder = document.documentMode ? this : doc,
5431          attaches = dataPriv.get(dataHolder, delegateType);
5432
5433        // Support: IE 9 - 11+
5434        // We use the same native handler for focusin & focus (and focusout & blur)
5435        // so we need to coordinate setup & teardown parts between those events.
5436        // Use `delegateType` as the key as `type` is already used by `leverageNative`.
5437        if (!attaches) {
5438          if (document.documentMode) {
5439            this.addEventListener(delegateType, focusMappedHandler);
5440          } else {
5441            doc.addEventListener(type, focusMappedHandler, true);
5442          }
5443        }
5444        dataPriv.set(dataHolder, delegateType, (attaches || 0) + 1);
5445      },
5446      teardown: function teardown() {
5447        var doc = this.ownerDocument || this.document || this,
5448          dataHolder = document.documentMode ? this : doc,
5449          attaches = dataPriv.get(dataHolder, delegateType) - 1;
5450        if (!attaches) {
5451          if (document.documentMode) {
5452            this.removeEventListener(delegateType, focusMappedHandler);
5453          } else {
5454            doc.removeEventListener(type, focusMappedHandler, true);
5455          }
5456          dataPriv.remove(dataHolder, delegateType);
5457        } else {
5458          dataPriv.set(dataHolder, delegateType, attaches);
5459        }
5460      }
5461    };
5462  });
5463
5464  // Create mouseenter/leave events using mouseover/out and event-time checks
5465  // so that event delegation works in jQuery.
5466  // Do the same for pointerenter/pointerleave and pointerover/pointerout
5467  //
5468  // Support: Safari 7 only
5469  // Safari sends mouseenter too often; see:
5470  // https://bugs.chromium.org/p/chromium/issues/detail?id=470258
5471  // for the description of the bug (it existed in older Chrome versions as well).
5472  _jQuery2.each({
5473    mouseenter: "mouseover",
5474    mouseleave: "mouseout",
5475    pointerenter: "pointerover",
5476    pointerleave: "pointerout"
5477  }, function (orig, fix) {
5478    _jQuery2.event.special[orig] = {
5479      delegateType: fix,
5480      bindType: fix,
5481      handle: function handle(event) {
5482        var ret,
5483          target = this,
5484          related = event.relatedTarget,
5485          handleObj = event.handleObj;
5486
5487        // For mouseenter/leave call the handler if related is outside the target.
5488        // NB: No relatedTarget if the mouse left/entered the browser window
5489        if (!related || related !== target && !_jQuery2.contains(target, related)) {
5490          event.type = handleObj.origType;
5491          ret = handleObj.handler.apply(this, arguments);
5492          event.type = fix;
5493        }
5494        return ret;
5495      }
5496    };
5497  });
5498  _jQuery2.fn.extend({
5499    on: function on(types, selector, data, fn) {
5500      return _on(this, types, selector, data, fn);
5501    },
5502    one: function one(types, selector, data, fn) {
5503      return _on(this, types, selector, data, fn, 1);
5504    },
5505    off: function off(types, selector, fn) {
5506      var handleObj, type;
5507      if (types && types.preventDefault && types.handleObj) {
5508        // ( event )  dispatched jQuery.Event
5509        handleObj = types.handleObj;
5510        _jQuery2(types.delegateTarget).off(handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler);
5511        return this;
5512      }
5513      if (_typeof(types) === "object") {
5514        // ( types-object [, selector] )
5515        for (type in types) {
5516          this.off(type, selector, types[type]);
5517        }
5518        return this;
5519      }
5520      if (selector === false || typeof selector === "function") {
5521        // ( types [, fn] )
5522        fn = selector;
5523        selector = undefined;
5524      }
5525      if (fn === false) {
5526        fn = returnFalse;
5527      }
5528      return this.each(function () {
5529        _jQuery2.event.remove(this, types, fn, selector);
5530      });
5531    }
5532  });
5533  var
5534    // Support: IE <=10 - 11, Edge 12 - 13 only
5535    // In IE/Edge using regex groups here causes severe slowdowns.
5536    // See https://connect.microsoft.com/IE/feedback/details/1736512/
5537    rnoInnerhtml = /<script|<style|<link/i,
5538    // checked="checked" or checked
5539    rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
5540    rcleanScript = /^\s*<!\[CDATA\[|\]\]>\s*$/g;
5541
5542  // Prefer a tbody over its parent table for containing new rows
5543  function manipulationTarget(elem, content) {
5544    if (nodeName(elem, "table") && nodeName(content.nodeType !== 11 ? content : content.firstChild, "tr")) {
5545      return _jQuery2(elem).children("tbody")[0] || elem;
5546    }
5547    return elem;
5548  }
5549
5550  // Replace/restore the type attribute of script elements for safe DOM manipulation
5551  function disableScript(elem) {
5552    elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type;
5553    return elem;
5554  }
5555  function restoreScript(elem) {
5556    if ((elem.type || "").slice(0, 5) === "true/") {
5557      elem.type = elem.type.slice(5);
5558    } else {
5559      elem.removeAttribute("type");
5560    }
5561    return elem;
5562  }
5563  function cloneCopyEvent(src, dest) {
5564    var i, l, type, pdataOld, udataOld, udataCur, events;
5565    if (dest.nodeType !== 1) {
5566      return;
5567    }
5568
5569    // 1. Copy private data: events, handlers, etc.
5570    if (dataPriv.hasData(src)) {
5571      pdataOld = dataPriv.get(src);
5572      events = pdataOld.events;
5573      if (events) {
5574        dataPriv.remove(dest, "handle events");
5575        for (type in events) {
5576          for (i = 0, l = events[type].length; i < l; i++) {
5577            _jQuery2.event.add(dest, type, events[type][i]);
5578          }
5579        }
5580      }
5581    }
5582
5583    // 2. Copy user data
5584    if (dataUser.hasData(src)) {
5585      udataOld = dataUser.access(src);
5586      udataCur = _jQuery2.extend({}, udataOld);
5587      dataUser.set(dest, udataCur);
5588    }
5589  }
5590
5591  // Fix IE bugs, see support tests
5592  function fixInput(src, dest) {
5593    var nodeName = dest.nodeName.toLowerCase();
5594
5595    // Fails to persist the checked state of a cloned checkbox or radio button.
5596    if (nodeName === "input" && rcheckableType.test(src.type)) {
5597      dest.checked = src.checked;
5598
5599      // Fails to return the selected option to the default selected state when cloning options
5600    } else if (nodeName === "input" || nodeName === "textarea") {
5601      dest.defaultValue = src.defaultValue;
5602    }
5603  }
5604  function domManip(collection, args, callback, ignored) {
5605    // Flatten any nested arrays
5606    args = flat(args);
5607    var fragment,
5608      first,
5609      scripts,
5610      hasScripts,
5611      node,
5612      doc,
5613      i = 0,
5614      l = collection.length,
5615      iNoClone = l - 1,
5616      value = args[0],
5617      valueIsFunction = isFunction(value);
5618
5619    // We can't cloneNode fragments that contain checked, in WebKit
5620    if (valueIsFunction || l > 1 && typeof value === "string" && !support.checkClone && rchecked.test(value)) {
5621      return collection.each(function (index) {
5622        var self = collection.eq(index);
5623        if (valueIsFunction) {
5624          args[0] = value.call(this, index, self.html());
5625        }
5626        domManip(self, args, callback, ignored);
5627      });
5628    }
5629    if (l) {
5630      fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored);
5631      first = fragment.firstChild;
5632      if (fragment.childNodes.length === 1) {
5633        fragment = first;
5634      }
5635
5636      // Require either new content or an interest in ignored elements to invoke the callback
5637      if (first || ignored) {
5638        scripts = _jQuery2.map(getAll(fragment, "script"), disableScript);
5639        hasScripts = scripts.length;
5640
5641        // Use the original fragment for the last item
5642        // instead of the first because it can end up
5643        // being emptied incorrectly in certain situations (trac-8070).
5644        for (; i < l; i++) {
5645          node = fragment;
5646          if (i !== iNoClone) {
5647            node = _jQuery2.clone(node, true, true);
5648
5649            // Keep references to cloned scripts for later restoration
5650            if (hasScripts) {
5651              // Support: Android <=4.0 only, PhantomJS 1 only
5652              // push.apply(_, arraylike) throws on ancient WebKit
5653              _jQuery2.merge(scripts, getAll(node, "script"));
5654            }
5655          }
5656          callback.call(collection[i], node, i);
5657        }
5658        if (hasScripts) {
5659          doc = scripts[scripts.length - 1].ownerDocument;
5660
5661          // Re-enable scripts
5662          _jQuery2.map(scripts, restoreScript);
5663
5664          // Evaluate executable scripts on first document insertion
5665          for (i = 0; i < hasScripts; i++) {
5666            node = scripts[i];
5667            if (rscriptType.test(node.type || "") && !dataPriv.access(node, "globalEval") && _jQuery2.contains(doc, node)) {
5668              if (node.src && (node.type || "").toLowerCase() !== "module") {
5669                // Optional AJAX dependency, but won't run scripts if not present
5670                if (_jQuery2._evalUrl && !node.noModule) {
5671                  _jQuery2._evalUrl(node.src, {
5672                    nonce: node.nonce || node.getAttribute("nonce")
5673                  }, doc);
5674                }
5675              } else {
5676                // Unwrap a CDATA section containing script contents. This shouldn't be
5677                // needed as in XML documents they're already not visible when
5678                // inspecting element contents and in HTML documents they have no
5679                // meaning but we're preserving that logic for backwards compatibility.
5680                // This will be removed completely in 4.0. See gh-4904.
5681                DOMEval(node.textContent.replace(rcleanScript, ""), node, doc);
5682              }
5683            }
5684          }
5685        }
5686      }
5687    }
5688    return collection;
5689  }
5690  function _remove(elem, selector, keepData) {
5691    var node,
5692      nodes = selector ? _jQuery2.filter(selector, elem) : elem,
5693      i = 0;
5694    for (; (node = nodes[i]) != null; i++) {
5695      if (!keepData && node.nodeType === 1) {
5696        _jQuery2.cleanData(getAll(node));
5697      }
5698      if (node.parentNode) {
5699        if (keepData && isAttached(node)) {
5700          setGlobalEval(getAll(node, "script"));
5701        }
5702        node.parentNode.removeChild(node);
5703      }
5704    }
5705    return elem;
5706  }
5707  _jQuery2.extend({
5708    htmlPrefilter: function htmlPrefilter(html) {
5709      return html;
5710    },
5711    clone: function clone(elem, dataAndEvents, deepDataAndEvents) {
5712      var i,
5713        l,
5714        srcElements,
5715        destElements,
5716        clone = elem.cloneNode(true),
5717        inPage = isAttached(elem);
5718
5719      // Fix IE cloning issues
5720      if (!support.noCloneChecked && (elem.nodeType === 1 || elem.nodeType === 11) && !_jQuery2.isXMLDoc(elem)) {
5721        // We eschew jQuery#find here for performance reasons:
5722        // https://jsperf.com/getall-vs-sizzle/2
5723        destElements = getAll(clone);
5724        srcElements = getAll(elem);
5725        for (i = 0, l = srcElements.length; i < l; i++) {
5726          fixInput(srcElements[i], destElements[i]);
5727        }
5728      }
5729
5730      // Copy the events from the original to the clone
5731      if (dataAndEvents) {
5732        if (deepDataAndEvents) {
5733          srcElements = srcElements || getAll(elem);
5734          destElements = destElements || getAll(clone);
5735          for (i = 0, l = srcElements.length; i < l; i++) {
5736            cloneCopyEvent(srcElements[i], destElements[i]);
5737          }
5738        } else {
5739          cloneCopyEvent(elem, clone);
5740        }
5741      }
5742
5743      // Preserve script evaluation history
5744      destElements = getAll(clone, "script");
5745      if (destElements.length > 0) {
5746        setGlobalEval(destElements, !inPage && getAll(elem, "script"));
5747      }
5748
5749      // Return the cloned set
5750      return clone;
5751    },
5752    cleanData: function cleanData(elems) {
5753      var data,
5754        elem,
5755        type,
5756        special = _jQuery2.event.special,
5757        i = 0;
5758      for (; (elem = elems[i]) !== undefined; i++) {
5759        if (acceptData(elem)) {
5760          if (data = elem[dataPriv.expando]) {
5761            if (data.events) {
5762              for (type in data.events) {
5763                if (special[type]) {
5764                  _jQuery2.event.remove(elem, type);
5765
5766                  // This is a shortcut to avoid jQuery.event.remove's overhead
5767                } else {
5768                  _jQuery2.removeEvent(elem, type, data.handle);
5769                }
5770              }
5771            }
5772
5773            // Support: Chrome <=35 - 45+
5774            // Assign undefined instead of using delete, see Data#remove
5775            elem[dataPriv.expando] = undefined;
5776          }
5777          if (elem[dataUser.expando]) {
5778            // Support: Chrome <=35 - 45+
5779            // Assign undefined instead of using delete, see Data#remove
5780            elem[dataUser.expando] = undefined;
5781          }
5782        }
5783      }
5784    }
5785  });
5786  _jQuery2.fn.extend({
5787    detach: function detach(selector) {
5788      return _remove(this, selector, true);
5789    },
5790    remove: function remove(selector) {
5791      return _remove(this, selector);
5792    },
5793    text: function text(value) {
5794      return _access(this, function (value) {
5795        return value === undefined ? _jQuery2.text(this) : this.empty().each(function () {
5796          if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
5797            this.textContent = value;
5798          }
5799        });
5800      }, null, value, arguments.length);
5801    },
5802    append: function append() {
5803      return domManip(this, arguments, function (elem) {
5804        if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
5805          var target = manipulationTarget(this, elem);
5806          target.appendChild(elem);
5807        }
5808      });
5809    },
5810    prepend: function prepend() {
5811      return domManip(this, arguments, function (elem) {
5812        if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
5813          var target = manipulationTarget(this, elem);
5814          target.insertBefore(elem, target.firstChild);
5815        }
5816      });
5817    },
5818    before: function before() {
5819      return domManip(this, arguments, function (elem) {
5820        if (this.parentNode) {
5821          this.parentNode.insertBefore(elem, this);
5822        }
5823      });
5824    },
5825    after: function after() {
5826      return domManip(this, arguments, function (elem) {
5827        if (this.parentNode) {
5828          this.parentNode.insertBefore(elem, this.nextSibling);
5829        }
5830      });
5831    },
5832    empty: function empty() {
5833      var elem,
5834        i = 0;
5835      for (; (elem = this[i]) != null; i++) {
5836        if (elem.nodeType === 1) {
5837          // Prevent memory leaks
5838          _jQuery2.cleanData(getAll(elem, false));
5839
5840          // Remove any remaining nodes
5841          elem.textContent = "";
5842        }
5843      }
5844      return this;
5845    },
5846    clone: function clone(dataAndEvents, deepDataAndEvents) {
5847      dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
5848      deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
5849      return this.map(function () {
5850        return _jQuery2.clone(this, dataAndEvents, deepDataAndEvents);
5851      });
5852    },
5853    html: function html(value) {
5854      return _access(this, function (value) {
5855        var elem = this[0] || {},
5856          i = 0,
5857          l = this.length;
5858        if (value === undefined && elem.nodeType === 1) {
5859          return elem.innerHTML;
5860        }
5861
5862        // See if we can take a shortcut and just use innerHTML
5863        if (typeof value === "string" && !rnoInnerhtml.test(value) && !wrapMap[(rtagName.exec(value) || ["", ""])[1].toLowerCase()]) {
5864          value = _jQuery2.htmlPrefilter(value);
5865          try {
5866            for (; i < l; i++) {
5867              elem = this[i] || {};
5868
5869              // Remove element nodes and prevent memory leaks
5870              if (elem.nodeType === 1) {
5871                _jQuery2.cleanData(getAll(elem, false));
5872                elem.innerHTML = value;
5873              }
5874            }
5875            elem = 0;
5876
5877            // If using innerHTML throws an exception, use the fallback method
5878          } catch (e) {}
5879        }
5880        if (elem) {
5881          this.empty().append(value);
5882        }
5883      }, null, value, arguments.length);
5884    },
5885    replaceWith: function replaceWith() {
5886      var ignored = [];
5887
5888      // Make the changes, replacing each non-ignored context element with the new content
5889      return domManip(this, arguments, function (elem) {
5890        var parent = this.parentNode;
5891        if (_jQuery2.inArray(this, ignored) < 0) {
5892          _jQuery2.cleanData(getAll(this));
5893          if (parent) {
5894            parent.replaceChild(elem, this);
5895          }
5896        }
5897
5898        // Force callback invocation
5899      }, ignored);
5900    }
5901  });
5902  _jQuery2.each({
5903    appendTo: "append",
5904    prependTo: "prepend",
5905    insertBefore: "before",
5906    insertAfter: "after",
5907    replaceAll: "replaceWith"
5908  }, function (name, original) {
5909    _jQuery2.fn[name] = function (selector) {
5910      var elems,
5911        ret = [],
5912        insert = _jQuery2(selector),
5913        last = insert.length - 1,
5914        i = 0;
5915      for (; i <= last; i++) {
5916        elems = i === last ? this : this.clone(true);
5917        _jQuery2(insert[i])[original](elems);
5918
5919        // Support: Android <=4.0 only, PhantomJS 1 only
5920        // .get() because push.apply(_, arraylike) throws on ancient WebKit
5921        push.apply(ret, elems.get());
5922      }
5923      return this.pushStack(ret);
5924    };
5925  });
5926  var rnumnonpx = new RegExp("^(" + pnum + ")(?!px)[a-z%]+$", "i");
5927  var rcustomProp = /^--/;
5928  var getStyles = function getStyles(elem) {
5929    // Support: IE <=11 only, Firefox <=30 (trac-15098, trac-14150)
5930    // IE throws on elements created in popups
5931    // FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
5932    var view = elem.ownerDocument.defaultView;
5933    if (!view || !view.opener) {
5934      view = window;
5935    }
5936    return view.getComputedStyle(elem);
5937  };
5938  var swap = function swap(elem, options, callback) {
5939    var ret,
5940      name,
5941      old = {};
5942
5943    // Remember the old values, and insert the new ones
5944    for (name in options) {
5945      old[name] = elem.style[name];
5946      elem.style[name] = options[name];
5947    }
5948    ret = callback.call(elem);
5949
5950    // Revert the old values
5951    for (name in options) {
5952      elem.style[name] = old[name];
5953    }
5954    return ret;
5955  };
5956  var rboxStyle = new RegExp(cssExpand.join("|"), "i");
5957  (function () {
5958    // Executing both pixelPosition & boxSizingReliable tests require only one layout
5959    // so they're executed at the same time to save the second computation.
5960    function computeStyleTests() {
5961      // This is a singleton, we need to execute it only once
5962      if (!div) {
5963        return;
5964      }
5965      container.style.cssText = "position:absolute;left:-11111px;width:60px;" + "margin-top:1px;padding:0;border:0";
5966      div.style.cssText = "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + "margin:auto;border:1px;padding:1px;" + "width:60%;top:1%";
5967      documentElement.appendChild(container).appendChild(div);
5968      var divStyle = window.getComputedStyle(div);
5969      pixelPositionVal = divStyle.top !== "1%";
5970
5971      // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
5972      reliableMarginLeftVal = roundPixelMeasures(divStyle.marginLeft) === 12;
5973
5974      // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3
5975      // Some styles come back with percentage values, even though they shouldn't
5976      div.style.right = "60%";
5977      pixelBoxStylesVal = roundPixelMeasures(divStyle.right) === 36;
5978
5979      // Support: IE 9 - 11 only
5980      // Detect misreporting of content dimensions for box-sizing:border-box elements
5981      boxSizingReliableVal = roundPixelMeasures(divStyle.width) === 36;
5982
5983      // Support: IE 9 only
5984      // Detect overflow:scroll screwiness (gh-3699)
5985      // Support: Chrome <=64
5986      // Don't get tricked when zoom affects offsetWidth (gh-4029)
5987      div.style.position = "absolute";
5988      scrollboxSizeVal = roundPixelMeasures(div.offsetWidth / 3) === 12;
5989      documentElement.removeChild(container);
5990
5991      // Nullify the div so it wouldn't be stored in the memory and
5992      // it will also be a sign that checks already performed
5993      div = null;
5994    }
5995    function roundPixelMeasures(measure) {
5996      return Math.round(parseFloat(measure));
5997    }
5998    var pixelPositionVal,
5999      boxSizingReliableVal,
6000      scrollboxSizeVal,
6001      pixelBoxStylesVal,
6002      reliableTrDimensionsVal,
6003      reliableMarginLeftVal,
6004      container = document.createElement("div"),
6005      div = document.createElement("div");
6006
6007    // Finish early in limited (non-browser) environments
6008    if (!div.style) {
6009      return;
6010    }
6011
6012    // Support: IE <=9 - 11 only
6013    // Style of cloned element affects source element cloned (trac-8908)
6014    div.style.backgroundClip = "content-box";
6015    div.cloneNode(true).style.backgroundClip = "";
6016    support.clearCloneStyle = div.style.backgroundClip === "content-box";
6017    _jQuery2.extend(support, {
6018      boxSizingReliable: function boxSizingReliable() {
6019        computeStyleTests();
6020        return boxSizingReliableVal;
6021      },
6022      pixelBoxStyles: function pixelBoxStyles() {
6023        computeStyleTests();
6024        return pixelBoxStylesVal;
6025      },
6026      pixelPosition: function pixelPosition() {
6027        computeStyleTests();
6028        return pixelPositionVal;
6029      },
6030      reliableMarginLeft: function reliableMarginLeft() {
6031        computeStyleTests();
6032        return reliableMarginLeftVal;
6033      },
6034      scrollboxSize: function scrollboxSize() {
6035        computeStyleTests();
6036        return scrollboxSizeVal;
6037      },
6038      // Support: IE 9 - 11+, Edge 15 - 18+
6039      // IE/Edge misreport `getComputedStyle` of table rows with width/height
6040      // set in CSS while `offset*` properties report correct values.
6041      // Behavior in IE 9 is more subtle than in newer versions & it passes
6042      // some versions of this test; make sure not to make it pass there!
6043      //
6044      // Support: Firefox 70+
6045      // Only Firefox includes border widths
6046      // in computed dimensions. (gh-4529)
6047      reliableTrDimensions: function reliableTrDimensions() {
6048        var table, tr, trChild, trStyle;
6049        if (reliableTrDimensionsVal == null) {
6050          table = document.createElement("table");
6051          tr = document.createElement("tr");
6052          trChild = document.createElement("div");
6053          table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate";
6054          tr.style.cssText = "box-sizing:content-box;border:1px solid";
6055
6056          // Support: Chrome 86+
6057          // Height set through cssText does not get applied.
6058          // Computed height then comes back as 0.
6059          tr.style.height = "1px";
6060          trChild.style.height = "9px";
6061
6062          // Support: Android 8 Chrome 86+
6063          // In our bodyBackground.html iframe,
6064          // display for all div elements is set to "inline",
6065          // which causes a problem only in Android 8 Chrome 86.
6066          // Ensuring the div is `display: block`
6067          // gets around this issue.
6068          trChild.style.display = "block";
6069          documentElement.appendChild(table).appendChild(tr).appendChild(trChild);
6070          trStyle = window.getComputedStyle(tr);
6071          reliableTrDimensionsVal = parseInt(trStyle.height, 10) + parseInt(trStyle.borderTopWidth, 10) + parseInt(trStyle.borderBottomWidth, 10) === tr.offsetHeight;
6072          documentElement.removeChild(table);
6073        }
6074        return reliableTrDimensionsVal;
6075      }
6076    });
6077  })();
6078  function curCSS(elem, name, computed) {
6079    var width,
6080      minWidth,
6081      maxWidth,
6082      ret,
6083      isCustomProp = rcustomProp.test(name),
6084      // Support: Firefox 51+
6085      // Retrieving style before computed somehow
6086      // fixes an issue with getting wrong values
6087      // on detached elements
6088      style = elem.style;
6089    computed = computed || getStyles(elem);
6090
6091    // getPropertyValue is needed for:
6092    //   .css('filter') (IE 9 only, trac-12537)
6093    //   .css('--customProperty) (gh-3144)
6094    if (computed) {
6095      // Support: IE <=9 - 11+
6096      // IE only supports `"float"` in `getPropertyValue`; in computed styles
6097      // it's only available as `"cssFloat"`. We no longer modify properties
6098      // sent to `.css()` apart from camelCasing, so we need to check both.
6099      // Normally, this would create difference in behavior: if
6100      // `getPropertyValue` returns an empty string, the value returned
6101      // by `.css()` would be `undefined`. This is usually the case for
6102      // disconnected elements. However, in IE even disconnected elements
6103      // with no styles return `"none"` for `getPropertyValue( "float" )`
6104      ret = computed.getPropertyValue(name) || computed[name];
6105      if (isCustomProp && ret) {
6106        // Support: Firefox 105+, Chrome <=105+
6107        // Spec requires trimming whitespace for custom properties (gh-4926).
6108        // Firefox only trims leading whitespace. Chrome just collapses
6109        // both leading & trailing whitespace to a single space.
6110        //
6111        // Fall back to `undefined` if empty string returned.
6112        // This collapses a missing definition with property defined
6113        // and set to an empty string but there's no standard API
6114        // allowing us to differentiate them without a performance penalty
6115        // and returning `undefined` aligns with older jQuery.
6116        //
6117        // rtrimCSS treats U+000D CARRIAGE RETURN and U+000C FORM FEED
6118        // as whitespace while CSS does not, but this is not a problem
6119        // because CSS preprocessing replaces them with U+000A LINE FEED
6120        // (which *is* CSS whitespace)
6121        // https://www.w3.org/TR/css-syntax-3/#input-preprocessing
6122        ret = ret.replace(rtrimCSS, "$1") || undefined;
6123      }
6124      if (ret === "" && !isAttached(elem)) {
6125        ret = _jQuery2.style(elem, name);
6126      }
6127
6128      // A tribute to the "awesome hack by Dean Edwards"
6129      // Android Browser returns percentage for some values,
6130      // but width seems to be reliably pixels.
6131      // This is against the CSSOM draft spec:
6132      // https://drafts.csswg.org/cssom/#resolved-values
6133      if (!support.pixelBoxStyles() && rnumnonpx.test(ret) && rboxStyle.test(name)) {
6134        // Remember the original values
6135        width = style.width;
6136        minWidth = style.minWidth;
6137        maxWidth = style.maxWidth;
6138
6139        // Put in the new values to get a computed value out
6140        style.minWidth = style.maxWidth = style.width = ret;
6141        ret = computed.width;
6142
6143        // Revert the changed values
6144        style.width = width;
6145        style.minWidth = minWidth;
6146        style.maxWidth = maxWidth;
6147      }
6148    }
6149    return ret !== undefined ?
6150    // Support: IE <=9 - 11 only
6151    // IE returns zIndex value as an integer.
6152    ret + "" : ret;
6153  }
6154  function addGetHookIf(conditionFn, hookFn) {
6155    // Define the hook, we'll check on the first run if it's really needed.
6156    return {
6157      get: function get() {
6158        if (conditionFn()) {
6159          // Hook not needed (or it's not possible to use it due
6160          // to missing dependency), remove it.
6161          delete this.get;
6162          return;
6163        }
6164
6165        // Hook needed; redefine it so that the support test is not executed again.
6166        return (this.get = hookFn).apply(this, arguments);
6167      }
6168    };
6169  }
6170  var cssPrefixes = ["Webkit", "Moz", "ms"],
6171    emptyStyle = document.createElement("div").style,
6172    vendorProps = {};
6173
6174  // Return a vendor-prefixed property or undefined
6175  function vendorPropName(name) {
6176    // Check for vendor prefixed names
6177    var capName = name[0].toUpperCase() + name.slice(1),
6178      i = cssPrefixes.length;
6179    while (i--) {
6180      name = cssPrefixes[i] + capName;
6181      if (name in emptyStyle) {
6182        return name;
6183      }
6184    }
6185  }
6186
6187  // Return a potentially-mapped jQuery.cssProps or vendor prefixed property
6188  function finalPropName(name) {
6189    var _final = _jQuery2.cssProps[name] || vendorProps[name];
6190    if (_final) {
6191      return _final;
6192    }
6193    if (name in emptyStyle) {
6194      return name;
6195    }
6196    return vendorProps[name] = vendorPropName(name) || name;
6197  }
6198  var
6199    // Swappable if display is none or starts with table
6200    // except "table", "table-cell", or "table-caption"
6201    // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
6202    rdisplayswap = /^(none|table(?!-c[ea]).+)/,
6203    cssShow = {
6204      position: "absolute",
6205      visibility: "hidden",
6206      display: "block"
6207    },
6208    cssNormalTransform = {
6209      letterSpacing: "0",
6210      fontWeight: "400"
6211    };
6212  function setPositiveNumber(_elem, value, subtract) {
6213    // Any relative (+/-) values have already been
6214    // normalized at this point
6215    var matches = rcssNum.exec(value);
6216    return matches ?
6217    // Guard against undefined "subtract", e.g., when used as in cssHooks
6218    Math.max(0, matches[2] - (subtract || 0)) + (matches[3] || "px") : value;
6219  }
6220  function boxModelAdjustment(elem, dimension, box, isBorderBox, styles, computedVal) {
6221    var i = dimension === "width" ? 1 : 0,
6222      extra = 0,
6223      delta = 0,
6224      marginDelta = 0;
6225
6226    // Adjustment may not be necessary
6227    if (box === (isBorderBox ? "border" : "content")) {
6228      return 0;
6229    }
6230    for (; i < 4; i += 2) {
6231      // Both box models exclude margin
6232      // Count margin delta separately to only add it after scroll gutter adjustment.
6233      // This is needed to make negative margins work with `outerHeight( true )` (gh-3982).
6234      if (box === "margin") {
6235        marginDelta += _jQuery2.css(elem, box + cssExpand[i], true, styles);
6236      }
6237
6238      // If we get here with a content-box, we're seeking "padding" or "border" or "margin"
6239      if (!isBorderBox) {
6240        // Add padding
6241        delta += _jQuery2.css(elem, "padding" + cssExpand[i], true, styles);
6242
6243        // For "border" or "margin", add border
6244        if (box !== "padding") {
6245          delta += _jQuery2.css(elem, "border" + cssExpand[i] + "Width", true, styles);
6246
6247          // But still keep track of it otherwise
6248        } else {
6249          extra += _jQuery2.css(elem, "border" + cssExpand[i] + "Width", true, styles);
6250        }
6251
6252        // If we get here with a border-box (content + padding + border), we're seeking "content" or
6253        // "padding" or "margin"
6254      } else {
6255        // For "content", subtract padding
6256        if (box === "content") {
6257          delta -= _jQuery2.css(elem, "padding" + cssExpand[i], true, styles);
6258        }
6259
6260        // For "content" or "padding", subtract border
6261        if (box !== "margin") {
6262          delta -= _jQuery2.css(elem, "border" + cssExpand[i] + "Width", true, styles);
6263        }
6264      }
6265    }
6266
6267    // Account for positive content-box scroll gutter when requested by providing computedVal
6268    if (!isBorderBox && computedVal >= 0) {
6269      // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
6270      // Assuming integer scroll gutter, subtract the rest and round down
6271      delta += Math.max(0, Math.ceil(elem["offset" + dimension[0].toUpperCase() + dimension.slice(1)] - computedVal - delta - extra - 0.5
6272
6273      // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter
6274      // Use an explicit zero to avoid NaN (gh-3964)
6275      )) || 0;
6276    }
6277    return delta + marginDelta;
6278  }
6279  function getWidthOrHeight(elem, dimension, extra) {
6280    // Start with computed style
6281    var styles = getStyles(elem),
6282      // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).
6283      // Fake content-box until we know it's needed to know the true value.
6284      boxSizingNeeded = !support.boxSizingReliable() || extra,
6285      isBorderBox = boxSizingNeeded && _jQuery2.css(elem, "boxSizing", false, styles) === "border-box",
6286      valueIsBorderBox = isBorderBox,
6287      val = curCSS(elem, dimension, styles),
6288      offsetProp = "offset" + dimension[0].toUpperCase() + dimension.slice(1);
6289
6290    // Support: Firefox <=54
6291    // Return a confounding non-pixel value or feign ignorance, as appropriate.
6292    if (rnumnonpx.test(val)) {
6293      if (!extra) {
6294        return val;
6295      }
6296      val = "auto";
6297    }
6298
6299    // Support: IE 9 - 11 only
6300    // Use offsetWidth/offsetHeight for when box sizing is unreliable.
6301    // In those cases, the computed value can be trusted to be border-box.
6302    if ((!support.boxSizingReliable() && isBorderBox ||
6303    // Support: IE 10 - 11+, Edge 15 - 18+
6304    // IE/Edge misreport `getComputedStyle` of table rows with width/height
6305    // set in CSS while `offset*` properties report correct values.
6306    // Interestingly, in some cases IE 9 doesn't suffer from this issue.
6307    !support.reliableTrDimensions() && nodeName(elem, "tr") ||
6308    // Fall back to offsetWidth/offsetHeight when value is "auto"
6309    // This happens for inline elements with no explicit setting (gh-3571)
6310    val === "auto" ||
6311    // Support: Android <=4.1 - 4.3 only
6312    // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
6313    !parseFloat(val) && _jQuery2.css(elem, "display", false, styles) === "inline") &&
6314    // Make sure the element is visible & connected
6315    elem.getClientRects().length) {
6316      isBorderBox = _jQuery2.css(elem, "boxSizing", false, styles) === "border-box";
6317
6318      // Where available, offsetWidth/offsetHeight approximate border box dimensions.
6319      // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the
6320      // retrieved value as a content box dimension.
6321      valueIsBorderBox = offsetProp in elem;
6322      if (valueIsBorderBox) {
6323        val = elem[offsetProp];
6324      }
6325    }
6326
6327    // Normalize "" and auto
6328    val = parseFloat(val) || 0;
6329
6330    // Adjust for the element's box model
6331    return val + boxModelAdjustment(elem, dimension, extra || (isBorderBox ? "border" : "content"), valueIsBorderBox, styles,
6332    // Provide the current computed size to request scroll gutter calculation (gh-3589)
6333    val) + "px";
6334  }
6335  _jQuery2.extend({
6336    // Add in style property hooks for overriding the default
6337    // behavior of getting and setting a style property
6338    cssHooks: {
6339      opacity: {
6340        get: function get(elem, computed) {
6341          if (computed) {
6342            // We should always get a number back from opacity
6343            var ret = curCSS(elem, "opacity");
6344            return ret === "" ? "1" : ret;
6345          }
6346        }
6347      }
6348    },
6349    // Don't automatically add "px" to these possibly-unitless properties
6350    cssNumber: {
6351      animationIterationCount: true,
6352      aspectRatio: true,
6353      borderImageSlice: true,
6354      columnCount: true,
6355      flexGrow: true,
6356      flexShrink: true,
6357      fontWeight: true,
6358      gridArea: true,
6359      gridColumn: true,
6360      gridColumnEnd: true,
6361      gridColumnStart: true,
6362      gridRow: true,
6363      gridRowEnd: true,
6364      gridRowStart: true,
6365      lineHeight: true,
6366      opacity: true,
6367      order: true,
6368      orphans: true,
6369      scale: true,
6370      widows: true,
6371      zIndex: true,
6372      zoom: true,
6373      // SVG-related
6374      fillOpacity: true,
6375      floodOpacity: true,
6376      stopOpacity: true,
6377      strokeMiterlimit: true,
6378      strokeOpacity: true
6379    },
6380    // Add in properties whose names you wish to fix before
6381    // setting or getting the value
6382    cssProps: {},
6383    // Get and set the style property on a DOM Node
6384    style: function style(elem, name, value, extra) {
6385      // Don't set styles on text and comment nodes
6386      if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) {
6387        return;
6388      }
6389
6390      // Make sure that we're working with the right name
6391      var ret,
6392        type,
6393        hooks,
6394        origName = camelCase(name),
6395        isCustomProp = rcustomProp.test(name),
6396        style = elem.style;
6397
6398      // Make sure that we're working with the right name. We don't
6399      // want to query the value if it is a CSS custom property
6400      // since they are user-defined.
6401      if (!isCustomProp) {
6402        name = finalPropName(origName);
6403      }
6404
6405      // Gets hook for the prefixed version, then unprefixed version
6406      hooks = _jQuery2.cssHooks[name] || _jQuery2.cssHooks[origName];
6407
6408      // Check if we're setting a value
6409      if (value !== undefined) {
6410        type = _typeof(value);
6411
6412        // Convert "+=" or "-=" to relative numbers (trac-7345)
6413        if (type === "string" && (ret = rcssNum.exec(value)) && ret[1]) {
6414          value = adjustCSS(elem, name, ret);
6415
6416          // Fixes bug trac-9237
6417          type = "number";
6418        }
6419
6420        // Make sure that null and NaN values aren't set (trac-7116)
6421        if (value == null || value !== value) {
6422          return;
6423        }
6424
6425        // If a number was passed in, add the unit (except for certain CSS properties)
6426        // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append
6427        // "px" to a few hardcoded values.
6428        if (type === "number" && !isCustomProp) {
6429          value += ret && ret[3] || (_jQuery2.cssNumber[origName] ? "" : "px");
6430        }
6431
6432        // background-* props affect original clone's values
6433        if (!support.clearCloneStyle && value === "" && name.indexOf("background") === 0) {
6434          style[name] = "inherit";
6435        }
6436
6437        // If a hook was provided, use that value, otherwise just set the specified value
6438        if (!hooks || !("set" in hooks) || (value = hooks.set(elem, value, extra)) !== undefined) {
6439          if (isCustomProp) {
6440            style.setProperty(name, value);
6441          } else {
6442            style[name] = value;
6443          }
6444        }
6445      } else {
6446        // If a hook was provided get the non-computed value from there
6447        if (hooks && "get" in hooks && (ret = hooks.get(elem, false, extra)) !== undefined) {
6448          return ret;
6449        }
6450
6451        // Otherwise just get the value from the style object
6452        return style[name];
6453      }
6454    },
6455    css: function css(elem, name, extra, styles) {
6456      var val,
6457        num,
6458        hooks,
6459        origName = camelCase(name),
6460        isCustomProp = rcustomProp.test(name);
6461
6462      // Make sure that we're working with the right name. We don't
6463      // want to modify the value if it is a CSS custom property
6464      // since they are user-defined.
6465      if (!isCustomProp) {
6466        name = finalPropName(origName);
6467      }
6468
6469      // Try prefixed name followed by the unprefixed name
6470      hooks = _jQuery2.cssHooks[name] || _jQuery2.cssHooks[origName];
6471
6472      // If a hook was provided get the computed value from there
6473      if (hooks && "get" in hooks) {
6474        val = hooks.get(elem, true, extra);
6475      }
6476
6477      // Otherwise, if a way to get the computed value exists, use that
6478      if (val === undefined) {
6479        val = curCSS(elem, name, styles);
6480      }
6481
6482      // Convert "normal" to computed value
6483      if (val === "normal" && name in cssNormalTransform) {
6484        val = cssNormalTransform[name];
6485      }
6486
6487      // Make numeric if forced or a qualifier was provided and val looks numeric
6488      if (extra === "" || extra) {
6489        num = parseFloat(val);
6490        return extra === true || isFinite(num) ? num || 0 : val;
6491      }
6492      return val;
6493    }
6494  });
6495  _jQuery2.each(["height", "width"], function (_i, dimension) {
6496    _jQuery2.cssHooks[dimension] = {
6497      get: function get(elem, computed, extra) {
6498        if (computed) {
6499          // Certain elements can have dimension info if we invisibly show them
6500          // but it must have a current display style that would benefit
6501          return rdisplayswap.test(_jQuery2.css(elem, "display")) && (
6502          // Support: Safari 8+
6503          // Table columns in Safari have non-zero offsetWidth & zero
6504          // getBoundingClientRect().width unless display is changed.
6505          // Support: IE <=11 only
6506          // Running getBoundingClientRect on a disconnected node
6507          // in IE throws an error.
6508          !elem.getClientRects().length || !elem.getBoundingClientRect().width) ? swap(elem, cssShow, function () {
6509            return getWidthOrHeight(elem, dimension, extra);
6510          }) : getWidthOrHeight(elem, dimension, extra);
6511        }
6512      },
6513      set: function set(elem, value, extra) {
6514        var matches,
6515          styles = getStyles(elem),
6516          // Only read styles.position if the test has a chance to fail
6517          // to avoid forcing a reflow.
6518          scrollboxSizeBuggy = !support.scrollboxSize() && styles.position === "absolute",
6519          // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)
6520          boxSizingNeeded = scrollboxSizeBuggy || extra,
6521          isBorderBox = boxSizingNeeded && _jQuery2.css(elem, "boxSizing", false, styles) === "border-box",
6522          subtract = extra ? boxModelAdjustment(elem, dimension, extra, isBorderBox, styles) : 0;
6523
6524        // Account for unreliable border-box dimensions by comparing offset* to computed and
6525        // faking a content-box to get border and padding (gh-3699)
6526        if (isBorderBox && scrollboxSizeBuggy) {
6527          subtract -= Math.ceil(elem["offset" + dimension[0].toUpperCase() + dimension.slice(1)] - parseFloat(styles[dimension]) - boxModelAdjustment(elem, dimension, "border", false, styles) - 0.5);
6528        }
6529
6530        // Convert to pixels if value adjustment is needed
6531        if (subtract && (matches = rcssNum.exec(value)) && (matches[3] || "px") !== "px") {
6532          elem.style[dimension] = value;
6533          value = _jQuery2.css(elem, dimension);
6534        }
6535        return setPositiveNumber(elem, value, subtract);
6536      }
6537    };
6538  });
6539  _jQuery2.cssHooks.marginLeft = addGetHookIf(support.reliableMarginLeft, function (elem, computed) {
6540    if (computed) {
6541      return (parseFloat(curCSS(elem, "marginLeft")) || elem.getBoundingClientRect().left - swap(elem, {
6542        marginLeft: 0
6543      }, function () {
6544        return elem.getBoundingClientRect().left;
6545      })) + "px";
6546    }
6547  });
6548
6549  // These hooks are used by animate to expand properties
6550  _jQuery2.each({
6551    margin: "",
6552    padding: "",
6553    border: "Width"
6554  }, function (prefix, suffix) {
6555    _jQuery2.cssHooks[prefix + suffix] = {
6556      expand: function expand(value) {
6557        var i = 0,
6558          expanded = {},
6559          // Assumes a single number if not a string
6560          parts = typeof value === "string" ? value.split(" ") : [value];
6561        for (; i < 4; i++) {
6562          expanded[prefix + cssExpand[i] + suffix] = parts[i] || parts[i - 2] || parts[0];
6563        }
6564        return expanded;
6565      }
6566    };
6567    if (prefix !== "margin") {
6568      _jQuery2.cssHooks[prefix + suffix].set = setPositiveNumber;
6569    }
6570  });
6571  _jQuery2.fn.extend({
6572    css: function css(name, value) {
6573      return _access(this, function (elem, name, value) {
6574        var styles,
6575          len,
6576          map = {},
6577          i = 0;
6578        if (Array.isArray(name)) {
6579          styles = getStyles(elem);
6580          len = name.length;
6581          for (; i < len; i++) {
6582            map[name[i]] = _jQuery2.css(elem, name[i], false, styles);
6583          }
6584          return map;
6585        }
6586        return value !== undefined ? _jQuery2.style(elem, name, value) : _jQuery2.css(elem, name);
6587      }, name, value, arguments.length > 1);
6588    }
6589  });
6590  function Tween(elem, options, prop, end, easing) {
6591    return new Tween.prototype.init(elem, options, prop, end, easing);
6592  }
6593  _jQuery2.Tween = Tween;
6594  Tween.prototype = {
6595    constructor: Tween,
6596    init: function init(elem, options, prop, end, easing, unit) {
6597      this.elem = elem;
6598      this.prop = prop;
6599      this.easing = easing || _jQuery2.easing._default;
6600      this.options = options;
6601      this.start = this.now = this.cur();
6602      this.end = end;
6603      this.unit = unit || (_jQuery2.cssNumber[prop] ? "" : "px");
6604    },
6605    cur: function cur() {
6606      var hooks = Tween.propHooks[this.prop];
6607      return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this);
6608    },
6609    run: function run(percent) {
6610      var eased,
6611        hooks = Tween.propHooks[this.prop];
6612      if (this.options.duration) {
6613        this.pos = eased = _jQuery2.easing[this.easing](percent, this.options.duration * percent, 0, 1, this.options.duration);
6614      } else {
6615        this.pos = eased = percent;
6616      }
6617      this.now = (this.end - this.start) * eased + this.start;
6618      if (this.options.step) {
6619        this.options.step.call(this.elem, this.now, this);
6620      }
6621      if (hooks && hooks.set) {
6622        hooks.set(this);
6623      } else {
6624        Tween.propHooks._default.set(this);
6625      }
6626      return this;
6627    }
6628  };
6629  Tween.prototype.init.prototype = Tween.prototype;
6630  Tween.propHooks = {
6631    _default: {
6632      get: function get(tween) {
6633        var result;
6634
6635        // Use a property on the element directly when it is not a DOM element,
6636        // or when there is no matching style property that exists.
6637        if (tween.elem.nodeType !== 1 || tween.elem[tween.prop] != null && tween.elem.style[tween.prop] == null) {
6638          return tween.elem[tween.prop];
6639        }
6640
6641        // Passing an empty string as a 3rd parameter to .css will automatically
6642        // attempt a parseFloat and fallback to a string if the parse fails.
6643        // Simple values such as "10px" are parsed to Float;
6644        // complex values such as "rotate(1rad)" are returned as-is.
6645        result = _jQuery2.css(tween.elem, tween.prop, "");
6646
6647        // Empty strings, null, undefined and "auto" are converted to 0.
6648        return !result || result === "auto" ? 0 : result;
6649      },
6650      set: function set(tween) {
6651        // Use step hook for back compat.
6652        // Use cssHook if its there.
6653        // Use .style if available and use plain properties where available.
6654        if (_jQuery2.fx.step[tween.prop]) {
6655          _jQuery2.fx.step[tween.prop](tween);
6656        } else if (tween.elem.nodeType === 1 && (_jQuery2.cssHooks[tween.prop] || tween.elem.style[finalPropName(tween.prop)] != null)) {
6657          _jQuery2.style(tween.elem, tween.prop, tween.now + tween.unit);
6658        } else {
6659          tween.elem[tween.prop] = tween.now;
6660        }
6661      }
6662    }
6663  };
6664
6665  // Support: IE <=9 only
6666  // Panic based approach to setting things on disconnected nodes
6667  Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
6668    set: function set(tween) {
6669      if (tween.elem.nodeType && tween.elem.parentNode) {
6670        tween.elem[tween.prop] = tween.now;
6671      }
6672    }
6673  };
6674  _jQuery2.easing = {
6675    linear: function linear(p) {
6676      return p;
6677    },
6678    swing: function swing(p) {
6679      return 0.5 - Math.cos(p * Math.PI) / 2;
6680    },
6681    _default: "swing"
6682  };
6683  _jQuery2.fx = Tween.prototype.init;
6684
6685  // Back compat <1.8 extension point
6686  _jQuery2.fx.step = {};
6687  var fxNow,
6688    inProgress,
6689    rfxtypes = /^(?:toggle|show|hide)$/,
6690    rrun = /queueHooks$/;
6691  function schedule() {
6692    if (inProgress) {
6693      if (document.hidden === false && window.requestAnimationFrame) {
6694        window.requestAnimationFrame(schedule);
6695      } else {
6696        window.setTimeout(schedule, _jQuery2.fx.interval);
6697      }
6698      _jQuery2.fx.tick();
6699    }
6700  }
6701
6702  // Animations created synchronously will run synchronously
6703  function createFxNow() {
6704    window.setTimeout(function () {
6705      fxNow = undefined;
6706    });
6707    return fxNow = Date.now();
6708  }
6709
6710  // Generate parameters to create a standard animation
6711  function genFx(type, includeWidth) {
6712    var which,
6713      i = 0,
6714      attrs = {
6715        height: type
6716      };
6717
6718    // If we include width, step value is 1 to do all cssExpand values,
6719    // otherwise step value is 2 to skip over Left and Right
6720    includeWidth = includeWidth ? 1 : 0;
6721    for (; i < 4; i += 2 - includeWidth) {
6722      which = cssExpand[i];
6723      attrs["margin" + which] = attrs["padding" + which] = type;
6724    }
6725    if (includeWidth) {
6726      attrs.opacity = attrs.width = type;
6727    }
6728    return attrs;
6729  }
6730  function createTween(value, prop, animation) {
6731    var tween,
6732      collection = (Animation.tweeners[prop] || []).concat(Animation.tweeners["*"]),
6733      index = 0,
6734      length = collection.length;
6735    for (; index < length; index++) {
6736      if (tween = collection[index].call(animation, prop, value)) {
6737        // We're done with this property
6738        return tween;
6739      }
6740    }
6741  }
6742  function defaultPrefilter(elem, props, opts) {
6743    var prop,
6744      value,
6745      toggle,
6746      hooks,
6747      oldfire,
6748      propTween,
6749      restoreDisplay,
6750      display,
6751      isBox = "width" in props || "height" in props,
6752      anim = this,
6753      orig = {},
6754      style = elem.style,
6755      hidden = elem.nodeType && isHiddenWithinTree(elem),
6756      dataShow = dataPriv.get(elem, "fxshow");
6757
6758    // Queue-skipping animations hijack the fx hooks
6759    if (!opts.queue) {
6760      hooks = _jQuery2._queueHooks(elem, "fx");
6761      if (hooks.unqueued == null) {
6762        hooks.unqueued = 0;
6763        oldfire = hooks.empty.fire;
6764        hooks.empty.fire = function () {
6765          if (!hooks.unqueued) {
6766            oldfire();
6767          }
6768        };
6769      }
6770      hooks.unqueued++;
6771      anim.always(function () {
6772        // Ensure the complete handler is called before this completes
6773        anim.always(function () {
6774          hooks.unqueued--;
6775          if (!_jQuery2.queue(elem, "fx").length) {
6776            hooks.empty.fire();
6777          }
6778        });
6779      });
6780    }
6781
6782    // Detect show/hide animations
6783    for (prop in props) {
6784      value = props[prop];
6785      if (rfxtypes.test(value)) {
6786        delete props[prop];
6787        toggle = toggle || value === "toggle";
6788        if (value === (hidden ? "hide" : "show")) {
6789          // Pretend to be hidden if this is a "show" and
6790          // there is still data from a stopped show/hide
6791          if (value === "show" && dataShow && dataShow[prop] !== undefined) {
6792            hidden = true;
6793
6794            // Ignore all other no-op show/hide data
6795          } else {
6796            continue;
6797          }
6798        }
6799        orig[prop] = dataShow && dataShow[prop] || _jQuery2.style(elem, prop);
6800      }
6801    }
6802
6803    // Bail out if this is a no-op like .hide().hide()
6804    propTween = !_jQuery2.isEmptyObject(props);
6805    if (!propTween && _jQuery2.isEmptyObject(orig)) {
6806      return;
6807    }
6808
6809    // Restrict "overflow" and "display" styles during box animations
6810    if (isBox && elem.nodeType === 1) {
6811      // Support: IE <=9 - 11, Edge 12 - 15
6812      // Record all 3 overflow attributes because IE does not infer the shorthand
6813      // from identically-valued overflowX and overflowY and Edge just mirrors
6814      // the overflowX value there.
6815      opts.overflow = [style.overflow, style.overflowX, style.overflowY];
6816
6817      // Identify a display type, preferring old show/hide data over the CSS cascade
6818      restoreDisplay = dataShow && dataShow.display;
6819      if (restoreDisplay == null) {
6820        restoreDisplay = dataPriv.get(elem, "display");
6821      }
6822      display = _jQuery2.css(elem, "display");
6823      if (display === "none") {
6824        if (restoreDisplay) {
6825          display = restoreDisplay;
6826        } else {
6827          // Get nonempty value(s) by temporarily forcing visibility
6828          showHide([elem], true);
6829          restoreDisplay = elem.style.display || restoreDisplay;
6830          display = _jQuery2.css(elem, "display");
6831          showHide([elem]);
6832        }
6833      }
6834
6835      // Animate inline elements as inline-block
6836      if (display === "inline" || display === "inline-block" && restoreDisplay != null) {
6837        if (_jQuery2.css(elem, "float") === "none") {
6838          // Restore the original display value at the end of pure show/hide animations
6839          if (!propTween) {
6840            anim.done(function () {
6841              style.display = restoreDisplay;
6842            });
6843            if (restoreDisplay == null) {
6844              display = style.display;
6845              restoreDisplay = display === "none" ? "" : display;
6846            }
6847          }
6848          style.display = "inline-block";
6849        }
6850      }
6851    }
6852    if (opts.overflow) {
6853      style.overflow = "hidden";
6854      anim.always(function () {
6855        style.overflow = opts.overflow[0];
6856        style.overflowX = opts.overflow[1];
6857        style.overflowY = opts.overflow[2];
6858      });
6859    }
6860
6861    // Implement show/hide animations
6862    propTween = false;
6863    for (prop in orig) {
6864      // General show/hide setup for this element animation
6865      if (!propTween) {
6866        if (dataShow) {
6867          if ("hidden" in dataShow) {
6868            hidden = dataShow.hidden;
6869          }
6870        } else {
6871          dataShow = dataPriv.access(elem, "fxshow", {
6872            display: restoreDisplay
6873          });
6874        }
6875
6876        // Store hidden/visible for toggle so `.stop().toggle()` "reverses"
6877        if (toggle) {
6878          dataShow.hidden = !hidden;
6879        }
6880
6881        // Show elements before animating them
6882        if (hidden) {
6883          showHide([elem], true);
6884        }
6885
6886        /* eslint-disable no-loop-func */
6887
6888        anim.done(function () {
6889          /* eslint-enable no-loop-func */
6890
6891          // The final step of a "hide" animation is actually hiding the element
6892          if (!hidden) {
6893            showHide([elem]);
6894          }
6895          dataPriv.remove(elem, "fxshow");
6896          for (prop in orig) {
6897            _jQuery2.style(elem, prop, orig[prop]);
6898          }
6899        });
6900      }
6901
6902      // Per-property setup
6903      propTween = createTween(hidden ? dataShow[prop] : 0, prop, anim);
6904      if (!(prop in dataShow)) {
6905        dataShow[prop] = propTween.start;
6906        if (hidden) {
6907          propTween.end = propTween.start;
6908          propTween.start = 0;
6909        }
6910      }
6911    }
6912  }
6913  function propFilter(props, specialEasing) {
6914    var index, name, easing, value, hooks;
6915
6916    // camelCase, specialEasing and expand cssHook pass
6917    for (index in props) {
6918      name = camelCase(index);
6919      easing = specialEasing[name];
6920      value = props[index];
6921      if (Array.isArray(value)) {
6922        easing = value[1];
6923        value = props[index] = value[0];
6924      }
6925      if (index !== name) {
6926        props[name] = value;
6927        delete props[index];
6928      }
6929      hooks = _jQuery2.cssHooks[name];
6930      if (hooks && "expand" in hooks) {
6931        value = hooks.expand(value);
6932        delete props[name];
6933
6934        // Not quite $.extend, this won't overwrite existing keys.
6935        // Reusing 'index' because we have the correct "name"
6936        for (index in value) {
6937          if (!(index in props)) {
6938            props[index] = value[index];
6939            specialEasing[index] = easing;
6940          }
6941        }
6942      } else {
6943        specialEasing[name] = easing;
6944      }
6945    }
6946  }
6947  function Animation(elem, properties, options) {
6948    var result,
6949      stopped,
6950      index = 0,
6951      length = Animation.prefilters.length,
6952      deferred = _jQuery2.Deferred().always(function () {
6953        // Don't match elem in the :animated selector
6954        delete tick.elem;
6955      }),
6956      tick = function tick() {
6957        if (stopped) {
6958          return false;
6959        }
6960        var currentTime = fxNow || createFxNow(),
6961          remaining = Math.max(0, animation.startTime + animation.duration - currentTime),
6962          // Support: Android 2.3 only
6963          // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (trac-12497)
6964          temp = remaining / animation.duration || 0,
6965          percent = 1 - temp,
6966          index = 0,
6967          length = animation.tweens.length;
6968        for (; index < length; index++) {
6969          animation.tweens[index].run(percent);
6970        }
6971        deferred.notifyWith(elem, [animation, percent, remaining]);
6972
6973        // If there's more to do, yield
6974        if (percent < 1 && length) {
6975          return remaining;
6976        }
6977
6978        // If this was an empty animation, synthesize a final progress notification
6979        if (!length) {
6980          deferred.notifyWith(elem, [animation, 1, 0]);
6981        }
6982
6983        // Resolve the animation and report its conclusion
6984        deferred.resolveWith(elem, [animation]);
6985        return false;
6986      },
6987      animation = deferred.promise({
6988        elem: elem,
6989        props: _jQuery2.extend({}, properties),
6990        opts: _jQuery2.extend(true, {
6991          specialEasing: {},
6992          easing: _jQuery2.easing._default
6993        }, options),
6994        originalProperties: properties,
6995        originalOptions: options,
6996        startTime: fxNow || createFxNow(),
6997        duration: options.duration,
6998        tweens: [],
6999        createTween: function createTween(prop, end) {
7000          var tween = _jQuery2.Tween(elem, animation.opts, prop, end, animation.opts.specialEasing[prop] || animation.opts.easing);
7001          animation.tweens.push(tween);
7002          return tween;
7003        },
7004        stop: function stop(gotoEnd) {
7005          var index = 0,
7006            // If we are going to the end, we want to run all the tweens
7007            // otherwise we skip this part
7008            length = gotoEnd ? animation.tweens.length : 0;
7009          if (stopped) {
7010            return this;
7011          }
7012          stopped = true;
7013          for (; index < length; index++) {
7014            animation.tweens[index].run(1);
7015          }
7016
7017          // Resolve when we played the last frame; otherwise, reject
7018          if (gotoEnd) {
7019            deferred.notifyWith(elem, [animation, 1, 0]);
7020            deferred.resolveWith(elem, [animation, gotoEnd]);
7021          } else {
7022            deferred.rejectWith(elem, [animation, gotoEnd]);
7023          }
7024          return this;
7025        }
7026      }),
7027      props = animation.props;
7028    propFilter(props, animation.opts.specialEasing);
7029    for (; index < length; index++) {
7030      result = Animation.prefilters[index].call(animation, elem, props, animation.opts);
7031      if (result) {
7032        if (isFunction(result.stop)) {
7033          _jQuery2._queueHooks(animation.elem, animation.opts.queue).stop = result.stop.bind(result);
7034        }
7035        return result;
7036      }
7037    }
7038    _jQuery2.map(props, createTween, animation);
7039    if (isFunction(animation.opts.start)) {
7040      animation.opts.start.call(elem, animation);
7041    }
7042
7043    // Attach callbacks from options
7044    animation.progress(animation.opts.progress).done(animation.opts.done, animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always);
7045    _jQuery2.fx.timer(_jQuery2.extend(tick, {
7046      elem: elem,
7047      anim: animation,
7048      queue: animation.opts.queue
7049    }));
7050    return animation;
7051  }
7052  _jQuery2.Animation = _jQuery2.extend(Animation, {
7053    tweeners: {
7054      "*": [function (prop, value) {
7055        var tween = this.createTween(prop, value);
7056        adjustCSS(tween.elem, prop, rcssNum.exec(value), tween);
7057        return tween;
7058      }]
7059    },
7060    tweener: function tweener(props, callback) {
7061      if (isFunction(props)) {
7062        callback = props;
7063        props = ["*"];
7064      } else {
7065        props = props.match(rnothtmlwhite);
7066      }
7067      var prop,
7068        index = 0,
7069        length = props.length;
7070      for (; index < length; index++) {
7071        prop = props[index];
7072        Animation.tweeners[prop] = Animation.tweeners[prop] || [];
7073        Animation.tweeners[prop].unshift(callback);
7074      }
7075    },
7076    prefilters: [defaultPrefilter],
7077    prefilter: function prefilter(callback, prepend) {
7078      if (prepend) {
7079        Animation.prefilters.unshift(callback);
7080      } else {
7081        Animation.prefilters.push(callback);
7082      }
7083    }
7084  });
7085  _jQuery2.speed = function (speed, easing, fn) {
7086    var opt = speed && _typeof(speed) === "object" ? _jQuery2.extend({}, speed) : {
7087      complete: fn || !fn && easing || isFunction(speed) && speed,
7088      duration: speed,
7089      easing: fn && easing || easing && !isFunction(easing) && easing
7090    };
7091
7092    // Go to the end state if fx are off
7093    if (_jQuery2.fx.off) {
7094      opt.duration = 0;
7095    } else {
7096      if (typeof opt.duration !== "number") {
7097        if (opt.duration in _jQuery2.fx.speeds) {
7098          opt.duration = _jQuery2.fx.speeds[opt.duration];
7099        } else {
7100          opt.duration = _jQuery2.fx.speeds._default;
7101        }
7102      }
7103    }
7104
7105    // Normalize opt.queue - true/undefined/null -> "fx"
7106    if (opt.queue == null || opt.queue === true) {
7107      opt.queue = "fx";
7108    }
7109
7110    // Queueing
7111    opt.old = opt.complete;
7112    opt.complete = function () {
7113      if (isFunction(opt.old)) {
7114        opt.old.call(this);
7115      }
7116      if (opt.queue) {
7117        _jQuery2.dequeue(this, opt.queue);
7118      }
7119    };
7120    return opt;
7121  };
7122  _jQuery2.fn.extend({
7123    fadeTo: function fadeTo(speed, to, easing, callback) {
7124      // Show any hidden elements after setting opacity to 0
7125      return this.filter(isHiddenWithinTree).css("opacity", 0).show()
7126
7127      // Animate to the value specified
7128      .end().animate({
7129        opacity: to
7130      }, speed, easing, callback);
7131    },
7132    animate: function animate(prop, speed, easing, callback) {
7133      var empty = _jQuery2.isEmptyObject(prop),
7134        optall = _jQuery2.speed(speed, easing, callback),
7135        doAnimation = function doAnimation() {
7136          // Operate on a copy of prop so per-property easing won't be lost
7137          var anim = Animation(this, _jQuery2.extend({}, prop), optall);
7138
7139          // Empty animations, or finishing resolves immediately
7140          if (empty || dataPriv.get(this, "finish")) {
7141            anim.stop(true);
7142          }
7143        };
7144      doAnimation.finish = doAnimation;
7145      return empty || optall.queue === false ? this.each(doAnimation) : this.queue(optall.queue, doAnimation);
7146    },
7147    stop: function stop(type, clearQueue, gotoEnd) {
7148      var stopQueue = function stopQueue(hooks) {
7149        var stop = hooks.stop;
7150        delete hooks.stop;
7151        stop(gotoEnd);
7152      };
7153      if (typeof type !== "string") {
7154        gotoEnd = clearQueue;
7155        clearQueue = type;
7156        type = undefined;
7157      }
7158      if (clearQueue) {
7159        this.queue(type || "fx", []);
7160      }
7161      return this.each(function () {
7162        var dequeue = true,
7163          index = type != null && type + "queueHooks",
7164          timers = _jQuery2.timers,
7165          data = dataPriv.get(this);
7166        if (index) {
7167          if (data[index] && data[index].stop) {
7168            stopQueue(data[index]);
7169          }
7170        } else {
7171          for (index in data) {
7172            if (data[index] && data[index].stop && rrun.test(index)) {
7173              stopQueue(data[index]);
7174            }
7175          }
7176        }
7177        for (index = timers.length; index--;) {
7178          if (timers[index].elem === this && (type == null || timers[index].queue === type)) {
7179            timers[index].anim.stop(gotoEnd);
7180            dequeue = false;
7181            timers.splice(index, 1);
7182          }
7183        }
7184
7185        // Start the next in the queue if the last step wasn't forced.
7186        // Timers currently will call their complete callbacks, which
7187        // will dequeue but only if they were gotoEnd.
7188        if (dequeue || !gotoEnd) {
7189          _jQuery2.dequeue(this, type);
7190        }
7191      });
7192    },
7193    finish: function finish(type) {
7194      if (type !== false) {
7195        type = type || "fx";
7196      }
7197      return this.each(function () {
7198        var index,
7199          data = dataPriv.get(this),
7200          queue = data[type + "queue"],
7201          hooks = data[type + "queueHooks"],
7202          timers = _jQuery2.timers,
7203          length = queue ? queue.length : 0;
7204
7205        // Enable finishing flag on private data
7206        data.finish = true;
7207
7208        // Empty the queue first
7209        _jQuery2.queue(this, type, []);
7210        if (hooks && hooks.stop) {
7211          hooks.stop.call(this, true);
7212        }
7213
7214        // Look for any active animations, and finish them
7215        for (index = timers.length; index--;) {
7216          if (timers[index].elem === this && timers[index].queue === type) {
7217            timers[index].anim.stop(true);
7218            timers.splice(index, 1);
7219          }
7220        }
7221
7222        // Look for any animations in the old queue and finish them
7223        for (index = 0; index < length; index++) {
7224          if (queue[index] && queue[index].finish) {
7225            queue[index].finish.call(this);
7226          }
7227        }
7228
7229        // Turn off finishing flag
7230        delete data.finish;
7231      });
7232    }
7233  });
7234  _jQuery2.each(["toggle", "show", "hide"], function (_i, name) {
7235    var cssFn = _jQuery2.fn[name];
7236    _jQuery2.fn[name] = function (speed, easing, callback) {
7237      return speed == null || typeof speed === "boolean" ? cssFn.apply(this, arguments) : this.animate(genFx(name, true), speed, easing, callback);
7238    };
7239  });
7240
7241  // Generate shortcuts for custom animations
7242  _jQuery2.each({
7243    slideDown: genFx("show"),
7244    slideUp: genFx("hide"),
7245    slideToggle: genFx("toggle"),
7246    fadeIn: {
7247      opacity: "show"
7248    },
7249    fadeOut: {
7250      opacity: "hide"
7251    },
7252    fadeToggle: {
7253      opacity: "toggle"
7254    }
7255  }, function (name, props) {
7256    _jQuery2.fn[name] = function (speed, easing, callback) {
7257      return this.animate(props, speed, easing, callback);
7258    };
7259  });
7260  _jQuery2.timers = [];
7261  _jQuery2.fx.tick = function () {
7262    var timer,
7263      i = 0,
7264      timers = _jQuery2.timers;
7265    fxNow = Date.now();
7266    for (; i < timers.length; i++) {
7267      timer = timers[i];
7268
7269      // Run the timer and safely remove it when done (allowing for external removal)
7270      if (!timer() && timers[i] === timer) {
7271        timers.splice(i--, 1);
7272      }
7273    }
7274    if (!timers.length) {
7275      _jQuery2.fx.stop();
7276    }
7277    fxNow = undefined;
7278  };
7279  _jQuery2.fx.timer = function (timer) {
7280    _jQuery2.timers.push(timer);
7281    _jQuery2.fx.start();
7282  };
7283  _jQuery2.fx.interval = 13;
7284  _jQuery2.fx.start = function () {
7285    if (inProgress) {
7286      return;
7287    }
7288    inProgress = true;
7289    schedule();
7290  };
7291  _jQuery2.fx.stop = function () {
7292    inProgress = null;
7293  };
7294  _jQuery2.fx.speeds = {
7295    slow: 600,
7296    fast: 200,
7297    // Default speed
7298    _default: 400
7299  };
7300
7301  // Based off of the plugin by Clint Helfers, with permission.
7302  _jQuery2.fn.delay = function (time, type) {
7303    time = _jQuery2.fx ? _jQuery2.fx.speeds[time] || time : time;
7304    type = type || "fx";
7305    return this.queue(type, function (next, hooks) {
7306      var timeout = window.setTimeout(next, time);
7307      hooks.stop = function () {
7308        window.clearTimeout(timeout);
7309      };
7310    });
7311  };
7312  (function () {
7313    var input = document.createElement("input"),
7314      select = document.createElement("select"),
7315      opt = select.appendChild(document.createElement("option"));
7316    input.type = "checkbox";
7317
7318    // Support: Android <=4.3 only
7319    // Default value for a checkbox should be "on"
7320    support.checkOn = input.value !== "";
7321
7322    // Support: IE <=11 only
7323    // Must access selectedIndex to make default options select
7324    support.optSelected = opt.selected;
7325
7326    // Support: IE <=11 only
7327    // An input loses its value after becoming a radio
7328    input = document.createElement("input");
7329    input.value = "t";
7330    input.type = "radio";
7331    support.radioValue = input.value === "t";
7332  })();
7333  var boolHook,
7334    attrHandle = _jQuery2.expr.attrHandle;
7335  _jQuery2.fn.extend({
7336    attr: function attr(name, value) {
7337      return _access(this, _jQuery2.attr, name, value, arguments.length > 1);
7338    },
7339    removeAttr: function removeAttr(name) {
7340      return this.each(function () {
7341        _jQuery2.removeAttr(this, name);
7342      });
7343    }
7344  });
7345  _jQuery2.extend({
7346    attr: function attr(elem, name, value) {
7347      var ret,
7348        hooks,
7349        nType = elem.nodeType;
7350
7351      // Don't get/set attributes on text, comment and attribute nodes
7352      if (nType === 3 || nType === 8 || nType === 2) {
7353        return;
7354      }
7355
7356      // Fallback to prop when attributes are not supported
7357      if (typeof elem.getAttribute === "undefined") {
7358        return _jQuery2.prop(elem, name, value);
7359      }
7360
7361      // Attribute hooks are determined by the lowercase version
7362      // Grab necessary hook if one is defined
7363      if (nType !== 1 || !_jQuery2.isXMLDoc(elem)) {
7364        hooks = _jQuery2.attrHooks[name.toLowerCase()] || (_jQuery2.expr.match.bool.test(name) ? boolHook : undefined);
7365      }
7366      if (value !== undefined) {
7367        if (value === null) {
7368          _jQuery2.removeAttr(elem, name);
7369          return;
7370        }
7371        if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {
7372          return ret;
7373        }
7374        elem.setAttribute(name, value + "");
7375        return value;
7376      }
7377      if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) {
7378        return ret;
7379      }
7380      ret = _jQuery2.find.attr(elem, name);
7381
7382      // Non-existent attributes return null, we normalize to undefined
7383      return ret == null ? undefined : ret;
7384    },
7385    attrHooks: {
7386      type: {
7387        set: function set(elem, value) {
7388          if (!support.radioValue && value === "radio" && nodeName(elem, "input")) {
7389            var val = elem.value;
7390            elem.setAttribute("type", value);
7391            if (val) {
7392              elem.value = val;
7393            }
7394            return value;
7395          }
7396        }
7397      }
7398    },
7399    removeAttr: function removeAttr(elem, value) {
7400      var name,
7401        i = 0,
7402        // Attribute names can contain non-HTML whitespace characters
7403        // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
7404        attrNames = value && value.match(rnothtmlwhite);
7405      if (attrNames && elem.nodeType === 1) {
7406        while (name = attrNames[i++]) {
7407          elem.removeAttribute(name);
7408        }
7409      }
7410    }
7411  });
7412
7413  // Hooks for boolean attributes
7414  boolHook = {
7415    set: function set(elem, value, name) {
7416      if (value === false) {
7417        // Remove boolean attributes when set to false
7418        _jQuery2.removeAttr(elem, name);
7419      } else {
7420        elem.setAttribute(name, name);
7421      }
7422      return name;
7423    }
7424  };
7425  _jQuery2.each(_jQuery2.expr.match.bool.source.match(/\w+/g), function (_i, name) {
7426    var getter = attrHandle[name] || _jQuery2.find.attr;
7427    attrHandle[name] = function (elem, name, isXML) {
7428      var ret,
7429        handle,
7430        lowercaseName = name.toLowerCase();
7431      if (!isXML) {
7432        // Avoid an infinite loop by temporarily removing this function from the getter
7433        handle = attrHandle[lowercaseName];
7434        attrHandle[lowercaseName] = ret;
7435        ret = getter(elem, name, isXML) != null ? lowercaseName : null;
7436        attrHandle[lowercaseName] = handle;
7437      }
7438      return ret;
7439    };
7440  });
7441  var rfocusable = /^(?:input|select|textarea|button)$/i,
7442    rclickable = /^(?:a|area)$/i;
7443  _jQuery2.fn.extend({
7444    prop: function prop(name, value) {
7445      return _access(this, _jQuery2.prop, name, value, arguments.length > 1);
7446    },
7447    removeProp: function removeProp(name) {
7448      return this.each(function () {
7449        delete this[_jQuery2.propFix[name] || name];
7450      });
7451    }
7452  });
7453  _jQuery2.extend({
7454    prop: function prop(elem, name, value) {
7455      var ret,
7456        hooks,
7457        nType = elem.nodeType;
7458
7459      // Don't get/set properties on text, comment and attribute nodes
7460      if (nType === 3 || nType === 8 || nType === 2) {
7461        return;
7462      }
7463      if (nType !== 1 || !_jQuery2.isXMLDoc(elem)) {
7464        // Fix name and attach hooks
7465        name = _jQuery2.propFix[name] || name;
7466        hooks = _jQuery2.propHooks[name];
7467      }
7468      if (value !== undefined) {
7469        if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {
7470          return ret;
7471        }
7472        return elem[name] = value;
7473      }
7474      if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) {
7475        return ret;
7476      }
7477      return elem[name];
7478    },
7479    propHooks: {
7480      tabIndex: {
7481        get: function get(elem) {
7482          // Support: IE <=9 - 11 only
7483          // elem.tabIndex doesn't always return the
7484          // correct value when it hasn't been explicitly set
7485          // Use proper attribute retrieval (trac-12072)
7486          var tabindex = _jQuery2.find.attr(elem, "tabindex");
7487          if (tabindex) {
7488            return parseInt(tabindex, 10);
7489          }
7490          if (rfocusable.test(elem.nodeName) || rclickable.test(elem.nodeName) && elem.href) {
7491            return 0;
7492          }
7493          return -1;
7494        }
7495      }
7496    },
7497    propFix: {
7498      "for": "htmlFor",
7499      "class": "className"
7500    }
7501  });
7502
7503  // Support: IE <=11 only
7504  // Accessing the selectedIndex property
7505  // forces the browser to respect setting selected
7506  // on the option
7507  // The getter ensures a default option is selected
7508  // when in an optgroup
7509  // eslint rule "no-unused-expressions" is disabled for this code
7510  // since it considers such accessions noop
7511  if (!support.optSelected) {
7512    _jQuery2.propHooks.selected = {
7513      get: function get(elem) {
7514        /* eslint no-unused-expressions: "off" */
7515
7516        var parent = elem.parentNode;
7517        if (parent && parent.parentNode) {
7518          parent.parentNode.selectedIndex;
7519        }
7520        return null;
7521      },
7522      set: function set(elem) {
7523        /* eslint no-unused-expressions: "off" */
7524
7525        var parent = elem.parentNode;
7526        if (parent) {
7527          parent.selectedIndex;
7528          if (parent.parentNode) {
7529            parent.parentNode.selectedIndex;
7530          }
7531        }
7532      }
7533    };
7534  }
7535  _jQuery2.each(["tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable"], function () {
7536    _jQuery2.propFix[this.toLowerCase()] = this;
7537  });
7538
7539  // Strip and collapse whitespace according to HTML spec
7540  // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
7541  function stripAndCollapse(value) {
7542    var tokens = value.match(rnothtmlwhite) || [];
7543    return tokens.join(" ");
7544  }
7545  function getClass(elem) {
7546    return elem.getAttribute && elem.getAttribute("class") || "";
7547  }
7548  function classesToArray(value) {
7549    if (Array.isArray(value)) {
7550      return value;
7551    }
7552    if (typeof value === "string") {
7553      return value.match(rnothtmlwhite) || [];
7554    }
7555    return [];
7556  }
7557  _jQuery2.fn.extend({
7558    addClass: function addClass(value) {
7559      var classNames, cur, curValue, className, i, finalValue;
7560      if (isFunction(value)) {
7561        return this.each(function (j) {
7562          _jQuery2(this).addClass(value.call(this, j, getClass(this)));
7563        });
7564      }
7565      classNames = classesToArray(value);
7566      if (classNames.length) {
7567        return this.each(function () {
7568          curValue = getClass(this);
7569          cur = this.nodeType === 1 && " " + stripAndCollapse(curValue) + " ";
7570          if (cur) {
7571            for (i = 0; i < classNames.length; i++) {
7572              className = classNames[i];
7573              if (cur.indexOf(" " + className + " ") < 0) {
7574                cur += className + " ";
7575              }
7576            }
7577
7578            // Only assign if different to avoid unneeded rendering.
7579            finalValue = stripAndCollapse(cur);
7580            if (curValue !== finalValue) {
7581              this.setAttribute("class", finalValue);
7582            }
7583          }
7584        });
7585      }
7586      return this;
7587    },
7588    removeClass: function removeClass(value) {
7589      var classNames, cur, curValue, className, i, finalValue;
7590      if (isFunction(value)) {
7591        return this.each(function (j) {
7592          _jQuery2(this).removeClass(value.call(this, j, getClass(this)));
7593        });
7594      }
7595      if (!arguments.length) {
7596        return this.attr("class", "");
7597      }
7598      classNames = classesToArray(value);
7599      if (classNames.length) {
7600        return this.each(function () {
7601          curValue = getClass(this);
7602
7603          // This expression is here for better compressibility (see addClass)
7604          cur = this.nodeType === 1 && " " + stripAndCollapse(curValue) + " ";
7605          if (cur) {
7606            for (i = 0; i < classNames.length; i++) {
7607              className = classNames[i];
7608
7609              // Remove *all* instances
7610              while (cur.indexOf(" " + className + " ") > -1) {
7611                cur = cur.replace(" " + className + " ", " ");
7612              }
7613            }
7614
7615            // Only assign if different to avoid unneeded rendering.
7616            finalValue = stripAndCollapse(cur);
7617            if (curValue !== finalValue) {
7618              this.setAttribute("class", finalValue);
7619            }
7620          }
7621        });
7622      }
7623      return this;
7624    },
7625    toggleClass: function toggleClass(value, stateVal) {
7626      var classNames,
7627        className,
7628        i,
7629        self,
7630        type = _typeof(value),
7631        isValidValue = type === "string" || Array.isArray(value);
7632      if (isFunction(value)) {
7633        return this.each(function (i) {
7634          _jQuery2(this).toggleClass(value.call(this, i, getClass(this), stateVal), stateVal);
7635        });
7636      }
7637      if (typeof stateVal === "boolean" && isValidValue) {
7638        return stateVal ? this.addClass(value) : this.removeClass(value);
7639      }
7640      classNames = classesToArray(value);
7641      return this.each(function () {
7642        if (isValidValue) {
7643          // Toggle individual class names
7644          self = _jQuery2(this);
7645          for (i = 0; i < classNames.length; i++) {
7646            className = classNames[i];
7647
7648            // Check each className given, space separated list
7649            if (self.hasClass(className)) {
7650              self.removeClass(className);
7651            } else {
7652              self.addClass(className);
7653            }
7654          }
7655
7656          // Toggle whole class name
7657        } else if (value === undefined || type === "boolean") {
7658          className = getClass(this);
7659          if (className) {
7660            // Store className if set
7661            dataPriv.set(this, "__className__", className);
7662          }
7663
7664          // If the element has a class name or if we're passed `false`,
7665          // then remove the whole classname (if there was one, the above saved it).
7666          // Otherwise bring back whatever was previously saved (if anything),
7667          // falling back to the empty string if nothing was stored.
7668          if (this.setAttribute) {
7669            this.setAttribute("class", className || value === false ? "" : dataPriv.get(this, "__className__") || "");
7670          }
7671        }
7672      });
7673    },
7674    hasClass: function hasClass(selector) {
7675      var className,
7676        elem,
7677        i = 0;
7678      className = " " + selector + " ";
7679      while (elem = this[i++]) {
7680        if (elem.nodeType === 1 && (" " + stripAndCollapse(getClass(elem)) + " ").indexOf(className) > -1) {
7681          return true;
7682        }
7683      }
7684      return false;
7685    }
7686  });
7687  var rreturn = /\r/g;
7688  _jQuery2.fn.extend({
7689    val: function val(value) {
7690      var hooks,
7691        ret,
7692        valueIsFunction,
7693        elem = this[0];
7694      if (!arguments.length) {
7695        if (elem) {
7696          hooks = _jQuery2.valHooks[elem.type] || _jQuery2.valHooks[elem.nodeName.toLowerCase()];
7697          if (hooks && "get" in hooks && (ret = hooks.get(elem, "value")) !== undefined) {
7698            return ret;
7699          }
7700          ret = elem.value;
7701
7702          // Handle most common string cases
7703          if (typeof ret === "string") {
7704            return ret.replace(rreturn, "");
7705          }
7706
7707          // Handle cases where value is null/undef or number
7708          return ret == null ? "" : ret;
7709        }
7710        return;
7711      }
7712      valueIsFunction = isFunction(value);
7713      return this.each(function (i) {
7714        var val;
7715        if (this.nodeType !== 1) {
7716          return;
7717        }
7718        if (valueIsFunction) {
7719          val = value.call(this, i, _jQuery2(this).val());
7720        } else {
7721          val = value;
7722        }
7723
7724        // Treat null/undefined as ""; convert numbers to string
7725        if (val == null) {
7726          val = "";
7727        } else if (typeof val === "number") {
7728          val += "";
7729        } else if (Array.isArray(val)) {
7730          val = _jQuery2.map(val, function (value) {
7731            return value == null ? "" : value + "";
7732          });
7733        }
7734        hooks = _jQuery2.valHooks[this.type] || _jQuery2.valHooks[this.nodeName.toLowerCase()];
7735
7736        // If set returns undefined, fall back to normal setting
7737        if (!hooks || !("set" in hooks) || hooks.set(this, val, "value") === undefined) {
7738          this.value = val;
7739        }
7740      });
7741    }
7742  });
7743  _jQuery2.extend({
7744    valHooks: {
7745      option: {
7746        get: function get(elem) {
7747          var val = _jQuery2.find.attr(elem, "value");
7748          return val != null ? val :
7749          // Support: IE <=10 - 11 only
7750          // option.text throws exceptions (trac-14686, trac-14858)
7751          // Strip and collapse whitespace
7752          // https://html.spec.whatwg.org/#strip-and-collapse-whitespace
7753          stripAndCollapse(_jQuery2.text(elem));
7754        }
7755      },
7756      select: {
7757        get: function get(elem) {
7758          var value,
7759            option,
7760            i,
7761            options = elem.options,
7762            index = elem.selectedIndex,
7763            one = elem.type === "select-one",
7764            values = one ? null : [],
7765            max = one ? index + 1 : options.length;
7766          if (index < 0) {
7767            i = max;
7768          } else {
7769            i = one ? index : 0;
7770          }
7771
7772          // Loop through all the selected options
7773          for (; i < max; i++) {
7774            option = options[i];
7775
7776            // Support: IE <=9 only
7777            // IE8-9 doesn't update selected after form reset (trac-2551)
7778            if ((option.selected || i === index) &&
7779            // Don't return options that are disabled or in a disabled optgroup
7780            !option.disabled && (!option.parentNode.disabled || !nodeName(option.parentNode, "optgroup"))) {
7781              // Get the specific value for the option
7782              value = _jQuery2(option).val();
7783
7784              // We don't need an array for one selects
7785              if (one) {
7786                return value;
7787              }
7788
7789              // Multi-Selects return an array
7790              values.push(value);
7791            }
7792          }
7793          return values;
7794        },
7795        set: function set(elem, value) {
7796          var optionSet,
7797            option,
7798            options = elem.options,
7799            values = _jQuery2.makeArray(value),
7800            i = options.length;
7801          while (i--) {
7802            option = options[i];
7803
7804            /* eslint-disable no-cond-assign */
7805
7806            if (option.selected = _jQuery2.inArray(_jQuery2.valHooks.option.get(option), values) > -1) {
7807              optionSet = true;
7808            }
7809
7810            /* eslint-enable no-cond-assign */
7811          }
7812
7813          // Force browsers to behave consistently when non-matching value is set
7814          if (!optionSet) {
7815            elem.selectedIndex = -1;
7816          }
7817          return values;
7818        }
7819      }
7820    }
7821  });
7822
7823  // Radios and checkboxes getter/setter
7824  _jQuery2.each(["radio", "checkbox"], function () {
7825    _jQuery2.valHooks[this] = {
7826      set: function set(elem, value) {
7827        if (Array.isArray(value)) {
7828          return elem.checked = _jQuery2.inArray(_jQuery2(elem).val(), value) > -1;
7829        }
7830      }
7831    };
7832    if (!support.checkOn) {
7833      _jQuery2.valHooks[this].get = function (elem) {
7834        return elem.getAttribute("value") === null ? "on" : elem.value;
7835      };
7836    }
7837  });
7838
7839  // Return jQuery for attributes-only inclusion
7840  var location = window.location;
7841  var nonce = {
7842    guid: Date.now()
7843  };
7844  var rquery = /\?/;
7845
7846  // Cross-browser xml parsing
7847  _jQuery2.parseXML = function (data) {
7848    var xml, parserErrorElem;
7849    if (!data || typeof data !== "string") {
7850      return null;
7851    }
7852
7853    // Support: IE 9 - 11 only
7854    // IE throws on parseFromString with invalid input.
7855    try {
7856      xml = new window.DOMParser().parseFromString(data, "text/xml");
7857    } catch (e) {}
7858    parserErrorElem = xml && xml.getElementsByTagName("parsererror")[0];
7859    if (!xml || parserErrorElem) {
7860      _jQuery2.error("Invalid XML: " + (parserErrorElem ? _jQuery2.map(parserErrorElem.childNodes, function (el) {
7861        return el.textContent;
7862      }).join("\n") : data));
7863    }
7864    return xml;
7865  };
7866  var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
7867    stopPropagationCallback = function stopPropagationCallback(e) {
7868      e.stopPropagation();
7869    };
7870  _jQuery2.extend(_jQuery2.event, {
7871    trigger: function trigger(event, data, elem, onlyHandlers) {
7872      var i,
7873        cur,
7874        tmp,
7875        bubbleType,
7876        ontype,
7877        handle,
7878        special,
7879        lastElement,
7880        eventPath = [elem || document],
7881        type = hasOwn.call(event, "type") ? event.type : event,
7882        namespaces = hasOwn.call(event, "namespace") ? event.namespace.split(".") : [];
7883      cur = lastElement = tmp = elem = elem || document;
7884
7885      // Don't do events on text and comment nodes
7886      if (elem.nodeType === 3 || elem.nodeType === 8) {
7887        return;
7888      }
7889
7890      // focus/blur morphs to focusin/out; ensure we're not firing them right now
7891      if (rfocusMorph.test(type + _jQuery2.event.triggered)) {
7892        return;
7893      }
7894      if (type.indexOf(".") > -1) {
7895        // Namespaced trigger; create a regexp to match event type in handle()
7896        namespaces = type.split(".");
7897        type = namespaces.shift();
7898        namespaces.sort();
7899      }
7900      ontype = type.indexOf(":") < 0 && "on" + type;
7901
7902      // Caller can pass in a jQuery.Event object, Object, or just an event type string
7903      event = event[_jQuery2.expando] ? event : new _jQuery2.Event(type, _typeof(event) === "object" && event);
7904
7905      // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
7906      event.isTrigger = onlyHandlers ? 2 : 3;
7907      event.namespace = namespaces.join(".");
7908      event.rnamespace = event.namespace ? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
7909
7910      // Clean up the event in case it is being reused
7911      event.result = undefined;
7912      if (!event.target) {
7913        event.target = elem;
7914      }
7915
7916      // Clone any incoming data and prepend the event, creating the handler arg list
7917      data = data == null ? [event] : _jQuery2.makeArray(data, [event]);
7918
7919      // Allow special events to draw outside the lines
7920      special = _jQuery2.event.special[type] || {};
7921      if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) {
7922        return;
7923      }
7924
7925      // Determine event propagation path in advance, per W3C events spec (trac-9951)
7926      // Bubble up to document, then to window; watch for a global ownerDocument var (trac-9724)
7927      if (!onlyHandlers && !special.noBubble && !isWindow(elem)) {
7928        bubbleType = special.delegateType || type;
7929        if (!rfocusMorph.test(bubbleType + type)) {
7930          cur = cur.parentNode;
7931        }
7932        for (; cur; cur = cur.parentNode) {
7933          eventPath.push(cur);
7934          tmp = cur;
7935        }
7936
7937        // Only add window if we got to document (e.g., not plain obj or detached DOM)
7938        if (tmp === (elem.ownerDocument || document)) {
7939          eventPath.push(tmp.defaultView || tmp.parentWindow || window);
7940        }
7941      }
7942
7943      // Fire handlers on the event path
7944      i = 0;
7945      while ((cur = eventPath[i++]) && !event.isPropagationStopped()) {
7946        lastElement = cur;
7947        event.type = i > 1 ? bubbleType : special.bindType || type;
7948
7949        // jQuery handler
7950        handle = (dataPriv.get(cur, "events") || Object.create(null))[event.type] && dataPriv.get(cur, "handle");
7951        if (handle) {
7952          handle.apply(cur, data);
7953        }
7954
7955        // Native handler
7956        handle = ontype && cur[ontype];
7957        if (handle && handle.apply && acceptData(cur)) {
7958          event.result = handle.apply(cur, data);
7959          if (event.result === false) {
7960            event.preventDefault();
7961          }
7962        }
7963      }
7964      event.type = type;
7965
7966      // If nobody prevented the default action, do it now
7967      if (!onlyHandlers && !event.isDefaultPrevented()) {
7968        if ((!special._default || special._default.apply(eventPath.pop(), data) === false) && acceptData(elem)) {
7969          // Call a native DOM method on the target with the same name as the event.
7970          // Don't do default actions on window, that's where global variables be (trac-6170)
7971          if (ontype && isFunction(elem[type]) && !isWindow(elem)) {
7972            // Don't re-trigger an onFOO event when we call its FOO() method
7973            tmp = elem[ontype];
7974            if (tmp) {
7975              elem[ontype] = null;
7976            }
7977
7978            // Prevent re-triggering of the same event, since we already bubbled it above
7979            _jQuery2.event.triggered = type;
7980            if (event.isPropagationStopped()) {
7981              lastElement.addEventListener(type, stopPropagationCallback);
7982            }
7983            elem[type]();
7984            if (event.isPropagationStopped()) {
7985              lastElement.removeEventListener(type, stopPropagationCallback);
7986            }
7987            _jQuery2.event.triggered = undefined;
7988            if (tmp) {
7989              elem[ontype] = tmp;
7990            }
7991          }
7992        }
7993      }
7994      return event.result;
7995    },
7996    // Piggyback on a donor event to simulate a different one
7997    // Used only for `focus(in | out)` events
7998    simulate: function simulate(type, elem, event) {
7999      var e = _jQuery2.extend(new _jQuery2.Event(), event, {
8000        type: type,
8001        isSimulated: true
8002      });
8003      _jQuery2.event.trigger(e, null, elem);
8004    }
8005  });
8006  _jQuery2.fn.extend({
8007    trigger: function trigger(type, data) {
8008      return this.each(function () {
8009        _jQuery2.event.trigger(type, data, this);
8010      });
8011    },
8012    triggerHandler: function triggerHandler(type, data) {
8013      var elem = this[0];
8014      if (elem) {
8015        return _jQuery2.event.trigger(type, data, elem, true);
8016      }
8017    }
8018  });
8019  var rbracket = /\[\]$/,
8020    rCRLF = /\r?\n/g,
8021    rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
8022    rsubmittable = /^(?:input|select|textarea|keygen)/i;
8023  function buildParams(prefix, obj, traditional, add) {
8024    var name;
8025    if (Array.isArray(obj)) {
8026      // Serialize array item.
8027      _jQuery2.each(obj, function (i, v) {
8028        if (traditional || rbracket.test(prefix)) {
8029          // Treat each array item as a scalar.
8030          add(prefix, v);
8031        } else {
8032          // Item is non-scalar (array or object), encode its numeric index.
8033          buildParams(prefix + "[" + (_typeof(v) === "object" && v != null ? i : "") + "]", v, traditional, add);
8034        }
8035      });
8036    } else if (!traditional && toType(obj) === "object") {
8037      // Serialize object item.
8038      for (name in obj) {
8039        buildParams(prefix + "[" + name + "]", obj[name], traditional, add);
8040      }
8041    } else {
8042      // Serialize scalar item.
8043      add(prefix, obj);
8044    }
8045  }
8046
8047  // Serialize an array of form elements or a set of
8048  // key/values into a query string
8049  _jQuery2.param = function (a, traditional) {
8050    var prefix,
8051      s = [],
8052      add = function add(key, valueOrFunction) {
8053        // If value is a function, invoke it and use its return value
8054        var value = isFunction(valueOrFunction) ? valueOrFunction() : valueOrFunction;
8055        s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value == null ? "" : value);
8056      };
8057    if (a == null) {
8058      return "";
8059    }
8060
8061    // If an array was passed in, assume that it is an array of form elements.
8062    if (Array.isArray(a) || a.jquery && !_jQuery2.isPlainObject(a)) {
8063      // Serialize the form elements
8064      _jQuery2.each(a, function () {
8065        add(this.name, this.value);
8066      });
8067    } else {
8068      // If traditional, encode the "old" way (the way 1.3.2 or older
8069      // did it), otherwise encode params recursively.
8070      for (prefix in a) {
8071        buildParams(prefix, a[prefix], traditional, add);
8072      }
8073    }
8074
8075    // Return the resulting serialization
8076    return s.join("&");
8077  };
8078  _jQuery2.fn.extend({
8079    serialize: function serialize() {
8080      return _jQuery2.param(this.serializeArray());
8081    },
8082    serializeArray: function serializeArray() {
8083      return this.map(function () {
8084        // Can add propHook for "elements" to filter or add form elements
8085        var elements = _jQuery2.prop(this, "elements");
8086        return elements ? _jQuery2.makeArray(elements) : this;
8087      }).filter(function () {
8088        var type = this.type;
8089
8090        // Use .is( ":disabled" ) so that fieldset[disabled] works
8091        return this.name && !_jQuery2(this).is(":disabled") && rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) && (this.checked || !rcheckableType.test(type));
8092      }).map(function (_i, elem) {
8093        var val = _jQuery2(this).val();
8094        if (val == null) {
8095          return null;
8096        }
8097        if (Array.isArray(val)) {
8098          return _jQuery2.map(val, function (val) {
8099            return {
8100              name: elem.name,
8101              value: val.replace(rCRLF, "\r\n")
8102            };
8103          });
8104        }
8105        return {
8106          name: elem.name,
8107          value: val.replace(rCRLF, "\r\n")
8108        };
8109      }).get();
8110    }
8111  });
8112  var r20 = /%20/g,
8113    rhash = /#.*$/,
8114    rantiCache = /([?&])_=[^&]*/,
8115    rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
8116    // trac-7653, trac-8125, trac-8152: local protocol detection
8117    rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
8118    rnoContent = /^(?:GET|HEAD)$/,
8119    rprotocol = /^\/\//,
8120    /* Prefilters
8121     * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
8122     * 2) These are called:
8123     *    - BEFORE asking for a transport
8124     *    - AFTER param serialization (s.data is a string if s.processData is true)
8125     * 3) key is the dataType
8126     * 4) the catchall symbol "*" can be used
8127     * 5) execution will start with transport dataType and THEN continue down to "*" if needed
8128     */
8129    prefilters = {},
8130    /* Transports bindings
8131     * 1) key is the dataType
8132     * 2) the catchall symbol "*" can be used
8133     * 3) selection will start with transport dataType and THEN go to "*" if needed
8134     */
8135    transports = {},
8136    // Avoid comment-prolog char sequence (trac-10098); must appease lint and evade compression
8137    allTypes = "*/".concat("*"),
8138    // Anchor tag for parsing the document origin
8139    originAnchor = document.createElement("a");
8140  originAnchor.href = location.href;
8141
8142  // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
8143  function addToPrefiltersOrTransports(structure) {
8144    // dataTypeExpression is optional and defaults to "*"
8145    return function (dataTypeExpression, func) {
8146      if (typeof dataTypeExpression !== "string") {
8147        func = dataTypeExpression;
8148        dataTypeExpression = "*";
8149      }
8150      var dataType,
8151        i = 0,
8152        dataTypes = dataTypeExpression.toLowerCase().match(rnothtmlwhite) || [];
8153      if (isFunction(func)) {
8154        // For each dataType in the dataTypeExpression
8155        while (dataType = dataTypes[i++]) {
8156          // Prepend if requested
8157          if (dataType[0] === "+") {
8158            dataType = dataType.slice(1) || "*";
8159            (structure[dataType] = structure[dataType] || []).unshift(func);
8160
8161            // Otherwise append
8162          } else {
8163            (structure[dataType] = structure[dataType] || []).push(func);
8164          }
8165        }
8166      }
8167    };
8168  }
8169
8170  // Base inspection function for prefilters and transports
8171  function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {
8172    var inspected = {},
8173      seekingTransport = structure === transports;
8174    function inspect(dataType) {
8175      var selected;
8176      inspected[dataType] = true;
8177      _jQuery2.each(structure[dataType] || [], function (_, prefilterOrFactory) {
8178        var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);
8179        if (typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[dataTypeOrTransport]) {
8180          options.dataTypes.unshift(dataTypeOrTransport);
8181          inspect(dataTypeOrTransport);
8182          return false;
8183        } else if (seekingTransport) {
8184          return !(selected = dataTypeOrTransport);
8185        }
8186      });
8187      return selected;
8188    }
8189    return inspect(options.dataTypes[0]) || !inspected["*"] && inspect("*");
8190  }
8191
8192  // A special extend for ajax options
8193  // that takes "flat" options (not to be deep extended)
8194  // Fixes trac-9887
8195  function ajaxExtend(target, src) {
8196    var key,
8197      deep,
8198      flatOptions = _jQuery2.ajaxSettings.flatOptions || {};
8199    for (key in src) {
8200      if (src[key] !== undefined) {
8201        (flatOptions[key] ? target : deep || (deep = {}))[key] = src[key];
8202      }
8203    }
8204    if (deep) {
8205      _jQuery2.extend(true, target, deep);
8206    }
8207    return target;
8208  }
8209
8210  /* Handles responses to an ajax request:
8211   * - finds the right dataType (mediates between content-type and expected dataType)
8212   * - returns the corresponding response
8213   */
8214  function ajaxHandleResponses(s, jqXHR, responses) {
8215    var ct,
8216      type,
8217      finalDataType,
8218      firstDataType,
8219      contents = s.contents,
8220      dataTypes = s.dataTypes;
8221
8222    // Remove auto dataType and get content-type in the process
8223    while (dataTypes[0] === "*") {
8224      dataTypes.shift();
8225      if (ct === undefined) {
8226        ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
8227      }
8228    }
8229
8230    // Check if we're dealing with a known content-type
8231    if (ct) {
8232      for (type in contents) {
8233        if (contents[type] && contents[type].test(ct)) {
8234          dataTypes.unshift(type);
8235          break;
8236        }
8237      }
8238    }
8239
8240    // Check to see if we have a response for the expected dataType
8241    if (dataTypes[0] in responses) {
8242      finalDataType = dataTypes[0];
8243    } else {
8244      // Try convertible dataTypes
8245      for (type in responses) {
8246        if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) {
8247          finalDataType = type;
8248          break;
8249        }
8250        if (!firstDataType) {
8251          firstDataType = type;
8252        }
8253      }
8254
8255      // Or just use first one
8256      finalDataType = finalDataType || firstDataType;
8257    }
8258
8259    // If we found a dataType
8260    // We add the dataType to the list if needed
8261    // and return the corresponding response
8262    if (finalDataType) {
8263      if (finalDataType !== dataTypes[0]) {
8264        dataTypes.unshift(finalDataType);
8265      }
8266      return responses[finalDataType];
8267    }
8268  }
8269
8270  /* Chain conversions given the request and the original response
8271   * Also sets the responseXXX fields on the jqXHR instance
8272   */
8273  function ajaxConvert(s, response, jqXHR, isSuccess) {
8274    var conv2,
8275      current,
8276      conv,
8277      tmp,
8278      prev,
8279      converters = {},
8280      // Work with a copy of dataTypes in case we need to modify it for conversion
8281      dataTypes = s.dataTypes.slice();
8282
8283    // Create converters map with lowercased keys
8284    if (dataTypes[1]) {
8285      for (conv in s.converters) {
8286        converters[conv.toLowerCase()] = s.converters[conv];
8287      }
8288    }
8289    current = dataTypes.shift();
8290
8291    // Convert to each sequential dataType
8292    while (current) {
8293      if (s.responseFields[current]) {
8294        jqXHR[s.responseFields[current]] = response;
8295      }
8296
8297      // Apply the dataFilter if provided
8298      if (!prev && isSuccess && s.dataFilter) {
8299        response = s.dataFilter(response, s.dataType);
8300      }
8301      prev = current;
8302      current = dataTypes.shift();
8303      if (current) {
8304        // There's only work to do if current dataType is non-auto
8305        if (current === "*") {
8306          current = prev;
8307
8308          // Convert response if prev dataType is non-auto and differs from current
8309        } else if (prev !== "*" && prev !== current) {
8310          // Seek a direct converter
8311          conv = converters[prev + " " + current] || converters["* " + current];
8312
8313          // If none found, seek a pair
8314          if (!conv) {
8315            for (conv2 in converters) {
8316              // If conv2 outputs current
8317              tmp = conv2.split(" ");
8318              if (tmp[1] === current) {
8319                // If prev can be converted to accepted input
8320                conv = converters[prev + " " + tmp[0]] || converters["* " + tmp[0]];
8321                if (conv) {
8322                  // Condense equivalence converters
8323                  if (conv === true) {
8324                    conv = converters[conv2];
8325
8326                    // Otherwise, insert the intermediate dataType
8327                  } else if (converters[conv2] !== true) {
8328                    current = tmp[0];
8329                    dataTypes.unshift(tmp[1]);
8330                  }
8331                  break;
8332                }
8333              }
8334            }
8335          }
8336
8337          // Apply converter (if not an equivalence)
8338          if (conv !== true) {
8339            // Unless errors are allowed to bubble, catch and return them
8340            if (conv && s["throws"]) {
8341              response = conv(response);
8342            } else {
8343              try {
8344                response = conv(response);
8345              } catch (e) {
8346                return {
8347                  state: "parsererror",
8348                  error: conv ? e : "No conversion from " + prev + " to " + current
8349                };
8350              }
8351            }
8352          }
8353        }
8354      }
8355    }
8356    return {
8357      state: "success",
8358      data: response
8359    };
8360  }
8361  _jQuery2.extend({
8362    // Counter for holding the number of active queries
8363    active: 0,
8364    // Last-Modified header cache for next request
8365    lastModified: {},
8366    etag: {},
8367    ajaxSettings: {
8368      url: location.href,
8369      type: "GET",
8370      isLocal: rlocalProtocol.test(location.protocol),
8371      global: true,
8372      processData: true,
8373      async: true,
8374      contentType: "application/x-www-form-urlencoded; charset=UTF-8",
8375      /*
8376      timeout: 0,
8377      data: null,
8378      dataType: null,
8379      username: null,
8380      password: null,
8381      cache: null,
8382      throws: false,
8383      traditional: false,
8384      headers: {},
8385      */
8386
8387      accepts: {
8388        "*": allTypes,
8389        text: "text/plain",
8390        html: "text/html",
8391        xml: "application/xml, text/xml",
8392        json: "application/json, text/javascript"
8393      },
8394      contents: {
8395        xml: /\bxml\b/,
8396        html: /\bhtml/,
8397        json: /\bjson\b/
8398      },
8399      responseFields: {
8400        xml: "responseXML",
8401        text: "responseText",
8402        json: "responseJSON"
8403      },
8404      // Data converters
8405      // Keys separate source (or catchall "*") and destination types with a single space
8406      converters: {
8407        // Convert anything to text
8408        "* text": String,
8409        // Text to html (true = no transformation)
8410        "text html": true,
8411        // Evaluate text as a json expression
8412        "text json": JSON.parse,
8413        // Parse text as xml
8414        "text xml": _jQuery2.parseXML
8415      },
8416      // For options that shouldn't be deep extended:
8417      // you can add your own custom options here if
8418      // and when you create one that shouldn't be
8419      // deep extended (see ajaxExtend)
8420      flatOptions: {
8421        url: true,
8422        context: true
8423      }
8424    },
8425    // Creates a full fledged settings object into target
8426    // with both ajaxSettings and settings fields.
8427    // If target is omitted, writes into ajaxSettings.
8428    ajaxSetup: function ajaxSetup(target, settings) {
8429      return settings ?
8430      // Building a settings object
8431      ajaxExtend(ajaxExtend(target, _jQuery2.ajaxSettings), settings) :
8432      // Extending ajaxSettings
8433      ajaxExtend(_jQuery2.ajaxSettings, target);
8434    },
8435    ajaxPrefilter: addToPrefiltersOrTransports(prefilters),
8436    ajaxTransport: addToPrefiltersOrTransports(transports),
8437    // Main method
8438    ajax: function ajax(url, options) {
8439      // If url is an object, simulate pre-1.5 signature
8440      if (_typeof(url) === "object") {
8441        options = url;
8442        url = undefined;
8443      }
8444
8445      // Force options to be an object
8446      options = options || {};
8447      var transport,
8448        // URL without anti-cache param
8449        cacheURL,
8450        // Response headers
8451        responseHeadersString,
8452        responseHeaders,
8453        // timeout handle
8454        timeoutTimer,
8455        // Url cleanup var
8456        urlAnchor,
8457        // Request state (becomes false upon send and true upon completion)
8458        completed,
8459        // To know if global events are to be dispatched
8460        fireGlobals,
8461        // Loop variable
8462        i,
8463        // uncached part of the url
8464        uncached,
8465        // Create the final options object
8466        s = _jQuery2.ajaxSetup({}, options),
8467        // Callbacks context
8468        callbackContext = s.context || s,
8469        // Context for global events is callbackContext if it is a DOM node or jQuery collection
8470        globalEventContext = s.context && (callbackContext.nodeType || callbackContext.jquery) ? _jQuery2(callbackContext) : _jQuery2.event,
8471        // Deferreds
8472        deferred = _jQuery2.Deferred(),
8473        completeDeferred = _jQuery2.Callbacks("once memory"),
8474        // Status-dependent callbacks
8475        _statusCode = s.statusCode || {},
8476        // Headers (they are sent all at once)
8477        requestHeaders = {},
8478        requestHeadersNames = {},
8479        // Default abort message
8480        strAbort = "canceled",
8481        // Fake xhr
8482        jqXHR = {
8483          readyState: 0,
8484          // Builds headers hashtable if needed
8485          getResponseHeader: function getResponseHeader(key) {
8486            var match;
8487            if (completed) {
8488              if (!responseHeaders) {
8489                responseHeaders = {};
8490                while (match = rheaders.exec(responseHeadersString)) {
8491                  responseHeaders[match[1].toLowerCase() + " "] = (responseHeaders[match[1].toLowerCase() + " "] || []).concat(match[2]);
8492                }
8493              }
8494              match = responseHeaders[key.toLowerCase() + " "];
8495            }
8496            return match == null ? null : match.join(", ");
8497          },
8498          // Raw string
8499          getAllResponseHeaders: function getAllResponseHeaders() {
8500            return completed ? responseHeadersString : null;
8501          },
8502          // Caches the header
8503          setRequestHeader: function setRequestHeader(name, value) {
8504            if (completed == null) {
8505              name = requestHeadersNames[name.toLowerCase()] = requestHeadersNames[name.toLowerCase()] || name;
8506              requestHeaders[name] = value;
8507            }
8508            return this;
8509          },
8510          // Overrides response content-type header
8511          overrideMimeType: function overrideMimeType(type) {
8512            if (completed == null) {
8513              s.mimeType = type;
8514            }
8515            return this;
8516          },
8517          // Status-dependent callbacks
8518          statusCode: function statusCode(map) {
8519            var code;
8520            if (map) {
8521              if (completed) {
8522                // Execute the appropriate callbacks
8523                jqXHR.always(map[jqXHR.status]);
8524              } else {
8525                // Lazy-add the new callbacks in a way that preserves old ones
8526                for (code in map) {
8527                  _statusCode[code] = [_statusCode[code], map[code]];
8528                }
8529              }
8530            }
8531            return this;
8532          },
8533          // Cancel the request
8534          abort: function abort(statusText) {
8535            var finalText = statusText || strAbort;
8536            if (transport) {
8537              transport.abort(finalText);
8538            }
8539            done(0, finalText);
8540            return this;
8541          }
8542        };
8543
8544      // Attach deferreds
8545      deferred.promise(jqXHR);
8546
8547      // Add protocol if not provided (prefilters might expect it)
8548      // Handle falsy url in the settings object (trac-10093: consistency with old signature)
8549      // We also use the url parameter if available
8550      s.url = ((url || s.url || location.href) + "").replace(rprotocol, location.protocol + "//");
8551
8552      // Alias method option to type as per ticket trac-12004
8553      s.type = options.method || options.type || s.method || s.type;
8554
8555      // Extract dataTypes list
8556      s.dataTypes = (s.dataType || "*").toLowerCase().match(rnothtmlwhite) || [""];
8557
8558      // A cross-domain request is in order when the origin doesn't match the current origin.
8559      if (s.crossDomain == null) {
8560        urlAnchor = document.createElement("a");
8561
8562        // Support: IE <=8 - 11, Edge 12 - 15
8563        // IE throws exception on accessing the href property if url is malformed,
8564        // e.g. http://example.com:80x/
8565        try {
8566          urlAnchor.href = s.url;
8567
8568          // Support: IE <=8 - 11 only
8569          // Anchor's host property isn't correctly set when s.url is relative
8570          urlAnchor.href = urlAnchor.href;
8571          s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== urlAnchor.protocol + "//" + urlAnchor.host;
8572        } catch (e) {
8573          // If there is an error parsing the URL, assume it is crossDomain,
8574          // it can be rejected by the transport if it is invalid
8575          s.crossDomain = true;
8576        }
8577      }
8578
8579      // Convert data if not already a string
8580      if (s.data && s.processData && typeof s.data !== "string") {
8581        s.data = _jQuery2.param(s.data, s.traditional);
8582      }
8583
8584      // Apply prefilters
8585      inspectPrefiltersOrTransports(prefilters, s, options, jqXHR);
8586
8587      // If request was aborted inside a prefilter, stop there
8588      if (completed) {
8589        return jqXHR;
8590      }
8591
8592      // We can fire global events as of now if asked to
8593      // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (trac-15118)
8594      fireGlobals = _jQuery2.event && s.global;
8595
8596      // Watch for a new set of requests
8597      if (fireGlobals && _jQuery2.active++ === 0) {
8598        _jQuery2.event.trigger("ajaxStart");
8599      }
8600
8601      // Uppercase the type
8602      s.type = s.type.toUpperCase();
8603
8604      // Determine if request has content
8605      s.hasContent = !rnoContent.test(s.type);
8606
8607      // Save the URL in case we're toying with the If-Modified-Since
8608      // and/or If-None-Match header later on
8609      // Remove hash to simplify url manipulation
8610      cacheURL = s.url.replace(rhash, "");
8611
8612      // More options handling for requests with no content
8613      if (!s.hasContent) {
8614        // Remember the hash so we can put it back
8615        uncached = s.url.slice(cacheURL.length);
8616
8617        // If data is available and should be processed, append data to url
8618        if (s.data && (s.processData || typeof s.data === "string")) {
8619          cacheURL += (rquery.test(cacheURL) ? "&" : "?") + s.data;
8620
8621          // trac-9682: remove data so that it's not used in an eventual retry
8622          delete s.data;
8623        }
8624
8625        // Add or update anti-cache param if needed
8626        if (s.cache === false) {
8627          cacheURL = cacheURL.replace(rantiCache, "$1");
8628          uncached = (rquery.test(cacheURL) ? "&" : "?") + "_=" + nonce.guid++ + uncached;
8629        }
8630
8631        // Put hash and anti-cache on the URL that will be requested (gh-1732)
8632        s.url = cacheURL + uncached;
8633
8634        // Change '%20' to '+' if this is encoded form body content (gh-2658)
8635      } else if (s.data && s.processData && (s.contentType || "").indexOf("application/x-www-form-urlencoded") === 0) {
8636        s.data = s.data.replace(r20, "+");
8637      }
8638
8639      // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
8640      if (s.ifModified) {
8641        if (_jQuery2.lastModified[cacheURL]) {
8642          jqXHR.setRequestHeader("If-Modified-Since", _jQuery2.lastModified[cacheURL]);
8643        }
8644        if (_jQuery2.etag[cacheURL]) {
8645          jqXHR.setRequestHeader("If-None-Match", _jQuery2.etag[cacheURL]);
8646        }
8647      }
8648
8649      // Set the correct header, if data is being sent
8650      if (s.data && s.hasContent && s.contentType !== false || options.contentType) {
8651        jqXHR.setRequestHeader("Content-Type", s.contentType);
8652      }
8653
8654      // Set the Accepts header for the server, depending on the dataType
8655      jqXHR.setRequestHeader("Accept", s.dataTypes[0] && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] + (s.dataTypes[0] !== "*" ? ", " + allTypes + "; q=0.01" : "") : s.accepts["*"]);
8656
8657      // Check for headers option
8658      for (i in s.headers) {
8659        jqXHR.setRequestHeader(i, s.headers[i]);
8660      }
8661
8662      // Allow custom headers/mimetypes and early abort
8663      if (s.beforeSend && (s.beforeSend.call(callbackContext, jqXHR, s) === false || completed)) {
8664        // Abort if not done already and return
8665        return jqXHR.abort();
8666      }
8667
8668      // Aborting is no longer a cancellation
8669      strAbort = "abort";
8670
8671      // Install callbacks on deferreds
8672      completeDeferred.add(s.complete);
8673      jqXHR.done(s.success);
8674      jqXHR.fail(s.error);
8675
8676      // Get transport
8677      transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR);
8678
8679      // If no transport, we auto-abort
8680      if (!transport) {
8681        done(-1, "No Transport");
8682      } else {
8683        jqXHR.readyState = 1;
8684
8685        // Send global event
8686        if (fireGlobals) {
8687          globalEventContext.trigger("ajaxSend", [jqXHR, s]);
8688        }
8689
8690        // If request was aborted inside ajaxSend, stop there
8691        if (completed) {
8692          return jqXHR;
8693        }
8694
8695        // Timeout
8696        if (s.async && s.timeout > 0) {
8697          timeoutTimer = window.setTimeout(function () {
8698            jqXHR.abort("timeout");
8699          }, s.timeout);
8700        }
8701        try {
8702          completed = false;
8703          transport.send(requestHeaders, done);
8704        } catch (e) {
8705          // Rethrow post-completion exceptions
8706          if (completed) {
8707            throw e;
8708          }
8709
8710          // Propagate others as results
8711          done(-1, e);
8712        }
8713      }
8714
8715      // Callback for when everything is done
8716      function done(status, nativeStatusText, responses, headers) {
8717        var isSuccess,
8718          success,
8719          error,
8720          response,
8721          modified,
8722          statusText = nativeStatusText;
8723
8724        // Ignore repeat invocations
8725        if (completed) {
8726          return;
8727        }
8728        completed = true;
8729
8730        // Clear timeout if it exists
8731        if (timeoutTimer) {
8732          window.clearTimeout(timeoutTimer);
8733        }
8734
8735        // Dereference transport for early garbage collection
8736        // (no matter how long the jqXHR object will be used)
8737        transport = undefined;
8738
8739        // Cache response headers
8740        responseHeadersString = headers || "";
8741
8742        // Set readyState
8743        jqXHR.readyState = status > 0 ? 4 : 0;
8744
8745        // Determine if successful
8746        isSuccess = status >= 200 && status < 300 || status === 304;
8747
8748        // Get response data
8749        if (responses) {
8750          response = ajaxHandleResponses(s, jqXHR, responses);
8751        }
8752
8753        // Use a noop converter for missing script but not if jsonp
8754        if (!isSuccess && _jQuery2.inArray("script", s.dataTypes) > -1 && _jQuery2.inArray("json", s.dataTypes) < 0) {
8755          s.converters["text script"] = function () {};
8756        }
8757
8758        // Convert no matter what (that way responseXXX fields are always set)
8759        response = ajaxConvert(s, response, jqXHR, isSuccess);
8760
8761        // If successful, handle type chaining
8762        if (isSuccess) {
8763          // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
8764          if (s.ifModified) {
8765            modified = jqXHR.getResponseHeader("Last-Modified");
8766            if (modified) {
8767              _jQuery2.lastModified[cacheURL] = modified;
8768            }
8769            modified = jqXHR.getResponseHeader("etag");
8770            if (modified) {
8771              _jQuery2.etag[cacheURL] = modified;
8772            }
8773          }
8774
8775          // if no content
8776          if (status === 204 || s.type === "HEAD") {
8777            statusText = "nocontent";
8778
8779            // if not modified
8780          } else if (status === 304) {
8781            statusText = "notmodified";
8782
8783            // If we have data, let's convert it
8784          } else {
8785            statusText = response.state;
8786            success = response.data;
8787            error = response.error;
8788            isSuccess = !error;
8789          }
8790        } else {
8791          // Extract error from statusText and normalize for non-aborts
8792          error = statusText;
8793          if (status || !statusText) {
8794            statusText = "error";
8795            if (status < 0) {
8796              status = 0;
8797            }
8798          }
8799        }
8800
8801        // Set data for the fake xhr object
8802        jqXHR.status = status;
8803        jqXHR.statusText = (nativeStatusText || statusText) + "";
8804
8805        // Success/Error
8806        if (isSuccess) {
8807          deferred.resolveWith(callbackContext, [success, statusText, jqXHR]);
8808        } else {
8809          deferred.rejectWith(callbackContext, [jqXHR, statusText, error]);
8810        }
8811
8812        // Status-dependent callbacks
8813        jqXHR.statusCode(_statusCode);
8814        _statusCode = undefined;
8815        if (fireGlobals) {
8816          globalEventContext.trigger(isSuccess ? "ajaxSuccess" : "ajaxError", [jqXHR, s, isSuccess ? success : error]);
8817        }
8818
8819        // Complete
8820        completeDeferred.fireWith(callbackContext, [jqXHR, statusText]);
8821        if (fireGlobals) {
8822          globalEventContext.trigger("ajaxComplete", [jqXHR, s]);
8823
8824          // Handle the global AJAX counter
8825          if (! --_jQuery2.active) {
8826            _jQuery2.event.trigger("ajaxStop");
8827          }
8828        }
8829      }
8830      return jqXHR;
8831    },
8832    getJSON: function getJSON(url, data, callback) {
8833      return _jQuery2.get(url, data, callback, "json");
8834    },
8835    getScript: function getScript(url, callback) {
8836      return _jQuery2.get(url, undefined, callback, "script");
8837    }
8838  });
8839  _jQuery2.each(["get", "post"], function (_i, method) {
8840    _jQuery2[method] = function (url, data, callback, type) {
8841      // Shift arguments if data argument was omitted
8842      if (isFunction(data)) {
8843        type = type || callback;
8844        callback = data;
8845        data = undefined;
8846      }
8847
8848      // The url can be an options object (which then must have .url)
8849      return _jQuery2.ajax(_jQuery2.extend({
8850        url: url,
8851        type: method,
8852        dataType: type,
8853        data: data,
8854        success: callback
8855      }, _jQuery2.isPlainObject(url) && url));
8856    };
8857  });
8858  _jQuery2.ajaxPrefilter(function (s) {
8859    var i;
8860    for (i in s.headers) {
8861      if (i.toLowerCase() === "content-type") {
8862        s.contentType = s.headers[i] || "";
8863      }
8864    }
8865  });
8866  _jQuery2._evalUrl = function (url, options, doc) {
8867    return _jQuery2.ajax({
8868      url: url,
8869      // Make this explicit, since user can override this through ajaxSetup (trac-11264)
8870      type: "GET",
8871      dataType: "script",
8872      cache: true,
8873      async: false,
8874      global: false,
8875      // Only evaluate the response if it is successful (gh-4126)
8876      // dataFilter is not invoked for failure responses, so using it instead
8877      // of the default converter is kludgy but it works.
8878      converters: {
8879        "text script": function text_script() {}
8880      },
8881      dataFilter: function dataFilter(response) {
8882        _jQuery2.globalEval(response, options, doc);
8883      }
8884    });
8885  };
8886  _jQuery2.fn.extend({
8887    wrapAll: function wrapAll(html) {
8888      var wrap;
8889      if (this[0]) {
8890        if (isFunction(html)) {
8891          html = html.call(this[0]);
8892        }
8893
8894        // The elements to wrap the target around
8895        wrap = _jQuery2(html, this[0].ownerDocument).eq(0).clone(true);
8896        if (this[0].parentNode) {
8897          wrap.insertBefore(this[0]);
8898        }
8899        wrap.map(function () {
8900          var elem = this;
8901          while (elem.firstElementChild) {
8902            elem = elem.firstElementChild;
8903          }
8904          return elem;
8905        }).append(this);
8906      }
8907      return this;
8908    },
8909    wrapInner: function wrapInner(html) {
8910      if (isFunction(html)) {
8911        return this.each(function (i) {
8912          _jQuery2(this).wrapInner(html.call(this, i));
8913        });
8914      }
8915      return this.each(function () {
8916        var self = _jQuery2(this),
8917          contents = self.contents();
8918        if (contents.length) {
8919          contents.wrapAll(html);
8920        } else {
8921          self.append(html);
8922        }
8923      });
8924    },
8925    wrap: function wrap(html) {
8926      var htmlIsFunction = isFunction(html);
8927      return this.each(function (i) {
8928        _jQuery2(this).wrapAll(htmlIsFunction ? html.call(this, i) : html);
8929      });
8930    },
8931    unwrap: function unwrap(selector) {
8932      this.parent(selector).not("body").each(function () {
8933        _jQuery2(this).replaceWith(this.childNodes);
8934      });
8935      return this;
8936    }
8937  });
8938  _jQuery2.expr.pseudos.hidden = function (elem) {
8939    return !_jQuery2.expr.pseudos.visible(elem);
8940  };
8941  _jQuery2.expr.pseudos.visible = function (elem) {
8942    return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);
8943  };
8944  _jQuery2.ajaxSettings.xhr = function () {
8945    try {
8946      return new window.XMLHttpRequest();
8947    } catch (e) {}
8948  };
8949  var xhrSuccessStatus = {
8950      // File protocol always yields status code 0, assume 200
8951      0: 200,
8952      // Support: IE <=9 only
8953      // trac-1450: sometimes IE returns 1223 when it should be 204
8954      1223: 204
8955    },
8956    xhrSupported = _jQuery2.ajaxSettings.xhr();
8957  support.cors = !!xhrSupported && "withCredentials" in xhrSupported;
8958  support.ajax = xhrSupported = !!xhrSupported;
8959  _jQuery2.ajaxTransport(function (options) {
8960    var _callback, errorCallback;
8961
8962    // Cross domain only allowed if supported through XMLHttpRequest
8963    if (support.cors || xhrSupported && !options.crossDomain) {
8964      return {
8965        send: function send(headers, complete) {
8966          var i,
8967            xhr = options.xhr();
8968          xhr.open(options.type, options.url, options.async, options.username, options.password);
8969
8970          // Apply custom fields if provided
8971          if (options.xhrFields) {
8972            for (i in options.xhrFields) {
8973              xhr[i] = options.xhrFields[i];
8974            }
8975          }
8976
8977          // Override mime type if needed
8978          if (options.mimeType && xhr.overrideMimeType) {
8979            xhr.overrideMimeType(options.mimeType);
8980          }
8981
8982          // X-Requested-With header
8983          // For cross-domain requests, seeing as conditions for a preflight are
8984          // akin to a jigsaw puzzle, we simply never set it to be sure.
8985          // (it can always be set on a per-request basis or even using ajaxSetup)
8986          // For same-domain requests, won't change header if already provided.
8987          if (!options.crossDomain && !headers["X-Requested-With"]) {
8988            headers["X-Requested-With"] = "XMLHttpRequest";
8989          }
8990
8991          // Set headers
8992          for (i in headers) {
8993            xhr.setRequestHeader(i, headers[i]);
8994          }
8995
8996          // Callback
8997          _callback = function callback(type) {
8998            return function () {
8999              if (_callback) {
9000                _callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.ontimeout = xhr.onreadystatechange = null;
9001                if (type === "abort") {
9002                  xhr.abort();
9003                } else if (type === "error") {
9004                  // Support: IE <=9 only
9005                  // On a manual native abort, IE9 throws
9006                  // errors on any property access that is not readyState
9007                  if (typeof xhr.status !== "number") {
9008                    complete(0, "error");
9009                  } else {
9010                    complete(
9011                    // File: protocol always yields status 0; see trac-8605, trac-14207
9012                    xhr.status, xhr.statusText);
9013                  }
9014                } else {
9015                  complete(xhrSuccessStatus[xhr.status] || xhr.status, xhr.statusText,
9016                  // Support: IE <=9 only
9017                  // IE9 has no XHR2 but throws on binary (trac-11426)
9018                  // For XHR2 non-text, let the caller handle it (gh-2498)
9019                  (xhr.responseType || "text") !== "text" || typeof xhr.responseText !== "string" ? {
9020                    binary: xhr.response
9021                  } : {
9022                    text: xhr.responseText
9023                  }, xhr.getAllResponseHeaders());
9024                }
9025              }
9026            };
9027          };
9028
9029          // Listen to events
9030          xhr.onload = _callback();
9031          errorCallback = xhr.onerror = xhr.ontimeout = _callback("error");
9032
9033          // Support: IE 9 only
9034          // Use onreadystatechange to replace onabort
9035          // to handle uncaught aborts
9036          if (xhr.onabort !== undefined) {
9037            xhr.onabort = errorCallback;
9038          } else {
9039            xhr.onreadystatechange = function () {
9040              // Check readyState before timeout as it changes
9041              if (xhr.readyState === 4) {
9042                // Allow onerror to be called first,
9043                // but that will not handle a native abort
9044                // Also, save errorCallback to a variable
9045                // as xhr.onerror cannot be accessed
9046                window.setTimeout(function () {
9047                  if (_callback) {
9048                    errorCallback();
9049                  }
9050                });
9051              }
9052            };
9053          }
9054
9055          // Create the abort callback
9056          _callback = _callback("abort");
9057          try {
9058            // Do send the request (this may raise an exception)
9059            xhr.send(options.hasContent && options.data || null);
9060          } catch (e) {
9061            // trac-14683: Only rethrow if this hasn't been notified as an error yet
9062            if (_callback) {
9063              throw e;
9064            }
9065          }
9066        },
9067        abort: function abort() {
9068          if (_callback) {
9069            _callback();
9070          }
9071        }
9072      };
9073    }
9074  });
9075
9076  // Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
9077  _jQuery2.ajaxPrefilter(function (s) {
9078    if (s.crossDomain) {
9079      s.contents.script = false;
9080    }
9081  });
9082
9083  // Install script dataType
9084  _jQuery2.ajaxSetup({
9085    accepts: {
9086      script: "text/javascript, application/javascript, " + "application/ecmascript, application/x-ecmascript"
9087    },
9088    contents: {
9089      script: /\b(?:java|ecma)script\b/
9090    },
9091    converters: {
9092      "text script": function text_script(text) {
9093        _jQuery2.globalEval(text);
9094        return text;
9095      }
9096    }
9097  });
9098
9099  // Handle cache's special case and crossDomain
9100  _jQuery2.ajaxPrefilter("script", function (s) {
9101    if (s.cache === undefined) {
9102      s.cache = false;
9103    }
9104    if (s.crossDomain) {
9105      s.type = "GET";
9106    }
9107  });
9108
9109  // Bind script tag hack transport
9110  _jQuery2.ajaxTransport("script", function (s) {
9111    // This transport only deals with cross domain or forced-by-attrs requests
9112    if (s.crossDomain || s.scriptAttrs) {
9113      var script, _callback2;
9114      return {
9115        send: function send(_, complete) {
9116          script = _jQuery2("<script>").attr(s.scriptAttrs || {}).prop({
9117            charset: s.scriptCharset,
9118            src: s.url
9119          }).on("load error", _callback2 = function callback(evt) {
9120            script.remove();
9121            _callback2 = null;
9122            if (evt) {
9123              complete(evt.type === "error" ? 404 : 200, evt.type);
9124            }
9125          });
9126
9127          // Use native DOM manipulation to avoid our domManip AJAX trickery
9128          document.head.appendChild(script[0]);
9129        },
9130        abort: function abort() {
9131          if (_callback2) {
9132            _callback2();
9133          }
9134        }
9135      };
9136    }
9137  });
9138  var oldCallbacks = [],
9139    rjsonp = /(=)\?(?=&|$)|\?\?/;
9140
9141  // Default jsonp settings
9142  _jQuery2.ajaxSetup({
9143    jsonp: "callback",
9144    jsonpCallback: function jsonpCallback() {
9145      var callback = oldCallbacks.pop() || _jQuery2.expando + "_" + nonce.guid++;
9146      this[callback] = true;
9147      return callback;
9148    }
9149  });
9150
9151  // Detect, normalize options and install callbacks for jsonp requests
9152  _jQuery2.ajaxPrefilter("json jsonp", function (s, originalSettings, jqXHR) {
9153    var callbackName,
9154      overwritten,
9155      responseContainer,
9156      jsonProp = s.jsonp !== false && (rjsonp.test(s.url) ? "url" : typeof s.data === "string" && (s.contentType || "").indexOf("application/x-www-form-urlencoded") === 0 && rjsonp.test(s.data) && "data");
9157
9158    // Handle iff the expected data type is "jsonp" or we have a parameter to set
9159    if (jsonProp || s.dataTypes[0] === "jsonp") {
9160      // Get callback name, remembering preexisting value associated with it
9161      callbackName = s.jsonpCallback = isFunction(s.jsonpCallback) ? s.jsonpCallback() : s.jsonpCallback;
9162
9163      // Insert callback into url or form data
9164      if (jsonProp) {
9165        s[jsonProp] = s[jsonProp].replace(rjsonp, "$1" + callbackName);
9166      } else if (s.jsonp !== false) {
9167        s.url += (rquery.test(s.url) ? "&" : "?") + s.jsonp + "=" + callbackName;
9168      }
9169
9170      // Use data converter to retrieve json after script execution
9171      s.converters["script json"] = function () {
9172        if (!responseContainer) {
9173          _jQuery2.error(callbackName + " was not called");
9174        }
9175        return responseContainer[0];
9176      };
9177
9178      // Force json dataType
9179      s.dataTypes[0] = "json";
9180
9181      // Install callback
9182      overwritten = window[callbackName];
9183      window[callbackName] = function () {
9184        responseContainer = arguments;
9185      };
9186
9187      // Clean-up function (fires after converters)
9188      jqXHR.always(function () {
9189        // If previous value didn't exist - remove it
9190        if (overwritten === undefined) {
9191          _jQuery2(window).removeProp(callbackName);
9192
9193          // Otherwise restore preexisting value
9194        } else {
9195          window[callbackName] = overwritten;
9196        }
9197
9198        // Save back as free
9199        if (s[callbackName]) {
9200          // Make sure that re-using the options doesn't screw things around
9201          s.jsonpCallback = originalSettings.jsonpCallback;
9202
9203          // Save the callback name for future use
9204          oldCallbacks.push(callbackName);
9205        }
9206
9207        // Call if it was a function and we have a response
9208        if (responseContainer && isFunction(overwritten)) {
9209          overwritten(responseContainer[0]);
9210        }
9211        responseContainer = overwritten = undefined;
9212      });
9213
9214      // Delegate to script
9215      return "script";
9216    }
9217  });
9218
9219  // Support: Safari 8 only
9220  // In Safari 8 documents created via document.implementation.createHTMLDocument
9221  // collapse sibling forms: the second one becomes a child of the first one.
9222  // Because of that, this security measure has to be disabled in Safari 8.
9223  // https://bugs.webkit.org/show_bug.cgi?id=137337
9224  support.createHTMLDocument = function () {
9225    var body = document.implementation.createHTMLDocument("").body;
9226    body.innerHTML = "<form></form><form></form>";
9227    return body.childNodes.length === 2;
9228  }();
9229
9230  // Argument "data" should be string of html
9231  // context (optional): If specified, the fragment will be created in this context,
9232  // defaults to document
9233  // keepScripts (optional): If true, will include scripts passed in the html string
9234  _jQuery2.parseHTML = function (data, context, keepScripts) {
9235    if (typeof data !== "string") {
9236      return [];
9237    }
9238    if (typeof context === "boolean") {
9239      keepScripts = context;
9240      context = false;
9241    }
9242    var base, parsed, scripts;
9243    if (!context) {
9244      // Stop scripts or inline event handlers from being executed immediately
9245      // by using document.implementation
9246      if (support.createHTMLDocument) {
9247        context = document.implementation.createHTMLDocument("");
9248
9249        // Set the base href for the created document
9250        // so any parsed elements with URLs
9251        // are based on the document's URL (gh-2965)
9252        base = context.createElement("base");
9253        base.href = document.location.href;
9254        context.head.appendChild(base);
9255      } else {
9256        context = document;
9257      }
9258    }
9259    parsed = rsingleTag.exec(data);
9260    scripts = !keepScripts && [];
9261
9262    // Single tag
9263    if (parsed) {
9264      return [context.createElement(parsed[1])];
9265    }
9266    parsed = buildFragment([data], context, scripts);
9267    if (scripts && scripts.length) {
9268      _jQuery2(scripts).remove();
9269    }
9270    return _jQuery2.merge([], parsed.childNodes);
9271  };
9272
9273  /**
9274   * Load a url into a page
9275   */
9276  _jQuery2.fn.load = function (url, params, callback) {
9277    var selector,
9278      type,
9279      response,
9280      self = this,
9281      off = url.indexOf(" ");
9282    if (off > -1) {
9283      selector = stripAndCollapse(url.slice(off));
9284      url = url.slice(0, off);
9285    }
9286
9287    // If it's a function
9288    if (isFunction(params)) {
9289      // We assume that it's the callback
9290      callback = params;
9291      params = undefined;
9292
9293      // Otherwise, build a param string
9294    } else if (params && _typeof(params) === "object") {
9295      type = "POST";
9296    }
9297
9298    // If we have elements to modify, make the request
9299    if (self.length > 0) {
9300      _jQuery2.ajax({
9301        url: url,
9302        // If "type" variable is undefined, then "GET" method will be used.
9303        // Make value of this field explicit since
9304        // user can override it through ajaxSetup method
9305        type: type || "GET",
9306        dataType: "html",
9307        data: params
9308      }).done(function (responseText) {
9309        // Save response for use in complete callback
9310        response = arguments;
9311        self.html(selector ?
9312        // If a selector was specified, locate the right elements in a dummy div
9313        // Exclude scripts to avoid IE 'Permission Denied' errors
9314        _jQuery2("<div>").append(_jQuery2.parseHTML(responseText)).find(selector) :
9315        // Otherwise use the full result
9316        responseText);
9317
9318        // If the request succeeds, this function gets "data", "status", "jqXHR"
9319        // but they are ignored because response was set above.
9320        // If it fails, this function gets "jqXHR", "status", "error"
9321      }).always(callback && function (jqXHR, status) {
9322        self.each(function () {
9323          callback.apply(this, response || [jqXHR.responseText, status, jqXHR]);
9324        });
9325      });
9326    }
9327    return this;
9328  };
9329  _jQuery2.expr.pseudos.animated = function (elem) {
9330    return _jQuery2.grep(_jQuery2.timers, function (fn) {
9331      return elem === fn.elem;
9332    }).length;
9333  };
9334  _jQuery2.offset = {
9335    setOffset: function setOffset(elem, options, i) {
9336      var curPosition,
9337        curLeft,
9338        curCSSTop,
9339        curTop,
9340        curOffset,
9341        curCSSLeft,
9342        calculatePosition,
9343        position = _jQuery2.css(elem, "position"),
9344        curElem = _jQuery2(elem),
9345        props = {};
9346
9347      // Set position first, in-case top/left are set even on static elem
9348      if (position === "static") {
9349        elem.style.position = "relative";
9350      }
9351      curOffset = curElem.offset();
9352      curCSSTop = _jQuery2.css(elem, "top");
9353      curCSSLeft = _jQuery2.css(elem, "left");
9354      calculatePosition = (position === "absolute" || position === "fixed") && (curCSSTop + curCSSLeft).indexOf("auto") > -1;
9355
9356      // Need to be able to calculate position if either
9357      // top or left is auto and position is either absolute or fixed
9358      if (calculatePosition) {
9359        curPosition = curElem.position();
9360        curTop = curPosition.top;
9361        curLeft = curPosition.left;
9362      } else {
9363        curTop = parseFloat(curCSSTop) || 0;
9364        curLeft = parseFloat(curCSSLeft) || 0;
9365      }
9366      if (isFunction(options)) {
9367        // Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
9368        options = options.call(elem, i, _jQuery2.extend({}, curOffset));
9369      }
9370      if (options.top != null) {
9371        props.top = options.top - curOffset.top + curTop;
9372      }
9373      if (options.left != null) {
9374        props.left = options.left - curOffset.left + curLeft;
9375      }
9376      if ("using" in options) {
9377        options.using.call(elem, props);
9378      } else {
9379        curElem.css(props);
9380      }
9381    }
9382  };
9383  _jQuery2.fn.extend({
9384    // offset() relates an element's border box to the document origin
9385    offset: function offset(options) {
9386      // Preserve chaining for setter
9387      if (arguments.length) {
9388        return options === undefined ? this : this.each(function (i) {
9389          _jQuery2.offset.setOffset(this, options, i);
9390        });
9391      }
9392      var rect,
9393        win,
9394        elem = this[0];
9395      if (!elem) {
9396        return;
9397      }
9398
9399      // Return zeros for disconnected and hidden (display: none) elements (gh-2310)
9400      // Support: IE <=11 only
9401      // Running getBoundingClientRect on a
9402      // disconnected node in IE throws an error
9403      if (!elem.getClientRects().length) {
9404        return {
9405          top: 0,
9406          left: 0
9407        };
9408      }
9409
9410      // Get document-relative position by adding viewport scroll to viewport-relative gBCR
9411      rect = elem.getBoundingClientRect();
9412      win = elem.ownerDocument.defaultView;
9413      return {
9414        top: rect.top + win.pageYOffset,
9415        left: rect.left + win.pageXOffset
9416      };
9417    },
9418    // position() relates an element's margin box to its offset parent's padding box
9419    // This corresponds to the behavior of CSS absolute positioning
9420    position: function position() {
9421      if (!this[0]) {
9422        return;
9423      }
9424      var offsetParent,
9425        offset,
9426        doc,
9427        elem = this[0],
9428        parentOffset = {
9429          top: 0,
9430          left: 0
9431        };
9432
9433      // position:fixed elements are offset from the viewport, which itself always has zero offset
9434      if (_jQuery2.css(elem, "position") === "fixed") {
9435        // Assume position:fixed implies availability of getBoundingClientRect
9436        offset = elem.getBoundingClientRect();
9437      } else {
9438        offset = this.offset();
9439
9440        // Account for the *real* offset parent, which can be the document or its root element
9441        // when a statically positioned element is identified
9442        doc = elem.ownerDocument;
9443        offsetParent = elem.offsetParent || doc.documentElement;
9444        while (offsetParent && (offsetParent === doc.body || offsetParent === doc.documentElement) && _jQuery2.css(offsetParent, "position") === "static") {
9445          offsetParent = offsetParent.parentNode;
9446        }
9447        if (offsetParent && offsetParent !== elem && offsetParent.nodeType === 1) {
9448          // Incorporate borders into its offset, since they are outside its content origin
9449          parentOffset = _jQuery2(offsetParent).offset();
9450          parentOffset.top += _jQuery2.css(offsetParent, "borderTopWidth", true);
9451          parentOffset.left += _jQuery2.css(offsetParent, "borderLeftWidth", true);
9452        }
9453      }
9454
9455      // Subtract parent offsets and element margins
9456      return {
9457        top: offset.top - parentOffset.top - _jQuery2.css(elem, "marginTop", true),
9458        left: offset.left - parentOffset.left - _jQuery2.css(elem, "marginLeft", true)
9459      };
9460    },
9461    // This method will return documentElement in the following cases:
9462    // 1) For the element inside the iframe without offsetParent, this method will return
9463    //    documentElement of the parent window
9464    // 2) For the hidden or detached element
9465    // 3) For body or html element, i.e. in case of the html node - it will return itself
9466    //
9467    // but those exceptions were never presented as a real life use-cases
9468    // and might be considered as more preferable results.
9469    //
9470    // This logic, however, is not guaranteed and can change at any point in the future
9471    offsetParent: function offsetParent() {
9472      return this.map(function () {
9473        var offsetParent = this.offsetParent;
9474        while (offsetParent && _jQuery2.css(offsetParent, "position") === "static") {
9475          offsetParent = offsetParent.offsetParent;
9476        }
9477        return offsetParent || documentElement;
9478      });
9479    }
9480  });
9481
9482  // Create scrollLeft and scrollTop methods
9483  _jQuery2.each({
9484    scrollLeft: "pageXOffset",
9485    scrollTop: "pageYOffset"
9486  }, function (method, prop) {
9487    var top = "pageYOffset" === prop;
9488    _jQuery2.fn[method] = function (val) {
9489      return _access(this, function (elem, method, val) {
9490        // Coalesce documents and windows
9491        var win;
9492        if (isWindow(elem)) {
9493          win = elem;
9494        } else if (elem.nodeType === 9) {
9495          win = elem.defaultView;
9496        }
9497        if (val === undefined) {
9498          return win ? win[prop] : elem[method];
9499        }
9500        if (win) {
9501          win.scrollTo(!top ? val : win.pageXOffset, top ? val : win.pageYOffset);
9502        } else {
9503          elem[method] = val;
9504        }
9505      }, method, val, arguments.length);
9506    };
9507  });
9508
9509  // Support: Safari <=7 - 9.1, Chrome <=37 - 49
9510  // Add the top/left cssHooks using jQuery.fn.position
9511  // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
9512  // Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
9513  // getComputedStyle returns percent when specified for top/left/bottom/right;
9514  // rather than make the css module depend on the offset module, just check for it here
9515  _jQuery2.each(["top", "left"], function (_i, prop) {
9516    _jQuery2.cssHooks[prop] = addGetHookIf(support.pixelPosition, function (elem, computed) {
9517      if (computed) {
9518        computed = curCSS(elem, prop);
9519
9520        // If curCSS returns percentage, fallback to offset
9521        return rnumnonpx.test(computed) ? _jQuery2(elem).position()[prop] + "px" : computed;
9522      }
9523    });
9524  });
9525
9526  // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
9527  _jQuery2.each({
9528    Height: "height",
9529    Width: "width"
9530  }, function (name, type) {
9531    _jQuery2.each({
9532      padding: "inner" + name,
9533      content: type,
9534      "": "outer" + name
9535    }, function (defaultExtra, funcName) {
9536      // Margin is only for outerHeight, outerWidth
9537      _jQuery2.fn[funcName] = function (margin, value) {
9538        var chainable = arguments.length && (defaultExtra || typeof margin !== "boolean"),
9539          extra = defaultExtra || (margin === true || value === true ? "margin" : "border");
9540        return _access(this, function (elem, type, value) {
9541          var doc;
9542          if (isWindow(elem)) {
9543            // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
9544            return funcName.indexOf("outer") === 0 ? elem["inner" + name] : elem.document.documentElement["client" + name];
9545          }
9546
9547          // Get document width or height
9548          if (elem.nodeType === 9) {
9549            doc = elem.documentElement;
9550
9551            // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
9552            // whichever is greatest
9553            return Math.max(elem.body["scroll" + name], doc["scroll" + name], elem.body["offset" + name], doc["offset" + name], doc["client" + name]);
9554          }
9555          return value === undefined ?
9556          // Get width or height on the element, requesting but not forcing parseFloat
9557          _jQuery2.css(elem, type, extra) :
9558          // Set width or height on the element
9559          _jQuery2.style(elem, type, value, extra);
9560        }, type, chainable ? margin : undefined, chainable);
9561      };
9562    });
9563  });
9564  _jQuery2.each(["ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend"], function (_i, type) {
9565    _jQuery2.fn[type] = function (fn) {
9566      return this.on(type, fn);
9567    };
9568  });
9569  _jQuery2.fn.extend({
9570    bind: function bind(types, data, fn) {
9571      return this.on(types, null, data, fn);
9572    },
9573    unbind: function unbind(types, fn) {
9574      return this.off(types, null, fn);
9575    },
9576    delegate: function delegate(selector, types, data, fn) {
9577      return this.on(types, selector, data, fn);
9578    },
9579    undelegate: function undelegate(selector, types, fn) {
9580      // ( namespace ) or ( selector, types [, fn] )
9581      return arguments.length === 1 ? this.off(selector, "**") : this.off(types, selector || "**", fn);
9582    },
9583    hover: function hover(fnOver, fnOut) {
9584      return this.on("mouseenter", fnOver).on("mouseleave", fnOut || fnOver);
9585    }
9586  });
9587  _jQuery2.each(("blur focus focusin focusout resize scroll click dblclick " + "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + "change select submit keydown keypress keyup contextmenu").split(" "), function (_i, name) {
9588    // Handle event binding
9589    _jQuery2.fn[name] = function (data, fn) {
9590      return arguments.length > 0 ? this.on(name, null, data, fn) : this.trigger(name);
9591    };
9592  });
9593
9594  // Support: Android <=4.0 only
9595  // Make sure we trim BOM and NBSP
9596  // Require that the "whitespace run" starts from a non-whitespace
9597  // to avoid O(N^2) behavior when the engine would try matching "\s+$" at each space position.
9598  var rtrim = /^[\s\uFEFF\xA0]+|([^\s\uFEFF\xA0])[\s\uFEFF\xA0]+$/g;
9599
9600  // Bind a function to a context, optionally partially applying any
9601  // arguments.
9602  // jQuery.proxy is deprecated to promote standards (specifically Function#bind)
9603  // However, it is not slated for removal any time soon
9604  _jQuery2.proxy = function (fn, context) {
9605    var tmp, args, proxy;
9606    if (typeof context === "string") {
9607      tmp = fn[context];
9608      context = fn;
9609      fn = tmp;
9610    }
9611
9612    // Quick check to determine if target is callable, in the spec
9613    // this throws a TypeError, but we will just return undefined.
9614    if (!isFunction(fn)) {
9615      return undefined;
9616    }
9617
9618    // Simulated bind
9619    args = _slice.call(arguments, 2);
9620    proxy = function proxy() {
9621      return fn.apply(context || this, args.concat(_slice.call(arguments)));
9622    };
9623
9624    // Set the guid of unique handler to the same of original handler, so it can be removed
9625    proxy.guid = fn.guid = fn.guid || _jQuery2.guid++;
9626    return proxy;
9627  };
9628  _jQuery2.holdReady = function (hold) {
9629    if (hold) {
9630      _jQuery2.readyWait++;
9631    } else {
9632      _jQuery2.ready(true);
9633    }
9634  };
9635  _jQuery2.isArray = Array.isArray;
9636  _jQuery2.parseJSON = JSON.parse;
9637  _jQuery2.nodeName = nodeName;
9638  _jQuery2.isFunction = isFunction;
9639  _jQuery2.isWindow = isWindow;
9640  _jQuery2.camelCase = camelCase;
9641  _jQuery2.type = toType;
9642  _jQuery2.now = Date.now;
9643  _jQuery2.isNumeric = function (obj) {
9644    // As of jQuery 3.0, isNumeric is limited to
9645    // strings and numbers (primitives or objects)
9646    // that can be coerced to finite numbers (gh-2662)
9647    var type = _jQuery2.type(obj);
9648    return (type === "number" || type === "string") &&
9649    // parseFloat NaNs numeric-cast false positives ("")
9650    // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
9651    // subtraction forces infinities to NaN
9652    !isNaN(obj - parseFloat(obj));
9653  };
9654  _jQuery2.trim = function (text) {
9655    return text == null ? "" : (text + "").replace(rtrim, "$1");
9656  };
9657
9658  // Register as a named AMD module, since jQuery can be concatenated with other
9659  // files that may use define, but not via a proper concatenation script that
9660  // understands anonymous AMD modules. A named AMD is safest and most robust
9661  // way to register. Lowercase jquery is used because AMD module names are
9662  // derived from file names, and jQuery is normally delivered in a lowercase
9663  // file name. Do this after creating the global so that if an AMD module wants
9664  // to call noConflict to hide this version of jQuery, it will work.
9665
9666  // Note that for maximum portability, libraries that are not jQuery should
9667  // declare themselves as anonymous modules, and avoid setting a global if an
9668  // AMD loader is present. jQuery is a special case. For more information, see
9669  // https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
9670
9671  if (true) {
9672    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {
9673      return _jQuery2;
9674    }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
9675		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
9676  }
9677  var
9678    // Map over jQuery in case of overwrite
9679    _jQuery = window.jQuery,
9680    // Map over the $ in case of overwrite
9681    _$ = window.$;
9682  _jQuery2.noConflict = function (deep) {
9683    if (window.$ === _jQuery2) {
9684      window.$ = _$;
9685    }
9686    if (deep && window.jQuery === _jQuery2) {
9687      window.jQuery = _jQuery;
9688    }
9689    return _jQuery2;
9690  };
9691
9692  // Expose jQuery and $ identifiers, even in AMD
9693  // (trac-7102#comment:10, https://github.com/jquery/jquery/pull/557)
9694  // and CommonJS for browser emulators (trac-13566)
9695  if (typeof noGlobal === "undefined") {
9696    window.jQuery = window.$ = _jQuery2;
9697  }
9698  return _jQuery2;
9699});
9700
9701/***/ })