/*!

 * Copyright OpenJS Foundation and other contributors

 */

( function( factory ) {

	"use strict";

	if ( typeof define === "function" && define.amd ) {

		// AMD. Register as an anonymous module.

		define( [ "jquery" ], function( jQuery ) {

			return factory( jQuery, window );

		} );

	} else if ( typeof module === "object" && module.exports ) {

		// Node/CommonJS

		// eslint-disable-next-line no-undef

		module.exports = factory( require( "jquery" ), window );

	} else {

		// Browser globals

		factory( jQuery, window );

	}

} )( function( jQuery, window ) {

"use strict";

// Returns 0 if v1 == v2, -1 if v1 < v2, 1 if v1 > v2

function compareVersions( v1, v2 ) {

	var i,

		rVersionParts = /^(\d+)\.(\d+)\.(\d+)/,

		v1p = rVersionParts.exec( v1 ) || [ ],

		v2p = rVersionParts.exec( v2 ) || [ ];

	for ( i = 1; i <= 3; i++ ) {

		if ( +v1p[ i ] > +v2p[ i ] ) {

			return 1;

		}

		if ( +v1p[ i ] < +v2p[ i ] ) {

			return -1;

		}

	}

	return 0;

}

function jQueryVersionSince( version ) {

	return compareVersions( jQuery.fn.jquery, version ) >= 0;

}

( function() {

	// Support: IE9 only

	// IE9 only creates console object when dev tools are first opened

	// IE9 console is a host object, callable but doesn't have .apply()

	if ( !window.console || !window.console.log ) {

		return;

	}

	}

	if ( jQuery.migrateWarnings ) {

		window.console.log( "JQMIGRATE: Migrate plugin loaded multiple times" );

	}

	// Show a message on the console so devs know we're active

	window.console.log( "JQMIGRATE: Migrate is installed" +

		( jQuery.migrateMute ? "" : " with logging active" ) +

		", version " + jQuery.migrateVersion );

} )();

var warnedAbout = {};

// By default each warning is only reported once.

jQuery.migrateDeduplicateWarnings = true;

// List of warnings already given; public read only

jQuery.migrateWarnings = [];

// Set to false to disable traces that appear with warnings

if ( jQuery.migrateTrace === undefined ) {

	jQuery.migrateTrace = true;

}

// Forget any warnings we've already given; public

jQuery.migrateReset = function() {

	warnedAbout = {};

	jQuery.migrateWarnings.length = 0;

};

	var console = window.console;

		warnedAbout[ msg ] = true;

		if ( console && console.warn && !jQuery.migrateMute ) {

			console.warn( "JQMIGRATE: " + msg );

			if ( jQuery.migrateTrace && console.trace ) {

				console.trace();

			}

		}

	}

}

	Object.defineProperty( obj, prop, {

		configurable: true,

		enumerable: true,

		get: function() {

			return value;

		},

		set: function( newValue ) {

			value = newValue;

		}

	} );

}

	obj[ prop ] = function() {

	};

}

if ( window.document.compatMode === "BackCompat" ) {

}

var findProp,

	class2type = {},

	oldInit = jQuery.fn.init,

	oldFind = jQuery.find,

	rattrHashTest = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/,

	rattrHashGlob = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/g,

	var args = Array.prototype.slice.call( arguments );

		args[ 0 ] = [];

	}

	return oldInit.apply( this, args );

jQuery.fn.init.prototype = jQuery.fn;

	var args = Array.prototype.slice.call( arguments );

	// Support: PhantomJS 1.x

	// String#match fails to match when used with a //g RegExp, only on some strings

	if ( typeof selector === "string" && rattrHashTest.test( selector ) ) {

		// The nonstandard and undocumented unquoted-hash was removed in jQuery 1.12.0

		// First see if qS thinks it's a valid selector, if so avoid a false positive

		try {

			window.document.querySelector( selector );

		} catch ( err1 ) {

			// Didn't *look* valid to qSA, warn and try quoting what we think is the value

			selector = selector.replace( rattrHashGlob, function( _, attr, op, value ) {

				return "[" + attr + op + "\"" + value + "\"]";

			} );

			// If the regexp *may* have created an invalid selector, don't update it

			// Note that there may be false alarms if selector uses jQuery extensions

			try {

				window.document.querySelector( selector );

				args[ 0 ] = selector;

			} catch ( err2 ) {

			}

		}

	}

	return oldFind.apply( this, args );

// Copy properties attached to original jQuery.find method (e.g. .attr, .isXML)

for ( findProp in oldFind ) {

	if ( Object.prototype.hasOwnProperty.call( oldFind, findProp ) ) {

		jQuery.find[ findProp ] = oldFind[ findProp ];

	}

}

// The number of elements contained in the matched element set

	return this.length;

"jQuery.fn.size() is deprecated and removed; use the .length property" );

	return JSON.parse.apply( null, arguments );

"jQuery.parseJSON is deprecated; use JSON.parse" );

// Now jQuery.expr.pseudos is the standard incantation

	"jQuery.expr.filters is deprecated; use jQuery.expr.pseudos" );

	"jQuery.expr[':'] is deprecated; use jQuery.expr.pseudos" );

// Prior to jQuery 3.1.1 there were internal refs so we don't warn there

if ( jQueryVersionSince( "3.1.1" ) ) {

		return text == null ?

			"" :

	"jQuery.trim is deprecated; use String.prototype.trim" );

}

// Prior to jQuery 3.2 there were internal refs so we don't warn there

if ( jQueryVersionSince( "3.2.0" ) ) {

		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();

	"jQuery.nodeName is deprecated" );

		"jQuery.isArray is deprecated; use Array.isArray"

	);

}

if ( jQueryVersionSince( "3.3.0" ) ) {

			// As of jQuery 3.0, isNumeric is limited to

			// strings and numbers (primitives or objects)

			// that can be coerced to finite numbers (gh-2662)

			var type = typeof obj;

			return ( type === "number" || type === "string" ) &&

				// parseFloat NaNs numeric-cast false positives ("")

				// ...but misinterprets leading-number strings, e.g. hex literals ("0x...")

				// subtraction forces infinities to NaN

				!isNaN( obj - parseFloat( obj ) );

		"jQuery.isNumeric() is deprecated"

	);

	// Populate the class2type map

	jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".

		split( " " ),

	function( _, name ) {

		class2type[ "[object " + name + "]" ] = name.toLowerCase();

	} );