https://www.macsf.fr/build/vitrine_newindex_js.js

3/***/ "./assets/sitevitrine/js/lib/owl.carousel.min.js":
4/*!*******************************************************!*\
5  !*** ./assets/sitevitrine/js/lib/owl.carousel.min.js ***!
6  \*******************************************************/
7/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
8
9/* provided dependency */ var jQuery = __webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js");
10/* provided dependency */ var __webpack_provided_window_dot_jQuery = __webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js");
11function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
12__webpack_require__(/*! core-js/modules/es.symbol.js */ "./node_modules/core-js/modules/es.symbol.js");
13__webpack_require__(/*! core-js/modules/es.symbol.description.js */ "./node_modules/core-js/modules/es.symbol.description.js");
14__webpack_require__(/*! core-js/modules/es.symbol.iterator.js */ "./node_modules/core-js/modules/es.symbol.iterator.js");
15__webpack_require__(/*! core-js/modules/es.array.concat.js */ "./node_modules/core-js/modules/es.array.concat.js");
16__webpack_require__(/*! core-js/modules/es.array.filter.js */ "./node_modules/core-js/modules/es.array.filter.js");
17__webpack_require__(/*! core-js/modules/es.array.find.js */ "./node_modules/core-js/modules/es.array.find.js");
18__webpack_require__(/*! core-js/modules/es.array.index-of.js */ "./node_modules/core-js/modules/es.array.index-of.js");
19__webpack_require__(/*! core-js/modules/es.array.iterator.js */ "./node_modules/core-js/modules/es.array.iterator.js");
20__webpack_require__(/*! core-js/modules/es.array.join.js */ "./node_modules/core-js/modules/es.array.join.js");
21__webpack_require__(/*! core-js/modules/es.array.map.js */ "./node_modules/core-js/modules/es.array.map.js");
22__webpack_require__(/*! core-js/modules/es.array.slice.js */ "./node_modules/core-js/modules/es.array.slice.js");
23__webpack_require__(/*! core-js/modules/es.array.splice.js */ "./node_modules/core-js/modules/es.array.splice.js");
24__webpack_require__(/*! core-js/modules/es.date.to-string.js */ "./node_modules/core-js/modules/es.date.to-string.js");
25__webpack_require__(/*! core-js/modules/es.function.name.js */ "./node_modules/core-js/modules/es.function.name.js");
26__webpack_require__(/*! core-js/modules/es.number.constructor.js */ "./node_modules/core-js/modules/es.number.constructor.js");
27__webpack_require__(/*! core-js/modules/es.number.to-fixed.js */ "./node_modules/core-js/modules/es.number.to-fixed.js");
28__webpack_require__(/*! core-js/modules/es.object.get-own-property-names.js */ "./node_modules/core-js/modules/es.object.get-own-property-names.js");
29__webpack_require__(/*! core-js/modules/es.object.to-string.js */ "./node_modules/core-js/modules/es.object.to-string.js");
30__webpack_require__(/*! core-js/modules/es.parse-float.js */ "./node_modules/core-js/modules/es.parse-float.js");
31__webpack_require__(/*! core-js/modules/es.promise.js */ "./node_modules/core-js/modules/es.promise.js");
32__webpack_require__(/*! core-js/modules/es.regexp.constructor.js */ "./node_modules/core-js/modules/es.regexp.constructor.js");
33__webpack_require__(/*! core-js/modules/es.regexp.exec.js */ "./node_modules/core-js/modules/es.regexp.exec.js");
34__webpack_require__(/*! core-js/modules/es.regexp.to-string.js */ "./node_modules/core-js/modules/es.regexp.to-string.js");
35__webpack_require__(/*! core-js/modules/es.string.iterator.js */ "./node_modules/core-js/modules/es.string.iterator.js");
36__webpack_require__(/*! core-js/modules/es.string.match.js */ "./node_modules/core-js/modules/es.string.match.js");
37__webpack_require__(/*! core-js/modules/es.string.replace.js */ "./node_modules/core-js/modules/es.string.replace.js");
38__webpack_require__(/*! core-js/modules/web.dom-collections.iterator.js */ "./node_modules/core-js/modules/web.dom-collections.iterator.js");
39__webpack_require__(/*! core-js/modules/web.timers.js */ "./node_modules/core-js/modules/web.timers.js");
40/**
41 * Owl Carousel v2.3.4
42 * Copyright 2013-2018 David Deutsch
43 * Licensed under: SEE LICENSE IN https://github.com/OwlCarousel2/OwlCarousel2/blob/master/LICENSE
44 */
45!function (a, b, c, d) {
46  function e(b, c) {
47    this.settings = null, this.options = a.extend({}, e.Defaults, c), this.$element = a(b), this._handlers = {}, this._plugins = {}, this._supress = {}, this._current = null, this._speed = null, this._coordinates = [], this._breakpoint = null, this._width = null, this._items = [], this._clones = [], this._mergers = [], this._widths = [], this._invalidated = {}, this._pipe = [], this._drag = {
48      time: null,
49      target: null,
50      pointer: null,
51      stage: {
52        start: null,
53        current: null
54      },
55      direction: null
56    }, this._states = {
57      current: {},
58      tags: {
59        initializing: ["busy"],
60        animating: ["busy"],
61        dragging: ["interacting"]
62      }
63    }, a.each(["onResize", "onThrottledResize"], a.proxy(function (b, c) {
64      this._handlers[c] = a.proxy(this[c], this);
65    }, this)), a.each(e.Plugins, a.proxy(function (a, b) {
66      this._plugins[a.charAt(0).toLowerCase() + a.slice(1)] = new b(this);
67    }, this)), a.each(e.Workers, a.proxy(function (b, c) {
68      this._pipe.push({
69        filter: c.filter,
70        run: a.proxy(c.run, this)
71      });
72    }, this)), this.setup(), this.initialize();
73  }
74  e.Defaults = {
75    items: 3,
76    loop: !1,
77    center: !1,
78    rewind: !1,
79    checkVisibility: !0,
80    mouseDrag: !0,
81    touchDrag: !0,
82    pullDrag: !0,
83    freeDrag: !1,
84    margin: 0,
85    stagePadding: 0,
86    merge: !1,
87    mergeFit: !0,
88    autoWidth: !1,
89    startPosition: 0,
90    rtl: !1,
91    smartSpeed: 250,
92    fluidSpeed: !1,
93    dragEndSpeed: !1,
94    responsive: {},
95    responsiveRefreshRate: 200,
96    responsiveBaseElement: b,
97    fallbackEasing: "swing",
98    slideTransition: "",
99    info: !1,
100    nestedItemSelector: !1,
101    itemElement: "div",
102    stageElement: "div",
103    refreshClass: "owl-refresh",
104    loadedClass: "owl-loaded",
105    loadingClass: "owl-loading",
106    rtlClass: "owl-rtl",
107    responsiveClass: "owl-responsive",
108    dragClass: "owl-drag",
109    itemClass: "owl-item",
110    stageClass: "owl-stage",
111    stageOuterClass: "owl-stage-outer",
112    grabClass: "owl-grab"
113  }, e.Width = {
114    Default: "default",
115    Inner: "inner",
116    Outer: "outer"
117  }, e.Type = {
118    Event: "event",
119    State: "state"
120  }, e.Plugins = {}, e.Workers = [{
121    filter: ["width", "settings"],
122    run: function run() {
123      this._width = this.$element.width();
124    }
125  }, {
126    filter: ["width", "items", "settings"],
127    run: function run(a) {
128      a.current = this._items && this._items[this.relative(this._current)];
129    }
130  }, {
131    filter: ["items", "settings"],
132    run: function run() {
133      this.$stage.children(".cloned").remove();
134    }
135  }, {
136    filter: ["width", "items", "settings"],
137    run: function run(a) {
138      var b = this.settings.margin || "",
139        c = !this.settings.autoWidth,
140        d = this.settings.rtl,
141        e = {
142          width: "auto",
143          "margin-left": d ? b : "",
144          "margin-right": d ? "" : b
145        };
146      !c && this.$stage.children().css(e), a.css = e;
147    }
148  }, {
149    filter: ["width", "items", "settings"],
150    run: function run(a) {
151      var b = (this.width() / this.settings.items).toFixed(3) - this.settings.margin,
152        c = null,
153        d = this._items.length,
154        e = !this.settings.autoWidth,
155        f = [];
156      for (a.items = {
157        merge: !1,
158        width: b
159      }; d--;) c = this._mergers[d], c = this.settings.mergeFit && Math.min(c, this.settings.items) || c, a.items.merge = c > 1 || a.items.merge, f[d] = e ? b * c : this._items[d].width();
160      this._widths = f;
161    }
162  }, {
163    filter: ["items", "settings"],
164    run: function run() {
165      var b = [],
166        c = this._items,
167        d = this.settings,
168        e = Math.max(2 * d.items, 4),
169        f = 2 * Math.ceil(c.length / 2),
170        g = d.loop && c.length ? d.rewind ? e : Math.max(e, f) : 0,
171        h = "",
172        i = "";
173      for (g /= 2; g > 0;) b.push(this.normalize(b.length / 2, !0)), h += c[b[b.length - 1]][0].outerHTML, b.push(this.normalize(c.length - 1 - (b.length - 1) / 2, !0)), i = c[b[b.length - 1]][0].outerHTML + i, g -= 1;
174      this._clones = b, a(h).addClass("cloned").appendTo(this.$stage), a(i).addClass("cloned").prependTo(this.$stage);
175    }
176  }, {
177    filter: ["width", "items", "settings"],
178    run: function run() {
179      for (var a = this.settings.rtl ? 1 : -1, b = this._clones.length + this._items.length, c = -1, d = 0, e = 0, f = []; ++c < b;) d = f[c - 1] || 0, e = this._widths[this.relative(c)] + this.settings.margin, f.pu

308      y: d[16 === d.length ? 13 : 5]
309    }) : (d = this.$stage.position(), d = {
310      x: this.settings.rtl ? d.left + this.$stage.width() - this.width() + this.settings.margin : d.left,
311      y: d.top
312    }), this.is("animating") && (a.support.transform ? this.animate(d.x) : this.$stage.stop(), this.invalidate("position")), this.$element.toggleClass(this.options.grabClass, "mousedown" === b.type), this.speed(0), this._drag.time = new Date().getTime(), this._drag.target = a(b.target), this._drag.stage.start = d, this._drag.stage.current = d, this._drag.pointer = this.pointer(b), a(c).on("mouseup.owl.core touchend.owl.core", a.proxy(this.onDragEnd, this)), a(c).one("mousemove.owl.core touchmove.owl.core", a.proxy(function (b) {
313      var d = this.difference(this._drag.pointer, this.pointer(b));
314      a(c).on("mousemove.owl.core touchmove.owl.core", a.proxy(this.onDragMove, this)), Math.abs(d.x) < Math.abs(d.y) && this.is("valid") || (b.preventDefault(), this.enter("dragging"), this.trigger("drag"));
315    }, this)));
316  }, e.prototype.onDragMove = function (a) {
317    var b = null,
318      c = null,
319      d = null,
320      e = this.difference(this._drag.pointer, this.pointer(a)),
321      f = this.difference(this._drag.stage.start, e);
322    this.is("dragging") && (a.preventDefault(), this.settings.loop ? (b = this.coordinates(this.minimum()), c = this.coordinates(this.maximum() + 1) - b, f.x = ((f.x - b) % c + c) % c + b) : (b = this.settings.rtl ? this.coordinates(this.maximum()) : this.coordinates(this.minimum()), c = this.settings.rtl ? this.coordinates(this.minimum()) : this.coordinates(this.maximum()), d = this.settings.pullDrag ? -1 * e.x / 5 : 0, f.x = Math.max(Math.min(f.x, b + d), c + d)), this._drag.stage.current = f, this.animate(f.x));
323  }, e.prototype.onDragEnd = function (b) {
324    var d = this.difference(this._drag.pointer, this.pointer(b)),
325      e = this._drag.stage.current,
326      f = d.x > 0 ^ this.settings.rtl ? "left" : "right";
327    a(c).off(".owl.core"), this.$element.removeClass(this.options.grabClass), (0 !== d.x && this.is("dragging") || !this.is("valid")) && (this.speed(this.settings.dragEndSpeed || this.settings.smartSpeed), this.current(this.closest(e.x, 0 !== d.x ? f : this._drag.direction)), this.invalidate("position"), this.update(), this._drag.direction = f, (Math.abs(d.x) > 3 || new Date().getTime() - this._drag.time > 300) && this._drag.target.one("click.owl.core", function () {
328      return !1;
329    })), this.is("dragging") && (this.leave("dragging"), this.trigger("dragged"));
330  }, e.prototype.closest = function (b, c) {
331    var e = -1,
332      f = 30,
333      g = this.width(),
334      h = this.coordinates();
335    return this.settings.freeDrag || a.each(h, a.proxy(function (a, i) {
336      return "left" === c && b > i - f && b < i + f ? e = a : "right" === c && b > i - g - f && b < i - g + f ? e = a + 1 : this.op(b, "<", i) && this.op(b, ">", h[a + 1] !== d ? h[a + 1] : i - g) && (e = "left" === c ? a + 1 : a), -1 === e;
337    }, this)), this.settings.loop || (this.op(b, ">", h[this.minimum()]) ? e = b = this.minimum() : this.op(b, "<", h[this.maximum()]) && (e = b = this.maximum())), e;
338  }, e.prototype.animate = function (b) {
339    var c = this.speed() > 0;
340    this.is("animating") && this.onTransitionEnd(), c && (this.enter("animating"), this.trigger("translate")), a.support.transform3d && a.support.transition ? this.$stage.css({
341      transform: "translate3d(" + b + "px,0px,0px)",
342      transition: this.speed() / 1e3 + "s" + (this.settings.slideTransition ? " " + this.settings.slideTransition : "")
343    }) : c ? this.$stage.animate({
344      left: b + "px"
345    }, this.speed(), this.settings.fallbackEasing, a.proxy(this.onTransitionEnd, this)) : this.$stage.css({
346      left: b + "px"
347    });
348  }, e.prototype.is = function (a) {
349    return this._states.current[a] && this._states.current[a] > 0;
350  }, e.prototype.current = function (a) {
351    if (a === d) return this._current;
352    if (0 === this._items.length) return d;
353    if (a = this.normalize(a), this._current !== a) {
354      var b = this.trigger("change", {
355        property: {
356          name: "position",
357          value: a
358        }
359      });
360      b.data !== d && (a = this.normalize(b.data)), this._current = a, this.invalidate("position"), this.trigger("changed", {
361        property: {
362          name: "position",
363          value: this._current
364        }
365      });
366    }
367    return this._current;
368  }, e.prototype.invalidate = function (b) {
369    return "string" === a.type(b) && (this._invalidated[b] = !0, this.is("valid") && this.leave("valid")), a.map(this._invalidated, function (a, b) {
370      return b;
371    });
372  }, e.prototype.reset = function (a) {
373    (a = this.normalize(a)) !== d && (this._speed = 0, this._current = a, this.suppress(["translate", "translated"]), this.animate(this.coordinates(a)), this.release(["translate", "translated"]));
374  }, e.prototype.normalize = function (a, b) {
375    var c = this._items.length,
376      e = b ? 0 : this._clones.length;
377    return !this.isNumeric(a) || c < 1 ? a = d : (a < 0 || a >= c + e) && (a = ((a - e / 2) % c + c) % c + e / 2), a;
378  }, e.prototype.relative = function (a) {
379    return a -= this._clones.length / 2, this.normalize(a, !0);
380  }, e.prototype.maximum = function (a) {
381    var b,
382      c,
383      d,
384      e = this.settings,
385      f = this._coordinates.length;
386    if (e.loop) f = this._clones.length / 2 + this._items.length - 1;else if (e.autoWidth || e.merge) {
387      if (b = this._items.length) for (c = this._items[--b].width(), d = this.$element.width(); b-- && !((c += this._items[b].width() + this.settings.margin) > d););
388      f = b + 1;
389    } else f = e.center ? this._items.length - 1 : this._items.length - e.items;
390    return a && (f -= this._clones.length / 2), Math.max(f, 0);
391  }, e.prototype.minimum = function (a) {
392    return a ? 0 : this._clones.length / 2;
393  }, e.prototype.items = function (a) {
394    return a === d ? this._items.slice() : (a = this.normalize(a, !0), this._items[a]);
395  }, e.prototype.mergers = function (a) {
396    return a === d ? this._mergers.slice() : (a = this.normalize(a, !0), this._mergers[a]);
397  }, e.prototype.clones = function (b) {
398    var c = this._clones.length / 2,
399      e = c + this._items.length,
400      f = function f(a) {
401        return a % 2 == 0 ? e + a / 2 : c - (a + 1) / 2;
402      };
403    return b === d ? a.map(this._clones, function (a, b) {
404      return f(b);
405    }) : a.map(this._clones, function (a, c) {
406      return a === b ? f(c) : null;
407    });
408  }, e.prototype.speed = function (a) {
409    return a !== d && (this._speed = a), this._speed;
410  }, e.prototype.coordinates = function (b) {
411    var c,
412      e = 1,
413      f = b - 1;
414    return b === d ? a.map(this._coordinates, a.proxy(function (a, b) {
415      return this.coordinates(b);
416    }, this)) : (this.settings.center ? (this.settings.rtl && (e = -1, f = b + 1), c = this._coordinates[b], c += (this.width() - c + (this._coordinates[f] || 0)) / 2 * e) : c = this._coordinates[f] || 0, c = Math.ceil(c));
417  }, e.prototype.duration = function (a, b, c) {
418    return 0 === c ? 0 : Math.min(Math.max(Math.abs(b - a), 1), 6) * Math.abs(c || this.settings.smartSpeed);
419  }, e.prototype.to = function (a, b) {
420    var c = this.current(),
421      d = null,
422      e = a - this.relative(c),
423      f = (e > 0) - (e < 0),
424      g = this._items.length,
425      h = this.minimum(),
426      i = this.maximum();
427    this.settings.loop ? (!this.settings.rewind && Math.abs(e) > g / 2 && (e += -1 * f * g), a = c + e, (d = ((a - h) % g + g) % g + h) !== a && d - e <= i && d - e > 0 && (c = d - e, a = d, this.reset(c))) : this.settings.rewind ? (i += 1, a = (a % i + i) % i) : a = Math.max(h, Math.min(i, a)), this.speed(this.duration(c, a, b)), this.current(a), this.isVisible() && this.update();
428  }, e.prototype.next = function (a) {
429    a = a || !1, this.to(this.relative(this.current()) + 1, a);
430  }, e.prototype.prev = function (a) {
431    a = a || !1, this.to(this.relative(this.current()) - 1, a);
432  }, e.prototype.onTransitionEnd = function (a) {
433    if (a !== d && (a.stopPropagation(), (a.target || a.srcElement || a.originalTarget) !== this.$stage.get(0))) return !1;
434    this.leave("animating"), this.trigger("translated");
435  }, e.prototype.viewport = function () {
436    var d;
437    return this.options.responsiveBaseElement !== b ? d = a(this.options.responsiveBaseElement).width() : b.innerWidth ? d = b.innerWidth : c.documentElement && c.documentElement.clientWidth ? d = c.documentElement.clientWidth : console.warn("Can not detect viewport width."), d;
438  }, e.prototype.replace = function (b) {
439    this.$stage.empty(), this._items = [], b && (b = b instanceof jQuery ? b : a(b)), this.settings.nestedItemSelector && (b = b.find("." + this.settings.nestedItemSelector)), b.filter(function () {
440      return 1 === this.nodeType;
441    }).each(a.proxy(function (a, b) {
442      b = this.prepare(b), this.$stage.append(b), this._items.push(b), this._mergers.push(1 * b.find("[data-merge]").addBack("[data-merge]").attr("data-merge") || 1);
443    }, this)), this.reset(this.isNumeric(this.settings.startPosition) ? this.settings.startPosition : 0), this.invalidate("items");
444  }, e.prototype.add = function (b, c) {
445    var e = this.relative(this._current);
446    c = c === d ? this._items.length : this.normalize(c, !0), b = b instanceof jQuery ? b : a(b), this.trigger("add", {
447      content: b,
448      position: c
449    }), b = this.prepare(b), 0 === this._items.length || c === this._items.length ? (0 === this._items.length && this.$stage.append(b), 0 !== this._items.length && this._items[c - 1].after(b), this._items.push(b), this._mergers.push(1 * b.find("[data-merge]").addBack("[data-merge]").attr("data-merge") || 1)) : (this._items[c].before(b), this._items.splice(c, 0, b), this._mergers.splice(c, 0, 1 * b.find("[data-merge]").addBack("[data-merge]").attr("data-merge") || 1)), this._items[e] && this.reset(this._items[e].index()), this.invalidate("items"), this.trigger("added", {
450      content: b,
451      position: c
452    });
453  }, e.prototype.remove = function (a) {
454    (a = this.normalize(a, !0)) !== d && (this.trigger("remove", {
455      content: this._items[a],
456      position: a
457    }), this._items[a].remove(), this._items.splice(a, 1), this._mergers.splice(a, 1), this.invalidate("items"), this.trigger("removed", {
458      content: null,
459      position: a
460    }));
461  }, e.prototype.preloadAutoWidthImages = function (b) {
462    b.each(a.proxy(function (b, c) {
463      this.enter("pre-loading"), c = a(c), a(new Image()).one("load", a.proxy(function (a) {
464        c.attr("src", a.target.src), c.css("opacity", 1), this.leave("pre-loading"), !this.is("pre-loading") && !this.is("initializing") && this.refresh();
465      }, this)).attr("src", c.attr("src") || c.attr("data-src") || c.attr("data-src-retina"));
466    }, this));
467  }, e.prototype.destroy = function () {
468    this.$element.off(".owl.core"), this.$stage.off(".owl.core"), a(c).off(".owl.core"), !1 !== this.settings.responsive && (b.clearTimeout(this.resizeTimer), this.off(b, "resize", this._handlers.onThrottledResize));
469    for (var d in this._plugins) this._plugins[d].destroy();
470    this.$stage.children(".cloned").remove(), this.$stage.unwrap(), this.$stage.children().contents().unwrap(), this.$stage.children().unwrap(), this.$stage.remove(), this.$element.removeClass(this.options.refreshClass).removeClass(this.options.loadingClass).removeClass(this.options.loadedClass).removeClass(this.options.rtlClass).removeClass(this.options.dragClass).removeClass(this.options.grabClass).attr("class", this.$element.attr("class").replace(new RegExp(this.options.responsiveClass + "-\\S+\\s", "g"), "")).removeData("owl.carousel");
471  }, e.prototype.op = function (a, b, c) {
472    var d = this.settings.rtl;
473    switch (b) {
474      case "<":
475        return d ? a > c : a < c;
476      case ">":
477        return d ? a < c : a > c;
478      case ">=":
479        return d ? a <= c : a >= c;
480      case "<=":
481        return d ? a >= c : a <= c;
482    }
483  }, e.prototype.on = function (a, b, c, d) {
484    a.addEventListener ? a.addEventListener(b, c, d) : a.attachEvent && a.attachEvent("on" + b, c);
485  }, e.prototype.off = function (a, b, c, d) {
486    a.removeEventListener ? a.removeEventListener(b, c, d) : a.detachEvent && a.detachEvent("on" + b, c);
487  }, e.prototype.trigger = function (b, c, d, f, g) {
488    var h = {
489        item: {
490          count: this._items.length,
491          index: this.current()
492        }
493      },
494      i = a.camelCase(a.grep(["on", b, d], function (a) {
495        return a;
496      }).join("-").toLowerCase()),
497      j = a.Event([b, "owl", d || "carousel"].join(".").toLowerCase(), a.extend({
498        relatedTarget: this
499      }, h, c));
500    return this._supress[b] || (a.each(this._plugins, function (a, b) {
501      b.onTrigger && b.onTrigger(j);
502    }), this.register({
503      type: e.Type.Event,
504      name: b
505    }), this.$element.trigger(j), this.settings && "function" == typeof this.settings[i] && this.settings[i].call(this, j)), j;
506  }, e.prototype.enter = function (b) {
507    a.each([b].concat(this._states.tags[b] || []), a.proxy(function (a, b) {
508      this._states.current[b] === d && (this._states.current[b] = 0), this._states.current[b]++;
509    }, this));
510  }, e.prototype.leave = function (b) {
511    a.each([b].concat(this._states.tags[b] || []), a.proxy(function (a, b) {
512      this._states.current[b]--;
513    }, this));
514  }, e.prototype.register = function (b) {
515    if (b.type === e.Type.Event) {
516      if (a.event.special[b.name] || (a.event.special[b.name] = {}), !a.event.special[b.name].owl) {
517        var c = a.event.special[b.name]._default;
518        a.event.special[b.name]._default = function (a) {
519          return !c || !c.apply || a.namespace && -1 !== a.namespace.indexOf("owl") ? a.namespace && a.namespace.indexOf("owl") > -1 : c.apply(this, arguments);
520        }, a.event.special[b.name].owl = !0;
521      }
522    } else b.type === e.Type.State && (this._states.tags[b.name] ? this._states.tags[b.name] = this._states.tags[b.name].

862- this.read()), this._core.is("interacting") || c.hidden || this._core.next(d || this._core.settings.autoplaySpeed);
863  }, e.prototype.read = function () {
864    return new Date().getTime() - this._time;
865  }, e.prototype.play = function (c, d) {
866    var e;
867    this._core.is("rotating") || this._core.enter("rotating"), c = c || this._core.settings.autoplayTimeout, e = Math.min(this._time % (this._timeout || c), c), this._paused ? (this._time = this.read(), this._paused = !1) : b.clearTimeout(this._call), this._time += this.read() % c - e, this._timeout = c, this._call = b.setTimeout(a.proxy(this._next, this, d), c - e);
868  }, e.prototype.stop = function () {
869    this._core.is("rotating") && (this._time = 0, this._paused = !0, b.clearTimeout(this._call), this._core.leave("rotating"));
870  }, e.prototype.pause = function () {
871    this._core.is("rotating") && !this._paused && (this._time = this.read(), this._paused = !0, b.clearTimeout(this._call));
872  }, e.prototype.destroy = function () {
873    var a, b;
874    this.stop();
875    for (a in this._handlers) this._core.$element.off(a, this._handlers[a]);
876    for (b in Object.getOwnPropertyNames(this)) "function" != typeof this[b] && (this[b] = null);
877  }, a.fn.owlCarousel.Constructor.Plugins.autoplay = e;
878}(window.Zepto || __webpack_provided_window_dot_jQuery, window, document), function (a, b, c, d) {
879  "use strict";
880
881  var e = function e(b) {
882    this._core = b, this._initialized = !1, this._pages = [], this._controls = {}, this._templates = [], this.$element = this._core.$element, this._overrides = {
883      next: this._core.next,
884      prev: this._core.prev,
885      to: this._core.to
886    }, this._handlers = {
887      "prepared.owl.carousel": a.proxy(function (b) {
888        b.namespace && this._core.settings.dotsData && this._templates.push('<div class="' + this._core.settings.dotClass + '">' + a(b.content).find("[data-dot]").addBack("[data-dot]").attr("data-dot") + "</div>");
889      }, this),
890      "added.owl.carousel": a.proxy(function (a) {
891        a.namespace && this._core.settings.dotsData && this._templates.splice(a.position, 0, this._templates.pop());
892      }, this),
893      "remove.owl.carousel": a.proxy(function (a) {
894        a.namespace && this._core.settings.dotsData && this._templates.splice(a.position, 1);
895      }, this),
896      "changed.owl.carousel": a.proxy(function (a) {
897        a.namespace && "position" == a.property.name && this.draw();
898      }, this),
899      "initialized.owl.carousel": a.proxy(function (a) {
900        a.namespace && !this._initialized && (this._core.trigger("initialize", null, "navigation"), this.initialize(), this.update(), this.draw(), this._initialized = !0, this._core.trigger("initialized", null, "navigation"));
901      }, this),
902      "refreshed.owl.carousel": a.proxy(function (a) {
903        a.namespace && this._initialized && (this._core.trigger("refresh", null, "navigation"), this.update(), this.draw(), this._core.trigger("refreshed", null, "navigation"));
904      }, this)
905    }, this._core.options = a.extend({}, e.Defaults, this._core.options), this.$element.on(this._handlers);
906  };
907  e.Defaults = {
908    nav: !1,
909    navText: ['<span aria-label="Previous">&#x2039;</span>', '<span aria-label="Next">&#x203a;</span>'],
910    navSpeed: !1,
911    navElement: 'button type="button" role="presentation"',
912    navContainer: !1,
913    navContainerClass: "owl-nav",
914    navClass: ["owl-prev", "owl-next"],
915    slideBy: 1,
916    dotClass: "owl-dot",
917    dotsClass: "owl-dots",
918    dots: !0,
919    dotsEach: !1,
920    dotsData: !1,
921    dotsSpeed: !1,
922    dotsContainer: !1
923  }, e.prototype.initialize = function () {
924    var b,
925      c = this._core.settings;
926    this._controls.$relative = (c.navContainer ? a(c.navContainer) : a("<div>").addClass(c.navContainerClass).appendTo(this.$element)).addClass("disabled"), this._controls.$previous = a("<" + c.navElement + ">").addClass(c.navClass[0]).html(c.navText[0]).prependTo(this._controls.$relative).on("click", a.proxy(function (a) {
927      this.prev(c.navSpeed);
928    }, this)), this._controls.$next = a("<" + c.navElement + ">").addClass(c.navClass[1]).html(c.navText[1]).appendTo(this._controls.$relative).on("click", a.proxy(function (a) {
929      this.next(c.navSpeed);
930    }, this)), c.dotsData || (this._templates = [a('<button role="button">').addClass(c.dotClass).append(a("<span>")).prop("outerHTML")]), this._controls.$absolute = (c.dotsContainer ? a(c.dotsContainer) : a("<div>").addClass(c.dotsClass).appendTo(this.$element)).addClass("disabled"), this._controls.$absolute.on("click", "button", a.proxy(function (b) {
931      var d = a(b.target).parent().is(this._controls.$absolute) ? a(b.target).index() : a(b.target).parent().index();
932      b.preventDefault(), this.to(d, c.dotsSpeed);
933    }, this));
934    for (b in this._overrides) this._core[b] = a.proxy(this[b], this);
935  }, e.prototype.destroy = function () {
936    var a, b, c, d, e;
937    e = this._core.settings;
938    for (a in this._handlers) this.$element.off(a, this._handlers[a]);
939    for (b in this._controls) "$relative" === b && e.navContainer ? this._controls[b].html("") : this._controls[b].remove();
940    for (d in this.overides) this._core[d] = this._overrides[d];
941    for (c in Object.getOwnPropertyNames(this)) "function" != typeof this[c] && (this[c] = null);
942  }, e.prototype.update = function () {
943    var a,
944      b,
945      c,
946      d = this._core.clones().length / 2,
947      e = d + this._core.items().length,
948      f = this._core.maximum(!0),
949      g = this._core.settings,
950      h = g.center || g.autoWidth || g.dotsData ? 1 : g.dotsEach || g.items;
951    if ("page" !== g.slideBy && (g.slideBy = Math.min(g.slideBy, g.items)), g.dots || "page" == g.slideBy) for (this._pages = [], a = d, b = 0, c = 0; a < e; a++) {
952      if (b >= h || 0 === b) {
953        if (this._pages.push({
954          start: Math.min(f, a - d),
955          end: a - d + h - 1
956        }), Math.min(f, a - d) === f) break;
957        b = 0, ++c;
958      }
959      b += this._core.mergers(this._core.relative(a));
960    }
961  }, e.prototype.draw = function () {
962    var b,
963      c = this._core.settings,
964      d = this._core.items().length <= c.items,
965      e = this._core.relative(this._core.current()),
966      f = c.loop || c.rewind;
967    this._controls.$relative.toggleClass("disabled", !c.nav || d), c.nav && (this._controls.$previous.toggleClass("disabled", !f && e <= this._core.minimum(!0)), this._controls.$next.toggleClass("disabled", !f && e >= this._core.maximum(!0))), this._controls.$absolute.toggleClass("disabled", !c.dots || d), c.dots && (b = this._pages.length - this._controls.$absolute.children().length, c.dotsData && 0 !== b ? this._controls.$absolute.html(this._templates.join("")) : b > 0 ? this._controls.$absolute.append(new Array(b + 1).join(this._templates[0])) : b < 0 && this._controls.$absolute.children().slice(b).remove(), this._controls.$absolute.find(".active").removeClass("active"), this._controls.$absolute.children().eq(a.inArray(this.current(), this._pages)).addClass("active"));
968  }, e.prototype.onTrigger = function (b) {
969    var c = this._core.settings;
970    b.page = {
971      index: a.inArray(this.current(), this._pages),
972      count: this._pages.length,
973      size: c && (c.center || c.autoWidth || c.dotsData ? 1 : c.dotsEach || c.items)
974    };
975  }, e.prototype.current = function () {
976    var b = this._core.relative(this._core.current());
977    return a.grep(this._pages, a.proxy(function (a, c) {
978      return a.start <= b && a.end >= b;
979    }, this)).pop();
980  }, e.prototype.getPosition = function (b) {
981    var c,
982      d,
983      e = this._core.settings;
984    return "page" == e.slideBy ? (c = a.inArray(this.current(), this._pages), d = this._pages.length, b ? ++c : --c, c = this._pages[(c % d + d) % d].start) : (c = this._core.relative(this._core.current()), d = this._core.items().length, b ? c += e.

1202/***/ "./assets/sitevitrine/js/lib/slider.js":
1203/*!*********************************************!*\
1204  !*** ./assets/sitevitrine/js/lib/slider.js ***!
1205  \*********************************************/
1206/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
1207
1208/* provided dependency */ var jQuery = __webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js");
1209/* provided dependency */ var __webpack_provided_window_dot_jQuery = __webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js");
1210function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
1211__webpack_require__(/*! core-js/modules/es.symbol.js */ "./node_modules/core-js/modules/es.symbol.js");
1212__webpack_require__(/*! core-js/modules/es.symbol.description.js */ "./node_modules/core-js/modules/es.symbol.description.js");
1213__webpack_require__(/*! core-js/modules/es.symbol.iterator.js */ "./node_modules/core-js/modules/es.symbol.iterator.js");
1214__webpack_require__(/*! core-js/modules/es.array.concat.js */ "./node_modules/core-js/modules/es.array.concat.js");
1215__webpack_require__(/*! core-js/modules/es.array.filter.js */ "./node_modules/core-js/modules/es.array.filter.js");
1216__webpack_require__(/*! core-js/modules/es.array.find.js */ "./node_modules/core-js/modules/es.array.find.js");
1217__webpack_require__(/*! core-js/modules/es.array.index-of.js */ "./node_modules/core-js/modules/es.array.index-of.js");
1218__webpack_require__(/*! core-js/modules/es.array.iterator.js */ "./node_modules/core-js/modules/es.array.iterator.js");
1219__webpack_require__(/*! core-js/modules/es.array.join.js */ "./node_modules/core-js/modules/es.array.join.js");
1220__webpack_require__(/*! core-js/modules/es.array.map.js */ "./node_modules/core-js/modules/es.array.map.js");
1221__webpack_require__(/*! core-js/modules/es.array.slice.js */ "./node_modules/core-js/modules/es.array.slice.js");
1222__webpack_require__(/*! core-js/modules/es.array.splice.js */ "./node_modules/core-js/modules/es.array.splice.js");
1223__webpack_require__(/*! core-js/modules/es.date.to-string.js */ "./node_modules/core-js/modules/es.date.to-string.js");
1224__webpack_require__(/*! core-js/modules/es.function.name.js */ "./node_modules/core-js/modules/es.function.name.js");
1225__webpack_require__(/*! core-js/modules/es.number.constructor.js */ "./node_modules/core-js/modules/es.number.constructor.js");
1226__webpack_require__(/*! core-js/modules/es.number.to-fixed.js */ "./node_modules/core-js/modules/es.number.to-fixed.js");
1227__webpack_require__(/*! core-js/modules/es.object.get-own-property-names.js */ "./node_modules/core-js/modules/es.object.get-own-property-names.js");
1228__webpack_require__(/*! core-js/modules/es.object.to-string.js */ "./node_modules/core-js/modules/es.object.to-string.js");
1229__webpack_require__(/*! core-js/modules/es.parse-float.js */ "./node_modules/core-js/modules/es.parse-float.js");
1230__webpack_require__(/*! core-js/modules/es.promise.js */ "./node_modules/core-js/modules/es.promise.js");
1231__webpack_require__(/*! core-js/modules/es.regexp.constructor.js */ "./node_modules/core-js/modules/es.regexp.constructor.js");
1232__webpack_require__(/*! core-js/modules/es.regexp.exec.js */ "./node_modules/core-js/modules/es.regexp.exec.js");
1233__webpack_require__(/*! core-js/modules/es.regexp.to-string.js */ "./node_modules/core-js/modules/es.regexp.to-string.js");
1234__webpack_require__(/*! core-js/modules/es.string.iterator.js */ "./node_modules/core-js/modules/es.string.iterator.js");
1235__webpack_require__(/*! core-js/modules/es.string.match.js */ "./node_modules/core-js/modules/es.string.match.js");
1236__webpack_require__(/*! core-js/modules/es.string.replace.js */ "./node_modules/core-js/modules/es.string.replace.js");
1237__webpack_require__(/*! core-js/modules/web.dom-collections.iterator.js */ "./node_modules/core-js/modules/web.dom-collections.iterator.js");
1238__webpack_require__(/*! core-js/modules/web.timers.js */ "./node_modules/core-js/modules/web.timers.js");
1239/**
1240 * Owl Carousel v2.3.4
1241 * Copyright 2013-2018 David Deutsch
1242 * Licensed under: SEE LICENSE IN https://github.com/OwlCarousel2/OwlCarousel2/blob/master/LICENSE
1243 */
1244!function (a, b, c, d) {
1245  function e(b, c) {
1246    this.settings = null, this.options = a.extend({}, e.Defaults, c), this.$element = a(b), this._handlers = {}, this._plugins = {}, this._supress = {}, this._current = null, this._speed = null, this._coordinates = [], this._breakpoint = null, this._width = null, this._items = [], this._clones = [], this._mergers = [], this._widths = [], this._invalidated = {}, this._pipe = [], this._drag = {
1247      time: null,
1248      target: null,
1249      pointer: null,
1250      stage: {
1251        start: null,
1252        current: null
1253      },
1254      direction: null
1255    }, this._states = {
1256      current: {},
1257      tags: {
1258        initializing: ["busy"],
1259        animating: ["busy"],
1260        dragging: ["interacting"]
1261      }
1262    }, a.each(["onResize", "onThrottledResize"], a.proxy(function (b, c) {
1263      this._handlers[c] = a.proxy(this[c], this);
1264    }, this)), a.each(e.Plugins, a.proxy(function (a, b) {
1265      this._plugins[a.charAt(0).toLowerCase() + a.slice(1)] = new b(this);
1266    }, this)), a.each(e.Workers, a.proxy(function (b, c) {
1267      this._pipe.push({
1268        filter: c.filter,
1269        run: a.proxy(c.run, this)
1270      });
1271    }, this)), this.setup(), this.initialize();
1272  }
1273  e.Defaults = {
1274    items: 3,
1275    loop: !1,
1276    center: !1,
1277    rewind: !1,
1278    checkVisibility: !0,
1279    mouseDrag: !0,
1280    touchDrag: !0,
1281    pullDrag: !0,
1282    freeDrag: !1,
1283    margin: 0,
1284    stagePadding: 0,
1285    merge: !1,
1286    mergeFit: !0,
1287    autoWidth: !1,
1288    startPosition: 0,
1289    rtl: !1,
1290    smartSpeed: 250,
1291    fluidSpeed: !1,
1292    dragEndSpeed: !1,
1293    responsive: {},
1294    responsiveRefreshRate: 200,
1295    responsiveBaseElement: b,
1296    fallbackEasing: "swing",
1297    slideTransition: "",
1298    info: !1,
1299    nestedItemSelector: !1,
1300    itemElement: "div",
1301    stageElement: "div",
1302    refreshClass: "owl-refresh",
1303    loadedClass: "owl-loaded",
1304    loadingClass: "owl-loading",
1305    rtlClass: "owl-rtl",
1306    responsiveClass: "owl-responsive",
1307    dragClass: "owl-drag",
1308    itemClass: "owl-item",
1309    stageClass: "owl-stage",
1310    stageOuterClass: "owl-stage-outer",
1311    grabClass: "owl-grab"
1312  }, e.Width = {
1313    Default: "default",
1314    Inner: "inner",
1315    Outer: "outer"
1316  }, e.Type = {
1317    Event: "event",
1318    State: "state"
1319  }, e.Plugins = {}, e.Workers = [{
1320    filter: ["width", "settings"],
1321    run: function run() {
1322      this._width = this.$element.width();
1323    }
1324  }, {
1325    filter: ["width", "items", "settings"],
1326    run: function run(a) {
1327      a.current = this._items && this._items[this.relative(this._current)];
1328    }
1329  }, {
1330    filter: ["items", "settings"],
1331    run: function run() {
1332      this.$stage.children(".cloned").remove();
1333    }
1334  }, {
1335    filter: ["width", "items", "settings"],
1336    run: function run(a) {
1337      var b = this.settings.margin || "",
1338        c = !this.settings.autoWidth,
1339        d = this.settings.rtl,
1340        e = {
1341          width: "auto",
1342          "margin-left": d ? b : "",
1343          "margin-right": d ? "" : b
1344        };
1345      !c && this.$stage.children().css(e), a.css = e;
1346    }
1347  }, {
1348    filter: ["width", "items", "settings"],
1349    run: function run(a) {
1350      var b = (this.width() / this.settings.items).toFixed(3) - this.settings.margin,
1351        c = null,
1352        d = this._items.length,
1353        e = !this.settings.autoWidth,
1354        f = [];
1355      for (a.items = {
1356        merge: !1,
1357        width: b
1358      }; d--;) c = this._mergers[d], c = this.settings.mergeFit && Math.min(c, this.settings.items) || c, a.items.merge = c > 1 || a.items.merge, f[d] = e ? b * c : this._items[d].width();
1359      this._widths = f;
1360    }
1361  }, {
1362    filter: ["items", "settings"],
1363    run: function run() {
1364      var b = [],
1365        c = this._items,
1366        d = this.settings,
1367        e = Math.max(2 * d.items, 4),
1368        f = 2 * Math.ceil(c.length / 2),
1369        g = d.loop && c.length ? d.rewind ? e : Math.max(e, f) : 0,
1370        h = "",
1371        i = "";
1372      for (g /= 2; g > 0;) b.push(this.normalize(b.length / 2, !0)), h += c[b[b.length - 1]][0].outerHTML, b.push(this.normalize(c.length - 1 - (b.length - 1) / 2, !0)), i = c[b[b.length - 1]][0].outerHTML + i, g -= 1;
1373      this._clones = b, a(h).addClass("cloned").appendTo(this.$stage), a(i).addClass("cloned").prependTo(this.$stage);
1374    }
1375  }, {
1376    filter: ["width", "items", "settings"],
1377    run: function run() {
1378      for (var a = this.settings.rtl ? 1 : -1, b = this._clones.length + this._items.length, c = -1, d = 0, e = 0, f = []; ++c < b;) d = f[c - 1] || 0, e = this._widths[this.relative(c)] + this.settings.margin, f.pu

1507      y: d[16 === d.length ? 13 : 5]
1508    }) : (d = this.$stage.position(), d = {
1509      x: this.settings.rtl ? d.left + this.$stage.width() - this.width() + this.settings.margin : d.left,
1510      y: d.top
1511    }), this.is("animating") && (a.support.transform ? this.animate(d.x) : this.$stage.stop(), this.invalidate("position")), this.$element.toggleClass(this.options.grabClass, "mousedown" === b.type), this.speed(0), this._drag.time = new Date().getTime(), this._drag.target = a(b.target), this._drag.stage.start = d, this._drag.stage.current = d, this._drag.pointer = this.pointer(b), a(c).on("mouseup.owl.core touchend.owl.core", a.proxy(this.onDragEnd, this)), a(c).one("mousemove.owl.core touchmove.owl.core", a.proxy(function (b) {
1512      var d = this.difference(this._drag.pointer, this.pointer(b));
1513      a(c).on("mousemove.owl.core touchmove.owl.core", a.proxy(this.onDragMove, this)), Math.abs(d.x) < Math.abs(d.y) && this.is("valid") || (b.preventDefault(), this.enter("dragging"), this.trigger("drag"));
1514    }, this)));
1515  }, e.prototype.onDragMove = function (a) {
1516    var b = null,
1517      c = null,
1518      d = null,
1519      e = this.difference(this._drag.pointer, this.pointer(a)),
1520      f = this.difference(this._drag.stage.start, e);
1521    this.is("dragging") && (a.preventDefault(), this.settings.loop ? (b = this.coordinates(this.minimum()), c = this.coordinates(this.maximum() + 1) - b, f.x = ((f.x - b) % c + c) % c + b) : (b = this.settings.rtl ? this.coordinates(this.maximum()) : this.coordinates(this.minimum()), c = this.settings.rtl ? this.coordinates(this.minimum()) : this.coordinates(this.maximum()), d = this.settings.pullDrag ? -1 * e.x / 5 : 0, f.x = Math.max(Math.min(f.x, b + d), c + d)), this._drag.stage.current = f, this.animate(f.x));
1522  }, e.prototype.onDragEnd = function (b) {
1523    var d = this.difference(this._drag.pointer, this.pointer(b)),
1524      e = this._drag.stage.current,
1525      f = d.x > 0 ^ this.settings.rtl ? "left" : "right";
1526    a(c).off(".owl.core"), this.$element.removeClass(this.options.grabClass), (0 !== d.x && this.is("dragging") || !this.is("valid")) && (this.speed(this.settings.dragEndSpeed || this.settings.smartSpeed), this.current(this.closest(e.x, 0 !== d.x ? f : this._drag.direction)), this.invalidate("position"), this.update(), this._drag.direction = f, (Math.abs(d.x) > 3 || new Date().getTime() - this._drag.time > 300) && this._drag.target.one("click.owl.core", function () {
1527      return !1;
1528    })), this.is("dragging") && (this.leave("dragging"), this.trigger("dragged"));
1529  }, e.prototype.closest = function (b, c) {
1530    var e = -1,
1531      f = 30,
1532      g = this.width(),
1533      h = this.coordinates();
1534    return this.settings.freeDrag || a.each(h, a.proxy(function (a, i) {
1535      return "left" === c && b > i - f && b < i + f ? e = a : "right" === c && b > i - g - f && b < i - g + f ? e = a + 1 : this.op(b, "<", i) && this.op(b, ">", h[a + 1] !== d ? h[a + 1] : i - g) && (e = "left" === c ? a + 1 : a), -1 === e;
1536    }, this)), this.settings.loop || (this.op(b, ">", h[this.minimum()]) ? e = b = this.minimum() : this.op(b, "<", h[this.maximum()]) && (e = b = this.maximum())), e;
1537  }, e.prototype.animate = function (b) {
1538    var c = this.speed() > 0;
1539    this.is("animating") && this.onTransitionEnd(), c && (this.enter("animating"), this.trigger("translate")), a.support.transform3d && a.support.transition ? this.$stage.css({
1540      transform: "translate3d(" + b + "px,0px,0px)",
1541      transition: this.speed() / 1e3 + "s" + (this.settings.slideTransition ? " " + this.settings.slideTransition : "")
1542    }) : c ? this.$stage.animate({
1543      left: b + "px"
1544    }, this.speed(), this.settings.fallbackEasing, a.proxy(this.onTransitionEnd, this)) : this.$stage.css({
1545      left: b + "px"
1546    });
1547  }, e.prototype.is = function (a) {
1548    return this._states.current[a] && this._states.current[a] > 0;
1549  }, e.prototype.current = function (a) {
1550    if (a === d) return this._current;
1551    if (0 === this._items.length) return d;
1552    if (a = this.normalize(a), this._current !== a) {
1553      var b = this.trigger("change", {
1554        property: {
1555          name: "position",
1556          value: a
1557        }
1558      });
1559      b.data !== d && (a = this.normalize(b.data)), this._current = a, this.invalidate("position"), this.trigger("changed", {
1560        property: {
1561          name: "position",
1562          value: this._current
1563        }
1564      });
1565    }
1566    return this._current;
1567  }, e.prototype.invalidate = function (b) {
1568    return "string" === a.type(b) && (this._invalidated[b] = !0, this.is("valid") && this.leave("valid")), a.map(this._invalidated, function (a, b) {
1569      return b;
1570    });
1571  }, e.prototype.reset = function (a) {
1572    (a = this.normalize(a)) !== d && (this._speed = 0, this._current = a, this.suppress(["translate", "translated"]), this.animate(this.coordinates(a)), this.release(["translate", "translated"]));
1573  }, e.prototype.normalize = function (a, b) {
1574    var c = this._items.length,
1575      e = b ? 0 : this._clones.length;
1576    return !this.isNumeric(a) || c < 1 ? a = d : (a < 0 || a >= c + e) && (a = ((a - e / 2) % c + c) % c + e / 2), a;
1577  }, e.prototype.relative = function (a) {
1578    return a -= this._clones.length / 2, this.normalize(a, !0);
1579  }, e.prototype.maximum = function (a) {
1580    var b,
1581      c,
1582      d,
1583      e = this.settings,
1584      f = this._coordinates.length;
1585    if (e.loop) f = this._clones.length / 2 + this._items.length - 1;else if (e.autoWidth || e.merge) {
1586      if (b = this._items.length) for (c = this._items[--b].width(), d = this.$element.width(); b-- && !((c += this._items[b].width() + this.settings.margin) > d););
1587      f = b + 1;
1588    } else f = e.center ? this._items.length - 1 : this._items.length - e.items;
1589    return a && (f -= this._clones.length / 2), Math.max(f, 0);
1590  }, e.prototype.minimum = function (a) {
1591    return a ? 0 : this._clones.length / 2;
1592  }, e.prototype.items = function (a) {
1593    return a === d ? this._items.slice() : (a = this.normalize(a, !0), this._items[a]);
1594  }, e.prototype.mergers = function (a) {
1595    return a === d ? this._mergers.slice() : (a = this.normalize(a, !0), this._mergers[a]);
1596  }, e.prototype.clones = function (b) {
1597    var c = this._clones.length / 2,
1598      e = c + this._items.length,
1599      f = function f(a) {
1600        return a % 2 == 0 ? e + a / 2 : c - (a + 1) / 2;
1601      };
1602    return b === d ? a.map(this._clones, function (a, b) {
1603      return f(b);
1604    }) : a.map(this._clones, function (a, c) {
1605      return a === b ? f(c) : null;
1606    });
1607  }, e.prototype.speed = function (a) {
1608    return a !== d && (this._speed = a), this._speed;
1609  }, e.prototype.coordinates = function (b) {
1610    var c,
1611      e = 1,
1612      f = b - 1;
1613    return b === d ? a.map(this._coordinates, a.proxy(function (a, b) {
1614      return this.coordinates(b);
1615    }, this)) : (this.settings.center ? (this.settings.rtl && (e = -1, f = b + 1), c = this._coordinates[b], c += (this.width() - c + (this._coordinates[f] || 0)) / 2 * e) : c = this._coordinates[f] || 0, c = Math.ceil(c));
1616  }, e.prototype.duration = function (a, b, c) {
1617    return 0 === c ? 0 : Math.min(Math.max(Math.abs(b - a), 1), 6) * Math.abs(c || this.settings.smartSpeed);
1618  }, e.prototype.to = function (a, b) {
1619    var c = this.current(),
1620      d = null,
1621      e = a - this.relative(c),
1622      f = (e > 0) - (e < 0),
1623      g = this._items.length,
1624      h = this.minimum(),
1625      i = this.maximum();
1626    this.settings.loop ? (!this.settings.rewind && Math.abs(e) > g / 2 && (e += -1 * f * g), a = c + e, (d = ((a - h) % g + g) % g + h) !== a && d - e <= i && d - e > 0 && (c = d - e, a = d, this.reset(c))) : this.settings.rewind ? (i += 1, a = (a % i + i) % i) : a = Math.max(h, Math.min(i, a)), this.speed(this.duration(c, a, b)), this.current(a), this.isVisible() && this.update();
1627  }, e.prototype.next = function (a) {
1628    a = a || !1, this.to(this.relative(this.current()) + 1, a);
1629  }, e.prototype.prev = function (a) {
1630    a = a || !1, this.to(this.relative(this.current()) - 1, a);
1631  }, e.prototype.onTransitionEnd = function (a) {
1632    if (a !== d && (a.stopPropagation(), (a.target || a.srcElement || a.originalTarget) !== this.$stage.get(0))) return !1;
1633    this.leave("animating"), this.trigger("translated");
1634  }, e.prototype.viewport = function () {
1635    var d;
1636    return this.options.responsiveBaseElement !== b ? d = a(this.options.responsiveBaseElement).width() : b.innerWidth ? d = b.innerWidth : c.documentElement && c.documentElement.clientWidth ? d = c.documentElement.clientWidth : console.warn("Can not detect viewport width."), d;
1637  }, e.prototype.replace = function (b) {
1638    this.$stage.empty(), this._items = [], b && (b = b instanceof jQuery ? b : a(b)), this.settings.nestedItemSelector && (b = b.find("." + this.settings.nestedItemSelector)), b.filter(function () {
1639      return 1 === this.nodeType;
1640    }).each(a.proxy(function (a, b) {
1641      b = this.prepare(b), this.$stage.append(b), this._items.push(b), this._mergers.push(1 * b.find("[data-merge]").addBack("[data-merge]").attr("data-merge") || 1);
1642    }, this)), this.reset(this.isNumeric(this.settings.startPosition) ? this.settings.startPosition : 0), this.invalidate("items");
1643  }, e.prototype.add = function (b, c) {
1644    var e = this.relative(this._current);
1645    c = c === d ? this._items.length : this.normalize(c, !0), b = b instanceof jQuery ? b : a(b), this.trigger("add", {
1646      content: b,
1647      position: c
1648    }), b = this.prepare(b), 0 === this._items.length || c === this._items.length ? (0 === this._items.length && this.$stage.append(b), 0 !== this._items.length && this._items[c - 1].after(b), this._items.push(b), this._mergers.push(1 * b.find("[data-merge]").addBack("[data-merge]").attr("data-merge") || 1)) : (this._items[c].before(b), this._items.splice(c, 0, b), this._mergers.splice(c, 0, 1 * b.find("[data-merge]").addBack("[data-merge]").attr("data-merge") || 1)), this._items[e] && this.reset(this._items[e].index()), this.invalidate("items"), this.trigger("added", {
1649      content: b,
1650      position: c
1651    });
1652  }, e.prototype.remove = function (a) {
1653    (a = this.normalize(a, !0)) !== d && (this.trigger("remove", {
1654      content: this._items[a],
1655      position: a
1656    }), this._items[a].remove(), this._items.splice(a, 1), this._mergers.splice(a, 1), this.invalidate("items"), this.trigger("removed", {
1657      content: null,
1658      position: a
1659    }));
1660  }, e.prototype.preloadAutoWidthImages = function (b) {
1661    b.each(a.proxy(function (b, c) {
1662      this.enter("pre-loading"), c = a(c), a(new Image()).one("load", a.proxy(function (a) {
1663        c.attr("src", a.target.src), c.css("opacity", 1), this.leave("pre-loading"), !this.is("pre-loading") && !this.is("initializing") && this.refresh();
1664      }, this)).attr("src", c.attr("src") || c.attr("data-src") || c.attr("data-src-retina"));
1665    }, this));
1666  }, e.prototype.destroy = function () {
1667    this.$element.off(".owl.core"), this.$stage.off(".owl.core"), a(c).off(".owl.core"), !1 !== this.settings.responsive && (b.clearTimeout(this.resizeTimer), this.off(b, "resize", this._handlers.onThrottledResize));
1668    for (var d in this._plugins) this._plugins[d].destroy();
1669    this.$stage.children(".cloned").remove(), this.$stage.unwrap(), this.$stage.children().contents().unwrap(), this.$stage.children().unwrap(), this.$stage.remove(), this.$element.removeClass(this.options.refreshClass).removeClass(this.options.loadingClass).removeClass(this.options.loadedClass).removeClass(this.options.rtlClass).removeClass(this.options.dragClass).removeClass(this.options.grabClass).attr("class", this.$element.attr("class").replace(new RegExp(this.options.responsiveClass + "-\\S+\\s", "g"), "")).removeData("owl.carousel");
1670  }, e.prototype.op = function (a, b, c) {
1671    var d = this.settings.rtl;
1672    switch (b) {
1673      case "<":
1674        return d ? a > c : a < c;
1675      case ">":
1676        return d ? a < c : a > c;
1677      case ">=":
1678        return d ? a <= c : a >= c;
1679      case "<=":
1680        return d ? a >= c : a <= c;
1681    }
1682  }, e.prototype.on = function (a, b, c, d) {
1683    a.addEventListener ? a.addEventListener(b, c, d) : a.attachEvent && a.attachEvent("on" + b, c);
1684  }, e.prototype.off = function (a, b, c, d) {
1685    a.removeEventListener ? a.removeEventListener(b, c, d) : a.detachEvent && a.detachEvent("on" + b, c);
1686  }, e.prototype.trigger = function (b, c, d, f, g) {
1687    var h = {
1688        item: {
1689          count: this._items.length,
1690          index: this.current()
1691        }
1692      },
1693      i = a.camelCase(a.grep(["on", b, d], function (a) {
1694        return a;
1695      }).join("-").toLowerCase()),
1696      j = a.Event([b, "owl", d || "carousel"].join(".").toLowerCase(), a.extend({
1697        relatedTarget: this
1698      }, h, c));
1699    return this._supress[b] || (a.each(this._plugins, function (a, b) {
1700      b.onTrigger && b.onTrigger(j);
1701    }), this.register({
1702      type: e.Type.Event,
1703      name: b
1704    }), this.$element.trigger(j), this.settings && "function" == typeof this.settings[i] && this.settings[i].call(this, j)), j;
1705  }, e.prototype.enter = function (b) {
1706    a.each([b].concat(this._states.tags[b] || []), a.proxy(function (a, b) {
1707      this._states.current[b] === d && (this._states.current[b] = 0), this._states.current[b]++;
1708    }, this));
1709  }, e.prototype.leave = function (b) {
1710    a.each([b].concat(this._states.tags[b] || []), a.proxy(function (a, b) {
1711      this._states.current[b]--;
1712    }, this));
1713  }, e.prototype.register = function (b) {
1714    if (b.type === e.Type.Event) {
1715      if (a.event.special[b.name] || (a.event.special[b.name] = {}), !a.event.special[b.name].owl) {
1716        var c = a.event.special[b.name]._default;
1717        a.event.special[b.name]._default = function (a) {
1718          return !c || !c.apply || a.namespace && -1 !== a.namespace.indexOf("owl") ? a.namespace && a.namespace.indexOf("owl") > -1 : c.apply(this, arguments);
1719        }, a.event.special[b.name].owl = !0;
1720      }
1721    } else b.type === e.Type.State && (this._states.tags[b.name] ? this._states.tags[b.name] = this._states.tags[b.name].

2061- this.read()), this._core.is("interacting") || c.hidden || this._core.next(d || this._core.settings.autoplaySpeed);
2062  }, e.prototype.read = function () {
2063    return new Date().getTime() - this._time;
2064  }, e.prototype.play = function (c, d) {
2065    var e;
2066    this._core.is("rotating") || this._core.enter("rotating"), c = c || this._core.settings.autoplayTimeout, e = Math.min(this._time % (this._timeout || c), c), this._paused ? (this._time = this.read(), this._paused = !1) : b.clearTimeout(this._call), this._time += this.read() % c - e, this._timeout = c, this._call = b.setTimeout(a.proxy(this._next, this, d), c - e);
2067  }, e.prototype.stop = function () {
2068    this._core.is("rotating") && (this._time = 0, this._paused = !0, b.clearTimeout(this._call), this._core.leave("rotating"));
2069  }, e.prototype.pause = function () {
2070    this._core.is("rotating") && !this._paused && (this._time = this.read(), this._paused = !0, b.clearTimeout(this._call));
2071  }, e.prototype.destroy = function () {
2072    var a, b;
2073    this.stop();
2074    for (a in this._handlers) this._core.$element.off(a, this._handlers[a]);
2075    for (b in Object.getOwnPropertyNames(this)) "function" != typeof this[b] && (this[b] = null);
2076  }, a.fn.owlCarousel.Constructor.Plugins.autoplay = e;
2077}(window.Zepto || __webpack_provided_window_dot_jQuery, window, document), function (a, b, c, d) {
2078  "use strict";
2079
2080  var e = function e(b) {
2081    this._core = b, this._initialized = !1, this._pages = [], this._controls = {}, this._templates = [], this.$element = this._core.$element, this._overrides = {
2082      next: this._core.next,
2083      prev: this._core.prev,
2084      to: this._core.to
2085    }, this._handlers = {
2086      "prepared.owl.carousel": a.proxy(function (b) {
2087        b.namespace && this._core.settings.dotsData && this._templates.push('<div class="' + this._core.settings.dotClass + '">' + a(b.content).find("[data-dot]").addBack("[data-dot]").attr("data-dot") + "</div>");
2088      }, this),
2089      "added.owl.carousel": a.proxy(function (a) {
2090        a.namespace && this._core.settings.dotsData && this._templates.splice(a.position, 0, this._templates.pop());
2091      }, this),
2092      "remove.owl.carousel": a.proxy(function (a) {
2093        a.namespace && this._core.settings.dotsData && this._templates.splice(a.position, 1);
2094      }, this),
2095      "changed.owl.carousel": a.proxy(function (a) {
2096        a.namespace && "position" == a.property.name && this.draw();
2097      }, this),
2098      "initialized.owl.carousel": a.proxy(function (a) {
2099        a.namespace && !this._initialized && (this._core.trigger("initialize", null, "navigation"), this.initialize(), this.update(), this.draw(), this._initialized = !0, this._core.trigger("initialized", null, "navigation"));
2100      }, this),
2101      "refreshed.owl.carousel": a.proxy(function (a) {
2102        a.namespace && this._initialized && (this._core.trigger("refresh", null, "navigation"), this.update(), this.draw(), this._core.trigger("refreshed", null, "navigation"));
2103      }, this)
2104    }, this._core.options = a.extend({}, e.Defaults, this._core.options), this.$element.on(this._handlers);
2105  };
2106  e.Defaults = {
2107    nav: !1,
2108    navText: ['<span aria-label="Previous">&#x2039;</span>', '<span aria-label="Next">&#x203a;</span>'],
2109    navSpeed: !1,
2110    navElement: 'button type="button" role="presentation"',
2111    navContainer: !1,
2112    navContainerClass: "owl-nav",
2113    navClass: ["owl-prev", "owl-next"],
2114    slideBy: 1,
2115    dotClass: "owl-dot",
2116    dotsClass: "owl-dots",
2117    dots: !0,
2118    dotsEach: !1,
2119    dotsData: !1,
2120    dotsSpeed: !1,
2121    dotsContainer: !1
2122  }, e.prototype.initialize = function () {
2123    var b,
2124      c = this._core.settings;
2125    this._controls.$relative = (c.navContainer ? a(c.navContainer) : a("<div>").addClass(c.navContainerClass).appendTo(this.$element)).addClass("disabled"), this._controls.$previous = a("<" + c.navElement + ">").addClass(c.navClass[0]).html(c.navText[0]).prependTo(this._controls.$relative).on("click", a.proxy(function (a) {
2126      this.prev(c.navSpeed);
2127    }, this)), this._controls.$next = a("<" + c.navElement + ">").addClass(c.navClass[1]).html(c.navText[1]).appendTo(this._controls.$relative).on("click", a.proxy(function (a) {
2128      this.next(c.navSpeed);
2129    }, this)), c.dotsData || (this._templates = [a('<button role="button">').addClass(c.dotClass).append(a("<span>")).prop("outerHTML")]), this._controls.$absolute = (c.dotsContainer ? a(c.dotsContainer) : a("<div>").addClass(c.dotsClass).appendTo(this.$element)).addClass("disabled"), this._controls.$absolute.on("click", "button", a.proxy(function (b) {
2130      var d = a(b.target).parent().is(this._controls.$absolute) ? a(b.target).index() : a(b.target).parent().index();
2131      b.preventDefault(), this.to(d, c.dotsSpeed);
2132    }, this));
2133    for (b in this._overrides) this._core[b] = a.proxy(this[b], this);
2134  }, e.prototype.destroy = function () {
2135    var a, b, c, d, e;
2136    e = this._core.settings;
2137    for (a in this._handlers) this.$element.off(a, this._handlers[a]);
2138    for (b in this._controls) "$relative" === b && e.navContainer ? this._controls[b].html("") : this._controls[b].remove();
2139    for (d in this.overides) this._core[d] = this._overrides[d];
2140    for (c in Object.getOwnPropertyNames(this)) "function" != typeof this[c] && (this[c] = null);
2141  }, e.prototype.update = function () {
2142    var a,
2143      b,
2144      c,
2145      d = this._core.clones().length / 2,
2146      e = d + this._core.items().length,
2147      f = this._core.maximum(!0),
2148      g = this._core.settings,
2149      h = g.center || g.autoWidth || g.dotsData ? 1 : g.dotsEach || g.items;
2150    if ("page" !== g.slideBy && (g.slideBy = Math.min(g.slideBy, g.items)), g.dots || "page" == g.slideBy) for (this._pages = [], a = d, b = 0, c = 0; a < e; a++) {
2151      if (b >= h || 0 === b) {
2152        if (this._pages.push({
2153          start: Math.min(f, a - d),
2154          end: a - d + h - 1
2155        }), Math.min(f, a - d) === f) break;
2156        b = 0, ++c;
2157      }
2158      b += this._core.mergers(this._core.relative(a));
2159    }
2160  }, e.prototype.draw = function () {
2161    var b,
2162      c = this._core.settings,
2163      d = this._core.items().length <= c.items,
2164      e = this._core.relative(this._core.current()),
2165      f = c.loop || c.rewind;
2166    this._controls.$relative.toggleClass("disabled", !c.nav || d), c.nav && (this._controls.$previous.toggleClass("disabled", !f && e <= this._core.minimum(!0)), this._controls.$next.toggleClass("disabled", !f && e >= this._core.maximum(!0))), this._controls.$absolute.toggleClass("disabled", !c.dots || d), c.dots && (b = this._pages.length - this._controls.$absolute.children().length, c.dotsData && 0 !== b ? this._controls.$absolute.html(this._templates.join("")) : b > 0 ? this._controls.$absolute.append(new Array(b + 1).join(this._templates[0])) : b < 0 && this._controls.$absolute.children().slice(b).remove(), this._controls.$absolute.find(".active").removeClass("active"), this._controls.$absolute.children().eq(a.inArray(this.current(), this._pages)).addClass("active"));
2167  }, e.prototype.onTrigger = function (b) {
2168    var c = this._core.settings;
2169    b.page = {
2170      index: a.inArray(this.current(), this._pages),
2171      count: this._pages.length,
2172      size: c && (c.center || c.autoWidth || c.dotsData ? 1 : c.dotsEach || c.items)
2173    };
2174  }, e.prototype.current = function () {
2175    var b = this._core.relative(this._core.current());
2176    return a.grep(this._pages, a.proxy(function (a, c) {
2177      return a.start <= b && a.end >= b;
2178    }, this)).pop();
2179  }, e.prototype.getPosition = function (b) {
2180    var c,
2181      d,
2182      e = this._core.settings;
2183    return "page" == e.slideBy ? (c = a.inArray(this.current(), this._pages), d = this._pages.length, b ? ++c : --c, c = this._pages[(c % d + d) % d].start) : (c = this._core.relative(this._core.current()), d = this._core.items().length, b ? c += e.

2350/***/ "./node_modules/jquery/dist/jquery.js":
2351/*!********************************************!*\
2352  !*** ./node_modules/jquery/dist/jquery.js ***!
2353  \********************************************/
2354/***/ (function(module, exports) {
2355
2356var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
2357 * jQuery JavaScript Library v3.4.1
2358 * https://jquery.com/
2359 *
2360 * Includes Sizzle.js
2361 * https://sizzlejs.com/
2362 *
2363 * Copyright JS Foundation and other contributors
2364 * Released under the MIT license
2365 * https://jquery.org/license
2366 *
2367 * Date: 2019-05-01T21:04Z
2368 */
2369( function( global, factory ) {
2370
2371	"use strict";
2372
2373	if (  true && typeof module.exports === "object" ) {
2374
2375		// For CommonJS and CommonJS-like environments where a proper `window`
2376		// is present, execute the factory and get jQuery.
2377		// For environments that do not have a `window` with a `document`
2378		// (such as Node.js), expose a factory as module.exports.
2379		// This accentuates the need for the creation of a real `window`.
2380		// e.g. var jQuery = require("jquery")(window);
2381		// See ticket #14549 for more info.
2382		module.exports = global.document ?
2383			factory( global, true ) :
2384			function( w ) {
2385				if ( !w.document ) {
2386					throw new Error( "jQuery requires a window with a document" );
2387				}
2388				return factory( w );
2389			};
2390	} else {
2391		factory( global );
2392	}
2393
2394// Pass this if window is not defined yet
2395} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
2396
2397// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
2398// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
2399// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
2400// enough that all such attempts are guarded in a try block.
2401"use strict";
2402
2403var arr = [];
2404
2405var document = window.document;
2406
2407var getProto = Object.getPrototypeOf;
2408
2409var slice = arr.slice;
2410
2411var concat = arr.concat;
2412
2413var push = arr.push;
2414
2415var indexOf = arr.indexOf;
2416
2417var class2type = {};
2418
2419var toString = class2type.toString;
2420
2421var hasOwn = class2type.hasOwnProperty;
2422
2423var fnToString = hasOwn.toString;
2424
2425var ObjectFunctionString = fnToString.call( Object );
2426
2427var support = {};
2428
2429var isFunction = function isFunction( obj ) {
2430
2431      // Support: Chrome <=57, Firefox <=52
2432      // In some browsers, typeof returns "function" for HTML <object> elements
2433      // (i.e., `typeof document.createElement( "object" ) === "function"`).
2434      // We don't want to classify *any* DOM node as a function.
2435      return typeof obj === "function" && typeof obj.nodeType !== "number";
2436  };
2437
2438
2439var isWindow = function isWindow( obj ) {
2440		return obj != null && obj === obj.window;
2441	};
2442
2443
2444
2445
2446	var preservedScriptAttributes = {
2447		type: true,
2448		src: true,
2449		nonce: true,
2450		noModule: true
2451	};
2452
2453	function DOMEval( code, node, doc ) {
2454		doc = doc || document;
2455
2456		var i, val,
2457			script = doc.createElement( "script" );
2458
2459		script.text = code;
2460		if ( node ) {
2461			for ( i in preservedScriptAttributes ) {
2462
2463				// Support: Firefox 64+, Edge 18+
2464				// Some browsers don't support the "nonce" property on scripts.
2465				// On the other hand, just using `getAttribute` is not enough as
2466				// the `nonce` attribute is reset to an empty string whenever it
2467				// becomes browsing-context connected.
2468				// See https://github.com/whatwg/html/issues/2369
2469				// See https://html.spec.whatwg.org/#nonce-attributes
2470				// The `node.getAttribute` check was added for the sake of
2471				// `jQuery.globalEval` so that it can fake a nonce-containing node
2472				// via an object.
2473				val = node[ i ] || node.getAttribute && node.getAttribute( i );
2474				if ( val ) {
2475					script.setAttribute( i, val );
2476				}
2477			}
2478		}
2479		doc.head.appendChild( script ).parentNode.removeChild( script );
2480	}
2481
2482
2483function toType( obj ) {
2484	if ( obj == null ) {
2485		return obj + "";
2486	}
2487
2488	// Support: Android <=2.3 only (functionish RegExp)
2489	return typeof obj === "object" || typeof obj === "function" ?
2490		class2type[ toString.call( obj ) ] || "object" :
2491		typeof obj;
2492}
2493/* global Symbol */
2494// Defining this global in .eslintrc.json would create a danger of using the global
2495// unguarded in another place, it seems safer to define global only for this module
2496
2497
2498
2499var
2500	version = "3.4.1",
2501
2502	// Define a local copy of jQuery
2503	jQuery = function( selector, context ) {
2504
2505		// The jQuery object is actually just the init constructor 'enhanced'
2506		// Need init if jQuery is called (just allow error to be thrown if not included)
2507		return new jQuery.fn.init( selector, context );
2508	},
2509
2510	// Support: Android <=4.0 only
2511	// Make sure we trim BOM and NBSP
2512	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
2513
2514jQuery.fn = jQuery.prototype = {
2515
2516	// The current version of jQuery being used
2517	jquery: version,
2518
2519	constructor: jQuery,
2520
2521	// The default length of a jQuery object is 0
2522	length: 0,
2523
2524	toArray: function() {
2525		return slice.call( this );
2526	},
2527
2528	// Get the Nth element in the matched element set OR
2529	// Get the whole matched element set as a clean array
2530	get: function( num ) {
2531
2532		// Return all the elements in a clean array
2533		if ( num == null ) {
2534			return slice.call( this );
2535		}
2536
2537		// Return just the one element from the set
2538		return num < 0 ? this[ num + this.length ] : this[ num ];
2539	},
2540
2541	// Take an array of elements and push it onto the stack
2542	// (returning the new matched element set)
2543	pushStack: function( elems ) {
2544
2545		// Build a new jQuery matched element set
2546		var ret = jQuery.merge( this.constructor(), elems );
2547
2548		// Add the old object onto the stack (as a reference)
2549		ret.prevObject = this;
2550
2551		// Return the newly-formed element set
2552		return ret;
2553	},
2554
2555	// Execute a callback for every element in the matched set.
2556	each: function( callback ) {
2557		return jQuery.each( this, callback );
2558	},
2559
2560	map: function( callback ) {
2561		return this.pushStack( jQuery.map( this, function( elem, i ) {
2562			return callback.call( elem, i, elem );
2563		} ) );
2564	},
2565
2566	slice: function() {
2567		return this.pushStack( slice.apply( this, arguments ) );
2568	},
2569
2570	first: function() {
2571		return this.eq( 0 );
2572	},
2573
2574	last: function() {
2575		return this.eq( -1 );
2576	},
2577
2578	eq: function( i ) {
2579		var len = this.length,
2580			j = +i + ( i < 0 ? len : 0 );
2581		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
2582	},
2583
2584	end: function() {
2585		return this.prevObject || this.constructor();
2586	},
2587
2588	// For internal use only.
2589	// Behaves like an Array's method, not like a jQuery method.
2590	push: push,
2591	sort: arr.sort,
2592	splice: arr.splice
2593};
2594
2595jQuery.extend = jQuery.fn.extend = function() {
2596	var options, name, src, copy, copyIsArray, clone,
2597		target = arguments[ 0 ] || {},
2598		i = 1,
2599		length = arguments.length,
2600		deep = false;
2601
2602	// Handle a deep copy situation
2603	if ( typeof target === "boolean" ) {
2604		deep = target;
2605
2606		// Skip the boolean and the target
2607		target = arguments[ i ] || {};
2608		i++;
2609	}
2610
2611	// Handle case when target is a string or something (possible in deep copy)
2612	if ( typeof target !== "object" && !isFunction( target ) ) {
2613		target = {};
2614	}
2615
2616	// Extend jQuery itself if only one argument is passed
2617	if ( i === length ) {
2618		target = this;
2619		i--;
2620	}
2621
2622	for ( ; i < length; i++ ) {
2623
2624		// Only deal with non-null/undefined values
2625		if ( ( options = arguments[ i ] ) != null ) {
2626
2627			// Extend the base object
2628			for ( name in options ) {
2629				copy = options[ name ];
2630
2631				// Prevent Object.prototype pollution
2632				// Prevent never-ending loop
2633				if ( name === "__proto__" || target === copy ) {
2634					continue;
2635				}
2636
2637				// Recurse if we're merging plain objects or arrays
2638				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
2639					( copyIsArray = Array.isArray( copy ) ) ) ) {
2640					src = target[ name ];
2641
2642					// Ensure proper type for the source value
2643					if ( copyIsArray && !Array.isArray( src ) ) {
2644						clone = [];
2645					} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
2646						clone = {};
2647					} else {
2648						clone = src;
2649					}
2650					copyIsArray = false;
2651
2652					// Never move original objects, clone them
2653					target[ name ] = jQuery.extend( deep, clone, copy );
2654
2655				// Don't bring in undefined values
2656				} else if ( copy !== undefined ) {
2657					target[ name ] = copy;
2658				}
2659			}
2660		}
2661	}
2662
2663	// Return the modified object
2664	return target;
2665};
2666
2667jQuery.extend( {
2668
2669	// Unique for each copy of jQuery on the page
2670	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
2671
2672	// Assume jQuery is ready without the ready module
2673	isReady: true,
2674
2675	error: function( msg ) {
2676		throw new Error( msg );
2677	},
2678
2679	noop: function() {},
2680
2681	isPlainObject: function( obj ) {
2682		var proto, Ctor;
2683
2684		// Detect obvious negatives
2685		// Use toString instead of jQuery.type to catch host objects
2686		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
2687			return false;
2688		}
2689
2690		proto = getProto( obj );
2691
2692		// Objects with no prototype (e.g., `Object.create( null )`) are plain
2693		if ( !proto ) {
2694			return true;
2695		}
2696
2697		// Objects with prototype are plain iff they were constructed by a global Object function
2698		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
2699		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
2700	},
2701
2702	isEmptyObject: function( obj ) {
2703		var name;
2704
2705		for ( name in obj ) {
2706			return false;
2707		}
2708		return true;
2709	},
2710
2711	// Evaluates a script in a global context
2712	globalEval: function( code, options ) {
2713		DOMEval( code, { nonce: options && options.nonce } );
2714	},
2715
2716	each: function( obj, callback ) {
2717		var length, i = 0;
2718
2719		if ( isArrayLike( obj ) ) {
2720			length = obj.length;
2721			for ( ; i < length; i++ ) {
2722				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
2723					break;
2724				}
2725			}
2726		} else {
2727			for ( i in obj ) {
2728				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
2729					break;
2730				}
2731			}
2732		}
2733
2734		return obj;
2735	},
2736
2737	// Support: Android <=4.0 only
2738	trim: function( text ) {
2739		return text == null ?
2740			"" :
2741			( text + "" ).replace( rtrim, "" );
2742	},
2743
2744	// results is for internal usage only
2745	makeArray: function( arr, results ) {
2746		var ret = results || [];
2747
2748		if ( arr != null ) {
2749			if ( isArrayLike( Object( arr ) ) ) {
2750				jQuery.merge( ret,
2751					typeof arr === "string" ?
2752					[ arr ] : arr
2753				);
2754			} else {
2755				push.call( ret, arr );
2756			}
2757		}
2758
2759		return ret;
2760	},
2761
2762	inArray: function( elem, arr, i ) {
2763		return arr == null ? -1 : indexOf.call( arr, elem, i );
2764	},
2765
2766	// Support: Android <=4.0 only, PhantomJS 1 only
2767	// push.apply(_, arraylike) throws on ancient WebKit
2768	merge: function( first, second ) {
2769		var len = +second.length,
2770			j = 0,
2771			i = first.length;
2772
2773		for ( ; j < len; j++ ) {
2774			first[ i++ ] = second[ j ];
2775		}
2776
2777		first.length = i;
2778
2779		return first;
2780	},
2781
2782	grep: function( elems, callback, invert ) {
2783		var callbackInverse,
2784			matches = [],
2785			i = 0,
2786			length = elems.length,
2787			callbackExpect = !invert;
2788
2789		// Go through the array, only saving the items
2790		// that pass the validator function
2791		for ( ; i < length; i++ ) {
2792			callbackInverse = !callback( elems[ i ], i );
2793			if ( callbackInverse !== callbackExpect ) {
2794				matches.push( elems[ i ] );
2795			}
2796		}
2797
2798		return matches;
2799	},
2800
2801	// arg is for internal usage only
2802	map: function( elems, callback, arg ) {
2803		var length, value,
2804			i = 0,
2805			ret = [];
2806
2807		// Go through the array, translating each of the items to their new values
2808		if ( isArrayLike( elems ) ) {
2809			length = elems.length;
2810			for ( ; i < length; i++ ) {
2811				value = callback( elems[ i ], i, arg );
2812
2813				if ( value != null ) {
2814					ret.push( value );
2815				}
2816			}
2817
2818		// Go through every key on the object,
2819		} else {
2820			for ( i in elems ) {
2821				value = callback( elems[ i ], i, arg );
2822
2823				if ( value != null ) {
2824					ret.push( value );
2825				}
2826			}
2827		}
2828
2829		// Flatten any nested arrays
2830		return concat.apply( [], ret );
2831	},
2832
2833	// A global GUID counter for objects
2834	guid: 1,
2835
2836	// jQuery.support is not used in Core but other projects attach their
2837	// properties to it so it needs to exist.
2838	support: support
2839} );
2840
2841if ( typeof Symbol === "function" ) {
2842	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
2843}
2844
2845// Populate the class2type map
2846jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
2847function( i, name ) {
2848	class2type[ "[object " + name + "]" ] = name.toLowerCase();
2849} );
2850
2851function isArrayLike( obj ) {
2852
2853	// Support: real iOS 8.2 only (not reproducible in simulator)
2854	// `in` check used to prevent JIT error (gh-2145)
2855	// hasOwn isn't used here due to false negatives
2856	// regarding Nodelist length in IE
2857	var length = !!obj && "length" in obj && obj.length,
2858		type = toType( obj );
2859
2860	if ( isFunction( obj ) || isWindow( obj ) ) {
2861		return false;
2862	}
2863
2864	return type === "array" || length === 0 ||
2865		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
2866}
2867var Sizzle =
2868/*!
2869 * Sizzle CSS Selector Engine v2.3.4
2870 * https://sizzlejs.com/
2871 *
2872 * Copyright JS Foundation and other contributors
2873 * Released under the MIT license
2874 * https://js.foundation/
2875 *
2876 * Date: 2019-04-08
2877 */
2878(function( window ) {
2879
2880var i,
2881	support,
2882	Expr,
2883	getText,
2884	isXML,
2885	tokenize,
2886	compile,
2887	select,
2888	outermostContext,
2889	sortInput,
2890	hasDuplicate,
2891
2892	// Local document vars
2893	setDocument,
2894	document,
2895	docElem,
2896	documentIsHTML,
2897	rbuggyQSA,
2898	rbuggyMatches,
2899	matches,
2900	contains,
2901
2902	// Instance-specific data
2903	expando = "sizzle" + 1 * new Date(),
2904	preferredDoc = window.document,
2905	dirruns = 0,
2906	done = 0,
2907	classCache = createCache(),
2908	tokenCache = createCache(),
2909	compilerCache = createCache(),
2910	nonnativeSelectorCache = createCache(),
2911	sortOrder = function( a, b ) {
2912		if ( a === b ) {
2913			hasDuplicate = true;
2914		}
2915		return 0;
2916	},
2917
2918	// Instance methods
2919	hasOwn = ({}).hasOwnProperty,
2920	arr = [],
2921	pop = arr.pop,
2922	push_native = arr.push,
2923	push = arr.push,
2924	slice = arr.slice,
2925	// Use a stripped-down indexOf as it's faster than native
2926	// https://jsperf.com/thor-indexof-vs-for/5
2927	indexOf = function( list, elem ) {
2928		var i = 0,
2929			len = list.length;
2930		for ( ; i < len; i++ ) {
2931			if ( list[i] === elem ) {
2932				return i;
2933			}
2934		}
2935		return -1;
2936	},
2937
2938	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
2939
2940	// Regular expressions
2941
2942	// http://www.w3.org/TR/css3-selectors/#whitespace
2943	whitespace = "[\\x20\\t\\r\\n\\f]",
2944
2945	// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
2946	identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
2947
2948	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
2949	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
2950		// Operator (capture 2)
2951		"*([*^$|!~]?=)" + whitespace +
2952		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
2953		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
2954		"*\\]",
2955
2956	pseudos = ":(" + identifier + ")(?:\\((" +
2957		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
2958		// 1. quoted (capture 3; capture 4 or capture 5)
2959		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
2960		// 2. simple (capture 6)
2961		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
2962		// 3. anything else (capture 2)
2963		".*" +
2964		")\\)|)",
2965
2966	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
2967	rwhitespace = new RegExp( whitespace + "+", "g" ),
2968	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
2969
2970	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
2971	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
2972	rdescend = new RegExp( whitespace + "|>" ),
2973
2974	rpseudo = new RegExp( pseudos ),
2975	ridentifier = new RegExp( "^" + identifier + "$" ),
2976
2977	matchExpr = {
2978		"ID": new RegExp( "^#(" + identifier + ")" ),
2979		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
2980		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
2981		"ATTR": new RegExp( "^" + attributes ),
2982		"PSEUDO": new RegExp( "^" + pseudos ),
2983		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
2984			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
2985			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
2986		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
2987		// For use in libraries implementing .is()
2988		// We use this for POS matching in `select`
2989		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
2990			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
2991	},
2992
2993	rhtml = /HTML$/i,
2994	rinputs = /^(?:input|select|textarea|button)$/i,
2995	rheader = /^h\d$/i,
2996
2997	rnative = /^[^{]+\{\s*\[native \w/,
2998
2999	// Easily-parseable/retrievable ID or TAG or CLASS selectors
3000	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
3001
3002	rsibling = /[+~]/,
3003
3004	// CSS escapes
3005	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
3006	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
3007	funescape = function( _, escaped, escapedWhitespace ) {
3008		var high = "0x" + escaped - 0x10000;
3009		// NaN means non-codepoint
3010		// Support: Firefox<24
3011		// Workaround erroneous numeric interpretation of +"0x"
3012		return high !== high || escapedWhitespace ?
3013			escaped :
3014			high < 0 ?
3015				// BMP codepoint
3016				String.fromCharCode( high + 0x10000 ) :
3017				// Supplemental Plane codepoint (surrogate pair)
3018				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
3019	},
3020
3021	// CSS string/identifier serialization
3022	// https://drafts.csswg.org/cssom/#common-serializing-idioms
3023	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
3024	fcssescape = function( ch, asCodePoint ) {
3025		if ( asCodePoint ) {
3026
3027			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
3028			if ( ch === "\0" ) {
3029				return "\uFFFD";
3030			}
3031
3032			// Control characters and (dependent upon position) numbers get escaped as code points
3033			return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
3034		}
3035
3036		// Other potentially-special ASCII characters get backslash-escaped
3037		return "\\" + ch;
3038	},
3039
3040	// Used for iframes
3041	// See setDocument()
3042	// Removing the function wrapper causes a "Permission Denied"
3043	// error in IE
3044	unloadHandler = function() {
3045		setDocument();
3046	},
3047
3048	inDisabledFieldset = addCombinator(
3049		function( elem ) {
3050			return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
3051		},
3052		{ dir: "parentNode", next: "legend" }
3053	);
3054
3055// Optimize for push.apply( _, NodeList )
3056try {
3057	push.apply(
3058		(arr = slice.call( preferredDoc.childNodes )),
3059		preferredDoc.childNodes
3060	);
3061	// Support: Android<4.0
3062	// Detect silently failing push.apply
3063	arr[ preferredDoc.childNodes.length ].nodeType;
3064} catch ( e ) {
3065	push = { apply: arr.length ?
3066
3067		// Leverage slice if possible
3068		function( target, els ) {
3069			push_native.apply( target, slice.call(els) );
3070		} :
3071
3072		// Support: IE<9
3073		// Otherwise append directly
3074		function( target, els ) {
3075			var j = target.length,
3076				i = 0;
3077			// Can't trust NodeList.length
3078			while ( (target[j++] = els[i++]) ) {}
3079			target.length = j - 1;
3080		}
3081	};
3082}
3083
3084function Sizzle( selector, context, results, seed ) {
3085	var m, i, elem, nid, match, groups, newSelector,
3086		newContext = context && context.ownerDocument,
3087
3088		// nodeType defaults to 9, since context defaults to document
3089		nodeType = context ? context.nodeType : 9;
3090
3091	results = results || [];
3092
3093	// Return early from calls with invalid selector or context
3094	if ( typeof selector !== "string" || !selector ||
3095		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
3096
3097		return results;
3098	}
3099
3100	// Try to shortcut find operations (as opposed to filters) in HTML documents
3101	if ( !seed ) {
3102
3103		if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
3104			setDocument( context );
3105		}
3106		context = context || document;
3107
3108		if ( documentIsHTML ) {
3109
3110			// If the selector is sufficiently simple, try using a "get*By*" DOM method
3111			// (excepting DocumentFragment context, where the methods don't exist)
3112			if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
3113
3114				// ID selector
3115				if ( (m = match[1]) ) {
3116
3117					// Document context
3118					if ( nodeType === 9 ) {
3119						if ( (elem = context.getElementById( m )) ) {
3120
3121							// Support: IE, Opera, Webkit
3122							// TODO: identify versions
3123							// getElementById can match elements by name instead of ID
3124							if ( elem.id === m ) {
3125								results.push( elem );
3126								return results;
3127							}
3128						} else {
3129							return results;
3130						}
3131
3132					// Element context
3133					} else {
3134
3135						// Support: IE, Opera, Webkit
3136						// TODO: identify versions
3137						// getElementById can match elements by name instead of ID
3138						if ( newContext && (elem = newContext.getElementById( m )) &&
3139							contains( context, elem ) &&
3140							elem.id === m ) {
3141
3142							results.push( elem );
3143							return results;
3144						}
3145					}
3146
3147				// Type selector
3148				} else if ( match[2] ) {
3149					push.apply( results, context.getElementsByTagName( selector ) );
3150					return results;
3151
3152				// Class selector
3153				} else if ( (m = match[3]) && support.getElementsByClassName &&
3154					context.getElementsByClassName ) {
3155
3156					push.apply( results, context.getElementsByClassName( m ) );
3157					return results;
3158				}
3159			}
3160
3161			// Take advantage of querySelectorAll
3162			if ( support.qsa &&
3163				!nonnativeSelectorCache[ selector + " " ] &&
3164				(!rbuggyQSA || !rbuggyQSA.test( selector )) &&
3165
3166				// Support: IE 8 only
3167				// Exclude object elements
3168				(nodeType !== 1 || context.nodeName.toLowerCase() !== "object") ) {
3169
3170				newSelector = selector;
3171				newContext = context;
3172
3173				// qSA considers elements outside a scoping root when evaluating child or
3174				// descendant combinators, which is not what we want.
3175				// In such cases, we work around the behavior by prefixing every selector in the
3176				// list with an ID selector referencing the scope context.
3177				// Thanks to Andrew Dupont for this technique.
3178				if ( nodeType === 1 && rdescend.test( selector ) ) {
3179
3180					// Capture the context ID, setting it first if necessary
3181					if ( (nid = context.getAttribute( "id" )) ) {
3182						nid = nid.replace( rcssescape, fcssescape );
3183					} else {
3184						context.setAttribute( "id", (nid = expando) );
3185					}
3186
3187					// Prefix every selector in the list
3188					groups = tokenize( selector );
3189					i = groups.length;
3190					while ( i-- ) {
3191						groups[i] = "#" + nid + " " + toSelector( groups[i] );
3192					}
3193					newSelector = groups.join( "," );
3194
3195					// Expand context for sibling selectors
3196					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
3197						context;
3198				}
3199
3200				try {
3201					push.apply( results,
3202						newContext.querySelectorAll( newSelector )
3203					);
3204					return results;
3205				} catch ( qsaError ) {
3206					nonnativeSelectorCache( selector, true );
3207				} finally {
3208					if ( nid === expando ) {
3209						context.removeAttribute( "id" );
3210					}
3211				}
3212			}
3213		}
3214	}
3215
3216	// All others
3217	return select( selector.replace( rtrim, "$1" ), context, results, seed );
3218}
3219
3220/**
3221 * Create key-value caches of limited size
3222 * @returns {function(string, object)} Returns the Object data after storing it on itself with
3223 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
3224 *	deleting the oldest entry
3225 */
3226function createCache() {
3227	var keys = [];
3228
3229	function cache( key, value ) {
3230		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
3231		if ( keys.push( key + " " ) > Expr.cacheLength ) {
3232			// Only keep the most recent entries
3233			delete cache[ keys.shift() ];
3234		}
3235		return (cache[ key + " " ] = value);
3236	}
3237	return cache;
3238}
3239
3240/**
3241 * Mark a function for special use by Sizzle
3242 * @param {Function} fn The function to mark
3243 */
3244function markFunction( fn ) {
3245	fn[ expando ] = true;
3246	return fn;
3247}
3248
3249/**
3250 * Support testing using an element
3251 * @param {Function} fn Passed the created element and returns a boolean result
3252 */
3253function assert( fn ) {
3254	var el = document.createElement("fieldset");
3255
3256	try {
3257		return !!fn( el );
3258	} catch (e) {
3259		return false;
3260	} finally {
3261		// Remove from its parent by default
3262		if ( el.parentNode ) {
3263			el.parentNode.removeChild( el );
3264		}
3265		// release memory in IE
3266		el = null;
3267	}
3268}
3269
3270/**
3271 * Adds the same handler for all of the specified attrs
3272 * @param {String} attrs Pipe-separated list of attributes
3273 * @param {Function} handler The method that will be applied
3274 */
3275function addHandle( attrs, handler ) {
3276	var arr = attrs.split("|"),
3277		i = arr.length;
3278
3279	while ( i-- ) {
3280		Expr.attrHandle[ arr[i] ] = handler;
3281	}
3282}
3283
3284/**
3285 * Checks document order of two siblings
3286 * @param {Element} a
3287 * @param {Element} b
3288 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
3289 */
3290function siblingCheck( a, b ) {
3291	var cur = b && a,
3292		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
3293			a.sourceIndex - b.sourceIndex;
3294
3295	// Use IE sourceIndex if available on both nodes
3296	if ( diff ) {
3297		return diff;
3298	}
3299
3300	// Check if b follows a
3301	if ( cur ) {
3302		while ( (cur = cur.nextSibling) ) {
3303			if ( cur === b ) {
3304				return -1;
3305			}
3306		}
3307	}
3308
3309	return a ? 1 : -1;
3310}
3311
3312/**
3313 * Returns a function to use in pseudos for input types
3314 * @param {String} type
3315 */
3316function createInputPseudo( type ) {
3317	return function( elem ) {
3318		var name = elem.nodeName.toLowerCase();
3319		return name === "input" && elem.type === type;
3320	};
3321}
3322
3323/**
3324 * Returns a function to use in pseudos for buttons
3325 * @param {String} type
3326 */
3327function createButtonPseudo( type ) {
3328	return function( elem ) {
3329		var name = elem.nodeName.toLowerCase();
3330		return (name === "input" || name === "button") && elem.type === type;
3331	};
3332}
3333
3334/**
3335 * Returns a function to use in pseudos for :enabled/:disabled
3336 * @param {Boolean} disabled true for :disabled; false for :enabled
3337 */
3338function createDisabledPseudo( disabled ) {
3339
3340	// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
3341	return function( elem ) {
3342
3343		// Only certain elements can match :enabled or :disabled
3344		// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
3345		// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
3346		if ( "form" in elem ) {
3347
3348			// Check for inherited disabledness on relevant non-disabled elements:
3349			// * listed form-associated elements in a disabled fieldset
3350			//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
3351			//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
3352			// * option elements in a disabled optgroup
3353			//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
3354			// All such elements have a "form" property.
3355			if ( elem.parentNode && elem.disabled === false ) {
3356
3357				// Option elements defer to a parent optgroup if present
3358				if ( "label" in elem ) {
3359					if ( "label" in elem.parentNode ) {
3360						return elem.parentNode.disabled === disabled;
3361					} else {
3362						return elem.disabled === disabled;
3363					}
3364				}
3365
3366				// Support: IE 6 - 11
3367				// Use the isDisabled shortcut property to check for disabled fieldset ancestors
3368				return elem.isDisabled === disabled ||
3369
3370					// Where there is no isDisabled, check manually
3371					/* jshint -W018 */
3372					elem.isDisabled !== !disabled &&
3373						inDisabledFieldset( elem ) === disabled;
3374			}
3375
3376			return elem.disabled === disabled;
3377
3378		// Try to winnow out elements that can't be disabled before trusting the disabled property.
3379		// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
3380		// even exist on them, let alone have a boolean value.
3381		} else if ( "label" in elem ) {
3382			return elem.disabled === disabled;
3383		}
3384
3385		// Remaining elements are neither :enabled nor :disabled
3386		return false;
3387	};
3388}
3389
3390/**
3391 * Returns a function to use in pseudos for positionals
3392 * @param {Function} fn
3393 */
3394function createPositionalPseudo( fn ) {
3395	return markFunction(function( argument ) {
3396		argument = +argument;
3397		return markFunction(function( seed, matches ) {
3398			var j,
3399				matchIndexes = fn( [], seed.length, argument ),
3400				i = matchIndexes.length;
3401
3402			// Match elements found at the specified indexes
3403			while ( i-- ) {
3404				if ( seed[ (j = matchIndexes[i]) ] ) {
3405					seed[j] = !(matches[j] = seed[j]);
3406				}
3407			}
3408		});
3409	});
3410}
3411
3412/**
3413 * Checks a node for validity as a Sizzle context
3414 * @param {Element|Object=} context
3415 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
3416 */
3417function testContext( context ) {
3418	return context && typeof context.getElementsByTagName !== "undefined" && context;
3419}
3420
3421// Expose support vars for convenience
3422support = Sizzle.support = {};
3423
3424/**
3425 * Detects XML nodes
3426 * @param {Element|Object} elem An element or a document
3427 * @returns {Boolean} True iff elem is a non-HTML XML node
3428 */
3429isXML = Sizzle.isXML = function( elem ) {
3430	var namespace = elem.namespaceURI,
3431		docElem = (elem.ownerDocument || elem).documentElement;
3432
3433	// Support: IE <=8
3434	// Assume HTML when documentElement doesn't yet exist, such as inside loading iframes
3435	// https://bugs.jquery.com/ticket/4833
3436	return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" );
3437};
3438
3439/**
3440 * Sets document-related variables once based on the current document
3441 * @param {Element|Object} [doc] An element or document object to use to set the document
3442 * @returns {Object} Returns the current document
3443 */
3444setDocument = Sizzle.setDocument = function( node ) {
3445	var hasCompare, subWindow,
3446		doc = node ? node.ownerDocument || node : preferredDoc;
3447
3448	// Return early if doc is invalid or already selected
3449	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
3450		return document;
3451	}
3452
3453	// Update global variables
3454	document = doc;
3455	docElem = document.documentElement;
3456	documentIsHTML = !isXML( document );
3457
3458	// Support: IE 9-11, Edge
3459	// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
3460	if ( preferredDoc !== document &&
3461		(subWindow = document.defaultView) && subWindow.top !== subWindow ) {
3462
3463		// Support: IE 11, Edge
3464		if ( subWindow.addEventListener ) {
3465			subWindow.addEventListener( "unload", unloadHandler, false );
3466
3467		// Support: IE 9 - 10 only
3468		} else if ( subWindow.attachEvent ) {
3469			subWindow.attachEvent( "onunload", unloadHandler );
3470		}
3471	}
3472
3473	/* Attributes
3474	---------------------------------------------------------------------- */
3475
3476	// Support: IE<8
3477	// Verify that getAttribute really returns attributes and not properties
3478	// (excepting IE8 booleans)
3479	support.attributes = assert(function( el ) {
3480		el.className = "i";
3481		return !el.getAttribute("className");
3482	});
3483
3484	/* getElement(s)By*
3485	---------------------------------------------------------------------- */
3486
3487	// Check if getElementsByTagName("*") returns only elements
3488	support.getElementsByTagName = assert(function( el ) {
3489		el.appendChild( document.createComment("") );
3490		return !el.getElementsByTagName("*").length;
3491	});
3492
3493	// Support: IE<9
3494	support.getElementsByClassName = rnative.test( document.getElementsByClassName );
3495
3496	// Support: IE<10
3497	// Check if getElementById returns elements by name
3498	// The broken getElementById methods don't pick up programmatically-set names,
3499	// so use a roundabout getElementsByName test
3500	support.getById = assert(function( el ) {
3501		docElem.appendChild( el ).id = expando;
3502		return !document.getElementsByName || !document.getElementsByName( expando ).length;
3503	});
3504
3505	// ID filter and find
3506	if ( support.getById ) {
3507		Expr.filter["ID"] = function( id ) {
3508			var attrId = id.replace( runescape, funescape );
3509			return function( elem ) {
3510				return elem.getAttribute("id") === attrId;
3511			};
3512		};
3513		Expr.find["ID"] = function( id, context ) {
3514			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
3515				var elem = context.getElementById( id );
3516				return elem ? [ elem ] : [];
3517			}
3518		};
3519	} else {
3520		Expr.filter["ID"] =  function( id ) {
3521			var attrId = id.replace( runescape, funescape );
3522			return function( elem ) {
3523				var node = typeof elem.getAttributeNode !== "undefined" &&
3524					elem.getAttributeNode("id");
3525				return node && node.value === attrId;
3526			};
3527		};
3528
3529		// Support: IE 6 - 7 only
3530		// getElementById is not reliable as a find shortcut
3531		Expr.find["ID"] = function( id, context ) {
3532			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
3533				var node, i, elems,
3534					elem = context.getElementById( id );
3535
3536				if ( elem ) {
3537
3538					// Verify the id attribute
3539					node = elem.getAttributeNode("id");
3540					if ( node && node.value === id ) {
3541						return [ elem ];
3542					}
3543
3544					// Fall back on getElementsByName
3545					elems = context.getElementsByName( id );
3546					i = 0;
3547					while ( (elem = elems[i++]) ) {
3548						node = elem.getAttributeNode("id");
3549						if ( node && node.value === id ) {
3550							return [ elem ];
3551						}
3552					}
3553				}
3554
3555				return [];
3556			}
3557		};
3558	}
3559
3560	// Tag
3561	Expr.find["TAG"] = support.getElementsByTagName ?
3562		function( tag, context ) {
3563			if ( typeof context.getElementsByTagName !== "undefined" ) {
3564				return context.getElementsByTagName( tag );
3565
3566			// DocumentFragment nodes don't have gEBTN
3567			} else if ( support.qsa ) {
3568				return context.querySelectorAll( tag );
3569			}
3570		} :
3571
3572		function( tag, context ) {
3573			var elem,
3574				tmp = [],
3575				i = 0,
3576				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
3577				results = context.getElementsByTagName( tag );
3578
3579			// Filter out possible comments
3580			if ( tag === "*" ) {
3581				while ( (elem = results[i++]) ) {
3582					if ( elem.nodeType === 1 ) {
3583						tmp.push( elem );
3584					}
3585				}
3586
3587				return tmp;
3588			}
3589			return results;
3590		};
3591
3592	// Class
3593	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
3594		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
3595			return context.getElementsByClassName( className );
3596		}
3597	};
3598
3599	/* QSA/matchesSelector
3600	---------------------------------------------------------------------- */
3601
3602	// QSA and matchesSelector support
3603
3604	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
3605	rbuggyMatches = [];
3606
3607	// qSa(:focus) reports false when true (Chrome 21)
3608	// We allow this because of a bug in IE8/9 that throws an error
3609	// whenever `document.activeElement` is accessed on an iframe
3610	// So, we allow :focus to pass through QSA all the time to avoid the IE error
3611	// See https://bugs.jquery.com/ticket/13378
3612	rbuggyQSA = [];
3613
3614	if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
3615		// Build QSA regex
3616		// Regex strategy adopted from Diego Perini
3617		assert(function( el ) {
3618			// Select is set to empty string on purpose
3619			// This is to test IE's treatment of not explicitly
3620			// setting a boolean content attribute,
3621			// since its presence should be enough
3622			// https://bugs.jquery.com/ticket/12359
3623			docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
3624				"<select id='" + expando + "-\r\\' msallowcapture=''>" +
3625				"<option selected=''></option></select>";
3626
3627			// Support: IE8, Opera 11-12.16
3628			// Nothing should be selected when empty strings follow ^= or $= or *=
3629			// The test attribute must be unknown in Opera but "safe" for WinRT
3630			// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
3631			if ( el.querySelectorAll("[msallowcapture^='']").length ) {
3632				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
3633			}
3634
3635			// Support: IE8
3636			// Boolean attributes and "value" are not treated correctly
3637			if ( !el.querySelectorAll("[selected]").length ) {
3638				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
3639			}
3640
3641			// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
3642			if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
3643				rbuggyQSA.push("~=");
3644			}
3645
3646			// Webkit/Opera - :checked should return selected option elements
3647			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
3648			// IE8 throws error here and will not see later tests
3649			if ( !el.querySelectorAll(":checked").length ) {
3650				rbuggyQSA.push(":checked");
3651			}
3652
3653			// Support: Safari 8+, iOS 8+
3654			// https://bugs.webkit.org/show_bug.cgi?id=136851
3655			// In-page `selector#id sibling-combinator selector` fails
3656			if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
3657				rbuggyQSA.push(".#.+[+~]");
3658			}
3659		});
3660
3661		assert(function( el ) {
3662			el.innerHTML = "<a href='' disabled='disabled'></a>" +
3663				"<select disabled='disabled'><option/></select>";
3664
3665			// Support: Windows 8 Native Apps
3666			// The type and name attributes are restricted during .innerHTML assignment
3667			var input = document.createElement("input");
3668			input.setAttribute( "type", "hidden" );
3669			el.appendChild( input ).setAttribute( "name", "D" );
3670
3671			// Support: IE8
3672			// Enforce case-sensitivity of name attribute
3673			if ( el.querySelectorAll("[name=d]").length ) {
3674				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
3675			}
3676
3677			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
3678			// IE8 throws error here and will not see later tests
3679			if ( el.querySelectorAll(":enabled").length !== 2 ) {
3680				rbuggyQSA.push( ":enabled", ":disabled" );
3681			}
3682
3683			// Support: IE9-11+
3684			// IE's :disabled selector does not pick up the children of disabled fieldsets
3685			docElem.appendChild( el ).disabled = true;
3686			if ( el.querySelectorAll(":disabled").length !== 2 ) {
3687				rbuggyQSA.push( ":enabled", ":disabled" );
3688			}
3689
3690			// Opera 10-11 does not throw on post-comma invalid pseudos
3691			el.querySelectorAll("*,:x");
3692			rbuggyQSA.push(",.*:");
3693		});
3694	}
3695
3696	if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
3697		docElem.webkitMatchesSelector ||
3698		docElem.mozMatchesSelector ||
3699		docElem.oMatchesSelector ||
3700		docElem.msMatchesSelector) )) ) {
3701
3702		assert(function( el ) {
3703			// Check to see if it's possible to do matchesSelector
3704			// on a disconnected node (IE 9)
3705			support.disconnectedMatch = matches.call( el, "*" );
3706
3707			// This should fail with an exception
3708			// Gecko does not error, returns false instead
3709			matches.call( el, "[s!='']:x" );
3710			rbuggyMatches.push( "!=", pseudos );
3711		});
3712	}
3713
3714	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
3715	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
3716
3717	/* Contains
3718	---------------------------------------------------------------------- */
3719	hasCompare = rnative.test( docElem.compareDocumentPosition );
3720
3721	// Element contains another
3722	// Purposefully self-exclusive
3723	// As in, an element does not contain itself
3724	contains = hasCompare || rnative.test( docElem.contains ) ?
3725		function( a, b ) {
3726			var adown = a.nodeType === 9 ? a.documentElement : a,
3727				bup = b && b.parentNode;
3728			return a === bup || !!( bup && bup.nodeType === 1 && (
3729				adown.contains ?
3730					adown.contains( bup ) :
3731					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
3732			));
3733		} :
3734		function( a, b ) {
3735			if ( b ) {
3736				while ( (b = b.parentNode) ) {
3737					if ( b === a ) {
3738						return true;
3739					}
3740				}
3741			}
3742			return false;
3743		};
3744
3745	/* Sorting
3746	---------------------------------------------------------------------- */
3747
3748	// Document order sorting
3749	sortOrder = hasCompare ?
3750	function( a, b ) {
3751
3752		// Flag for duplicate removal
3753		if ( a === b ) {
3754			hasDuplicate = true;
3755			return 0;
3756		}
3757
3758		// Sort on method existence if only one input has compareDocumentPosition
3759		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
3760		if ( compare ) {
3761			return compare;
3762		}
3763
3764		// Calculate position if both inputs belong to the same document
3765		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
3766			a.compareDocumentPosition( b ) :
3767
3768			// Otherwise we know they are disconnected
3769			1;
3770
3771		// Disconnected nodes
3772		if ( compare & 1 ||
3773			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
3774
3775			// Choose the first element that is related to our preferred document
3776			if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
3777				return -1;
3778			}
3779			if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
3780				return 1;
3781			}
3782
3783			// Maintain original order
3784			return sortInput ?
3785				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
3786				0;
3787		}
3788
3789		return compare & 4 ? -1 : 1;
3790	} :
3791	function( a, b ) {
3792		// Exit early if the nodes are identical
3793		if ( a === b ) {
3794			hasDuplicate = true;
3795			return 0;
3796		}
3797
3798		var cur,
3799			i = 0,
3800			aup = a.parentNode,
3801			bup = b.parentNode,
3802			ap = [ a ],
3803			bp = [ b ];
3804
3805		// Parentless nodes are either documents or disconnected
3806		if ( !aup || !bup ) {
3807			return a === document ? -1 :
3808				b === document ? 1 :
3809				aup ? -1 :
3810				bup ? 1 :
3811				sortInput ?
3812				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
3813				0;
3814
3815		// If the nodes are siblings, we can do a quick check
3816		} else if ( aup === bup ) {
3817			return siblingCheck( a, b );
3818		}
3819
3820		// Otherwise we need full lists of their ancestors for comparison
3821		cur = a;
3822		while ( (cur = cur.parentNode) ) {
3823			ap.unshift( cur );
3824		}
3825		cur = b;
3826		while ( (cur = cur.parentNode) ) {
3827			bp.unshift( cur );
3828		}
3829
3830		// Walk down the tree looking for a discrepancy
3831		while ( ap[i] === bp[i] ) {
3832			i++;
3833		}
3834
3835		return i ?
3836			// Do a sibling check if the nodes have a common ancestor
3837			siblingCheck( ap[i], bp[i] ) :
3838
3839			// Otherwise nodes in our document sort first
3840			ap[i] === preferredDoc ? -1 :
3841			bp[i] === preferredDoc ? 1 :
3842			0;
3843	};
3844
3845	return document;
3846};
3847
3848Sizzle.matches = function( expr, elements ) {
3849	return Sizzle( expr, null, null, elements );
3850};
3851
3852Sizzle.matchesSelector = function( elem, expr ) {
3853	// Set document vars if needed
3854	if ( ( elem.ownerDocument || elem ) !== document ) {
3855		setDocument( elem );
3856	}
3857
3858	if ( support.matchesSelector && documentIsHTML &&
3859		!nonnativeSelectorCache[ expr + " " ] &&
3860		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
3861		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
3862
3863		try {
3864			var ret = matches.call( elem, expr );
3865
3866			// IE 9's matchesSelector returns false on disconnected nodes
3867			if ( ret || support.disconnectedMatch ||
3868					// As well, disconnected nodes are said to be in a document
3869					// fragment in IE 9
3870					elem.document && elem.document.nodeType !== 11 ) {
3871				return ret;
3872			}
3873		} catch (e) {
3874			nonnativeSelectorCache( expr, true );
3875		}
3876	}
3877
3878	return Sizzle( expr, document, null, [ elem ] ).length > 0;
3879};
3880
3881Sizzle.contains = function( context, elem ) {
3882	// Set document vars if needed
3883	if ( ( context.ownerDocument || context ) !== document ) {
3884		setDocument( context );
3885	}
3886	return contains( context, elem );
3887};
3888
3889Sizzle.attr = function( elem, name ) {
3890	// Set document vars if needed
3891	if ( ( elem.ownerDocument || elem ) !== document ) {
3892		setDocument( elem );
3893	}
3894
3895	var fn = Expr.attrHandle[ name.toLowerCase() ],
3896		// Don't get fooled by Object.prototype properties (jQuery #13807)
3897		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
3898			fn( elem, name, !documentIsHTML ) :
3899			undefined;
3900
3901	return val !== undefined ?
3902		val :
3903		support.attributes || !documentIsHTML ?
3904			elem.getAttribute( name ) :
3905			(val = elem.getAttributeNode(name)) && val.specified ?
3906				val.value :
3907				null;
3908};
3909
3910Sizzle.escape = function( sel ) {
3911	return (sel + "").replace( rcssescape, fcssescape );
3912};
3913
3914Sizzle.error = function( msg ) {
3915	throw new Error( "Syntax error, unrecognized expression: " + msg );
3916};
3917
3918/**
3919 * Document sorting and removing duplicates
3920 * @param {ArrayLike} results
3921 */
3922Sizzle.uniqueSort = function( results ) {
3923	var elem,
3924		duplicates = [],
3925		j = 0,
3926		i = 0;
3927
3928	// Unless we *know* we can detect duplicates, assume their presence
3929	hasDuplicate = !support.detectDuplicates;
3930	sortInput = !support.sortStable && results.slice( 0 );
3931	results.sort( sortOrder );
3932
3933	if ( hasDuplicate ) {
3934		while ( (elem = results[i++]) ) {
3935			if ( elem === results[ i ] ) {
3936				j = duplicates.push( i );
3937			}
3938		}
3939		while ( j-- ) {
3940			results.splice( duplicates[ j ], 1 );
3941		}
3942	}
3943
3944	// Clear input after sorting to release objects
3945	// See https://github.com/jquery/sizzle/pull/225
3946	sortInput = null;
3947
3948	return results;
3949};
3950
3951/**
3952 * Utility function for retrieving the text value of an array of DOM nodes
3953 * @param {Array|Element} elem
3954 */
3955getText = Sizzle.getText = function( elem ) {
3956	var node,
3957		ret = "",
3958		i = 0,
3959		nodeType = elem.nodeType;
3960
3961	if ( !nodeType ) {
3962		// If no nodeType, this is expected to be an array
3963		while ( (node = elem[i++]) ) {
3964			// Do not traverse comment nodes
3965			ret += getText( node );
3966		}
3967	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
3968		// Use textContent for elements
3969		// innerText usage removed for consistency of new lines (jQuery #11153)
3970		if ( typeof elem.textContent === "string" ) {
3971			return elem.textContent;
3972		} else {
3973			// Traverse its children
3974			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
3975				ret += getText( elem );
3976			}
3977		}
3978	} else if ( nodeType === 3 || nodeType === 4 ) {
3979		return elem.nodeValue;
3980	}
3981	// Do not include comment or processing instruction nodes
3982
3983	return ret;
3984};
3985
3986Expr = Sizzle.selectors = {
3987
3988	// Can be adjusted by the user
3989	cacheLength: 50,
3990
3991	createPseudo: markFunction,
3992
3993	match: matchExpr,
3994
3995	attrHandle: {},
3996
3997	find: {},
3998
3999	relative: {
4000		">": { dir: "parentNode", first: true },
4001		" ": { dir: "parentNode" },
4002		"+": { dir: "previousSibling", first: true },
4003		"~": { dir: "previousSibling" }
4004	},
4005
4006	preFilter: {
4007		"ATTR": function( match ) {
4008			match[1] = match[1].replace( runescape, funescape );
4009
4010			// Move the given value to match[3] whether quoted or unquoted
4011			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
4012
4013			if ( match[2] === "~=" ) {
4014				match[3] = " " + match[3] + " ";
4015			}
4016
4017			return match.slice( 0, 4 );
4018		},
4019
4020		"CHILD": function( match ) {
4021			/* matches from matchExpr["CHILD"]
4022				1 type (only|nth|...)
4023				2 what (child|of-type)
4024				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
4025				4 xn-component of xn+y argument ([+-]?\d*n|)
4026				5 sign of xn-component
4027				6 x of xn-component
4028				7 sign of y-component
4029				8 y of y-component
4030			*/
4031			match[1] = match[1].toLowerCase();
4032
4033			if ( match[1].slice( 0, 3 ) === "nth" ) {
4034				// nth-* requires argument
4035				if ( !match[3] ) {
4036					Sizzle.error( match[0] );
4037				}
4038
4039				// numeric x and y parameters for Expr.filter.CHILD
4040				// remember that false/true cast respectively to 0/1
4041				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
4042				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
4043
4044			// other types prohibit arguments
4045			} else if ( match[3] ) {
4046				Sizzle.error( match[0] );
4047			}
4048
4049			return match;
4050		},
4051
4052		"PSEUDO": function( match ) {
4053			var excess,
4054				unquoted = !match[6] && match[2];
4055
4056			if ( matchExpr["CHILD"].test( match[0] ) ) {
4057				return null;
4058			}
4059
4060			// Accept quoted arguments as-is
4061			if ( match[3] ) {
4062				match[2] = match[4] || match[5] || "";
4063
4064			// Strip excess characters from unquoted arguments
4065			} else if ( unquoted && rpseudo.test( unquoted ) &&
4066				// Get excess from tokenize (recursively)
4067				(excess = tokenize( unquoted, true )) &&
4068				// advance to the next closing parenthesis
4069				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
4070
4071				// excess is a negative index
4072				match[0] = match[0].slice( 0, excess );
4073				match[2] = unquoted.slice( 0, excess );
4074			}
4075
4076			// Return only captures needed by the pseudo filter method (type and argument)
4077			return match.slice( 0, 3 );
4078		}
4079	},
4080
4081	filter: {
4082
4083		"TAG": function( nodeNameSelector ) {
4084			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
4085			return nodeNameSelector === "*" ?
4086				function() { return true; } :
4087				function( elem ) {
4088					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
4089				};
4090		},
4091
4092		"CLASS": function( className ) {
4093			var pattern = classCache[ className + " " ];
4094
4095			return pattern ||
4096				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
4097				classCache( className, function( elem ) {
4098					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
4099				});
4100		},
4101
4102		"ATTR": function( name, operator, check ) {
4103			return function( elem ) {
4104				var result = Sizzle.attr( elem, name );
4105
4106				if ( result == null ) {
4107					return operator === "!=";
4108				}
4109				if ( !operator ) {
4110					return true;
4111				}
4112
4113				result += "";
4114
4115				return operator === "=" ? result === check :
4116					operator === "!=" ? result !== check :
4117					operator === "^=" ? check && result.indexOf( check ) === 0 :
4118					operator === "*=" ? check && result.indexOf( check ) > -1 :
4119					operator === "$=" ? check && result.slice( -check.length ) === check :
4120					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
4121					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
4122					false;
4123			};
4124		},
4125
4126		"CHILD": function( type, what, argument, first, last ) {
4127			var simple = type.slice( 0, 3 ) !== "nth",
4128				forward = type.slice( -4 ) !== "last",
4129				ofType = what === "of-type";
4130
4131			return first === 1 && last === 0 ?
4132
4133				// Shortcut for :nth-*(n)
4134				function( elem ) {
4135					return !!elem.parentNode;
4136				} :
4137
4138				function( elem, context, xml ) {
4139					var cache, uniqueCache, outerCache, node, nodeIndex, start,
4140						dir = simple !== forward ? "nextSibling" : "previousSibling",
4141						parent = elem.parentNode,
4142						name = ofType && elem.nodeName.toLowerCase(),
4143						useCache = !xml && !ofType,
4144						diff = false;
4145
4146					if ( parent ) {
4147
4148						// :(first|last|only)-(child|of-type)
4149						if ( simple ) {
4150							while ( dir ) {
4151								node = elem;
4152								while ( (node = node[ dir ]) ) {
4153									if ( ofType ?
4154										node.nodeName.toLowerCase() === name :
4155										node.nodeType === 1 ) {
4156
4157										return false;
4158									}
4159								}
4160								// Reverse direction for :only-* (if we haven't yet done so)
4161								start = dir = type === "only" && !start && "nextSibling";
4162							}
4163							return true;
4164						}
4165
4166						start = [ forward ? parent.firstChild : parent.lastChild ];
4167
4168						// non-xml :nth-child(...) stores cache data on `parent`
4169						if ( forward && useCache ) {
4170
4171							// Seek `elem` from a previously-cached index
4172
4173							// ...in a gzip-friendly way
4174							node = parent;
4175							outerCache = node[ expando ] || (node[ expando ] = {});
4176
4177							// Support: IE <9 only
4178							// Defend against cloned attroperties (jQuery gh-1709)
4179							uniqueCache = outerCache[ node.uniqueID ] ||
4180								(outerCache[ node.uniqueID ] = {});
4181
4182							cache = uniqueCache[ type ] || [];
4183							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
4184							diff = nodeIndex && cache[ 2 ];
4185							node = nodeIndex && parent.childNodes[ nodeIndex ];
4186
4187							while ( (node = ++nodeIndex && node && node[ dir ] ||
4188
4189								// Fallback to seeking `elem` from the start
4190								(diff = nodeIndex = 0) || start.pop()) ) {
4191
4192								// When found, cache indexes on `parent` and break
4193								if ( node.nodeType === 1 && ++diff && node === elem ) {
4194									uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
4195									break;
4196								}
4197							}
4198
4199						} else {
4200							// Use previously-cached element index if available
4201							if ( useCache ) {
4202								// ...in a gzip-friendly way
4203								node = elem;
4204								outerCache = node[ expando ] || (node[ expando ] = {});
4205
4206								// Support: IE <9 only
4207								// Defend against cloned attroperties (jQuery gh-1709)
4208								uniqueCache = outerCache[ node.uniqueID ] ||
4209									(outerCache[ node.uniqueID ] = {});
4210
4211								cache = uniqueCache[ type ] || [];
4212								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
4213								diff = nodeIndex;
4214							}
4215
4216							// xml :nth-child(...)
4217							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
4218							if ( diff === false ) {
4219								// Use the same loop as above to seek `elem` from the start
4220								while ( (node = ++nodeIndex && node && node[ dir ] ||
4221									(diff = nodeIndex = 0) || start.pop()) ) {
4222
4223									if ( ( ofType ?
4224										node.nodeName.toLowerCase() === name :
4225										node.nodeType === 1 ) &&
4226										++diff ) {
4227
4228										// Cache the index of each encountered element
4229										if ( useCache ) {
4230											outerCache = node[ expando ] || (node[ expando ] = {});
4231
4232											// Support: IE <9 only
4233											// Defend against cloned attroperties (jQuery gh-1709)
4234											uniqueCache = outerCache[ node.uniqueID ] ||
4235												(outerCache[ node.uniqueID ] = {});
4236
4237											uniqueCache[ type ] = [ dirruns, diff ];
4238										}
4239
4240										if ( node === elem ) {
4241											break;
4242										}
4243									}
4244								}
4245							}
4246						}
4247
4248						// Incorporate the offset, then check against cycle size
4249						diff -= last;
4250						return diff === first || ( diff % first === 0 && diff / first >= 0 );
4251					}
4252				};
4253		},
4254
4255		"PSEUDO": function( pseudo, argument ) {
4256			// pseudo-class names are case-insensitive
4257			// http://www.w3.org/TR/selectors/#pseudo-classes
4258			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
4259			// Remember that setFilters inherits from pseudos
4260			var args,
4261				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
4262					Sizzle.error( "unsupported pseudo: " + pseudo );
4263
4264			// The user may use createPseudo to indicate that
4265			// arguments are needed to create the filter function
4266			// just as Sizzle does
4267			if ( fn[ expando ] ) {
4268				return fn( argument );
4269			}
4270
4271			// But maintain support for old signatures
4272			if ( fn.length > 1 ) {
4273				args = [ pseudo, pseudo, "", argument ];
4274				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
4275					markFunction(function( seed, matches ) {
4276						var idx,
4277							matched = fn( seed, argument ),
4278							i = matched.length;
4279						while ( i-- ) {
4280							idx = indexOf( seed, matched[i] );
4281							seed[ idx ] = !( matches[ idx ] = matched[i] );
4282						}
4283					}) :
4284					function( elem ) {
4285						return fn( elem, 0, args );
4286					};
4287			}
4288
4289			return fn;
4290		}
4291	},
4292
4293	pseudos: {
4294		// Potentially complex pseudos
4295		"not": markFunction(function( selector ) {
4296			// Trim the selector passed to compile
4297			// to avoid treating leading and trailing
4298			// spaces as combinators
4299			var input = [],
4300				results = [],
4301				matcher = compile( selector.replace( rtrim, "$1" ) );
4302
4303			return matcher[ expando ] ?
4304				markFunction(function( seed, matches, context, xml ) {
4305					var elem,
4306						unmatched = matcher( seed, null, xml, [] ),
4307						i = seed.length;
4308
4309					// Match elements unmatched by `matcher`
4310					while ( i-- ) {
4311						if ( (elem = unmatched[i]) ) {
4312							seed[i] = !(matches[i] = elem);
4313						}
4314					}
4315				}) :
4316				function( elem, context, xml ) {
4317					input[0] = elem;
4318					matcher( input, null, xml, results );
4319					// Don't keep the element (issue #299)
4320					input[0] = null;
4321					return !results.pop();
4322				};
4323		}),
4324
4325		"has": markFunction(function( selector ) {
4326			return function( elem ) {
4327				return Sizzle( selector, elem ).length > 0;
4328			};
4329		}),
4330
4331		"contains": markFunction(function( text ) {
4332			text = text.replace( runescape, funescape );
4333			return function( elem ) {
4334				return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;
4335			};
4336		}),
4337
4338		// "Whether an element is represented by a :lang() selector
4339		// is based solely on the element's language value
4340		// being equal to the identifier C,
4341		// or beginning with the identifier C immediately followed by "-".
4342		// The matching of C against the element's language value is performed case-insensitively.
4343		// The identifier C does not have to be a valid language name."
4344		// http://www.w3.org/TR/selectors/#lang-pseudo
4345		"lang": markFunction( function( lang ) {
4346			// lang value must be a valid identifier
4347			if ( !ridentifier.test(lang || "") ) {
4348				Sizzle.error( "unsupported lang: " + lang );
4349			}
4350			lang = lang.replace( runescape, funescape ).toLowerCase();
4351			return function( elem ) {
4352				var elemLang;
4353				do {
4354					if ( (elemLang = documentIsHTML ?
4355						elem.lang :
4356						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
4357
4358						elemLang = elemLang.toLowerCase();
4359						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
4360					}
4361				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
4362				return false;
4363			};
4364		}),
4365
4366		// Miscellaneous
4367		"target": function( elem ) {
4368			var hash = window.location && window.location.hash;
4369			return hash && hash.slice( 1 ) === elem.id;
4370		},
4371
4372		"root": function( elem ) {
4373			return elem === docElem;
4374		},
4375
4376		"focus": function( elem ) {
4377			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
4378		},
4379
4380		// Boolean properties
4381		"enabled": createDisabledPseudo( false ),
4382		"disabled": createDisabledPseudo( true ),
4383
4384		"checked": function( elem ) {
4385			// In CSS3, :checked should return both checked and selected elements
4386			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
4387			var nodeName = elem.nodeName.toLowerCase();
4388			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
4389		},
4390
4391		"selected": function( elem ) {
4392			// Accessing this property makes selected-by-default
4393			// options in Safari work properly
4394			if ( elem.parentNode ) {
4395				elem.parentNode.selectedIndex;
4396			}
4397
4398			return elem.selected === true;
4399		},
4400
4401		// Contents
4402		"empty": function( elem ) {
4403			// http://www.w3.org/TR/selectors/#empty-pseudo
4404			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
4405			//   but not by others (comment: 8; processing instruction: 7; etc.)
4406			// nodeType < 6 works because attributes (2) do not appear as children
4407			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
4408				if ( elem.nodeType < 6 ) {
4409					return false;
4410				}
4411			}
4412			return true;
4413		},
4414
4415		"parent": function( elem ) {
4416			return !Expr.pseudos["empty"]( elem );
4417		},
4418
4419		// Element/input types
4420		"header": function( elem ) {
4421			return rheader.test( elem.nodeName );
4422		},
4423
4424		"input": function( elem ) {
4425			return rinputs.test( elem.nodeName );
4426		},
4427
4428		"button": function( elem ) {
4429			var name = elem.nodeName.toLowerCase();
4430			return name === "input" && elem.type === "button" || name === "button";
4431		},
4432
4433		"text": function( elem ) {
4434			var attr;
4435			return elem.nodeName.toLowerCase() === "input" &&
4436				elem.type === "text" &&
4437
4438				// Support: IE<8
4439				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
4440				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
4441		},
4442
4443		// Position-in-collection
4444		"first": createPositionalPseudo(function() {
4445			return [ 0 ];
4446		}),
4447
4448		"last": createPositionalPseudo(function( matchIndexes, length ) {
4449			return [ length - 1 ];
4450		}),
4451
4452		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
4453			return [ argument < 0 ? argument + length : argument ];
4454		}),
4455
4456		"even": createPositionalPseudo(function( matchIndexes, length ) {
4457			var i = 0;
4458			for ( ; i < length; i += 2 ) {
4459				matchIndexes.push( i );
4460			}
4461			return matchIndexes;
4462		}),
4463
4464		"odd": createPositionalPseudo(function( matchIndexes, length ) {
4465			var i = 1;
4466			for ( ; i < length; i += 2 ) {
4467				matchIndexes.push( i );
4468			}
4469			return matchIndexes;
4470		}),
4471
4472		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
4473			var i = argument < 0 ?
4474				argument + length :
4475				argument > length ?
4476					length :
4477					argument;
4478			for ( ; --i >= 0; ) {
4479				matchIndexes.push( i );
4480			}
4481			return matchIndexes;
4482		}),
4483
4484		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
4485			var i = argument < 0 ? argument + length : argument;
4486			for ( ; ++i < length; ) {
4487				matchIndexes.push( i );
4488			}
4489			return matchIndexes;
4490		})
4491	}
4492};
4493
4494Expr.pseudos["nth"] = Expr.pseudos["eq"];
4495
4496// Add button/input type pseudos
4497for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
4498	Expr.pseudos[ i ] = createInputPseudo( i );
4499}
4500for ( i in { submit: true, reset: true } ) {
4501	Expr.pseudos[ i ] = createButtonPseudo( i );
4502}
4503
4504// Easy API for creating new setFilters
4505function setFilters() {}
4506setFilters.prototype = Expr.filters = Expr.pseudos;
4507Expr.setFilters = new setFilters();
4508
4509tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
4510	var matched, match, tokens, type,
4511		soFar, groups, preFilters,
4512		cached = tokenCache[ selector + " " ];
4513
4514	if ( cached ) {
4515		return parseOnly ? 0 : cached.slice( 0 );
4516	}
4517
4518	soFar = selector;
4519	groups = [];
4520	preFilters = Expr.preFilter;
4521
4522	while ( soFar ) {
4523
4524		// Comma and first run
4525		if ( !matched || (match = rcomma.exec( soFar )) ) {
4526			if ( match ) {
4527				// Don't consume trailing commas as valid
4528				soFar = soFar.slice( match[0].length ) || soFar;
4529			}
4530			groups.push( (tokens = []) );
4531		}
4532
4533		matched = false;
4534
4535		// Combinators
4536		if ( (match = rcombinators.exec( soFar )) ) {
4537			matched = match.shift();
4538			tokens.push({
4539				value: matched,
4540				// Cast descendant combinators to space
4541				type: match[0].replace( rtrim, " " )
4542			});
4543			soFar = soFar.slice( matched.length );
4544		}
4545
4546		// Filters
4547		for ( type in Expr.filter ) {
4548			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
4549				(match = preFilters[ type ]( match ))) ) {
4550				matched = match.shift();
4551				tokens.push({
4552					value: matched,
4553					type: type,
4554					matches: match
4555				});
4556				soFar = soFar.slice( matched.length );
4557			}
4558		}
4559
4560		if ( !matched ) {
4561			break;
4562		}
4563	}
4564
4565	// Return the length of the invalid excess
4566	// if we're just parsing
4567	// Otherwise, throw an error or return tokens
4568	return parseOnly ?
4569		soFar.length :
4570		soFar ?
4571			Sizzle.error( selector ) :
4572			// Cache the tokens
4573			tokenCache( selector, groups ).slice( 0 );
4574};
4575
4576function toSelector( tokens ) {
4577	var i = 0,
4578		len = tokens.length,
4579		selector = "";
4580	for ( ; i < len; i++ ) {
4581		selector += tokens[i].value;
4582	}
4583	return selector;
4584}
4585
4586function addCombinator( matcher, combinator, base ) {
4587	var dir = combinator.dir,
4588		skip = combinator.next,
4589		key = skip || dir,
4590		checkNonElements = base && key === "parentNode",
4591		doneName = done++;
4592
4593	return combinator.first ?
4594		// Check against closest ancestor/preceding element
4595		function( elem, context, xml ) {
4596			while ( (elem = elem[ dir ]) ) {
4597				if ( elem.nodeType === 1 || checkNonElements ) {
4598					return matcher( elem, context, xml );
4599				}
4600			}
4601			return false;
4602		} :
4603
4604		// Check against all ancestor/preceding elements
4605		function( elem, context, xml ) {
4606			var oldCache, uniqueCache, outerCache,
4607				newCache = [ dirruns, doneName ];
4608
4609			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
4610			if ( xml ) {
4611				while ( (elem = elem[ dir ]) ) {
4612					if ( elem.nodeType === 1 || checkNonElements ) {
4613						if ( matcher( elem, context, xml ) ) {
4614							return true;
4615						}
4616					}
4617				}
4618			} else {
4619				while ( (elem = elem[ dir ]) ) {
4620					if ( elem.nodeType === 1 || checkNonElements ) {
4621						outerCache = elem[ expando ] || (elem[ expando ] = {});
4622
4623						// Support: IE <9 only
4624						// Defend against cloned attroperties (jQuery gh-1709)
4625						uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});
4626
4627						if ( skip && skip === elem.nodeName.toLowerCase() ) {
4628							elem = elem[ dir ] || elem;
4629						} else if ( (oldCache = uniqueCache[ key ]) &&
4630							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
4631
4632							// Assign to newCache so results back-propagate to previous elements
4633							return (newCache[ 2 ] = oldCache[ 2 ]);
4634						} else {
4635							// Reuse newcache so results back-propagate to previous elements
4636							uniqueCache[ key ] = newCache;
4637
4638							// A match means we're done; a fail means we have to keep checking
4639							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
4640								return true;
4641							}
4642						}
4643					}
4644				}
4645			}
4646			return false;
4647		};
4648}
4649
4650function elementMatcher( matchers ) {
4651	return matchers.length > 1 ?
4652		function( elem, context, xml ) {
4653			var i = matchers.length;
4654			while ( i-- ) {
4655				if ( !matchers[i]( elem, context, xml ) ) {
4656					return false;
4657				}
4658			}
4659			return true;
4660		} :
4661		matchers[0];
4662}
4663
4664function multipleContexts( selector, contexts, results ) {
4665	var i = 0,
4666		len = contexts.length;
4667	for ( ; i < len; i++ ) {
4668		Sizzle( selector, contexts[i], results );
4669	}
4670	return results;
4671}
4672
4673function condense( unmatched, map, filter, context, xml ) {
4674	var elem,
4675		newUnmatched = [],
4676		i = 0,
4677		len = unmatched.length,
4678		mapped = map != null;
4679
4680	for ( ; i < len; i++ ) {
4681		if ( (elem = unmatched[i]) ) {
4682			if ( !filter || filter( elem, context, xml ) ) {
4683				newUnmatched.push( elem );
4684				if ( mapped ) {
4685					map.push( i );
4686				}
4687			}
4688		}
4689	}
4690
4691	return newUnmatched;
4692}
4693
4694function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
4695	if ( postFilter && !postFilter[ expando ] ) {
4696		postFilter = setMatcher( postFilter );
4697	}
4698	if ( postFinder && !postFinder[ expando ] ) {
4699		postFinder = setMatcher( postFinder, postSelector );
4700	}
4701	return markFunction(function( seed, results, context, xml ) {
4702		var temp, i, elem,
4703			preMap = [],
4704			postMap = [],
4705			preexisting = results.length,
4706
4707			// Get initial elements from seed or context
4708			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
4709
4710			// Prefilter to get matcher input, preserving a map for seed-results synchronization
4711			matcherIn = preFilter && ( seed || !selector ) ?
4712				condense( elems, preMap, preFilter, context, xml ) :
4713				elems,
4714
4715			matcherOut = matcher ?
4716				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
4717				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
4718
4719					// ...intermediate processing is necessary
4720					[] :
4721
4722					// ...otherwise use results directly
4723					results :
4724				matcherIn;
4725
4726		// Find primary matches
4727		if ( matcher ) {
4728			matcher( matcherIn, matcherOut, context, xml );
4729		}
4730
4731		// Apply postFilter
4732		if ( postFilter ) {
4733			temp = condense( matcherOut, postMap );
4734			postFilter( temp, [], context, xml );
4735
4736			// Un-match failing elements by moving them back to matcherIn
4737			i = temp.length;
4738			while ( i-- ) {
4739				if ( (elem = temp[i]) ) {
4740					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
4741				}
4742			}
4743		}
4744
4745		if ( seed ) {
4746			if ( postFinder || preFilter ) {
4747				if ( postFinder ) {
4748					// Get the final matcherOut by condensing this intermediate into postFinder contexts
4749					temp = [];
4750					i = matcherOut.length;
4751					while ( i-- ) {
4752						if ( (elem = matcherOut[i]) ) {
4753							// Restore matcherIn since elem is not yet a final match
4754							temp.push( (matcherIn[i] = elem) );
4755						}
4756					}
4757					postFinder( null, (matcherOut = []), temp, xml );
4758				}
4759
4760				// Move matched elements from seed to results to keep them synchronized
4761				i = matcherOut.length;
4762				while ( i-- ) {
4763					if ( (elem = matcherOut[i]) &&
4764						(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
4765
4766						seed[temp] = !(results[temp] = elem);
4767					}
4768				}
4769			}
4770
4771		// Add elements to results, through postFinder if defined
4772		} else {
4773			matcherOut = condense(
4774				matcherOut === results ?
4775					matcherOut.splice( preexisting, matcherOut.length ) :
4776					matcherOut
4777			);
4778			if ( postFinder ) {
4779				postFinder( null, results, matcherOut, xml );
4780			} else {
4781				push.apply( results, matcherOut );
4782			}
4783		}
4784	});
4785}
4786
4787function matcherFromTokens( tokens ) {
4788	var checkContext, matcher, j,
4789		len = tokens.length,
4790		leadingRelative = Expr.relative[ tokens[0].type ],
4791		implicitRelative = leadingRelative || Expr.relative[" "],
4792		i = leadingRelative ? 1 : 0,
4793
4794		// The foundational matcher ensures that elements are reachable from top-level context(s)
4795		matchContext = addCombinator( function( elem ) {
4796			return elem === checkContext;
4797		}, implicitRelative, true ),
4798		matchAnyContext = addCombinator( function( elem ) {
4799			return indexOf( checkContext, elem ) > -1;
4800		}, implicitRelative, true ),
4801		matchers = [ function( elem, context, xml ) {
4802			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
4803				(checkContext = context).nodeType ?
4804					matchContext( elem, context, xml ) :
4805					matchAnyContext( elem, context, xml ) );
4806			// Avoid hanging onto element (issue #299)
4807			checkContext = null;
4808			return ret;
4809		} ];
4810
4811	for ( ; i < len; i++ ) {
4812		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
4813			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
4814		} else {
4815			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
4816
4817			// Return special upon seeing a positional matcher
4818			if ( matcher[ expando ] ) {
4819				// Find the next relative operator (if any) for proper handling
4820				j = ++i;
4821				for ( ; j < len; j++ ) {
4822					if ( Expr.relative[ tokens[j].type ] ) {
4823						break;
4824					}
4825				}
4826				return setMatcher(
4827					i > 1 && elementMatcher( matchers ),
4828					i > 1 && toSelector(
4829						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
4830						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
4831					).replace( rtrim, "$1" ),
4832					matcher,
4833					i < j && matcherFromTokens( tokens.slice( i, j ) ),
4834					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
4835					j < len && toSelector( tokens )
4836				);
4837			}
4838			matchers.push( matcher );
4839		}
4840	}
4841
4842	return elementMatcher( matchers );
4843}
4844
4845function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
4846	var bySet = setMatchers.length > 0,
4847		byElement = elementMatchers.length > 0,
4848		superMatcher = function( seed, context, xml, results, outermost ) {
4849			var elem, j, matcher,
4850				matchedCount = 0,
4851				i = "0",
4852				unmatched = seed && [],
4853				setMatched = [],
4854				contextBackup = outermostContext,
4855				// We must always have either seed elements or outermost context
4856				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
4857				// Use integer dirruns iff this is the outermost matcher
4858				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
4859				len = elems.length;
4860
4861			if ( outermost ) {
4862				outermostContext = context === document || context || outermost;
4863			}
4864
4865			// Add elements passing elementMatchers directly to results
4866			// Support: IE<9, Safari
4867			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
4868			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
4869				if ( byElement && elem ) {
4870					j = 0;
4871					if ( !context && elem.ownerDocument !== document ) {
4872						setDocument( elem );
4873						xml = !documentIsHTML;
4874					}
4875					while ( (matcher = elementMatchers[j++]) ) {
4876						if ( matcher( elem, context || document, xml) ) {
4877							results.push( elem );
4878							break;
4879						}
4880					}
4881					if ( outermost ) {
4882						dirruns = dirrunsUnique;
4883					}
4884				}
4885
4886				// Track unmatched elements for set filters
4887				if ( bySet ) {
4888					// They will have gone through all possible matchers
4889					if ( (elem = !matcher && elem) ) {
4890						matchedCount--;
4891					}
4892
4893					// Lengthen the array for every element, matched or not
4894					if ( seed ) {
4895						unmatched.push( elem );
4896					}
4897				}
4898			}
4899
4900			// `i` is now the count of elements visited above, and adding it to `matchedCount`
4901			// makes the latter nonnegative.
4902			matchedCount += i;
4903
4904			// Apply set filters to unmatched elements
4905			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
4906			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
4907			// no element matchers and no seed.
4908			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
4909			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
4910			// numerically zero.
4911			if ( bySet && i !== matchedCount ) {
4912				j = 0;
4913				while ( (matcher = setMatchers[j++]) ) {
4914					matcher( unmatched, setMatched, context, xml );
4915				}
4916
4917				if ( seed ) {
4918					// Reintegrate element matches to eliminate the need for sorting
4919					if ( matchedCount > 0 ) {
4920						while ( i-- ) {
4921							if ( !(unmatched[i] || setMatched[i]) ) {
4922								setMatched[i] = pop.call( results );
4923							}
4924						}
4925					}
4926
4927					// Discard index placeholder values to get only actual matches
4928					setMatched = condense( setMatched );
4929				}
4930
4931				// Add matches to results
4932				push.apply( results, setMatched );
4933
4934				// Seedless set matches succeeding multiple successful matchers stipulate sorting
4935				if ( outermost && !seed && setMatched.length > 0 &&
4936					( matchedCount + setMatchers.length ) > 1 ) {
4937
4938					Sizzle.uniqueSort( results );
4939				}
4940			}
4941
4942			// Override manipulation of globals by nested matchers
4943			if ( outermost ) {
4944				dirruns = dirrunsUnique;
4945				outermostContext = contextBackup;
4946			}
4947
4948			return unmatched;
4949		};
4950
4951	return bySet ?
4952		markFunction( superMatcher ) :
4953		superMatcher;
4954}
4955
4956compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
4957	var i,
4958		setMatchers = [],
4959		elementMatchers = [],
4960		cached = compilerCache[ selector + " " ];
4961
4962	if ( !cached ) {
4963		// Generate a function of recursive functions that can be used to check each element
4964		if ( !match ) {
4965			match = tokenize( selector );
4966		}
4967		i = match.length;
4968		while ( i-- ) {
4969			cached = matcherFromTokens( match[i] );
4970			if ( cached[ expando ] ) {
4971				setMatchers.push( cached );
4972			} else {
4973				elementMatchers.push( cached );
4974			}
4975		}
4976
4977		// Cache the compiled function
4978		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
4979
4980		// Save selector and tokenization
4981		cached.selector = selector;
4982	}
4983	return cached;
4984};
4985
4986/**
4987 * A low-level selection function that works with Sizzle's compiled
4988 *  selector functions
4989 * @param {String|Function} selector A selector or a pre-compiled
4990 *  selector function built with Sizzle.compile
4991 * @param {Element} context
4992 * @param {Array} [results]
4993 * @param {Array} [seed] A set of elements to match against
4994 */
4995select = Sizzle.select = function( selector, context, results, seed ) {
4996	var i, tokens, token, type, find,
4997		compiled = typeof selector === "function" && selector,
4998		match = !seed && tokenize( (selector = compiled.selector || selector) );
4999
5000	results = results || [];
5001
5002	// Try to minimize operations if there is only one selector in the list and no seed
5003	// (the latter of which guarantees us context)
5004	if ( match.length === 1 ) {
5005
5006		// Reduce context if the leading compound selector is an ID
5007		tokens = match[0] = match[0].slice( 0 );
5008		if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
5009				context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {
5010
5011			context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
5012			if ( !context ) {
5013				return results;
5014
5015			// Precompiled matchers will still verify ancestry, so step up a level
5016			} else if ( compiled ) {
5017				context = context.parentNode;
5018			}
5019
5020			selector = selector.slice( tokens.shift().value.length );
5021		}
5022
5023		// Fetch a seed set for right-to-left matching
5024		i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
5025		while ( i-- ) {
5026			token = tokens[i];
5027
5028			// Abort if we hit a combinator
5029			if ( Expr.relative[ (type = token.type) ] ) {
5030				break;
5031			}
5032			if ( (find = Expr.find[ type ]) ) {
5033				// Search, expanding context for leading sibling combinators
5034				if ( (seed = find(
5035					token.matches[0].replace( runescape, funescape ),
5036					rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
5037				)) ) {
5038
5039					// If seed is empty or no tokens remain, we can return early
5040					tokens.splice( i, 1 );
5041					selector = seed.length && toSelector( tokens );
5042					if ( !selector ) {
5043						push.apply( results, seed );
5044						return results;
5045					}
5046
5047					break;
5048				}
5049			}
5050		}
5051	}
5052
5053	// Compile and execute a filtering function if one is not provided
5054	// Provide `match` to avoid retokenization if we modified the selector above
5055	( compiled || compile( selector, match ) )(
5056		seed,
5057		context,
5058		!documentIsHTML,
5059		results,
5060		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
5061	);
5062	return results;
5063};
5064
5065// One-time assignments
5066
5067// Sort stability
5068support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
5069
5070// Support: Chrome 14-35+
5071// Always assume duplicates if they aren't passed to the comparison function
5072support.detectDuplicates = !!hasDuplicate;
5073
5074// Initialize against the default document
5075setDocument();
5076
5077// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
5078// Detached nodes confoundingly follow *each other*
5079support.sortDetached = assert(function( el ) {
5080	// Should return 1, but returns 4 (following)
5081	return el.compareDocumentPosition( document.createElement("fieldset") ) & 1;
5082});
5083
5084// Support: IE<8
5085// Prevent attribute/property "interpolation"
5086// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
5087if ( !assert(function( el ) {
5088	el.innerHTML = "<a href='#'></a>";
5089	return el.firstChild.getAttribute("href") === "#" ;
5090}) ) {
5091	addHandle( "type|href|height|width", function( elem, name, isXML ) {
5092		if ( !isXML ) {
5093			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
5094		}
5095	});
5096}
5097
5098// Support: IE<9
5099// Use defaultValue in place of getAttribute("value")
5100if ( !support.attributes || !assert(function( el ) {
5101	el.innerHTML = "<input/>";
5102	el.firstChild.setAttribute( "value", "" );
5103	return el.firstChild.getAttribute( "value" ) === "";
5104}) ) {
5105	addHandle( "value", function( elem, name, isXML ) {
5106		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
5107			return elem.defaultValue;
5108		}
5109	});
5110}
5111
5112// Support: IE<9
5113// Use getAttributeNode to fetch booleans when getAttribute lies
5114if ( !assert(function( el ) {
5115	return el.getAttribute("disabled") == null;
5116}) ) {
5117	addHandle( booleans, function( elem, name, isXML ) {
5118		var val;
5119		if ( !isXML ) {
5120			return elem[ name ] === true ? name.toLowerCase() :
5121					(val = elem.getAttributeNode( name )) && val.specified ?
5122					val.value :
5123				null;
5124		}
5125	});
5126}
5127
5128return Sizzle;
5129
5130})( window );
5131
5132
5133
5134jQuery.find = Sizzle;
5135jQuery.expr = Sizzle.selectors;
5136
5137// Deprecated
5138jQuery.expr[ ":" ] = jQuery.expr.pseudos;
5139jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
5140jQuery.text = Sizzle.getText;
5141jQuery.isXMLDoc = Sizzle.isXML;
5142jQuery.contains = Sizzle.contains;
5143jQuery.escapeSelector = Sizzle.escape;
5144
5145
5146
5147
5148var dir = function( elem, dir, until ) {
5149	var matched = [],
5150		truncate = until !== undefined;
5151
5152	while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
5153		if ( elem.nodeType === 1 ) {
5154			if ( truncate && jQuery( elem ).is( until ) ) {
5155				break;
5156			}
5157			matched.push( elem );
5158		}
5159	}
5160	return matched;
5161};
5162
5163
5164var siblings = function( n, elem ) {
5165	var matched = [];
5166
5167	for ( ; n; n = n.nextSibling ) {
5168		if ( n.nodeType === 1 && n !== elem ) {
5169			matched.push( n );
5170		}
5171	}
5172
5173	return matched;
5174};
5175
5176
5177var rneedsContext = jQuery.expr.match.needsContext;
5178
5179
5180
5181function nodeName( elem, name ) {
5182
5183  return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
5184
5185};
5186var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
5187
5188
5189
5190// Implement the identical functionality for filter and not
5191function winnow( elements, qualifier, not ) {
5192	if ( isFunction( qualifier ) ) {
5193		return jQuery.grep( elements, function( elem, i ) {
5194			return !!qualifier.call( elem, i, elem ) !== not;
5195		} );
5196	}
5197
5198	// Single element
5199	if ( qualifier.nodeType ) {
5200		return jQuery.grep( elements, function( elem ) {
5201			return ( elem === qualifier ) !== not;
5202		} );
5203	}
5204
5205	// Arraylike of elements (jQuery, arguments, Array)
5206	if ( typeof qualifier !== "string" ) {
5207		return jQuery.grep( elements, function( elem ) {
5208			return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
5209		} );
5210	}
5211
5212	// Filtered directly for both simple and complex selectors
5213	return jQuery.filter( qualifier, elements, not );
5214}
5215
5216jQuery.filter = function( expr, elems, not ) {
5217	var elem = elems[ 0 ];
5218
5219	if ( not ) {
5220		expr = ":not(" + expr + ")";
5221	}
5222
5223	if ( elems.length === 1 && elem.nodeType === 1 ) {
5224		return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
5225	}
5226
5227	return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
5228		return elem.nodeType === 1;
5229	} ) );
5230};
5231
5232jQuery.fn.extend( {
5233	find: function( selector ) {
5234		var i, ret,
5235			len = this.length,
5236			self = this;
5237
5238		if ( typeof selector !== "string" ) {
5239			return this.pushStack( jQuery( selector ).filter( function() {
5240				for ( i = 0; i < len; i++ ) {
5241					if ( jQuery.contains( self[ i ], this ) ) {
5242						return true;
5243					}
5244				}
5245			} ) );
5246		}
5247
5248		ret = this.pushStack( [] );
5249
5250		for ( i = 0; i < len; i++ ) {
5251			jQuery.find( selector, self[ i ], ret );
5252		}
5253
5254		return len > 1 ? jQuery.uniqueSort( ret ) : ret;
5255	},
5256	filter: function( selector ) {
5257		return this.pushStack( winnow( this, selector || [], false ) );
5258	},
5259	not: function( selector ) {
5260		return this.pushStack( winnow( this, selector || [], true ) );
5261	},
5262	is: function( selector ) {
5263		return !!winnow(
5264			this,
5265
5266			// If this is a positional/relative selector, check membership in the returned set
5267			// so $("p:first").is("p:last") won't return true for a doc with two "p".
5268			typeof selector === "string" && rneedsContext.test( selector ) ?
5269				jQuery( selector ) :
5270				selector || [],
5271			false
5272		).length;
5273	}
5274} );
5275
5276
5277// Initialize a jQuery object
5278
5279
5280// A central reference to the root jQuery(document)
5281var rootjQuery,
5282
5283	// A simple way to check for HTML strings
5284	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
5285	// Strict HTML recognition (#11290: must start with <)
5286	// Shortcut simple #id case for speed
5287	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
5288
5289	init = jQuery.fn.init = function( selector, context, root ) {
5290		var match, elem;
5291
5292		// HANDLE: $(""), $(null), $(undefined), $(false)
5293		if ( !selector ) {
5294			return this;
5295		}
5296
5297		// Method init() accepts an alternate rootjQuery
5298		// so migrate can support jQuery.sub (gh-2101)
5299		root = root || rootjQuery;
5300
5301		// Handle HTML strings
5302		if ( typeof selector === "string" ) {
5303			if ( selector[ 0 ] === "<" &&
5304				selector[ selector.length - 1 ] === ">" &&
5305				selector.length >= 3 ) {
5306
5307				// Assume that strings that start and end with <> are HTML and skip the regex check
5308				match = [ null, selector, null ];
5309
5310			} else {
5311				match = rquickExpr.exec( selector );
5312			}
5313
5314			// Match html or make sure no context is specified for #id
5315			if ( match && ( match[ 1 ] || !context ) ) {
5316
5317				// HANDLE: $(html) -> $(array)
5318				if ( match[ 1 ] ) {
5319					context = context instanceof jQuery ? context[ 0 ] : context;
5320
5321					// Option to run scripts is true for back-compat
5322					// Intentionally let the error be thrown if parseHTML is not present
5323					jQuery.merge( this, jQuery.parseHTML(
5324						match[ 1 ],
5325						context && context.nodeType ? context.ownerDocument || context : document,
5326						true
5327					) );
5328
5329					// HANDLE: $(html, props)
5330					if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
5331						for ( match in context ) {
5332
5333							// Properties of context are called as methods if possible
5334							if ( isFunction( this[ match ] ) ) {
5335								this[ match ]( context[ match ] );
5336
5337							// ...and otherwise set as attributes
5338							} else {
5339								this.attr( match, context[ match ] );
5340							}
5341						}
5342					}
5343
5344					return this;
5345
5346				// HANDLE: $(#id)
5347				} else {
5348					elem = document.getElementById( match[ 2 ] );
5349
5350					if ( elem ) {
5351
5352						// Inject the element directly into the jQuery object
5353						this[ 0 ] = elem;
5354						this.length = 1;
5355					}
5356					return this;
5357				}
5358
5359			// HANDLE: $(expr, $(...))
5360			} else if ( !context || context.jquery ) {
5361				return ( context || root ).find( selector );
5362
5363			// HANDLE: $(expr, context)
5364			// (which is just equivalent to: $(context).find(expr)
5365			} else {
5366				return this.constructor( context ).find( selector );
5367			}
5368
5369		// HANDLE: $(DOMElement)
5370		} else if ( selector.nodeType ) {
5371			this[ 0 ] = selector;
5372			this.length = 1;
5373			return this;
5374
5375		// HANDLE: $(function)
5376		// Shortcut for document ready
5377		} else if ( isFunction( selector ) ) {
5378			return root.ready !== undefined ?
5379				root.ready( selector ) :
5380
5381				// Execute immediately if ready is not present
5382				selector( jQuery );
5383		}
5384
5385		return jQuery.makeArray( selector, this );
5386	};
5387
5388// Give the init function the jQuery prototype for later instantiation
5389init.prototype = jQuery.fn;
5390
5391// Initialize central reference
5392rootjQuery = jQuery( document );
5393
5394
5395var rparentsprev = /^(?:parents|prev(?:Until|All))/,
5396
5397	// Methods guaranteed to produce a unique set when starting from a unique set
5398	guaranteedUnique = {
5399		children: true,
5400		contents: true,
5401		next: true,
5402		prev: true
5403	};
5404
5405jQuery.fn.extend( {
5406	has: function( target ) {
5407		var targets = jQuery( target, this ),
5408			l = targets.length;
5409
5410		return this.filter( function() {
5411			var i = 0;
5412			for ( ; i < l; i++ ) {
5413				if ( jQuery.contains( this, targets[ i ] ) ) {
5414					return true;
5415				}
5416			}
5417		} );
5418	},
5419
5420	closest: function( selectors, context ) {
5421		var cur,
5422			i = 0,
5423			l = this.length,
5424			matched = [],
5425			targets = typeof selectors !== "string" && jQuery( selectors );
5426
5427		// Positional selectors never match, since there's no _selection_ context
5428		if ( !rneedsContext.test( selectors ) ) {
5429			for ( ; i < l; i++ ) {
5430				for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
5431
5432					// Always skip document fragments
5433					if ( cur.nodeType < 11 && ( targets ?
5434						targets.index( cur ) > -1 :
5435
5436						// Don't pass non-elements to Sizzle
5437						cur.nodeType === 1 &&
5438							jQuery.find.matchesSelector( cur, selectors ) ) ) {
5439
5440						matched.push( cur );
5441						break;
5442					}
5443				}
5444			}
5445		}
5446
5447		return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
5448	},
5449
5450	// Determine the position of an element within the set
5451	index: function( elem ) {
5452
5453		// No argument, return index in parent
5454		if ( !elem ) {
5455			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
5456		}
5457
5458		// Index in selector
5459		if ( typeof elem === "string" ) {
5460			return indexOf.call( jQuery( elem ), this[ 0 ] );
5461		}
5462
5463		// Locate the position of the desired element
5464		return indexOf.call( this,
5465
5466			// If it receives a jQuery object, the first element is used
5467			elem.jquery ? elem[ 0 ] : elem
5468		);
5469	},
5470
5471	add: function( selector, context ) {
5472		return this.pushStack(
5473			jQuery.uniqueSort(
5474				jQuery.merge( this.get(), jQuery( selector, context ) )
5475			)
5476		);
5477	},
5478
5479	addBack: function( selector ) {
5480		return this.add( selector == null ?
5481			this.prevObject : this.prevObject.filter( selector )
5482		);
5483	}
5484} );
5485
5486function sibling( cur, dir ) {
5487	while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
5488	return cur;
5489}
5490
5491jQuery.each( {
5492	parent: function( elem ) {
5493		var parent = elem.parentNode;
5494		return parent && parent.nodeType !== 11 ? parent : null;
5495	},
5496	parents: function( elem ) {
5497		return dir( elem, "parentNode" );
5498	},
5499	parentsUntil: function( elem, i, until ) {
5500		return dir( elem, "parentNode", until );
5501	},
5502	next: function( elem ) {
5503		return sibling( elem, "nextSibling" );
5504	},
5505	prev: function( elem ) {
5506		return sibling( elem, "previousSibling" );
5507	},
5508	nextAll: function( elem ) {
5509		return dir( elem, "nextSibling" );
5510	},
5511	prevAll: function( elem ) {
5512		return dir( elem, "previousSibling" );
5513	},
5514	nextUntil: function( elem, i, until ) {
5515		return dir( elem, "nextSibling", until );
5516	},
5517	prevUntil: function( elem, i, until ) {
5518		return dir( elem, "previousSibling", until );
5519	},
5520	siblings: function( elem ) {
5521		return siblings( ( elem.parentNode || {} ).firstChild, elem );
5522	},
5523	children: function( elem ) {
5524		return siblings( elem.firstChild );
5525	},
5526	contents: function( elem ) {
5527		if ( typeof elem.contentDocument !== "undefined" ) {
5528			return elem.contentDocument;
5529		}
5530
5531		// Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
5532		// Treat the template element as a regular one in browsers that
5533		// don't support it.
5534		if ( nodeName( elem, "template" ) ) {
5535			elem = elem.content || elem;
5536		}
5537
5538		return jQuery.merge( [], elem.childNodes );
5539	}
5540}, function( name, fn ) {
5541	jQuery.fn[ name ] = function( until, selector ) {
5542		var matched = jQuery.map( this, fn, until );
5543
5544		if ( name.slice( -5 ) !== "Until" ) {
5545			selector = until;
5546		}
5547
5548		if ( selector && typeof selector === "string" ) {
5549			matched = jQuery.filter( selector, matched );
5550		}
5551
5552		if ( this.length > 1 ) {
5553
5554			// Remove duplicates
5555			if ( !guaranteedUnique[ name ] ) {
5556				jQuery.uniqueSort( matched );
5557			}
5558
5559			// Reverse order for parents* and prev-derivatives
5560			if ( rparentsprev.test( name ) ) {
5561				matched.reverse();
5562			}
5563		}
5564
5565		return this.pushStack( matched );
5566	};
5567} );
5568var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
5569
5570
5571
5572// Convert String-formatted options into Object-formatted ones
5573function createOptions( options ) {
5574	var object = {};
5575	jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
5576		object[ flag ] = true;
5577	} );
5578	return object;
5579}
5580
5581/*
5582 * Create a callback list using the following parameters:
5583 *
5584 *	options: an optional list of space-separated options that will change how
5585 *			the callback list behaves or a more traditional option object
5586 *
5587 * By default a callback list will act like an event callback list and can be
5588 * "fired" multiple times.
5589 *
5590 * Possible options:
5591 *
5592 *	once:			will ensure the callback list can only be fired once (like a Deferred)
5593 *
5594 *	memory:			will keep track of previous values and will call any callback added
5595 *					after the list has been fired right away with the latest "memorized"
5596 *					values (like a Deferred)
5597 *
5598 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
5599 *
5600 *	stopOnFalse:	interrupt callings when a callback returns false
5601 *
5602 */
5603jQuery.Callbacks = function( options ) {
5604
5605	// Convert options from String-formatted to Object-formatted if needed
5606	// (we check in cache first)
5607	options = typeof options === "string" ?
5608		createOptions( options ) :
5609		jQuery.extend( {}, options );
5610
5611	var // Flag to know if list is currently firing
5612		firing,
5613
5614		// Last fire value for non-forgettable lists
5615		memory,
5616
5617		// Flag to know if list was already fired
5618		fired,
5619
5620		// Flag to prevent firing
5621		locked,
5622
5623		// Actual callback list
5624		list = [],
5625
5626		// Queue of execution data for repeatable lists
5627		queue = [],
5628
5629		// Index of currently firing callback (modified by add/remove as needed)
5630		firingIndex = -1,
5631
5632		// Fire callbacks
5633		fire = function() {
5634
5635			// Enforce single-firing
5636			locked = locked || options.once;
5637
5638			// Execute callbacks for all pending executions,
5639			// respecting firingIndex overrides and runtime changes
5640			fired = firing = true;
5641			for ( ; queue.length; firingIndex = -1 ) {
5642				memory = queue.shift();
5643				while ( ++firingIndex < list.length ) {
5644
5645					// Run callback and check for early termination
5646					if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
5647						options.stopOnFalse ) {
5648
5649						// Jump to end and forget the data so .add doesn't re-fire
5650						firingIndex = list.length;
5651						memory = false;
5652					}
5653				}
5654			}
5655
5656			// Forget the data if we're done with it
5657			if ( !options.memory ) {
5658				memory = false;
5659			}
5660
5661			firing = false;
5662
5663			// Clean up if we're done firing for good
5664			if ( locked ) {
5665
5666				// Keep an empty list if we have data for future add calls
5667				if ( memory ) {
5668					list = [];
5669
5670				// Otherwise, this object is spent
5671				} else {
5672					list = "";
5673				}
5674			}
5675		},
5676
5677		// Actual Callbacks object
5678		self = {
5679
5680			// Add a callback or a collection of callbacks to the list
5681			add: function() {
5682				if ( list ) {
5683
5684					// If we have memory from a past run, we should fire after adding
5685					if ( memory && !firing ) {
5686						firingIndex = list.length - 1;
5687						queue.push( memory );
5688					}
5689
5690					( function add( args ) {
5691						jQuery.each( args, function( _, arg ) {
5692							if ( isFunction( arg ) ) {
5693								if ( !options.unique || !self.has( arg ) ) {
5694									list.push( arg );
5695								}
5696							} else if ( arg && arg.length && toType( arg ) !== "string" ) {
5697
5698								// Inspect recursively
5699								add( arg );
5700							}
5701						} );
5702					} )( arguments );
5703
5704					if ( memory && !firing ) {
5705						fire();
5706					}
5707				}
5708				return this;
5709			},
5710
5711			// Remove a callback from the list
5712			remove: function() {
5713				jQuery.each( arguments, function( _, arg ) {
5714					var index;
5715					while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
5716						list.splice( index, 1 );
5717
5718						// Handle firing indexes
5719						if ( index <= firingIndex ) {
5720							firingIndex--;
5721						}
5722					}
5723				} );
5724				return this;
5725			},
5726
5727			// Check if a given callback is in the list.
5728			// If no argument is given, return whether or not list has callbacks attached.
5729			has: function( fn ) {
5730				return fn ?
5731					jQuery.inArray( fn, list ) > -1 :
5732					list.length > 0;
5733			},
5734
5735			// Remove all callbacks from the list
5736			empty: function() {
5737				if ( list ) {
5738					list = [];
5739				}
5740				return this;
5741			},
5742
5743			// Disable .fire and .add
5744			// Abort any current/pending executions
5745			// Clear all callbacks and values
5746			disable: function() {
5747				locked = queue = [];
5748				list = memory = "";
5749				return this;
5750			},
5751			disabled: function() {
5752				return !list;
5753			},
5754
5755			// Disable .fire
5756			// Also disable .add unless we have memory (since it would have no effect)
5757			// Abort any pending executions
5758			lock: function() {
5759				locked = queue = [];
5760				if ( !memory && !firing ) {
5761					list = memory = "";
5762				}
5763				return this;
5764			},
5765			locked: function() {
5766				return !!locked;
5767			},
5768
5769			// Call all callbacks with the given context and arguments
5770			fireWith: function( context, args ) {
5771				if ( !locked ) {
5772					args = args || [];
5773					args = [ context, args.slice ? args.slice() : args ];
5774					queue.push( args );
5775					if ( !firing ) {
5776						fire();
5777					}
5778				}
5779				return this;
5780			},
5781
5782			// Call all the callbacks with the given arguments
5783			fire: function() {
5784				self.fireWith( this, arguments );
5785				return this;
5786			},
5787
5788			// To know if the callbacks have already been called at least once
5789			fired: function() {
5790				return !!fired;
5791			}
5792		};
5793
5794	return self;
5795};
5796
5797
5798function Identity( v ) {
5799	return v;
5800}
5801function Thrower( ex ) {
5802	throw ex;
5803}
5804
5805function adoptValue( value, resolve, reject, noValue ) {
5806	var method;
5807
5808	try {
5809
5810		// Check for promise aspect first to privilege synchronous behavior
5811		if ( value && isFunction( ( method = value.promise ) ) ) {
5812			method.call( value ).done( resolve ).fail( reject );
5813
5814		// Other thenables
5815		} else if ( value && isFunction( ( method = value.then ) ) ) {
5816			method.call( value, resolve, reject );
5817
5818		// Other non-thenables
5819		} else {
5820
5821			// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
5822			// * false: [ value ].slice( 0 ) => resolve( value )
5823			// * true: [ value ].slice( 1 ) => resolve()
5824			resolve.apply( undefined, [ value ].slice( noValue ) );
5825		}
5826
5827	// For Promises/A+, convert exceptions into rejections
5828	// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
5829	// Deferred#then to conditionally suppress rejection.
5830	} catch ( value ) {
5831
5832		// Support: Android 4.0 only
5833		// Strict mode functions invoked without .call/.apply get global-object context
5834		reject.apply( undefined, [ value ] );
5835	}
5836}
5837
5838jQuery.extend( {
5839
5840	Deferred: function( func ) {
5841		var tuples = [
5842
5843				// action, add listener, callbacks,
5844				// ... .then handlers, argument index, [final state]
5845				[ "notify", "progress", jQuery.Callbacks( "memory" ),
5846					jQuery.Callbacks( "memory" ), 2 ],
5847				[ "resolve", "done", jQuery.Callbacks( "once memory" ),
5848					jQuery.Callbacks( "once memory" ), 0, "resolved" ],
5849				[ "reject", "fail", jQuery.Callbacks( "once memory" ),
5850					jQuery.Callbacks( "once memory" ), 1, "rejected" ]
5851			],
5852			state = "pending",
5853			promise = {
5854				state: function() {
5855					return state;
5856				},
5857				always: function() {
5858					deferred.done( arguments ).fail( arguments );
5859					return this;
5860				},
5861				"catch": function( fn ) {
5862					return promise.then( null, fn );
5863				},
5864
5865				// Keep pipe for back-compat
5866				pipe: function( /* fnDone, fnFail, fnProgress */ ) {
5867					var fns = arguments;
5868
5869					return jQuery.Deferred( function( newDefer ) {
5870						jQuery.each( tuples, function( i, tuple ) {
5871
5872							// Map tuples (progress, done, fail) to arguments (done, fail, progress)
5873							var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
5874
5875							// deferred.progress(function() { bind to newDefer or newDefer.notify })
5876							// deferred.done(function() { bind to newDefer or newDefer.resolve })
5877							// deferred.fail(function() { bind to newDefer or newDefer.reject })
5878							deferred[ tuple[ 1 ] ]( function() {
5879								var returned = fn && fn.apply( this, arguments );
5880								if ( returned && isFunction( returned.promise ) ) {
5881									returned.promise()
5882										.progress( newDefer.notify )
5883										.done( newDefer.resolve )
5884										.fail( newDefer.reject );
5885								} else {
5886									newDefer[ tuple[ 0 ] + "With" ](
5887										this,
5888										fn ? [ returned ] : arguments
5889									);
5890								}
5891							} );
5892						} );
5893						fns = null;
5894					} ).promise();
5895				},
5896				then: function( onFulfilled, onRejected, onProgress ) {
5897					var maxDepth = 0;
5898					function resolve( depth, deferred, handler, special ) {
5899						return function() {
5900							var that = this,
5901								args = arguments,
5902								mightThrow = function() {
5903									var returned, then;
5904
5905									// Support: Promises/A+ section 2.3.3.3.3
5906									// https://promisesaplus.com/#point-59
5907									// Ignore double-resolution attempts
5908									if ( depth < maxDepth ) {
5909										return;
5910									}
5911
5912									returned = handler.apply( that, args );
5913
5914									// Support: Promises/A+ section 2.3.1
5915									// https://promisesaplus.com/#point-48
5916									if ( returned === deferred.promise() ) {
5917										throw new TypeError( "Thenable self-resolution" );
5918									}
5919
5920									// Support: Promises/A+ sections 2.3.3.1, 3.5
5921									// https://promisesaplus.com/#point-54
5922									// https://promisesaplus.com/#point-75
5923									// Retrieve `then` only once
5924									then = returned &&
5925
5926										// Support: Promises/A+ section 2.3.4
5927										// https://promisesaplus.com/#point-64
5928										// Only check objects and functions for thenability
5929										( typeof returned === "object" ||
5930											typeof returned === "function" ) &&
5931										returned.then;
5932
5933									// Handle a returned thenable
5934									if ( isFunction( then ) ) {
5935
5936										// Special processors (notify) just wait for resolution
5937										if ( special ) {
5938											then.call(
5939												returned,
5940												resolve( maxDepth, deferred, Identity, special ),
5941												resolve( maxDepth, deferred, Thrower, special )
5942											);
5943
5944										// Normal processors (resolve) also hook into progress
5945										} else {
5946
5947											// ...and disregard older resolution values
5948											maxDepth++;
5949
5950											then.call(
5951												returned,
5952												resolve( maxDepth, deferred, Identity, special ),
5953												resolve( maxDepth, deferred, Thrower, special ),
5954												resolve( maxDepth, deferred, Identity,
5955													deferred.notifyWith )
5956											);
5957										}
5958
5959									// Handle all other returned values
5960									} else {
5961
5962										// Only substitute handlers pass on context
5963										// and multiple values (non-spec behavior)
5964										if ( handler !== Identity ) {
5965											that = undefined;
5966											args = [ returned ];
5967										}
5968
5969										// Process the value(s)
5970										// Default process is resolve
5971										( special || deferred.resolveWith )( that, args );
5972									}
5973								},
5974
5975								// Only normal processors (resolve) catch and reject exceptions
5976								process = special ?
5977									mightThrow :
5978									function() {
5979										try {
5980											mightThrow();
5981										} catch ( e ) {
5982
5983											if ( jQuery.Deferred.exceptionHook ) {
5984												jQuery.Deferred.exceptionHook( e,
5985													process.stackTrace );
5986											}
5987
5988											// Support: Promises/A+ section 2.3.3.3.4.1
5989											// https://promisesaplus.com/#point-61
5990											// Ignore post-resolution exceptions
5991											if ( depth + 1 >= maxDepth ) {
5992
5993												// Only substitute handlers pass on context
5994												// and multiple values (non-spec behavior)
5995												if ( handler !== Thrower ) {
5996													that = undefined;
5997													args = [ e ];
5998												}
5999
6000												deferred.rejectWith( that, args );
6001											}
6002										}
6003									};
6004
6005							// Support: Promises/A+ section 2.3.3.3.1
6006							// https://promisesaplus.com/#point-57
6007							// Re-resolve promises immediately to dodge false rejection from
6008							// subsequent errors
6009							if ( depth ) {
6010								process();
6011							} else {
6012
6013								// Call an optional hook to record the stack, in case of exception
6014								// since it's otherwise lost when execution goes async
6015								if ( jQuery.Deferred.getStackHook ) {
6016									process.stackTrace = jQuery.Deferred.getStackHook();
6017								}
6018								window.setTimeout( process );
6019							}
6020						};
6021					}
6022
6023					return jQuery.Deferred( function( newDefer ) {
6024
6025						// progress_handlers.add( ... )
6026						tuples[ 0 ][ 3 ].add(
6027							resolve(
6028								0,
6029								newDefer,
6030								isFunction( onProgress ) ?
6031									onProgress :
6032									Identity,
6033								newDefer.notifyWith
6034							)
6035						);
6036
6037						// fulfilled_handlers.add( ... )
6038						tuples[ 1 ][ 3 ].add(
6039							resolve(
6040								0,
6041								newDefer,
6042								isFunction( onFulfilled ) ?
6043									onFulfilled :
6044									Identity
6045							)
6046						);
6047
6048						// rejected_handlers.add( ... )
6049						tuples[ 2 ][ 3 ].add(
6050							resolve(
6051								0,
6052								newDefer,
6053								isFunction( onRejected ) ?
6054									onRejected :
6055									Thrower
6056							)
6057						);
6058					} ).promise();
6059				},
6060
6061				// Get a promise for this deferred
6062				// If obj is provided, the promise aspect is added to the object
6063				promise: function( obj ) {
6064					return obj != null ? jQuery.extend( obj, promise ) : promise;
6065				}
6066			},
6067			deferred = {};
6068
6069		// Add list-specific methods
6070		jQuery.each( tuples, function( i, tuple ) {
6071			var list = tuple[ 2 ],
6072				stateString = tuple[ 5 ];
6073
6074			// promise.progress = list.add
6075			// promise.done = list.add
6076			// promise.fail = list.add
6077			promise[ tuple[ 1 ] ] = list.add;
6078
6079			// Handle state
6080			if ( stateString ) {
6081				list.add(
6082					function() {
6083
6084						// state = "resolved" (i.e., fulfilled)
6085						// state = "rejected"
6086						state = stateString;
6087					},
6088
6089					// rejected_callbacks.disable
6090					// fulfilled_callbacks.disable
6091					tuples[ 3 - i ][ 2 ].disable,
6092
6093					// rejected_handlers.disable
6094					// fulfilled_handlers.disable
6095					tuples[ 3 - i ][ 3 ].disable,
6096
6097					// progress_callbacks.lock
6098					tuples[ 0 ][ 2 ].lock,
6099
6100					// progress_handlers.lock
6101					tuples[ 0 ][ 3 ].lock
6102				);
6103			}
6104
6105			// progress_handlers.fire
6106			// fulfilled_handlers.fire
6107			// rejected_handlers.fire
6108			list.add( tuple[ 3 ].fire );
6109
6110			// deferred.notify = function() { deferred.notifyWith(...) }
6111			// deferred.resolve = function() { deferred.resolveWith(...) }
6112			// deferred.reject = function() { deferred.rejectWith(...) }
6113			deferred[ tuple[ 0 ] ] = function() {
6114				deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
6115				return this;
6116			};
6117
6118			// deferred.notifyWith = list.fireWith
6119			// deferred.resolveWith = list.fireWith
6120			// deferred.rejectWith = list.fireWith
6121			deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
6122		} );
6123
6124		// Make the deferred a promise
6125		promise.promise( deferred );
6126
6127		// Call given func if any
6128		if ( func ) {
6129			func.call( deferred, deferred );
6130		}
6131
6132		// All done!
6133		return deferred;
6134	},
6135
6136	// Deferred helper
6137	when: function( singleValue ) {
6138		var
6139
6140			// count of uncompleted subordinates
6141			remaining = arguments.length,
6142
6143			// count of unprocessed arguments
6144			i = remaining,
6145
6146			// subordinate fulfillment data
6147			resolveContexts = Array( i ),
6148			resolveValues = slice.call( arguments ),
6149
6150			// the master Deferred
6151			master = jQuery.Deferred(),
6152
6153			// subordinate callback factory
6154			updateFunc = function( i ) {
6155				return function( value ) {
6156					resolveContexts[ i ] = this;
6157					resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
6158					if ( !( --remaining ) ) {
6159						master.resolveWith( resolveContexts, resolveValues );
6160					}
6161				};
6162			};
6163
6164		// Single- and empty arguments are adopted like Promise.resolve
6165		if ( remaining <= 1 ) {
6166			adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject,
6167				!remaining );
6168
6169			// Use .then() to unwrap secondary thenables (cf. gh-3000)
6170			if ( master.state() === "pending" ||
6171				isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
6172
6173				return master.then();
6174			}
6175		}
6176
6177		// Multiple arguments are aggregated like Promise.all array elements
6178		while ( i-- ) {
6179			adoptValue( resolveValues[ i ], updateFunc( i ), master.reject );
6180		}
6181
6182		return master.promise();
6183	}
6184} );
6185
6186
6187// These usually indicate a programmer mistake during development,
6188// warn about them ASAP rather than swallowing them by default.
6189var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
6190
6191jQuery.Deferred.exceptionHook = function( error, stack ) {
6192
6193	// Support: IE 8 - 9 only
6194	// Console exists when dev tools are open, which can happen at any time
6195	if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
6196		window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
6197	}
6198};
6199
6200
6201
6202
6203jQuery.readyException = function( error ) {
6204	window.setTimeout( function() {
6205		throw error;
6206	} );
6207};
6208
6209
6210
6211
6212// The deferred used on DOM ready
6213var readyList = jQuery.Deferred();
6214
6215jQuery.fn.ready = function( fn ) {
6216
6217	readyList
6218		.then( fn )
6219
6220		// Wrap jQuery.readyException in a function so that the lookup
6221		// happens at the time of error handling instead of callback
6222		// registration.
6223		.catch( function( error ) {
6224			jQuery.readyException( error );
6225		} );
6226
6227	return this;
6228};
6229
6230jQuery.extend( {
6231
6232	// Is the DOM ready to be used? Set to true once it occurs.
6233	isReady: false,
6234
6235	// A counter to track how many items to wait for before
6236	// the ready event fires. See #6781
6237	readyWait: 1,
6238
6239	// Handle when the DOM is ready
6240	ready: function( wait ) {
6241
6242		// Abort if there are pending holds or we're already ready
6243		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
6244			return;
6245		}
6246
6247		// Remember that the DOM is ready
6248		jQuery.isReady = true;
6249
6250		// If a normal DOM Ready event fired, decrement, and wait if need be
6251		if ( wait !== true && --jQuery.readyWait > 0 ) {
6252			return;
6253		}
6254
6255		// If there are functions bound, to execute
6256		readyList.resolveWith( document, [ jQuery ] );
6257	}
6258} );
6259
6260jQuery.ready.then = readyList.then;
6261
6262// The ready event handler and self cleanup method
6263function completed() {
6264	document.removeEventListener( "DOMContentLoaded", completed );
6265	window.removeEventListener( "load", completed );
6266	jQuery.ready();
6267}
6268
6269// Catch cases where $(document).ready() is called
6270// after the browser event has already occurred.
6271// Support: IE <=9 - 10 only
6272// Older IE sometimes signals "interactive" too soon
6273if ( document.readyState === "complete" ||
6274	( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
6275
6276	// Handle it asynchronously to allow scripts the opportunity to delay ready
6277	window.setTimeout( jQuery.ready );
6278
6279} else {
6280
6281	// Use the handy event callback
6282	document.addEventListener( "DOMContentLoaded", completed );
6283
6284	// A fallback to window.onload, that will always work
6285	window.addEventListener( "load", completed );
6286}
6287
6288
6289
6290
6291// Multifunctional method to get and set values of a collection
6292// The value/s can optionally be executed if it's a function
6293var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
6294	var i = 0,
6295		len = elems.length,
6296		bulk = key == null;
6297
6298	// Sets many values
6299	if ( toType( key ) === "object" ) {
6300		chainable = true;
6301		for ( i in key ) {
6302			access( elems, fn, i, key[ i ], true, emptyGet, raw );
6303		}
6304
6305	// Sets one value
6306	} else if ( value !== undefined ) {
6307		chainable = true;
6308
6309		if ( !isFunction( value ) ) {
6310			raw = true;
6311		}
6312
6313		if ( bulk ) {
6314
6315			// Bulk operations run against the entire set
6316			if ( raw ) {
6317				fn.call( elems, value );
6318				fn = null;
6319
6320			// ...except when executing function values
6321			} else {
6322				bulk = fn;
6323				fn = function( elem, key, value ) {
6324					return bulk.call( jQuery( elem ), value );
6325				};
6326			}
6327		}
6328
6329		if ( fn ) {
6330			for ( ; i < len; i++ ) {
6331				fn(
6332					elems[ i ], key, raw ?
6333					value :
6334					value.call( elems[ i ], i, fn( elems[ i ], key ) )
6335				);
6336			}
6337		}
6338	}
6339
6340	if ( chainable ) {
6341		return elems;
6342	}
6343
6344	// Gets
6345	if ( bulk ) {
6346		return fn.call( elems );
6347	}
6348
6349	return len ? fn( elems[ 0 ], key ) : emptyGet;
6350};
6351
6352
6353// Matches dashed string for camelizing
6354var rmsPrefix = /^-ms-/,
6355	rdashAlpha = /-([a-z])/g;
6356
6357// Used by camelCase as callback to replace()
6358function fcamelCase( all, letter ) {
6359	return letter.toUpperCase();
6360}
6361
6362// Convert dashed to camelCase; used by the css and data modules
6363// Support: IE <=9 - 11, Edge 12 - 15
6364// Microsoft forgot to hump their vendor prefix (#9572)
6365function camelCase( string ) {
6366	return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
6367}
6368var acceptData = function( owner ) {
6369
6370	// Accepts only:
6371	//  - Node
6372	//    - Node.ELEMENT_NODE
6373	//    - Node.DOCUMENT_NODE
6374	//  - Object
6375	//    - Any
6376	return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
6377};
6378
6379
6380
6381
6382function Data() {
6383	this.expando = jQuery.expando + Data.uid++;
6384}
6385
6386Data.uid = 1;
6387
6388Data.prototype = {
6389
6390	cache: function( owner ) {
6391
6392		// Check if the owner object already has a cache
6393		var value = owner[ this.expando ];
6394
6395		// If not, create one
6396		if ( !value ) {
6397			value = {};
6398
6399			// We can accept data for non-element nodes in modern browsers,
6400			// but we should not, see #8335.
6401			// Always return an empty object.
6402			if ( acceptData( owner ) ) {
6403
6404				// If it is a node unlikely to be stringify-ed or looped over
6405				// use plain assignment
6406				if ( owner.nodeType ) {
6407					owner[ this.expando ] = value;
6408
6409				// Otherwise secure it in a non-enumerable property
6410				// configurable must be true to allow the property to be
6411				// deleted when data is removed
6412				} else {
6413					Object.defineProperty( owner, this.expando, {
6414						value: value,
6415						configurable: true
6416					} );
6417				}
6418			}
6419		}
6420
6421		return value;
6422	},
6423	set: function( owner, data, value ) {
6424		var prop,
6425			cache = this.cache( owner );
6426
6427		// Handle: [ owner, key, value ] args
6428		// Always use camelCase key (gh-2257)
6429		if ( typeof data === "string" ) {
6430			cache[ camelCase( data ) ] = value;
6431
6432		// Handle: [ owner, { properties } ] args
6433		} else {
6434
6435			// Copy the properties one-by-one to the cache object
6436			for ( prop in data ) {
6437				cache[ camelCase( prop ) ] = data[ prop ];
6438			}
6439		}
6440		return cache;
6441	},
6442	get: function( owner, key ) {
6443		return key === undefined ?
6444			this.cache( owner ) :
6445
6446			// Always use camelCase key (gh-2257)
6447			owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];
6448	},
6449	access: function( owner, key, value ) {
6450
6451		// In cases where either:
6452		//
6453		//   1. No key was specified
6454		//   2. A string key was specified, but no value provided
6455		//
6456		// Take the "read" path and allow the get method to determine
6457		// which value to return, respectively either:
6458		//
6459		//   1. The entire cache object
6460		//   2. The data stored at the key
6461		//
6462		if ( key === undefined ||
6463				( ( key && typeof key === "string" ) && value === undefined ) ) {
6464
6465			return this.get( owner, key );
6466		}
6467
6468		// When the key is not a string, or both a key and value
6469		// are specified, set or extend (existing objects) with either:
6470		//
6471		//   1. An object of properties
6472		//   2. A key and value
6473		//
6474		this.set( owner, key, value );
6475
6476		// Since the "set" path can have two possible entry points
6477		// return the expected data based on which path was taken[*]
6478		return value !== undefined ? value : key;
6479	},
6480	remove: function( owner, key ) {
6481		var i,
6482			cache = owner[ this.expando ];
6483
6484		if ( cache === undefined ) {
6485			return;
6486		}
6487
6488		if ( key !== undefined ) {
6489
6490			// Support array or space separated string of keys
6491			if ( Array.isArray( key ) ) {
6492
6493				// If key is an array of keys...
6494				// We always set camelCase keys, so remove that.
6495				key = key.map( camelCase );
6496			} else {
6497				key = camelCase( key );
6498
6499				// If a key with the spaces exists, use it.
6500				// Otherwise, create an array by matching non-whitespace
6501				key = key in cache ?
6502					[ key ] :
6503					( key.match( rnothtmlwhite ) || [] );
6504			}
6505
6506			i = key.length;
6507
6508			while ( i-- ) {
6509				delete cache[ key[ i ] ];
6510			}
6511		}
6512
6513		// Remove the expando if there's no more data
6514		if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
6515
6516			// Support: Chrome <=35 - 45
6517			// Webkit & Blink performance suffers when deleting properties
6518			// from DOM nodes, so set to undefined instead
6519			// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
6520			if ( owner.nodeType ) {
6521				owner[ this.expando ] = undefined;
6522			} else {
6523				delete owner[ this.expando ];
6524			}
6525		}
6526	},
6527	hasData: function( owner ) {
6528		var cache = owner[ this.expando ];
6529		return cache !== undefined && !jQuery.isEmptyObject( cache );
6530	}
6531};
6532var dataPriv = new Data();
6533
6534var dataUser = new Data();
6535
6536
6537
6538//	Implementation Summary
6539//
6540//	1. Enforce API surface and semantic compatibility with 1.9.x branch
6541//	2. Improve the module's maintainability by reducing the storage
6542//		paths to a single mechanism.
6543//	3. Use the same single mechanism to support "private" and "user" data.
6544//	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
6545//	5. Avoid exposing implementation details on user objects (eg. expando properties)
6546//	6. Provide a clear path for implementation upgrade to WeakMap in 2014
6547
6548var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
6549	rmultiDash = /[A-Z]/g;
6550
6551function getData( data ) {
6552	if ( data === "true" ) {
6553		return true;
6554	}
6555
6556	if ( data === "false" ) {
6557		return false;
6558	}
6559
6560	if ( data === "null" ) {
6561		return null;
6562	}
6563
6564	// Only convert to a number if it doesn't change the string
6565	if ( data === +data + "" ) {
6566		return +data;
6567	}
6568
6569	if ( rbrace.test( data ) ) {
6570		return JSON.parse( data );
6571	}
6572
6573	return data;
6574}
6575
6576function dataAttr( elem, key, data ) {
6577	var name;
6578
6579	// If nothing was found internally, try to fetch any
6580	// data from the HTML5 data-* attribute
6581	if ( data === undefined && elem.nodeType === 1 ) {
6582		name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
6583		data = elem.getAttribute( name );
6584
6585		if ( typeof data === "string" ) {
6586			try {
6587				data = getData( data );
6588			} catch ( e ) {}
6589
6590			// Make sure we set the data so it isn't changed later
6591			dataUser.set( elem, key, data );
6592		} else {
6593			data = undefined;
6594		}
6595	}
6596	return data;
6597}
6598
6599jQuery.extend( {
6600	hasData: function( elem ) {
6601		return dataUser.hasData( elem ) || dataPriv.hasData( elem );
6602	},
6603
6604	data: function( elem, name, data ) {
6605		return dataUser.access( elem, name, data );
6606	},
6607
6608	removeData: function( elem, name ) {
6609		dataUser.remove( elem, name );
6610	},
6611
6612	// TODO: Now that all calls to _data and _removeData have been replaced
6613	// with direct calls to dataPriv methods, these can be deprecated.
6614	_data: function( elem, name, data ) {
6615		return dataPriv.access( elem, name, data );
6616	},
6617
6618	_removeData: function( elem, name ) {
6619		dataPriv.remove( elem, name );
6620	}
6621} );
6622
6623jQuery.fn.extend( {
6624	data: function( key, value ) {
6625		var i, name, data,
6626			elem = this[ 0 ],
6627			attrs = elem && elem.attributes;
6628
6629		// Gets all values
6630		if ( key === undefined ) {
6631			if ( this.length ) {
6632				data = dataUser.get( elem );
6633
6634				if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
6635					i = attrs.length;
6636					while ( i-- ) {
6637
6638						// Support: IE 11 only
6639						// The attrs elements can be null (#14894)
6640						if ( attrs[ i ] ) {
6641							name = attrs[ i ].name;
6642							if ( name.indexOf( "data-" ) === 0 ) {
6643								name = camelCase( name.slice( 5 ) );
6644								dataAttr( elem, name, data[ name ] );
6645							}
6646						}
6647					}
6648					dataPriv.set( elem, "hasDataAttrs", true );
6649				}
6650			}
6651
6652			return data;
6653		}
6654
6655		// Sets multiple values
6656		if ( typeof key === "object" ) {
6657			return this.each( function() {
6658				dataUser.set( this, key );
6659			} );
6660		}
6661
6662		return access( this, function( value ) {
6663			var data;
6664
6665			// The calling jQuery object (element matches) is not empty
6666			// (and therefore has an element appears at this[ 0 ]) and the
6667			// `value` parameter was not undefined. An empty jQuery object
6668			// will result in `undefined` for elem = this[ 0 ] which will
6669			// throw an exception if an attempt to read a data cache is made.
6670			if ( elem && value === undefined ) {
6671
6672				// Attempt to get data from the cache
6673				// The key will always be camelCased in Data
6674				data = dataUser.get( elem, key );
6675				if ( data !== undefined ) {
6676					return data;
6677				}
6678
6679				// Attempt to "discover" the data in
6680				// HTML5 custom data-* attrs
6681				data = dataAttr( elem, key );
6682				if ( data !== undefined ) {
6683					return data;
6684				}
6685
6686				// We tried really hard, but the data doesn't exist.
6687				return;
6688			}
6689
6690			// Set the data...
6691			this.each( function() {
6692
6693				// We always store the camelCased key
6694				dataUser.set( this, key, value );
6695			} );
6696		}, null, value, arguments.length > 1, null, true );
6697	},
6698
6699	removeData: function( key ) {
6700		return this.each( function() {
6701			dataUser.remove( this, key );
6702		} );
6703	}
6704} );
6705
6706
6707jQuery.extend( {
6708	queue: function( elem, type, data ) {
6709		var queue;
6710
6711		if ( elem ) {
6712			type = ( type || "fx" ) + "queue";
6713			queue = dataPriv.get( elem, type );
6714
6715			// Speed up dequeue by getting out quickly if this is just a lookup
6716			if ( data ) {
6717				if ( !queue || Array.isArray( data ) ) {
6718					queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
6719				} else {
6720					queue.push( data );
6721				}
6722			}
6723			return queue || [];
6724		}
6725	},
6726
6727	dequeue: function( elem, type ) {
6728		type = type || "fx";
6729
6730		var queue = jQuery.queue( elem, type ),
6731			startLength = queue.length,
6732			fn = queue.shift(),
6733			hooks = jQuery._queueHooks( elem, type ),
6734			next = function() {
6735				jQuery.dequeue( elem, type );
6736			};
6737
6738		// If the fx queue is dequeued, always remove the progress sentinel
6739		if ( fn === "inprogress" ) {
6740			fn = queue.shift();
6741			startLength--;
6742		}
6743
6744		if ( fn ) {
6745
6746			// Add a progress sentinel to prevent the fx queue from being
6747			// automatically dequeued
6748			if ( type === "fx" ) {
6749				queue.unshift( "inprogress" );
6750			}
6751
6752			// Clear up the last queue stop function
6753			delete hooks.stop;
6754			fn.call( elem, next, hooks );
6755		}
6756
6757		if ( !startLength && hooks ) {
6758			hooks.empty.fire();
6759		}
6760	},
6761
6762	// Not public - generate a queueHooks object, or return the current one
6763	_queueHooks: function( elem, type ) {
6764		var key = type + "queueHooks";
6765		return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
6766			empty: jQuery.Callbacks( "once memory" ).add( function() {
6767				dataPriv.remove( elem, [ type + "queue", key ] );
6768			} )
6769		} );
6770	}
6771} );
6772
6773jQuery.fn.extend( {
6774	queue: function( type, data ) {
6775		var setter = 2;
6776
6777		if ( typeof type !== "string" ) {
6778			data = type;
6779			type = "fx";
6780			setter--;
6781		}
6782
6783		if ( arguments.length < setter ) {
6784			return jQuery.queue( this[ 0 ], type );
6785		}
6786
6787		return data === undefined ?
6788			this :
6789			this.each( function() {
6790				var queue = jQuery.queue( this, type, data );
6791
6792				// Ensure a hooks for this queue
6793				jQuery._queueHooks( this, type );
6794
6795				if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
6796					jQuery.dequeue( this, type );
6797				}
6798			} );
6799	},
6800	dequeue: function( type ) {
6801		return this.each( function() {
6802			jQuery.dequeue( this, type );
6803		} );
6804	},
6805	clearQueue: function( type ) {
6806		return this.queue( type || "fx", [] );
6807	},
6808
6809	// Get a promise resolved when queues of a certain type
6810	// are emptied (fx is the type by default)
6811	promise: function( type, obj ) {
6812		var tmp,
6813			count = 1,
6814			defer = jQuery.Deferred(),
6815			elements = this,
6816			i = this.length,
6817			resolve = function() {
6818				if ( !( --count ) ) {
6819					defer.resolveWith( elements, [ elements ] );
6820				}
6821			};
6822
6823		if ( typeof type !== "string" ) {
6824			obj = type;
6825			type = undefined;
6826		}
6827		type = type || "fx";
6828
6829		while ( i-- ) {
6830			tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
6831			if ( tmp && tmp.empty ) {
6832				count++;
6833				tmp.empty.add( resolve );
6834			}
6835		}
6836		resolve();
6837		return defer.promise( obj );
6838	}
6839} );
6840var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
6841
6842var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
6843
6844
6845var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
6846
6847var documentElement = document.documentElement;
6848
6849
6850
6851	var isAttached = function( elem ) {
6852			return jQuery.contains( elem.ownerDocument, elem );
6853		},
6854		composed = { composed: true };
6855
6856	// Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only
6857	// Check attachment across shadow DOM boundaries when possible (gh-3504)
6858	// Support: iOS 10.0-10.2 only
6859	// Early iOS 10 versions support `attachShadow` but not `getRootNode`,
6860	// leading to errors. We need to check for `getRootNode`.
6861	if ( documentElement.getRootNode ) {
6862		isAttached = function( elem ) {
6863			return jQuery.contains( elem.ownerDocument, elem ) ||
6864				elem.getRootNode( composed ) === elem.ownerDocument;
6865		};
6866	}
6867var isHiddenWithinTree = function( elem, el ) {
6868
6869		// isHiddenWithinTree might be called from jQuery#filter function;
6870		// in that case, element will be second argument
6871		elem = el || elem;
6872
6873		// Inline style trumps all
6874		return elem.style.display === "none" ||
6875			elem.style.display === "" &&
6876
6877			// Otherwise, check computed style
6878			// Support: Firefox <=43 - 45
6879			// Disconnected elements can have computed display: none, so first confirm that elem is
6880			// in the document.
6881			isAttached( elem ) &&
6882
6883			jQuery.css( elem, "display" ) === "none";
6884	};
6885
6886var swap = function( elem, options, callback, args ) {
6887	var ret, name,
6888		old = {};
6889
6890	// Remember the old values, and insert the new ones
6891	for ( name in options ) {
6892		old[ name ] = elem.style[ name ];
6893		elem.style[ name ] = options[ name ];
6894	}
6895
6896	ret = callback.apply( elem, args || [] );
6897
6898	// Revert the old values
6899	for ( name in options ) {
6900		elem.style[ name ] = old[ name ];
6901	}
6902
6903	return ret;
6904};
6905
6906
6907
6908
6909function adjustCSS( elem, prop, valueParts, tween ) {
6910	var adjusted, scale,
6911		maxIterations = 20,
6912		currentValue = tween ?
6913			function() {
6914				return tween.cur();
6915			} :
6916			function() {
6917				return jQuery.css( elem, prop, "" );
6918			},
6919		initial = currentValue(),
6920		unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
6921
6922		// Starting value computation is required for potential unit mismatches
6923		initialInUnit = elem.nodeType &&
6924			( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
6925			rcssNum.exec( jQuery.css( elem, prop ) );
6926
6927	if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
6928
6929		// Support: Firefox <=54
6930		// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)
6931		initial = initial / 2;
6932
6933		// Trust units reported by jQuery.css
6934		unit = unit || initialInUnit[ 3 ];
6935
6936		// Iteratively approximate from a nonzero starting point
6937		initialInUnit = +initial || 1;
6938
6939		while ( maxIterations-- ) {
6940
6941			// Evaluate and update our best guess (doubling guesses that zero out).
6942			// Finish if the scale equals or crosses 1 (making the old*new product non-positive).
6943			jQuery.style( elem, prop, initialInUnit + unit );
6944			if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {
6945				maxIterations = 0;
6946			}
6947			initialInUnit = initialInUnit / scale;
6948
6949		}
6950
6951		initialInUnit = initialInUnit * 2;
6952		jQuery.style( elem, prop, initialInUnit + unit );
6953
6954		// Make sure we update the tween properties later on
6955		valueParts = valueParts || [];
6956	}
6957
6958	if ( valueParts ) {
6959		initialInUnit = +initialInUnit || +initial || 0;
6960
6961		// Apply relative offset (+=/-=) if specified
6962		adjusted = valueParts[ 1 ] ?
6963			initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
6964			+valueParts[ 2 ];
6965		if ( tween ) {
6966			tween.unit = unit;
6967			tween.start = initialInUnit;
6968			tween.end = adjusted;
6969		}
6970	}
6971	return adjusted;
6972}
6973
6974
6975var defaultDisplayMap = {};
6976
6977function getDefaultDisplay( elem ) {
6978	var temp,
6979		doc = elem.ownerDocument,
6980		nodeName = elem.nodeName,
6981		display = defaultDisplayMap[ nodeName ];
6982
6983	if ( display ) {
6984		return display;
6985	}
6986
6987	temp = doc.body.appendChild( doc.createElement( nodeName ) );
6988	display = jQuery.css( temp, "display" );
6989
6990	temp.parentNode.removeChild( temp );
6991
6992	if ( display === "none" ) {
6993		display = "block";
6994	}
6995	defaultDisplayMap[ nodeName ] = display;
6996
6997	return display;
6998}
6999
7000function showHide( elements, show ) {
7001	var display, elem,
7002		values = [],
7003		index = 0,
7004		length = elements.length;
7005
7006	// Determine new display value for elements that need to change
7007	for ( ; index < length; index++ ) {
7008		elem = elements[ index ];
7009		if ( !elem.style ) {
7010			continue;
7011		}
7012
7013		display = elem.style.display;
7014		if ( show ) {
7015
7016			// Since we force visibility upon cascade-hidden elements, an immediate (and slow)
7017			// check is required in this first loop unless we have a nonempty display value (either
7018			// inline or about-to-be-restored)
7019			if ( display === "none" ) {
7020				values[ index ] = dataPriv.get( elem, "display" ) || null;
7021				if ( !values[ index ] ) {
7022					elem.style.display = "";
7023				}
7024			}
7025			if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
7026				values[ index ] = getDefaultDisplay( elem );
7027			}
7028		} else {
7029			if ( display !== "none" ) {
7030				values[ index ] = "none";
7031
7032				// Remember what we're overwriting
7033				dataPriv.set( elem, "display", display );
7034			}
7035		}
7036	}
7037
7038	// Set the display of the elements in a second loop to avoid constant reflow
7039	for ( index = 0; index < length; index++ ) {
7040		if ( values[ index ] != null ) {
7041			elements[ index ].style.display = values[ index ];
7042		}
7043	}
7044
7045	return elements;
7046}
7047
7048jQuery.fn.extend( {
7049	show: function() {
7050		return showHide( this, true );
7051	},
7052	hide: function() {
7053		return showHide( this );
7054	},
7055	toggle: function( state ) {
7056		if ( typeof state === "boolean" ) {
7057			return state ? this.show() : this.hide();
7058		}
7059
7060		return this.each( function() {
7061			if ( isHiddenWithinTree( this ) ) {
7062				jQuery( this ).show();
7063			} else {
7064				jQuery( this ).hide();
7065			}
7066		} );
7067	}
7068} );
7069var rcheckableType = ( /^(?:checkbox|radio)$/i );
7070
7071var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i );
7072
7073var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i );
7074
7075
7076
7077// We have to close these tags to support XHTML (#13200)
7078var wrapMap = {
7079
7080	// Support: IE <=9 only
7081	option: [ 1, "<select multiple='multiple'>", "</select>" ],
7082
7083	// XHTML parsers do not magically insert elements in the
7084	// same way that tag soup parsers do. So we cannot shorten
7085	// this by omitting <tbody> or other required elements.
7086	thead: [ 1, "<table>", "</table>" ],
7087	col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
7088	tr: [ 2, "<table><tbody>", "</tbody></table>" ],
7089	td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
7090
7091	_default: [ 0, "", "" ]
7092};
7093
7094// Support: IE <=9 only
7095wrapMap.optgroup = wrapMap.option;
7096
7097wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
7098wrapMap.th = wrapMap.td;
7099
7100
7101function getAll( context, tag ) {
7102
7103	// Support: IE <=9 - 11 only
7104	// Use typeof to avoid zero-argument method invocation on host objects (#15151)
7105	var ret;
7106
7107	if ( typeof context.getElementsByTagName !== "undefined" ) {
7108		ret = context.getElementsByTagName( tag || "*" );
7109
7110	} else if ( typeof context.querySelectorAll !== "undefined" ) {
7111		ret = context.querySelectorAll( tag || "*" );
7112
7113	} else {
7114		ret = [];
7115	}
7116
7117	if ( tag === undefined || tag && nodeName( context, tag ) ) {
7118		return jQuery.merge( [ context ], ret );
7119	}
7120
7121	return ret;
7122}
7123
7124
7125// Mark scripts as having already been evaluated
7126function setGlobalEval( elems, refElements ) {
7127	var i = 0,
7128		l = elems.length;
7129
7130	for ( ; i < l; i++ ) {
7131		dataPriv.set(
7132			elems[ i ],
7133			"globalEval",
7134			!refElements || dataPriv.get( refElements[ i ], "globalEval" )
7135		);
7136	}
7137}
7138
7139
7140var rhtml = /<|&#?\w+;/;
7141
7142function buildFragment( elems, context, scripts, selection, ignored ) {
7143	var elem, tmp, tag, wrap, attached, j,
7144		fragment = context.createDocumentFragment(),
7145		nodes = [],
7146		i = 0,
7147		l = elems.length;
7148
7149	for ( ; i < l; i++ ) {
7150		elem = elems[ i ];
7151
7152		if ( elem || elem === 0 ) {
7153
7154			// Add nodes directly
7155			if ( toType( elem ) === "object" ) {
7156
7157				// Support: Android <=4.0 only, PhantomJS 1 only
7158				// push.apply(_, arraylike) throws on ancient WebKit
7159				jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
7160
7161			// Convert non-html into a text node
7162			} else if ( !rhtml.test( elem ) ) {
7163				nodes.push( context.createTextNode( elem ) );
7164
7165			// Convert html into DOM nodes
7166			} else {
7167				tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
7168
7169				// Deserialize a standard representation
7170				tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
7171				wrap = wrapMap[ tag ] || wrapMap._default;
7172				tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
7173
7174				// Descend through wrappers to the right content
7175				j = wrap[ 0 ];
7176				while ( j-- ) {
7177					tmp = tmp.lastChild;
7178				}
7179
7180				// Support: Android <=4.0 only, PhantomJS 1 only
7181				// push.apply(_, arraylike) throws on ancient WebKit
7182				jQuery.merge( nodes, tmp.childNodes );
7183
7184				// Remember the top-level container
7185				tmp = fragment.firstChild;
7186
7187				// Ensure the created nodes are orphaned (#12392)
7188				tmp.textContent = "";
7189			}
7190		}
7191	}
7192
7193	// Remove wrapper from fragment
7194	fragment.textContent = "";
7195
7196	i = 0;
7197	while ( ( elem = nodes[ i++ ] ) ) {
7198
7199		// Skip elements already in the context collection (trac-4087)
7200		if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
7201			if ( ignored ) {
7202				ignored.push( elem );
7203			}
7204			continue;
7205		}
7206
7207		attached = isAttached( elem );
7208
7209		// Append to fragment
7210		tmp = getAll( fragment.appendChild( elem ), "script" );
7211
7212		// Preserve script evaluation history
7213		if ( attached ) {
7214			setGlobalEval( tmp );
7215		}
7216
7217		// Capture executables
7218		if ( scripts ) {
7219			j = 0;
7220			while ( ( elem = tmp[ j++ ] ) ) {
7221				if ( rscriptType.test( elem.type || "" ) ) {
7222					scripts.push( elem );
7223				}
7224			}
7225		}
7226	}
7227
7228	return fragment;
7229}
7230
7231
7232( function() {
7233	var fragment = document.createDocumentFragment(),
7234		div = fragment.appendChild( document.createElement( "div" ) ),
7235		input = document.createElement( "input" );
7236
7237	// Support: Android 4.0 - 4.3 only
7238	// Check state lost if the name is set (#11217)
7239	// Support: Windows Web Apps (WWA)
7240	// `name` and `type` must use .setAttribute for WWA (#14901)
7241	input.setAttribute( "type", "radio" );
7242	input.setAttribute( "checked", "checked" );
7243	input.setAttribute( "name", "t" );
7244
7245	div.appendChild( input );
7246
7247	// Support: Android <=4.1 only
7248	// Older WebKit doesn't clone checked state correctly in fragments
7249	support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
7250
7251	// Support: IE <=11 only
7252	// Make sure textarea (and checkbox) defaultValue is properly cloned
7253	div.innerHTML = "<textarea>x</textarea>";
7254	support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
7255} )();
7256
7257
7258var
7259	rkeyEvent = /^key/,
7260	rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
7261	rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
7262
7263function returnTrue() {
7264	return true;
7265}
7266
7267function returnFalse() {
7268	return false;
7269}
7270
7271// Support: IE <=9 - 11+
7272// focus() and blur() are asynchronous, except when they are no-op.
7273// So expect focus to be synchronous when the element is already active,
7274// and blur to be synchronous when the element is not already active.
7275// (focus and blur are always synchronous in other supported browsers,
7276// this just defines when we can count on it).
7277function expectSync( elem, type ) {
7278	return ( elem === safeActiveElement() ) === ( type === "focus" );
7279}
7280
7281// Support: IE <=9 only
7282// Accessing document.activeElement can throw unexpectedly
7283// https://bugs.jquery.com/ticket/13393
7284function safeActiveElement() {
7285	try {
7286		return document.activeElement;
7287	} catch ( err ) { }
7288}
7289
7290function on( elem, types, selector, data, fn, one ) {
7291	var origFn, type;
7292
7293	// Types can be a map of types/handlers
7294	if ( typeof types === "object" ) {
7295
7296		// ( types-Object, selector, data )
7297		if ( typeof selector !== "string" ) {
7298
7299			// ( types-Object, data )
7300			data = data || selector;
7301			selector = undefined;
7302		}
7303		for ( type in types ) {
7304			on( elem, type, selector, data, types[ type ], one );
7305		}
7306		return elem;
7307	}
7308
7309	if ( data == null && fn == null ) {
7310
7311		// ( types, fn )
7312		fn = selector;
7313		data = selector = undefined;
7314	} else if ( fn == null ) {
7315		if ( typeof selector === "string" ) {
7316
7317			// ( types, selector, fn )
7318			fn = data;
7319			data = undefined;
7320		} else {
7321
7322			// ( types, data, fn )
7323			fn = data;
7324			data = selector;
7325			selector = undefined;
7326		}
7327	}
7328	if ( fn === false ) {
7329		fn = returnFalse;
7330	} else if ( !fn ) {
7331		return elem;
7332	}
7333
7334	if ( one === 1 ) {
7335		origFn = fn;
7336		fn = function( event ) {
7337
7338			// Can use an empty set, since event contains the info
7339			jQuery().off( event );
7340			return origFn.apply( this, arguments );
7341		};
7342
7343		// Use same guid so caller can remove using origFn
7344		fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
7345	}
7346	return elem.each( function() {
7347		jQuery.event.add( this, types, fn, data, selector );
7348	} );
7349}
7350
7351/*
7352 * Helper functions for managing events -- not part of the public interface.
7353 * Props to Dean Edwards' addEvent library for many of the ideas.
7354 */
7355jQuery.event = {
7356
7357	global: {},
7358
7359	add: function( elem, types, handler, data, selector ) {
7360
7361		var handleObjIn, eventHandle, tmp,
7362			events, t, handleObj,
7363			special, handlers, type, namespaces, origType,
7364			elemData = dataPriv.get( elem );
7365
7366		// Don't attach events to noData or text/comment nodes (but allow plain objects)
7367		if ( !elemData ) {
7368			return;
7369		}
7370
7371		// Caller can pass in an object of custom data in lieu of the handler
7372		if ( handler.handler ) {
7373			handleObjIn = handler;
7374			handler = handleObjIn.handler;
7375			selector = handleObjIn.selector;
7376		}
7377
7378		// Ensure that invalid selectors throw exceptions at attach time
7379		// Evaluate against documentElement in case elem is a non-element node (e.g., document)
7380		if ( selector ) {
7381			jQuery.find.matchesSelector( documentElement, selector );
7382		}
7383
7384		// Make sure that the handler has a unique ID, used to find/remove it later
7385		if ( !handler.guid ) {
7386			handler.guid = jQuery.guid++;
7387		}
7388
7389		// Init the element's event structure and main handler, if this is the first
7390		if ( !( events = elemData.events ) ) {
7391			events = elemData.events = {};
7392		}
7393		if ( !( eventHandle = elemData.handle ) ) {
7394			eventHandle = elemData.handle = function( e ) {
7395
7396				// Discard the second event of a jQuery.event.trigger() and
7397				// when an event is called after a page has unloaded
7398				return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
7399					jQuery.event.dispatch.apply( elem, arguments ) : undefined;
7400			};
7401		}
7402
7403		// Handle multiple events separated by a space
7404		types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
7405		t = types.length;
7406		while ( t-- ) {
7407			tmp = rtypenamespace.exec( types[ t ] ) || [];
7408			type = origType = tmp[ 1 ];
7409			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
7410
7411			// There *must* be a type, no attaching namespace-only handlers
7412			if ( !type ) {
7413				continue;
7414			}
7415
7416			// If event changes its type, use the special event handlers for the changed type
7417			special = jQuery.event.special[ type ] || {};
7418
7419			// If selector defined, determine special event api type, otherwise given type
7420			type = ( selector ? special.delegateType : special.bindType ) || type;
7421
7422			// Update special based on newly reset type
7423			special = jQuery.event.special[ type ] || {};
7424
7425			// handleObj is passed to all event handlers
7426			handleObj = jQuery.extend( {
7427				type: type,
7428				origType: origType,
7429				data: data,
7430				handler: handler,
7431				guid: handler.guid,
7432				selector: selector,
7433				needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
7434				namespace: namespaces.join( "." )
7435			}, handleObjIn );
7436
7437			// Init the event handler queue if we're the first
7438			if ( !( handlers = events[ type ] ) ) {
7439				handlers = events[ type ] = [];
7440				handlers.delegateCount = 0;
7441
7442				// Only use addEventListener if the special events handler returns false
7443				if ( !special.setup ||
7444					special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
7445
7446					if ( elem.addEventListener ) {
7447						elem.addEventListener( type, eventHandle );
7448					}
7449				}
7450			}
7451
7452			if ( special.add ) {
7453				special.add.call( elem, handleObj );
7454
7455				if ( !handleObj.handler.guid ) {
7456					handleObj.handler.guid = handler.guid;
7457				}
7458			}
7459
7460			// Add to the element's handler list, delegates in front
7461			if ( selector ) {
7462				handlers.splice( handlers.delegateCount++, 0, handleObj );
7463			} else {
7464				handlers.push( handleObj );
7465			}
7466
7467			// Keep track of which events have ever been used, for event optimization
7468			jQuery.event.global[ type ] = true;
7469		}
7470
7471	},
7472
7473	// Detach an event or set of events from an element
7474	remove: function( elem, types, handler, selector, mappedTypes ) {
7475
7476		var j, origCount, tmp,
7477			events, t, handleObj,
7478			special, handlers, type, namespaces, origType,
7479			elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
7480
7481		if ( !elemData || !( events = elemData.events ) ) {
7482			return;
7483		}
7484
7485		// Once for each type.namespace in types; type may be omitted
7486		types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
7487		t = types.length;
7488		while ( t-- ) {
7489			tmp = rtypenamespace.exec( types[ t ] ) || [];
7490			type = origType = tmp[ 1 ];
7491			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
7492
7493			// Unbind all events (on this namespace, if provided) for the element
7494			if ( !type ) {
7495				for ( type in events ) {
7496					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
7497				}
7498				continue;
7499			}
7500
7501			special = jQuery.event.special[ type ] || {};
7502			type = ( selector ? special.delegateType : special.bindType ) || type;
7503			handlers = events[ type ] || [];
7504			tmp = tmp[ 2 ] &&
7505				new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
7506
7507			// Remove matching events
7508			origCount = j = handlers.length;
7509			while ( j-- ) {
7510				handleObj = handlers[ j ];
7511
7512				if ( ( mappedTypes || origType === handleObj.origType ) &&
7513					( !handler || handler.guid === handleObj.guid ) &&
7514					( !tmp || tmp.test( handleObj.namespace ) ) &&
7515					( !selector || selector === handleObj.selector ||
7516						selector === "**" && handleObj.selector ) ) {
7517					handlers.splice( j, 1 );
7518
7519					if ( handleObj.selector ) {
7520						handlers.delegateCount--;
7521					}
7522					if ( special.remove ) {
7523						special.remove.call( elem, handleObj );
7524					}
7525				}
7526			}
7527
7528			// Remove generic event handler if we removed something and no more handlers exist
7529			// (avoids potential for endless recursion during removal of special event handlers)
7530			if ( origCount && !handlers.length ) {
7531				if ( !special.teardown ||
7532					special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
7533
7534					jQuery.removeEvent( elem, type, elemData.handle );
7535				}
7536
7537				delete events[ type ];
7538			}
7539		}
7540
7541		// Remove data and the expando if it's no longer used
7542		if ( jQuery.isEmptyObject( events ) ) {
7543			dataPriv.remove( elem, "handle events" );
7544		}
7545	},
7546
7547	dispatch: function( nativeEvent ) {
7548
7549		// Make a writable jQuery.Event from the native event object
7550		var event = jQuery.event.fix( nativeEvent );
7551
7552		var i, j, ret, matched, handleObj, handlerQueue,
7553			args = new Array( arguments.length ),
7554			handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [],
7555			special = jQuery.event.special[ event.type ] || {};
7556
7557		// Use the fix-ed jQuery.Event rather than the (read-only) native event
7558		args[ 0 ] = event;
7559
7560		for ( i = 1; i < arguments.length; i++ ) {
7561			args[ i ] = arguments[ i ];
7562		}
7563
7564		event.delegateTarget = this;
7565
7566		// Call the preDispatch hook for the mapped type, and let it bail if desired
7567		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
7568			return;
7569		}
7570
7571		// Determine handlers
7572		handlerQueue = jQuery.event.handlers.call( this, event, handlers );
7573
7574		// Run delegates first; they may want to stop propagation beneath us
7575		i = 0;
7576		while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
7577			event.currentTarget = matched.elem;
7578
7579			j = 0;
7580			while ( ( handleObj = matched.handlers[ j++ ] ) &&
7581				!event.isImmediatePropagationStopped() ) {
7582
7583				// If the event is namespaced, then each handler is only invoked if it is
7584				// specially universal or its namespaces are a superset of the event's.
7585				if ( !event.rnamespace || handleObj.namespace === false ||
7586					event.rnamespace.test( handleObj.namespace ) ) {
7587
7588					event.handleObj = handleObj;
7589					event.data = handleObj.data;
7590
7591					ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
7592						handleObj.handler ).apply( matched.elem, args );
7593
7594					if ( ret !== undefined ) {
7595						if ( ( event.result = ret ) === false ) {
7596							event.preventDefault();
7597							event.stopPropagation();
7598						}
7599					}
7600				}
7601			}
7602		}
7603
7604		// Call the postDispatch hook for the mapped type
7605		if ( special.postDispatch ) {
7606			special.postDispatch.call( this, event );
7607		}
7608
7609		return event.result;
7610	},
7611
7612	handlers: function( event, handlers ) {
7613		var i, handleObj, sel, matchedHandlers, matchedSelectors,
7614			handlerQueue = [],
7615			delegateCount = handlers.delegateCount,
7616			cur = event.target;
7617
7618		// Find delegate handlers
7619		if ( delegateCount &&
7620
7621			// Support: IE <=9
7622			// Black-hole SVG <use> instance trees (trac-13180)
7623			cur.nodeType &&
7624
7625			// Support: Firefox <=42
7626			// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
7627			// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
7628			// Support: IE 11 only
7629			// ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
7630			!( event.type === "click" && event.button >= 1 ) ) {
7631
7632			for ( ; cur !== this; cur = cur.parentNode || this ) {
7633
7634				// Don't check non-elements (#13208)
7635				// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
7636				if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
7637					matchedHandlers = [];
7638					matchedSelectors = {};
7639					for ( i = 0; i < delegateCount; i++ ) {
7640						handleObj = handlers[ i ];
7641
7642						// Don't conflict with Object.prototype properties (#13203)
7643						sel = handleObj.selector + " ";
7644
7645						if ( matchedSelectors[ sel ] === undefined ) {
7646							matchedSelectors[ sel ] = handleObj.needsContext ?
7647								jQuery( sel, this ).index( cur ) > -1 :
7648								jQuery.find( sel, this, null, [ cur ] ).length;
7649						}
7650						if ( matchedSelectors[ sel ] ) {
7651							matchedHandlers.push( handleObj );
7652						}
7653					}
7654					if ( matchedHandlers.length ) {
7655						handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
7656					}
7657				}
7658			}
7659		}
7660
7661		// Add the remaining (directly-bound) handlers
7662		cur = this;
7663		if ( delegateCount < handlers.length ) {
7664			handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
7665		}
7666
7667		return handlerQueue;
7668	},
7669
7670	addProp: function( name, hook ) {
7671		Object.defineProperty( jQuery.Event.prototype, name, {
7672			enumerable: true,
7673			configurable: true,
7674
7675			get: isFunction( hook ) ?
7676				function() {
7677					if ( this.originalEvent ) {
7678							return hook( this.originalEvent );
7679					}
7680				} :
7681				function() {
7682					if ( this.originalEvent ) {
7683							return this.originalEvent[ name ];
7684					}
7685				},
7686
7687			set: function( value ) {
7688				Object.defineProperty( this, name, {
7689					enumerable: true,
7690					configurable: true,
7691					writable: true,
7692					value: value
7693				} );
7694			}
7695		} );
7696	},
7697
7698	fix: function( originalEvent ) {
7699		return originalEvent[ jQuery.expando ] ?
7700			originalEvent :
7701			new jQuery.Event( originalEvent );
7702	},
7703
7704	special: {
7705		load: {
7706
7707			// Prevent triggered image.load events from bubbling to window.load
7708			noBubble: true
7709		},
7710		click: {
7711
7712			// Utilize native event to ensure correct state for checkable inputs
7713			setup: function( data ) {
7714
7715				// For mutual compressibility with _default, replace `this` access with a local var.
7716				// `|| data` is dead code meant only to preserve the variable through minification.
7717				var el = this || data;
7718
7719				// Claim the first handler
7720				if ( rcheckableType.test( el.type ) &&
7721					el.click && nodeName( el, "input" ) ) {
7722
7723					// dataPriv.set( el, "click", ... )
7724					leverageNative( el, "click", returnTrue );
7725				}
7726
7727				// Return false to allow normal processing in the caller
7728				return false;
7729			},
7730			trigger: function( data ) {
7731
7732				// For mutual compressibility with _default, replace `this` access with a local var.
7733				// `|| data` is dead code meant only to preserve the variable through minification.
7734				var el = this || data;
7735
7736				// Force setup before triggering a click
7737				if ( rcheckableType.test( el.type ) &&
7738					el.click && nodeName( el, "input" ) ) {
7739
7740					leverageNative( el, "click" );
7741				}
7742
7743				// Return non-false to allow normal event-path propagation
7744				return true;
7745			},
7746
7747			// For cross-browser consistency, suppress native .click() on links
7748			// Also prevent it if we're currently inside a leveraged native-event stack
7749			_default: function( event ) {
7750				var target = event.target;
7751				return rcheckableType.test( target.type ) &&
7752					target.click && nodeName( target, "input" ) &&
7753					dataPriv.get( target, "click" ) ||
7754					nodeName( target, "a" );
7755			}
7756		},
7757
7758		beforeunload: {
7759			postDispatch: function( event ) {
7760
7761				// Support: Firefox 20+
7762				// Firefox doesn't alert if the returnValue field is not set.
7763				if ( event.result !== undefined && event.originalEvent ) {
7764					event.originalEvent.returnValue = event.result;
7765				}
7766			}
7767		}
7768	}
7769};
7770
7771// Ensure the presence of an event listener that handles manually-triggered
7772// synthetic events by interrupting progress until reinvoked in response to
7773// *native* events that it fires directly, ensuring that state changes have
7774// already occurred before other listeners are invoked.
7775function leverageNative( el, type, expectSync ) {
7776
7777	// Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add
7778	if ( !expectSync ) {
7779		if ( dataPriv.get( el, type ) === undefined ) {
7780			jQuery.event.add( el, type, returnTrue );
7781		}
7782		return;
7783	}
7784
7785	// Register the controller as a special universal handler for all event namespaces
7786	dataPriv.set( el, type, false );
7787	jQuery.event.add( el, type, {
7788		namespace: false,
7789		handler: function( event ) {
7790			var notAsync, result,
7791				saved = dataPriv.get( this, type );
7792
7793			if ( ( event.isTrigger & 1 ) && this[ type ] ) {
7794
7795				// Interrupt processing of the outer synthetic .trigger()ed event
7796				// Saved data should be false in such cases, but might be a leftover capture object
7797				// from an async native handler (gh-4350)
7798				if ( !saved.length ) {
7799
7800					// Store arguments for use when handling the inner native event
7801					// There will always be at least one argument (an event object), so this array
7802					// will not be confused with a leftover capture object.
7803					saved = slice.call( arguments );
7804					dataPriv.set( this, type, saved );
7805
7806					// Trigger the native event and capture its result
7807					// Support: IE <=9 - 11+
7808					// focus() and blur() are asynchronous
7809					notAsync = expectSync( this, type );
7810					this[ type ]();
7811					result = dataPriv.get( this, type );
7812					if ( saved !== result || notAsync ) {
7813						dataPriv.set( this, type, false );
7814					} else {
7815						result = {};
7816					}
7817					if ( saved !== result ) {
7818
7819						// Cancel the outer synthetic event
7820						event.stopImmediatePropagation();
7821						event.preventDefault();
7822						return result.value;
7823					}
7824
7825				// If this is an inner synthetic event for an event with a bubbling surrogate
7826				// (focus or blur), assume that the surrogate already propagated from triggering the
7827				// native event and prevent that from happening again here.
7828				// This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the
7829				// bubbling surrogate propagates *after* the non-bubbling base), but that seems
7830				// less bad than duplication.
7831				} else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {
7832					event.stopPropagation();
7833				}
7834
7835			// If this is a native event triggered above, everything is now in order
7836			// Fire an inner synthetic event with the original arguments
7837			} else if ( saved.length ) {
7838
7839				// ...and capture the result
7840				dataPriv.set( this, type, {
7841					value: jQuery.event.trigger(
7842
7843						// Support: IE <=9 - 11+
7844						// Extend with the prototype to reset the above stopImmediatePropagation()
7845						jQuery.extend( saved[ 0 ], jQuery.Event.prototype ),
7846						saved.slice( 1 ),
7847						this
7848					)
7849				} );
7850
7851				// Abort handling of the native event
7852				event.stopImmediatePropagation();
7853			}
7854		}
7855	} );
7856}
7857
7858jQuery.removeEvent = function( elem, type, handle ) {
7859
7860	// This "if" is needed for plain objects
7861	if ( elem.removeEventListener ) {
7862		elem.removeEventListener( type, handle );
7863	}
7864};
7865
7866jQuery.Event = function( src, props ) {
7867
7868	// Allow instantiation without the 'new' keyword
7869	if ( !( this instanceof jQuery.Event ) ) {
7870		return new jQuery.Event( src, props );
7871	}
7872
7873	// Event object
7874	if ( src && src.type ) {
7875		this.originalEvent = src;
7876		this.type = src.type;
7877
7878		// Events bubbling up the document may have been marked as prevented
7879		// by a handler lower down the tree; reflect the correct value.
7880		this.isDefaultPrevented = src.defaultPrevented ||
7881				src.defaultPrevented === undefined &&
7882
7883				// Support: Android <=2.3 only
7884				src.returnValue === false ?
7885			returnTrue :
7886			returnFalse;
7887
7888		// Create target properties
7889		// Support: Safari <=6 - 7 only
7890		// Target should not be a text node (#504, #13143)
7891		this.target = ( src.target && src.target.nodeType === 3 ) ?
7892			src.target.parentNode :
7893			src.target;
7894
7895		this.currentTarget = src.currentTarget;
7896		this.relatedTarget = src.relatedTarget;
7897
7898	// Event type
7899	} else {
7900		this.type = src;
7901	}
7902
7903	// Put explicitly provided properties onto the event object
7904	if ( props ) {
7905		jQuery.extend( this, props );
7906	}
7907
7908	// Create a timestamp if incoming event doesn't have one
7909	this.timeStamp = src && src.timeStamp || Date.now();
7910
7911	// Mark it as fixed
7912	this[ jQuery.expando ] = true;
7913};
7914
7915// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
7916// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
7917jQuery.Event.prototype = {
7918	constructor: jQuery.Event,
7919	isDefaultPrevented: returnFalse,
7920	isPropagationStopped: returnFalse,
7921	isImmediatePropagationStopped: returnFalse,
7922	isSimulated: false,
7923
7924	preventDefault: function() {
7925		var e = this.originalEvent;
7926
7927		this.isDefaultPrevented = returnTrue;
7928
7929		if ( e && !this.isSimulated ) {
7930			e.preventDefault();
7931		}
7932	},
7933	stopPropagation: function() {
7934		var e = this.originalEvent;
7935
7936		this.isPropagationStopped = returnTrue;
7937
7938		if ( e && !this.isSimulated ) {
7939			e.stopPropagation();
7940		}
7941	},
7942	stopImmediatePropagation: function() {
7943		var e = this.originalEvent;
7944
7945		this.isImmediatePropagationStopped = returnTrue;
7946
7947		if ( e && !this.isSimulated ) {
7948			e.stopImmediatePropagation();
7949		}
7950
7951		this.stopPropagation();
7952	}
7953};
7954
7955// Includes all common event props including KeyEvent and MouseEvent specific props
7956jQuery.each( {
7957	altKey: true,
7958	bubbles: true,
7959	cancelable: true,
7960	changedTouches: true,
7961	ctrlKey: true,
7962	detail: true,
7963	eventPhase: true,
7964	metaKey: true,
7965	pageX: true,
7966	pageY: true,
7967	shiftKey: true,
7968	view: true,
7969	"char": true,
7970	code: true,
7971	charCode: true,
7972	key: true,
7973	keyCode: true,
7974	button: true,
7975	buttons: true,
7976	clientX: true,
7977	clientY: true,
7978	offsetX: true,
7979	offsetY: true,
7980	pointerId: true,
7981	pointerType: true,
7982	screenX: true,
7983	screenY: true,
7984	targetTouches: true,
7985	toElement: true,
7986	touches: true,
7987
7988	which: function( event ) {
7989		var button = event.button;
7990
7991		// Add which for key events
7992		if ( event.which == null && rkeyEvent.test( event.type ) ) {
7993			return event.charCode != null ? event.charCode : event.keyCode;
7994		}
7995
7996		// Add which for click: 1 === left; 2 === middle; 3 === right
7997		if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {
7998			if ( button & 1 ) {
7999				return 1;
8000			}
8001
8002			if ( button & 2 ) {
8003				return 3;
8004			}
8005
8006			if ( button & 4 ) {
8007				return 2;
8008			}
8009
8010			return 0;
8011		}
8012
8013		return event.which;
8014	}
8015}, jQuery.event.addProp );
8016
8017jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) {
8018	jQuery.event.special[ type ] = {
8019
8020		// Utilize native event if possible so blur/focus sequence is correct
8021		setup: function() {
8022
8023			// Claim the first handler
8024			// dataPriv.set( this, "focus", ... )
8025			// dataPriv.set( this, "blur", ... )
8026			leverageNative( this, type, expectSync );
8027
8028			// Return false to allow normal processing in the caller
8029			return false;
8030		},
8031		trigger: function() {
8032
8033			// Force setup before trigger
8034			leverageNative( this, type );
8035
8036			// Return non-false to allow normal event-path propagation
8037			return true;
8038		},
8039
8040		delegateType: delegateType
8041	};
8042} );
8043
8044// Create mouseenter/leave events using mouseover/out and event-time checks
8045// so that event delegation works in jQuery.
8046// Do the same for pointerenter/pointerleave and pointerover/pointerout
8047//
8048// Support: Safari 7 only
8049// Safari sends mouseenter too often; see:
8050// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
8051// for the description of the bug (it existed in older Chrome versions as well).
8052jQuery.each( {
8053	mouseenter: "mouseover",
8054	mouseleave: "mouseout",
8055	pointerenter: "pointerover",
8056	pointerleave: "pointerout"
8057}, function( orig, fix ) {
8058	jQuery.event.special[ orig ] = {
8059		delegateType: fix,
8060		bindType: fix,
8061
8062		handle: function( event ) {
8063			var ret,
8064				target = this,
8065				related = event.relatedTarget,
8066				handleObj = event.handleObj;
8067
8068			// For mouseenter/leave call the handler if related is outside the target.
8069			// NB: No relatedTarget if the mouse left/entered the browser window
8070			if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
8071				event.type = handleObj.origType;
8072				ret = handleObj.handler.apply( this, arguments );
8073				event.type = fix;
8074			}
8075			return ret;
8076		}
8077	};
8078} );
8079
8080jQuery.fn.extend( {
8081
8082	on: function( types, selector, data, fn ) {
8083		return on( this, types, selector, data, fn );
8084	},
8085	one: function( types, selector, data, fn ) {
8086		return on( this, types, selector, data, fn, 1 );
8087	},
8088	off: function( types, selector, fn ) {
8089		var handleObj, type;
8090		if ( types && types.preventDefault && types.handleObj ) {
8091
8092			// ( event )  dispatched jQuery.Event
8093			handleObj = types.handleObj;
8094			jQuery( types.delegateTarget ).off(
8095				handleObj.namespace ?
8096					handleObj.origType + "." + handleObj.namespace :
8097					handleObj.origType,
8098				handleObj.selector,
8099				handleObj.handler
8100			);
8101			return this;
8102		}
8103		if ( typeof types === "object" ) {
8104
8105			// ( types-object [, selector] )
8106			for ( type in types ) {
8107				this.off( type, selector, types[ type ] );
8108			}
8109			return this;
8110		}
8111		if ( selector === false || typeof selector === "function" ) {
8112
8113			// ( types [, fn] )
8114			fn = selector;
8115			selector = undefined;
8116		}
8117		if ( fn === false ) {
8118			fn = returnFalse;
8119		}
8120		return this.each( function() {
8121			jQuery.event.remove( this, types, fn, selector );
8122		} );
8123	}
8124} );
8125
8126
8127var
8128
8129	/* eslint-disable max-len */
8130
8131	// See https://github.com/eslint/eslint/issues/3229
8132	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,
8133
8134	/* eslint-enable */
8135
8136	// Support: IE <=10 - 11, Edge 12 - 13 only
8137	// In IE/Edge using regex groups here causes severe slowdowns.
8138	// See https://connect.microsoft.com/IE/feedback/details/1736512/
8139	rnoInnerhtml = /<script|<style|<link/i,
8140
8141	// checked="checked" or checked
8142	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
8143	rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
8144
8145// Prefer a tbody over its parent table for containing new rows
8146function manipulationTarget( elem, content ) {
8147	if ( nodeName( elem, "table" ) &&
8148		nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {
8149
8150		return jQuery( elem ).children( "tbody" )[ 0 ] || elem;
8151	}
8152
8153	return elem;
8154}
8155
8156// Replace/restore the type attribute of script elements for safe DOM manipulation
8157function disableScript( elem ) {
8158	elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
8159	return elem;
8160}
8161function restoreScript( elem ) {
8162	if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) {
8163		elem.type = elem.type.slice( 5 );
8164	} else {
8165		elem.removeAttribute( "type" );
8166	}
8167
8168	return elem;
8169}
8170
8171function cloneCopyEvent( src, dest ) {
8172	var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
8173
8174	if ( dest.nodeType !== 1 ) {
8175		return;
8176	}
8177
8178	// 1. Copy private data: events, handlers, etc.
8179	if ( dataPriv.hasData( src ) ) {
8180		pdataOld = dataPriv.access( src );
8181		pdataCur = dataPriv.set( dest, pdataOld );
8182		events = pdataOld.events;
8183
8184		if ( events ) {
8185			delete pdataCur.handle;
8186			pdataCur.events = {};
8187
8188			for ( type in events ) {
8189				for ( i = 0, l = events[ type ].length; i < l; i++ ) {
8190					jQuery.event.add( dest, type, events[ type ][ i ] );
8191				}
8192			}
8193		}
8194	}
8195
8196	// 2. Copy user data
8197	if ( dataUser.hasData( src ) ) {
8198		udataOld = dataUser.access( src );
8199		udataCur = jQuery.extend( {}, udataOld );
8200
8201		dataUser.set( dest, udataCur );
8202	}
8203}
8204
8205// Fix IE bugs, see support tests
8206function fixInput( src, dest ) {
8207	var nodeName = dest.nodeName.toLowerCase();
8208
8209	// Fails to persist the checked state of a cloned checkbox or radio button.
8210	if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
8211		dest.checked = src.checked;
8212
8213	// Fails to return the selected option to the default selected state when cloning options
8214	} else if ( nodeName === "input" || nodeName === "textarea" ) {
8215		dest.defaultValue = src.defaultValue;
8216	}
8217}
8218
8219function domManip( collection, args, callback, ignored ) {
8220
8221	// Flatten any nested arrays
8222	args = concat.apply( [], args );
8223
8224	var fragment, first, scripts, hasScripts, node, doc,
8225		i = 0,
8226		l = collection.length,
8227		iNoClone = l - 1,
8228		value = args[ 0 ],
8229		valueIsFunction = isFunction( value );
8230
8231	// We can't cloneNode fragments that contain checked, in WebKit
8232	if ( valueIsFunction ||
8233			( l > 1 && typeof value === "string" &&
8234				!support.checkClone && rchecked.test( value ) ) ) {
8235		return collection.each( function( index ) {
8236			var self = collection.eq( index );
8237			if ( valueIsFunction ) {
8238				args[ 0 ] = value.call( this, index, self.html() );
8239			}
8240			domManip( self, args, callback, ignored );
8241		} );
8242	}
8243
8244	if ( l ) {
8245		fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
8246		first = fragment.firstChild;
8247
8248		if ( fragment.childNodes.length === 1 ) {
8249			fragment = first;
8250		}
8251
8252		// Require either new content or an interest in ignored elements to invoke the callback
8253		if ( first || ignored ) {
8254			scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
8255			hasScripts = scripts.length;
8256
8257			// Use the original fragment for the last item
8258			// instead of the first because it can end up
8259			// being emptied incorrectly in certain situations (#8070).
8260			for ( ; i < l; i++ ) {
8261				node = fragment;
8262
8263				if ( i !== iNoClone ) {
8264					node = jQuery.clone( node, true, true );
8265
8266					// Keep references to cloned scripts for later restoration
8267					if ( hasScripts ) {
8268
8269						// Support: Android <=4.0 only, PhantomJS 1 only
8270						// push.apply(_, arraylike) throws on ancient WebKit
8271						jQuery.merge( scripts, getAll( node, "script" ) );
8272					}
8273				}
8274
8275				callback.call( collection[ i ], node, i );
8276			}
8277
8278			if ( hasScripts ) {
8279				doc = scripts[ scripts.length - 1 ].ownerDocument;
8280
8281				// Reenable scripts
8282				jQuery.map( scripts, restoreScript );
8283
8284				// Evaluate executable scripts on first document insertion
8285				for ( i = 0; i < hasScripts; i++ ) {
8286					node = scripts[ i ];
8287					if ( rscriptType.test( node.type || "" ) &&
8288						!dataPriv.access( node, "globalEval" ) &&
8289						jQuery.contains( doc, node ) ) {
8290
8291						if ( node.src && ( node.type || "" ).toLowerCase()  !== "module" ) {
8292
8293							// Optional AJAX dependency, but won't run scripts if not present
8294							if ( jQuery._evalUrl && !node.noModule ) {
8295								jQuery._evalUrl( node.src, {
8296									nonce: node.nonce || node.getAttribute( "nonce" )
8297								} );
8298							}
8299						} else {
8300							DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc );
8301						}
8302					}
8303				}
8304			}
8305		}
8306	}
8307
8308	return collection;
8309}
8310
8311function remove( elem, selector, keepData ) {
8312	var node,
8313		nodes = selector ? jQuery.filter( selector, elem ) : elem,
8314		i = 0;
8315
8316	for ( ; ( node = nodes[ i ] ) != null; i++ ) {
8317		if ( !keepData && node.nodeType === 1 ) {
8318			jQuery.cleanData( getAll( node ) );
8319		}
8320
8321		if ( node.parentNode ) {
8322			if ( keepData && isAttached( node ) ) {
8323				setGlobalEval( getAll( node, "script" ) );
8324			}
8325			node.parentNode.removeChild( node );
8326		}
8327	}
8328
8329	return elem;
8330}
8331
8332jQuery.extend( {
8333	htmlPrefilter: function( html ) {
8334		return html.replace( rxhtmlTag, "<$1></$2>" );
8335	},
8336
8337	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
8338		var i, l, srcElements, destElements,
8339			clone = elem.cloneNode( true ),
8340			inPage = isAttached( elem );
8341
8342		// Fix IE cloning issues
8343		if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
8344				!jQuery.isXMLDoc( elem ) ) {
8345
8346			// We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
8347			destElements = getAll( clone );
8348			srcElements = getAll( elem );
8349
8350			for ( i = 0, l = srcElements.length; i < l; i++ ) {
8351				fixInput( srcElements[ i ], destElements[ i ] );
8352			}
8353		}
8354
8355		// Copy the events from the original to the clone
8356		if ( dataAndEvents ) {
8357			if ( deepDataAndEvents ) {
8358				srcElements = srcElements || getAll( elem );
8359				destElements = destElements || getAll( clone );
8360
8361				for ( i = 0, l = srcElements.length; i < l; i++ ) {
8362					cloneCopyEvent( srcElements[ i ], destElements[ i ] );
8363				}
8364			} else {
8365				cloneCopyEvent( elem, clone );
8366			}
8367		}
8368
8369		// Preserve script evaluation history
8370		destElements = getAll( clone, "script" );
8371		if ( destElements.length > 0 ) {
8372			setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
8373		}
8374
8375		// Return the cloned set
8376		return clone;
8377	},
8378
8379	cleanData: function( elems ) {
8380		var data, elem, type,
8381			special = jQuery.event.special,
8382			i = 0;
8383
8384		for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
8385			if ( acceptData( elem ) ) {
8386				if ( ( data = elem[ dataPriv.expando ] ) ) {
8387					if ( data.events ) {
8388						for ( type in data.events ) {
8389							if ( special[ type ] ) {
8390								jQuery.event.remove( elem, type );
8391
8392							// This is a shortcut to avoid jQuery.event.remove's overhead
8393							} else {
8394								jQuery.removeEvent( elem, type, data.handle );
8395							}
8396						}
8397					}
8398
8399					// Support: Chrome <=35 - 45+
8400					// Assign undefined instead of using delete, see Data#remove
8401					elem[ dataPriv.expando ] = undefined;
8402				}
8403				if ( elem[ dataUser.expando ] ) {
8404
8405					// Support: Chrome <=35 - 45+
8406					// Assign undefined instead of using delete, see Data#remove
8407					elem[ dataUser.expando ] = undefined;
8408				}
8409			}
8410		}
8411	}
8412} );
8413
8414jQuery.fn.extend( {
8415	detach: function( selector ) {
8416		return remove( this, selector, true );
8417	},
8418
8419	remove: function( selector ) {
8420		return remove( this, selector );
8421	},
8422
8423	text: function( value ) {
8424		return access( this, function( value ) {
8425			return value === undefined ?
8426				jQuery.text( this ) :
8427				this.empty().each( function() {
8428					if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
8429						this.textContent = value;
8430					}
8431				} );
8432		}, null, value, arguments.length );
8433	},
8434
8435	append: function() {
8436		return domManip( this, arguments, function( elem ) {
8437			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
8438				var target = manipulationTarget( this, elem );
8439				target.appendChild( elem );
8440			}
8441		} );
8442	},
8443
8444	prepend: function() {
8445		return domManip( this, arguments, function( elem ) {
8446			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
8447				var target = manipulationTarget( this, elem );
8448				target.insertBefore( elem, target.firstChild );
8449			}
8450		} );
8451	},
8452
8453	before: function() {
8454		return domManip( this, arguments, function( elem ) {
8455			if ( this.parentNode ) {
8456				this.parentNode.insertBefore( elem, this );
8457			}
8458		} );
8459	},
8460
8461	after: function() {
8462		return domManip( this, arguments, function( elem ) {
8463			if ( this.parentNode ) {
8464				this.parentNode.insertBefore( elem, this.nextSibling );
8465			}
8466		} );
8467	},
8468
8469	empty: function() {
8470		var elem,
8471			i = 0;
8472
8473		for ( ; ( elem = this[ i ] ) != null; i++ ) {
8474			if ( elem.nodeType === 1 ) {
8475
8476				// Prevent memory leaks
8477				jQuery.cleanData( getAll( elem, false ) );
8478
8479				// Remove any remaining nodes
8480				elem.textContent = "";
8481			}
8482		}
8483
8484		return this;
8485	},
8486
8487	clone: function( dataAndEvents, deepDataAndEvents ) {
8488		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
8489		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
8490
8491		return this.map( function() {
8492			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
8493		} );
8494	},
8495
8496	html: function( value ) {
8497		return access( this, function( value ) {
8498			var elem = this[ 0 ] || {},
8499				i = 0,
8500				l = this.length;
8501
8502			if ( value === undefined && elem.nodeType === 1 ) {
8503				return elem.innerHTML;
8504			}
8505
8506			// See if we can take a shortcut and just use innerHTML
8507			if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
8508				!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
8509
8510				value = jQuery.htmlPrefilter( value );
8511
8512				try {
8513					for ( ; i < l; i++ ) {
8514						elem = this[ i ] || {};
8515
8516						// Remove element nodes and prevent memory leaks
8517						if ( elem.nodeType === 1 ) {
8518							jQuery.cleanData( getAll( elem, false ) );
8519							elem.innerHTML = value;
8520						}
8521					}
8522
8523					elem = 0;
8524
8525				// If using innerHTML throws an exception, use the fallback method
8526				} catch ( e ) {}
8527			}
8528
8529			if ( elem ) {
8530				this.empty().append( value );
8531			}
8532		}, null, value, arguments.length );
8533	},
8534
8535	replaceWith: function() {
8536		var ignored = [];
8537
8538		// Make the changes, replacing each non-ignored context element with the new content
8539		return domManip( this, arguments, function( elem ) {
8540			var parent = this.parentNode;
8541
8542			if ( jQuery.inArray( this, ignored ) < 0 ) {
8543				jQuery.cleanData( getAll( this ) );
8544				if ( parent ) {
8545					parent.replaceChild( elem, this );
8546				}
8547			}
8548
8549		// Force callback invocation
8550		}, ignored );
8551	}
8552} );
8553
8554jQuery.each( {
8555	appendTo: "append",
8556	prependTo: "prepend",
8557	insertBefore: "before",
8558	insertAfter: "after",
8559	replaceAll: "replaceWith"
8560}, function( name, original ) {
8561	jQuery.fn[ name ] = function( selector ) {
8562		var elems,
8563			ret = [],
8564			insert = jQuery( selector ),
8565			last = insert.length - 1,
8566			i = 0;
8567
8568		for ( ; i <= last; i++ ) {
8569			elems = i === last ? this : this.clone( true );
8570			jQuery( insert[ i ] )[ original ]( elems );
8571
8572			// Support: Android <=4.0 only, PhantomJS 1 only
8573			// .get() because push.apply(_, arraylike) throws on ancient WebKit
8574			push.apply( ret, elems.get() );
8575		}
8576
8577		return this.pushStack( ret );
8578	};
8579} );
8580var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
8581
8582var getStyles = function( elem ) {
8583
8584		// Support: IE <=11 only, Firefox <=30 (#15098, #14150)
8585		// IE throws on elements created in popups
8586		// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
8587		var view = elem.ownerDocument.defaultView;
8588
8589		if ( !view || !view.opener ) {
8590			view = window;
8591		}
8592
8593		return view.getComputedStyle( elem );
8594	};
8595
8596var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" );
8597
8598
8599
8600( function() {
8601
8602	// Executing both pixelPosition & boxSizingReliable tests require only one layout
8603	// so they're executed at the same time to save the second computation.
8604	function computeStyleTests() {
8605
8606		// This is a singleton, we need to execute it only once
8607		if ( !div ) {
8608			return;
8609		}
8610
8611		container.style.cssText = "position:absolute;left:-11111px;width:60px;" +
8612			"margin-top:1px;padding:0;border:0";
8613		div.style.cssText =
8614			"position:relative;display:block;box-sizing:border-box;overflow:scroll;" +
8615			"margin:auto;border:1px;padding:1px;" +
8616			"width:60%;top:1%";
8617		documentElement.appendChild( container ).appendChild( div );
8618
8619		var divStyle = window.getComputedStyle( div );
8620		pixelPositionVal = divStyle.top !== "1%";
8621
8622		// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
8623		reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;
8624
8625		// Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3
8626		// Some styles come back with percentage values, even though they shouldn't
8627		div.style.right = "60%";
8628		pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;
8629
8630		// Support: IE 9 - 11 only
8631		// Detect misreporting of content dimensions for box-sizing:border-box elements
8632		boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;
8633
8634		// Support: IE 9 only
8635		// Detect overflow:scroll screwiness (gh-3699)
8636		// Support: Chrome <=64
8637		// Don't get tricked when zoom affects offsetWidth (gh-4029)
8638		div.style.position = "absolute";
8639		scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;
8640
8641		documentElement.removeChild( container );
8642
8643		// Nullify the div so it wouldn't be stored in the memory and
8644		// it will also be a sign that checks already performed
8645		div = null;
8646	}
8647
8648	function roundPixelMeasures( measure ) {
8649		return Math.round( parseFloat( measure ) );
8650	}
8651
8652	var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,
8653		reliableMarginLeftVal,
8654		container = document.createElement( "div" ),
8655		div = document.createElement( "div" );
8656
8657	// Finish early in limited (non-browser) environments
8658	if ( !div.style ) {
8659		return;
8660	}
8661
8662	// Support: IE <=9 - 11 only
8663	// Style of cloned element affects source element cloned (#8908)
8664	div.style.backgroundClip = "content-box";
8665	div.cloneNode( true ).style.backgroundClip = "";
8666	support.clearCloneStyle = div.style.backgroundClip === "content-box";
8667
8668	jQuery.extend( support, {
8669		boxSizingReliable: function() {
8670			computeStyleTests();
8671			return boxSizingReliableVal;
8672		},
8673		pixelBoxStyles: function() {
8674			computeStyleTests();
8675			return pixelBoxStylesVal;
8676		},
8677		pixelPosition: function() {
8678			computeStyleTests();
8679			return pixelPositionVal;
8680		},
8681		reliableMarginLeft: function() {
8682			computeStyleTests();
8683			return reliableMarginLeftVal;
8684		},
8685		scrollboxSize: function() {
8686			computeStyleTests();
8687			return scrollboxSizeVal;
8688		}
8689	} );
8690} )();
8691
8692
8693function curCSS( elem, name, computed ) {
8694	var width, minWidth, maxWidth, ret,
8695
8696		// Support: Firefox 51+
8697		// Retrieving style before computed somehow
8698		// fixes an issue with getting wrong values
8699		// on detached elements
8700		style = elem.style;
8701
8702	computed = computed || getStyles( elem );
8703
8704	// getPropertyValue is needed for:
8705	//   .css('filter') (IE 9 only, #12537)
8706	//   .css('--customProperty) (#3144)
8707	if ( computed ) {
8708		ret = computed.getPropertyValue( name ) || computed[ name ];
8709
8710		if ( ret === "" && !isAttached( elem ) ) {
8711			ret = jQuery.style( elem, name );
8712		}
8713
8714		// A tribute to the "awesome hack by Dean Edwards"
8715		// Android Browser returns percentage for some values,
8716		// but width seems to be reliably pixels.
8717		// This is against the CSSOM draft spec:
8718		// https://drafts.csswg.org/cssom/#resolved-values
8719		if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {
8720
8721			// Remember the original values
8722			width = style.width;
8723			minWidth = style.minWidth;
8724			maxWidth = style.maxWidth;
8725
8726			// Put in the new values to get a computed value out
8727			style.minWidth = style.maxWidth = style.width = ret;
8728			ret = computed.width;
8729
8730			// Revert the changed values
8731			style.width = width;
8732			style.minWidth = minWidth;
8733			style.maxWidth = maxWidth;
8734		}
8735	}
8736
8737	return ret !== undefined ?
8738
8739		// Support: IE <=9 - 11 only
8740		// IE returns zIndex value as an integer.
8741		ret + "" :
8742		ret;
8743}
8744
8745
8746function addGetHookIf( conditionFn, hookFn ) {
8747
8748	// Define the hook, we'll check on the first run if it's really needed.
8749	return {
8750		get: function() {
8751			if ( conditionFn() ) {
8752
8753				// Hook not needed (or it's not possible to use it due
8754				// to missing dependency), remove it.
8755				delete this.get;
8756				return;
8757			}
8758
8759			// Hook needed; redefine it so that the support test is not executed again.
8760			return ( this.get = hookFn ).apply( this, arguments );
8761		}
8762	};
8763}
8764
8765
8766var cssPrefixes = [ "Webkit", "Moz", "ms" ],
8767	emptyStyle = document.createElement( "div" ).style,
8768	vendorProps = {};
8769
8770// Return a vendor-prefixed property or undefined
8771function vendorPropName( name ) {
8772
8773	// Check for vendor prefixed names
8774	var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
8775		i = cssPrefixes.length;
8776
8777	while ( i-- ) {
8778		name = cssPrefixes[ i ] + capName;
8779		if ( name in emptyStyle ) {
8780			return name;
8781		}
8782	}
8783}
8784
8785// Return a potentially-mapped jQuery.cssProps or vendor prefixed property
8786function finalPropName( name ) {
8787	var final = jQuery.cssProps[ name ] || vendorProps[ name ];
8788
8789	if ( final ) {
8790		return final;
8791	}
8792	if ( name in emptyStyle ) {
8793		return name;
8794	}
8795	return vendorProps[ name ] = vendorPropName( name ) || name;
8796}
8797
8798
8799var
8800
8801	// Swappable if display is none or starts with table
8802	// except "table", "table-cell", or "table-caption"
8803	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
8804	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
8805	rcustomProp = /^--/,
8806	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
8807	cssNormalTransform = {
8808		letterSpacing: "0",
8809		fontWeight: "400"
8810	};
8811
8812function setPositiveNumber( elem, value, subtract ) {
8813
8814	// Any relative (+/-) values have already been
8815	// normalized at this point
8816	var matches = rcssNum.exec( value );
8817	return matches ?
8818
8819		// Guard against undefined "subtract", e.g., when used as in cssHooks
8820		Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
8821		value;
8822}
8823
8824function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {
8825	var i = dimension === "width" ? 1 : 0,
8826		extra = 0,
8827		delta = 0;
8828
8829	// Adjustment may not be necessary
8830	if ( box === ( isBorderBox ? "border" : "content" ) ) {
8831		return 0;
8832	}
8833
8834	for ( ; i < 4; i += 2 ) {
8835
8836		// Both box models exclude margin
8837		if ( box === "margin" ) {
8838			delta += jQuery.css( elem, box + cssExpand[ i ], true, styles );
8839		}
8840
8841		// If we get here with a content-box, we're seeking "padding" or "border" or "margin"
8842		if ( !isBorderBox ) {
8843
8844			// Add padding
8845			delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
8846
8847			// For "border" or "margin", add border
8848			if ( box !== "padding" ) {
8849				delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
8850
8851			// But still keep track of it otherwise
8852			} else {
8853				extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
8854			}
8855
8856		// If we get here with a border-box (content + padding + border), we're seeking "content" or
8857		// "padding" or "margin"
8858		} else {
8859
8860			// For "content", subtract padding
8861			if ( box === "content" ) {
8862				delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
8863			}
8864
8865			// For "content" or "padding", subtract border
8866			if ( box !== "margin" ) {
8867				delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
8868			}
8869		}
8870	}
8871
8872	// Account for positive content-box scroll gutter when requested by providing computedVal
8873	if ( !isBorderBox && computedVal >= 0 ) {
8874
8875		// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
8876		// Assuming integer scroll gutter, subtract the rest and round down
8877		delta += Math.max( 0, Math.ceil(
8878			elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
8879			computedVal -
8880			delta -
8881			extra -
8882			0.5
8883
8884		// If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter
8885		// Use an explicit zero to avoid NaN (gh-3964)
8886		) ) || 0;
8887	}
8888
8889	return delta;
8890}
8891
8892function getWidthOrHeight( elem, dimension, extra ) {
8893
8894	// Start with computed style
8895	var styles = getStyles( elem ),
8896
8897		// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).
8898		// Fake content-box until we know it's needed to know the true value.
8899		boxSizingNeeded = !support.boxSizingReliable() || extra,
8900		isBorderBox = boxSizingNeeded &&
8901			jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
8902		valueIsBorderBox = isBorderBox,
8903
8904		val = curCSS( elem, dimension, styles ),
8905		offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );
8906
8907	// Support: Firefox <=54
8908	// Return a confounding non-pixel value or feign ignorance, as appropriate.
8909	if ( rnumnonpx.test( val ) ) {
8910		if ( !extra ) {
8911			return val;
8912		}
8913		val = "auto";
8914	}
8915
8916
8917	// Fall back to offsetWidth/offsetHeight when value is "auto"
8918	// This happens for inline elements with no explicit setting (gh-3571)
8919	// Support: Android <=4.1 - 4.3 only
8920	// Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
8921	// Support: IE 9-11 only
8922	// Also use offsetWidth/offsetHeight for when box sizing is unreliable
8923	// We use getClientRects() to check for hidden/disconnected.
8924	// In those cases, the computed value can be trusted to be border-box
8925	if ( ( !support.boxSizingReliable() && isBorderBox ||
8926		val === "auto" ||
8927		!parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) &&
8928		elem.getClientRects().length ) {
8929
8930		isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
8931
8932		// Where available, offsetWidth/offsetHeight approximate border box dimensions.
8933		// Where not available (e.g., SVG), assume unreliable box-sizing and interpret the
8934		// retrieved value as a content box dimension.
8935		valueIsBorderBox = offsetProp in elem;
8936		if ( valueIsBorderBox ) {
8937			val = elem[ offsetProp ];
8938		}
8939	}
8940
8941	// Normalize "" and auto
8942	val = parseFloat( val ) || 0;
8943
8944	// Adjust for the element's box model
8945	return ( val +
8946		boxModelAdjustment(
8947			elem,
8948			dimension,
8949			extra || ( isBorderBox ? "border" : "content" ),
8950			valueIsBorderBox,
8951			styles,
8952
8953			// Provide the current computed size to request scroll gutter calculation (gh-3589)
8954			val
8955		)
8956	) + "px";
8957}
8958
8959jQuery.extend( {
8960
8961	// Add in style property hooks for overriding the default
8962	// behavior of getting and setting a style property
8963	cssHooks: {
8964		opacity: {
8965			get: function( elem, computed ) {
8966				if ( computed ) {
8967
8968					// We should always get a number back from opacity
8969					var ret = curCSS( elem, "opacity" );
8970					return ret === "" ? "1" : ret;
8971				}
8972			}
8973		}
8974	},
8975
8976	// Don't automatically add "px" to these possibly-unitless properties
8977	cssNumber: {
8978		"animationIterationCount": true,
8979		"columnCount": true,
8980		"fillOpacity": true,
8981		"flexGrow": true,
8982		"flexShrink": true,
8983		"fontWeight": true,
8984		"gridArea": true,
8985		"gridColumn": true,
8986		"gridColumnEnd": true,
8987		"gridColumnStart": true,
8988		"gridRow": true,
8989		"gridRowEnd": true,
8990		"gridRowStart": true,
8991		"lineHeight": true,
8992		"opacity": true,
8993		"order": true,
8994		"orphans": true,
8995		"widows": true,
8996		"zIndex": true,
8997		"zoom": true
8998	},
8999
9000	// Add in properties whose names you wish to fix before
9001	// setting or getting the value
9002	cssProps: {},
9003
9004	// Get and set the style property on a DOM Node
9005	style: function( elem, name, value, extra ) {
9006
9007		// Don't set styles on text and comment nodes
9008		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
9009			return;
9010		}
9011
9012		// Make sure that we're working with the right name
9013		var ret, type, hooks,
9014			origName = camelCase( name ),
9015			isCustomProp = rcustomProp.test( name ),
9016			style = elem.style;
9017
9018		// Make sure that we're working with the right name. We don't
9019		// want to query the value if it is a CSS custom property
9020		// since they are user-defined.
9021		if ( !isCustomProp ) {
9022			name = finalPropName( origName );
9023		}
9024
9025		// Gets hook for the prefixed version, then unprefixed version
9026		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
9027
9028		// Check if we're setting a value
9029		if ( value !== undefined ) {
9030			type = typeof value;
9031
9032			// Convert "+=" or "-=" to relative numbers (#7345)
9033			if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
9034				value = adjustCSS( elem, name, ret );
9035
9036				// Fixes bug #9237
9037				type = "number";
9038			}
9039
9040			// Make sure that null and NaN values aren't set (#7116)
9041			if ( value == null || value !== value ) {
9042				return;
9043			}
9044
9045			// If a number was passed in, add the unit (except for certain CSS properties)
9046			// The isCustomProp check can be removed in jQuery 4.0 when we only auto-append
9047			// "px" to a few hardcoded values.
9048			if ( type === "number" && !isCustomProp ) {
9049				value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
9050			}
9051
9052			// background-* props affect original clone's values
9053			if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
9054				style[ name ] = "inherit";
9055			}
9056
9057			// If a hook was provided, use that value, otherwise just set the specified value
9058			if ( !hooks || !( "set" in hooks ) ||
9059				( value = hooks.set( elem, value, extra ) ) !== undefined ) {
9060
9061				if ( isCustomProp ) {
9062					style.setProperty( name, value );
9063				} else {
9064					style[ name ] = value;
9065				}
9066			}
9067
9068		} else {
9069
9070			// If a hook was provided get the non-computed value from there
9071			if ( hooks && "get" in hooks &&
9072				( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
9073
9074				return ret;
9075			}
9076
9077			// Otherwise just get the value from the style object
9078			return style[ name ];
9079		}
9080	},
9081
9082	css: function( elem, name, extra, styles ) {
9083		var val, num, hooks,
9084			origName = camelCase( name ),
9085			isCustomProp = rcustomProp.test( name );
9086
9087		// Make sure that we're working with the right name. We don't
9088		// want to modify the value if it is a CSS custom property
9089		// since they are user-defined.
9090		if ( !isCustomProp ) {
9091			name = finalPropName( origName );
9092		}
9093
9094		// Try prefixed name followed by the unprefixed name
9095		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
9096
9097		// If a hook was provided get the computed value from there
9098		if ( hooks && "get" in hooks ) {
9099			val = hooks.get( elem, true, extra );
9100		}
9101
9102		// Otherwise, if a way to get the computed value exists, use that
9103		if ( val === undefined ) {
9104			val = curCSS( elem, name, styles );
9105		}
9106
9107		// Convert "normal" to computed value
9108		if ( val === "normal" && name in cssNormalTransform ) {
9109			val = cssNormalTransform[ name ];
9110		}
9111
9112		// Make numeric if forced or a qualifier was provided and val looks numeric
9113		if ( extra === "" || extra ) {
9114			num = parseFloat( val );
9115			return extra === true || isFinite( num ) ? num || 0 : val;
9116		}
9117
9118		return val;
9119	}
9120} );
9121
9122jQuery.each( [ "height", "width" ], function( i, dimension ) {
9123	jQuery.cssHooks[ dimension ] = {
9124		get: function( elem, computed, extra ) {
9125			if ( computed ) {
9126
9127				// Certain elements can have dimension info if we invisibly show them
9128				// but it must have a current display style that would benefit
9129				return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
9130
9131					// Support: Safari 8+
9132					// Table columns in Safari have non-zero offsetWidth & zero
9133					// getBoundingClientRect().width unless display is changed.
9134					// Support: IE <=11 only
9135					// Running getBoundingClientRect on a disconnected node
9136					// in IE throws an error.
9137					( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
9138						swap( elem, cssShow, function() {
9139							return getWidthOrHeight( elem, dimension, extra );
9140						} ) :
9141						getWidthOrHeight( elem, dimension, extra );
9142			}
9143		},
9144
9145		set: function( elem, value, extra ) {
9146			var matches,
9147				styles = getStyles( elem ),
9148
9149				// Only read styles.position if the test has a chance to fail
9150				// to avoid forcing a reflow.
9151				scrollboxSizeBuggy = !support.scrollboxSize() &&
9152					styles.position === "absolute",
9153
9154				// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)
9155				boxSizingNeeded = scrollboxSizeBuggy || extra,
9156				isBorderBox = boxSizingNeeded &&
9157					jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
9158				subtract = extra ?
9159					boxModelAdjustment(
9160						elem,
9161						dimension,
9162						extra,
9163						isBorderBox,
9164						styles
9165					) :
9166					0;
9167
9168			// Account for unreliable border-box dimensions by comparing offset* to computed and
9169			// faking a content-box to get border and padding (gh-3699)
9170			if ( isBorderBox && scrollboxSizeBuggy ) {
9171				subtract -= Math.ceil(
9172					elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
9173					parseFloat( styles[ dimension ] ) -
9174					boxModelAdjustment( elem, dimension, "border", false, styles ) -
9175					0.5
9176				);
9177			}
9178
9179			// Convert to pixels if value adjustment is needed
9180			if ( subtract && ( matches = rcssNum.exec( value ) ) &&
9181				( matches[ 3 ] || "px" ) !== "px" ) {
9182
9183				elem.style[ dimension ] = value;
9184				value = jQuery.css( elem, dimension );
9185			}
9186
9187			return setPositiveNumber( elem, value, subtract );
9188		}
9189	};
9190} );
9191
9192jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
9193	function( elem, computed ) {
9194		if ( computed ) {
9195			return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
9196				elem.getBoundingClientRect().left -
9197					swap( elem, { marginLeft: 0 }, function() {
9198						return elem.getBoundingClientRect().left;
9199					} )
9200				) + "px";
9201		}
9202	}
9203);
9204
9205// These hooks are used by animate to expand properties
9206jQuery.each( {
9207	margin: "",
9208	padding: "",
9209	border: "Width"
9210}, function( prefix, suffix ) {
9211	jQuery.cssHooks[ prefix + suffix ] = {
9212		expand: function( value ) {
9213			var i = 0,
9214				expanded = {},
9215
9216				// Assumes a single number if not a string
9217				parts = typeof value === "string" ? value.split( " " ) : [ value ];
9218
9219			for ( ; i < 4; i++ ) {
9220				expanded[ prefix + cssExpand[ i ] + suffix ] =
9221					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
9222			}
9223
9224			return expanded;
9225		}
9226	};
9227
9228	if ( prefix !== "margin" ) {
9229		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
9230	}
9231} );
9232
9233jQuery.fn.extend( {
9234	css: function( name, value ) {
9235		return access( this, function( elem, name, value ) {
9236			var styles, len,
9237				map = {},
9238				i = 0;
9239
9240			if ( Array.isArray( name ) ) {
9241				styles = getStyles( elem );
9242				len = name.length;
9243
9244				for ( ; i < len; i++ ) {
9245					map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
9246				}
9247
9248				return map;
9249			}
9250
9251			return value !== undefined ?
9252				jQuery.style( elem, name, value ) :
9253				jQuery.css( elem, name );
9254		}, name, value, arguments.length > 1 );
9255	}
9256} );
9257
9258
9259function Tween( elem, options, prop, end, easing ) {
9260	return new Tween.prototype.init( elem, options, prop, end, easing );
9261}
9262jQuery.Tween = Tween;
9263
9264Tween.prototype = {
9265	constructor: Tween,
9266	init: function( elem, options, prop, end, easing, unit ) {
9267		this.elem = elem;
9268		this.prop = prop;
9269		this.easing = easing || jQuery.easing._default;
9270		this.options = options;
9271		this.start = this.now = this.cur();
9272		this.end = end;
9273		this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
9274	},
9275	cur: function() {
9276		var hooks = Tween.propHooks[ this.prop ];
9277
9278		return hooks && hooks.get ?
9279			hooks.get( this ) :
9280			Tween.propHooks._default.get( this );
9281	},
9282	run: function( percent ) {
9283		var eased,
9284			hooks = Tween.propHooks[ this.prop ];
9285
9286		if ( this.options.duration ) {
9287			this.pos = eased = jQuery.easing[ this.easing ](
9288				percent, this.options.duration * percent, 0, 1, this.options.duration
9289			);
9290		} else {
9291			this.pos = eased = percent;
9292		}
9293		this.now = ( this.end - this.start ) * eased + this.start;
9294
9295		if ( this.options.step ) {
9296			this.options.step.call( this.elem, this.now, this );
9297		}
9298
9299		if ( hooks && hooks.set ) {
9300			hooks.set( this );
9301		} else {
9302			Tween.propHooks._default.set( this );
9303		}
9304		return this;
9305	}
9306};
9307
9308Tween.prototype.init.prototype = Tween.prototype;
9309
9310Tween.propHooks = {
9311	_default: {
9312		get: function( tween ) {
9313			var result;
9314
9315			// Use a property on the element directly when it is not a DOM element,
9316			// or when there is no matching style property that exists.
9317			if ( tween.elem.nodeType !== 1 ||
9318				tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
9319				return tween.elem[ tween.prop ];
9320			}
9321
9322			// Passing an empty string as a 3rd parameter to .css will automatically
9323			// attempt a parseFloat and fallback to a string if the parse fails.
9324			// Simple values such as "10px" are parsed to Float;
9325			// complex values such as "rotate(1rad)" are returned as-is.
9326			result = jQuery.css( tween.elem, tween.prop, "" );
9327
9328			// Empty strings, null, undefined and "auto" are converted to 0.
9329			return !result || result === "auto" ? 0 : result;
9330		},
9331		set: function( tween ) {
9332
9333			// Use step hook for back compat.
9334			// Use cssHook if its there.
9335			// Use .style if available and use plain properties where available.
9336			if ( jQuery.fx.step[ tween.prop ] ) {
9337				jQuery.fx.step[ tween.prop ]( tween );
9338			} else if ( tween.elem.nodeType === 1 && (
9339					jQuery.cssHooks[ tween.prop ] ||
9340					tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {
9341				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
9342			} else {
9343				tween.elem[ tween.prop ] = tween.now;
9344			}
9345		}
9346	}
9347};
9348
9349// Support: IE <=9 only
9350// Panic based approach to setting things on disconnected nodes
9351Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
9352	set: function( tween ) {
9353		if ( tween.elem.nodeType && tween.elem.parentNode ) {
9354			tween.elem[ tween.prop ] = tween.now;
9355		}
9356	}
9357};
9358
9359jQuery.easing = {
9360	linear: function( p ) {
9361		return p;
9362	},
9363	swing: function( p ) {
9364		return 0.5 - Math.cos( p * Math.PI ) / 2;
9365	},
9366	_default: "swing"
9367};
9368
9369jQuery.fx = Tween.prototype.init;
9370
9371// Back compat <1.8 extension point
9372jQuery.fx.step = {};
9373
9374
9375
9376
9377var
9378	fxNow, inProgress,
9379	rfxtypes = /^(?:toggle|show|hide)$/,
9380	rrun = /queueHooks$/;
9381
9382function schedule() {
9383	if ( inProgress ) {
9384		if ( document.hidden === false && window.requestAnimationFrame ) {
9385			window.requestAnimationFrame( schedule );
9386		} else {
9387			window.setTimeout( schedule, jQuery.fx.interval );
9388		}
9389
9390		jQuery.fx.tick();
9391	}
9392}
9393
9394// Animations created synchronously will run synchronously
9395function createFxNow() {
9396	window.setTimeout( function() {
9397		fxNow = undefined;
9398	} );
9399	return ( fxNow = Date.now() );
9400}
9401
9402// Generate parameters to create a standard animation
9403function genFx( type, includeWidth ) {
9404	var which,
9405		i = 0,
9406		attrs = { height: type };
9407
9408	// If we include width, step value is 1 to do all cssExpand values,
9409	// otherwise step value is 2 to skip over Left and Right
9410	includeWidth = includeWidth ? 1 : 0;
9411	for ( ; i < 4; i += 2 - includeWidth ) {
9412		which = cssExpand[ i ];
9413		attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
9414	}
9415
9416	if ( includeWidth ) {
9417		attrs.opacity = attrs.width = type;
9418	}
9419
9420	return attrs;
9421}
9422
9423function createTween( value, prop, animation ) {
9424	var tween,
9425		collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
9426		index = 0,
9427		length = collection.length;
9428	for ( ; index < length; index++ ) {
9429		if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
9430
9431			// We're done with this property
9432			return tween;
9433		}
9434	}
9435}
9436
9437function defaultPrefilter( elem, props, opts ) {
9438	var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
9439		isBox = "width" in props || "height" in props,
9440		anim = this,
9441		orig = {},
9442		style = elem.style,
9443		hidden = elem.nodeType && isHiddenWithinTree( elem ),
9444		dataShow = dataPriv.get( elem, "fxshow" );
9445
9446	// Queue-skipping animations hijack the fx hooks
9447	if ( !opts.queue ) {
9448		hooks = jQuery._queueHooks( elem, "fx" );
9449		if ( hooks.unqueued == null ) {
9450			hooks.unqueued = 0;
9451			oldfire = hooks.empty.fire;
9452			hooks.empty.fire = function() {
9453				if ( !hooks.unqueued ) {
9454					oldfire();
9455				}
9456			};
9457		}
9458		hooks.unqueued++;
9459
9460		anim.always( function() {
9461
9462			// Ensure the complete handler is called before this completes
9463			anim.always( function() {
9464				hooks.unqueued--;
9465				if ( !jQuery.queue( elem, "fx" ).length ) {
9466					hooks.empty.fire();
9467				}
9468			} );
9469		} );
9470	}
9471
9472	// Detect show/hide animations
9473	for ( prop in props ) {
9474		value = props[ prop ];
9475		if ( rfxtypes.test( value ) ) {
9476			delete props[ prop ];
9477			toggle = toggle || value === "toggle";
9478			if ( value === ( hidden ? "hide" : "show" ) ) {
9479
9480				// Pretend to be hidden if this is a "show" and
9481				// there is still data from a stopped show/hide
9482				if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
9483					hidden = true;
9484
9485				// Ignore all other no-op show/hide data
9486				} else {
9487					continue;
9488				}
9489			}
9490			orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
9491		}
9492	}
9493
9494	// Bail out if this is a no-op like .hide().hide()
9495	propTween = !jQuery.isEmptyObject( props );
9496	if ( !propTween && jQuery.isEmptyObject( orig ) ) {
9497		return;
9498	}
9499
9500	// Restrict "overflow" and "display" styles during box animations
9501	if ( isBox && elem.nodeType === 1 ) {
9502
9503		// Support: IE <=9 - 11, Edge 12 - 15
9504		// Record all 3 overflow attributes because IE does not infer the shorthand
9505		// from identically-valued overflowX and overflowY and Edge just mirrors
9506		// the overflowX value there.
9507		opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
9508
9509		// Identify a display type, preferring old show/hide data over the CSS cascade
9510		restoreDisplay = dataShow && dataShow.display;
9511		if ( restoreDisplay == null ) {
9512			restoreDisplay = dataPriv.get( elem, "display" );
9513		}
9514		display = jQuery.css( elem, "display" );
9515		if ( display === "none" ) {
9516			if ( restoreDisplay ) {
9517				display = restoreDisplay;
9518			} else {
9519
9520				// Get nonempty value(s) by temporarily forcing visibility
9521				showHide( [ elem ], true );
9522				restoreDisplay = elem.style.display || restoreDisplay;
9523				display = jQuery.css( elem, "display" );
9524				showHide( [ elem ] );
9525			}
9526		}
9527
9528		// Animate inline elements as inline-block
9529		if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
9530			if ( jQuery.css( elem, "float" ) === "none" ) {
9531
9532				// Restore the original display value at the end of pure show/hide animations
9533				if ( !propTween ) {
9534					anim.done( function() {
9535						style.display = restoreDisplay;
9536					} );
9537					if ( restoreDisplay == null ) {
9538						display = style.display;
9539						restoreDisplay = display === "none" ? "" : display;
9540					}
9541				}
9542				style.display = "inline-block";
9543			}
9544		}
9545	}
9546
9547	if ( opts.overflow ) {
9548		style.overflow = "hidden";
9549		anim.always( function() {
9550			style.overflow = opts.overflow[ 0 ];
9551			style.overflowX = opts.overflow[ 1 ];
9552			style.overflowY = opts.overflow[ 2 ];
9553		} );
9554	}
9555
9556	// Implement show/hide animations
9557	propTween = false;
9558	for ( prop in orig ) {
9559
9560		// General show/hide setup for this element animation
9561		if ( !propTween ) {
9562			if ( dataShow ) {
9563				if ( "hidden" in dataShow ) {
9564					hidden = dataShow.hidden;
9565				}
9566			} else {
9567				dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
9568			}
9569
9570			// Store hidden/visible for toggle so `.stop().toggle()` "reverses"
9571			if ( toggle ) {
9572				dataShow.hidden = !hidden;
9573			}
9574
9575			// Show elements before animating them
9576			if ( hidden ) {
9577				showHide( [ elem ], true );
9578			}
9579
9580			/* eslint-disable no-loop-func */
9581
9582			anim.done( function() {
9583
9584			/* eslint-enable no-loop-func */
9585
9586				// The final step of a "hide" animation is actually hiding the element
9587				if ( !hidden ) {
9588					showHide( [ elem ] );
9589				}
9590				dataPriv.remove( elem, "fxshow" );
9591				for ( prop in orig ) {
9592					jQuery.style( elem, prop, orig[ prop ] );
9593				}
9594			} );
9595		}
9596
9597		// Per-property setup
9598		propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
9599		if ( !( prop in dataShow ) ) {
9600			dataShow[ prop ] = propTween.start;
9601			if ( hidden ) {
9602				propTween.end = propTween.start;
9603				propTween.start = 0;
9604			}
9605		}
9606	}
9607}
9608
9609function propFilter( props, specialEasing ) {
9610	var index, name, easing, value, hooks;
9611
9612	// camelCase, specialEasing and expand cssHook pass
9613	for ( index in props ) {
9614		name = camelCase( index );
9615		easing = specialEasing[ name ];
9616		value = props[ index ];
9617		if ( Array.isArray( value ) ) {
9618			easing = value[ 1 ];
9619			value = props[ index ] = value[ 0 ];
9620		}
9621
9622		if ( index !== name ) {
9623			props[ name ] = value;
9624			delete props[ index ];
9625		}
9626
9627		hooks = jQuery.cssHooks[ name ];
9628		if ( hooks && "expand" in hooks ) {
9629			value = hooks.expand( value );
9630			delete props[ name ];
9631
9632			// Not quite $.extend, this won't overwrite existing keys.
9633			// Reusing 'index' because we have the correct "name"
9634			for ( index in value ) {
9635				if ( !( index in props ) ) {
9636					props[ index ] = value[ index ];
9637					specialEasing[ index ] = easing;
9638				}
9639			}
9640		} else {
9641			specialEasing[ name ] = easing;
9642		}
9643	}
9644}
9645
9646function Animation( elem, properties, options ) {
9647	var result,
9648		stopped,
9649		index = 0,
9650		length = Animation.prefilters.length,
9651		deferred = jQuery.Deferred().always( function() {
9652
9653			// Don't match elem in the :animated selector
9654			delete tick.elem;
9655		} ),
9656		tick = function() {
9657			if ( stopped ) {
9658				return false;
9659			}
9660			var currentTime = fxNow || createFxNow(),
9661				remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
9662
9663				// Support: Android 2.3 only
9664				// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
9665				temp = remaining / animation.duration || 0,
9666				percent = 1 - temp,
9667				index = 0,
9668				length = animation.tweens.length;
9669
9670			for ( ; index < length; index++ ) {
9671				animation.tweens[ index ].run( percent );
9672			}
9673
9674			deferred.notifyWith( elem, [ animation, percent, remaining ] );
9675
9676			// If there's more to do, yield
9677			if ( percent < 1 && length ) {
9678				return remaining;
9679			}
9680
9681			// If this was an empty animation, synthesize a final progress notification
9682			if ( !length ) {
9683				deferred.notifyWith( elem, [ animation, 1, 0 ] );
9684			}
9685
9686			// Resolve the animation and report its conclusion
9687			deferred.resolveWith( elem, [ animation ] );
9688			return false;
9689		},
9690		animation = deferred.promise( {
9691			elem: elem,
9692			props: jQuery.extend( {}, properties ),
9693			opts: jQuery.extend( true, {
9694				specialEasing: {},
9695				easing: jQuery.easing._default
9696			}, options ),
9697			originalProperties: properties,
9698			originalOptions: options,
9699			startTime: fxNow || createFxNow(),
9700			duration: options.duration,
9701			tweens: [],
9702			createTween: function( prop, end ) {
9703				var tween = jQuery.Tween( elem, animation.opts, prop, end,
9704						animation.opts.specialEasing[ prop ] || animation.opts.easing );
9705				animation.tweens.push( tween );
9706				return tween;
9707			},
9708			stop: function( gotoEnd ) {
9709				var index = 0,
9710
9711					// If we are going to the end, we want to run all the tweens
9712					// otherwise we skip this part
9713					length = gotoEnd ? animation.tweens.length : 0;
9714				if ( stopped ) {
9715					return this;
9716				}
9717				stopped = true;
9718				for ( ; index < length; index++ ) {
9719					animation.tweens[ index ].run( 1 );
9720				}
9721
9722				// Resolve when we played the last frame; otherwise, reject
9723				if ( gotoEnd ) {
9724					deferred.notifyWith( elem, [ animation, 1, 0 ] );
9725					deferred.resolveWith( elem, [ animation, gotoEnd ] );
9726				} else {
9727					deferred.rejectWith( elem, [ animation, gotoEnd ] );
9728				}
9729				return this;
9730			}
9731		} ),
9732		props = animation.props;
9733
9734	propFilter( props, animation.opts.specialEasing );
9735
9736	for ( ; index < length; index++ ) {
9737		result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
9738		if ( result ) {
9739			if ( isFunction( result.stop ) ) {
9740				jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
9741					result.stop.bind( result );
9742			}
9743			return result;
9744		}
9745	}
9746
9747	jQuery.map( props, createTween, animation );
9748
9749	if ( isFunction( animation.opts.start ) ) {
9750		animation.opts.start.call( elem, animation );
9751	}
9752
9753	// Attach callbacks from options
9754	animation
9755		.progress( animation.opts.progress )
9756		.done( animation.opts.done, animation.opts.complete )
9757		.fail( animation.opts.fail )
9758		.always( animation.opts.always );
9759
9760	jQuery.fx.timer(
9761		jQuery.extend( tick, {
9762			elem: elem,
9763			anim: animation,
9764			queue: animation.opts.queue
9765		} )
9766	);
9767
9768	return animation;
9769}
9770
9771jQuery.Animation = jQuery.extend( Animation, {
9772
9773	tweeners: {
9774		"*": [ function( prop, value ) {
9775			var tween = this.createTween( prop, value );
9776			adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
9777			return tween;
9778		} ]
9779	},
9780
9781	tweener: function( props, callback ) {
9782		if ( isFunction( props ) ) {
9783			callback = props;
9784			props = [ "*" ];
9785		} else {
9786			props = props.match( rnothtmlwhite );
9787		}
9788
9789		var prop,
9790			index = 0,
9791			length = props.length;
9792
9793		for ( ; index < length; index++ ) {
9794			prop = props[ index ];
9795			Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
9796			Animation.tweeners[ prop ].unshift( callback );
9797		}
9798	},
9799
9800	prefilters: [ defaultPrefilter ],
9801
9802	prefilter: function( callback, prepend ) {
9803		if ( prepend ) {
9804			Animation.prefilters.unshift( callback );
9805		} else {
9806			Animation.prefilters.push( callback );
9807		}
9808	}
9809} );
9810
9811jQuery.speed = function( speed, easing, fn ) {
9812	var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
9813		complete: fn || !fn && easing ||
9814			isFunction( speed ) && speed,
9815		duration: speed,
9816		easing: fn && easing || easing && !isFunction( easing ) && easing
9817	};
9818
9819	// Go to the end state if fx are off
9820	if ( jQuery.fx.off ) {
9821		opt.duration = 0;
9822
9823	} else {
9824		if ( typeof opt.duration !== "number" ) {
9825			if ( opt.duration in jQuery.fx.speeds ) {
9826				opt.duration = jQuery.fx.speeds[ opt.duration ];
9827
9828			} else {
9829				opt.duration = jQuery.fx.speeds._default;
9830			}
9831		}
9832	}
9833
9834	// Normalize opt.queue - true/undefined/null -> "fx"
9835	if ( opt.queue == null || opt.queue === true ) {
9836		opt.queue = "fx";
9837	}
9838
9839	// Queueing
9840	opt.old = opt.complete;
9841
9842	opt.complete = function() {
9843		if ( isFunction( opt.old ) ) {
9844			opt.old.call( this );
9845		}
9846
9847		if ( opt.queue ) {
9848			jQuery.dequeue( this, opt.queue );
9849		}
9850	};
9851
9852	return opt;
9853};
9854
9855jQuery.fn.extend( {
9856	fadeTo: function( speed, to, easing, callback ) {
9857
9858		// Show any hidden elements after setting opacity to 0
9859		return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()
9860
9861			// Animate to the value specified
9862			.end().animate( { opacity: to }, speed, easing, callback );
9863	},
9864	animate: function( prop, speed, easing, callback ) {
9865		var empty = jQuery.isEmptyObject( prop ),
9866			optall = jQuery.speed( speed, easing, callback ),
9867			doAnimation = function() {
9868
9869				// Operate on a copy of prop so per-property easing won't be lost
9870				var anim = Animation( this, jQuery.extend( {}, prop ), optall );
9871
9872				// Empty animations, or finishing resolves immediately
9873				if ( empty || dataPriv.get( this, "finish" ) ) {
9874					anim.stop( true );
9875				}
9876			};
9877			doAnimation.finish = doAnimation;
9878
9879		return empty || optall.queue === false ?
9880			this.each( doAnimation ) :
9881			this.queue( optall.queue, doAnimation );
9882	},
9883	stop: function( type, clearQueue, gotoEnd ) {
9884		var stopQueue = function( hooks ) {
9885			var stop = hooks.stop;
9886			delete hooks.stop;
9887			stop( gotoEnd );
9888		};
9889
9890		if ( typeof type !== "string" ) {
9891			gotoEnd = clearQueue;
9892			clearQueue = type;
9893			type = undefined;
9894		}
9895		if ( clearQueue && type !== false ) {
9896			this.queue( type || "fx", [] );
9897		}
9898
9899		return this.each( function() {
9900			var dequeue = true,
9901				index = type != null && type + "queueHooks",
9902				timers = jQuery.timers,
9903				data = dataPriv.get( this );
9904
9905			if ( index ) {
9906				if ( data[ index ] && data[ index ].stop ) {
9907					stopQueue( data[ index ] );
9908				}
9909			} else {
9910				for ( index in data ) {
9911					if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
9912						stopQueue( data[ index ] );
9913					}
9914				}
9915			}
9916
9917			for ( index = timers.length; index--; ) {
9918				if ( timers[ index ].elem === this &&
9919					( type == null || timers[ index ].queue === type ) ) {
9920
9921					timers[ index ].anim.stop( gotoEnd );
9922					dequeue = false;
9923					timers.splice( index, 1 );
9924				}
9925			}
9926
9927			// Start the next in the queue if the last step wasn't forced.
9928			// Timers currently will call their complete callbacks, which
9929			// will dequeue but only if they were gotoEnd.
9930			if ( dequeue || !gotoEnd ) {
9931				jQuery.dequeue( this, type );
9932			}
9933		} );
9934	},
9935	finish: function( type ) {
9936		if ( type !== false ) {
9937			type = type || "fx";
9938		}
9939		return this.each( function() {
9940			var index,
9941				data = dataPriv.get( this ),
9942				queue = data[ type + "queue" ],
9943				hooks = data[ type + "queueHooks" ],
9944				timers = jQuery.timers,
9945				length = queue ? queue.length : 0;
9946
9947			// Enable finishing flag on private data
9948			data.finish = true;
9949
9950			// Empty the queue first
9951			jQuery.queue( this, type, [] );
9952
9953			if ( hooks && hooks.stop ) {
9954				hooks.stop.call( this, true );
9955			}
9956
9957			// Look for any active animations, and finish them
9958			for ( index = timers.length; index--; ) {
9959				if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
9960					timers[ index ].anim.stop( true );
9961					timers.splice( index, 1 );
9962				}
9963			}
9964
9965			// Look for any animations in the old queue and finish them
9966			for ( index = 0; index < length; index++ ) {
9967				if ( queue[ index ] && queue[ index ].finish ) {
9968					queue[ index ].finish.call( this );
9969				}
9970			}
9971
9972			// Turn off finishing flag
9973			delete data.finish;
9974		} );
9975	}
9976} );
9977
9978jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) {
9979	var cssFn = jQuery.fn[ name ];
9980	jQuery.fn[ name ] = function( speed, easing, callback ) {
9981		return speed == null || typeof speed === "boolean" ?
9982			cssFn.apply( this, arguments ) :
9983			this.animate( genFx( name, true ), speed, easing, callback );
9984	};
9985} );
9986
9987// Generate shortcuts for custom animations
9988jQuery.each( {
9989	slideDown: genFx( "show" ),
9990	slideUp: genFx( "hide" ),
9991	slideToggle: genFx( "toggle" ),
9992	fadeIn: { opacity: "show" },
9993	fadeOut: { opacity: "hide" },
9994	fadeToggle: { opacity: "toggle" }
9995}, function( name, props ) {
9996	jQuery.fn[ name ] = function( speed, easing, callback ) {
9997		return this.animate( props, speed, easing, callback );
9998	};
9999} );
10000
10001jQuery.timers = [];
10002jQuery.fx.tick = function() {
10003	var timer,
10004		i = 0,
10005		timers = jQuery.timers;
10006
10007	fxNow = Date.now();
10008
10009	for ( ; i < timers.length; i++ ) {
10010		timer = timers[ i ];
10011
10012		// Run the timer and safely remove it when done (allowing for external removal)
10013		if ( !timer() && timers[ i ] === timer ) {
10014			timers.splice( i--, 1 );
10015		}
10016	}
10017
10018	if ( !timers.length ) {
10019		jQuery.fx.stop();
10020	}
10021	fxNow = undefined;
10022};
10023
10024jQuery.fx.timer = function( timer ) {
10025	jQuery.timers.push( timer );
10026	jQuery.fx.start();
10027};
10028
10029jQuery.fx.interval = 13;
10030jQuery.fx.start = function() {
10031	if ( inProgress ) {
10032		return;
10033	}
10034
10035	inProgress = true;
10036	schedule();
10037};
10038
10039jQuery.fx.stop = function() {
10040	inProgress = null;
10041};
10042
10043jQuery.fx.speeds = {
10044	slow: 600,
10045	fast: 200,
10046
10047	// Default speed
10048	_default: 400
10049};
10050
10051
10052// Based off of the plugin by Clint Helfers, with permission.
10053// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
10054jQuery.fn.delay = function( time, type ) {
10055	time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
10056	type = type || "fx";
10057
10058	return this.queue( type, function( next, hooks ) {
10059		var timeout = window.setTimeout( next, time );
10060		hooks.stop = function() {
10061			window.clearTimeout( timeout );
10062		};
10063	} );
10064};
10065
10066
10067( function() {
10068	var input = document.createElement( "input" ),
10069		select = document.createElement( "select" ),
10070		opt = select.appendChild( document.createElement( "option" ) );
10071
10072	input.type = "checkbox";
10073
10074	// Support: Android <=4.3 only
10075	// Default value for a checkbox should be "on"
10076	support.checkOn = input.value !== "";
10077
10078	// Support: IE <=11 only
10079	// Must access selectedIndex to make default options select
10080	support.optSelected = opt.selected;
10081
10082	// Support: IE <=11 only
10083	// An input loses its value after becoming a radio
10084	input = document.createElement( "input" );
10085	input.value = "t";
10086	input.type = "radio";
10087	support.radioValue = input.value === "t";
10088} )();
10089
10090
10091var boolHook,
10092	attrHandle = jQuery.expr.attrHandle;
10093
10094jQuery.fn.extend( {
10095	attr: function( name, value ) {
10096		return access( this, jQuery.attr, name, value, arguments.length > 1 );
10097	},
10098
10099	removeAttr: function( name ) {
10100		return this.each( function() {
10101			jQuery.removeAttr( this, name );
10102		} );
10103	}
10104} );
10105
10106jQuery.extend( {
10107	attr: function( elem, name, value ) {
10108		var ret, hooks,
10109			nType = elem.nodeType;
10110
10111		// Don't get/set attributes on text, comment and attribute nodes
10112		if ( nType === 3 || nType === 8 || nType === 2 ) {
10113			return;
10114		}
10115
10116		// Fallback to prop when attributes are not supported
10117		if ( typeof elem.getAttribute === "undefined" ) {
10118			return jQuery.prop( elem, name, value );
10119		}
10120
10121		// Attribute hooks are determined by the lowercase version
10122		// Grab necessary hook if one is defined
10123		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
10124			hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
10125				( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
10126		}
10127
10128		if ( value !== undefined ) {
10129			if ( value === null ) {
10130				jQuery.removeAttr( elem, name );
10131				return;
10132			}
10133
10134			if ( hooks && "set" in hooks &&
10135				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
10136				return ret;
10137			}
10138
10139			elem.setAttribute( name, value + "" );
10140			return value;
10141		}
10142
10143		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
10144			return ret;
10145		}
10146
10147		ret = jQuery.find.attr( elem, name );
10148
10149		// Non-existent attributes return null, we normalize to undefined
10150		return ret == null ? undefined : ret;
10151	},
10152
10153	attrHooks: {
10154		type: {
10155			set: function( elem, value ) {
10156				if ( !support.radioValue && value === "radio" &&
10157					nodeName( elem, "input" ) ) {
10158					var val = elem.value;
10159					elem.setAttribute( "type", value );
10160					if ( val ) {
10161						elem.value = val;
10162					}
10163					return value;
10164				}
10165			}
10166		}
10167	},
10168
10169	removeAttr: function( elem, value ) {
10170		var name,
10171			i = 0,
10172
10173			// Attribute names can contain non-HTML whitespace characters
10174			// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
10175			attrNames = value && value.match( rnothtmlwhite );
10176
10177		if ( attrNames && elem.nodeType === 1 ) {
10178			while ( ( name = attrNames[ i++ ] ) ) {
10179				elem.removeAttribute( name );
10180			}
10181		}
10182	}
10183} );
10184
10185// Hooks for boolean attributes
10186boolHook = {
10187	set: function( elem, value, name ) {
10188		if ( value === false ) {
10189
10190			// Remove boolean attributes when set to false
10191			jQuery.removeAttr( elem, name );
10192		} else {
10193			elem.setAttribute( name, name );
10194		}
10195		return name;
10196	}
10197};
10198
10199jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
10200	var getter = attrHandle[ name ] || jQuery.find.attr;
10201
10202	attrHandle[ name ] = function( elem, name, isXML ) {
10203		var ret, handle,
10204			lowercaseName = name.toLowerCase();
10205
10206		if ( !isXML ) {
10207
10208			// Avoid an infinite loop by temporarily removing this function from the getter
10209			handle = attrHandle[ lowercaseName ];
10210			attrHandle[ lowercaseName ] = ret;
10211			ret = getter( elem, name, isXML ) != null ?
10212				lowercaseName :
10213				null;
10214			attrHandle[ lowercaseName ] = handle;
10215		}
10216		return ret;
10217	};
10218} );
10219
10220
10221
10222
10223var rfocusable = /^(?:input|select|textarea|button)$/i,
10224	rclickable = /^(?:a|area)$/i;
10225
10226jQuery.fn.extend( {
10227	prop: function( name, value ) {
10228		return access( this, jQuery.prop, name, value, arguments.length > 1 );
10229	},
10230
10231	removeProp: function( name ) {
10232		return this.each( function() {
10233			delete this[ jQuery.propFix[ name ] || name ];
10234		} );
10235	}
10236} );
10237
10238jQuery.extend( {
10239	prop: function( elem, name, value ) {
10240		var ret, hooks,
10241			nType = elem.nodeType;
10242
10243		// Don't get/set properties on text, comment and attribute nodes
10244		if ( nType === 3 || nType === 8 || nType === 2 ) {
10245			return;
10246		}
10247
10248		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
10249
10250			// Fix name and attach hooks
10251			name = jQuery.propFix[ name ] || name;
10252			hooks = jQuery.propHooks[ name ];
10253		}
10254
10255		if ( value !== undefined ) {
10256			if ( hooks && "set" in hooks &&
10257				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
10258				return ret;
10259			}
10260
10261			return ( elem[ name ] = value );
10262		}
10263
10264		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
10265			return ret;
10266		}
10267
10268		return elem[ name ];
10269	},
10270
10271	propHooks: {
10272		tabIndex: {
10273			get: function( elem ) {
10274
10275				// Support: IE <=9 - 11 only
10276				// elem.tabIndex doesn't always return the
10277				// correct value when it hasn't been explicitly set
10278				// https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
10279				// Use proper attribute retrieval(#12072)
10280				var tabindex = jQuery.find.attr( elem, "tabindex" );
10281
10282				if ( tabindex ) {
10283					return parseInt( tabindex, 10 );
10284				}
10285
10286				if (
10287					rfocusable.test( elem.nodeName ) ||
10288					rclickable.test( elem.nodeName ) &&
10289					elem.href
10290				) {
10291					return 0;
10292				}
10293
10294				return -1;
10295			}
10296		}
10297	},
10298
10299	propFix: {
10300		"for": "htmlFor",
10301		"class": "className"
10302	}
10303} );
10304
10305// Support: IE <=11 only
10306// Accessing the selectedIndex property
10307// forces the browser to respect setting selected
10308// on the option
10309// The getter ensures a default option is selected
10310// when in an optgroup
10311// eslint rule "no-unused-expressions" is disabled for this code
10312// since it considers such accessions noop
10313if ( !support.optSelected ) {
10314	jQuery.propHooks.selected = {
10315		get: function( elem ) {
10316
10317			/* eslint no-unused-expressions: "off" */
10318
10319			var parent = elem.parentNode;
10320			if ( parent && parent.parentNode ) {
10321				parent.parentNode.selectedIndex;
10322			}
10323			return null;
10324		},
10325		set: function( elem ) {
10326
10327			/* eslint no-unused-expressions: "off" */
10328
10329			var parent = elem.parentNode;
10330			if ( parent ) {
10331				parent.selectedIndex;
10332
10333				if ( parent.parentNode ) {
10334					parent.parentNode.selectedIndex;
10335				}
10336			}
10337		}
10338	};
10339}
10340
10341jQuery.each( [
10342	"tabIndex",
10343	"readOnly",
10344	"maxLength",
10345	"cellSpacing",
10346	"cellPadding",
10347	"rowSpan",
10348	"colSpan",
10349	"useMap",
10350	"frameBorder",
10351	"contentEditable"
10352], function() {
10353	jQuery.propFix[ this.toLowerCase() ] = this;
10354} );
10355
10356
10357
10358
10359	// Strip and collapse whitespace according to HTML spec
10360	// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
10361	function stripAndCollapse( value ) {
10362		var tokens = value.match( rnothtmlwhite ) || [];
10363		return tokens.join( " " );
10364	}
10365
10366
10367function getClass( elem ) {
10368	return elem.getAttribute && elem.getAttribute( "class" ) || "";
10369}
10370
10371function classesToArray( value ) {
10372	if ( Array.isArray( value ) ) {
10373		return value;
10374	}
10375	if ( typeof value === "string" ) {
10376		return value.match( rnothtmlwhite ) || [];
10377	}
10378	return [];
10379}
10380
10381jQuery.fn.extend( {
10382	addClass: function( value ) {
10383		var classes, elem, cur, curValue, clazz, j, finalValue,
10384			i = 0;
10385
10386		if ( isFunction( value ) ) {
10387			return this.each( function( j ) {
10388				jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
10389			} );
10390		}
10391
10392		classes = classesToArray( value );
10393
10394		if ( classes.length ) {
10395			while ( ( elem = this[ i++ ] ) ) {
10396				curValue = getClass( elem );
10397				cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
10398
10399				if ( cur ) {
10400					j = 0;
10401					while ( ( clazz = classes[ j++ ] ) ) {
10402						if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
10403							cur += clazz + " ";
10404						}
10405					}
10406
10407					// Only assign if different to avoid unneeded rendering.
10408					finalValue = stripAndCollapse( cur );
10409					if ( curValue !== finalValue ) {
10410						elem.setAttribute( "class", finalValue );
10411					}
10412				}
10413			}
10414		}
10415
10416		return this;
10417	},
10418
10419	removeClass: function( value ) {
10420		var classes, elem, cur, curValue, clazz, j, finalValue,
10421			i = 0;
10422
10423		if ( isFunction( value ) ) {
10424			return this.each( function( j ) {
10425				jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
10426			} );
10427		}
10428
10429		if ( !arguments.length ) {
10430			return this.attr( "class", "" );
10431		}
10432
10433		classes = classesToArray( value );
10434
10435		if ( classes.length ) {
10436			while ( ( elem = this[ i++ ] ) ) {
10437				curValue = getClass( elem );
10438
10439				// This expression is here for better compressibility (see addClass)
10440				cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
10441
10442				if ( cur ) {
10443					j = 0;
10444					while ( ( clazz = classes[ j++ ] ) ) {
10445
10446						// Remove *all* instances
10447						while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
10448							cur = cur.replace( " " + clazz + " ", " " );
10449						}
10450					}
10451
10452					// Only assign if different to avoid unneeded rendering.
10453					finalValue = stripAndCollapse( cur );
10454					if ( curValue !== finalValue ) {
10455						elem.setAttribute( "class", finalValue );
10456					}
10457				}
10458			}
10459		}
10460
10461		return this;
10462	},
10463
10464	toggleClass: function( value, stateVal ) {
10465		var type = typeof value,
10466			isValidValue = type === "string" || Array.isArray( value );
10467
10468		if ( typeof stateVal === "boolean" && isValidValue ) {
10469			return stateVal ? this.addClass( value ) : this.removeClass( value );
10470		}
10471
10472		if ( isFunction( value ) ) {
10473			return this.each( function( i ) {
10474				jQuery( this ).toggleClass(
10475					value.call( this, i, getClass( this ), stateVal ),
10476					stateVal
10477				);
10478			} );
10479		}
10480
10481		return this.each( function() {
10482			var className, i, self, classNames;
10483
10484			if ( isValidValue ) {
10485
10486				// Toggle individual class names
10487				i = 0;
10488				self = jQuery( this );
10489				classNames = classesToArray( value );
10490
10491				while ( ( className = classNames[ i++ ] ) ) {
10492
10493					// Check each className given, space separated list
10494					if ( self.hasClass( className ) ) {
10495						self.removeClass( className );
10496					} else {
10497						self.addClass( className );
10498					}
10499				}
10500
10501			// Toggle whole class name
10502			} else if ( value === undefined || type === "boolean" ) {
10503				className = getClass( this );
10504				if ( className ) {
10505
10506					// Store className if set
10507					dataPriv.set( this, "__className__", className );
10508				}
10509
10510				// If the element has a class name or if we're passed `false`,
10511				// then remove the whole classname (if there was one, the above saved it).
10512				// Otherwise bring back whatever was previously saved (if anything),
10513				// falling back to the empty string if nothing was stored.
10514				if ( this.setAttribute ) {
10515					this.setAttribute( "class",
10516						className || value === false ?
10517						"" :
10518						dataPriv.get( this, "__className__" ) || ""
10519					);
10520				}
10521			}
10522		} );
10523	},
10524
10525	hasClass: function( selector ) {
10526		var className, elem,
10527			i = 0;
10528
10529		className = " " + selector + " ";
10530		while ( ( elem = this[ i++ ] ) ) {
10531			if ( elem.nodeType === 1 &&
10532				( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {
10533					return true;
10534			}
10535		}
10536
10537		return false;
10538	}
10539} );
10540
10541
10542
10543
10544var rreturn = /\r/g;
10545
10546jQuery.fn.extend( {
10547	val: function( value ) {
10548		var hooks, ret, valueIsFunction,
10549			elem = this[ 0 ];
10550
10551		if ( !arguments.length ) {
10552			if ( elem ) {
10553				hooks = jQuery.valHooks[ elem.type ] ||
10554					jQuery.valHooks[ elem.nodeName.toLowerCase() ];
10555
10556				if ( hooks &&
10557					"get" in hooks &&
10558					( ret = hooks.get( elem, "value" ) ) !== undefined
10559				) {
10560					return ret;
10561				}
10562
10563				ret = elem.value;
10564
10565				// Handle most common string cases
10566				if ( typeof ret === "string" ) {
10567					return ret.replace( rreturn, "" );
10568				}
10569
10570				// Handle cases where value is null/undef or number
10571				return ret == null ? "" : ret;
10572			}
10573
10574			return;
10575		}
10576
10577		valueIsFunction = isFunction( value );
10578
10579		return this.each( function( i ) {
10580			var val;
10581
10582			if ( this.nodeType !== 1 ) {
10583				return;
10584			}
10585
10586			if ( valueIsFunction ) {
10587				val = value.call( this, i, jQuery( this ).val() );
10588			} else {
10589				val = value;
10590			}
10591
10592			// Treat null/undefined as ""; convert numbers to string
10593			if ( val == null ) {
10594				val = "";
10595
10596			} else if ( typeof val === "number" ) {
10597				val += "";
10598
10599			} else if ( Array.isArray( val ) ) {
10600				val = jQuery.map( val, function( value ) {
10601					return value == null ? "" : value + "";
10602				} );
10603			}
10604
10605			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
10606
10607			// If set returns undefined, fall back to normal setting
10608			if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
10609				this.value = val;
10610			}
10611		} );
10612	}
10613} );
10614
10615jQuery.extend( {
10616	valHooks: {
10617		option: {
10618			get: function( elem ) {
10619
10620				var val = jQuery.find.attr( elem, "value" );
10621				return val != null ?
10622					val :
10623
10624					// Support: IE <=10 - 11 only
10625					// option.text throws exceptions (#14686, #14858)
10626					// Strip and collapse whitespace
10627					// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
10628					stripAndCollapse( jQuery.text( elem ) );
10629			}
10630		},
10631		select: {
10632			get: function( elem ) {
10633				var value, option, i,
10634					options = elem.options,
10635					index = elem.selectedIndex,
10636					one = elem.type === "select-one",
10637					values = one ? null : [],
10638					max = one ? index + 1 : options.length;
10639
10640				if ( index < 0 ) {
10641					i = max;
10642
10643				} else {
10644					i = one ? index : 0;
10645				}
10646
10647				// Loop through all the selected options
10648				for ( ; i < max; i++ ) {
10649					option = options[ i ];
10650
10651					// Support: IE <=9 only
10652					// IE8-9 doesn't update selected after form reset (#2551)
10653					if ( ( option.selected || i === index ) &&
10654
10655							// Don't return options that are disabled or in a disabled optgroup
10656							!option.disabled &&
10657							( !option.parentNode.disabled ||
10658								!nodeName( option.parentNode, "optgroup" ) ) ) {
10659
10660						// Get the specific value for the option
10661						value = jQuery( option ).val();
10662
10663						// We don't need an array for one selects
10664						if ( one ) {
10665							return value;
10666						}
10667
10668						// Multi-Selects return an array
10669						values.push( value );
10670					}
10671				}
10672
10673				return values;
10674			},
10675
10676			set: function( elem, value ) {
10677				var optionSet, option,
10678					options = elem.options,
10679					values = jQuery.makeArray( value ),
10680					i = options.length;
10681
10682				while ( i-- ) {
10683					option = options[ i ];
10684
10685					/* eslint-disable no-cond-assign */
10686
10687					if ( option.selected =
10688						jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
10689					) {
10690						optionSet = true;
10691					}
10692
10693					/* eslint-enable no-cond-assign */
10694				}
10695
10696				// Force browsers to behave consistently when non-matching value is set
10697				if ( !optionSet ) {
10698					elem.selectedIndex = -1;
10699				}
10700				return values;
10701			}
10702		}
10703	}
10704} );
10705
10706// Radios and checkboxes getter/setter
10707jQuery.each( [ "radio", "checkbox" ], function() {
10708	jQuery.valHooks[ this ] = {
10709		set: function( elem, value ) {
10710			if ( Array.isArray( value ) ) {
10711				return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
10712			}
10713		}
10714	};
10715	if ( !support.checkOn ) {
10716		jQuery.valHooks[ this ].get = function( elem ) {
10717			return elem.getAttribute( "value" ) === null ? "on" : elem.value;
10718		};
10719	}
10720} );
10721
10722
10723
10724
10725// Return jQuery for attributes-only inclusion
10726
10727
10728support.focusin = "onfocusin" in window;
10729
10730
10731var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
10732	stopPropagationCallback = function( e ) {
10733		e.stopPropagation();
10734	};
10735
10736jQuery.extend( jQuery.event, {
10737
10738	trigger: function( event, data, elem, onlyHandlers ) {
10739
10740		var i, cur, tmp, bubbleType, ontype, handle, special, lastElement,
10741			eventPath = [ elem || document ],
10742			type = hasOwn.call( event, "type" ) ? event.type : event,
10743			namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
10744
10745		cur = lastElement = tmp = elem = elem || document;
10746
10747		// Don't do events on text and comment nodes
10748		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
10749			return;
10750		}
10751
10752		// focus/blur morphs to focusin/out; ensure we're not firing them right now
10753		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
10754			return;
10755		}
10756
10757		if ( type.indexOf( "." ) > -1 ) {
10758
10759			// Namespaced trigger; create a regexp to match event type in handle()
10760			namespaces = type.split( "." );
10761			type = namespaces.shift();
10762			namespaces.sort();
10763		}
10764		ontype = type.indexOf( ":" ) < 0 && "on" + type;
10765
10766		// Caller can pass in a jQuery.Event object, Object, or just an event type string
10767		event = event[ jQuery.expando ] ?
10768			event :
10769			new jQuery.Event( type, typeof event === "object" && event );
10770
10771		// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
10772		event.isTrigger = onlyHandlers ? 2 : 3;
10773		event.namespace = namespaces.join( "." );
10774		event.rnamespace = event.namespace ?
10775			new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
10776			null;
10777
10778		// Clean up the event in case it is being reused
10779		event.result = undefined;
10780		if ( !event.target ) {
10781			event.target = elem;
10782		}
10783
10784		// Clone any incoming data and prepend the event, creating the handler arg list
10785		data = data == null ?
10786			[ event ] :
10787			jQuery.makeArray( data, [ event ] );
10788
10789		// Allow special events to draw outside the lines
10790		special = jQuery.event.special[ type ] || {};
10791		if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
10792			return;
10793		}
10794
10795		// Determine event propagation path in advance, per W3C events spec (#9951)
10796		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
10797		if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {
10798
10799			bubbleType = special.delegateType || type;
10800			if ( !rfocusMorph.test( bubbleType + type ) ) {
10801				cur = cur.parentNode;
10802			}
10803			for ( ; cur; cur = cur.parentNode ) {
10804				eventPath.push( cur );
10805				tmp = cur;
10806			}
10807
10808			// Only add window if we got to document (e.g., not plain obj or detached DOM)
10809			if ( tmp === ( elem.ownerDocument || document ) ) {
10810				eventPath.push( tmp.defaultView || tmp.parentWindow || window );
10811			}
10812		}
10813
10814		// Fire handlers on the event path
10815		i = 0;
10816		while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
10817			lastElement = cur;
10818			event.type = i > 1 ?
10819				bubbleType :
10820				special.bindType || type;
10821
10822			// jQuery handler
10823			handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] &&
10824				dataPriv.get( cur, "handle" );
10825			if ( handle ) {
10826				handle.apply( cur, data );
10827			}
10828
10829			// Native handler
10830			handle = ontype && cur[ ontype ];
10831			if ( handle && handle.apply && acceptData( cur ) ) {
10832				event.result = handle.apply( cur, data );
10833				if ( event.result === false ) {
10834					event.preventDefault();
10835				}
10836			}
10837		}
10838		event.type = type;
10839
10840		// If nobody prevented the default action, do it now
10841		if ( !onlyHandlers && !event.isDefaultPrevented() ) {
10842
10843			if ( ( !special._default ||
10844				special._default.apply( eventPath.pop(), data ) === false ) &&
10845				acceptData( elem ) ) {
10846
10847				// Call a native DOM method on the target with the same name as the event.
10848				// Don't do default actions on window, that's where global variables be (#6170)
10849				if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {
10850
10851					// Don't re-trigger an onFOO event when we call its FOO() method
10852					tmp = elem[ ontype ];
10853
10854					if ( tmp ) {
10855						elem[ ontype ] = null;
10856					}
10857
10858					// Prevent re-triggering of the same event, since we already bubbled it above
10859					jQuery.event.triggered = type;
10860
10861					if ( event.isPropagationStopped() ) {
10862						lastElement.addEventListener( type, stopPropagationCallback );
10863					}
10864
10865					elem[ type ]();
10866
10867					if ( event.isPropagationStopped() ) {
10868						lastElement.removeEventListener( type, stopPropagationCallback );
10869					}
10870
10871					jQuery.event.triggered = undefined;
10872
10873					if ( tmp ) {
10874						elem[ ontype ] = tmp;
10875					}
10876				}
10877			}
10878		}
10879
10880		return event.result;
10881	},
10882
10883	// Piggyback on a donor event to simulate a different one
10884	// Used only for `focus(in | out)` events
10885	simulate: function( type, elem, event ) {
10886		var e = jQuery.extend(
10887			new jQuery.Event(),
10888			event,
10889			{
10890				type: type,
10891				isSimulated: true
10892			}
10893		);
10894
10895		jQuery.event.trigger( e, null, elem );
10896	}
10897
10898} );
10899
10900jQuery.fn.extend( {
10901
10902	trigger: function( type, data ) {
10903		return this.each( function() {
10904			jQuery.event.trigger( type, data, this );
10905		} );
10906	},
10907	triggerHandler: function( type, data ) {
10908		var elem = this[ 0 ];
10909		if ( elem ) {
10910			return jQuery.event.trigger( type, data, elem, true );
10911		}
10912	}
10913} );
10914
10915
10916// Support: Firefox <=44
10917// Firefox doesn't have focus(in | out) events
10918// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
10919//
10920// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
10921// focus(in | out) events fire after focus & blur events,
10922// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
10923// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
10924if ( !support.focusin ) {
10925	jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {
10926
10927		// Attach a single capturing handler on the document while someone wants focusin/focusout
10928		var handler = function( event ) {
10929			jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
10930		};
10931
10932		jQuery.event.special[ fix ] = {
10933			setup: function() {
10934				var doc = this.ownerDocument || this,
10935					attaches = dataPriv.access( doc, fix );
10936
10937				if ( !attaches ) {
10938					doc.addEventListener( orig, handler, true );
10939				}
10940				dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );
10941			},
10942			teardown: function() {
10943				var doc = this.ownerDocument || this,
10944					attaches = dataPriv.access( doc, fix ) - 1;
10945
10946				if ( !attaches ) {
10947					doc.removeEventListener( orig, handler, true );
10948					dataPriv.remove( doc, fix );
10949
10950				} else {
10951					dataPriv.access( doc, fix, attaches );
10952				}
10953			}
10954		};
10955	} );
10956}
10957var location = window.location;
10958
10959var nonce = Date.now();
10960
10961var rquery = ( /\?/ );
10962
10963
10964
10965// Cross-browser xml parsing
10966jQuery.parseXML = function( data ) {
10967	var xml;
10968	if ( !data || typeof data !== "string" ) {
10969		return null;
10970	}
10971
10972	// Support: IE 9 - 11 only
10973	// IE throws on parseFromString with invalid input.
10974	try {
10975		xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
10976	} catch ( e ) {
10977		xml = undefined;
10978	}
10979
10980	if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {
10981		jQuery.error( "Invalid XML: " + data );
10982	}
10983	return xml;
10984};
10985
10986
10987var
10988	rbracket = /\[\]$/,
10989	rCRLF = /\r?\n/g,
10990	rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
10991	rsubmittable = /^(?:input|select|textarea|keygen)/i;
10992
10993function buildParams( prefix, obj, traditional, add ) {
10994	var name;
10995
10996	if ( Array.isArray( obj ) ) {
10997
10998		// Serialize array item.
10999		jQuery.each( obj, function( i, v ) {
11000			if ( traditional || rbracket.test( prefix ) ) {
11001
11002				// Treat each array item as a scalar.
11003				add( prefix, v );
11004
11005			} else {
11006
11007				// Item is non-scalar (array or object), encode its numeric index.
11008				buildParams(
11009					prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
11010					v,
11011					traditional,
11012					add
11013				);
11014			}
11015		} );
11016
11017	} else if ( !traditional && toType( obj ) === "object" ) {
11018
11019		// Serialize object item.
11020		for ( name in obj ) {
11021			buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
11022		}
11023
11024	} else {
11025
11026		// Serialize scalar item.
11027		add( prefix, obj );
11028	}
11029}
11030
11031// Serialize an array of form elements or a set of
11032// key/values into a query string
11033jQuery.param = function( a, traditional ) {
11034	var prefix,
11035		s = [],
11036		add = function( key, valueOrFunction ) {
11037
11038			// If value is a function, invoke it and use its return value
11039			var value = isFunction( valueOrFunction ) ?
11040				valueOrFunction() :
11041				valueOrFunction;
11042
11043			s[ s.length ] = encodeURIComponent( key ) + "=" +
11044				encodeURIComponent( value == null ? "" : value );
11045		};
11046
11047	if ( a == null ) {
11048		return "";
11049	}
11050
11051	// If an array was passed in, assume that it is an array of form elements.
11052	if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
11053
11054		// Serialize the form elements
11055		jQuery.each( a, function() {
11056			add( this.name, this.value );
11057		} );
11058
11059	} else {
11060
11061		// If traditional, encode the "old" way (the way 1.3.2 or older
11062		// did it), otherwise encode params recursively.
11063		for ( prefix in a ) {
11064			buildParams( prefix, a[ prefix ], traditional, add );
11065		}
11066	}
11067
11068	// Return the resulting serialization
11069	return s.join( "&" );
11070};
11071
11072jQuery.fn.extend( {
11073	serialize: function() {
11074		return jQuery.param( this.serializeArray() );
11075	},
11076	serializeArray: function() {
11077		return this.map( function() {
11078
11079			// Can add propHook for "elements" to filter or add form elements
11080			var elements = jQuery.prop( this, "elements" );
11081			return elements ? jQuery.makeArray( elements ) : this;
11082		} )
11083		.filter( function() {
11084			var type = this.type;
11085
11086			// Use .is( ":disabled" ) so that fieldset[disabled] works
11087			return this.name && !jQuery( this ).is( ":disabled" ) &&
11088				rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
11089				( this.checked || !rcheckableType.test( type ) );
11090		} )
11091		.map( function( i, elem ) {
11092			var val = jQuery( this ).val();
11093
11094			if ( val == null ) {
11095				return null;
11096			}
11097
11098			if ( Array.isArray( val ) ) {
11099				return jQuery.map( val, function( val ) {
11100					return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
11101				} );
11102			}
11103
11104			return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
11105		} ).get();
11106	}
11107} );
11108
11109
11110var
11111	r20 = /%20/g,
11112	rhash = /#.*$/,
11113	rantiCache = /([?&])_=[^&]*/,
11114	rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
11115
11116	// #7653, #8125, #8152: local protocol detection
11117	rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
11118	rnoContent = /^(?:GET|HEAD)$/,
11119	rprotocol = /^\/\//,
11120
11121	/* Prefilters
11122	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
11123	 * 2) These are called:
11124	 *    - BEFORE asking for a transport
11125	 *    - AFTER param serialization (s.data is a string if s.processData is true)
11126	 * 3) key is the dataType
11127	 * 4) the catchall symbol "*" can be used
11128	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
11129	 */
11130	prefilters = {},
11131
11132	/* Transports bindings
11133	 * 1) key is the dataType
11134	 * 2) the catchall symbol "*" can be used
11135	 * 3) selection will start with transport dataType and THEN go to "*" if needed
11136	 */
11137	transports = {},
11138
11139	// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
11140	allTypes = "*/".concat( "*" ),
11141
11142	// Anchor tag for parsing the document origin
11143	originAnchor = document.createElement( "a" );
11144	originAnchor.href = location.href;
11145
11146// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
11147function addToPrefiltersOrTransports( structure ) {
11148
11149	// dataTypeExpression is optional and defaults to "*"
11150	return function( dataTypeExpression, func ) {
11151
11152		if ( typeof dataTypeExpression !== "string" ) {
11153			func = dataTypeExpression;
11154			dataTypeExpression = "*";
11155		}
11156
11157		var dataType,
11158			i = 0,
11159			dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
11160
11161		if ( isFunction( func ) ) {
11162
11163			// For each dataType in the dataTypeExpression
11164			while ( ( dataType = dataTypes[ i++ ] ) ) {
11165
11166				// Prepend if requested
11167				if ( dataType[ 0 ] === "+" ) {
11168					dataType = dataType.slice( 1 ) || "*";
11169					( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
11170
11171				// Otherwise append
11172				} else {
11173					( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
11174				}
11175			}
11176		}
11177	};
11178}
11179
11180// Base inspection function for prefilters and transports
11181function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
11182
11183	var inspected = {},
11184		seekingTransport = ( structure === transports );
11185
11186	function inspect( dataType ) {
11187		var selected;
11188		inspected[ dataType ] = true;
11189		jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
11190			var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
11191			if ( typeof dataTypeOrTransport === "string" &&
11192				!seekingTransport && !inspected[ dataTypeOrTransport ] ) {
11193
11194				options.dataTypes.unshift( dataTypeOrTransport );
11195				inspect( dataTypeOrTransport );
11196				return false;
11197			} else if ( seekingTransport ) {
11198				return !( selected = dataTypeOrTransport );
11199			}
11200		} );
11201		return selected;
11202	}
11203
11204	return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
11205}
11206
11207// A special extend for ajax options
11208// that takes "flat" options (not to be deep extended)
11209// Fixes #9887
11210function ajaxExtend( target, src ) {
11211	var key, deep,
11212		flatOptions = jQuery.ajaxSettings.flatOptions || {};
11213
11214	for ( key in src ) {
11215		if ( src[ key ] !== undefined ) {
11216			( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
11217		}
11218	}
11219	if ( deep ) {
11220		jQuery.extend( true, target, deep );
11221	}
11222
11223	return target;
11224}
11225
11226/* Handles responses to an ajax request:
11227 * - finds the right dataType (mediates between content-type and expected dataType)
11228 * - returns the corresponding response
11229 */
11230function ajaxHandleResponses( s, jqXHR, responses ) {
11231
11232	var ct, type, finalDataType, firstDataType,
11233		contents = s.contents,
11234		dataTypes = s.dataTypes;
11235
11236	// Remove auto dataType and get content-type in the process
11237	while ( dataTypes[ 0 ] === "*" ) {
11238		dataTypes.shift();
11239		if ( ct === undefined ) {
11240			ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
11241		}
11242	}
11243
11244	// Check if we're dealing with a known content-type
11245	if ( ct ) {
11246		for ( type in contents ) {
11247			if ( contents[ type ] && contents[ type ].test( ct ) ) {
11248				dataTypes.unshift( type );
11249				break;
11250			}
11251		}
11252	}
11253
11254	// Check to see if we have a response for the expected dataType
11255	if ( dataTypes[ 0 ] in responses ) {
11256		finalDataType = dataTypes[ 0 ];
11257	} else {
11258
11259		// Try convertible dataTypes
11260		for ( type in responses ) {
11261			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
11262				finalDataType = type;
11263				break;
11264			}
11265			if ( !firstDataType ) {
11266				firstDataType = type;
11267			}
11268		}
11269
11270		// Or just use first one
11271		finalDataType = finalDataType || firstDataType;
11272	}
11273
11274	// If we found a dataType
11275	// We add the dataType to the list if needed
11276	// and return the corresponding response
11277	if ( finalDataType ) {
11278		if ( finalDataType !== dataTypes[ 0 ] ) {
11279			dataTypes.unshift( finalDataType );
11280		}
11281		return responses[ finalDataType ];
11282	}
11283}
11284
11285/* Chain conversions given the request and the original response
11286 * Also sets the responseXXX fields on the jqXHR instance
11287 */
11288function ajaxConvert( s, response, jqXHR, isSuccess ) {
11289	var conv2, current, conv, tmp, prev,
11290		converters = {},
11291
11292		// Work with a copy of dataTypes in case we need to modify it for conversion
11293		dataTypes = s.dataTypes.slice();
11294
11295	// Create converters map with lowercased keys
11296	if ( dataTypes[ 1 ] ) {
11297		for ( conv in s.converters ) {
11298			converters[ conv.toLowerCase() ] = s.converters[ conv ];
11299		}
11300	}
11301
11302	current = dataTypes.shift();
11303
11304	// Convert to each sequential dataType
11305	while ( current ) {
11306
11307		if ( s.responseFields[ current ] ) {
11308			jqXHR[ s.responseFields[ current ] ] = response;
11309		}
11310
11311		// Apply the dataFilter if provided
11312		if ( !prev && isSuccess && s.dataFilter ) {
11313			response = s.dataFilter( response, s.dataType );
11314		}
11315
11316		prev = current;
11317		current = dataTypes.shift();
11318
11319		if ( current ) {
11320
11321			// There's only work to do if current dataType is non-auto
11322			if ( current === "*" ) {
11323
11324				current = prev;
11325
11326			// Convert response if prev dataType is non-auto and differs from current
11327			} else if ( prev !== "*" && prev !== current ) {
11328
11329				// Seek a direct converter
11330				conv = converters[ prev + " " + current ] || converters[ "* " + current ];
11331
11332				// If none found, seek a pair
11333				if ( !conv ) {
11334					for ( conv2 in converters ) {
11335
11336						// If conv2 outputs current
11337						tmp = conv2.split( " " );
11338						if ( tmp[ 1 ] === current ) {
11339
11340							// If prev can be converted to accepted input
11341							conv = converters[ prev + " " + tmp[ 0 ] ] ||
11342								converters[ "* " + tmp[ 0 ] ];
11343							if ( conv ) {
11344
11345								// Condense equivalence converters
11346								if ( conv === true ) {
11347									conv = converters[ conv2 ];
11348
11349								// Otherwise, insert the intermediate dataType
11350								} else if ( converters[ conv2 ] !== true ) {
11351									current = tmp[ 0 ];
11352									dataTypes.unshift( tmp[ 1 ] );
11353								}
11354								break;
11355							}
11356						}
11357					}
11358				}
11359
11360				// Apply converter (if not an equivalence)
11361				if ( conv !== true ) {
11362
11363					// Unless errors are allowed to bubble, catch and return them
11364					if ( conv && s.throws ) {
11365						response = conv( response );
11366					} else {
11367						try {
11368							response = conv( response );
11369						} catch ( e ) {
11370							return {
11371								state: "parsererror",
11372								error: conv ? e : "No conversion from " + prev + " to " + current
11373							};
11374						}
11375					}
11376				}
11377			}
11378		}
11379	}
11380
11381	return { state: "success", data: response };
11382}
11383
11384jQuery.extend( {
11385
11386	// Counter for holding the number of active queries
11387	active: 0,
11388
11389	// Last-Modified header cache for next request
11390	lastModified: {},
11391	etag: {},
11392
11393	ajaxSettings: {
11394		url: location.href,
11395		type: "GET",
11396		isLocal: rlocalProtocol.test( location.protocol ),
11397		global: true,
11398		processData: true,
11399		async: true,
11400		contentType: "application/x-www-form-urlencoded; charset=UTF-8",
11401
11402		/*
11403		timeout: 0,
11404		data: null,
11405		dataType: null,
11406		username: null,
11407		password: null,
11408		cache: null,
11409		throws: false,
11410		traditional: false,
11411		headers: {},
11412		*/
11413
11414		accepts: {
11415			"*": allTypes,
11416			text: "text/plain",
11417			html: "text/html",
11418			xml: "application/xml, text/xml",
11419			json: "application/json, text/javascript"
11420		},
11421
11422		contents: {
11423			xml: /\bxml\b/,
11424			html: /\bhtml/,
11425			json: /\bjson\b/
11426		},
11427
11428		responseFields: {
11429			xml: "responseXML",
11430			text: "responseText",
11431			json: "responseJSON"
11432		},
11433
11434		// Data converters
11435		// Keys separate source (or catchall "*") and destination types with a single space
11436		converters: {
11437
11438			// Convert anything to text
11439			"* text": String,
11440
11441			// Text to html (true = no transformation)
11442			"text html": true,
11443
11444			// Evaluate text as a json expression
11445			"text json": JSON.parse,
11446
11447			// Parse text as xml
11448			"text xml": jQuery.parseXML
11449		},
11450
11451		// For options that shouldn't be deep extended:
11452		// you can add your own custom options here if
11453		// and when you create one that shouldn't be
11454		// deep extended (see ajaxExtend)
11455		flatOptions: {
11456			url: true,
11457			context: true
11458		}
11459	},
11460
11461	// Creates a full fledged settings object into target
11462	// with both ajaxSettings and settings fields.
11463	// If target is omitted, writes into ajaxSettings.
11464	ajaxSetup: function( target, settings ) {
11465		return settings ?
11466
11467			// Building a settings object
11468			ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
11469
11470			// Extending ajaxSettings
11471			ajaxExtend( jQuery.ajaxSettings, target );
11472	},
11473
11474	ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
11475	ajaxTransport: addToPrefiltersOrTransports( transports ),
11476
11477	// Main method
11478	ajax: function( url, options ) {
11479
11480		// If url is an object, simulate pre-1.5 signature
11481		if ( typeof url === "object" ) {
11482			options = url;
11483			url = undefined;
11484		}
11485
11486		// Force options to be an object
11487		options = options || {};
11488
11489		var transport,
11490
11491			// URL without anti-cache param
11492			cacheURL,
11493
11494			// Response headers
11495			responseHeadersString,
11496			responseHeaders,
11497
11498			// timeout handle
11499			timeoutTimer,
11500
11501			// Url cleanup var
11502			urlAnchor,
11503
11504			// Request state (becomes false upon send and true upon completion)
11505			completed,
11506
11507			// To know if global events are to be dispatched
11508			fireGlobals,
11509
11510			// Loop variable
11511			i,
11512
11513			// uncached part of the url
11514			uncached,
11515
11516			// Create the final options object
11517			s = jQuery.ajaxSetup( {}, options ),
11518
11519			// Callbacks context
11520			callbackContext = s.context || s,
11521
11522			// Context for global events is callbackContext if it is a DOM node or jQuery collection
11523			globalEventContext = s.context &&
11524				( callbackContext.nodeType || callbackContext.jquery ) ?
11525					jQuery( callbackContext ) :
11526					jQuery.event,
11527
11528			// Deferreds
11529			deferred = jQuery.Deferred(),
11530			completeDeferred = jQuery.Callbacks( "once memory" ),
11531
11532			// Status-dependent callbacks
11533			statusCode = s.statusCode || {},
11534
11535			// Headers (they are sent all at once)
11536			requestHeaders = {},
11537			requestHeadersNames = {},
11538
11539			// Default abort message
11540			strAbort = "canceled",
11541
11542			// Fake xhr
11543			jqXHR = {
11544				readyState: 0,
11545
11546				// Builds headers hashtable if needed
11547				getResponseHeader: function( key ) {
11548					var match;
11549					if ( completed ) {
11550						if ( !responseHeaders ) {
11551							responseHeaders = {};
11552							while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
11553								responseHeaders[ match[ 1 ].toLowerCase() + " " ] =
11554									( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] )
11555										.concat( match[ 2 ] );
11556							}
11557						}
11558						match = responseHeaders[ key.toLowerCase() + " " ];
11559					}
11560					return match == null ? null : match.join( ", " );
11561				},
11562
11563				// Raw string
11564				getAllResponseHeaders: function() {
11565					return completed ? responseHeadersString : null;
11566				},
11567
11568				// Caches the header
11569				setRequestHeader: function( name, value ) {
11570					if ( completed == null ) {
11571						name = requestHeadersNames[ name.toLowerCase() ] =
11572							requestHeadersNames[ name.toLowerCase() ] || name;
11573						requestHeaders[ name ] = value;
11574					}
11575					return this;
11576				},
11577
11578				// Overrides response content-type header
11579				overrideMimeType: function( type ) {
11580					if ( completed == null ) {
11581						s.mimeType = type;
11582					}
11583					return this;
11584				},
11585
11586				// Status-dependent callbacks
11587				statusCode: function( map ) {
11588					var code;
11589					if ( map ) {
11590						if ( completed ) {
11591
11592							// Execute the appropriate callbacks
11593							jqXHR.always( map[ jqXHR.status ] );
11594						} else {
11595
11596							// Lazy-add the new callbacks in a way that preserves old ones
11597							for ( code in map ) {
11598								statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
11599							}
11600						}
11601					}
11602					return this;
11603				},
11604
11605				// Cancel the request
11606				abort: function( statusText ) {
11607					var finalText = statusText || strAbort;
11608					if ( transport ) {
11609						transport.abort( finalText );
11610					}
11611					done( 0, finalText );
11612					return this;
11613				}
11614			};
11615
11616		// Attach deferreds
11617		deferred.promise( jqXHR );
11618
11619		// Add protocol if not provided (prefilters might expect it)
11620		// Handle falsy url in the settings object (#10093: consistency with old signature)
11621		// We also use the url parameter if available
11622		s.url = ( ( url || s.url || location.href ) + "" )
11623			.replace( rprotocol, location.protocol + "//" );
11624
11625		// Alias method option to type as per ticket #12004
11626		s.type = options.method || options.type || s.method || s.type;
11627
11628		// Extract dataTypes list
11629		s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
11630
11631		// A cross-domain request is in order when the origin doesn't match the current origin.
11632		if ( s.crossDomain == null ) {
11633			urlAnchor = document.createElement( "a" );
11634
11635			// Support: IE <=8 - 11, Edge 12 - 15
11636			// IE throws exception on accessing the href property if url is malformed,
11637			// e.g. http://example.com:80x/
11638			try {
11639				urlAnchor.href = s.url;
11640
11641				// Support: IE <=8 - 11 only
11642				// Anchor's host property isn't correctly set when s.url is relative
11643				urlAnchor.href = urlAnchor.href;
11644				s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
11645					urlAnchor.protocol + "//" + urlAnchor.host;
11646			} catch ( e ) {
11647
11648				// If there is an error parsing the URL, assume it is crossDomain,
11649				// it can be rejected by the transport if it is invalid
11650				s.crossDomain = true;
11651			}
11652		}
11653
11654		// Convert data if not already a string
11655		if ( s.data && s.processData && typeof s.data !== "string" ) {
11656			s.data = jQuery.param( s.data, s.traditional );
11657		}
11658
11659		// Apply prefilters
11660		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
11661
11662		// If request was aborted inside a prefilter, stop there
11663		if ( completed ) {
11664			return jqXHR;
11665		}
11666
11667		// We can fire global events as of now if asked to
11668		// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
11669		fireGlobals = jQuery.event && s.global;
11670
11671		// Watch for a new set of requests
11672		if ( fireGlobals && jQuery.active++ === 0 ) {
11673			jQuery.event.trigger( "ajaxStart" );
11674		}
11675
11676		// Uppercase the type
11677		s.type = s.type.toUpperCase();
11678
11679		// Determine if request has content
11680		s.hasContent = !rnoContent.test( s.type );
11681
11682		// Save the URL in case we're toying with the If-Modified-Since
11683		// and/or If-None-Match header later on
11684		// Remove hash to simplify url manipulation
11685		cacheURL = s.url.replace( rhash, "" );
11686
11687		// More options handling for requests with no content
11688		if ( !s.hasContent ) {
11689
11690			// Remember the hash so we can put it back
11691			uncached = s.url.slice( cacheURL.length );
11692
11693			// If data is available and should be processed, append data to url
11694			if ( s.data && ( s.processData || typeof s.data === "string" ) ) {
11695				cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
11696
11697				// #9682: remove data so that it's not used in an eventual retry
11698				delete s.data;
11699			}
11700
11701			// Add or update anti-cache param if needed
11702			if ( s.cache === false ) {
11703				cacheURL = cacheURL.replace( rantiCache, "$1" );
11704				uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached;
11705			}
11706
11707			// Put hash and anti-cache on the URL that will be requested (gh-1732)
11708			s.url = cacheURL + uncached;
11709
11710		// Change '%20' to '+' if this is encoded form body content (gh-2658)
11711		} else if ( s.data && s.processData &&
11712			( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
11713			s.data = s.data.replace( r20, "+" );
11714		}
11715
11716		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
11717		if ( s.ifModified ) {
11718			if ( jQuery.lastModified[ cacheURL ] ) {
11719				jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
11720			}
11721			if ( jQuery.etag[ cacheURL ] ) {
11722				jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
11723			}
11724		}
11725
11726		// Set the correct header, if data is being sent
11727		if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
11728			jqXHR.setRequestHeader( "Content-Type", s.contentType );
11729		}
11730
11731		// Set the Accepts header for the server, depending on the dataType
11732		jqXHR.setRequestHeader(
11733			"Accept",
11734			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
11735				s.accepts[ s.dataTypes[ 0 ] ] +
11736					( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
11737				s.accepts[ "*" ]
11738		);
11739
11740		// Check for headers option
11741		for ( i in s.headers ) {
11742			jqXHR.setRequestHeader( i, s.headers[ i ] );
11743		}
11744
11745		// Allow custom headers/mimetypes and early abort
11746		if ( s.beforeSend &&
11747			( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
11748
11749			// Abort if not done already and return
11750			return jqXHR.abort();
11751		}
11752
11753		// Aborting is no longer a cancellation
11754		strAbort = "abort";
11755
11756		// Install callbacks on deferreds
11757		completeDeferred.add( s.complete );
11758		jqXHR.done( s.success );
11759		jqXHR.fail( s.error );
11760
11761		// Get transport
11762		transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
11763
11764		// If no transport, we auto-abort
11765		if ( !transport ) {
11766			done( -1, "No Transport" );
11767		} else {
11768			jqXHR.readyState = 1;
11769
11770			// Send global event
11771			if ( fireGlobals ) {
11772				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
11773			}
11774
11775			// If request was aborted inside ajaxSend, stop there
11776			if ( completed ) {
11777				return jqXHR;
11778			}
11779
11780			// Timeout
11781			if ( s.async && s.timeout > 0 ) {
11782				timeoutTimer = window.setTimeout( function() {
11783					jqXHR.abort( "timeout" );
11784				}, s.timeout );
11785			}
11786
11787			try {
11788				completed = false;
11789				transport.send( requestHeaders, done );
11790			} catch ( e ) {
11791
11792				// Rethrow post-completion exceptions
11793				if ( completed ) {
11794					throw e;
11795				}
11796
11797				// Propagate others as results
11798				done( -1, e );
11799			}
11800		}
11801
11802		// Callback for when everything is done
11803		function done( status, nativeStatusText, responses, headers ) {
11804			var isSuccess, success, error, response, modified,
11805				statusText = nativeStatusText;
11806
11807			// Ignore repeat invocations
11808			if ( completed ) {
11809				return;
11810			}
11811
11812			completed = true;
11813
11814			// Clear timeout if it exists
11815			if ( timeoutTimer ) {
11816				window.clearTimeout( timeoutTimer );
11817			}
11818
11819			// Dereference transport for early garbage collection
11820			// (no matter how long the jqXHR object will be used)
11821			transport = undefined;
11822
11823			// Cache response headers
11824			responseHeadersString = headers || "";
11825
11826			// Set readyState
11827			jqXHR.readyState = status > 0 ? 4 : 0;
11828
11829			// Determine if successful
11830			isSuccess = status >= 200 && status < 300 || status === 304;
11831
11832			// Get response data
11833			if ( responses ) {
11834				response = ajaxHandleResponses( s, jqXHR, responses );
11835			}
11836
11837			// Convert no matter what (that way responseXXX fields are always set)
11838			response = ajaxConvert( s, response, jqXHR, isSuccess );
11839
11840			// If successful, handle type chaining
11841			if ( isSuccess ) {
11842
11843				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
11844				if ( s.ifModified ) {
11845					modified = jqXHR.getResponseHeader( "Last-Modified" );
11846					if ( modified ) {
11847						jQuery.lastModified[ cacheURL ] = modified;
11848					}
11849					modified = jqXHR.getResponseHeader( "etag" );
11850					if ( modified ) {
11851						jQuery.etag[ cacheURL ] = modified;
11852					}
11853				}
11854
11855				// if no content
11856				if ( status === 204 || s.type === "HEAD" ) {
11857					statusText = "nocontent";
11858
11859				// if not modified
11860				} else if ( status === 304 ) {
11861					statusText = "notmodified";
11862
11863				// If we have data, let's convert it
11864				} else {
11865					statusText = response.state;
11866					success = response.data;
11867					error = response.error;
11868					isSuccess = !error;
11869				}
11870			} else {
11871
11872				// Extract error from statusText and normalize for non-aborts
11873				error = statusText;
11874				if ( status || !statusText ) {
11875					statusText = "error";
11876					if ( status < 0 ) {
11877						status = 0;
11878					}
11879				}
11880			}
11881
11882			// Set data for the fake xhr object
11883			jqXHR.status = status;
11884			jqXHR.statusText = ( nativeStatusText || statusText ) + "";
11885
11886			// Success/Error
11887			if ( isSuccess ) {
11888				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
11889			} else {
11890				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
11891			}
11892
11893			// Status-dependent callbacks
11894			jqXHR.statusCode( statusCode );
11895			statusCode = undefined;
11896
11897			if ( fireGlobals ) {
11898				globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
11899					[ jqXHR, s, isSuccess ? success : error ] );
11900			}
11901
11902			// Complete
11903			completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
11904
11905			if ( fireGlobals ) {
11906				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
11907
11908				// Handle the global AJAX counter
11909				if ( !( --jQuery.active ) ) {
11910					jQuery.event.trigger( "ajaxStop" );
11911				}
11912			}
11913		}
11914
11915		return jqXHR;
11916	},
11917
11918	getJSON: function( url, data, callback ) {
11919		return jQuery.get( url, data, callback, "json" );
11920	},
11921
11922	getScript: function( url, callback ) {
11923		return jQuery.get( url, undefined, callback, "script" );
11924	}
11925} );
11926
11927jQuery.each( [ "get", "post" ], function( i, method ) {
11928	jQuery[ method ] = function( url, data, callback, type ) {
11929
11930		// Shift arguments if data argument was omitted
11931		if ( isFunction( data ) ) {
11932			type = type || callback;
11933			callback = data;
11934			data = undefined;
11935		}
11936
11937		// The url can be an options object (which then must have .url)
11938		return jQuery.ajax( jQuery.extend( {
11939			url: url,
11940			type: method,
11941			dataType: type,
11942			data: data,
11943			success: callback
11944		}, jQuery.isPlainObject( url ) && url ) );
11945	};
11946} );
11947
11948
11949jQuery._evalUrl = function( url, options ) {
11950	return jQuery.ajax( {
11951		url: url,
11952
11953		// Make this explicit, since user can override this through ajaxSetup (#11264)
11954		type: "GET",
11955		dataType: "script",
11956		cache: true,
11957		async: false,
11958		global: false,
11959
11960		// Only evaluate the response if it is successful (gh-4126)
11961		// dataFilter is not invoked for failure responses, so using it instead
11962		// of the default converter is kludgy but it works.
11963		converters: {
11964			"text script": function() {}
11965		},
11966		dataFilter: function( response ) {
11967			jQuery.globalEval( response, options );
11968		}
11969	} );
11970};
11971
11972
11973jQuery.fn.extend( {
11974	wrapAll: function( html ) {
11975		var wrap;
11976
11977		if ( this[ 0 ] ) {
11978			if ( isFunction( html ) ) {
11979				html = html.call( this[ 0 ] );
11980			}
11981
11982			// The elements to wrap the target around
11983			wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
11984
11985			if ( this[ 0 ].parentNode ) {
11986				wrap.insertBefore( this[ 0 ] );
11987			}
11988
11989			wrap.map( function() {
11990				var elem = this;
11991
11992				while ( elem.firstElementChild ) {
11993					elem = elem.firstElementChild;
11994				}
11995
11996				return elem;
11997			} ).append( this );
11998		}
11999
12000		return this;
12001	},
12002
12003	wrapInner: function( html ) {
12004		if ( isFunction( html ) ) {
12005			return this.each( function( i ) {
12006				jQuery( this ).wrapInner( html.call( this, i ) );
12007			} );
12008		}
12009
12010		return this.each( function() {
12011			var self = jQuery( this ),
12012				contents = self.contents();
12013
12014			if ( contents.length ) {
12015				contents.wrapAll( html );
12016
12017			} else {
12018				self.append( html );
12019			}
12020		} );
12021	},
12022
12023	wrap: function( html ) {
12024		var htmlIsFunction = isFunction( html );
12025
12026		return this.each( function( i ) {
12027			jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );
12028		} );
12029	},
12030
12031	unwrap: function( selector ) {
12032		this.parent( selector ).not( "body" ).each( function() {
12033			jQuery( this ).replaceWith( this.childNodes );
12034		} );
12035		return this;
12036	}
12037} );
12038
12039
12040jQuery.expr.pseudos.hidden = function( elem ) {
12041	return !jQuery.expr.pseudos.visible( elem );
12042};
12043jQuery.expr.pseudos.visible = function( elem ) {
12044	return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
12045};
12046
12047
12048
12049
12050jQuery.ajaxSettings.xhr = function() {
12051	try {
12052		return new window.XMLHttpRequest();
12053	} catch ( e ) {}
12054};
12055
12056var xhrSuccessStatus = {
12057
12058		// File protocol always yields status code 0, assume 200
12059		0: 200,
12060
12061		// Support: IE <=9 only
12062		// #1450: sometimes IE returns 1223 when it should be 204
12063		1223: 204
12064	},
12065	xhrSupported = jQuery.ajaxSettings.xhr();
12066
12067support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
12068support.ajax = xhrSupported = !!xhrSupported;
12069
12070jQuery.ajaxTransport( function( options ) {
12071	var callback, errorCallback;
12072
12073	// Cross domain only allowed if supported through XMLHttpRequest
12074	if ( support.cors || xhrSupported && !options.crossDomain ) {
12075		return {
12076			send: function( headers, complete ) {
12077				var i,
12078					xhr = options.xhr();
12079
12080				xhr.open(
12081					options.type,
12082					options.url,
12083					options.async,
12084					options.username,
12085					options.password
12086				);
12087
12088				// Apply custom fields if provided
12089				if ( options.xhrFields ) {
12090					for ( i in options.xhrFields ) {
12091						xhr[ i ] = options.xhrFields[ i ];
12092					}
12093				}
12094
12095				// Override mime type if needed
12096				if ( options.mimeType && xhr.overrideMimeType ) {
12097					xhr.overrideMimeType( options.mimeType );
12098				}
12099
12100				// X-Requested-With header
12101				// For cross-domain requests, seeing as conditions for a preflight are
12102				// akin to a jigsaw puzzle, we simply never set it to be sure.
12103				// (it can always be set on a per-request basis or even using ajaxSetup)
12104				// For same-domain requests, won't change header if already provided.
12105				if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
12106					headers[ "X-Requested-With" ] = "XMLHttpRequest";
12107				}
12108
12109				// Set headers
12110				for ( i in headers ) {
12111					xhr.setRequestHeader( i, headers[ i ] );
12112				}
12113
12114				// Callback
12115				callback = function( type ) {
12116					return function() {
12117						if ( callback ) {
12118							callback = errorCallback = xhr.onload =
12119								xhr.onerror = xhr.onabort = xhr.ontimeout =
12120									xhr.onreadystatechange = null;
12121
12122							if ( type === "abort" ) {
12123								xhr.abort();
12124							} else if ( type === "error" ) {
12125
12126								// Support: IE <=9 only
12127								// On a manual native abort, IE9 throws
12128								// errors on any property access that is not readyState
12129								if ( typeof xhr.status !== "number" ) {
12130									complete( 0, "error" );
12131								} else {
12132									complete(
12133
12134										// File: protocol always yields status 0; see #8605, #14207
12135										xhr.status,
12136										xhr.statusText
12137									);
12138								}
12139							} else {
12140								complete(
12141									xhrSuccessStatus[ xhr.status ] || xhr.status,
12142									xhr.statusText,
12143
12144									// Support: IE <=9 only
12145									// IE9 has no XHR2 but throws on binary (trac-11426)
12146									// For XHR2 non-text, let the caller handle it (gh-2498)
12147									( xhr.responseType || "text" ) !== "text"  ||
12148									typeof xhr.responseText !== "string" ?
12149										{ binary: xhr.response } :
12150										{ text: xhr.responseText },
12151									xhr.getAllResponseHeaders()
12152								);
12153							}
12154						}
12155					};
12156				};
12157
12158				// Listen to events
12159				xhr.onload = callback();
12160				errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" );
12161
12162				// Support: IE 9 only
12163				// Use onreadystatechange to replace onabort
12164				// to handle uncaught aborts
12165				if ( xhr.onabort !== undefined ) {
12166					xhr.onabort = errorCallback;
12167				} else {
12168					xhr.onreadystatechange = function() {
12169
12170						// Check readyState before timeout as it changes
12171						if ( xhr.readyState === 4 ) {
12172
12173							// Allow onerror to be called first,
12174							// but that will not handle a native abort
12175							// Also, save errorCallback to a variable
12176							// as xhr.onerror cannot be accessed
12177							window.setTimeout( function() {
12178								if ( callback ) {
12179									errorCallback();
12180								}
12181							} );
12182						}
12183					};
12184				}
12185
12186				// Create the abort callback
12187				callback = callback( "abort" );
12188
12189				try {
12190
12191					// Do send the request (this may raise an exception)
12192					xhr.send( options.hasContent && options.data || null );
12193				} catch ( e ) {
12194
12195					// #14683: Only rethrow if this hasn't been notified as an error yet
12196					if ( callback ) {
12197						throw e;
12198					}
12199				}
12200			},
12201
12202			abort: function() {
12203				if ( callback ) {
12204					callback();
12205				}
12206			}
12207		};
12208	}
12209} );
12210
12211
12212
12213
12214// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
12215jQuery.ajaxPrefilter( function( s ) {
12216	if ( s.crossDomain ) {
12217		s.contents.script = false;
12218	}
12219} );
12220
12221// Install script dataType
12222jQuery.ajaxSetup( {
12223	accepts: {
12224		script: "text/javascript, application/javascript, " +
12225			"application/ecmascript, application/x-ecmascript"
12226	},
12227	contents: {
12228		script: /\b(?:java|ecma)script\b/
12229	},
12230	converters: {
12231		"text script": function( text ) {
12232			jQuery.globalEval( text );
12233			return text;
12234		}
12235	}
12236} );
12237
12238// Handle cache's special case and crossDomain
12239jQuery.ajaxPrefilter( "script", function( s ) {
12240	if ( s.cache === undefined ) {
12241		s.cache = false;
12242	}
12243	if ( s.crossDomain ) {
12244		s.type = "GET";
12245	}
12246} );
12247
12248// Bind script tag hack transport
12249jQuery.ajaxTransport( "script", function( s ) {
12250
12251	// This transport only deals with cross domain or forced-by-attrs requests
12252	if ( s.crossDomain || s.scriptAttrs ) {
12253		var script, callback;
12254		return {
12255			send: function( _, complete ) {
12256				script = jQuery( "<script>" )
12257					.attr( s.scriptAttrs || {} )
12258					.prop( { charset: s.scriptCharset, src: s.url } )
12259					.on( "load error", callback = function( evt ) {
12260						script.remove();
12261						callback = null;
12262						if ( evt ) {
12263							complete( evt.type === "error" ? 404 : 200, evt.type );
12264						}
12265					} );
12266
12267				// Use native DOM manipulation to avoid our domManip AJAX trickery
12268				document.head.appendChild( script[ 0 ] );
12269			},
12270			abort: function() {
12271				if ( callback ) {
12272					callback();
12273				}
12274			}
12275		};
12276	}
12277} );
12278
12279
12280
12281
12282var oldCallbacks = [],
12283	rjsonp = /(=)\?(?=&|$)|\?\?/;
12284
12285// Default jsonp settings
12286jQuery.ajaxSetup( {
12287	jsonp: "callback",
12288	jsonpCallback: function() {
12289		var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
12290		this[ callback ] = true;
12291		return callback;
12292	}
12293} );
12294
12295// Detect, normalize options and install callbacks for jsonp requests
12296jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
12297
12298	var callbackName, overwritten, responseContainer,
12299		jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
12300			"url" :
12301			typeof s.data === "string" &&
12302				( s.contentType || "" )
12303					.indexOf( "application/x-www-form-urlencoded" ) === 0 &&
12304				rjsonp.test( s.data ) && "data"
12305		);
12306
12307	// Handle iff the expected data type is "jsonp" or we have a parameter to set
12308	if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
12309
12310		// Get callback name, remembering preexisting value associated with it
12311		callbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?
12312			s.jsonpCallback() :
12313			s.jsonpCallback;
12314
12315		// Insert callback into url or form data
12316		if ( jsonProp ) {
12317			s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
12318		} else if ( s.jsonp !== false ) {
12319			s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
12320		}
12321
12322		// Use data converter to retrieve json after script execution
12323		s.converters[ "script json" ] = function() {
12324			if ( !responseContainer ) {
12325				jQuery.error( callbackName + " was not called" );
12326			}
12327			return responseContainer[ 0 ];
12328		};
12329
12330		// Force json dataType
12331		s.dataTypes[ 0 ] = "json";
12332
12333		// Install callback
12334		overwritten = window[ callbackName ];
12335		window[ callbackName ] = function() {
12336			responseContainer = arguments;
12337		};
12338
12339		// Clean-up function (fires after converters)
12340		jqXHR.always( function() {
12341
12342			// If previous value didn't exist - remove it
12343			if ( overwritten === undefined ) {
12344				jQuery( window ).removeProp( callbackName );
12345
12346			// Otherwise restore preexisting value
12347			} else {
12348				window[ callbackName ] = overwritten;
12349			}
12350
12351			// Save back as free
12352			if ( s[ callbackName ] ) {
12353
12354				// Make sure that re-using the options doesn't screw things around
12355				s.jsonpCallback = originalSettings.jsonpCallback;
12356
12357				// Save the callback name for future use
12358				oldCallbacks.push( callbackName );
12359			}
12360
12361			// Call if it was a function and we have a response
12362			if ( responseContainer && isFunction( overwritten ) ) {
12363				overwritten( responseContainer[ 0 ] );
12364			}
12365
12366			responseContainer = overwritten = undefined;
12367		} );
12368
12369		// Delegate to script
12370		return "script";
12371	}
12372} );
12373
12374
12375
12376
12377// Support: Safari 8 only
12378// In Safari 8 documents created via document.implementation.createHTMLDocument
12379// collapse sibling forms: the second one becomes a child of the first one.
12380// Because of that, this security measure has to be disabled in Safari 8.
12381// https://bugs.webkit.org/show_bug.cgi?id=137337
12382support.createHTMLDocument = ( function() {
12383	var body = document.implementation.createHTMLDocument( "" ).body;
12384	body.innerHTML = "<form></form><form></form>";
12385	return body.childNodes.length === 2;
12386} )();
12387
12388
12389// Argument "data" should be string of html
12390// context (optional): If specified, the fragment will be created in this context,
12391// defaults to document
12392// keepScripts (optional): If true, will include scripts passed in the html string
12393jQuery.parseHTML = function( data, context, keepScripts ) {
12394	if ( typeof data !== "string" ) {
12395		return [];
12396	}
12397	if ( typeof context === "boolean" ) {
12398		keepScripts = context;
12399		context = false;
12400	}
12401
12402	var base, parsed, scripts;
12403
12404	if ( !context ) {
12405
12406		// Stop scripts or inline event handlers from being executed immediately
12407		// by using document.implementation
12408		if ( support.createHTMLDocument ) {
12409			context = document.implementation.createHTMLDocument( "" );
12410
12411			// Set the base href for the created document
12412			// so any parsed elements with URLs
12413			// are based on the document's URL (gh-2965)
12414			base = context.createElement( "base" );
12415			base.href = document.location.href;
12416			context.head.appendChild( base );
12417		} else {
12418			context = document;
12419		}
12420	}
12421
12422	parsed = rsingleTag.exec( data );
12423	scripts = !keepScripts && [];
12424
12425	// Single tag
12426	if ( parsed ) {
12427		return [ context.createElement( parsed[ 1 ] ) ];
12428	}
12429
12430	parsed = buildFragment( [ data ], context, scripts );
12431
12432	if ( scripts && scripts.length ) {
12433		jQuery( scripts ).remove();
12434	}
12435
12436	return jQuery.merge( [], parsed.childNodes );
12437};
12438
12439
12440/**
12441 * Load a url into a page
12442 */
12443jQuery.fn.load = function( url, params, callback ) {
12444	var selector, type, response,
12445		self = this,
12446		off = url.indexOf( " " );
12447
12448	if ( off > -1 ) {
12449		selector = stripAndCollapse( url.slice( off ) );
12450		url = url.slice( 0, off );
12451	}
12452
12453	// If it's a function
12454	if ( isFunction( params ) ) {
12455
12456		// We assume that it's the callback
12457		callback = params;
12458		params = undefined;
12459
12460	// Otherwise, build a param string
12461	} else if ( params && typeof params === "object" ) {
12462		type = "POST";
12463	}
12464
12465	// If we have elements to modify, make the request
12466	if ( self.length > 0 ) {
12467		jQuery.ajax( {
12468			url: url,
12469
12470			// If "type" variable is undefined, then "GET" method will be used.
12471			// Make value of this field explicit since
12472			// user can override it through ajaxSetup method
12473			type: type || "GET",
12474			dataType: "html",
12475			data: params
12476		} ).done( function( responseText ) {
12477
12478			// Save response for use in complete callback
12479			response = arguments;
12480
12481			self.html( selector ?
12482
12483				// If a selector was specified, locate the right elements in a dummy div
12484				// Exclude scripts to avoid IE 'Permission Denied' errors
12485				jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
12486
12487				// Otherwise use the full result
12488				responseText );
12489
12490		// If the request succeeds, this function gets "data", "status", "jqXHR"
12491		// but they are ignored because response was set above.
12492		// If it fails, this function gets "jqXHR", "status", "error"
12493		} ).always( callback && function( jqXHR, status ) {
12494			self.each( function() {
12495				callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
12496			} );
12497		} );
12498	}
12499
12500	return this;
12501};
12502
12503
12504
12505
12506// Attach a bunch of functions for handling common AJAX events
12507jQuery.each( [
12508	"ajaxStart",
12509	"ajaxStop",
12510	"ajaxComplete",
12511	"ajaxError",
12512	"ajaxSuccess",
12513	"ajaxSend"
12514], function( i, type ) {
12515	jQuery.fn[ type ] = function( fn ) {
12516		return this.on( type, fn );
12517	};
12518} );
12519
12520
12521
12522
12523jQuery.expr.pseudos.animated = function( elem ) {
12524	return jQuery.grep( jQuery.timers, function( fn ) {
12525		return elem === fn.elem;
12526	} ).length;
12527};
12528
12529
12530
12531
12532jQuery.offset = {
12533	setOffset: function( elem, options, i ) {
12534		var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
12535			position = jQuery.css( elem, "position" ),
12536			curElem = jQuery( elem ),
12537			props = {};
12538
12539		// Set position first, in-case top/left are set even on static elem
12540		if ( position === "static" ) {
12541			elem.style.position = "relative";
12542		}
12543
12544		curOffset = curElem.offset();
12545		curCSSTop = jQuery.css( elem, "top" );
12546		curCSSLeft = jQuery.css( elem, "left" );
12547		calculatePosition = ( position === "absolute" || position === "fixed" ) &&
12548			( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;
12549
12550		// Need to be able to calculate position if either
12551		// top or left is auto and position is either absolute or fixed
12552		if ( calculatePosition ) {
12553			curPosition = curElem.position();
12554			curTop = curPosition.top;
12555			curLeft = curPosition.left;
12556
12557		} else {
12558			curTop = parseFloat( curCSSTop ) || 0;
12559			curLeft = parseFloat( curCSSLeft ) || 0;
12560		}
12561
12562		if ( isFunction( options ) ) {
12563
12564			// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
12565			options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
12566		}
12567
12568		if ( options.top != null ) {
12569			props.top = ( options.top - curOffset.top ) + curTop;
12570		}
12571		if ( options.left != null ) {
12572			props.left = ( options.left - curOffset.left ) + curLeft;
12573		}
12574
12575		if ( "using" in options ) {
12576			options.using.call( elem, props );
12577
12578		} else {
12579			curElem.css( props );
12580		}
12581	}
12582};
12583
12584jQuery.fn.extend( {
12585
12586	// offset() relates an element's border box to the document origin
12587	offset: function( options ) {
12588
12589		// Preserve chaining for setter
12590		if ( arguments.length ) {
12591			return options === undefined ?
12592				this :
12593				this.each( function( i ) {
12594					jQuery.offset.setOffset( this, options, i );
12595				} );
12596		}
12597
12598		var rect, win,
12599			elem = this[ 0 ];
12600
12601		if ( !elem ) {
12602			return;
12603		}
12604
12605		// Return zeros for disconnected and hidden (display: none) elements (gh-2310)
12606		// Support: IE <=11 only
12607		// Running getBoundingClientRect on a
12608		// disconnected node in IE throws an error
12609		if ( !elem.getClientRects().length ) {
12610			return { top: 0, left: 0 };
12611		}
12612
12613		// Get document-relative position by adding viewport scroll to viewport-relative gBCR
12614		rect = elem.getBoundingClientRect();
12615		win = elem.ownerDocument.defaultView;
12616		return {
12617			top: rect.top + win.pageYOffset,
12618			left: rect.left + win.pageXOffset
12619		};
12620	},
12621
12622	// position() relates an element's margin box to its offset parent's padding box
12623	// This corresponds to the behavior of CSS absolute positioning
12624	position: function() {
12625		if ( !this[ 0 ] ) {
12626			return;
12627		}
12628
12629		var offsetParent, offset, doc,
12630			elem = this[ 0 ],
12631			parentOffset = { top: 0, left: 0 };
12632
12633		// position:fixed elements are offset from the viewport, which itself always has zero offset
12634		if ( jQuery.css( elem, "position" ) === "fixed" ) {
12635
12636			// Assume position:fixed implies availability of getBoundingClientRect
12637			offset = elem.getBoundingClientRect();
12638
12639		} else {
12640			offset = this.offset();
12641
12642			// Account for the *real* offset parent, which can be the document or its root element
12643			// when a statically positioned element is identified
12644			doc = elem.ownerDocument;
12645			offsetParent = elem.offsetParent || doc.documentElement;
12646			while ( offsetParent &&
12647				( offsetParent === doc.body || offsetParent === doc.documentElement ) &&
12648				jQuery.css( offsetParent, "position" ) === "static" ) {
12649
12650				offsetParent = offsetParent.parentNode;
12651			}
12652			if ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {
12653
12654				// Incorporate borders into its offset, since they are outside its content origin
12655				parentOffset = jQuery( offsetParent ).offset();
12656				parentOffset.top += jQuery.css( offsetParent, "borderTopWidth", true );
12657				parentOffset.left += jQuery.css( offsetParent, "borderLeftWidth", true );
12658			}
12659		}
12660
12661		// Subtract parent offsets and element margins
12662		return {
12663			top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
12664			left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
12665		};
12666	},
12667
12668	// This method will return documentElement in the following cases:
12669	// 1) For the element inside the iframe without offsetParent, this method will return
12670	//    documentElement of the parent window
12671	// 2) For the hidden or detached element
12672	// 3) For body or html element, i.e. in case of the html node - it will return itself
12673	//
12674	// but those exceptions were never presented as a real life use-cases
12675	// and might be considered as more preferable results.
12676	//
12677	// This logic, however, is not guaranteed and can change at any point in the future
12678	offsetParent: function() {
12679		return this.map( function() {
12680			var offsetParent = this.offsetParent;
12681
12682			while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {
12683				offsetParent = offsetParent.offsetParent;
12684			}
12685
12686			return offsetParent || documentElement;
12687		} );
12688	}
12689} );
12690
12691// Create scrollLeft and scrollTop methods
12692jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
12693	var top = "pageYOffset" === prop;
12694
12695	jQuery.fn[ method ] = function( val ) {
12696		return access( this, function( elem, method, val ) {
12697
12698			// Coalesce documents and windows
12699			var win;
12700			if ( isWindow( elem ) ) {
12701				win = elem;
12702			} else if ( elem.nodeType === 9 ) {
12703				win = elem.defaultView;
12704			}
12705
12706			if ( val === undefined ) {
12707				return win ? win[ prop ] : elem[ method ];
12708			}
12709
12710			if ( win ) {
12711				win.scrollTo(
12712					!top ? val : win.pageXOffset,
12713					top ? val : win.pageYOffset
12714				);
12715
12716			} else {
12717				elem[ method ] = val;
12718			}
12719		}, method, val, arguments.length );
12720	};
12721} );
12722
12723// Support: Safari <=7 - 9.1, Chrome <=37 - 49
12724// Add the top/left cssHooks using jQuery.fn.position
12725// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
12726// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
12727// getComputedStyle returns percent when specified for top/left/bottom/right;
12728// rather than make the css module depend on the offset module, just check for it here
12729jQuery.each( [ "top", "left" ], function( i, prop ) {
12730	jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
12731		function( elem, computed ) {
12732			if ( computed ) {
12733				computed = curCSS( elem, prop );
12734
12735				// If curCSS returns percentage, fallback to offset
12736				return rnumnonpx.test( computed ) ?
12737					jQuery( elem ).position()[ prop ] + "px" :
12738					computed;
12739			}
12740		}
12741	);
12742} );
12743
12744
12745// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
12746jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
12747	jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name },
12748		function( defaultExtra, funcName ) {
12749
12750		// Margin is only for outerHeight, outerWidth
12751		jQuery.fn[ funcName ] = function( margin, value ) {
12752			var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
12753				extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
12754
12755			return access( this, function( elem, type, value ) {
12756				var doc;
12757
12758				if ( isWindow( elem ) ) {
12759
12760					// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
12761					return funcName.indexOf( "outer" ) === 0 ?
12762						elem[ "inner" + name ] :
12763						elem.document.documentElement[ "client" + name ];
12764				}
12765
12766				// Get document width or height
12767				if ( elem.nodeType === 9 ) {
12768					doc = elem.documentElement;
12769
12770					// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
12771					// whichever is greatest
12772					return Math.max(
12773						elem.body[ "scroll" + name ], doc[ "scroll" + name ],
12774						elem.body[ "offset" + name ], doc[ "offset" + name ],
12775						doc[ "client" + name ]
12776					);
12777				}
12778
12779				return value === undefined ?
12780
12781					// Get width or height on the element, requesting but not forcing parseFloat
12782					jQuery.css( elem, type, extra ) :
12783
12784					// Set width or height on the element
12785					jQuery.style( elem, type, value, extra );
12786			}, type, chainable ? margin : undefined, chainable );
12787		};
12788	} );
12789} );
12790
12791
12792jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " +
12793	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
12794	"change select submit keydown keypress keyup contextmenu" ).split( " " ),
12795	function( i, name ) {
12796
12797	// Handle event binding
12798	jQuery.fn[ name ] = function( data, fn ) {
12799		return arguments.length > 0 ?
12800			this.on( name, null, data, fn ) :
12801			this.trigger( name );
12802	};
12803} );
12804
12805jQuery.fn.extend( {
12806	hover: function( fnOver, fnOut ) {
12807		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
12808	}
12809} );
12810
12811
12812
12813
12814jQuery.fn.extend( {
12815
12816	bind: function( types, data, fn ) {
12817		return this.on( types, null, data, fn );
12818	},
12819	unbind: function( types, fn ) {
12820		return this.off( types, null, fn );
12821	},
12822
12823	delegate: function( selector, types, data, fn ) {
12824		return this.on( types, selector, data, fn );
12825	},
12826	undelegate: function( selector, types, fn ) {
12827
12828		// ( namespace ) or ( selector, types [, fn] )
12829		return arguments.length === 1 ?
12830			this.off( selector, "**" ) :
12831			this.off( types, selector || "**", fn );
12832	}
12833} );
12834
12835// Bind a function to a context, optionally partially applying any
12836// arguments.
12837// jQuery.proxy is deprecated to promote standards (specifically Function#bind)
12838// However, it is not slated for removal any time soon
12839jQuery.proxy = function( fn, context ) {
12840	var tmp, args, proxy;
12841
12842	if ( typeof context === "string" ) {
12843		tmp = fn[ context ];
12844		context = fn;
12845		fn = tmp;
12846	}
12847
12848	// Quick check to determine if target is callable, in the spec
12849	// this throws a TypeError, but we will just return undefined.
12850	if ( !isFunction( fn ) ) {
12851		return undefined;
12852	}
12853
12854	// Simulated bind
12855	args = slice.call( arguments, 2 );
12856	proxy = function() {
12857		return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
12858	};
12859
12860	// Set the guid of unique handler to the same of original handler, so it can be removed
12861	proxy.guid = fn.guid = fn.guid || jQuery.guid++;
12862
12863	return proxy;
12864};
12865
12866jQuery.holdReady = function( hold ) {
12867	if ( hold ) {
12868		jQuery.readyWait++;
12869	} else {
12870		jQuery.ready( true );
12871	}
12872};
12873jQuery.isArray = Array.isArray;
12874jQuery.parseJSON = JSON.parse;
12875jQuery.nodeName = nodeName;
12876jQuery.isFunction = isFunction;
12877jQuery.isWindow = isWindow;
12878jQuery.camelCase = camelCase;
12879jQuery.type = toType;
12880
12881jQuery.now = Date.now;
12882
12883jQuery.isNumeric = function( obj ) {
12884
12885	// As of jQuery 3.0, isNumeric is limited to
12886	// strings and numbers (primitives or objects)
12887	// that can be coerced to finite numbers (gh-2662)
12888	var type = jQuery.type( obj );
12889	return ( type === "number" || type === "string" ) &&
12890
12891		// parseFloat NaNs numeric-cast false positives ("")
12892		// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
12893		// subtraction forces infinities to NaN
12894		!isNaN( obj - parseFloat( obj ) );
12895};
12896
12897
12898
12899
12900// Register as a named AMD module, since jQuery can be concatenated with other
12901// files that may use define, but not via a proper concatenation script that
12902// understands anonymous AMD modules. A named AMD is safest and most robust
12903// way to register. Lowercase jquery is used because AMD module names are
12904// derived from file names, and jQuery is normally delivered in a lowercase
12905// file name. Do this after creating the global so that if an AMD module wants
12906// to call noConflict to hide this version of jQuery, it will work.
12907
12908// Note that for maximum portability, libraries that are not jQuery should
12909// declare themselves as anonymous modules, and avoid setting a global if an
12910// AMD loader is present. jQuery is a special case. For more information, see
12911// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
12912
12913if ( true ) {
12914	!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function() {
12915		return jQuery;
12916	}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
12917		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
12918}
12919
12920
12921
12922
12923var
12924
12925	// Map over jQuery in case of overwrite
12926	_jQuery = window.jQuery,
12927
12928	// Map over the $ in case of overwrite
12929	_$ = window.$;
12930
12931jQuery.noConflict = function( deep ) {
12932	if ( window.$ === jQuery ) {
12933		window.$ = _$;
12934	}
12935
12936	if ( deep && window.jQuery === jQuery ) {
12937		window.jQuery = _jQuery;
12938	}
12939
12940	return jQuery;
12941};
12942
12943// Expose jQuery and $ identifiers, even in AMD
12944// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
12945// and CommonJS for browser emulators (#13566)
12946if ( !noGlobal ) {
12947	window.jQuery = window.$ = jQuery;
12948}
12949
12950
12951
12952
12953return jQuery;
12954} );
12955
12956
12957/***/ }),
12958