\s*$/g; // Prefer a tbody over its parent table for containing new rows
+
+ function manipulationTarget(elem, content) {
+ if (nodeName(elem, "table") && nodeName(content.nodeType !== 11 ? content : content.firstChild, "tr")) {
+ return jQuery(elem).children("tbody")[0] || elem;
+ }
+
+ return elem;
+ } // Replace/restore the type attribute of script elements for safe DOM manipulation
+
+
+ function disableScript(elem) {
+ elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type;
+ return elem;
+ }
+
+ function restoreScript(elem) {
+ if ((elem.type || "").slice(0, 5) === "true/") {
+ elem.type = elem.type.slice(5);
+ } else {
+ elem.removeAttribute("type");
+ }
+
+ return elem;
+ }
+
+ function cloneCopyEvent(src, dest) {
+ var i, l, type, pdataOld, udataOld, udataCur, events;
+
+ if (dest.nodeType !== 1) {
+ return;
+ } // 1. Copy private data: events, handlers, etc.
+
+
+ if (dataPriv.hasData(src)) {
+ pdataOld = dataPriv.get(src);
+ events = pdataOld.events;
+
+ if (events) {
+ dataPriv.remove(dest, "handle events");
+
+ for (type in events) {
+ for (i = 0, l = events[type].length; i < l; i++) {
+ jQuery.event.add(dest, type, events[type][i]);
+ }
+ }
+ }
+ } // 2. Copy user data
+
+
+ if (dataUser.hasData(src)) {
+ udataOld = dataUser.access(src);
+ udataCur = jQuery.extend({}, udataOld);
+ dataUser.set(dest, udataCur);
+ }
+ } // Fix IE bugs, see support tests
+
+
+ function fixInput(src, dest) {
+ var nodeName = dest.nodeName.toLowerCase(); // Fails to persist the checked state of a cloned checkbox or radio button.
+
+ if (nodeName === "input" && rcheckableType.test(src.type)) {
+ dest.checked = src.checked; // Fails to return the selected option to the default selected state when cloning options
+ } else if (nodeName === "input" || nodeName === "textarea") {
+ dest.defaultValue = src.defaultValue;
+ }
+ }
+
+ function domManip(collection, args, callback, ignored) {
+ // Flatten any nested arrays
+ args = flat(args);
+ var fragment,
+ first,
+ scripts,
+ hasScripts,
+ node,
+ doc,
+ i = 0,
+ l = collection.length,
+ iNoClone = l - 1,
+ value = args[0],
+ valueIsFunction = isFunction(value); // We can't cloneNode fragments that contain checked, in WebKit
+
+ if (valueIsFunction || l > 1 && typeof value === "string" && !support.checkClone && rchecked.test(value)) {
+ return collection.each(function (index) {
+ var self = collection.eq(index);
+
+ if (valueIsFunction) {
+ args[0] = value.call(this, index, self.html());
+ }
+
+ domManip(self, args, callback, ignored);
+ });
+ }
+
+ if (l) {
+ fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored);
+ first = fragment.firstChild;
+
+ if (fragment.childNodes.length === 1) {
+ fragment = first;
+ } // Require either new content or an interest in ignored elements to invoke the callback
+
+
+ if (first || ignored) {
+ scripts = jQuery.map(getAll(fragment, "script"), disableScript);
+ hasScripts = scripts.length; // Use the original fragment for the last item
+ // instead of the first because it can end up
+ // being emptied incorrectly in certain situations (#8070).
+
+ for (; i < l; i++) {
+ node = fragment;
+
+ if (i !== iNoClone) {
+ node = jQuery.clone(node, true, true); // Keep references to cloned scripts for later restoration
+
+ if (hasScripts) {
+ // Support: Android <=4.0 only, PhantomJS 1 only
+ // push.apply(_, arraylike) throws on ancient WebKit
+ jQuery.merge(scripts, getAll(node, "script"));
+ }
+ }
+
+ callback.call(collection[i], node, i);
+ }
+
+ if (hasScripts) {
+ doc = scripts[scripts.length - 1].ownerDocument; // Reenable scripts
+
+ jQuery.map(scripts, restoreScript); // Evaluate executable scripts on first document insertion
+
+ for (i = 0; i < hasScripts; i++) {
+ node = scripts[i];
+
+ if (rscriptType.test(node.type || "") && !dataPriv.access(node, "globalEval") && jQuery.contains(doc, node)) {
+ if (node.src && (node.type || "").toLowerCase() !== "module") {
+ // Optional AJAX dependency, but won't run scripts if not present
+ if (jQuery._evalUrl && !node.noModule) {
+ jQuery._evalUrl(node.src, {
+ nonce: node.nonce || node.getAttribute("nonce")
+ }, doc);
+ }
+ } else {
+ DOMEval(node.textContent.replace(rcleanScript, ""), node, doc);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return collection;
+ }
+
+ function _remove(elem, selector, keepData) {
+ var node,
+ nodes = selector ? jQuery.filter(selector, elem) : elem,
+ i = 0;
+
+ for (; (node = nodes[i]) != null; i++) {
+ if (!keepData && node.nodeType === 1) {
+ jQuery.cleanData(getAll(node));
+ }
+
+ if (node.parentNode) {
+ if (keepData && isAttached(node)) {
+ setGlobalEval(getAll(node, "script"));
+ }
+
+ node.parentNode.removeChild(node);
+ }
+ }
+
+ return elem;
+ }
+
+ jQuery.extend({
+ htmlPrefilter: function htmlPrefilter(html) {
+ return html;
+ },
+ clone: function clone(elem, dataAndEvents, deepDataAndEvents) {
+ var i,
+ l,
+ srcElements,
+ destElements,
+ clone = elem.cloneNode(true),
+ inPage = isAttached(elem); // Fix IE cloning issues
+
+ if (!support.noCloneChecked && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem)) {
+ // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
+ destElements = getAll(clone);
+ srcElements = getAll(elem);
+
+ for (i = 0, l = srcElements.length; i < l; i++) {
+ fixInput(srcElements[i], destElements[i]);
+ }
+ } // Copy the events from the original to the clone
+
+
+ if (dataAndEvents) {
+ if (deepDataAndEvents) {
+ srcElements = srcElements || getAll(elem);
+ destElements = destElements || getAll(clone);
+
+ for (i = 0, l = srcElements.length; i < l; i++) {
+ cloneCopyEvent(srcElements[i], destElements[i]);
+ }
+ } else {
+ cloneCopyEvent(elem, clone);
+ }
+ } // Preserve script evaluation history
+
+
+ destElements = getAll(clone, "script");
+
+ if (destElements.length > 0) {
+ setGlobalEval(destElements, !inPage && getAll(elem, "script"));
+ } // Return the cloned set
+
+
+ return clone;
+ },
+ cleanData: function cleanData(elems) {
+ var data,
+ elem,
+ type,
+ special = jQuery.event.special,
+ i = 0;
+
+ for (; (elem = elems[i]) !== undefined; i++) {
+ if (acceptData(elem)) {
+ if (data = elem[dataPriv.expando]) {
+ if (data.events) {
+ for (type in data.events) {
+ if (special[type]) {
+ jQuery.event.remove(elem, type); // This is a shortcut to avoid jQuery.event.remove's overhead
+ } else {
+ jQuery.removeEvent(elem, type, data.handle);
+ }
+ }
+ } // Support: Chrome <=35 - 45+
+ // Assign undefined instead of using delete, see Data#remove
+
+
+ elem[dataPriv.expando] = undefined;
+ }
+
+ if (elem[dataUser.expando]) {
+ // Support: Chrome <=35 - 45+
+ // Assign undefined instead of using delete, see Data#remove
+ elem[dataUser.expando] = undefined;
+ }
+ }
+ }
+ }
+ });
+ jQuery.fn.extend({
+ detach: function detach(selector) {
+ return _remove(this, selector, true);
+ },
+ remove: function remove(selector) {
+ return _remove(this, selector);
+ },
+ text: function text(value) {
+ return access(this, function (value) {
+ return value === undefined ? jQuery.text(this) : this.empty().each(function () {
+ if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
+ this.textContent = value;
+ }
+ });
+ }, null, value, arguments.length);
+ },
+ append: function append() {
+ return domManip(this, arguments, function (elem) {
+ if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
+ var target = manipulationTarget(this, elem);
+ target.appendChild(elem);
+ }
+ });
+ },
+ prepend: function prepend() {
+ return domManip(this, arguments, function (elem) {
+ if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
+ var target = manipulationTarget(this, elem);
+ target.insertBefore(elem, target.firstChild);
+ }
+ });
+ },
+ before: function before() {
+ return domManip(this, arguments, function (elem) {
+ if (this.parentNode) {
+ this.parentNode.insertBefore(elem, this);
+ }
+ });
+ },
+ after: function after() {
+ return domManip(this, arguments, function (elem) {
+ if (this.parentNode) {
+ this.parentNode.insertBefore(elem, this.nextSibling);
+ }
+ });
+ },
+ empty: function empty() {
+ var elem,
+ i = 0;
+
+ for (; (elem = this[i]) != null; i++) {
+ if (elem.nodeType === 1) {
+ // Prevent memory leaks
+ jQuery.cleanData(getAll(elem, false)); // Remove any remaining nodes
+
+ elem.textContent = "";
+ }
+ }
+
+ return this;
+ },
+ clone: function clone(dataAndEvents, deepDataAndEvents) {
+ dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
+ deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
+ return this.map(function () {
+ return jQuery.clone(this, dataAndEvents, deepDataAndEvents);
+ });
+ },
+ html: function html(value) {
+ return access(this, function (value) {
+ var elem = this[0] || {},
+ i = 0,
+ l = this.length;
+
+ if (value === undefined && elem.nodeType === 1) {
+ return elem.innerHTML;
+ } // See if we can take a shortcut and just use innerHTML
+
+
+ if (typeof value === "string" && !rnoInnerhtml.test(value) && !wrapMap[(rtagName.exec(value) || ["", ""])[1].toLowerCase()]) {
+ value = jQuery.htmlPrefilter(value);
+
+ try {
+ for (; i < l; i++) {
+ elem = this[i] || {}; // Remove element nodes and prevent memory leaks
+
+ if (elem.nodeType === 1) {
+ jQuery.cleanData(getAll(elem, false));
+ elem.innerHTML = value;
+ }
+ }
+
+ elem = 0; // If using innerHTML throws an exception, use the fallback method
+ } catch (e) {}
+ }
+
+ if (elem) {
+ this.empty().append(value);
+ }
+ }, null, value, arguments.length);
+ },
+ replaceWith: function replaceWith() {
+ var ignored = []; // Make the changes, replacing each non-ignored context element with the new content
+
+ return domManip(this, arguments, function (elem) {
+ var parent = this.parentNode;
+
+ if (jQuery.inArray(this, ignored) < 0) {
+ jQuery.cleanData(getAll(this));
+
+ if (parent) {
+ parent.replaceChild(elem, this);
+ }
+ } // Force callback invocation
+
+ }, ignored);
+ }
+ });
+ jQuery.each({
+ appendTo: "append",
+ prependTo: "prepend",
+ insertBefore: "before",
+ insertAfter: "after",
+ replaceAll: "replaceWith"
+ }, function (name, original) {
+ jQuery.fn[name] = function (selector) {
+ var elems,
+ ret = [],
+ insert = jQuery(selector),
+ last = insert.length - 1,
+ i = 0;
+
+ for (; i <= last; i++) {
+ elems = i === last ? this : this.clone(true);
+ jQuery(insert[i])[original](elems); // Support: Android <=4.0 only, PhantomJS 1 only
+ // .get() because push.apply(_, arraylike) throws on ancient WebKit
+
+ push.apply(ret, elems.get());
+ }
+
+ return this.pushStack(ret);
+ };
+ });
+ var rnumnonpx = new RegExp("^(" + pnum + ")(?!px)[a-z%]+$", "i");
+
+ var getStyles = function getStyles(elem) {
+ // Support: IE <=11 only, Firefox <=30 (#15098, #14150)
+ // IE throws on elements created in popups
+ // FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
+ var view = elem.ownerDocument.defaultView;
+
+ if (!view || !view.opener) {
+ view = window;
+ }
+
+ return view.getComputedStyle(elem);
+ };
+
+ var swap = function swap(elem, options, callback) {
+ var ret,
+ name,
+ old = {}; // Remember the old values, and insert the new ones
+
+ for (name in options) {
+ old[name] = elem.style[name];
+ elem.style[name] = options[name];
+ }
+
+ ret = callback.call(elem); // Revert the old values
+
+ for (name in options) {
+ elem.style[name] = old[name];
+ }
+
+ return ret;
+ };
+
+ var rboxStyle = new RegExp(cssExpand.join("|"), "i");
+
+ (function () {
+ // Executing both pixelPosition & boxSizingReliable tests require only one layout
+ // so they're executed at the same time to save the second computation.
+ function computeStyleTests() {
+ // This is a singleton, we need to execute it only once
+ if (!div) {
+ return;
+ }
+
+ container.style.cssText = "position:absolute;left:-11111px;width:60px;" + "margin-top:1px;padding:0;border:0";
+ div.style.cssText = "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + "margin:auto;border:1px;padding:1px;" + "width:60%;top:1%";
+ documentElement.appendChild(container).appendChild(div);
+ var divStyle = window.getComputedStyle(div);
+ pixelPositionVal = divStyle.top !== "1%"; // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
+
+ reliableMarginLeftVal = roundPixelMeasures(divStyle.marginLeft) === 12; // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3
+ // Some styles come back with percentage values, even though they shouldn't
+
+ div.style.right = "60%";
+ pixelBoxStylesVal = roundPixelMeasures(divStyle.right) === 36; // Support: IE 9 - 11 only
+ // Detect misreporting of content dimensions for box-sizing:border-box elements
+
+ boxSizingReliableVal = roundPixelMeasures(divStyle.width) === 36; // Support: IE 9 only
+ // Detect overflow:scroll screwiness (gh-3699)
+ // Support: Chrome <=64
+ // Don't get tricked when zoom affects offsetWidth (gh-4029)
+
+ div.style.position = "absolute";
+ scrollboxSizeVal = roundPixelMeasures(div.offsetWidth / 3) === 12;
+ documentElement.removeChild(container); // Nullify the div so it wouldn't be stored in the memory and
+ // it will also be a sign that checks already performed
+
+ div = null;
+ }
+
+ function roundPixelMeasures(measure) {
+ return Math.round(parseFloat(measure));
+ }
+
+ var pixelPositionVal,
+ boxSizingReliableVal,
+ scrollboxSizeVal,
+ pixelBoxStylesVal,
+ reliableTrDimensionsVal,
+ reliableMarginLeftVal,
+ container = document.createElement("div"),
+ div = document.createElement("div"); // Finish early in limited (non-browser) environments
+
+ if (!div.style) {
+ return;
+ } // Support: IE <=9 - 11 only
+ // Style of cloned element affects source element cloned (#8908)
+
+
+ div.style.backgroundClip = "content-box";
+ div.cloneNode(true).style.backgroundClip = "";
+ support.clearCloneStyle = div.style.backgroundClip === "content-box";
+ jQuery.extend(support, {
+ boxSizingReliable: function boxSizingReliable() {
+ computeStyleTests();
+ return boxSizingReliableVal;
+ },
+ pixelBoxStyles: function pixelBoxStyles() {
+ computeStyleTests();
+ return pixelBoxStylesVal;
+ },
+ pixelPosition: function pixelPosition() {
+ computeStyleTests();
+ return pixelPositionVal;
+ },
+ reliableMarginLeft: function reliableMarginLeft() {
+ computeStyleTests();
+ return reliableMarginLeftVal;
+ },
+ scrollboxSize: function scrollboxSize() {
+ computeStyleTests();
+ return scrollboxSizeVal;
+ },
+ // Support: IE 9 - 11+, Edge 15 - 18+
+ // IE/Edge misreport `getComputedStyle` of table rows with width/height
+ // set in CSS while `offset*` properties report correct values.
+ // Behavior in IE 9 is more subtle than in newer versions & it passes
+ // some versions of this test; make sure not to make it pass there!
+ reliableTrDimensions: function reliableTrDimensions() {
+ var table, tr, trChild, trStyle;
+
+ if (reliableTrDimensionsVal == null) {
+ table = document.createElement("table");
+ tr = document.createElement("tr");
+ trChild = document.createElement("div");
+ table.style.cssText = "position:absolute;left:-11111px";
+ tr.style.height = "1px";
+ trChild.style.height = "9px";
+ documentElement.appendChild(table).appendChild(tr).appendChild(trChild);
+ trStyle = window.getComputedStyle(tr);
+ reliableTrDimensionsVal = parseInt(trStyle.height) > 3;
+ documentElement.removeChild(table);
+ }
+
+ return reliableTrDimensionsVal;
+ }
+ });
+ })();
+
+ function curCSS(elem, name, computed) {
+ var width,
+ minWidth,
+ maxWidth,
+ ret,
+ // Support: Firefox 51+
+ // Retrieving style before computed somehow
+ // fixes an issue with getting wrong values
+ // on detached elements
+ style = elem.style;
+ computed = computed || getStyles(elem); // getPropertyValue is needed for:
+ // .css('filter') (IE 9 only, #12537)
+ // .css('--customProperty) (#3144)
+
+ if (computed) {
+ ret = computed.getPropertyValue(name) || computed[name];
+
+ if (ret === "" && !isAttached(elem)) {
+ ret = jQuery.style(elem, name);
+ } // A tribute to the "awesome hack by Dean Edwards"
+ // Android Browser returns percentage for some values,
+ // but width seems to be reliably pixels.
+ // This is against the CSSOM draft spec:
+ // https://drafts.csswg.org/cssom/#resolved-values
+
+
+ if (!support.pixelBoxStyles() && rnumnonpx.test(ret) && rboxStyle.test(name)) {
+ // Remember the original values
+ width = style.width;
+ minWidth = style.minWidth;
+ maxWidth = style.maxWidth; // Put in the new values to get a computed value out
+
+ style.minWidth = style.maxWidth = style.width = ret;
+ ret = computed.width; // Revert the changed values
+
+ style.width = width;
+ style.minWidth = minWidth;
+ style.maxWidth = maxWidth;
+ }
+ }
+
+ return ret !== undefined ? // Support: IE <=9 - 11 only
+ // IE returns zIndex value as an integer.
+ ret + "" : ret;
+ }
+
+ function addGetHookIf(conditionFn, hookFn) {
+ // Define the hook, we'll check on the first run if it's really needed.
+ return {
+ get: function get() {
+ if (conditionFn()) {
+ // Hook not needed (or it's not possible to use it due
+ // to missing dependency), remove it.
+ delete this.get;
+ return;
+ } // Hook needed; redefine it so that the support test is not executed again.
+
+
+ return (this.get = hookFn).apply(this, arguments);
+ }
+ };
+ }
+
+ var cssPrefixes = ["Webkit", "Moz", "ms"],
+ emptyStyle = document.createElement("div").style,
+ vendorProps = {}; // Return a vendor-prefixed property or undefined
+
+ function vendorPropName(name) {
+ // Check for vendor prefixed names
+ var capName = name[0].toUpperCase() + name.slice(1),
+ i = cssPrefixes.length;
+
+ while (i--) {
+ name = cssPrefixes[i] + capName;
+
+ if (name in emptyStyle) {
+ return name;
+ }
+ }
+ } // Return a potentially-mapped jQuery.cssProps or vendor prefixed property
+
+
+ function finalPropName(name) {
+ var final = jQuery.cssProps[name] || vendorProps[name];
+
+ if (final) {
+ return final;
+ }
+
+ if (name in emptyStyle) {
+ return name;
+ }
+
+ return vendorProps[name] = vendorPropName(name) || name;
+ }
+
+ var // Swappable if display is none or starts with table
+ // except "table", "table-cell", or "table-caption"
+ // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
+ rdisplayswap = /^(none|table(?!-c[ea]).+)/,
+ rcustomProp = /^--/,
+ cssShow = {
+ position: "absolute",
+ visibility: "hidden",
+ display: "block"
+ },
+ cssNormalTransform = {
+ letterSpacing: "0",
+ fontWeight: "400"
+ };
+
+ function setPositiveNumber(_elem, value, subtract) {
+ // Any relative (+/-) values have already been
+ // normalized at this point
+ var matches = rcssNum.exec(value);
+ return matches ? // Guard against undefined "subtract", e.g., when used as in cssHooks
+ Math.max(0, matches[2] - (subtract || 0)) + (matches[3] || "px") : value;
+ }
+
+ function boxModelAdjustment(elem, dimension, box, isBorderBox, styles, computedVal) {
+ var i = dimension === "width" ? 1 : 0,
+ extra = 0,
+ delta = 0; // Adjustment may not be necessary
+
+ if (box === (isBorderBox ? "border" : "content")) {
+ return 0;
+ }
+
+ for (; i < 4; i += 2) {
+ // Both box models exclude margin
+ if (box === "margin") {
+ delta += jQuery.css(elem, box + cssExpand[i], true, styles);
+ } // If we get here with a content-box, we're seeking "padding" or "border" or "margin"
+
+
+ if (!isBorderBox) {
+ // Add padding
+ delta += jQuery.css(elem, "padding" + cssExpand[i], true, styles); // For "border" or "margin", add border
+
+ if (box !== "padding") {
+ delta += jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles); // But still keep track of it otherwise
+ } else {
+ extra += jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
+ } // If we get here with a border-box (content + padding + border), we're seeking "content" or
+ // "padding" or "margin"
+
+ } else {
+ // For "content", subtract padding
+ if (box === "content") {
+ delta -= jQuery.css(elem, "padding" + cssExpand[i], true, styles);
+ } // For "content" or "padding", subtract border
+
+
+ if (box !== "margin") {
+ delta -= jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
+ }
+ }
+ } // Account for positive content-box scroll gutter when requested by providing computedVal
+
+
+ if (!isBorderBox && computedVal >= 0) {
+ // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
+ // Assuming integer scroll gutter, subtract the rest and round down
+ delta += Math.max(0, Math.ceil(elem["offset" + dimension[0].toUpperCase() + dimension.slice(1)] - computedVal - delta - extra - 0.5 // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter
+ // Use an explicit zero to avoid NaN (gh-3964)
+ )) || 0;
+ }
+
+ return delta;
+ }
+
+ function getWidthOrHeight(elem, dimension, extra) {
+ // Start with computed style
+ var styles = getStyles(elem),
+ // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).
+ // Fake content-box until we know it's needed to know the true value.
+ boxSizingNeeded = !support.boxSizingReliable() || extra,
+ isBorderBox = boxSizingNeeded && jQuery.css(elem, "boxSizing", false, styles) === "border-box",
+ valueIsBorderBox = isBorderBox,
+ val = curCSS(elem, dimension, styles),
+ offsetProp = "offset" + dimension[0].toUpperCase() + dimension.slice(1); // Support: Firefox <=54
+ // Return a confounding non-pixel value or feign ignorance, as appropriate.
+
+ if (rnumnonpx.test(val)) {
+ if (!extra) {
+ return val;
+ }
+
+ val = "auto";
+ } // Support: IE 9 - 11 only
+ // Use offsetWidth/offsetHeight for when box sizing is unreliable.
+ // In those cases, the computed value can be trusted to be border-box.
+
+
+ if ((!support.boxSizingReliable() && isBorderBox || // Support: IE 10 - 11+, Edge 15 - 18+
+ // IE/Edge misreport `getComputedStyle` of table rows with width/height
+ // set in CSS while `offset*` properties report correct values.
+ // Interestingly, in some cases IE 9 doesn't suffer from this issue.
+ !support.reliableTrDimensions() && nodeName(elem, "tr") || // Fall back to offsetWidth/offsetHeight when value is "auto"
+ // This happens for inline elements with no explicit setting (gh-3571)
+ val === "auto" || // Support: Android <=4.1 - 4.3 only
+ // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
+ !parseFloat(val) && jQuery.css(elem, "display", false, styles) === "inline") && // Make sure the element is visible & connected
+ elem.getClientRects().length) {
+ isBorderBox = jQuery.css(elem, "boxSizing", false, styles) === "border-box"; // Where available, offsetWidth/offsetHeight approximate border box dimensions.
+ // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the
+ // retrieved value as a content box dimension.
+
+ valueIsBorderBox = offsetProp in elem;
+
+ if (valueIsBorderBox) {
+ val = elem[offsetProp];
+ }
+ } // Normalize "" and auto
+
+
+ val = parseFloat(val) || 0; // Adjust for the element's box model
+
+ return val + boxModelAdjustment(elem, dimension, extra || (isBorderBox ? "border" : "content"), valueIsBorderBox, styles, // Provide the current computed size to request scroll gutter calculation (gh-3589)
+ val) + "px";
+ }
+
+ jQuery.extend({
+ // Add in style property hooks for overriding the default
+ // behavior of getting and setting a style property
+ cssHooks: {
+ opacity: {
+ get: function get(elem, computed) {
+ if (computed) {
+ // We should always get a number back from opacity
+ var ret = curCSS(elem, "opacity");
+ return ret === "" ? "1" : ret;
+ }
+ }
+ }
+ },
+ // Don't automatically add "px" to these possibly-unitless properties
+ cssNumber: {
+ "animationIterationCount": true,
+ "columnCount": true,
+ "fillOpacity": true,
+ "flexGrow": true,
+ "flexShrink": true,
+ "fontWeight": true,
+ "gridArea": true,
+ "gridColumn": true,
+ "gridColumnEnd": true,
+ "gridColumnStart": true,
+ "gridRow": true,
+ "gridRowEnd": true,
+ "gridRowStart": true,
+ "lineHeight": true,
+ "opacity": true,
+ "order": true,
+ "orphans": true,
+ "widows": true,
+ "zIndex": true,
+ "zoom": true
+ },
+ // Add in properties whose names you wish to fix before
+ // setting or getting the value
+ cssProps: {},
+ // Get and set the style property on a DOM Node
+ style: function style(elem, name, value, extra) {
+ // Don't set styles on text and comment nodes
+ if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) {
+ return;
+ } // Make sure that we're working with the right name
+
+
+ var ret,
+ type,
+ hooks,
+ origName = camelCase(name),
+ isCustomProp = rcustomProp.test(name),
+ style = elem.style; // Make sure that we're working with the right name. We don't
+ // want to query the value if it is a CSS custom property
+ // since they are user-defined.
+
+ if (!isCustomProp) {
+ name = finalPropName(origName);
+ } // Gets hook for the prefixed version, then unprefixed version
+
+
+ hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName]; // Check if we're setting a value
+
+ if (value !== undefined) {
+ type = _typeof(value); // Convert "+=" or "-=" to relative numbers (#7345)
+
+ if (type === "string" && (ret = rcssNum.exec(value)) && ret[1]) {
+ value = adjustCSS(elem, name, ret); // Fixes bug #9237
+
+ type = "number";
+ } // Make sure that null and NaN values aren't set (#7116)
+
+
+ if (value == null || value !== value) {
+ return;
+ } // If a number was passed in, add the unit (except for certain CSS properties)
+ // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append
+ // "px" to a few hardcoded values.
+
+
+ if (type === "number" && !isCustomProp) {
+ value += ret && ret[3] || (jQuery.cssNumber[origName] ? "" : "px");
+ } // background-* props affect original clone's values
+
+
+ if (!support.clearCloneStyle && value === "" && name.indexOf("background") === 0) {
+ style[name] = "inherit";
+ } // If a hook was provided, use that value, otherwise just set the specified value
+
+
+ if (!hooks || !("set" in hooks) || (value = hooks.set(elem, value, extra)) !== undefined) {
+ if (isCustomProp) {
+ style.setProperty(name, value);
+ } else {
+ style[name] = value;
+ }
+ }
+ } else {
+ // If a hook was provided get the non-computed value from there
+ if (hooks && "get" in hooks && (ret = hooks.get(elem, false, extra)) !== undefined) {
+ return ret;
+ } // Otherwise just get the value from the style object
+
+
+ return style[name];
+ }
+ },
+ css: function css(elem, name, extra, styles) {
+ var val,
+ num,
+ hooks,
+ origName = camelCase(name),
+ isCustomProp = rcustomProp.test(name); // Make sure that we're working with the right name. We don't
+ // want to modify the value if it is a CSS custom property
+ // since they are user-defined.
+
+ if (!isCustomProp) {
+ name = finalPropName(origName);
+ } // Try prefixed name followed by the unprefixed name
+
+
+ hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName]; // If a hook was provided get the computed value from there
+
+ if (hooks && "get" in hooks) {
+ val = hooks.get(elem, true, extra);
+ } // Otherwise, if a way to get the computed value exists, use that
+
+
+ if (val === undefined) {
+ val = curCSS(elem, name, styles);
+ } // Convert "normal" to computed value
+
+
+ if (val === "normal" && name in cssNormalTransform) {
+ val = cssNormalTransform[name];
+ } // Make numeric if forced or a qualifier was provided and val looks numeric
+
+
+ if (extra === "" || extra) {
+ num = parseFloat(val);
+ return extra === true || isFinite(num) ? num || 0 : val;
+ }
+
+ return val;
+ }
+ });
+ jQuery.each(["height", "width"], function (_i, dimension) {
+ jQuery.cssHooks[dimension] = {
+ get: function get(elem, computed, extra) {
+ if (computed) {
+ // Certain elements can have dimension info if we invisibly show them
+ // but it must have a current display style that would benefit
+ return rdisplayswap.test(jQuery.css(elem, "display")) && ( // Support: Safari 8+
+ // Table columns in Safari have non-zero offsetWidth & zero
+ // getBoundingClientRect().width unless display is changed.
+ // Support: IE <=11 only
+ // Running getBoundingClientRect on a disconnected node
+ // in IE throws an error.
+ !elem.getClientRects().length || !elem.getBoundingClientRect().width) ? swap(elem, cssShow, function () {
+ return getWidthOrHeight(elem, dimension, extra);
+ }) : getWidthOrHeight(elem, dimension, extra);
+ }
+ },
+ set: function set(elem, value, extra) {
+ var matches,
+ styles = getStyles(elem),
+ // Only read styles.position if the test has a chance to fail
+ // to avoid forcing a reflow.
+ scrollboxSizeBuggy = !support.scrollboxSize() && styles.position === "absolute",
+ // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)
+ boxSizingNeeded = scrollboxSizeBuggy || extra,
+ isBorderBox = boxSizingNeeded && jQuery.css(elem, "boxSizing", false, styles) === "border-box",
+ subtract = extra ? boxModelAdjustment(elem, dimension, extra, isBorderBox, styles) : 0; // Account for unreliable border-box dimensions by comparing offset* to computed and
+ // faking a content-box to get border and padding (gh-3699)
+
+ if (isBorderBox && scrollboxSizeBuggy) {
+ subtract -= Math.ceil(elem["offset" + dimension[0].toUpperCase() + dimension.slice(1)] - parseFloat(styles[dimension]) - boxModelAdjustment(elem, dimension, "border", false, styles) - 0.5);
+ } // Convert to pixels if value adjustment is needed
+
+
+ if (subtract && (matches = rcssNum.exec(value)) && (matches[3] || "px") !== "px") {
+ elem.style[dimension] = value;
+ value = jQuery.css(elem, dimension);
+ }
+
+ return setPositiveNumber(elem, value, subtract);
+ }
+ };
+ });
+ jQuery.cssHooks.marginLeft = addGetHookIf(support.reliableMarginLeft, function (elem, computed) {
+ if (computed) {
+ return (parseFloat(curCSS(elem, "marginLeft")) || elem.getBoundingClientRect().left - swap(elem, {
+ marginLeft: 0
+ }, function () {
+ return elem.getBoundingClientRect().left;
+ })) + "px";
+ }
+ }); // These hooks are used by animate to expand properties
+
+ jQuery.each({
+ margin: "",
+ padding: "",
+ border: "Width"
+ }, function (prefix, suffix) {
+ jQuery.cssHooks[prefix + suffix] = {
+ expand: function expand(value) {
+ var i = 0,
+ expanded = {},
+ // Assumes a single number if not a string
+ parts = typeof value === "string" ? value.split(" ") : [value];
+
+ for (; i < 4; i++) {
+ expanded[prefix + cssExpand[i] + suffix] = parts[i] || parts[i - 2] || parts[0];
+ }
+
+ return expanded;
+ }
+ };
+
+ if (prefix !== "margin") {
+ jQuery.cssHooks[prefix + suffix].set = setPositiveNumber;
+ }
+ });
+ jQuery.fn.extend({
+ css: function css(name, value) {
+ return access(this, function (elem, name, value) {
+ var styles,
+ len,
+ map = {},
+ i = 0;
+
+ if (Array.isArray(name)) {
+ styles = getStyles(elem);
+ len = name.length;
+
+ for (; i < len; i++) {
+ map[name[i]] = jQuery.css(elem, name[i], false, styles);
+ }
+
+ return map;
+ }
+
+ return value !== undefined ? jQuery.style(elem, name, value) : jQuery.css(elem, name);
+ }, name, value, arguments.length > 1);
+ }
+ });
+
+ function Tween(elem, options, prop, end, easing) {
+ return new Tween.prototype.init(elem, options, prop, end, easing);
+ }
+
+ jQuery.Tween = Tween;
+ Tween.prototype = {
+ constructor: Tween,
+ init: function init(elem, options, prop, end, easing, unit) {
+ this.elem = elem;
+ this.prop = prop;
+ this.easing = easing || jQuery.easing._default;
+ this.options = options;
+ this.start = this.now = this.cur();
+ this.end = end;
+ this.unit = unit || (jQuery.cssNumber[prop] ? "" : "px");
+ },
+ cur: function cur() {
+ var hooks = Tween.propHooks[this.prop];
+ return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this);
+ },
+ run: function run(percent) {
+ var eased,
+ hooks = Tween.propHooks[this.prop];
+
+ if (this.options.duration) {
+ this.pos = eased = jQuery.easing[this.easing](percent, this.options.duration * percent, 0, 1, this.options.duration);
+ } else {
+ this.pos = eased = percent;
+ }
+
+ this.now = (this.end - this.start) * eased + this.start;
+
+ if (this.options.step) {
+ this.options.step.call(this.elem, this.now, this);
+ }
+
+ if (hooks && hooks.set) {
+ hooks.set(this);
+ } else {
+ Tween.propHooks._default.set(this);
+ }
+
+ return this;
+ }
+ };
+ Tween.prototype.init.prototype = Tween.prototype;
+ Tween.propHooks = {
+ _default: {
+ get: function get(tween) {
+ var result; // Use a property on the element directly when it is not a DOM element,
+ // or when there is no matching style property that exists.
+
+ if (tween.elem.nodeType !== 1 || tween.elem[tween.prop] != null && tween.elem.style[tween.prop] == null) {
+ return tween.elem[tween.prop];
+ } // Passing an empty string as a 3rd parameter to .css will automatically
+ // attempt a parseFloat and fallback to a string if the parse fails.
+ // Simple values such as "10px" are parsed to Float;
+ // complex values such as "rotate(1rad)" are returned as-is.
+
+
+ result = jQuery.css(tween.elem, tween.prop, ""); // Empty strings, null, undefined and "auto" are converted to 0.
+
+ return !result || result === "auto" ? 0 : result;
+ },
+ set: function set(tween) {
+ // Use step hook for back compat.
+ // Use cssHook if its there.
+ // Use .style if available and use plain properties where available.
+ if (jQuery.fx.step[tween.prop]) {
+ jQuery.fx.step[tween.prop](tween);
+ } else if (tween.elem.nodeType === 1 && (jQuery.cssHooks[tween.prop] || tween.elem.style[finalPropName(tween.prop)] != null)) {
+ jQuery.style(tween.elem, tween.prop, tween.now + tween.unit);
+ } else {
+ tween.elem[tween.prop] = tween.now;
+ }
+ }
+ }
+ }; // Support: IE <=9 only
+ // Panic based approach to setting things on disconnected nodes
+
+ Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
+ set: function set(tween) {
+ if (tween.elem.nodeType && tween.elem.parentNode) {
+ tween.elem[tween.prop] = tween.now;
+ }
+ }
+ };
+ jQuery.easing = {
+ linear: function linear(p) {
+ return p;
+ },
+ swing: function swing(p) {
+ return 0.5 - Math.cos(p * Math.PI) / 2;
+ },
+ _default: "swing"
+ };
+ jQuery.fx = Tween.prototype.init; // Back compat <1.8 extension point
+
+ jQuery.fx.step = {};
+ var fxNow,
+ inProgress,
+ rfxtypes = /^(?:toggle|show|hide)$/,
+ rrun = /queueHooks$/;
+
+ function schedule() {
+ if (inProgress) {
+ if (document.hidden === false && window.requestAnimationFrame) {
+ window.requestAnimationFrame(schedule);
+ } else {
+ window.setTimeout(schedule, jQuery.fx.interval);
+ }
+
+ jQuery.fx.tick();
+ }
+ } // Animations created synchronously will run synchronously
+
+
+ function createFxNow() {
+ window.setTimeout(function () {
+ fxNow = undefined;
+ });
+ return fxNow = Date.now();
+ } // Generate parameters to create a standard animation
+
+
+ function genFx(type, includeWidth) {
+ var which,
+ i = 0,
+ attrs = {
+ height: type
+ }; // If we include width, step value is 1 to do all cssExpand values,
+ // otherwise step value is 2 to skip over Left and Right
+
+ includeWidth = includeWidth ? 1 : 0;
+
+ for (; i < 4; i += 2 - includeWidth) {
+ which = cssExpand[i];
+ attrs["margin" + which] = attrs["padding" + which] = type;
+ }
+
+ if (includeWidth) {
+ attrs.opacity = attrs.width = type;
+ }
+
+ return attrs;
+ }
+
+ function createTween(value, prop, animation) {
+ var tween,
+ collection = (Animation.tweeners[prop] || []).concat(Animation.tweeners["*"]),
+ index = 0,
+ length = collection.length;
+
+ for (; index < length; index++) {
+ if (tween = collection[index].call(animation, prop, value)) {
+ // We're done with this property
+ return tween;
+ }
+ }
+ }
+
+ function defaultPrefilter(elem, props, opts) {
+ var prop,
+ value,
+ toggle,
+ hooks,
+ oldfire,
+ propTween,
+ restoreDisplay,
+ display,
+ isBox = "width" in props || "height" in props,
+ anim = this,
+ orig = {},
+ style = elem.style,
+ hidden = elem.nodeType && isHiddenWithinTree(elem),
+ dataShow = dataPriv.get(elem, "fxshow"); // Queue-skipping animations hijack the fx hooks
+
+ if (!opts.queue) {
+ hooks = jQuery._queueHooks(elem, "fx");
+
+ if (hooks.unqueued == null) {
+ hooks.unqueued = 0;
+ oldfire = hooks.empty.fire;
+
+ hooks.empty.fire = function () {
+ if (!hooks.unqueued) {
+ oldfire();
+ }
+ };
+ }
+
+ hooks.unqueued++;
+ anim.always(function () {
+ // Ensure the complete handler is called before this completes
+ anim.always(function () {
+ hooks.unqueued--;
+
+ if (!jQuery.queue(elem, "fx").length) {
+ hooks.empty.fire();
+ }
+ });
+ });
+ } // Detect show/hide animations
+
+
+ for (prop in props) {
+ value = props[prop];
+
+ if (rfxtypes.test(value)) {
+ delete props[prop];
+ toggle = toggle || value === "toggle";
+
+ if (value === (hidden ? "hide" : "show")) {
+ // Pretend to be hidden if this is a "show" and
+ // there is still data from a stopped show/hide
+ if (value === "show" && dataShow && dataShow[prop] !== undefined) {
+ hidden = true; // Ignore all other no-op show/hide data
+ } else {
+ continue;
+ }
+ }
+
+ orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop);
+ }
+ } // Bail out if this is a no-op like .hide().hide()
+
+
+ propTween = !jQuery.isEmptyObject(props);
+
+ if (!propTween && jQuery.isEmptyObject(orig)) {
+ return;
+ } // Restrict "overflow" and "display" styles during box animations
+
+
+ if (isBox && elem.nodeType === 1) {
+ // Support: IE <=9 - 11, Edge 12 - 15
+ // Record all 3 overflow attributes because IE does not infer the shorthand
+ // from identically-valued overflowX and overflowY and Edge just mirrors
+ // the overflowX value there.
+ opts.overflow = [style.overflow, style.overflowX, style.overflowY]; // Identify a display type, preferring old show/hide data over the CSS cascade
+
+ restoreDisplay = dataShow && dataShow.display;
+
+ if (restoreDisplay == null) {
+ restoreDisplay = dataPriv.get(elem, "display");
+ }
+
+ display = jQuery.css(elem, "display");
+
+ if (display === "none") {
+ if (restoreDisplay) {
+ display = restoreDisplay;
+ } else {
+ // Get nonempty value(s) by temporarily forcing visibility
+ showHide([elem], true);
+ restoreDisplay = elem.style.display || restoreDisplay;
+ display = jQuery.css(elem, "display");
+ showHide([elem]);
+ }
+ } // Animate inline elements as inline-block
+
+
+ if (display === "inline" || display === "inline-block" && restoreDisplay != null) {
+ if (jQuery.css(elem, "float") === "none") {
+ // Restore the original display value at the end of pure show/hide animations
+ if (!propTween) {
+ anim.done(function () {
+ style.display = restoreDisplay;
+ });
+
+ if (restoreDisplay == null) {
+ display = style.display;
+ restoreDisplay = display === "none" ? "" : display;
+ }
+ }
+
+ style.display = "inline-block";
+ }
+ }
+ }
+
+ if (opts.overflow) {
+ style.overflow = "hidden";
+ anim.always(function () {
+ style.overflow = opts.overflow[0];
+ style.overflowX = opts.overflow[1];
+ style.overflowY = opts.overflow[2];
+ });
+ } // Implement show/hide animations
+
+
+ propTween = false;
+
+ for (prop in orig) {
+ // General show/hide setup for this element animation
+ if (!propTween) {
+ if (dataShow) {
+ if ("hidden" in dataShow) {
+ hidden = dataShow.hidden;
+ }
+ } else {
+ dataShow = dataPriv.access(elem, "fxshow", {
+ display: restoreDisplay
+ });
+ } // Store hidden/visible for toggle so `.stop().toggle()` "reverses"
+
+
+ if (toggle) {
+ dataShow.hidden = !hidden;
+ } // Show elements before animating them
+
+
+ if (hidden) {
+ showHide([elem], true);
+ }
+ /* eslint-disable no-loop-func */
+
+
+ anim.done(function () {
+ /* eslint-enable no-loop-func */
+ // The final step of a "hide" animation is actually hiding the element
+ if (!hidden) {
+ showHide([elem]);
+ }
+
+ dataPriv.remove(elem, "fxshow");
+
+ for (prop in orig) {
+ jQuery.style(elem, prop, orig[prop]);
+ }
+ });
+ } // Per-property setup
+
+
+ propTween = createTween(hidden ? dataShow[prop] : 0, prop, anim);
+
+ if (!(prop in dataShow)) {
+ dataShow[prop] = propTween.start;
+
+ if (hidden) {
+ propTween.end = propTween.start;
+ propTween.start = 0;
+ }
+ }
+ }
+ }
+
+ function propFilter(props, specialEasing) {
+ var index, name, easing, value, hooks; // camelCase, specialEasing and expand cssHook pass
+
+ for (index in props) {
+ name = camelCase(index);
+ easing = specialEasing[name];
+ value = props[index];
+
+ if (Array.isArray(value)) {
+ easing = value[1];
+ value = props[index] = value[0];
+ }
+
+ if (index !== name) {
+ props[name] = value;
+ delete props[index];
+ }
+
+ hooks = jQuery.cssHooks[name];
+
+ if (hooks && "expand" in hooks) {
+ value = hooks.expand(value);
+ delete props[name]; // Not quite $.extend, this won't overwrite existing keys.
+ // Reusing 'index' because we have the correct "name"
+
+ for (index in value) {
+ if (!(index in props)) {
+ props[index] = value[index];
+ specialEasing[index] = easing;
+ }
+ }
+ } else {
+ specialEasing[name] = easing;
+ }
+ }
+ }
+
+ function Animation(elem, properties, options) {
+ var result,
+ stopped,
+ index = 0,
+ length = Animation.prefilters.length,
+ deferred = jQuery.Deferred().always(function () {
+ // Don't match elem in the :animated selector
+ delete tick.elem;
+ }),
+ tick = function tick() {
+ if (stopped) {
+ return false;
+ }
+
+ var currentTime = fxNow || createFxNow(),
+ remaining = Math.max(0, animation.startTime + animation.duration - currentTime),
+ // Support: Android 2.3 only
+ // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
+ temp = remaining / animation.duration || 0,
+ percent = 1 - temp,
+ index = 0,
+ length = animation.tweens.length;
+
+ for (; index < length; index++) {
+ animation.tweens[index].run(percent);
+ }
+
+ deferred.notifyWith(elem, [animation, percent, remaining]); // If there's more to do, yield
+
+ if (percent < 1 && length) {
+ return remaining;
+ } // If this was an empty animation, synthesize a final progress notification
+
+
+ if (!length) {
+ deferred.notifyWith(elem, [animation, 1, 0]);
+ } // Resolve the animation and report its conclusion
+
+
+ deferred.resolveWith(elem, [animation]);
+ return false;
+ },
+ animation = deferred.promise({
+ elem: elem,
+ props: jQuery.extend({}, properties),
+ opts: jQuery.extend(true, {
+ specialEasing: {},
+ easing: jQuery.easing._default
+ }, options),
+ originalProperties: properties,
+ originalOptions: options,
+ startTime: fxNow || createFxNow(),
+ duration: options.duration,
+ tweens: [],
+ createTween: function createTween(prop, end) {
+ var tween = jQuery.Tween(elem, animation.opts, prop, end, animation.opts.specialEasing[prop] || animation.opts.easing);
+ animation.tweens.push(tween);
+ return tween;
+ },
+ stop: function stop(gotoEnd) {
+ var index = 0,
+ // If we are going to the end, we want to run all the tweens
+ // otherwise we skip this part
+ length = gotoEnd ? animation.tweens.length : 0;
+
+ if (stopped) {
+ return this;
+ }
+
+ stopped = true;
+
+ for (; index < length; index++) {
+ animation.tweens[index].run(1);
+ } // Resolve when we played the last frame; otherwise, reject
+
+
+ if (gotoEnd) {
+ deferred.notifyWith(elem, [animation, 1, 0]);
+ deferred.resolveWith(elem, [animation, gotoEnd]);
+ } else {
+ deferred.rejectWith(elem, [animation, gotoEnd]);
+ }
+
+ return this;
+ }
+ }),
+ props = animation.props;
+
+ propFilter(props, animation.opts.specialEasing);
+
+ for (; index < length; index++) {
+ result = Animation.prefilters[index].call(animation, elem, props, animation.opts);
+
+ if (result) {
+ if (isFunction(result.stop)) {
+ jQuery._queueHooks(animation.elem, animation.opts.queue).stop = result.stop.bind(result);
+ }
+
+ return result;
+ }
+ }
+
+ jQuery.map(props, createTween, animation);
+
+ if (isFunction(animation.opts.start)) {
+ animation.opts.start.call(elem, animation);
+ } // Attach callbacks from options
+
+
+ animation.progress(animation.opts.progress).done(animation.opts.done, animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always);
+ jQuery.fx.timer(jQuery.extend(tick, {
+ elem: elem,
+ anim: animation,
+ queue: animation.opts.queue
+ }));
+ return animation;
+ }
+
+ jQuery.Animation = jQuery.extend(Animation, {
+ tweeners: {
+ "*": [function (prop, value) {
+ var tween = this.createTween(prop, value);
+ adjustCSS(tween.elem, prop, rcssNum.exec(value), tween);
+ return tween;
+ }]
+ },
+ tweener: function tweener(props, callback) {
+ if (isFunction(props)) {
+ callback = props;
+ props = ["*"];
+ } else {
+ props = props.match(rnothtmlwhite);
+ }
+
+ var prop,
+ index = 0,
+ length = props.length;
+
+ for (; index < length; index++) {
+ prop = props[index];
+ Animation.tweeners[prop] = Animation.tweeners[prop] || [];
+ Animation.tweeners[prop].unshift(callback);
+ }
+ },
+ prefilters: [defaultPrefilter],
+ prefilter: function prefilter(callback, prepend) {
+ if (prepend) {
+ Animation.prefilters.unshift(callback);
+ } else {
+ Animation.prefilters.push(callback);
+ }
+ }
+ });
+
+ jQuery.speed = function (speed, easing, fn) {
+ var opt = speed && _typeof(speed) === "object" ? jQuery.extend({}, speed) : {
+ complete: fn || !fn && easing || isFunction(speed) && speed,
+ duration: speed,
+ easing: fn && easing || easing && !isFunction(easing) && easing
+ }; // Go to the end state if fx are off
+
+ if (jQuery.fx.off) {
+ opt.duration = 0;
+ } else {
+ if (typeof opt.duration !== "number") {
+ if (opt.duration in jQuery.fx.speeds) {
+ opt.duration = jQuery.fx.speeds[opt.duration];
+ } else {
+ opt.duration = jQuery.fx.speeds._default;
+ }
+ }
+ } // Normalize opt.queue - true/undefined/null -> "fx"
+
+
+ if (opt.queue == null || opt.queue === true) {
+ opt.queue = "fx";
+ } // Queueing
+
+
+ opt.old = opt.complete;
+
+ opt.complete = function () {
+ if (isFunction(opt.old)) {
+ opt.old.call(this);
+ }
+
+ if (opt.queue) {
+ jQuery.dequeue(this, opt.queue);
+ }
+ };
+
+ return opt;
+ };
+
+ jQuery.fn.extend({
+ fadeTo: function fadeTo(speed, to, easing, callback) {
+ // Show any hidden elements after setting opacity to 0
+ return this.filter(isHiddenWithinTree).css("opacity", 0).show() // Animate to the value specified
+ .end().animate({
+ opacity: to
+ }, speed, easing, callback);
+ },
+ animate: function animate(prop, speed, easing, callback) {
+ var empty = jQuery.isEmptyObject(prop),
+ optall = jQuery.speed(speed, easing, callback),
+ doAnimation = function doAnimation() {
+ // Operate on a copy of prop so per-property easing won't be lost
+ var anim = Animation(this, jQuery.extend({}, prop), optall); // Empty animations, or finishing resolves immediately
+
+ if (empty || dataPriv.get(this, "finish")) {
+ anim.stop(true);
+ }
+ };
+
+ doAnimation.finish = doAnimation;
+ return empty || optall.queue === false ? this.each(doAnimation) : this.queue(optall.queue, doAnimation);
+ },
+ stop: function stop(type, clearQueue, gotoEnd) {
+ var stopQueue = function stopQueue(hooks) {
+ var stop = hooks.stop;
+ delete hooks.stop;
+ stop(gotoEnd);
+ };
+
+ if (typeof type !== "string") {
+ gotoEnd = clearQueue;
+ clearQueue = type;
+ type = undefined;
+ }
+
+ if (clearQueue) {
+ this.queue(type || "fx", []);
+ }
+
+ return this.each(function () {
+ var dequeue = true,
+ index = type != null && type + "queueHooks",
+ timers = jQuery.timers,
+ data = dataPriv.get(this);
+
+ if (index) {
+ if (data[index] && data[index].stop) {
+ stopQueue(data[index]);
+ }
+ } else {
+ for (index in data) {
+ if (data[index] && data[index].stop && rrun.test(index)) {
+ stopQueue(data[index]);
+ }
+ }
+ }
+
+ for (index = timers.length; index--;) {
+ if (timers[index].elem === this && (type == null || timers[index].queue === type)) {
+ timers[index].anim.stop(gotoEnd);
+ dequeue = false;
+ timers.splice(index, 1);
+ }
+ } // Start the next in the queue if the last step wasn't forced.
+ // Timers currently will call their complete callbacks, which
+ // will dequeue but only if they were gotoEnd.
+
+
+ if (dequeue || !gotoEnd) {
+ jQuery.dequeue(this, type);
+ }
+ });
+ },
+ finish: function finish(type) {
+ if (type !== false) {
+ type = type || "fx";
+ }
+
+ return this.each(function () {
+ var index,
+ data = dataPriv.get(this),
+ queue = data[type + "queue"],
+ hooks = data[type + "queueHooks"],
+ timers = jQuery.timers,
+ length = queue ? queue.length : 0; // Enable finishing flag on private data
+
+ data.finish = true; // Empty the queue first
+
+ jQuery.queue(this, type, []);
+
+ if (hooks && hooks.stop) {
+ hooks.stop.call(this, true);
+ } // Look for any active animations, and finish them
+
+
+ for (index = timers.length; index--;) {
+ if (timers[index].elem === this && timers[index].queue === type) {
+ timers[index].anim.stop(true);
+ timers.splice(index, 1);
+ }
+ } // Look for any animations in the old queue and finish them
+
+
+ for (index = 0; index < length; index++) {
+ if (queue[index] && queue[index].finish) {
+ queue[index].finish.call(this);
+ }
+ } // Turn off finishing flag
+
+
+ delete data.finish;
+ });
+ }
+ });
+ jQuery.each(["toggle", "show", "hide"], function (_i, name) {
+ var cssFn = jQuery.fn[name];
+
+ jQuery.fn[name] = function (speed, easing, callback) {
+ return speed == null || typeof speed === "boolean" ? cssFn.apply(this, arguments) : this.animate(genFx(name, true), speed, easing, callback);
+ };
+ }); // Generate shortcuts for custom animations
+
+ jQuery.each({
+ slideDown: genFx("show"),
+ slideUp: genFx("hide"),
+ slideToggle: genFx("toggle"),
+ fadeIn: {
+ opacity: "show"
+ },
+ fadeOut: {
+ opacity: "hide"
+ },
+ fadeToggle: {
+ opacity: "toggle"
+ }
+ }, function (name, props) {
+ jQuery.fn[name] = function (speed, easing, callback) {
+ return this.animate(props, speed, easing, callback);
+ };
+ });
+ jQuery.timers = [];
+
+ jQuery.fx.tick = function () {
+ var timer,
+ i = 0,
+ timers = jQuery.timers;
+ fxNow = Date.now();
+
+ for (; i < timers.length; i++) {
+ timer = timers[i]; // Run the timer and safely remove it when done (allowing for external removal)
+
+ if (!timer() && timers[i] === timer) {
+ timers.splice(i--, 1);
+ }
+ }
+
+ if (!timers.length) {
+ jQuery.fx.stop();
+ }
+
+ fxNow = undefined;
+ };
+
+ jQuery.fx.timer = function (timer) {
+ jQuery.timers.push(timer);
+ jQuery.fx.start();
+ };
+
+ jQuery.fx.interval = 13;
+
+ jQuery.fx.start = function () {
+ if (inProgress) {
+ return;
+ }
+
+ inProgress = true;
+ schedule();
+ };
+
+ jQuery.fx.stop = function () {
+ inProgress = null;
+ };
+
+ jQuery.fx.speeds = {
+ slow: 600,
+ fast: 200,
+ // Default speed
+ _default: 400
+ }; // Based off of the plugin by Clint Helfers, with permission.
+ // https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
+
+ jQuery.fn.delay = function (time, type) {
+ time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
+ type = type || "fx";
+ return this.queue(type, function (next, hooks) {
+ var timeout = window.setTimeout(next, time);
+
+ hooks.stop = function () {
+ window.clearTimeout(timeout);
+ };
+ });
+ };
+
+ (function () {
+ var input = document.createElement("input"),
+ select = document.createElement("select"),
+ opt = select.appendChild(document.createElement("option"));
+ input.type = "checkbox"; // Support: Android <=4.3 only
+ // Default value for a checkbox should be "on"
+
+ support.checkOn = input.value !== ""; // Support: IE <=11 only
+ // Must access selectedIndex to make default options select
+
+ support.optSelected = opt.selected; // Support: IE <=11 only
+ // An input loses its value after becoming a radio
+
+ input = document.createElement("input");
+ input.value = "t";
+ input.type = "radio";
+ support.radioValue = input.value === "t";
+ })();
+
+ var boolHook,
+ attrHandle = jQuery.expr.attrHandle;
+ jQuery.fn.extend({
+ attr: function attr(name, value) {
+ return access(this, jQuery.attr, name, value, arguments.length > 1);
+ },
+ removeAttr: function removeAttr(name) {
+ return this.each(function () {
+ jQuery.removeAttr(this, name);
+ });
+ }
+ });
+ jQuery.extend({
+ attr: function attr(elem, name, value) {
+ var ret,
+ hooks,
+ nType = elem.nodeType; // Don't get/set attributes on text, comment and attribute nodes
+
+ if (nType === 3 || nType === 8 || nType === 2) {
+ return;
+ } // Fallback to prop when attributes are not supported
+
+
+ if (typeof elem.getAttribute === "undefined") {
+ return jQuery.prop(elem, name, value);
+ } // Attribute hooks are determined by the lowercase version
+ // Grab necessary hook if one is defined
+
+
+ if (nType !== 1 || !jQuery.isXMLDoc(elem)) {
+ hooks = jQuery.attrHooks[name.toLowerCase()] || (jQuery.expr.match.bool.test(name) ? boolHook : undefined);
+ }
+
+ if (value !== undefined) {
+ if (value === null) {
+ jQuery.removeAttr(elem, name);
+ return;
+ }
+
+ if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {
+ return ret;
+ }
+
+ elem.setAttribute(name, value + "");
+ return value;
+ }
+
+ if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) {
+ return ret;
+ }
+
+ ret = jQuery.find.attr(elem, name); // Non-existent attributes return null, we normalize to undefined
+
+ return ret == null ? undefined : ret;
+ },
+ attrHooks: {
+ type: {
+ set: function set(elem, value) {
+ if (!support.radioValue && value === "radio" && nodeName(elem, "input")) {
+ var val = elem.value;
+ elem.setAttribute("type", value);
+
+ if (val) {
+ elem.value = val;
+ }
+
+ return value;
+ }
+ }
+ }
+ },
+ removeAttr: function removeAttr(elem, value) {
+ var name,
+ i = 0,
+ // Attribute names can contain non-HTML whitespace characters
+ // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
+ attrNames = value && value.match(rnothtmlwhite);
+
+ if (attrNames && elem.nodeType === 1) {
+ while (name = attrNames[i++]) {
+ elem.removeAttribute(name);
+ }
+ }
+ }
+ }); // Hooks for boolean attributes
+
+ boolHook = {
+ set: function set(elem, value, name) {
+ if (value === false) {
+ // Remove boolean attributes when set to false
+ jQuery.removeAttr(elem, name);
+ } else {
+ elem.setAttribute(name, name);
+ }
+
+ return name;
+ }
+ };
+ jQuery.each(jQuery.expr.match.bool.source.match(/\w+/g), function (_i, name) {
+ var getter = attrHandle[name] || jQuery.find.attr;
+
+ attrHandle[name] = function (elem, name, isXML) {
+ var ret,
+ handle,
+ lowercaseName = name.toLowerCase();
+
+ if (!isXML) {
+ // Avoid an infinite loop by temporarily removing this function from the getter
+ handle = attrHandle[lowercaseName];
+ attrHandle[lowercaseName] = ret;
+ ret = getter(elem, name, isXML) != null ? lowercaseName : null;
+ attrHandle[lowercaseName] = handle;
+ }
+
+ return ret;
+ };
+ });
+ var rfocusable = /^(?:input|select|textarea|button)$/i,
+ rclickable = /^(?:a|area)$/i;
+ jQuery.fn.extend({
+ prop: function prop(name, value) {
+ return access(this, jQuery.prop, name, value, arguments.length > 1);
+ },
+ removeProp: function removeProp(name) {
+ return this.each(function () {
+ delete this[jQuery.propFix[name] || name];
+ });
+ }
+ });
+ jQuery.extend({
+ prop: function prop(elem, name, value) {
+ var ret,
+ hooks,
+ nType = elem.nodeType; // Don't get/set properties on text, comment and attribute nodes
+
+ if (nType === 3 || nType === 8 || nType === 2) {
+ return;
+ }
+
+ if (nType !== 1 || !jQuery.isXMLDoc(elem)) {
+ // Fix name and attach hooks
+ name = jQuery.propFix[name] || name;
+ hooks = jQuery.propHooks[name];
+ }
+
+ if (value !== undefined) {
+ if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {
+ return ret;
+ }
+
+ return elem[name] = value;
+ }
+
+ if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) {
+ return ret;
+ }
+
+ return elem[name];
+ },
+ propHooks: {
+ tabIndex: {
+ get: function get(elem) {
+ // Support: IE <=9 - 11 only
+ // elem.tabIndex doesn't always return the
+ // correct value when it hasn't been explicitly set
+ // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
+ // Use proper attribute retrieval(#12072)
+ var tabindex = jQuery.find.attr(elem, "tabindex");
+
+ if (tabindex) {
+ return parseInt(tabindex, 10);
+ }
+
+ if (rfocusable.test(elem.nodeName) || rclickable.test(elem.nodeName) && elem.href) {
+ return 0;
+ }
+
+ return -1;
+ }
+ }
+ },
+ propFix: {
+ "for": "htmlFor",
+ "class": "className"
+ }
+ }); // Support: IE <=11 only
+ // Accessing the selectedIndex property
+ // forces the browser to respect setting selected
+ // on the option
+ // The getter ensures a default option is selected
+ // when in an optgroup
+ // eslint rule "no-unused-expressions" is disabled for this code
+ // since it considers such accessions noop
+
+ if (!support.optSelected) {
+ jQuery.propHooks.selected = {
+ get: function get(elem) {
+ /* eslint no-unused-expressions: "off" */
+ var parent = elem.parentNode;
+
+ if (parent && parent.parentNode) {
+ parent.parentNode.selectedIndex;
+ }
+
+ return null;
+ },
+ set: function set(elem) {
+ /* eslint no-unused-expressions: "off" */
+ var parent = elem.parentNode;
+
+ if (parent) {
+ parent.selectedIndex;
+
+ if (parent.parentNode) {
+ parent.parentNode.selectedIndex;
+ }
+ }
+ }
+ };
+ }
+
+ jQuery.each(["tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable"], function () {
+ jQuery.propFix[this.toLowerCase()] = this;
+ }); // Strip and collapse whitespace according to HTML spec
+ // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
+
+ function stripAndCollapse(value) {
+ var tokens = value.match(rnothtmlwhite) || [];
+ return tokens.join(" ");
+ }
+
+ function getClass(elem) {
+ return elem.getAttribute && elem.getAttribute("class") || "";
+ }
+
+ function classesToArray(value) {
+ if (Array.isArray(value)) {
+ return value;
+ }
+
+ if (typeof value === "string") {
+ return value.match(rnothtmlwhite) || [];
+ }
+
+ return [];
+ }
+
+ jQuery.fn.extend({
+ addClass: function addClass(value) {
+ var classes,
+ elem,
+ cur,
+ curValue,
+ clazz,
+ j,
+ finalValue,
+ i = 0;
+
+ if (isFunction(value)) {
+ return this.each(function (j) {
+ jQuery(this).addClass(value.call(this, j, getClass(this)));
+ });
+ }
+
+ classes = classesToArray(value);
+
+ if (classes.length) {
+ while (elem = this[i++]) {
+ curValue = getClass(elem);
+ cur = elem.nodeType === 1 && " " + stripAndCollapse(curValue) + " ";
+
+ if (cur) {
+ j = 0;
+
+ while (clazz = classes[j++]) {
+ if (cur.indexOf(" " + clazz + " ") < 0) {
+ cur += clazz + " ";
+ }
+ } // Only assign if different to avoid unneeded rendering.
+
+
+ finalValue = stripAndCollapse(cur);
+
+ if (curValue !== finalValue) {
+ elem.setAttribute("class", finalValue);
+ }
+ }
+ }
+ }
+
+ return this;
+ },
+ removeClass: function removeClass(value) {
+ var classes,
+ elem,
+ cur,
+ curValue,
+ clazz,
+ j,
+ finalValue,
+ i = 0;
+
+ if (isFunction(value)) {
+ return this.each(function (j) {
+ jQuery(this).removeClass(value.call(this, j, getClass(this)));
+ });
+ }
+
+ if (!arguments.length) {
+ return this.attr("class", "");
+ }
+
+ classes = classesToArray(value);
+
+ if (classes.length) {
+ while (elem = this[i++]) {
+ curValue = getClass(elem); // This expression is here for better compressibility (see addClass)
+
+ cur = elem.nodeType === 1 && " " + stripAndCollapse(curValue) + " ";
+
+ if (cur) {
+ j = 0;
+
+ while (clazz = classes[j++]) {
+ // Remove *all* instances
+ while (cur.indexOf(" " + clazz + " ") > -1) {
+ cur = cur.replace(" " + clazz + " ", " ");
+ }
+ } // Only assign if different to avoid unneeded rendering.
+
+
+ finalValue = stripAndCollapse(cur);
+
+ if (curValue !== finalValue) {
+ elem.setAttribute("class", finalValue);
+ }
+ }
+ }
+ }
+
+ return this;
+ },
+ toggleClass: function toggleClass(value, stateVal) {
+ var type = _typeof(value),
+ isValidValue = type === "string" || Array.isArray(value);
+
+ if (typeof stateVal === "boolean" && isValidValue) {
+ return stateVal ? this.addClass(value) : this.removeClass(value);
+ }
+
+ if (isFunction(value)) {
+ return this.each(function (i) {
+ jQuery(this).toggleClass(value.call(this, i, getClass(this), stateVal), stateVal);
+ });
+ }
+
+ return this.each(function () {
+ var className, i, self, classNames;
+
+ if (isValidValue) {
+ // Toggle individual class names
+ i = 0;
+ self = jQuery(this);
+ classNames = classesToArray(value);
+
+ while (className = classNames[i++]) {
+ // Check each className given, space separated list
+ if (self.hasClass(className)) {
+ self.removeClass(className);
+ } else {
+ self.addClass(className);
+ }
+ } // Toggle whole class name
+
+ } else if (value === undefined || type === "boolean") {
+ className = getClass(this);
+
+ if (className) {
+ // Store className if set
+ dataPriv.set(this, "__className__", className);
+ } // If the element has a class name or if we're passed `false`,
+ // then remove the whole classname (if there was one, the above saved it).
+ // Otherwise bring back whatever was previously saved (if anything),
+ // falling back to the empty string if nothing was stored.
+
+
+ if (this.setAttribute) {
+ this.setAttribute("class", className || value === false ? "" : dataPriv.get(this, "__className__") || "");
+ }
+ }
+ });
+ },
+ hasClass: function hasClass(selector) {
+ var className,
+ elem,
+ i = 0;
+ className = " " + selector + " ";
+
+ while (elem = this[i++]) {
+ if (elem.nodeType === 1 && (" " + stripAndCollapse(getClass(elem)) + " ").indexOf(className) > -1) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+ });
+ var rreturn = /\r/g;
+ jQuery.fn.extend({
+ val: function val(value) {
+ var hooks,
+ ret,
+ valueIsFunction,
+ elem = this[0];
+
+ if (!arguments.length) {
+ if (elem) {
+ hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()];
+
+ if (hooks && "get" in hooks && (ret = hooks.get(elem, "value")) !== undefined) {
+ return ret;
+ }
+
+ ret = elem.value; // Handle most common string cases
+
+ if (typeof ret === "string") {
+ return ret.replace(rreturn, "");
+ } // Handle cases where value is null/undef or number
+
+
+ return ret == null ? "" : ret;
+ }
+
+ return;
+ }
+
+ valueIsFunction = isFunction(value);
+ return this.each(function (i) {
+ var val;
+
+ if (this.nodeType !== 1) {
+ return;
+ }
+
+ if (valueIsFunction) {
+ val = value.call(this, i, jQuery(this).val());
+ } else {
+ val = value;
+ } // Treat null/undefined as ""; convert numbers to string
+
+
+ if (val == null) {
+ val = "";
+ } else if (typeof val === "number") {
+ val += "";
+ } else if (Array.isArray(val)) {
+ val = jQuery.map(val, function (value) {
+ return value == null ? "" : value + "";
+ });
+ }
+
+ hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()]; // If set returns undefined, fall back to normal setting
+
+ if (!hooks || !("set" in hooks) || hooks.set(this, val, "value") === undefined) {
+ this.value = val;
+ }
+ });
+ }
+ });
+ jQuery.extend({
+ valHooks: {
+ option: {
+ get: function get(elem) {
+ var val = jQuery.find.attr(elem, "value");
+ return val != null ? val : // Support: IE <=10 - 11 only
+ // option.text throws exceptions (#14686, #14858)
+ // Strip and collapse whitespace
+ // https://html.spec.whatwg.org/#strip-and-collapse-whitespace
+ stripAndCollapse(jQuery.text(elem));
+ }
+ },
+ select: {
+ get: function get(elem) {
+ var value,
+ option,
+ i,
+ options = elem.options,
+ index = elem.selectedIndex,
+ one = elem.type === "select-one",
+ values = one ? null : [],
+ max = one ? index + 1 : options.length;
+
+ if (index < 0) {
+ i = max;
+ } else {
+ i = one ? index : 0;
+ } // Loop through all the selected options
+
+
+ for (; i < max; i++) {
+ option = options[i]; // Support: IE <=9 only
+ // IE8-9 doesn't update selected after form reset (#2551)
+
+ if ((option.selected || i === index) && // Don't return options that are disabled or in a disabled optgroup
+ !option.disabled && (!option.parentNode.disabled || !nodeName(option.parentNode, "optgroup"))) {
+ // Get the specific value for the option
+ value = jQuery(option).val(); // We don't need an array for one selects
+
+ if (one) {
+ return value;
+ } // Multi-Selects return an array
+
+
+ values.push(value);
+ }
+ }
+
+ return values;
+ },
+ set: function set(elem, value) {
+ var optionSet,
+ option,
+ options = elem.options,
+ values = jQuery.makeArray(value),
+ i = options.length;
+
+ while (i--) {
+ option = options[i];
+ /* eslint-disable no-cond-assign */
+
+ if (option.selected = jQuery.inArray(jQuery.valHooks.option.get(option), values) > -1) {
+ optionSet = true;
+ }
+ /* eslint-enable no-cond-assign */
+
+ } // Force browsers to behave consistently when non-matching value is set
+
+
+ if (!optionSet) {
+ elem.selectedIndex = -1;
+ }
+
+ return values;
+ }
+ }
+ }
+ }); // Radios and checkboxes getter/setter
+
+ jQuery.each(["radio", "checkbox"], function () {
+ jQuery.valHooks[this] = {
+ set: function set(elem, value) {
+ if (Array.isArray(value)) {
+ return elem.checked = jQuery.inArray(jQuery(elem).val(), value) > -1;
+ }
+ }
+ };
+
+ if (!support.checkOn) {
+ jQuery.valHooks[this].get = function (elem) {
+ return elem.getAttribute("value") === null ? "on" : elem.value;
+ };
+ }
+ }); // Return jQuery for attributes-only inclusion
+
+ support.focusin = "onfocusin" in window;
+
+ var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
+ stopPropagationCallback = function stopPropagationCallback(e) {
+ e.stopPropagation();
+ };
+
+ jQuery.extend(jQuery.event, {
+ trigger: function trigger(event, data, elem, onlyHandlers) {
+ var i,
+ cur,
+ tmp,
+ bubbleType,
+ ontype,
+ handle,
+ special,
+ lastElement,
+ eventPath = [elem || document],
+ type = hasOwn.call(event, "type") ? event.type : event,
+ namespaces = hasOwn.call(event, "namespace") ? event.namespace.split(".") : [];
+ cur = lastElement = tmp = elem = elem || document; // Don't do events on text and comment nodes
+
+ if (elem.nodeType === 3 || elem.nodeType === 8) {
+ return;
+ } // focus/blur morphs to focusin/out; ensure we're not firing them right now
+
+
+ if (rfocusMorph.test(type + jQuery.event.triggered)) {
+ return;
+ }
+
+ if (type.indexOf(".") > -1) {
+ // Namespaced trigger; create a regexp to match event type in handle()
+ namespaces = type.split(".");
+ type = namespaces.shift();
+ namespaces.sort();
+ }
+
+ ontype = type.indexOf(":") < 0 && "on" + type; // Caller can pass in a jQuery.Event object, Object, or just an event type string
+
+ event = event[jQuery.expando] ? event : new jQuery.Event(type, _typeof(event) === "object" && event); // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
+
+ event.isTrigger = onlyHandlers ? 2 : 3;
+ event.namespace = namespaces.join(".");
+ event.rnamespace = event.namespace ? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null; // Clean up the event in case it is being reused
+
+ event.result = undefined;
+
+ if (!event.target) {
+ event.target = elem;
+ } // Clone any incoming data and prepend the event, creating the handler arg list
+
+
+ data = data == null ? [event] : jQuery.makeArray(data, [event]); // Allow special events to draw outside the lines
+
+ special = jQuery.event.special[type] || {};
+
+ if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) {
+ return;
+ } // Determine event propagation path in advance, per W3C events spec (#9951)
+ // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
+
+
+ if (!onlyHandlers && !special.noBubble && !isWindow(elem)) {
+ bubbleType = special.delegateType || type;
+
+ if (!rfocusMorph.test(bubbleType + type)) {
+ cur = cur.parentNode;
+ }
+
+ for (; cur; cur = cur.parentNode) {
+ eventPath.push(cur);
+ tmp = cur;
+ } // Only add window if we got to document (e.g., not plain obj or detached DOM)
+
+
+ if (tmp === (elem.ownerDocument || document)) {
+ eventPath.push(tmp.defaultView || tmp.parentWindow || window);
+ }
+ } // Fire handlers on the event path
+
+
+ i = 0;
+
+ while ((cur = eventPath[i++]) && !event.isPropagationStopped()) {
+ lastElement = cur;
+ event.type = i > 1 ? bubbleType : special.bindType || type; // jQuery handler
+
+ handle = (dataPriv.get(cur, "events") || Object.create(null))[event.type] && dataPriv.get(cur, "handle");
+
+ if (handle) {
+ handle.apply(cur, data);
+ } // Native handler
+
+
+ handle = ontype && cur[ontype];
+
+ if (handle && handle.apply && acceptData(cur)) {
+ event.result = handle.apply(cur, data);
+
+ if (event.result === false) {
+ event.preventDefault();
+ }
+ }
+ }
+
+ event.type = type; // If nobody prevented the default action, do it now
+
+ if (!onlyHandlers && !event.isDefaultPrevented()) {
+ if ((!special._default || special._default.apply(eventPath.pop(), data) === false) && acceptData(elem)) {
+ // Call a native DOM method on the target with the same name as the event.
+ // Don't do default actions on window, that's where global variables be (#6170)
+ if (ontype && isFunction(elem[type]) && !isWindow(elem)) {
+ // Don't re-trigger an onFOO event when we call its FOO() method
+ tmp = elem[ontype];
+
+ if (tmp) {
+ elem[ontype] = null;
+ } // Prevent re-triggering of the same event, since we already bubbled it above
+
+
+ jQuery.event.triggered = type;
+
+ if (event.isPropagationStopped()) {
+ lastElement.addEventListener(type, stopPropagationCallback);
+ }
+
+ elem[type]();
+
+ if (event.isPropagationStopped()) {
+ lastElement.removeEventListener(type, stopPropagationCallback);
+ }
+
+ jQuery.event.triggered = undefined;
+
+ if (tmp) {
+ elem[ontype] = tmp;
+ }
+ }
+ }
+ }
+
+ return event.result;
+ },
+ // Piggyback on a donor event to simulate a different one
+ // Used only for `focus(in | out)` events
+ simulate: function simulate(type, elem, event) {
+ var e = jQuery.extend(new jQuery.Event(), event, {
+ type: type,
+ isSimulated: true
+ });
+ jQuery.event.trigger(e, null, elem);
+ }
+ });
+ jQuery.fn.extend({
+ trigger: function trigger(type, data) {
+ return this.each(function () {
+ jQuery.event.trigger(type, data, this);
+ });
+ },
+ triggerHandler: function triggerHandler(type, data) {
+ var elem = this[0];
+
+ if (elem) {
+ return jQuery.event.trigger(type, data, elem, true);
+ }
+ }
+ }); // Support: Firefox <=44
+ // Firefox doesn't have focus(in | out) events
+ // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
+ //
+ // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
+ // focus(in | out) events fire after focus & blur events,
+ // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
+ // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
+
+ if (!support.focusin) {
+ jQuery.each({
+ focus: "focusin",
+ blur: "focusout"
+ }, function (orig, fix) {
+ // Attach a single capturing handler on the document while someone wants focusin/focusout
+ var handler = function handler(event) {
+ jQuery.event.simulate(fix, event.target, jQuery.event.fix(event));
+ };
+
+ jQuery.event.special[fix] = {
+ setup: function setup() {
+ // Handle: regular nodes (via `this.ownerDocument`), window
+ // (via `this.document`) & document (via `this`).
+ var doc = this.ownerDocument || this.document || this,
+ attaches = dataPriv.access(doc, fix);
+
+ if (!attaches) {
+ doc.addEventListener(orig, handler, true);
+ }
+
+ dataPriv.access(doc, fix, (attaches || 0) + 1);
+ },
+ teardown: function teardown() {
+ var doc = this.ownerDocument || this.document || this,
+ attaches = dataPriv.access(doc, fix) - 1;
+
+ if (!attaches) {
+ doc.removeEventListener(orig, handler, true);
+ dataPriv.remove(doc, fix);
+ } else {
+ dataPriv.access(doc, fix, attaches);
+ }
+ }
+ };
+ });
+ }
+
+ var location = window.location;
+ var nonce = {
+ guid: Date.now()
+ };
+ var rquery = /\?/; // Cross-browser xml parsing
+
+ jQuery.parseXML = function (data) {
+ var xml;
+
+ if (!data || typeof data !== "string") {
+ return null;
+ } // Support: IE 9 - 11 only
+ // IE throws on parseFromString with invalid input.
+
+
+ try {
+ xml = new window.DOMParser().parseFromString(data, "text/xml");
+ } catch (e) {
+ xml = undefined;
+ }
+
+ if (!xml || xml.getElementsByTagName("parsererror").length) {
+ jQuery.error("Invalid XML: " + data);
+ }
+
+ return xml;
+ };
+
+ var rbracket = /\[\]$/,
+ rCRLF = /\r?\n/g,
+ rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
+ rsubmittable = /^(?:input|select|textarea|keygen)/i;
+
+ function buildParams(prefix, obj, traditional, add) {
+ var name;
+
+ if (Array.isArray(obj)) {
+ // Serialize array item.
+ jQuery.each(obj, function (i, v) {
+ if (traditional || rbracket.test(prefix)) {
+ // Treat each array item as a scalar.
+ add(prefix, v);
+ } else {
+ // Item is non-scalar (array or object), encode its numeric index.
+ buildParams(prefix + "[" + (_typeof(v) === "object" && v != null ? i : "") + "]", v, traditional, add);
+ }
+ });
+ } else if (!traditional && toType(obj) === "object") {
+ // Serialize object item.
+ for (name in obj) {
+ buildParams(prefix + "[" + name + "]", obj[name], traditional, add);
+ }
+ } else {
+ // Serialize scalar item.
+ add(prefix, obj);
+ }
+ } // Serialize an array of form elements or a set of
+ // key/values into a query string
+
+
+ jQuery.param = function (a, traditional) {
+ var prefix,
+ s = [],
+ add = function add(key, valueOrFunction) {
+ // If value is a function, invoke it and use its return value
+ var value = isFunction(valueOrFunction) ? valueOrFunction() : valueOrFunction;
+ s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value == null ? "" : value);
+ };
+
+ if (a == null) {
+ return "";
+ } // If an array was passed in, assume that it is an array of form elements.
+
+
+ if (Array.isArray(a) || a.jquery && !jQuery.isPlainObject(a)) {
+ // Serialize the form elements
+ jQuery.each(a, function () {
+ add(this.name, this.value);
+ });
+ } else {
+ // If traditional, encode the "old" way (the way 1.3.2 or older
+ // did it), otherwise encode params recursively.
+ for (prefix in a) {
+ buildParams(prefix, a[prefix], traditional, add);
+ }
+ } // Return the resulting serialization
+
+
+ return s.join("&");
+ };
+
+ jQuery.fn.extend({
+ serialize: function serialize() {
+ return jQuery.param(this.serializeArray());
+ },
+ serializeArray: function serializeArray() {
+ return this.map(function () {
+ // Can add propHook for "elements" to filter or add form elements
+ var elements = jQuery.prop(this, "elements");
+ return elements ? jQuery.makeArray(elements) : this;
+ }).filter(function () {
+ var type = this.type; // Use .is( ":disabled" ) so that fieldset[disabled] works
+
+ return this.name && !jQuery(this).is(":disabled") && rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) && (this.checked || !rcheckableType.test(type));
+ }).map(function (_i, elem) {
+ var val = jQuery(this).val();
+
+ if (val == null) {
+ return null;
+ }
+
+ if (Array.isArray(val)) {
+ return jQuery.map(val, function (val) {
+ return {
+ name: elem.name,
+ value: val.replace(rCRLF, "\r\n")
+ };
+ });
+ }
+
+ return {
+ name: elem.name,
+ value: val.replace(rCRLF, "\r\n")
+ };
+ }).get();
+ }
+ });
+ var r20 = /%20/g,
+ rhash = /#.*$/,
+ rantiCache = /([?&])_=[^&]*/,
+ rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
+ // #7653, #8125, #8152: local protocol detection
+ rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
+ rnoContent = /^(?:GET|HEAD)$/,
+ rprotocol = /^\/\//,
+
+ /* Prefilters
+ * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
+ * 2) These are called:
+ * - BEFORE asking for a transport
+ * - AFTER param serialization (s.data is a string if s.processData is true)
+ * 3) key is the dataType
+ * 4) the catchall symbol "*" can be used
+ * 5) execution will start with transport dataType and THEN continue down to "*" if needed
+ */
+ prefilters = {},
+
+ /* Transports bindings
+ * 1) key is the dataType
+ * 2) the catchall symbol "*" can be used
+ * 3) selection will start with transport dataType and THEN go to "*" if needed
+ */
+ transports = {},
+ // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
+ allTypes = "*/".concat("*"),
+ // Anchor tag for parsing the document origin
+ originAnchor = document.createElement("a");
+ originAnchor.href = location.href; // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
+
+ function addToPrefiltersOrTransports(structure) {
+ // dataTypeExpression is optional and defaults to "*"
+ return function (dataTypeExpression, func) {
+ if (typeof dataTypeExpression !== "string") {
+ func = dataTypeExpression;
+ dataTypeExpression = "*";
+ }
+
+ var dataType,
+ i = 0,
+ dataTypes = dataTypeExpression.toLowerCase().match(rnothtmlwhite) || [];
+
+ if (isFunction(func)) {
+ // For each dataType in the dataTypeExpression
+ while (dataType = dataTypes[i++]) {
+ // Prepend if requested
+ if (dataType[0] === "+") {
+ dataType = dataType.slice(1) || "*";
+ (structure[dataType] = structure[dataType] || []).unshift(func); // Otherwise append
+ } else {
+ (structure[dataType] = structure[dataType] || []).push(func);
+ }
+ }
+ }
+ };
+ } // Base inspection function for prefilters and transports
+
+
+ function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {
+ var inspected = {},
+ seekingTransport = structure === transports;
+
+ function inspect(dataType) {
+ var selected;
+ inspected[dataType] = true;
+ jQuery.each(structure[dataType] || [], function (_, prefilterOrFactory) {
+ var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);
+
+ if (typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[dataTypeOrTransport]) {
+ options.dataTypes.unshift(dataTypeOrTransport);
+ inspect(dataTypeOrTransport);
+ return false;
+ } else if (seekingTransport) {
+ return !(selected = dataTypeOrTransport);
+ }
+ });
+ return selected;
+ }
+
+ return inspect(options.dataTypes[0]) || !inspected["*"] && inspect("*");
+ } // A special extend for ajax options
+ // that takes "flat" options (not to be deep extended)
+ // Fixes #9887
+
+
+ function ajaxExtend(target, src) {
+ var key,
+ deep,
+ flatOptions = jQuery.ajaxSettings.flatOptions || {};
+
+ for (key in src) {
+ if (src[key] !== undefined) {
+ (flatOptions[key] ? target : deep || (deep = {}))[key] = src[key];
+ }
+ }
+
+ if (deep) {
+ jQuery.extend(true, target, deep);
+ }
+
+ return target;
+ }
+ /* Handles responses to an ajax request:
+ * - finds the right dataType (mediates between content-type and expected dataType)
+ * - returns the corresponding response
+ */
+
+
+ function ajaxHandleResponses(s, jqXHR, responses) {
+ var ct,
+ type,
+ finalDataType,
+ firstDataType,
+ contents = s.contents,
+ dataTypes = s.dataTypes; // Remove auto dataType and get content-type in the process
+
+ while (dataTypes[0] === "*") {
+ dataTypes.shift();
+
+ if (ct === undefined) {
+ ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
+ }
+ } // Check if we're dealing with a known content-type
+
+
+ if (ct) {
+ for (type in contents) {
+ if (contents[type] && contents[type].test(ct)) {
+ dataTypes.unshift(type);
+ break;
+ }
+ }
+ } // Check to see if we have a response for the expected dataType
+
+
+ if (dataTypes[0] in responses) {
+ finalDataType = dataTypes[0];
+ } else {
+ // Try convertible dataTypes
+ for (type in responses) {
+ if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) {
+ finalDataType = type;
+ break;
+ }
+
+ if (!firstDataType) {
+ firstDataType = type;
+ }
+ } // Or just use first one
+
+
+ finalDataType = finalDataType || firstDataType;
+ } // If we found a dataType
+ // We add the dataType to the list if needed
+ // and return the corresponding response
+
+
+ if (finalDataType) {
+ if (finalDataType !== dataTypes[0]) {
+ dataTypes.unshift(finalDataType);
+ }
+
+ return responses[finalDataType];
+ }
+ }
+ /* Chain conversions given the request and the original response
+ * Also sets the responseXXX fields on the jqXHR instance
+ */
+
+
+ function ajaxConvert(s, response, jqXHR, isSuccess) {
+ var conv2,
+ current,
+ conv,
+ tmp,
+ prev,
+ converters = {},
+ // Work with a copy of dataTypes in case we need to modify it for conversion
+ dataTypes = s.dataTypes.slice(); // Create converters map with lowercased keys
+
+ if (dataTypes[1]) {
+ for (conv in s.converters) {
+ converters[conv.toLowerCase()] = s.converters[conv];
+ }
+ }
+
+ current = dataTypes.shift(); // Convert to each sequential dataType
+
+ while (current) {
+ if (s.responseFields[current]) {
+ jqXHR[s.responseFields[current]] = response;
+ } // Apply the dataFilter if provided
+
+
+ if (!prev && isSuccess && s.dataFilter) {
+ response = s.dataFilter(response, s.dataType);
+ }
+
+ prev = current;
+ current = dataTypes.shift();
+
+ if (current) {
+ // There's only work to do if current dataType is non-auto
+ if (current === "*") {
+ current = prev; // Convert response if prev dataType is non-auto and differs from current
+ } else if (prev !== "*" && prev !== current) {
+ // Seek a direct converter
+ conv = converters[prev + " " + current] || converters["* " + current]; // If none found, seek a pair
+
+ if (!conv) {
+ for (conv2 in converters) {
+ // If conv2 outputs current
+ tmp = conv2.split(" ");
+
+ if (tmp[1] === current) {
+ // If prev can be converted to accepted input
+ conv = converters[prev + " " + tmp[0]] || converters["* " + tmp[0]];
+
+ if (conv) {
+ // Condense equivalence converters
+ if (conv === true) {
+ conv = converters[conv2]; // Otherwise, insert the intermediate dataType
+ } else if (converters[conv2] !== true) {
+ current = tmp[0];
+ dataTypes.unshift(tmp[1]);
+ }
+
+ break;
+ }
+ }
+ }
+ } // Apply converter (if not an equivalence)
+
+
+ if (conv !== true) {
+ // Unless errors are allowed to bubble, catch and return them
+ if (conv && s.throws) {
+ response = conv(response);
+ } else {
+ try {
+ response = conv(response);
+ } catch (e) {
+ return {
+ state: "parsererror",
+ error: conv ? e : "No conversion from " + prev + " to " + current
+ };
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return {
+ state: "success",
+ data: response
+ };
+ }
+
+ jQuery.extend({
+ // Counter for holding the number of active queries
+ active: 0,
+ // Last-Modified header cache for next request
+ lastModified: {},
+ etag: {},
+ ajaxSettings: {
+ url: location.href,
+ type: "GET",
+ isLocal: rlocalProtocol.test(location.protocol),
+ global: true,
+ processData: true,
+ async: true,
+ contentType: "application/x-www-form-urlencoded; charset=UTF-8",
+
+ /*
+ timeout: 0,
+ data: null,
+ dataType: null,
+ username: null,
+ password: null,
+ cache: null,
+ throws: false,
+ traditional: false,
+ headers: {},
+ */
+ accepts: {
+ "*": allTypes,
+ text: "text/plain",
+ html: "text/html",
+ xml: "application/xml, text/xml",
+ json: "application/json, text/javascript"
+ },
+ contents: {
+ xml: /\bxml\b/,
+ html: /\bhtml/,
+ json: /\bjson\b/
+ },
+ responseFields: {
+ xml: "responseXML",
+ text: "responseText",
+ json: "responseJSON"
+ },
+ // Data converters
+ // Keys separate source (or catchall "*") and destination types with a single space
+ converters: {
+ // Convert anything to text
+ "* text": String,
+ // Text to html (true = no transformation)
+ "text html": true,
+ // Evaluate text as a json expression
+ "text json": JSON.parse,
+ // Parse text as xml
+ "text xml": jQuery.parseXML
+ },
+ // For options that shouldn't be deep extended:
+ // you can add your own custom options here if
+ // and when you create one that shouldn't be
+ // deep extended (see ajaxExtend)
+ flatOptions: {
+ url: true,
+ context: true
+ }
+ },
+ // Creates a full fledged settings object into target
+ // with both ajaxSettings and settings fields.
+ // If target is omitted, writes into ajaxSettings.
+ ajaxSetup: function ajaxSetup(target, settings) {
+ return settings ? // Building a settings object
+ ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) : // Extending ajaxSettings
+ ajaxExtend(jQuery.ajaxSettings, target);
+ },
+ ajaxPrefilter: addToPrefiltersOrTransports(prefilters),
+ ajaxTransport: addToPrefiltersOrTransports(transports),
+ // Main method
+ ajax: function ajax(url, options) {
+ // If url is an object, simulate pre-1.5 signature
+ if (_typeof(url) === "object") {
+ options = url;
+ url = undefined;
+ } // Force options to be an object
+
+
+ options = options || {};
+
+ var transport,
+ // URL without anti-cache param
+ cacheURL,
+ // Response headers
+ responseHeadersString,
+ responseHeaders,
+ // timeout handle
+ timeoutTimer,
+ // Url cleanup var
+ urlAnchor,
+ // Request state (becomes false upon send and true upon completion)
+ completed,
+ // To know if global events are to be dispatched
+ fireGlobals,
+ // Loop variable
+ i,
+ // uncached part of the url
+ uncached,
+ // Create the final options object
+ s = jQuery.ajaxSetup({}, options),
+ // Callbacks context
+ callbackContext = s.context || s,
+ // Context for global events is callbackContext if it is a DOM node or jQuery collection
+ globalEventContext = s.context && (callbackContext.nodeType || callbackContext.jquery) ? jQuery(callbackContext) : jQuery.event,
+ // Deferreds
+ deferred = jQuery.Deferred(),
+ completeDeferred = jQuery.Callbacks("once memory"),
+ // Status-dependent callbacks
+ _statusCode = s.statusCode || {},
+ // Headers (they are sent all at once)
+ requestHeaders = {},
+ requestHeadersNames = {},
+ // Default abort message
+ strAbort = "canceled",
+ // Fake xhr
+ jqXHR = {
+ readyState: 0,
+ // Builds headers hashtable if needed
+ getResponseHeader: function getResponseHeader(key) {
+ var match;
+
+ if (completed) {
+ if (!responseHeaders) {
+ responseHeaders = {};
+
+ while (match = rheaders.exec(responseHeadersString)) {
+ responseHeaders[match[1].toLowerCase() + " "] = (responseHeaders[match[1].toLowerCase() + " "] || []).concat(match[2]);
+ }
+ }
+
+ match = responseHeaders[key.toLowerCase() + " "];
+ }
+
+ return match == null ? null : match.join(", ");
+ },
+ // Raw string
+ getAllResponseHeaders: function getAllResponseHeaders() {
+ return completed ? responseHeadersString : null;
+ },
+ // Caches the header
+ setRequestHeader: function setRequestHeader(name, value) {
+ if (completed == null) {
+ name = requestHeadersNames[name.toLowerCase()] = requestHeadersNames[name.toLowerCase()] || name;
+ requestHeaders[name] = value;
+ }
+
+ return this;
+ },
+ // Overrides response content-type header
+ overrideMimeType: function overrideMimeType(type) {
+ if (completed == null) {
+ s.mimeType = type;
+ }
+
+ return this;
+ },
+ // Status-dependent callbacks
+ statusCode: function statusCode(map) {
+ var code;
+
+ if (map) {
+ if (completed) {
+ // Execute the appropriate callbacks
+ jqXHR.always(map[jqXHR.status]);
+ } else {
+ // Lazy-add the new callbacks in a way that preserves old ones
+ for (code in map) {
+ _statusCode[code] = [_statusCode[code], map[code]];
+ }
+ }
+ }
+
+ return this;
+ },
+ // Cancel the request
+ abort: function abort(statusText) {
+ var finalText = statusText || strAbort;
+
+ if (transport) {
+ transport.abort(finalText);
+ }
+
+ done(0, finalText);
+ return this;
+ }
+ }; // Attach deferreds
+
+
+ deferred.promise(jqXHR); // Add protocol if not provided (prefilters might expect it)
+ // Handle falsy url in the settings object (#10093: consistency with old signature)
+ // We also use the url parameter if available
+
+ s.url = ((url || s.url || location.href) + "").replace(rprotocol, location.protocol + "//"); // Alias method option to type as per ticket #12004
+
+ s.type = options.method || options.type || s.method || s.type; // Extract dataTypes list
+
+ s.dataTypes = (s.dataType || "*").toLowerCase().match(rnothtmlwhite) || [""]; // A cross-domain request is in order when the origin doesn't match the current origin.
+
+ if (s.crossDomain == null) {
+ urlAnchor = document.createElement("a"); // Support: IE <=8 - 11, Edge 12 - 15
+ // IE throws exception on accessing the href property if url is malformed,
+ // e.g. http://example.com:80x/
+
+ try {
+ urlAnchor.href = s.url; // Support: IE <=8 - 11 only
+ // Anchor's host property isn't correctly set when s.url is relative
+
+ urlAnchor.href = urlAnchor.href;
+ s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== urlAnchor.protocol + "//" + urlAnchor.host;
+ } catch (e) {
+ // If there is an error parsing the URL, assume it is crossDomain,
+ // it can be rejected by the transport if it is invalid
+ s.crossDomain = true;
+ }
+ } // Convert data if not already a string
+
+
+ if (s.data && s.processData && typeof s.data !== "string") {
+ s.data = jQuery.param(s.data, s.traditional);
+ } // Apply prefilters
+
+
+ inspectPrefiltersOrTransports(prefilters, s, options, jqXHR); // If request was aborted inside a prefilter, stop there
+
+ if (completed) {
+ return jqXHR;
+ } // We can fire global events as of now if asked to
+ // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
+
+
+ fireGlobals = jQuery.event && s.global; // Watch for a new set of requests
+
+ if (fireGlobals && jQuery.active++ === 0) {
+ jQuery.event.trigger("ajaxStart");
+ } // Uppercase the type
+
+
+ s.type = s.type.toUpperCase(); // Determine if request has content
+
+ s.hasContent = !rnoContent.test(s.type); // Save the URL in case we're toying with the If-Modified-Since
+ // and/or If-None-Match header later on
+ // Remove hash to simplify url manipulation
+
+ cacheURL = s.url.replace(rhash, ""); // More options handling for requests with no content
+
+ if (!s.hasContent) {
+ // Remember the hash so we can put it back
+ uncached = s.url.slice(cacheURL.length); // If data is available and should be processed, append data to url
+
+ if (s.data && (s.processData || typeof s.data === "string")) {
+ cacheURL += (rquery.test(cacheURL) ? "&" : "?") + s.data; // #9682: remove data so that it's not used in an eventual retry
+
+ delete s.data;
+ } // Add or update anti-cache param if needed
+
+
+ if (s.cache === false) {
+ cacheURL = cacheURL.replace(rantiCache, "$1");
+ uncached = (rquery.test(cacheURL) ? "&" : "?") + "_=" + nonce.guid++ + uncached;
+ } // Put hash and anti-cache on the URL that will be requested (gh-1732)
+
+
+ s.url = cacheURL + uncached; // Change '%20' to '+' if this is encoded form body content (gh-2658)
+ } else if (s.data && s.processData && (s.contentType || "").indexOf("application/x-www-form-urlencoded") === 0) {
+ s.data = s.data.replace(r20, "+");
+ } // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+
+
+ if (s.ifModified) {
+ if (jQuery.lastModified[cacheURL]) {
+ jqXHR.setRequestHeader("If-Modified-Since", jQuery.lastModified[cacheURL]);
+ }
+
+ if (jQuery.etag[cacheURL]) {
+ jqXHR.setRequestHeader("If-None-Match", jQuery.etag[cacheURL]);
+ }
+ } // Set the correct header, if data is being sent
+
+
+ if (s.data && s.hasContent && s.contentType !== false || options.contentType) {
+ jqXHR.setRequestHeader("Content-Type", s.contentType);
+ } // Set the Accepts header for the server, depending on the dataType
+
+
+ jqXHR.setRequestHeader("Accept", s.dataTypes[0] && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] + (s.dataTypes[0] !== "*" ? ", " + allTypes + "; q=0.01" : "") : s.accepts["*"]); // Check for headers option
+
+ for (i in s.headers) {
+ jqXHR.setRequestHeader(i, s.headers[i]);
+ } // Allow custom headers/mimetypes and early abort
+
+
+ if (s.beforeSend && (s.beforeSend.call(callbackContext, jqXHR, s) === false || completed)) {
+ // Abort if not done already and return
+ return jqXHR.abort();
+ } // Aborting is no longer a cancellation
+
+
+ strAbort = "abort"; // Install callbacks on deferreds
+
+ completeDeferred.add(s.complete);
+ jqXHR.done(s.success);
+ jqXHR.fail(s.error); // Get transport
+
+ transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR); // If no transport, we auto-abort
+
+ if (!transport) {
+ done(-1, "No Transport");
+ } else {
+ jqXHR.readyState = 1; // Send global event
+
+ if (fireGlobals) {
+ globalEventContext.trigger("ajaxSend", [jqXHR, s]);
+ } // If request was aborted inside ajaxSend, stop there
+
+
+ if (completed) {
+ return jqXHR;
+ } // Timeout
+
+
+ if (s.async && s.timeout > 0) {
+ timeoutTimer = window.setTimeout(function () {
+ jqXHR.abort("timeout");
+ }, s.timeout);
+ }
+
+ try {
+ completed = false;
+ transport.send(requestHeaders, done);
+ } catch (e) {
+ // Rethrow post-completion exceptions
+ if (completed) {
+ throw e;
+ } // Propagate others as results
+
+
+ done(-1, e);
+ }
+ } // Callback for when everything is done
+
+
+ function done(status, nativeStatusText, responses, headers) {
+ var isSuccess,
+ success,
+ error,
+ response,
+ modified,
+ statusText = nativeStatusText; // Ignore repeat invocations
+
+ if (completed) {
+ return;
+ }
+
+ completed = true; // Clear timeout if it exists
+
+ if (timeoutTimer) {
+ window.clearTimeout(timeoutTimer);
+ } // Dereference transport for early garbage collection
+ // (no matter how long the jqXHR object will be used)
+
+
+ transport = undefined; // Cache response headers
+
+ responseHeadersString = headers || ""; // Set readyState
+
+ jqXHR.readyState = status > 0 ? 4 : 0; // Determine if successful
+
+ isSuccess = status >= 200 && status < 300 || status === 304; // Get response data
+
+ if (responses) {
+ response = ajaxHandleResponses(s, jqXHR, responses);
+ } // Use a noop converter for missing script
+
+
+ if (!isSuccess && jQuery.inArray("script", s.dataTypes) > -1) {
+ s.converters["text script"] = function () {};
+ } // Convert no matter what (that way responseXXX fields are always set)
+
+
+ response = ajaxConvert(s, response, jqXHR, isSuccess); // If successful, handle type chaining
+
+ if (isSuccess) {
+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+ if (s.ifModified) {
+ modified = jqXHR.getResponseHeader("Last-Modified");
+
+ if (modified) {
+ jQuery.lastModified[cacheURL] = modified;
+ }
+
+ modified = jqXHR.getResponseHeader("etag");
+
+ if (modified) {
+ jQuery.etag[cacheURL] = modified;
+ }
+ } // if no content
+
+
+ if (status === 204 || s.type === "HEAD") {
+ statusText = "nocontent"; // if not modified
+ } else if (status === 304) {
+ statusText = "notmodified"; // If we have data, let's convert it
+ } else {
+ statusText = response.state;
+ success = response.data;
+ error = response.error;
+ isSuccess = !error;
+ }
+ } else {
+ // Extract error from statusText and normalize for non-aborts
+ error = statusText;
+
+ if (status || !statusText) {
+ statusText = "error";
+
+ if (status < 0) {
+ status = 0;
+ }
+ }
+ } // Set data for the fake xhr object
+
+
+ jqXHR.status = status;
+ jqXHR.statusText = (nativeStatusText || statusText) + ""; // Success/Error
+
+ if (isSuccess) {
+ deferred.resolveWith(callbackContext, [success, statusText, jqXHR]);
+ } else {
+ deferred.rejectWith(callbackContext, [jqXHR, statusText, error]);
+ } // Status-dependent callbacks
+
+
+ jqXHR.statusCode(_statusCode);
+ _statusCode = undefined;
+
+ if (fireGlobals) {
+ globalEventContext.trigger(isSuccess ? "ajaxSuccess" : "ajaxError", [jqXHR, s, isSuccess ? success : error]);
+ } // Complete
+
+
+ completeDeferred.fireWith(callbackContext, [jqXHR, statusText]);
+
+ if (fireGlobals) {
+ globalEventContext.trigger("ajaxComplete", [jqXHR, s]); // Handle the global AJAX counter
+
+ if (! --jQuery.active) {
+ jQuery.event.trigger("ajaxStop");
+ }
+ }
+ }
+
+ return jqXHR;
+ },
+ getJSON: function getJSON(url, data, callback) {
+ return jQuery.get(url, data, callback, "json");
+ },
+ getScript: function getScript(url, callback) {
+ return jQuery.get(url, undefined, callback, "script");
+ }
+ });
+ jQuery.each(["get", "post"], function (_i, method) {
+ jQuery[method] = function (url, data, callback, type) {
+ // Shift arguments if data argument was omitted
+ if (isFunction(data)) {
+ type = type || callback;
+ callback = data;
+ data = undefined;
+ } // The url can be an options object (which then must have .url)
+
+
+ return jQuery.ajax(jQuery.extend({
+ url: url,
+ type: method,
+ dataType: type,
+ data: data,
+ success: callback
+ }, jQuery.isPlainObject(url) && url));
+ };
+ });
+ jQuery.ajaxPrefilter(function (s) {
+ var i;
+
+ for (i in s.headers) {
+ if (i.toLowerCase() === "content-type") {
+ s.contentType = s.headers[i] || "";
+ }
+ }
+ });
+
+ jQuery._evalUrl = function (url, options, doc) {
+ return jQuery.ajax({
+ url: url,
+ // Make this explicit, since user can override this through ajaxSetup (#11264)
+ type: "GET",
+ dataType: "script",
+ cache: true,
+ async: false,
+ global: false,
+ // Only evaluate the response if it is successful (gh-4126)
+ // dataFilter is not invoked for failure responses, so using it instead
+ // of the default converter is kludgy but it works.
+ converters: {
+ "text script": function textScript() {}
+ },
+ dataFilter: function dataFilter(response) {
+ jQuery.globalEval(response, options, doc);
+ }
+ });
+ };
+
+ jQuery.fn.extend({
+ wrapAll: function wrapAll(html) {
+ var wrap;
+
+ if (this[0]) {
+ if (isFunction(html)) {
+ html = html.call(this[0]);
+ } // The elements to wrap the target around
+
+
+ wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true);
+
+ if (this[0].parentNode) {
+ wrap.insertBefore(this[0]);
+ }
+
+ wrap.map(function () {
+ var elem = this;
+
+ while (elem.firstElementChild) {
+ elem = elem.firstElementChild;
+ }
+
+ return elem;
+ }).append(this);
+ }
+
+ return this;
+ },
+ wrapInner: function wrapInner(html) {
+ if (isFunction(html)) {
+ return this.each(function (i) {
+ jQuery(this).wrapInner(html.call(this, i));
+ });
+ }
+
+ return this.each(function () {
+ var self = jQuery(this),
+ contents = self.contents();
+
+ if (contents.length) {
+ contents.wrapAll(html);
+ } else {
+ self.append(html);
+ }
+ });
+ },
+ wrap: function wrap(html) {
+ var htmlIsFunction = isFunction(html);
+ return this.each(function (i) {
+ jQuery(this).wrapAll(htmlIsFunction ? html.call(this, i) : html);
+ });
+ },
+ unwrap: function unwrap(selector) {
+ this.parent(selector).not("body").each(function () {
+ jQuery(this).replaceWith(this.childNodes);
+ });
+ return this;
+ }
+ });
+
+ jQuery.expr.pseudos.hidden = function (elem) {
+ return !jQuery.expr.pseudos.visible(elem);
+ };
+
+ jQuery.expr.pseudos.visible = function (elem) {
+ return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);
+ };
+
+ jQuery.ajaxSettings.xhr = function () {
+ try {
+ return new window.XMLHttpRequest();
+ } catch (e) {}
+ };
+
+ var xhrSuccessStatus = {
+ // File protocol always yields status code 0, assume 200
+ 0: 200,
+ // Support: IE <=9 only
+ // #1450: sometimes IE returns 1223 when it should be 204
+ 1223: 204
+ },
+ xhrSupported = jQuery.ajaxSettings.xhr();
+ support.cors = !!xhrSupported && "withCredentials" in xhrSupported;
+ support.ajax = xhrSupported = !!xhrSupported;
+ jQuery.ajaxTransport(function (options) {
+ var _callback, errorCallback; // Cross domain only allowed if supported through XMLHttpRequest
+
+
+ if (support.cors || xhrSupported && !options.crossDomain) {
+ return {
+ send: function send(headers, complete) {
+ var i,
+ xhr = options.xhr();
+ xhr.open(options.type, options.url, options.async, options.username, options.password); // Apply custom fields if provided
+
+ if (options.xhrFields) {
+ for (i in options.xhrFields) {
+ xhr[i] = options.xhrFields[i];
+ }
+ } // Override mime type if needed
+
+
+ if (options.mimeType && xhr.overrideMimeType) {
+ xhr.overrideMimeType(options.mimeType);
+ } // X-Requested-With header
+ // For cross-domain requests, seeing as conditions for a preflight are
+ // akin to a jigsaw puzzle, we simply never set it to be sure.
+ // (it can always be set on a per-request basis or even using ajaxSetup)
+ // For same-domain requests, won't change header if already provided.
+
+
+ if (!options.crossDomain && !headers["X-Requested-With"]) {
+ headers["X-Requested-With"] = "XMLHttpRequest";
+ } // Set headers
+
+
+ for (i in headers) {
+ xhr.setRequestHeader(i, headers[i]);
+ } // Callback
+
+
+ _callback = function callback(type) {
+ return function () {
+ if (_callback) {
+ _callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.ontimeout = xhr.onreadystatechange = null;
+
+ if (type === "abort") {
+ xhr.abort();
+ } else if (type === "error") {
+ // Support: IE <=9 only
+ // On a manual native abort, IE9 throws
+ // errors on any property access that is not readyState
+ if (typeof xhr.status !== "number") {
+ complete(0, "error");
+ } else {
+ complete( // File: protocol always yields status 0; see #8605, #14207
+ xhr.status, xhr.statusText);
+ }
+ } else {
+ complete(xhrSuccessStatus[xhr.status] || xhr.status, xhr.statusText, // Support: IE <=9 only
+ // IE9 has no XHR2 but throws on binary (trac-11426)
+ // For XHR2 non-text, let the caller handle it (gh-2498)
+ (xhr.responseType || "text") !== "text" || typeof xhr.responseText !== "string" ? {
+ binary: xhr.response
+ } : {
+ text: xhr.responseText
+ }, xhr.getAllResponseHeaders());
+ }
+ }
+ };
+ }; // Listen to events
+
+
+ xhr.onload = _callback();
+ errorCallback = xhr.onerror = xhr.ontimeout = _callback("error"); // Support: IE 9 only
+ // Use onreadystatechange to replace onabort
+ // to handle uncaught aborts
+
+ if (xhr.onabort !== undefined) {
+ xhr.onabort = errorCallback;
+ } else {
+ xhr.onreadystatechange = function () {
+ // Check readyState before timeout as it changes
+ if (xhr.readyState === 4) {
+ // Allow onerror to be called first,
+ // but that will not handle a native abort
+ // Also, save errorCallback to a variable
+ // as xhr.onerror cannot be accessed
+ window.setTimeout(function () {
+ if (_callback) {
+ errorCallback();
+ }
+ });
+ }
+ };
+ } // Create the abort callback
+
+
+ _callback = _callback("abort");
+
+ try {
+ // Do send the request (this may raise an exception)
+ xhr.send(options.hasContent && options.data || null);
+ } catch (e) {
+ // #14683: Only rethrow if this hasn't been notified as an error yet
+ if (_callback) {
+ throw e;
+ }
+ }
+ },
+ abort: function abort() {
+ if (_callback) {
+ _callback();
+ }
+ }
+ };
+ }
+ }); // Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
+
+ jQuery.ajaxPrefilter(function (s) {
+ if (s.crossDomain) {
+ s.contents.script = false;
+ }
+ }); // Install script dataType
+
+ jQuery.ajaxSetup({
+ accepts: {
+ script: "text/javascript, application/javascript, " + "application/ecmascript, application/x-ecmascript"
+ },
+ contents: {
+ script: /\b(?:java|ecma)script\b/
+ },
+ converters: {
+ "text script": function textScript(text) {
+ jQuery.globalEval(text);
+ return text;
+ }
+ }
+ }); // Handle cache's special case and crossDomain
+
+ jQuery.ajaxPrefilter("script", function (s) {
+ if (s.cache === undefined) {
+ s.cache = false;
+ }
+
+ if (s.crossDomain) {
+ s.type = "GET";
+ }
+ }); // Bind script tag hack transport
+
+ jQuery.ajaxTransport("script", function (s) {
+ // This transport only deals with cross domain or forced-by-attrs requests
+ if (s.crossDomain || s.scriptAttrs) {
+ var script, _callback2;
+
+ return {
+ send: function send(_, complete) {
+ script = jQuery("
+
+ {% block head %}
+ {% endblock %}
+
+
+
+
+
+
+{% block content %}
+{% endblock %}
+
+
+
+ {% block scr %}
+ {% endblock %}
+
+