https://4agc.com/assets/donors-81589d9f17928929f755516ebcd70a51e0b3b08b782a45244e3480f8a3e0ddf5.js

1/**
2 * Copyright (c) 2014-present, Facebook, Inc.
3 *
4 * This source code is licensed under the MIT license found in the
5 * LICENSE file in the root directory of this source tree.
6 */
7
8var runtime = (function (exports) {
9  "use strict";
10
11  var Op = Object.prototype;
12  var hasOwn = Op.hasOwnProperty;
13  var defineProperty = Object.defineProperty || function (obj, key, desc) { obj[key] = desc.value; };
14  var undefined; // More compressible than void 0.
15  var $Symbol = typeof Symbol === "function" ? Symbol : {};
16  var iteratorSymbol = $Symbol.iterator || "@@iterator";
17  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
18  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
19
20  function define(obj, key, value) {
21    Object.defineProperty(obj, key, {
22      value: value,
23      enumerable: true,
24      configurable: true,
25      writable: true
26    });
27    return obj[key];
28  }
29  try {
30    // IE 8 has a broken Object.defineProperty that only works on DOM objects.
31    define({}, "");
32  } catch (err) {
33    define = function(obj, key, value) {
34      return obj[key] = value;
35    };
36  }
37
38  function wrap(innerFn, outerFn, self, tryLocsList) {
39    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
40    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
41    var generator = Object.create(protoGenerator.prototype);
42    var context = new Context(tryLocsList || []);
43
44    // The ._invoke method unifies the implementations of the .next,
45    // .throw, and .return methods.
46    defineProperty(generator, "_invoke", { value: makeInvokeMethod(innerFn, self, context) });
47
48    return generator;
49  }
50  exports.wrap = wrap;
51
52  // Try/catch helper to minimize deoptimizations. Returns a completion
53  // record like context.tryEntries[i].completion. This interface could
54  // have been (and was previously) designed to take a closure to be
55  // invoked without arguments, but in all the cases we care about we
56  // already have an existing method we want to call, so there's no need
57  // to create a new function object. We can even get away with assuming
58  // the method takes exactly one argument, since that happens to be true
59  // in every case, so we don't have to touch the arguments object. The
60  // only additional allocation required is the completion record, which
61  // has a stable shape and so hopefully should be cheap to allocate.
62  function tryCatch(fn, obj, arg) {
63    try {
64      return { type: "normal", arg: fn.call(obj, arg) };
65    } catch (err) {
66      return { type: "throw", arg: err };
67    }
68  }
69
70  var GenStateSuspendedStart = "suspendedStart";
71  var GenStateSuspendedYield = "suspendedYield";
72  var GenStateExecuting = "executing";
73  var GenStateCompleted = "completed";
74
75  // Returning this object from the innerFn has the same effect as
76  // breaking out of the dispatch switch statement.
77  var ContinueSentinel = {};
78
79  // Dummy constructor functions that we use as the .constructor and
80  // .constructor.prototype properties for functions that return Generator
81  // objects. For full spec compliance, you may wish to configure your
82  // minifier not to mangle the names of these two functions.
83  function Generator() {}
84  function GeneratorFunction() {}
85  function GeneratorFunctionPrototype() {}
86
87  // This is a polyfill for %IteratorPrototype% for environments that
88  // don't natively support it.
89  var IteratorPrototype = {};
90  define(IteratorPrototype, iteratorSymbol, function () {
91    return this;
92  });
93
94  var getProto = Object.getPrototypeOf;
95  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
96  if (NativeIteratorPrototype &&
97      NativeIteratorPrototype !== Op &&
98      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
99    // This environment has a native %IteratorPrototype%; use it instead
100    // of the polyfill.
101    IteratorPrototype = NativeIteratorPrototype;
102  }
103
104  var Gp = GeneratorFunctionPrototype.prototype =
105    Generator.prototype = Object.create(IteratorPrototype);
106  GeneratorFunction.prototype = GeneratorFunctionPrototype;
107  defineProperty(Gp, "constructor", { value: GeneratorFunctionPrototype, configurable: true });
108  defineProperty(
109    GeneratorFunctionPrototype,
110    "constructor",
111    { value: GeneratorFunction, configurable: true }
112  );
113  GeneratorFunction.displayName = define(
114    GeneratorFunctionPrototype,
115    toStringTagSymbol,
116    "GeneratorFunction"
117  );
118
119  // Helper for defining the .next, .throw, and .return methods of the
120  // Iterator interface in terms of a single ._invoke method.
121  function defineIteratorMethods(prototype) {
122    ["next", "throw", "return"].forEach(function(method) {
123      define(prototype, method, function(arg) {
124        return this._invoke(method, arg);
125      });
126    });
127  }
128
129  exports.isGeneratorFunction = function(genFun) {
130    var ctor = typeof genFun === "function" && genFun.constructor;
131    return ctor
132      ? ctor === GeneratorFunction ||
133        // For the native GeneratorFunction constructor, the best we can
134        // do is to check its .name property.
135        (ctor.displayName || ctor.name) === "GeneratorFunction"
136      : false;

137  };
138
139  exports.mark = function(genFun) {
140    if (Object.setPrototypeOf) {
141      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
142    } else {
143      genFun.__proto__ = GeneratorFunctionPrototype;
144      define(genFun, toStringTagSymbol, "GeneratorFunction");
145    }
146    genFun.prototype = Object.create(Gp);
147    return genFun;
148  };
149
150  // Within the body of any async function, `await x` is transformed to
151  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
152  // `hasOwn.call(value, "__await")` to determine if the yielded value is
153  // meant to be awaited.
154  exports.awrap = function(arg) {
155    return { __await: arg };
156  };
157
158  function AsyncIterator(generator, PromiseImpl) {
159    function invoke(method, arg, resolve, reject) {
160      var record = tryCatch(generator[method], generator, arg);
161      if (record.type === "throw") {
162        reject(record.arg);
163      } else {
164        var result = record.arg;
165        var value = result.value;
166        if (value &&
167            typeof value === "object" &&
168            hasOwn.call(value, "__await")) {
169          return PromiseImpl.resolve(value.__await).then(function(value) {
170            invoke("next", value, resolve, reject);
171          }, function(err) {
172            invoke("throw", err, resolve, reject);
173          });
174        }
175
176        return PromiseImpl.resolve(value).then(function(unwrapped) {
177          // When a yielded Promise is resolved, its final value becomes
178          // the .value of the Promise<{value,done}> result for the
179          // current iteration.
180          result.value = unwrapped;
181          resolve(result);
182        }, function(error) {
183          // If a rejected Promise was yielded, throw the rejection back
184          // into the async generator function so it can be handled there.
185          return invoke("throw", error, resolve, reject);
186        });
187      }
188    }
189
190    var previousPromise;
191
192    function enqueue(method, arg) {
193      function callInvokeWithMethodAndArg() {
194        return new PromiseImpl(function(resolve, reject) {
195          invoke(method, arg, resolve, reject);
196        });
197      }
198
199      return previousPromise =
200        // If enqueue has been called before, then we want to wait until
201        // all previous Promises have been resolved before calling invoke,
202        // so that results are always delivered in the correct order. If
203        // enqueue has not been called before, then it is important to
204        // call invoke immediately, without waiting on a callback to fire,
205        // so that the async generator function has the opportunity to do
206        // any necessary setup in a predictable way. This predictability
207        // is why the Promise constructor synchronously invokes its
208        // executor callback, and why async functions synchronously
209        // execute code before the first await. Since we implement simple
210        // async functions in terms of async generators, it is especially
211        // important to get this right, even though it requires care.
212        previousPromise ? previousPromise.then(
213          callInvokeWithMethodAndArg,
214          // Avoid propagating failures to Promises returned by later
215          // invocations of the iterator.
216          callInvokeWithMethodAndArg
217        ) : callInvokeWithMethodAndArg();
218    }
219
220    // Define the unified helper method that is used to implement .next,
221    // .throw, and .return (see defineIteratorMethods).
222    defineProperty(this, "_invoke", { value: enqueue });
223  }
224
225  defineIteratorMethods(AsyncIterator.prototype);
226  define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
227    return this;
228  });
229  exports.AsyncIterator = AsyncIterator;
230
231  // Note that simple async functions are implemented on top of
232  // AsyncIterator objects; they just return a Promise for the value of
233  // the final result produced by the iterator.
234  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
235    if (PromiseImpl === void 0) PromiseImpl = Promise;
236
237    var iter = new AsyncIterator(
238      wrap(innerFn, outerFn, self, tryLocsList),
239      PromiseImpl
240    );
241
242    return exports.isGeneratorFunction(outerFn)
243      ? iter // If outerFn is a generator, return the full iterator.
244      : iter.next().then(function(result) {
245          return result.done ? result.value : iter.next();
246        });
247  };
248
249  function makeInvokeMethod(innerFn, self, context) {
250    var state = GenStateSuspendedStart;
251
252    return function invoke(method, arg) {
253      if (state === GenStateExecuting) {
254        throw new Error("Generator is already running");
255      }
256
257      if (state === GenStateCompleted) {
258        if (method === "throw") {
259          throw arg;
260        }
261
262        // Be forgiving, per GeneratorResume behavior specified since ES2015:
263        // ES2015 spec, step 3: https://262.ecma-international.org/6.0/#sec-generatorresume
264        // Latest spec, step 2: https://tc39.es/ecma262/#sec-generatorresume
265        return doneResult();
266      }
267
268      context.method = method;
269      context.arg = arg;
270
271      while (true) {
272        var delegate = context.delegate;
273        if (delegate) {
274          var delegateResult = maybeInvokeDelegate(delegate, context);
275          if (delegateResult) {
276            if (delegateResult === ContinueSentinel) continue;
277            return delegateResult;
278          }
279        }
280
281        if (context.method === "next") {
282          // Setting context._sent for legacy support of Babel's
283          // function.sent implementation.
284          context.sent = context._sent = context.arg;
285
286        } else if (context.method === "throw") {
287          if (state === GenStateSuspendedStart) {
288            state = GenStateCompleted;
289            throw context.arg;
290          }
291
292          context.dispatchException(context.arg);
293
294        } else if (context.method === "return") {
295          context.abrupt("return", context.arg);
296        }
297
298        state = GenStateExecuting;
299
300        var record = tryCatch(innerFn, self, context);
301        if (record.type === "normal") {
302          // If an exception is thrown from innerFn, we leave state ===
303          // GenStateExecuting and loop back for another invocation.
304          state = context.done
305            ? GenStateCompleted
306            : GenStateSuspendedYield;
307
308          if (record.arg === ContinueSentinel) {
309            continue;
310          }
311
312          return {
313            value: record.arg,
314            done: context.done
315          };
316
317        } else if (record.type === "throw") {
318          state = GenStateCompleted;
319          // Dispatch the exception by looping back around to the
320          // context.dispatchException(context.arg) call above.
321          context.method = "throw";
322          context.arg = record.arg;
323        }
324      }
325    };
326  }
327
328  // Call delegate.iterator[context.method](context.arg) and handle the
329  // result, either by returning a { value, done } result from the
330  // delegate iterator, or by modifying context.method and context.arg,
331  // setting context.delegate to null, and returning the ContinueSentinel.
332  function maybeInvokeDelegate(delegate, context) {
333    var methodName = context.method;
334    var method = delegate.iterator[methodName];
335    if (method === undefined) {
336      // A .throw or .return when the delegate iterator has no .throw
337      // method, or a missing .next method, always terminate the
338      // yield* loop.
339      context.delegate = null;
340
341      // Note: ["return"] must be used for ES3 parsing compatibility.
342      if (methodName === "throw" && delegate.iterator["return"]) {
343        // If the delegate iterator has a return method, give it a
344        // chance to clean up.
345        context.method = "return";
346        context.arg = undefined;
347        maybeInvokeDelegate(delegate, context);
348
349        if (context.method === "throw") {
350          // If maybeInvokeDelegate(context) changed context.method from
351          // "return" to "throw", let that override the TypeError below.
352          return ContinueSentinel;
353        }
354      }
355      if (methodName !== "return") {
356        context.method = "throw";
357        context.arg = new TypeError(
358          "The iterator does not provide a '" + methodName + "' method");
359      }
360
361      return ContinueSentinel;
362    }
363
364    var record = tryCatch(method, delegate.iterator, context.arg);
365
366    if (record.type === "throw") {
367      context.method = "throw";
368      context.arg = record.arg;
369      context.delegate = null;
370      return ContinueSentinel;
371    }
372
373    var info = record.arg;
374
375    if (! info) {
376      context.method = "throw";
377      context.arg = new TypeError("iterator result is not an object");
378      context.delegate = null;
379      return ContinueSentinel;
380    }
381
382    if (info.done) {
383      // Assign the result of the finished delegate to the temporary
384      // variable specified by delegate.resultName (see delegateYield).
385      context[delegate.resultName] = info.value;
386
387      // Resume execution at the desired location (see delegateYield).
388      context.next = delegate.nextLoc;
389
390      // If context.method was "throw" but the delegate handled the
391      // exception, let the outer generator proceed normally. If
392      // context.method was "next", forget context.arg since it has been
393      // "consumed" by the delegate iterator. If context.method was
394      // "return", allow the original .return call to continue in the
395      // outer generator.
396      if (context.method !== "return") {
397        context.method = "next";
398        context.arg = undefined;
399      }
400
401    } else {
402      // Re-yield the result returned by the delegate method.
403      return info;
404    }
405
406    // The delegate iterator is finished, so forget it and continue with
407    // the outer generator.
408    context.delegate = null;
409    return ContinueSentinel;
410  }
411
412  // Define Generator.prototype.{next,throw,return} in terms of the
413  // unified ._invoke helper method.
414  defineIteratorMethods(Gp);
415
416  define(Gp, toStringTagSymbol, "Generator");
417
418  // A Generator should always return itself as the iterator object when the
419  // @@iterator function is called on it. Some browsers' implementations of the
420  // iterator prototype chain incorrectly implement this, causing the Generator
421  // object to not be returned from this call. This ensures that doesn't happen.
422  // See https://github.com/facebook/regenerator/issues/274 for more details.
423  define(Gp, iteratorSymbol, function() {
424    return this;
425  });
426
427  define(Gp, "toString", function() {
428    return "[object Generator]";
429  });
430
431  function pushTryEntry(locs) {
432    var entry = { tryLoc: locs[0] };
433
434    if (1 in locs) {
435      entry.catchLoc = locs[1];
436    }
437
438    if (2 in locs) {
439      entry.finallyLoc = locs[2];
440      entry.afterLoc = locs[3];
441    }
442
443    this.tryEntries.push(entry);
444  }
445
446  function resetTryEntry(entry) {
447    var record = entry.completion || {};
448    record.type = "normal";
449    delete record.arg;
450    entry.completion = record;
451  }
452
453  function Context(tryLocsList) {
454    // The root entry object (effectively a try statement without a catch
455    // or a finally block) gives us a place to store values thrown from
456    // locations where there is no enclosing try statement.
457    this.tryEntries = [{ tryLoc: "root" }];
458    tryLocsList.forEach(pushTryEntry, this);
459    this.reset(true);
460  }
461
462  exports.keys = function(val) {
463    var object = Object(val);
464    var keys = [];
465    for (var key in object) {
466      keys.push(key);
467    }
468    keys.reverse();
469
470    // Rather than returning an object with a next method, we keep
471    // things simple and return the next function itself.
472    return function next() {
473      while (keys.length) {
474        var key = keys.pop();
475        if (key in object) {
476          next.value = key;
477          next.done = false;
478          return next;
479        }
480      }
481
482      // To avoid creating an additional object, we just hang the .value
483      // and .done properties off the next function object itself. This
484      // also ensures that the minifier will not anonymize the function.
485      next.done = true;
486      return next;
487    };
488  };
489
490  function values(iterable) {
491    if (iterable != null) {
492      var iteratorMethod = iterable[iteratorSymbol];
493      if (iteratorMethod) {
494        return iteratorMethod.call(iterable);
495      }
496
497      if (typeof iterable.next === "function") {
498        return iterable;
499      }
500
501      if (!isNaN(iterable.length)) {
502        var i = -1, next = function next() {
503          while (++i < iterable.length) {
504            if (hasOwn.call(iterable, i)) {
505              next.value = iterable[i];
506              next.done = false;
507              return next;
508            }
509          }
510
511          next.value = undefined;
512          next.done = true;
513
514          return next;
515        };
516
517        return next.next = next;
518      }
519    }
520
521    throw new TypeError(typeof iterable + " is not iterable");
522  }
523  exports.values = values;
524
525  function doneResult() {
526    return { value: undefined, done: true };
527  }
528
529  Context.prototype = {
530    constructor: Context,
531
532    reset: function(skipTempReset) {
533      this.prev = 0;
534      this.next = 0;
535      // Resetting context._sent for legacy support of Babel's
536      // function.sent implementation.
537      this.sent = this._sent = undefined;
538      this.done = false;
539      this.delegate = null;
540
541      this.method = "next";
542      this.arg = undefined;
543
544      this.tryEntries.forEach(resetTryEntry);
545
546      if (!skipTempReset) {
547        for (var name in this) {
548          // Not sure about the optimal order of these conditions:
549          if (name.charAt(0) === "t" &&
550              hasOwn.call(this, name) &&
551              !isNaN(+name.slice(1))) {
552            this[name] = undefined;
553          }
554        }
555      }
556    },
557
558    stop: function() {
559      this.done = true;
560
561      var rootEntry = this.tryEntries[0];
562      var rootRecord = rootEntry.completion;
563      if (rootRecord.type === "throw") {
564        throw rootRecord.arg;
565      }
566
567      return this.rval;
568    },
569
570    dispatchException: function(exception) {
571      if (this.done) {
572        throw exception;
573      }
574
575      var context = this;
576      function handle(loc, caught) {
577        record.type = "throw";
578        record.arg = exception;
579        context.next = loc;
580
581        if (caught) {
582          // If the dispatched exception was caught by a catch block,
583          // then let that catch block handle the exception normally.
584          context.method = "next";
585          context.arg = undefined;
586        }
587
588        return !! caught;
589      }
590
591      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
592        var entry = this.tryEntries[i];
593        var record = entry.completion;
594
595        if (entry.tryLoc === "root") {
596          // Exception thrown outside of any try block that could handle
597          // it, so set the completion value of the entire function to
598          // throw the exception.
599          return handle("end");
600        }
601
602        if (entry.tryLoc <= this.prev) {
603          var hasCatch = hasOwn.call(entry, "catchLoc");
604          var hasFinally = hasOwn.call(entry, "finallyLoc");
605
606          if (hasCatch && hasFinally) {
607            if (this.prev < entry.catchLoc) {
608              return handle(entry.catchLoc, true);
609            } else if (this.prev < entry.finallyLoc) {
610              return handle(entry.finallyLoc);
611            }
612
613          } else if (hasCatch) {
614            if (this.prev < entry.catchLoc) {
615              return handle(entry.catchLoc, true);
616            }
617
618          } else if (hasFinally) {
619            if (this.prev < entry.finallyLoc) {
620              return handle(entry.finallyLoc);
621            }
622
623          } else {
624            throw new Error("try statement without catch or finally");
625          }
626        }
627      }
628    },
629
630    abrupt: function(type, arg) {
631      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
632        var entry = this.tryEntries[i];
633        if (entry.tryLoc <= this.prev &&
634            hasOwn.call(entry, "finallyLoc") &&
635            this.prev < entry.finallyLoc) {
636          var finallyEntry = entry;
637          break;
638        }
639      }
640
641      if (finallyEntry &&
642          (type === "break" ||
643           type === "continue") &&
644          finallyEntry.tryLoc <= arg &&
645          arg <= finallyEntry.finallyLoc) {
646        // Ignore the finally entry if control is not jumping to a
647        // location outside the try/catch block.
648        finallyEntry = null;
649      }
650
651      var record = finallyEntry ? finallyEntry.completion : {};
652      record.type = type;
653      record.arg = arg;
654
655      if (finallyEntry) {
656        this.method = "next";
657        this.next = finallyEntry.finallyLoc;
658        return ContinueSentinel;
659      }
660
661      return this.complete(record);
662    },
663
664    complete: function(record, afterLoc) {
665      if (record.type === "throw") {
666        throw record.arg;
667      }
668
669      if (record.type === "break" ||
670          record.type === "continue") {
671        this.next = record.arg;
672      } else if (record.type === "return") {
673        this.rval = this.arg = record.arg;
674        this.method = "return";
675        this.next = "end";
676      } else if (record.type === "normal" && afterLoc) {
677        this.next = afterLoc;
678      }
679
680      return ContinueSentinel;
681    },
682
683    finish: function(finallyLoc) {
684      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
685        var entry = this.tryEntries[i];
686        if (entry.finallyLoc === finallyLoc) {
687          this.complete(entry.completion, entry.afterLoc);
688          resetTryEntry(entry);
689          return ContinueSentinel;
690        }
691      }
692    },
693
694    "catch": function(tryLoc) {
695      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
696        var entry = this.tryEntries[i];
697        if (entry.tryLoc === tryLoc) {
698          var record = entry.completion;
699          if (record.type === "throw") {
700            var thrown = record.arg;
701            resetTryEntry(entry);
702          }
703          return thrown;
704        }
705      }
706
707      // The context.catch method must only be called with a location
708      // argument that corresponds to a known catch block.
709      throw new Error("illegal catch attempt");
710    },
711
712    delegateYield: function(iterable, resultName, nextLoc) {
713      this.delegate = {
714        iterator: values(iterable),
715        resultName: resultName,
716        nextLoc: nextLoc
717      };
718
719      if (this.method === "next") {
720        // Deliberately forget the last sent value so that we don't
721        // accidentally pass it on to the delegate.
722        this.arg = undefined;
723      }
724
725      return ContinueSentinel;
726    }
727  };
728
729  // Regardless of whether this script is executing as a CommonJS module
730  // or not, return the runtime object so that we can declare the variable
731  // regeneratorRuntime in the outer scope, which allows this module to be
732  // injected easily by `bin/regenerator --include-runtime script.js`.
733  return exports;
734
735}(
736  // If this script is executing as a CommonJS module, use module.exports
737  // as the regeneratorRuntime namespace. Otherwise create a new empty
738  // object. Either way, the resulting object will be used to initialize
739  // the regeneratorRuntime variable at the top of this file.
740  typeof module === "object" ? module.exports : {}
741));
742
743try {
744  regeneratorRuntime = runtime;
745} catch (accidentalStrictMode) {
746  // This module should not be running in strict mode, so the above
747  // assignment should always work unless something is misconfigured. Just
748  // in case runtime.js accidentally runs in strict mode, in modern engines
749  // we can explicitly access globalThis. In older engines we can escape
750  // strict mode using a global Function call. This could conceivably fail
751  // if a Content Security Policy forbids using Function, but in that case
752  // the proper solution is to fix the accidental strict mode problem. If
753  // you've misconfigured your bundler to force strict mode and applied a
754  // CSP to forbid Function, and you're not willing to fix either of those
755  // problems, please detail your unique predicament in a GitHub issue.
756  if (typeof globalThis === "object") {
757    globalThis.regeneratorRuntime = runtime;
758  } else {
759    Function("r", "regeneratorRuntime = r")(runtime);
760  }
761}

761;
762!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):t.ES6Promise=e()}(this,function(){"use strict";function t(t){var e=typeof t;return null!==t&&("object"===e||"function"===e)}function e(t){return"function"==typeof t}function n(t){B=t}function r(t){G=t}function o(){return function(){return process.nextTick(a)}}function i(){return"undefined"!=typeof z?function(){z(a)}:c()}function s(){var t=0,e=new J(a),n=document.createTextNode("");return e.observe(n,{characterData:!0}),function(){n.data=t=++t%2}}function u(){var t=new MessageChannel;return t.port1.onmessage=a,function(){return t.port2.postMessage(0)}}function c(){var t=setTimeout;return function(){return t(a,1)}}function a(){for(var t=0;t<W;t+=2){var e=V[t],n=V[t+1];e(n),V[t]=void 0,V[t+1]=void 0}W=0}function f(){try{var t=Function("return this")().require("vertx");return z=t.runOnLoop||t.runOnContext,i()}catch(e){return c()}}function l(t,e){var n=this,r=new this.constructor(p);void 0===r[Z]&&O(r);var o=n._state;if(o){var i=arguments[o-1];G(function(){return P(o,r,i,n._result)})}else E(n,r,t,e);return r}function h(t){var e=this;if(t&&"object"==typeof t&&t.constructor===e)return t;var n=new e(p);return g(n,t),n}function p(){}function v(){return new TypeError("You cannot resolve a promise with itself")}function d(){return new TypeError("A promises callback cannot return that same promise.")}function _(t){try{return t.then}catch(e){return nt.error=e,nt}}function y(t,e,n,r){try{t.call(e,n,r)}catch(o){return o}}function m(t,e,n){G(function(t){var r=!1,o=y(n,e,function(n){r||(r=!0,e!==n?g(t,n):S(t,n))},function(e){r||(r=!0,j(t,e))},"Settle: "+(t._label||" unknown promise"));!r&&o&&(r=!0,j(t,o))},t)}function b(t,e){e._state===tt?S(t,e._result):e._state===et?j(t,e._result):E(e,void 0,function(e){return g(t,e)},function(e){return j(t,e)})}function w(t,n,r){n.constructor===t.constructor&&r===l&&n.constructor.resolve===h?b(t,n):r===nt?(j(t,nt.error),nt.error=null):void 0===r?S(t,n):e(r)?m(t,n,r):S(t,n)}function g(e,n){e===n?j(e,v()):t(n)?w(e,n,_(n)):S(e,n)}

762function A(t){t._onerror&&t._onerror(t._result),T(t)}function S(t,e){t._state===$&&(t._result=e,t._state=tt,0!==t._subscribers.length&&G(T,t))}function j(t,e){t._state===$&&(t._state=et,t._result=e,G(A,t))}function E(t,e,n,r){var o=t._subscribers,i=o.length;t._onerror=null,o[i]=e,o[i+tt]=n,o[i+et]=r,0===i&&t._state&&G(T,t)}function T(t){var e=t._subscribers,n=t._state;if(0!==e.length){for(var r=void 0,o=void 0,i=t._result,s=0;s<e.length;s+=3)r=e[s],o=e[s+n],r?P(n,r,o,i):o(i);t._subscribers.length=0}}function M(t,e){try{return t(e)}catch(n){return nt.error=n,nt}}function P(t,n,r,o){var i=e(r),s=void 0,u=void 0,c=void 0,a=void 0;if(i){if(s=M(r,o),s===nt?(a=!0,u=s.error,s.error=null):c=!0,n===s)return void j(n,d())}else s=o,c=!0;n._state!==$||(i&&c?g(n,s):a?j(n,u):t===tt?S(n,s):t===et&&j(n,s))}function x(t,e){try{e(function(e){g(t,e)},function(e){j(t,e)})}catch(n){j(t,n)}}function C(){return rt++}function O(t){t[Z]=rt++,t._state=void 0,t._result=void 0,t._subscribers=[]}function k(){return new Error("Array Methods must be provided an Array")}function F(t){return new ot(this,t).promise}function Y(t){var e=this;return new e(U(t)?function(n,r){for(var o=t.length,i=0;i<o;i++)e.resolve(t[i]).then(n,r)}:function(t,e){return e(new TypeError("You must pass an array to race."))})}function q(t){var e=this,n=new e(p);return j(n,t),n}function D(){throw new TypeError("You must pass a resolver function as the first argument to the promise constructor")}function K(){throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object c

763/*!
764 * jQuery JavaScript Library v3.7.1
765 * https://jquery.com/
766 *
767 * Copyright OpenJS Foundation and other contributors
768 * Released under the MIT license
769 * https://jquery.org/license
770 *
771 * Date: 2023-08-28T13:37Z
772 */
773( function( global, factory ) {
774
775	"use strict";
776
777	if ( typeof module === "object" && typeof module.exports === "object" ) {
778
779		// For CommonJS and CommonJS-like environments where a proper `window`
780		// is present, execute the factory and get jQuery.
781		// For environments that do not have a `window` with a `document`
782		// (such as Node.js), expose a factory as module.exports.
783		// This accentuates the need for the creation of a real `window`.
784		// e.g. var jQuery = require("jquery")(window);
785		// See ticket trac-14549 for more info.
786		module.exports = global.document ?
787			factory( global, true ) :
788			function( w ) {
789				if ( !w.document ) {
790					throw new Error( "jQuery requires a window with a document" );
791				}
792				return factory( w );
793			};
794	} else {
795		factory( global );
796	}
797
798// Pass this if window is not defined yet
799} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
800
801// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
802// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
803// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
804// enough that all such attempts are guarded in a try block.
805"use strict";
806
807var arr = [];
808
809var getProto = Object.getPrototypeOf;
810
811var slice = arr.slice;
812
813var flat = arr.flat ? function( array ) {
814	return arr.flat.call( array );
815} : function( array ) {
816	return arr.concat.apply( [], array );
817};
818
819
820var push = arr.push;
821
822var indexOf = arr.indexOf;
823
824var class2type = {};
825
826var toString = class2type.toString;
827
828var hasOwn = class2type.hasOwnProperty;
829
830var fnToString = hasOwn.toString;
831
832var ObjectFunctionString = fnToString.call( Object );
833
834var support = {};
835
836var isFunction = function isFunction( obj ) {
837
838		// Support: Chrome <=57, Firefox <=52
839		// In some browsers, typeof returns "function" for HTML <object> elements
840		// (i.e., `typeof document.createElement( "object" ) === "function"`).
841		// We don't want to classify *any* DOM node as a function.
842		// Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5
843		// Plus for old WebKit, typeof returns "function" for HTML collections
844		// (e.g., `typeof document.getElementsByTagName("div") === "function"`). (gh-4756)
845		return typeof obj === "function" && typeof obj.nodeType !== "number" &&
846			typeof obj.item !== "function";
847	};
848
849
850var isWindow = function isWindow( obj ) {
851		return obj != null && obj === obj.window;
852	};
853
854
855var document = window.document;
856
857
858
859	var preservedScriptAttributes = {
860		type: true,
861		src: true,
862		nonce: true,
863		noModule: true
864	};
865
866	function DOMEval( code, node, doc ) {
867		doc = doc || document;
868
869		var i, val,
870			script = doc.createElement( "script" );
871
872		script.text = code;
873		if ( node ) {
874			for ( i in preservedScriptAttributes ) {
875
876				// Support: Firefox 64+, Edge 18+
877				// Some browsers don't support the "nonce" property on scripts.
878				// On the other hand, just using `getAttribute` is not enough as
879				// the `nonce` attribute is reset to an empty string whenever it
880				// becomes browsing-context connected.
881				// See https://github.com/whatwg/html/issues/2369
882				// See https://html.spec.whatwg.org/#nonce-attributes
883				// The `node.getAttribute` check was added for the sake of
884				// `jQuery.globalEval` so that it can fake a nonce-containing node
885				// via an object.
886				val = node[ i ] || node.getAttribute && node.getAttribute( i );
887				if ( val ) {
888					script.setAttribute( i, val );
889				}
890			}
891		}
892		doc.head.appendChild( script ).parentNode.removeChild( script );
893	}
894
895
896function toType( obj ) {
897	if ( obj == null ) {
898		return obj + "";
899	}
900
901	// Support: Android <=2.3 only (functionish RegExp)
902	return typeof obj === "object" || typeof obj === "function" ?
903		class2type[ toString.call( obj ) ] || "object" :
904		typeof obj;
905}
906/* global Symbol */
907// Defining this global in .eslintrc.json would create a danger of using the global
908// unguarded in another place, it seems safer to define global only for this module
909
910
911
912var version = "3.7.1",
913
914	rhtmlSuffix = /HTML$/i,
915
916	// Define a local copy of jQuery
917	jQuery = function( selector, context ) {
918
919		// The jQuery object is actually just the init constructor 'enhanced'
920		// Need init if jQuery is called (just allow error to be thrown if not included)
921		return new jQuery.fn.init( selector, context );
922	};
923
924jQuery.fn = jQuery.prototype = {
925
926	// The current version of jQuery being used
927	jquery: version,
928
929	constructor: jQuery,
930
931	// The default length of a jQuery object is 0
932	length: 0,
933
934	toArray: function() {
935		return slice.call( this );
936	},
937
938	// Get the Nth element in the matched element set OR
939	// Get the whole matched element set as a clean array
940	get: function( num ) {
941
942		// Return all the elements in a clean array
943		if ( num == null ) {
944			return slice.call( this );
945		}
946
947		// Return just the one element from the set
948		return num < 0 ? this[ num + this.length ] : this[ num ];
949	},
950
951	// Take an array of elements and push it onto the stack
952	// (returning the new matched element set)
953	pushStack: function( elems ) {
954
955		// Build a new jQuery matched element set
956		var ret = jQuery.merge( this.constructor(), elems );
957
958		// Add the old object onto the stack (as a reference)
959		ret.prevObject = this;
960
961		// Return the newly-formed element set
962		return ret;
963	},
964
965	// Execute a callback for every element in the matched set.
966	each: function( callback ) {
967		return jQuery.each( this, callback );
968	},
969
970	map: function( callback ) {
971		return this.pushStack( jQuery.map( this, function( elem, i ) {
972			return callback.call( elem, i, elem );
973		} ) );
974	},
975
976	slice: function() {
977		return this.pushStack( slice.apply( this, arguments ) );
978	},
979
980	first: function() {
981		return this.eq( 0 );
982	},
983
984	last: function() {
985		return this.eq( -1 );
986	},
987
988	even: function() {
989		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
990			return ( i + 1 ) % 2;
991		} ) );
992	},
993
994	odd: function() {
995		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
996			return i % 2;
997		} ) );
998	},
999
1000	eq: function( i ) {
1001		var len = this.length,
1002			j = +i + ( i < 0 ? len : 0 );
1003		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
1004	},
1005
1006	end: function() {
1007		return this.prevObject || this.constructor();
1008	},
1009
1010	// For internal use only.
1011	// Behaves like an Array's method, not like a jQuery method.
1012	push: push,
1013	sort: arr.sort,
1014	splice: arr.splice
1015};
1016
1017jQuery.extend = jQuery.fn.extend = function() {
1018	var options, name, src, copy, copyIsArray, clone,
1019		target = arguments[ 0 ] || {},
1020		i = 1,
1021		length = arguments.length,
1022		deep = false;
1023
1024	// Handle a deep copy situation
1025	if ( typeof target === "boolean" ) {
1026		deep = target;
1027
1028		// Skip the boolean and the target
1029		target = arguments[ i ] || {};
1030		i++;
1031	}
1032
1033	// Handle case when target is a string or something (possible in deep copy)
1034	if ( typeof target !== "object" && !isFunction( target ) ) {
1035		target = {};
1036	}
1037
1038	// Extend jQuery itself if only one argument is passed
1039	if ( i === length ) {
1040		target = this;
1041		i--;
1042	}
1043
1044	for ( ; i < length; i++ ) {
1045
1046		// Only deal with non-null/undefined values
1047		if ( ( options = arguments[ i ] ) != null ) {
1048
1049			// Extend the base object
1050			for ( name in options ) {
1051				copy = options[ name ];
1052
1053				// Prevent Object.prototype pollution
1054				// Prevent never-ending loop
1055				if ( name === "__proto__" || target === copy ) {
1056					continue;
1057				}
1058
1059				// Recurse if we're merging plain objects or arrays
1060				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
1061					( copyIsArray = Array.isArray( copy ) ) ) ) {
1062					src = target[ name ];
1063
1064					// Ensure proper type for the source value
1065					if ( copyIsArray && !Array.isArray( src ) ) {
1066						clone = [];
1067					} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
1068						clone = {};
1069					} else {
1070						clone = src;
1071					}
1072					copyIsArray = false;
1073
1074					// Never move original objects, clone them
1075					target[ name ] = jQuery.extend( deep, clone, copy );
1076
1077				// Don't bring in undefined values
1078				} else if ( copy !== undefined ) {
1079					target[ name ] = copy;
1080				}
1081			}
1082		}
1083	}
1084
1085	// Return the modified object
1086	return target;
1087};
1088
1089jQuery.extend( {
1090
1091	// Unique for each copy of jQuery on the page
1092	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
1093
1094	// Assume jQuery is ready without the ready module
1095	isReady: true,
1096
1097	error: function( msg ) {
1098		throw new Error( msg );
1099	},
1100
1101	noop: function() {},
1102
1103	isPlainObject: function( obj ) {
1104		var proto, Ctor;
1105
1106		// Detect obvious negatives
1107		// Use toString instead of jQuery.type to catch host objects
1108		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
1109			return false;
1110		}
1111
1112		proto = getProto( obj );
1113
1114		// Objects with no prototype (e.g., `Object.create( null )`) are plain
1115		if ( !proto ) {
1116			return true;
1117		}
1118
1119		// Objects with prototype are plain iff they were constructed by a global Object function
1120		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
1121		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
1122	},
1123
1124	isEmptyObject: function( obj ) {
1125		var name;
1126
1127		for ( name in obj ) {
1128			return false;
1129		}
1130		return true;
1131	},
1132
1133	// Evaluates a script in a provided context; falls back to the global one
1134	// if not specified.
1135	globalEval: function( code, options, doc ) {
1136		DOMEval( code, { nonce: options && options.nonce }, doc );
1137	},
1138
1139	each: function( obj, callback ) {
1140		var length, i = 0;
1141
1142		if ( isArrayLike( obj ) ) {
1143			length = obj.length;
1144			for ( ; i < length; i++ ) {
1145				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
1146					break;
1147				}
1148			}
1149		} else {
1150			for ( i in obj ) {
1151				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
1152					break;
1153				}
1154			}
1155		}
1156
1157		return obj;
1158	},
1159
1160
1161	// Retrieve the text value of an array of DOM nodes
1162	text: function( elem ) {
1163		var node,
1164			ret = "",
1165			i = 0,
1166			nodeType = elem.nodeType;
1167
1168		if ( !nodeType ) {
1169
1170			// If no nodeType, this is expected to be an array
1171			while ( ( node = elem[ i++ ] ) ) {
1172
1173				// Do not traverse comment nodes
1174				ret += jQuery.text( node );
1175			}
1176		}
1177		if ( nodeType === 1 || nodeType === 11 ) {
1178			return elem.textContent;
1179		}
1180		if ( nodeType === 9 ) {
1181			return elem.documentElement.textContent;
1182		}
1183		if ( nodeType === 3 || nodeType === 4 ) {
1184			return elem.nodeValue;
1185		}
1186
1187		// Do not include comment or processing instruction nodes
1188
1189		return ret;
1190	},
1191
1192	// results is for internal usage only
1193	makeArray: function( arr, results ) {
1194		var ret = results || [];
1195
1196		if ( arr != null ) {
1197			if ( isArrayLike( Object( arr ) ) ) {
1198				jQuery.merge( ret,
1199					typeof arr === "string" ?
1200						[ arr ] : arr
1201				);
1202			} else {
1203				push.call( ret, arr );
1204			}
1205		}
1206
1207		return ret;
1208	},
1209
1210	inArray: function( elem, arr, i ) {
1211		return arr == null ? -1 : indexOf.call( arr, elem, i );
1212	},
1213
1214	isXMLDoc: function( elem ) {
1215		var namespace = elem && elem.namespaceURI,
1216			docElem = elem && ( elem.ownerDocument || elem ).documentElement;
1217
1218		// Assume HTML when documentElement doesn't yet exist, such as inside
1219		// document fragments.
1220		return !rhtmlSuffix.test( namespace || docElem && docElem.nodeName || "HTML" );
1221	},
1222
1223	// Support: Android <=4.0 only, PhantomJS 1 only
1224	// push.apply(_, arraylike) throws on ancient WebKit
1225	merge: function( first, second ) {
1226		var len = +second.length,
1227			j = 0,
1228			i = first.length;
1229
1230		for ( ; j < len; j++ ) {
1231			first[ i++ ] = second[ j ];
1232		}
1233
1234		first.length = i;
1235
1236		return first;
1237	},
1238
1239	grep: function( elems, callback, invert ) {
1240		var callbackInverse,
1241			matches = [],
1242			i = 0,
1243			length = elems.length,
1244			callbackExpect = !invert;
1245
1246		// Go through the array, only saving the items
1247		// that pass the validator function
1248		for ( ; i < length; i++ ) {
1249			callbackInverse = !callback( elems[ i ], i );
1250			if ( callbackInverse !== callbackExpect ) {
1251				matches.push( elems[ i ] );
1252			}
1253		}
1254
1255		return matches;
1256	},
1257
1258	// arg is for internal usage only
1259	map: function( elems, callback, arg ) {
1260		var length, value,
1261			i = 0,
1262			ret = [];
1263
1264		// Go through the array, translating each of the items to their new values
1265		if ( isArrayLike( elems ) ) {
1266			length = elems.length;
1267			for ( ; i < length; i++ ) {
1268				value = callback( elems[ i ], i, arg );
1269
1270				if ( value != null ) {
1271					ret.push( value );
1272				}
1273			}
1274
1275		// Go through every key on the object,
1276		} else {
1277			for ( i in elems ) {
1278				value = callback( elems[ i ], i, arg );
1279
1280				if ( value != null ) {
1281					ret.push( value );
1282				}
1283			}
1284		}
1285
1286		// Flatten any nested arrays
1287		return flat( ret );
1288	},
1289
1290	// A global GUID counter for objects
1291	guid: 1,
1292
1293	// jQuery.support is not used in Core but other projects attach their
1294	// properties to it so it needs to exist.
1295	support: support
1296} );
1297
1298if ( typeof Symbol === "function" ) {
1299	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
1300}
1301
1302// Populate the class2type map
1303jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
1304	function( _i, name ) {
1305		class2type[ "[object " + name + "]" ] = name.toLowerCase();
1306	} );
1307
1308function isArrayLike( obj ) {
1309
1310	// Support: real iOS 8.2 only (not reproducible in simulator)
1311	// `in` check used to prevent JIT error (gh-2145)
1312	// hasOwn isn't used here due to false negatives
1313	// regarding Nodelist length in IE
1314	var length = !!obj && "length" in obj && obj.length,
1315		type = toType( obj );
1316
1317	if ( isFunction( obj ) || isWindow( obj ) ) {
1318		return false;
1319	}
1320
1321	return type === "array" || length === 0 ||
1322		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
1323}
1324
1325
1326function nodeName( elem, name ) {
1327
1328	return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
1329
1330}
1331var pop = arr.pop;
1332
1333
1334var sort = arr.sort;
1335
1336
1337var splice = arr.splice;
1338
1339
1340var whitespace = "[\\x20\\t\\r\\n\\f]";
1341
1342
1343var rtrimCSS = new RegExp(
1344	"^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$",
1345	"g"
1346);
1347
1348
1349
1350
1351// Note: an element does not contain itself
1352jQuery.contains = function( a, b ) {
1353	var bup = b && b.parentNode;
1354
1355	return a === bup || !!( bup && bup.nodeType === 1 && (
1356
1357		// Support: IE 9 - 11+
1358		// IE doesn't have `contains` on SVG.
1359		a.contains ?
1360			a.contains( bup ) :
1361			a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1362	) );
1363};
1364
1365
1366
1367
1368// CSS string/identifier serialization
1369// https://drafts.csswg.org/cssom/#common-serializing-idioms
1370var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g;
1371
1372function fcssescape( ch, asCodePoint ) {
1373	if ( asCodePoint ) {
1374
1375		// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
1376		if ( ch === "\0" ) {
1377			return "\uFFFD";
1378		}
1379
1380		// Control characters and (dependent upon position) numbers get escaped as code points
1381		return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
1382	}
1383
1384	// Other potentially-special ASCII characters get backslash-escaped
1385	return "\\" + ch;
1386}
1387
1388jQuery.escapeSelector = function( sel ) {
1389	return ( sel + "" ).replace( rcssescape, fcssescape );
1390};
1391
1392
1393
1394
1395var preferredDoc = document,
1396	pushNative = push;
1397
1398( function() {
1399
1400var i,
1401	Expr,
1402	outermostContext,
1403	sortInput,
1404	hasDuplicate,
1405	push = pushNative,
1406
1407	// Local document vars
1408	document,
1409	documentElement,
1410	documentIsHTML,
1411	rbuggyQSA,
1412	matches,
1413
1414	// Instance-specific data
1415	expando = jQuery.expando,
1416	dirruns = 0,
1417	done = 0,
1418	classCache = createCache(),
1419	tokenCache = createCache(),
1420	compilerCache = createCache(),
1421	nonnativeSelectorCache = createCache(),
1422	sortOrder = function( a, b ) {
1423		if ( a === b ) {
1424			hasDuplicate = true;
1425		}
1426		return 0;
1427	},
1428
1429	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|" +
1430		"loop|multiple|open|readonly|required|scoped",
1431
1432	// Regular expressions
1433
1434	// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
1435	identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
1436		"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
1437
1438	// Attribute selectors: https://www.w3.org/TR/selectors/#attribute-selectors
1439	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
1440
1441		// Operator (capture 2)
1442		"*([*^$|!~]?=)" + whitespace +
1443
1444		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
1445		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
1446		whitespace + "*\\]",
1447
1448	pseudos = ":(" + identifier + ")(?:\\((" +
1449
1450		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
1451		// 1. quoted (capture 3; capture 4 or capture 5)
1452		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
1453
1454		// 2. simple (capture 6)
1455		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
1456
1457		// 3. anything else (capture 2)
1458		".*" +
1459		")\\)|)",
1460
1461	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
1462	rwhitespace = new RegExp( whitespace + "+", "g" ),
1463
1464	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
1465	rleadingCombinator = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" +
1466		whitespace + "*" ),
1467	rdescend = new RegExp( whitespace + "|>" ),
1468
1469	rpseudo = new RegExp( pseudos ),
1470	ridentifier = new RegExp( "^" + identifier + "$" ),
1471
1472	matchExpr = {
1473		ID: new RegExp( "^#(" + identifier + ")" ),
1474		CLASS: new RegExp( "^\\.(" + identifier + ")" ),
1475		TAG: new RegExp( "^(" + identifier + "|[*])" ),
1476		ATTR: new RegExp( "^" + attributes ),
1477		PSEUDO: new RegExp( "^" + pseudos ),
1478		CHILD: new RegExp(
1479			"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
1480				whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
1481				whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
1482		bool: new RegExp( "^(?:" + booleans + ")$", "i" ),
1483
1484		// For use in libraries implementing .is()
1485		// We use this for POS matching in `select`
1486		needsContext: new RegExp( "^" + whitespace +
1487			"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
1488			"*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
1489	},
1490
1491	rinputs = /^(?:input|select|textarea|button)$/i,
1492	rheader = /^h\d$/i,
1493
1494	// Easily-parseable/retrievable ID or TAG or CLASS selectors
1495	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
1496
1497	rsibling = /[+~]/,
1498
1499	// CSS escapes
1500	// https://www.w3.org/TR/CSS21/syndata.html#escaped-characters
1501	runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace +
1502		"?|\\\\([^\\r\\n\\f])", "g" ),
1503	funescape = function( escape, nonHex ) {
1504		var high = "0x" + escape.slice( 1 ) - 0x10000;
1505
1506		if ( nonHex ) {
1507
1508			// Strip the backslash prefix from a non-hex escape sequence
1509			return nonHex;
1510		}
1511
1512		// Replace a hexadecimal escape sequence with the encoded Unicode code point
1513		// Support: IE <=11+
1514		// For values outside the Basic Multilingual Plane (BMP), manually construct a
1515		// surrogate pair
1516		return high < 0 ?
1517			String.fromCharCode( high + 0x10000 ) :
1518			String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
1519	},
1520
1521	// Used for iframes; see `setDocument`.
1522	// Support: IE 9 - 11+, Edge 12 - 18+
1523	// Removing the function wrapper causes a "Permission Denied"
1524	// error in IE/Edge.
1525	unloadHandler = function() {
1526		setDocument();
1527	},
1528
1529	inDisabledFieldset = addCombinator(
1530		function( elem ) {
1531			return elem.disabled === true && nodeName( elem, "fieldset" );
1532		},
1533		{ dir: "parentNode", next: "legend" }
1534	);
1535
1536// Support: IE <=9 only
1537// Accessing document.activeElement can throw unexpectedly
1538// https://bugs.jquery.com/ticket/13393
1539function safeActiveElement() {
1540	try {
1541		return document.activeElement;
1542	} catch ( err ) { }
1543}
1544
1545// Optimize for push.apply( _, NodeList )
1546try {
1547	push.apply(
1548		( arr = slice.call( preferredDoc.childNodes ) ),
1549		preferredDoc.childNodes
1550	);
1551
1552	// Support: Android <=4.0
1553	// Detect silently failing push.apply
1554	// eslint-disable-next-line no-unused-expressions
1555	arr[ preferredDoc.childNodes.length ].nodeType;
1556} catch ( e ) {
1557	push = {
1558		apply: function( target, els ) {
1559			pushNative.apply( target, slice.call( els ) );
1560		},
1561		call: function( target ) {
1562			pushNative.apply( target, slice.call( arguments, 1 ) );
1563		}
1564	};
1565}
1566
1567function find( selector, context, results, seed ) {
1568	var m, i, elem, nid, match, groups, newSelector,
1569		newContext = context && context.ownerDocument,
1570
1571		// nodeType defaults to 9, since context defaults to document
1572		nodeType = context ? context.nodeType : 9;
1573
1574	results = results || [];
1575
1576	// Return early from calls with invalid selector or context
1577	if ( typeof selector !== "string" || !selector ||
1578		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
1579
1580		return results;
1581	}
1582
1583	// Try to shortcut find operations (as opposed to filters) in HTML documents
1584	if ( !seed ) {
1585		setDocument( context );
1586		context = context || document;
1587
1588		if ( documentIsHTML ) {
1589
1590			// If the selector is sufficiently simple, try using a "get*By*" DOM method
1591			// (excepting DocumentFragment context, where the methods don't exist)
1592			if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
1593
1594				// ID selector
1595				if ( ( m = match[ 1 ] ) ) {
1596
1597					// Document context
1598					if ( nodeType === 9 ) {
1599						if ( ( elem = context.getElementById( m ) ) ) {
1600
1601							// Support: IE 9 only
1602							// getElementById can match elements by name instead of ID
1603							if ( elem.id === m ) {
1604								push.call( results, elem );
1605								return results;
1606							}
1607						} else {
1608							return results;
1609						}
1610
1611					// Element context
1612					} else {
1613
1614						// Support: IE 9 only
1615						// getElementById can match elements by name instead of ID
1616						if ( newContext && ( elem = newContext.getElementById( m ) ) &&
1617							find.contains( context, elem ) &&
1618							elem.id === m ) {
1619
1620							push.call( results, elem );
1621							return results;
1622						}
1623					}
1624
1625				// Type selector
1626				} else if ( match[ 2 ] ) {
1627					push.apply( results, context.getElementsByTagName( selector ) );
1628					return results;
1629
1630				// Class selector
1631				} else if ( ( m = match[ 3 ] ) && context.getElementsByClassName ) {
1632					push.apply( results, context.getElementsByClassName( m ) );
1633					return results;
1634				}
1635			}
1636
1637			// Take advantage of querySelectorAll
1638			if ( !nonnativeSelectorCache[ selector + " " ] &&
1639				( !rbuggyQSA || !rbuggyQSA.test( selector ) ) ) {
1640
1641				newSelector = selector;
1642				newContext = context;
1643
1644				// qSA considers elements outside a scoping root when evaluating child or
1645				// descendant combinators, which is not what we want.
1646				// In such cases, we work around the behavior by prefixing every selector in the
1647				// list with an ID selector referencing the scope context.
1648				// The technique has to be used as well when a leading combinator is used
1649				// as such selectors are not recognized by querySelectorAll.
1650				// Thanks to Andrew Dupont for this technique.
1651				if ( nodeType === 1 &&
1652					( rdescend.test( selector ) || rleadingCombinator.test( selector ) ) ) {
1653
1654					// Expand context for sibling selectors
1655					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
1656						context;
1657
1658					// We can use :scope instead of the ID hack if the browser
1659					// supports it & if we're not changing the context.
1660					// Support: IE 11+, Edge 17 - 18+
1661					// IE/Edge sometimes throw a "Permission denied" error when
1662					// strict-comparing two documents; shallow comparisons work.
1663					// eslint-disable-next-line eqeqeq
1664					if ( newContext != context || !support.scope ) {
1665
1666						// Capture the context ID, setting it first if necessary
1667						if ( ( nid = context.getAttribute( "id" ) ) ) {
1668							nid = jQuery.escapeSelector( nid );
1669						} else {
1670							context.setAttribute( "id", ( nid = expando ) );
1671						}
1672					}
1673
1674					// Prefix every selector in the list
1675					groups = tokenize( selector );
1676					i = groups.length;
1677					while ( i-- ) {
1678						groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
1679							toSelector( groups[ i ] );
1680					}
1681					newSelector = groups.join( "," );
1682				}
1683
1684				try {
1685					push.apply( results,
1686						newContext.querySelectorAll( newSelector )
1687					);
1688					return results;
1689				} catch ( qsaError ) {
1690					nonnativeSelectorCache( selector, true );
1691				} finally {
1692					if ( nid === expando ) {
1693						context.removeAttribute( "id" );
1694					}
1695				}
1696			}
1697		}
1698	}
1699
1700	// All others
1701	return select( selector.replace( rtrimCSS, "$1" ), context, results, seed );
1702}
1703
1704/**
1705 * Create key-value caches of limited size
1706 * @returns {function(string, object)} Returns the Object data after storing it on itself with
1707 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
1708 *	deleting the oldest entry
1709 */
1710function createCache() {
1711	var keys = [];
1712
1713	function cache( key, value ) {
1714
1715		// Use (key + " ") to avoid collision with native prototype properties
1716		// (see https://github.com/jquery/sizzle/issues/157)
1717		if ( keys.push( key + " " ) > Expr.cacheLength ) {
1718
1719			// Only keep the most recent entries
1720			delete cache[ keys.shift() ];
1721		}
1722		return ( cache[ key + " " ] = value );
1723	}
1724	return cache;
1725}
1726
1727/**
1728 * Mark a function for special use by jQuery selector module
1729 * @param {Function} fn The function to mark
1730 */
1731function markFunction( fn ) {
1732	fn[ expando ] = true;
1733	return fn;
1734}
1735
1736/**
1737 * Support testing using an element
1738 * @param {Function} fn Passed the created element and returns a boolean result
1739 */
1740function assert( fn ) {
1741	var el = document.createElement( "fieldset" );
1742
1743	try {
1744		return !!fn( el );
1745	} catch ( e ) {
1746		return false;
1747	} finally {
1748
1749		// Remove from its parent by default
1750		if ( el.parentNode ) {
1751			el.parentNode.removeChild( el );
1752		}
1753
1754		// release memory in IE
1755		el = null;
1756	}
1757}
1758
1759/**
1760 * Returns a function to use in pseudos for input types
1761 * @param {String} type
1762 */
1763function createInputPseudo( type ) {
1764	return function( elem ) {
1765		return nodeName( elem, "input" ) && elem.type === type;
1766	};
1767}
1768
1769/**
1770 * Returns a function to use in pseudos for buttons
1771 * @param {String} type
1772 */
1773function createButtonPseudo( type ) {
1774	return function( elem ) {
1775		return ( nodeName( elem, "input" ) || nodeName( elem, "button" ) ) &&
1776			elem.type === type;
1777	};
1778}
1779
1780/**
1781 * Returns a function to use in pseudos for :enabled/:disabled
1782 * @param {Boolean} disabled true for :disabled; false for :enabled
1783 */
1784function createDisabledPseudo( disabled ) {
1785
1786	// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
1787	return function( elem ) {
1788
1789		// Only certain elements can match :enabled or :disabled
1790		// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
1791		// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
1792		if ( "form" in elem ) {
1793
1794			// Check for inherited disabledness on relevant non-disabled elements:
1795			// * listed form-associated elements in a disabled fieldset
1796			//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
1797			//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
1798			// * option elements in a disabled optgroup
1799			//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
1800			// All such elements have a "form" property.
1801			if ( elem.parentNode && elem.disabled === false ) {
1802
1803				// Option elements defer to a parent optgroup if present
1804				if ( "label" in elem ) {
1805					if ( "label" in elem.parentNode ) {
1806						return elem.parentNode.disabled === disabled;
1807					} else {
1808						return elem.disabled === disabled;
1809					}
1810				}
1811
1812				// Support: IE 6 - 11+
1813				// Use the isDisabled shortcut property to check for disabled fieldset ancestors
1814				return elem.isDisabled === disabled ||
1815
1816					// Where there is no isDisabled, check manually
1817					elem.isDisabled !== !disabled &&
1818						inDisabledFieldset( elem ) === disabled;
1819			}
1820
1821			return elem.disabled === disabled;
1822
1823		// Try to winnow out elements that can't be disabled before trusting the disabled property.
1824		// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
1825		// even exist on them, let alone have a boolean value.
1826		} else if ( "label" in elem ) {
1827			return elem.disabled === disabled;
1828		}
1829
1830		// Remaining elements are neither :enabled nor :disabled
1831		return false;
1832	};
1833}
1834
1835/**
1836 * Returns a function to use in pseudos for positionals
1837 * @param {Function} fn
1838 */
1839function createPositionalPseudo( fn ) {
1840	return markFunction( function( argument ) {
1841		argument = +argument;
1842		return markFunction( function( seed, matches ) {
1843			var j,
1844				matchIndexes = fn( [], seed.length, argument ),
1845				i = matchIndexes.length;
1846
1847			// Match elements found at the specified indexes
1848			while ( i-- ) {
1849				if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
1850					seed[ j ] = !( matches[ j ] = seed[ j ] );
1851				}
1852			}
1853		} );
1854	} );
1855}
1856
1857/**
1858 * Checks a node for validity as a jQuery selector context
1859 * @param {Element|Object=} context
1860 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1861 */
1862function testContext( context ) {
1863	return context && typeof context.getElementsByTagName !== "undefined" && context;
1864}
1865
1866/**
1867 * Sets document-related variables once based on the current document
1868 * @param {Element|Object} [node] An element or document object to use to set the document
1869 * @returns {Object} Returns the current document
1870 */
1871function setDocument( node ) {
1872	var subWindow,
1873		doc = node ? node.ownerDocument || node : preferredDoc;
1874
1875	// Return early if doc is invalid or already selected
1876	// Support: IE 11+, Edge 17 - 18+
1877	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1878	// two documents; shallow comparisons work.
1879	// eslint-disable-next-line eqeqeq
1880	if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {
1881		return document;
1882	}
1883
1884	// Update global variables
1885	document = doc;
1886	documentElement = document.documentElement;
1887	documentIsHTML = !jQuery.isXMLDoc( document );
1888
1889	// Support: iOS 7 only, IE 9 - 11+
1890	// Older browsers didn't support unprefixed `matches`.
1891	matches = documentElement.matches ||
1892		documentElement.webkitMatchesSelector ||
1893		documentElement.msMatchesSelector;
1894
1895	// Support: IE 9 - 11+, Edge 12 - 18+
1896	// Accessing iframe documents after unload throws "permission denied" errors
1897	// (see trac-13936).
1898	// Limit the fix to IE & Edge Legacy; despite Edge 15+ implementing `matches`,
1899	// all IE 9+ and Edge Legacy versions implement `msMatchesSelector` as well.
1900	if ( documentElement.msMatchesSelector &&
1901
1902		// Support: IE 11+, Edge 17 - 18+
1903		// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1904		// two documents; shallow comparisons work.
1905		// eslint-disable-next-line eqeqeq
1906		preferredDoc != document &&
1907		( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
1908
1909		// Support: IE 9 - 11+, Edge 12 - 18+
1910		subWindow.addEventListener( "unload", unloadHandler );
1911	}
1912
1913	// Support: IE <10
1914	// Check if getElementById returns elements by name
1915	// The broken getElementById methods don't pick up programmatically-set names,
1916	// so use a roundabout getElementsByName test
1917	support.getById = assert( function( el ) {
1918		documentElement.appendChild( el ).id = jQuery.expando;
1919		return !document.getElementsByName ||
1920			!document.getElementsByName( jQuery.expando ).length;
1921	} );
1922
1923	// Support: IE 9 only
1924	// Check to see if it's possible to do matchesSelector
1925	// on a disconnected node.
1926	support.disconnectedMatch = assert( function( el ) {
1927		return matches.call( el, "*" );
1928	} );
1929
1930	// Support: IE 9 - 11+, Edge 12 - 18+
1931	// IE/Edge don't support the :scope pseudo-class.
1932	support.scope = assert( function() {
1933		return document.querySelectorAll( ":scope" );
1934	} );
1935
1936	// Support: Chrome 105 - 111 only, Safari 15.4 - 16.3 only
1937	// Make sure the `:has()` argument is parsed unforgivingly.
1938	// We include `*` in the test to detect buggy implementations that are
1939	// _selectively_ forgiving (specifically when the list includes at least
1940	// one valid selector).
1941	// Note that we treat complete lack of support for `:has()` as if it were
1942	// spec-compliant support, which is fine because use of `:has()` in such
1943	// environments will fail in the qSA path and fall back to jQuery traversal
1944	// anyway.
1945	support.cssHas = assert( function() {
1946		try {
1947			document.querySelector( ":has(*,:jqfake)" );
1948			return false;
1949		} catch ( e ) {
1950			return true;
1951		}
1952	} );
1953
1954	// ID filter and find
1955	if ( support.getById ) {
1956		Expr.filter.ID = function( id ) {
1957			var attrId = id.replace( runescape, funescape );
1958			return function( elem ) {
1959				return elem.getAttribute( "id" ) === attrId;
1960			};
1961		};
1962		Expr.find.ID = function( id, context ) {
1963			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1964				var elem = context.getElementById( id );
1965				return elem ? [ elem ] : [];
1966			}
1967		};
1968	} else {
1969		Expr.filter.ID =  function( id ) {
1970			var attrId = id.replace( runescape, funescape );
1971			return function( elem ) {
1972				var node = typeof elem.getAttributeNode !== "undefined" &&
1973					elem.getAttributeNode( "id" );
1974				return node && node.value === attrId;
1975			};
1976		};
1977
1978		// Support: IE 6 - 7 only
1979		// getElementById is not reliable as a find shortcut
1980		Expr.find.ID = function( id, context ) {
1981			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1982				var node, i, elems,
1983					elem = context.getElementById( id );
1984
1985				if ( elem ) {
1986
1987					// Verify the id attribute
1988					node = elem.getAttributeNode( "id" );
1989					if ( node && node.value === id ) {
1990						return [ elem ];
1991					}
1992
1993					// Fall back on getElementsByName
1994					elems = context.getElementsByName( id );
1995					i = 0;
1996					while ( ( elem = elems[ i++ ] ) ) {
1997						node = elem.getAttributeNode( "id" );
1998						if ( node && node.value === id ) {
1999							return [ elem ];
2000						}
2001					}
2002				}
2003
2004				return [];
2005			}
2006		};
2007	}
2008
2009	// Tag
2010	Expr.find.TAG = function( tag, context ) {
2011		if ( typeof context.getElementsByTagName !== "undefined" ) {
2012			return context.getElementsByTagName( tag );
2013
2014		// DocumentFragment nodes don't have gEBTN
2015		} else {
2016			return context.querySelectorAll( tag );
2017		}
2018	};
2019
2020	// Class
2021	Expr.find.CLASS = function( className, context ) {
2022		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
2023			return context.getElementsByClassName( className );
2024		}
2025	};
2026
2027	/* QSA/matchesSelector
2028	---------------------------------------------------------------------- */
2029
2030	// QSA and matchesSelector support
2031
2032	rbuggyQSA = [];
2033
2034	// Build QSA regex
2035	// Regex strategy adopted from Diego Perini
2036	assert( function( el ) {
2037
2038		var input;
2039
2040		documentElement.appendChild( el ).innerHTML =
2041			"<a id='" + expando + "' href='' disabled='disabled'></a>" +
2042			"<select id='" + expando + "-\r\\' disabled='disabled'>" +
2043			"<option selected=''></option></select>";
2044
2045		// Support: iOS <=7 - 8 only
2046		// Boolean attributes and "value" are not treated correctly in some XML documents
2047		if ( !el.querySelectorAll( "[selected]" ).length ) {
2048			rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
2049		}
2050
2051		// Support: iOS <=7 - 8 only
2052		if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
2053			rbuggyQSA.push( "~=" );
2054		}
2055
2056		// Support: iOS 8 only
2057		// https://bugs.webkit.org/show_bug.cgi?id=136851
2058		// In-page `selector#id sibling-combinator selector` fails
2059		if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
2060			rbuggyQSA.push( ".#.+[+~]" );
2061		}
2062
2063		// Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+
2064		// In some of the document kinds, these selectors wouldn't work natively.
2065		// This is probably OK but for backwards compatibility we want to maintain
2066		// handling them through jQuery traversal in jQuery 3.x.
2067		if ( !el.querySelectorAll( ":checked" ).length ) {
2068			rbuggyQSA.push( ":checked" );
2069		}
2070
2071		// Support: Windows 8 Native Apps
2072		// The type and name attributes are restricted during .innerHTML assignment
2073		input = document.createElement( "input" );
2074		input.setAttribute( "type", "hidden" );
2075		el.appendChild( input ).setAttribute( "name", "D" );
2076
2077		// Support: IE 9 - 11+
2078		// IE's :disabled selector does not pick up the children of disabled fieldsets
2079		// Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+
2080		// In some of the document kinds, these selectors wouldn't work natively.
2081		// This is probably OK but for backwards compatibility we want to maintain
2082		// handling them through jQuery traversal in jQuery 3.x.
2083		documentElement.appendChild( el ).disabled = true;
2084		if ( el.querySelectorAll( ":disabled" ).length !== 2 ) {
2085			rbuggyQSA.push( ":enabled", ":disabled" );
2086		}
2087
2088		// Support: IE 11+, Edge 15 - 18+
2089		// IE 11/Edge don't find elements on a `[name='']` query in some cases.
2090		// Adding a temporary attribute to the document before the selection works
2091		// around the issue.
2092		// Interestingly, IE 10 & older don't seem to have the issue.
2093		input = document.createElement( "input" );
2094		input.setAttribute( "name", "" );
2095		el.appendChild( input );
2096		if ( !el.querySelectorAll( "[name='']" ).length ) {
2097			rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" +
2098				whitespace + "*(?:''|\"\")" );
2099		}
2100	} );
2101
2102	if ( !support.cssHas ) {
2103
2104		// Support: Chrome 105 - 110+, Safari 15.4 - 16.3+
2105		// Our regular `try-catch` mechanism fails to detect natively-unsupported
2106		// pseudo-classes inside `:has()` (such as `:has(:contains("Foo"))`)
2107		// in browsers that parse the `:has()` argument as a forgiving selector list.
2108		// https://drafts.csswg.org/selectors/#relational now requires the argument
2109		// to be parsed unforgivingly, but browsers have not yet fully adjusted.
2110		rbuggyQSA.push( ":has" );
2111	}
2112
2113	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) );
2114
2115	/* Sorting
2116	---------------------------------------------------------------------- */
2117
2118	// Document order sorting
2119	sortOrder = function( a, b ) {
2120
2121		// Flag for duplicate removal
2122		if ( a === b ) {
2123			hasDuplicate = true;
2124			return 0;
2125		}
2126
2127		// Sort on method existence if only one input has compareDocumentPosition
2128		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
2129		if ( compare ) {
2130			return compare;
2131		}
2132
2133		// Calculate position if both inputs belong to the same document
2134		// Support: IE 11+, Edge 17 - 18+
2135		// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2136		// two documents; shallow comparisons work.
2137		// eslint-disable-next-line eqeqeq
2138		compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?
2139			a.compareDocumentPosition( b ) :
2140
2141			// Otherwise we know they are disconnected
2142			1;
2143
2144		// Disconnected nodes
2145		if ( compare & 1 ||
2146			( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {
2147
2148			// Choose the first element that is related to our preferred document
2149			// Support: IE 11+, Edge 17 - 18+
2150			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2151			// two documents; shallow comparisons work.
2152			// eslint-disable-next-line eqeqeq
2153			if ( a === document || a.ownerDocument == preferredDoc &&
2154				find.contains( preferredDoc, a ) ) {
2155				return -1;
2156			}
2157
2158			// Support: IE 11+, Edge 17 - 18+
2159			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2160			// two documents; shallow comparisons work.
2161			// eslint-disable-next-line eqeqeq
2162			if ( b === document || b.ownerDocument == preferredDoc &&
2163				find.contains( preferredDoc, b ) ) {
2164				return 1;
2165			}
2166
2167			// Maintain original order
2168			return sortInput ?
2169				( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
2170				0;
2171		}
2172
2173		return compare & 4 ? -1 : 1;
2174	};
2175
2176	return document;
2177}
2178
2179find.matches = function( expr, elements ) {
2180	return find( expr, null, null, elements );
2181};
2182
2183find.matchesSelector = function( elem, expr ) {
2184	setDocument( elem );
2185
2186	if ( documentIsHTML &&
2187		!nonnativeSelectorCache[ expr + " " ] &&
2188		( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {
2189
2190		try {
2191			var ret = matches.call( elem, expr );
2192
2193			// IE 9's matchesSelector returns false on disconnected nodes
2194			if ( ret || support.disconnectedMatch ||
2195
2196					// As well, disconnected nodes are said to be in a document
2197					// fragment in IE 9
2198					elem.document && elem.document.nodeType !== 11 ) {
2199				return ret;
2200			}
2201		} catch ( e ) {
2202			nonnativeSelectorCache( expr, true );
2203		}
2204	}
2205
2206	return find( expr, document, null, [ elem ] ).length > 0;
2207};
2208
2209find.contains = function( context, elem ) {
2210
2211	// Set document vars if needed
2212	// Support: IE 11+, Edge 17 - 18+
2213	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2214	// two documents; shallow comparisons work.
2215	// eslint-disable-next-line eqeqeq
2216	if ( ( context.ownerDocument || context ) != document ) {
2217		setDocument( context );
2218	}
2219	return jQuery.contains( context, elem );
2220};
2221
2222
2223find.attr = function( elem, name ) {
2224
2225	// Set document vars if needed
2226	// Support: IE 11+, Edge 17 - 18+
2227	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2228	// two documents; shallow comparisons work.
2229	// eslint-disable-next-line eqeqeq
2230	if ( ( elem.ownerDocument || elem ) != document ) {
2231		setDocument( elem );
2232	}
2233
2234	var fn = Expr.attrHandle[ name.toLowerCase() ],
2235
2236		// Don't get fooled by Object.prototype properties (see trac-13807)
2237		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
2238			fn( elem, name, !documentIsHTML ) :
2239			undefined;
2240
2241	if ( val !== undefined ) {
2242		return val;
2243	}
2244
2245	return elem.getAttribute( name );
2246};
2247
2248find.error = function( msg ) {
2249	throw new Error( "Syntax error, unrecognized expression: " + msg );
2250};
2251
2252/**
2253 * Document sorting and removing duplicates
2254 * @param {ArrayLike} results
2255 */
2256jQuery.uniqueSort = function( results ) {
2257	var elem,
2258		duplicates = [],
2259		j = 0,
2260		i = 0;
2261
2262	// Unless we *know* we can detect duplicates, assume their presence
2263	//
2264	// Support: Android <=4.0+
2265	// Testing for detecting duplicates is unpredictable so instead assume we can't
2266	// depend on duplicate detection in all browsers without a stable sort.
2267	hasDuplicate = !support.sortStable;
2268	sortInput = !support.sortStable && slice.call( results, 0 );
2269	sort.call( results, sortOrder );
2270
2271	if ( hasDuplicate ) {
2272		while ( ( elem = results[ i++ ] ) ) {
2273			if ( elem === results[ i ] ) {
2274				j = duplicates.push( i );
2275			}
2276		}
2277		while ( j-- ) {
2278			splice.call( results, duplicates[ j ], 1 );
2279		}
2280	}
2281
2282	// Clear input after sorting to release objects
2283	// See https://github.com/jquery/sizzle/pull/225
2284	sortInput = null;
2285
2286	return results;
2287};
2288
2289jQuery.fn.uniqueSort = function() {
2290	return this.pushStack( jQuery.uniqueSort( slice.apply( this ) ) );
2291};
2292
2293Expr = jQuery.expr = {
2294
2295	// Can be adjusted by the user
2296	cacheLength: 50,
2297
2298	createPseudo: markFunction,
2299
2300	match: matchExpr,
2301
2302	attrHandle: {},
2303
2304	find: {},
2305
2306	relative: {
2307		">": { dir: "parentNode", first: true },
2308		" ": { dir: "parentNode" },
2309		"+": { dir: "previousSibling", first: true },
2310		"~": { dir: "previousSibling" }
2311	},
2312
2313	preFilter: {
2314		ATTR: function( match ) {
2315			match[ 1 ] = match[ 1 ].replace( runescape, funescape );
2316
2317			// Move the given value to match[3] whether quoted or unquoted
2318			match[ 3 ] = ( match[ 3 ] || match[ 4 ] || match[ 5 ] || "" )
2319				.replace( runescape, funescape );
2320
2321			if ( match[ 2 ] === "~=" ) {
2322				match[ 3 ] = " " + match[ 3 ] + " ";
2323			}
2324
2325			return match.slice( 0, 4 );
2326		},
2327
2328		CHILD: function( match ) {
2329
2330			/* matches from matchExpr["CHILD"]
2331				1 type (only|nth|...)
2332				2 what (child|of-type)
2333				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
2334				4 xn-component of xn+y argument ([+-]?\d*n|)
2335				5 sign of xn-component
2336				6 x of xn-component
2337				7 sign of y-component
2338				8 y of y-component
2339			*/
2340			match[ 1 ] = match[ 1 ].toLowerCase();
2341
2342			if ( match[ 1 ].slice( 0, 3 ) === "nth" ) {
2343
2344				// nth-* requires argument
2345				if ( !match[ 3 ] ) {
2346					find.error( match[ 0 ] );
2347				}
2348
2349				// numeric x and y parameters for Expr.filter.CHILD
2350				// remember that false/true cast respectively to 0/1
2351				match[ 4 ] = +( match[ 4 ] ?
2352					match[ 5 ] + ( match[ 6 ] || 1 ) :
2353					2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" )
2354				);
2355				match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" );
2356
2357			// other types prohibit arguments
2358			} else if ( match[ 3 ] ) {
2359				find.error( match[ 0 ] );
2360			}
2361
2362			return match;
2363		},
2364
2365		PSEUDO: function( match ) {
2366			var excess,
2367				unquoted = !match[ 6 ] && match[ 2 ];
2368
2369			if ( matchExpr.CHILD.test( match[ 0 ] ) ) {
2370				return null;
2371			}
2372
2373			// Accept quoted arguments as-is
2374			if ( match[ 3 ] ) {
2375				match[ 2 ] = match[ 4 ] || match[ 5 ] || "";
2376
2377			// Strip excess characters from unquoted arguments
2378			} else if ( unquoted && rpseudo.test( unquoted ) &&
2379
2380				// Get excess from tokenize (recursively)
2381				( excess = tokenize( unquoted, true ) ) &&
2382
2383				// advance to the next closing parenthesis
2384				( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) {
2385
2386				// excess is a negative index
2387				match[ 0 ] = match[ 0 ].slice( 0, excess );
2388				match[ 2 ] = unquoted.slice( 0, excess );
2389			}
2390
2391			// Return only captures needed by the pseudo filter method (type and argument)
2392			return match.slice( 0, 3 );
2393		}
2394	},
2395
2396	filter: {
2397
2398		TAG: function( nodeNameSelector ) {
2399			var expectedNodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
2400			return nodeNameSelector === "*" ?
2401				function() {
2402					return true;
2403				} :
2404				function( elem ) {
2405					return nodeName( elem, expectedNodeName );
2406				};
2407		},
2408
2409		CLASS: function( className ) {
2410			var pattern = classCache[ className + " " ];
2411
2412			return pattern ||
2413				( pattern = new RegExp( "(^|" + whitespace + ")" + className +
2414					"(" + whitespace + "|$)" ) ) &&
2415				classCache( className, function( elem ) {
2416					return pattern.test(
2417						typeof elem.className === "string" && elem.className ||
2418							typeof elem.getAttribute !== "undefined" &&
2419								elem.getAttribute( "class" ) ||
2420							""
2421					);
2422				} );
2423		},
2424
2425		ATTR: function( name, operator, check ) {
2426			return function( elem ) {
2427				var result = find.attr( elem, name );
2428
2429				if ( result == null ) {
2430					return operator === "!=";
2431				}
2432				if ( !operator ) {
2433					return true;
2434				}
2435
2436				result += "";
2437
2438				if ( operator === "=" ) {
2439					return result === check;
2440				}
2441				if ( operator === "!=" ) {
2442					return result !== check;
2443				}
2444				if ( operator === "^=" ) {
2445					return check && result.indexOf( check ) === 0;
2446				}
2447				if ( operator === "*=" ) {
2448					return check && result.indexOf( check ) > -1;
2449				}
2450				if ( operator === "$=" ) {
2451					return check && result.slice( -check.length ) === check;
2452				}
2453				if ( operator === "~=" ) {
2454					return ( " " + result.replace( rwhitespace, " " ) + " " )
2455						.indexOf( check ) > -1;
2456				}
2457				if ( operator === "|=" ) {
2458					return result === check || result.slice( 0, check.length + 1 ) === check + "-";
2459				}
2460
2461				return false;
2462			};
2463		},
2464
2465		CHILD: function( type, what, _argument, first, last ) {
2466			var simple = type.slice( 0, 3 ) !== "nth",
2467				forward = type.slice( -4 ) !== "last",
2468				ofType = what === "of-type";
2469
2470			return first === 1 && last === 0 ?
2471
2472				// Shortcut for :nth-*(n)
2473				function( elem ) {
2474					return !!elem.parentNode;
2475				} :
2476
2477				function( elem, _context, xml ) {
2478					var cache, outerCache, node, nodeIndex, start,
2479						dir = simple !== forward ? "nextSibling" : "previousSibling",
2480						parent = elem.parentNode,
2481						name = ofType && elem.nodeName.toLowerCase(),
2482						useCache = !xml && !ofType,
2483						diff = false;
2484
2485					if ( parent ) {
2486
2487						// :(first|last|only)-(child|of-type)
2488						if ( simple ) {
2489							while ( dir ) {
2490								node = elem;
2491								while ( ( node = node[ dir ] ) ) {
2492									if ( ofType ?
2493										nodeName( node, name ) :
2494										node.nodeType === 1 ) {
2495
2496										return false;
2497									}
2498								}
2499
2500								// Reverse direction for :only-* (if we haven't yet done so)
2501								start = dir = type === "only" && !start && "nextSibling";
2502							}
2503							return true;
2504						}
2505
2506						start = [ forward ? parent.firstChild : parent.lastChild ];
2507
2508						// non-xml :nth-child(...) stores cache data on `parent`
2509						if ( forward && useCache ) {
2510
2511							// Seek `elem` from a previously-cached index
2512							outerCache = parent[ expando ] || ( parent[ expando ] = {} );
2513							cache = outerCache[ type ] || [];
2514							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
2515							diff = nodeIndex && cache[ 2 ];
2516							node = nodeIndex && parent.childNodes[ nodeIndex ];
2517
2518							while ( ( node = ++nodeIndex && node && node[ dir ] ||
2519
2520								// Fallback to seeking `elem` from the start
2521								( diff = nodeIndex = 0 ) || start.pop() ) ) {
2522
2523								// When found, cache indexes on `parent` and break
2524								if ( node.nodeType === 1 && ++diff && node === elem ) {
2525									outerCache[ type ] = [ dirruns, nodeIndex, diff ];
2526									break;
2527								}
2528							}
2529
2530						} else {
2531
2532							// Use previously-cached element index if available
2533							if ( useCache ) {
2534								outerCache = elem[ expando ] || ( elem[ expando ] = {} );
2535								cache = outerCache[ type ] || [];
2536								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
2537								diff = nodeIndex;
2538							}
2539
2540							// xml :nth-child(...)
2541							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
2542							if ( diff === false ) {
2543
2544								// Use the same loop as above to seek `elem` from the start
2545								while ( ( node = ++nodeIndex && node && node[ dir ] ||
2546									( diff = nodeIndex = 0 ) || start.pop() ) ) {
2547
2548									if ( ( ofType ?
2549										nodeName( node, name ) :
2550										node.nodeType === 1 ) &&
2551										++diff ) {
2552
2553										// Cache the index of each encountered element
2554										if ( useCache ) {
2555											outerCache = node[ expando ] ||
2556												( node[ expando ] = {} );
2557											outerCache[ type ] = [ dirruns, diff ];
2558										}
2559
2560										if ( node === elem ) {
2561											break;
2562										}
2563									}
2564								}
2565							}
2566						}
2567
2568						// Incorporate the offset, then check against cycle size
2569						diff -= last;
2570						return diff === first || ( diff % first === 0 && diff / first >= 0 );
2571					}
2572				};
2573		},
2574
2575		PSEUDO: function( pseudo, argument ) {
2576
2577			// pseudo-class names are case-insensitive
2578			// https://www.w3.org/TR/selectors/#pseudo-classes
2579			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2580			// Remember that setFilters inherits from pseudos
2581			var args,
2582				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
2583					find.error( "unsupported pseudo: " + pseudo );
2584
2585			// The user may use createPseudo to indicate that
2586			// arguments are needed to create the filter function
2587			// just as jQuery does
2588			if ( fn[ expando ] ) {
2589				return fn( argument );
2590			}
2591
2592			// But maintain support for old signatures
2593			if ( fn.length > 1 ) {
2594				args = [ pseudo, pseudo, "", argument ];
2595				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
2596					markFunction( function( seed, matches ) {
2597						var idx,
2598							matched = fn( seed, argument ),
2599							i = matched.length;
2600						while ( i-- ) {
2601							idx = indexOf.call( seed, matched[ i ] );
2602							seed[ idx ] = !( matches[ idx ] = matched[ i ] );
2603						}
2604					} ) :
2605					function( elem ) {
2606						return fn( elem, 0, args );
2607					};
2608			}
2609
2610			return fn;
2611		}
2612	},
2613
2614	pseudos: {
2615
2616		// Potentially complex pseudos
2617		not: markFunction( function( selector ) {
2618
2619			// Trim the selector passed to compile
2620			// to avoid treating leading and trailing
2621			// spaces as combinators
2622			var input = [],
2623				results = [],
2624				matcher = compile( selector.replace( rtrimCSS, "$1" ) );
2625
2626			return matcher[ expando ] ?
2627				markFunction( function( seed, matches, _context, xml ) {
2628					var elem,
2629						unmatched = matcher( seed, null, xml, [] ),
2630						i = seed.length;
2631
2632					// Match elements unmatched by `matcher`
2633					while ( i-- ) {
2634						if ( ( elem = unmatched[ i ] ) ) {
2635							seed[ i ] = !( matches[ i ] = elem );
2636						}
2637					}
2638				} ) :
2639				function( elem, _context, xml ) {
2640					input[ 0 ] = elem;
2641					matcher( input, null, xml, results );
2642
2643					// Don't keep the element
2644					// (see https://github.com/jquery/sizzle/issues/299)
2645					input[ 0 ] = null;
2646					return !results.pop();
2647				};
2648		} ),
2649
2650		has: markFunction( function( selector ) {
2651			return function( elem ) {
2652				return find( selector, elem ).length > 0;
2653			};
2654		} ),
2655
2656		contains: markFunction( function( text ) {
2657			text = text.replace( runescape, funescape );
2658			return function( elem ) {
2659				return ( elem.textContent || jQuery.text( elem ) ).indexOf( text ) > -1;
2660			};
2661		} ),
2662
2663		// "Whether an element is represented by a :lang() selector
2664		// is based solely on the element's language value
2665		// being equal to the identifier C,
2666		// or beginning with the identifier C immediately followed by "-".
2667		// The matching of C against the element's language value is performed case-insensitively.
2668		// The identifier C does not have to be a valid language name."
2669		// https://www.w3.org/TR/selectors/#lang-pseudo
2670		lang: markFunction( function( lang ) {
2671
2672			// lang value must be a valid identifier
2673			if ( !ridentifier.test( lang || "" ) ) {
2674				find.error( "unsupported lang: " + lang );
2675			}
2676			lang = lang.replace( runescape, funescape ).toLowerCase();
2677			return function( elem ) {
2678				var elemLang;
2679				do {
2680					if ( ( elemLang = documentIsHTML ?
2681						elem.lang :
2682						elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) {
2683
2684						elemLang = elemLang.toLowerCase();
2685						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2686					}
2687				} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );
2688				return false;
2689			};
2690		} ),
2691
2692		// Miscellaneous
2693		target: function( elem ) {
2694			var hash = window.location && window.location.hash;
2695			return hash && hash.slice( 1 ) === elem.id;
2696		},
2697
2698		root: function( elem ) {
2699			return elem === documentElement;
2700		},
2701
2702		focus: function( elem ) {
2703			return elem === safeActiveElement() &&
2704				document.hasFocus() &&
2705				!!( elem.type || elem.href || ~elem.tabIndex );
2706		},
2707
2708		// Boolean properties
2709		enabled: createDisabledPseudo( false ),
2710		disabled: createDisabledPseudo( true ),
2711
2712		checked: function( elem ) {
2713
2714			// In CSS3, :checked should return both checked and selected elements
2715			// https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2716			return ( nodeName( elem, "input" ) && !!elem.checked ) ||
2717				( nodeName( elem, "option" ) && !!elem.selected );
2718		},
2719
2720		selected: function( elem ) {
2721
2722			// Support: IE <=11+
2723			// Accessing the selectedIndex property
2724			// forces the browser to treat the default option as
2725			// selected when in an optgroup.
2726			if ( elem.parentNode ) {
2727				// eslint-disable-next-line no-unused-expressions
2728				elem.parentNode.selectedIndex;
2729			}
2730
2731			return elem.selected === true;
2732		},
2733
2734		// Contents
2735		empty: function( elem ) {
2736
2737			// https://www.w3.org/TR/selectors/#empty-pseudo
2738			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
2739			//   but not by others (comment: 8; processing instruction: 7; etc.)
2740			// nodeType < 6 works because attributes (2) do not appear as children
2741			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2742				if ( elem.nodeType < 6 ) {
2743					return false;
2744				}
2745			}
2746			return true;
2747		},
2748
2749		parent: function( elem ) {
2750			return !Expr.pseudos.empty( elem );
2751		},
2752
2753		// Element/input types
2754		header: function( elem ) {
2755			return rheader.test( elem.nodeName );
2756		},
2757
2758		input: function( elem ) {
2759			return rinputs.test( elem.nodeName );
2760		},
2761
2762		button: function( elem ) {
2763			return nodeName( elem, "input" ) && elem.type === "button" ||
2764				nodeName( elem, "button" );
2765		},
2766
2767		text: function( elem ) {
2768			var attr;
2769			return nodeName( elem, "input" ) && elem.type === "text" &&
2770
2771				// Support: IE <10 only
2772				// New HTML5 attribute values (e.g., "search") appear
2773				// with elem.type === "text"
2774				( ( attr = elem.getAttribute( "type" ) ) == null ||
2775					attr.toLowerCase() === "text" );
2776		},
2777
2778		// Position-in-collection
2779		first: createPositionalPseudo( function() {
2780			return [ 0 ];
2781		} ),
2782
2783		last: createPositionalPseudo( function( _matchIndexes, length ) {
2784			return [ length - 1 ];
2785		} ),
2786
2787		eq: createPositionalPseudo( function( _matchIndexes, length, argument ) {
2788			return [ argument < 0 ? argument + length : argument ];
2789		} ),
2790
2791		even: createPositionalPseudo( function( matchIndexes, length ) {
2792			var i = 0;
2793			for ( ; i < length; i += 2 ) {
2794				matchIndexes.push( i );
2795			}
2796			return matchIndexes;
2797		} ),
2798
2799		odd: createPositionalPseudo( function( matchIndexes, length ) {
2800			var i = 1;
2801			for ( ; i < length; i += 2 ) {
2802				matchIndexes.push( i );
2803			}
2804			return matchIndexes;
2805		} ),
2806
2807		lt: createPositionalPseudo( function( matchIndexes, length, argument ) {
2808			var i;
2809
2810			if ( argument < 0 ) {
2811				i = argument + length;
2812			} else if ( argument > length ) {
2813				i = length;
2814			} else {
2815				i = argument;
2816			}
2817
2818			for ( ; --i >= 0; ) {
2819				matchIndexes.push( i );
2820			}
2821			return matchIndexes;
2822		} ),
2823
2824		gt: createPositionalPseudo( function( matchIndexes, length, argument ) {
2825			var i = argument < 0 ? argument + length : argument;
2826			for ( ; ++i < length; ) {
2827				matchIndexes.push( i );
2828			}
2829			return matchIndexes;
2830		} )
2831	}
2832};
2833
2834Expr.pseudos.nth = Expr.pseudos.eq;
2835
2836// Add button/input type pseudos
2837for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2838	Expr.pseudos[ i ] = createInputPseudo( i );
2839}
2840for ( i in { submit: true, reset: true } ) {
2841	Expr.pseudos[ i ] = createButtonPseudo( i );
2842}
2843
2844// Easy API for creating new setFilters
2845function setFilters() {}
2846setFilters.prototype = Expr.filters = Expr.pseudos;
2847Expr.setFilters = new setFilters();
2848
2849function tokenize( selector, parseOnly ) {
2850	var matched, match, tokens, type,
2851		soFar, groups, preFilters,
2852		cached = tokenCache[ selector + " " ];
2853
2854	if ( cached ) {
2855		return parseOnly ? 0 : cached.slice( 0 );
2856	}
2857
2858	soFar = selector;
2859	groups = [];
2860	preFilters = Expr.preFilter;
2861
2862	while ( soFar ) {
2863
2864		// Comma and first run
2865		if ( !matched || ( match = rcomma.exec( soFar ) ) ) {
2866			if ( match ) {
2867
2868				// Don't consume trailing commas as valid
2869				soFar = soFar.slice( match[ 0 ].length ) || soFar;
2870			}
2871			groups.push( ( tokens = [] ) );
2872		}
2873
2874		matched = false;
2875
2876		// Combinators
2877		if ( ( match = rleadingCombinator.exec( soFar ) ) ) {
2878			matched = match.shift();
2879			tokens.push( {
2880				value: matched,
2881
2882				// Cast descendant combinators to space
2883				type: match[ 0 ].replace( rtrimCSS, " " )
2884			} );
2885			soFar = soFar.slice( matched.length );
2886		}
2887
2888		// Filters
2889		for ( type in Expr.filter ) {
2890			if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||
2891				( match = preFilters[ type ]( match ) ) ) ) {
2892				matched = match.shift();
2893				tokens.push( {
2894					value: matched,
2895					type: type,
2896					matches: match
2897				} );
2898				soFar = soFar.slice( matched.length );
2899			}
2900		}
2901
2902		if ( !matched ) {
2903			break;
2904		}
2905	}
2906
2907	// Return the length of the invalid excess
2908	// if we're just parsing
2909	// Otherwise, throw an error or return tokens
2910	if ( parseOnly ) {
2911		return soFar.length;
2912	}
2913
2914	return soFar ?
2915		find.error( selector ) :
2916
2917		// Cache the tokens
2918		tokenCache( selector, groups ).slice( 0 );
2919}
2920
2921function toSelector( tokens ) {
2922	var i = 0,
2923		len = tokens.length,
2924		selector = "";
2925	for ( ; i < len; i++ ) {
2926		selector += tokens[ i ].value;
2927	}
2928	return selector;
2929}
2930
2931function addCombinator( matcher, combinator, base ) {
2932	var dir = combinator.dir,
2933		skip = combinator.next,
2934		key = skip || dir,
2935		checkNonElements = base && key === "parentNode",
2936		doneName = done++;
2937
2938	return combinator.first ?
2939
2940		// Check against closest ancestor/preceding element
2941		function( elem, context, xml ) {
2942			while ( ( elem = elem[ dir ] ) ) {
2943				if ( elem.nodeType === 1 || checkNonElements ) {
2944					return matcher( elem, context, xml );
2945				}
2946			}
2947			return false;
2948		} :
2949
2950		// Check against all ancestor/preceding elements
2951		function( elem, context, xml ) {
2952			var oldCache, outerCache,
2953				newCache = [ dirruns, doneName ];
2954
2955			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2956			if ( xml ) {
2957				while ( ( elem = elem[ dir ] ) ) {
2958					if ( elem.nodeType === 1 || checkNonElements ) {
2959						if ( matcher( elem, context, xml ) ) {
2960							return true;
2961						}
2962					}
2963				}
2964			} else {
2965				while ( ( elem = elem[ dir ] ) ) {
2966					if ( elem.nodeType === 1 || checkNonElements ) {
2967						outerCache = elem[ expando ] || ( elem[ expando ] = {} );
2968
2969						if ( skip && nodeName( elem, skip ) ) {
2970							elem = elem[ dir ] || elem;
2971						} else if ( ( oldCache = outerCache[ key ] ) &&
2972							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2973
2974							// Assign to newCache so results back-propagate to previous elements
2975							return ( newCache[ 2 ] = oldCache[ 2 ] );
2976						} else {
2977
2978							// Reuse newcache so results back-propagate to previous elements
2979							outerCache[ key ] = newCache;
2980
2981							// A match means we're done; a fail means we have to keep checking
2982							if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {
2983								return true;
2984							}
2985						}
2986					}
2987				}
2988			}
2989			return false;
2990		};
2991}
2992
2993function elementMatcher( matchers ) {
2994	return matchers.length > 1 ?
2995		function( elem, context, xml ) {
2996			var i = matchers.length;
2997			while ( i-- ) {
2998				if ( !matchers[ i ]( elem, context, xml ) ) {
2999					return false;
3000				}
3001			}
3002			return true;
3003		} :
3004		matchers[ 0 ];
3005}
3006
3007function multipleContexts( selector, contexts, results ) {
3008	var i = 0,
3009		len = contexts.length;
3010	for ( ; i < len; i++ ) {
3011		find( selector, contexts[ i ], results );
3012	}
3013	return results;
3014}
3015
3016function condense( unmatched, map, filter, context, xml ) {
3017	var elem,
3018		newUnmatched = [],
3019		i = 0,
3020		len = unmatched.length,
3021		mapped = map != null;
3022
3023	for ( ; i < len; i++ ) {
3024		if ( ( elem = unmatched[ i ] ) ) {
3025			if ( !filter || filter( elem, context, xml ) ) {
3026				newUnmatched.push( elem );
3027				if ( mapped ) {
3028					map.push( i );
3029				}
3030			}
3031		}
3032	}
3033
3034	return newUnmatched;
3035}
3036
3037function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
3038	if ( postFilter && !postFilter[ expando ] ) {
3039		postFilter = setMatcher( postFilter );
3040	}
3041	if ( postFinder && !postFinder[ expando ] ) {
3042		postFinder = setMatcher( postFinder, postSelector );
3043	}
3044	return markFunction( function( seed, results, context, xml ) {
3045		var temp, i, elem, matcherOut,
3046			preMap = [],
3047			postMap = [],
3048			preexisting = results.length,
3049
3050			// Get initial elements from seed or context
3051			elems = seed ||
3052				multipleContexts( selector || "*",
3053					context.nodeType ? [ context ] : context, [] ),
3054
3055			// Prefilter to get matcher input, preserving a map for seed-results synchronization
3056			matcherIn = preFilter && ( seed || !selector ) ?
3057				condense( elems, preMap, preFilter, context, xml ) :
3058				elems;
3059
3060		if ( matcher ) {
3061
3062			// If we have a postFinder, or filtered seed, or non-seed postFilter
3063			// or preexisting results,
3064			matcherOut = postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
3065
3066				// ...intermediate processing is necessary
3067				[] :
3068
3069				// ...otherwise use results directly
3070				results;
3071
3072			// Find primary matches
3073			matcher( matcherIn, matcherOut, context, xml );
3074		} else {
3075			matcherOut = matcherIn;
3076		}
3077
3078		// Apply postFilter
3079		if ( postFilter ) {
3080			temp = condense( matcherOut, postMap );
3081			postFilter( temp, [], context, xml );
3082
3083			// Un-match failing elements by moving them back to matcherIn
3084			i = temp.length;
3085			while ( i-- ) {
3086				if ( ( elem = temp[ i ] ) ) {
3087					matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );
3088				}
3089			}
3090		}
3091
3092		if ( seed ) {
3093			if ( postFinder || preFilter ) {
3094				if ( postFinder ) {
3095
3096					// Get the final matcherOut by condensing this intermediate into postFinder contexts
3097					temp = [];
3098					i = matcherOut.length;
3099					while ( i-- ) {
3100						if ( ( elem = matcherOut[ i ] ) ) {
3101
3102							// Restore matcherIn since elem is not yet a final match
3103							temp.push( ( matcherIn[ i ] = elem ) );
3104						}
3105					}
3106					postFinder( null, ( matcherOut = [] ), temp, xml );
3107				}
3108
3109				// Move matched elements from seed to results to keep them synchronized
3110				i = matcherOut.length;
3111				while ( i-- ) {
3112					if ( ( elem = matcherOut[ i ] ) &&
3113						( temp = postFinder ? indexOf.call( seed, elem ) : preMap[ i ] ) > -1 ) {
3114
3115						seed[ temp ] = !( results[ temp ] = elem );
3116					}
3117				}
3118			}
3119
3120		// Add elements to results, through postFinder if defined
3121		} else {
3122			matcherOut = condense(
3123				matcherOut === results ?
3124					matcherOut.splice( preexisting, matcherOut.length ) :
3125					matcherOut
3126			);
3127			if ( postFinder ) {
3128				postFinder( null, results, matcherOut, xml );
3129			} else {
3130				push.apply( results, matcherOut );
3131			}
3132		}
3133	} );
3134}
3135
3136function matcherFromTokens( tokens ) {
3137	var checkContext, matcher, j,
3138		len = tokens.length,
3139		leadingRelative = Expr.relative[ tokens[ 0 ].type ],
3140		implicitRelative = leadingRelative || Expr.relative[ " " ],
3141		i = leadingRelative ? 1 : 0,
3142
3143		// The foundational matcher ensures that elements are reachable from top-level context(s)
3144		matchContext = addCombinator( function( elem ) {
3145			return elem === checkContext;
3146		}, implicitRelative, true ),
3147		matchAnyContext = addCombinator( function( elem ) {
3148			return indexOf.call( checkContext, elem ) > -1;
3149		}, implicitRelative, true ),
3150		matchers = [ function( elem, context, xml ) {
3151
3152			// Support: IE 11+, Edge 17 - 18+
3153			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
3154			// two documents; shallow comparisons work.
3155			// eslint-disable-next-line eqeqeq
3156			var ret = ( !leadingRelative && ( xml || context != outermostContext ) ) || (
3157				( checkContext = context ).nodeType ?
3158					matchContext( elem, context, xml ) :
3159					matchAnyContext( elem, context, xml ) );
3160
3161			// Avoid hanging onto element
3162			// (see https://github.com/jquery/sizzle/issues/299)
3163			checkContext = null;
3164			return ret;
3165		} ];
3166
3167	for ( ; i < len; i++ ) {
3168		if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {
3169			matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
3170		} else {
3171			matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );
3172
3173			// Return special upon seeing a positional matcher
3174			if ( matcher[ expando ] ) {
3175
3176				// Find the next relative operator (if any) for proper handling
3177				j = ++i;
3178				for ( ; j < len; j++ ) {
3179					if ( Expr.relative[ tokens[ j ].type ] ) {
3180						break;
3181					}
3182				}
3183				return setMatcher(
3184					i > 1 && elementMatcher( matchers ),
3185					i > 1 && toSelector(
3186
3187						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
3188						tokens.slice( 0, i - 1 )
3189							.concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } )
3190					).replace( rtrimCSS, "$1" ),
3191					matcher,
3192					i < j && matcherFromTokens( tokens.slice( i, j ) ),
3193					j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),
3194					j < len && toSelector( tokens )
3195				);
3196			}
3197			matchers.push( matcher );
3198		}
3199	}
3200
3201	return elementMatcher( matchers );
3202}
3203
3204function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
3205	var bySet = setMatchers.length > 0,
3206		byElement = elementMatchers.length > 0,
3207		superMatcher = function( seed, context, xml, results, outermost ) {
3208			var elem, j, matcher,
3209				matchedCount = 0,
3210				i = "0",
3211				unmatched = seed && [],
3212				setMatched = [],
3213				contextBackup = outermostContext,
3214
3215				// We must always have either seed elements or outermost context
3216				elems = seed || byElement && Expr.find.TAG( "*", outermost ),
3217
3218				// Use integer dirruns iff this is the outermost matcher
3219				dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),
3220				len = elems.length;
3221
3222			if ( outermost ) {
3223
3224				// Support: IE 11+, Edge 17 - 18+
3225				// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
3226				// two documents; shallow comparisons work.
3227				// eslint-disable-next-line eqeqeq
3228				outermostContext = context == document || context || outermost;
3229			}
3230
3231			// Add elements passing elementMatchers directly to results
3232			// Support: iOS <=7 - 9 only
3233			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching
3234			// elements by id. (see trac-14142)
3235			for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {
3236				if ( byElement && elem ) {
3237					j = 0;
3238
3239					// Support: IE 11+, Edge 17 - 18+
3240					// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
3241					// two documents; shallow comparisons work.
3242					// eslint-disable-next-line eqeqeq
3243					if ( !context && elem.ownerDocument != document ) {
3244						setDocument( elem );
3245						xml = !documentIsHTML;
3246					}
3247					while ( ( matcher = elementMatchers[ j++ ] ) ) {
3248						if ( matcher( elem, context || document, xml ) ) {
3249							push.call( results, elem );
3250							break;
3251						}
3252					}
3253					if ( outermost ) {
3254						dirruns = dirrunsUnique;
3255					}
3256				}
3257
3258				// Track unmatched elements for set filters
3259				if ( bySet ) {
3260
3261					// They will have gone through all possible matchers
3262					if ( ( elem = !matcher && elem ) ) {
3263						matchedCount--;
3264					}
3265
3266					// Lengthen the array for every element, matched or not
3267					if ( seed ) {
3268						unmatched.push( elem );
3269					}
3270				}
3271			}
3272
3273			// `i` is now the count of elements visited above, and adding it to `matchedCount`
3274			// makes the latter nonnegative.
3275			matchedCount += i;
3276
3277			// Apply set filters to unmatched elements
3278			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
3279			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
3280			// no element matchers and no seed.
3281			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
3282			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
3283			// numerically zero.
3284			if ( bySet && i !== matchedCount ) {
3285				j = 0;
3286				while ( ( matcher = setMatchers[ j++ ] ) ) {
3287					matcher( unmatched, setMatched, context, xml );
3288				}
3289
3290				if ( seed ) {
3291
3292					// Reintegrate element matches to eliminate the need for sorting
3293					if ( matchedCount > 0 ) {
3294						while ( i-- ) {
3295							if ( !( unmatched[ i ] || setMatched[ i ] ) ) {
3296								setMatched[ i ] = pop.call( results );
3297							}
3298						}
3299					}
3300
3301					// Discard index placeholder values to get only actual matches
3302					setMatched = condense( setMatched );
3303				}
3304
3305				// Add matches to results
3306				push.apply( results, setMatched );
3307
3308				// Seedless set matches succeeding multiple successful matchers stipulate sorting
3309				if ( outermost && !seed && setMatched.length > 0 &&
3310					( matchedCount + setMatchers.length ) > 1 ) {
3311
3312					jQuery.uniqueSort( results );
3313				}
3314			}
3315
3316			// Override manipulation of globals by nested matchers
3317			if ( outermost ) {
3318				dirruns = dirrunsUnique;
3319				outermostContext = contextBackup;
3320			}
3321
3322			return unmatched;
3323		};
3324
3325	return bySet ?
3326		markFunction( superMatcher ) :
3327		superMatcher;
3328}
3329
3330function compile( selector, match /* Internal Use Only */ ) {
3331	var i,
3332		setMatchers = [],
3333		elementMatchers = [],
3334		cached = compilerCache[ selector + " " ];
3335
3336	if ( !cached ) {
3337
3338		// Generate a function of recursive functions that can be used to check each element
3339		if ( !match ) {
3340			match = tokenize( selector );
3341		}
3342		i = match.length;
3343		while ( i-- ) {
3344			cached = matcherFromTokens( match[ i ] );
3345			if ( cached[ expando ] ) {
3346				setMatchers.push( cached );
3347			} else {
3348				elementMatchers.push( cached );
3349			}
3350		}
3351
3352		// Cache the compiled function
3353		cached = compilerCache( selector,
3354			matcherFromGroupMatchers( elementMatchers, setMatchers ) );
3355
3356		// Save selector and tokenization
3357		cached.selector = selector;
3358	}
3359	return cached;
3360}
3361
3362/**
3363 * A low-level selection function that works with jQuery's compiled
3364 *  selector functions
3365 * @param {String|Function} selector A selector or a pre-compiled
3366 *  selector function built with jQuery selector compile
3367 * @param {Element} context
3368 * @param {Array} [results]
3369 * @param {Array} [seed] A set of elements to match against
3370 */
3371function select( selector, context, results, seed ) {
3372	var i, tokens, token, type, find,
3373		compiled = typeof selector === "function" && selector,
3374		match = !seed && tokenize( ( selector = compiled.selector || selector ) );
3375
3376	results = results || [];
3377
3378	// Try to minimize operations if there is only one selector in the list and no seed
3379	// (the latter of which guarantees us context)
3380	if ( match.length === 1 ) {
3381
3382		// Reduce context if the leading compound selector is an ID
3383		tokens = match[ 0 ] = match[ 0 ].slice( 0 );
3384		if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
3385				context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {
3386
3387			context = ( Expr.find.ID(
3388				token.matches[ 0 ].replace( runescape, funescape ),
3389				context
3390			) || [] )[ 0 ];
3391			if ( !context ) {
3392				return results;
3393
3394			// Precompiled matchers will still verify ancestry, so step up a level
3395			} else if ( compiled ) {
3396				context = context.parentNode;
3397			}
3398
3399			selector = selector.slice( tokens.shift().value.length );
3400		}
3401
3402		// Fetch a seed set for right-to-left matching
3403		i = matchExpr.needsContext.test( selector ) ? 0 : tokens.length;
3404		while ( i-- ) {
3405			token = tokens[ i ];
3406
3407			// Abort if we hit a combinator
3408			if ( Expr.relative[ ( type = token.type ) ] ) {
3409				break;
3410			}
3411			if ( ( find = Expr.find[ type ] ) ) {
3412
3413				// Search, expanding context for leading sibling combinators
3414				if ( ( seed = find(
3415					token.matches[ 0 ].replace( runescape, funescape ),
3416					rsibling.test( tokens[ 0 ].type ) &&
3417						testContext( context.parentNode ) || context
3418				) ) ) {
3419
3420					// If seed is empty or no tokens remain, we can return early
3421					tokens.splice( i, 1 );
3422					selector = seed.length && toSelector( tokens );
3423					if ( !selector ) {
3424						push.apply( results, seed );
3425						return results;
3426					}
3427
3428					break;
3429				}
3430			}
3431		}
3432	}
3433
3434	// Compile and execute a filtering function if one is not provided
3435	// Provide `match` to avoid retokenization if we modified the selector above
3436	( compiled || compile( selector, match ) )(
3437		seed,
3438		context,
3439		!documentIsHTML,
3440		results,
3441		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
3442	);
3443	return results;
3444}
3445
3446// One-time assignments
3447
3448// Support: Android <=4.0 - 4.1+
3449// Sort stability
3450support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando;
3451
3452// Initialize against the default document
3453setDocument();
3454
3455// Support: Android <=4.0 - 4.1+
3456// Detached nodes confoundingly follow *each other*
3457support.sortDetached = assert( function( el ) {
3458
3459	// Should return 1, but returns 4 (following)
3460	return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1;
3461} );
3462
3463jQuery.find = find;
3464
3465// Deprecated
3466jQuery.expr[ ":" ] = jQuery.expr.pseudos;
3467jQuery.unique = jQuery.uniqueSort;
3468
3469// These have always been private, but they used to be documented as part of
3470// Sizzle so let's maintain them for now for backwards compatibility purposes.
3471find.compile = compile;
3472find.select = select;
3473find.setDocument = setDocument;
3474find.tokenize = tokenize;
3475
3476find.escape = jQuery.escapeSelector;
3477find.getText = jQuery.text;
3478find.isXML = jQuery.isXMLDoc;
3479find.selectors = jQuery.expr;
3480find.support = jQuery.support;
3481find.uniqueSort = jQuery.uniqueSort;
3482
3483	/* eslint-enable */
3484
3485} )();
3486
3487
3488var dir = function( elem, dir, until ) {
3489	var matched = [],
3490		truncate = until !== undefined;
3491
3492	while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
3493		if ( elem.nodeType === 1 ) {
3494			if ( truncate && jQuery( elem ).is( until ) ) {
3495				break;
3496			}
3497			matched.push( elem );
3498		}
3499	}
3500	return matched;
3501};
3502
3503
3504var siblings = function( n, elem ) {
3505	var matched = [];
3506
3507	for ( ; n; n = n.nextSibling ) {
3508		if ( n.nodeType === 1 && n !== elem ) {
3509			matched.push( n );
3510		}
3511	}
3512
3513	return matched;
3514};
3515
3516
3517var rneedsContext = jQuery.expr.match.needsContext;
3518
3519var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
3520
3521
3522
3523// Implement the identical functionality for filter and not
3524function winnow( elements, qualifier, not ) {
3525	if ( isFunction( qualifier ) ) {
3526		return jQuery.grep( elements, function( elem, i ) {
3527			return !!qualifier.call( elem, i, elem ) !== not;
3528		} );
3529	}
3530
3531	// Single element
3532	if ( qualifier.nodeType ) {
3533		return jQuery.grep( elements, function( elem ) {
3534			return ( elem === qualifier ) !== not;
3535		} );
3536	}
3537
3538	// Arraylike of elements (jQuery, arguments, Array)
3539	if ( typeof qualifier !== "string" ) {
3540		return jQuery.grep( elements, function( elem ) {
3541			return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
3542		} );
3543	}
3544
3545	// Filtered directly for both simple and complex selectors
3546	return jQuery.filter( qualifier, elements, not );
3547}
3548
3549jQuery.filter = function( expr, elems, not ) {
3550	var elem = elems[ 0 ];
3551
3552	if ( not ) {
3553		expr = ":not(" + expr + ")";
3554	}
3555
3556	if ( elems.length === 1 && elem.nodeType === 1 ) {
3557		return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
3558	}
3559
3560	return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
3561		return elem.nodeType === 1;
3562	} ) );
3563};
3564
3565jQuery.fn.extend( {
3566	find: function( selector ) {
3567		var i, ret,
3568			len = this.length,
3569			self = this;
3570
3571		if ( typeof selector !== "string" ) {
3572			return this.pushStack( jQuery( selector ).filter( function() {
3573				for ( i = 0; i < len; i++ ) {
3574					if ( jQuery.contains( self[ i ], this ) ) {
3575						return true;
3576					}
3577				}
3578			} ) );
3579		}
3580
3581		ret = this.pushStack( [] );
3582
3583		for ( i = 0; i < len; i++ ) {
3584			jQuery.find( selector, self[ i ], ret );
3585		}
3586
3587		return len > 1 ? jQuery.uniqueSort( ret ) : ret;
3588	},
3589	filter: function( selector ) {
3590		return this.pushStack( winnow( this, selector || [], false ) );
3591	},
3592	not: function( selector ) {
3593		return this.pushStack( winnow( this, selector || [], true ) );
3594	},
3595	is: function( selector ) {
3596		return !!winnow(
3597			this,
3598
3599			// If this is a positional/relative selector, check membership in the returned set
3600			// so $("p:first").is("p:last") won't return true for a doc with two "p".
3601			typeof selector === "string" && rneedsContext.test( selector ) ?
3602				jQuery( selector ) :
3603				selector || [],
3604			false
3605		).length;
3606	}
3607} );
3608
3609
3610// Initialize a jQuery object
3611
3612
3613// A central reference to the root jQuery(document)
3614var rootjQuery,
3615
3616	// A simple way to check for HTML strings
3617	// Prioritize #id over <tag> to avoid XSS via location.hash (trac-9521)
3618	// Strict HTML recognition (trac-11290: must start with <)
3619	// Shortcut simple #id case for speed
3620	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
3621
3622	init = jQuery.fn.init = function( selector, context, root ) {
3623		var match, elem;
3624
3625		// HANDLE: $(""), $(null), $(undefined), $(false)
3626		if ( !selector ) {
3627			return this;
3628		}
3629
3630		// Method init() accepts an alternate rootjQuery
3631		// so migrate can support jQuery.sub (gh-2101)
3632		root = root || rootjQuery;
3633
3634		// Handle HTML strings
3635		if ( typeof selector === "string" ) {
3636			if ( selector[ 0 ] === "<" &&
3637				selector[ selector.length - 1 ] === ">" &&
3638				selector.length >= 3 ) {
3639
3640				// Assume that strings that start and end with <> are HTML and skip the regex check
3641				match = [ null, selector, null ];
3642
3643			} else {
3644				match = rquickExpr.exec( selector );
3645			}
3646
3647			// Match html or make sure no context is specified for #id
3648			if ( match && ( match[ 1 ] || !context ) ) {
3649
3650				// HANDLE: $(html) -> $(array)
3651				if ( match[ 1 ] ) {
3652					context = context instanceof jQuery ? context[ 0 ] : context;
3653
3654					// Option to run scripts is true for back-compat
3655					// Intentionally let the error be thrown if parseHTML is not present
3656					jQuery.merge( this, jQuery.parseHTML(
3657						match[ 1 ],
3658						context && context.nodeType ? context.ownerDocument || context : document,
3659						true
3660					) );
3661
3662					// HANDLE: $(html, props)
3663					if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
3664						for ( match in context ) {
3665
3666							// Properties of context are called as methods if possible
3667							if ( isFunction( this[ match ] ) ) {
3668								this[ match ]( context[ match ] );
3669
3670							// ...and otherwise set as attributes
3671							} else {
3672								this.attr( match, context[ match ] );
3673							}
3674						}
3675					}
3676
3677					return this;
3678
3679				// HANDLE: $(#id)
3680				} else {
3681					elem = document.getElementById( match[ 2 ] );
3682
3683					if ( elem ) {
3684
3685						// Inject the element directly into the jQuery object
3686						this[ 0 ] = elem;
3687						this.length = 1;
3688					}
3689					return this;
3690				}
3691
3692			// HANDLE: $(expr, $(...))
3693			} else if ( !context || context.jquery ) {
3694				return ( context || root ).find( selector );
3695
3696			// HANDLE: $(expr, context)
3697			// (which is just equivalent to: $(context).find(expr)
3698			} else {
3699				return this.constructor( context ).find( selector );
3700			}
3701
3702		// HANDLE: $(DOMElement)
3703		} else if ( selector.nodeType ) {
3704			this[ 0 ] = selector;
3705			this.length = 1;
3706			return this;
3707
3708		// HANDLE: $(function)
3709		// Shortcut for document ready
3710		} else if ( isFunction( selector ) ) {
3711			return root.ready !== undefined ?
3712				root.ready( selector ) :
3713
3714				// Execute immediately if ready is not present
3715				selector( jQuery );
3716		}
3717
3718		return jQuery.makeArray( selector, this );
3719	};
3720
3721// Give the init function the jQuery prototype for later instantiation
3722init.prototype = jQuery.fn;
3723
3724// Initialize central reference
3725rootjQuery = jQuery( document );
3726
3727
3728var rparentsprev = /^(?:parents|prev(?:Until|All))/,
3729
3730	// Methods guaranteed to produce a unique set when starting from a unique set
3731	guaranteedUnique = {
3732		children: true,
3733		contents: true,
3734		next: true,
3735		prev: true
3736	};
3737
3738jQuery.fn.extend( {
3739	has: function( target ) {
3740		var targets = jQuery( target, this ),
3741			l = targets.length;
3742
3743		return this.filter( function() {
3744			var i = 0;
3745			for ( ; i < l; i++ ) {
3746				if ( jQuery.contains( this, targets[ i ] ) ) {
3747					return true;
3748				}
3749			}
3750		} );
3751	},
3752
3753	closest: function( selectors, context ) {
3754		var cur,
3755			i = 0,
3756			l = this.length,
3757			matched = [],
3758			targets = typeof selectors !== "string" && jQuery( selectors );
3759
3760		// Positional selectors never match, since there's no _selection_ context
3761		if ( !rneedsContext.test( selectors ) ) {
3762			for ( ; i < l; i++ ) {
3763				for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
3764
3765					// Always skip document fragments
3766					if ( cur.nodeType < 11 && ( targets ?
3767						targets.index( cur ) > -1 :
3768
3769						// Don't pass non-elements to jQuery#find
3770						cur.nodeType === 1 &&
3771							jQuery.find.matchesSelector( cur, selectors ) ) ) {
3772
3773						matched.push( cur );
3774						break;
3775					}
3776				}
3777			}
3778		}
3779
3780		return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
3781	},
3782
3783	// Determine the position of an element within the set
3784	index: function( elem ) {
3785
3786		// No argument, return index in parent
3787		if ( !elem ) {
3788			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
3789		}
3790
3791		// Index in selector
3792		if ( typeof elem === "string" ) {
3793			return indexOf.call( jQuery( elem ), this[ 0 ] );
3794		}
3795
3796		// Locate the position of the desired element
3797		return indexOf.call( this,
3798
3799			// If it receives a jQuery object, the first element is used
3800			elem.jquery ? elem[ 0 ] : elem
3801		);
3802	},
3803
3804	add: function( selector, context ) {
3805		return this.pushStack(
3806			jQuery.uniqueSort(
3807				jQuery.merge( this.get(), jQuery( selector, context ) )
3808			)
3809		);
3810	},
3811
3812	addBack: function( selector ) {
3813		return this.add( selector == null ?
3814			this.prevObject : this.prevObject.filter( selector )
3815		);
3816	}
3817} );
3818
3819function sibling( cur, dir ) {
3820	while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
3821	return cur;
3822}
3823
3824jQuery.each( {
3825	parent: function( elem ) {
3826		var parent = elem.parentNode;
3827		return parent && parent.nodeType !== 11 ? parent : null;
3828	},
3829	parents: function( elem ) {
3830		return dir( elem, "parentNode" );
3831	},
3832	parentsUntil: function( elem, _i, until ) {
3833		return dir( elem, "parentNode", until );
3834	},
3835	next: function( elem ) {
3836		return sibling( elem, "nextSibling" );
3837	},
3838	prev: function( elem ) {
3839		return sibling( elem, "previousSibling" );
3840	},
3841	nextAll: function( elem ) {
3842		return dir( elem, "nextSibling" );
3843	},
3844	prevAll: function( elem ) {
3845		return dir( elem, "previousSibling" );
3846	},
3847	nextUntil: function( elem, _i, until ) {
3848		return dir( elem, "nextSibling", until );
3849	},
3850	prevUntil: function( elem, _i, until ) {
3851		return dir( elem, "previousSibling", until );
3852	},
3853	siblings: function( elem ) {
3854		return siblings( ( elem.parentNode || {} ).firstChild, elem );
3855	},
3856	children: function( elem ) {
3857		return siblings( elem.firstChild );
3858	},
3859	contents: function( elem ) {
3860		if ( elem.contentDocument != null &&
3861
3862			// Support: IE 11+
3863			// <object> elements with no `data` attribute has an object
3864			// `contentDocument` with a `null` prototype.
3865			getProto( elem.contentDocument ) ) {
3866
3867			return elem.contentDocument;
3868		}
3869
3870		// Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
3871		// Treat the template element as a regular one in browsers that
3872		// don't support it.
3873		if ( nodeName( elem, "template" ) ) {
3874			elem = elem.content || elem;
3875		}
3876
3877		return jQuery.merge( [], elem.childNodes );
3878	}
3879}, function( name, fn ) {
3880	jQuery.fn[ name ] = function( until, selector ) {
3881		var matched = jQuery.map( this, fn, until );
3882
3883		if ( name.slice( -5 ) !== "Until" ) {
3884			selector = until;
3885		}
3886
3887		if ( selector && typeof selector === "string" ) {
3888			matched = jQuery.filter( selector, matched );
3889		}
3890
3891		if ( this.length > 1 ) {
3892
3893			// Remove duplicates
3894			if ( !guaranteedUnique[ name ] ) {
3895				jQuery.uniqueSort( matched );
3896			}
3897
3898			// Reverse order for parents* and prev-derivatives
3899			if ( rparentsprev.test( name ) ) {
3900				matched.reverse();
3901			}
3902		}
3903
3904		return this.pushStack( matched );
3905	};
3906} );
3907var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
3908
3909
3910
3911// Convert String-formatted options into Object-formatted ones
3912function createOptions( options ) {
3913	var object = {};
3914	jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
3915		object[ flag ] = true;
3916	} );
3917	return object;
3918}
3919
3920/*
3921 * Create a callback list using the following parameters:
3922 *
3923 *	options: an optional list of space-separated options that will change how
3924 *			the callback list behaves or a more traditional option object
3925 *
3926 * By default a callback list will act like an event callback list and can be
3927 * "fired" multiple times.
3928 *
3929 * Possible options:
3930 *
3931 *	once:			will ensure the callback list can only be fired once (like a Deferred)
3932 *
3933 *	memory:			will keep track of previous values and will call any callback added
3934 *					after the list has been fired right away with the latest "memorized"
3935 *					values (like a Deferred)
3936 *
3937 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
3938 *
3939 *	stopOnFalse:	interrupt callings when a callback returns false
3940 *
3941 */
3942jQuery.Callbacks = function( options ) {
3943
3944	// Convert options from String-formatted to Object-formatted if needed
3945	// (we check in cache first)
3946	options = typeof options === "string" ?
3947		createOptions( options ) :
3948		jQuery.extend( {}, options );
3949
3950	var // Flag to know if list is currently firing
3951		firing,
3952
3953		// Last fire value for non-forgettable lists
3954		memory,
3955
3956		// Flag to know if list was already fired
3957		fired,
3958
3959		// Flag to prevent firing
3960		locked,
3961
3962		// Actual callback list
3963		list = [],
3964
3965		// Queue of execution data for repeatable lists
3966		queue = [],
3967
3968		// Index of currently firing callback (modified by add/remove as needed)
3969		firingIndex = -1,
3970
3971		// Fire callbacks
3972		fire = function() {
3973
3974			// Enforce single-firing
3975			locked = locked || options.once;
3976
3977			// Execute callbacks for all pending executions,
3978			// respecting firingIndex overrides and runtime changes
3979			fired = firing = true;
3980			for ( ; queue.length; firingIndex = -1 ) {
3981				memory = queue.shift();
3982				while ( ++firingIndex < list.length ) {
3983
3984					// Run callback and check for early termination
3985					if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
3986						options.stopOnFalse ) {
3987
3988						// Jump to end and forget the data so .add doesn't re-fire
3989						firingIndex = list.length;
3990						memory = false;