| /*! |
| * jQuery Migrate - v3.0.1 - 2017-09-26 |
| * Copyright jQuery Foundation and other contributors |
| */ |
| ;( function( factory ) { |
| if ( typeof define === "function" && define.amd ) { |
| |
| // AMD. Register as an anonymous module. |
| define( [ "jquery" ], window, factory ); |
| } 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"; |
| |
| |
| jQuery.migrateVersion = "3.0.1"; |
| |
| jQuery.migrateMute = true; |
| |
| /* exported migrateWarn, migrateWarnFunc, migrateWarnProp */ |
| |
| ( function() { |
| |
| var rbadVersions = /^[12]\./; |
| |
| // 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; |
| } |
| |
| // Need jQuery 3.0.0+ and no older Migrate loaded |
| if ( !jQuery || rbadVersions.test( jQuery.fn.jquery ) ) { |
| window.console.log( "JQMIGRATE: jQuery 3.0.0+ REQUIRED" ); |
| } |
| 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 = {}; |
| |
| // 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; |
| }; |
| |
| function migrateWarn( msg ) { |
| var console = window.console; |
| if ( !warnedAbout[ msg ] ) { |
| warnedAbout[ msg ] = true; |
| jQuery.migrateWarnings.push( msg ); |
| if ( console && console.warn && !jQuery.migrateMute ) { |
| console.warn( "JQMIGRATE: " + msg ); |
| if ( jQuery.migrateTrace && console.trace ) { |
| console.trace(); |
| } |
| } |
| } |
| } |
| |
| function migrateWarnProp( obj, prop, value, msg ) { |
| Object.defineProperty( obj, prop, { |
| configurable: true, |
| enumerable: true, |
| get: function() { |
| migrateWarn( msg ); |
| return value; |
| }, |
| set: function( newValue ) { |
| migrateWarn( msg ); |
| value = newValue; |
| } |
| } ); |
| } |
| |
| function migrateWarnFunc( obj, prop, newFunc, msg ) { |
| obj[ prop ] = function() { |
| migrateWarn( msg ); |
| return newFunc.apply( this, arguments ); |
| }; |
| } |
| |
| if ( window.document.compatMode === "BackCompat" ) { |
| |
| // JQuery has never supported or tested Quirks Mode |
| migrateWarn( "jQuery is not compatible with Quirks Mode" ); |
| } |
| |
| |
| var oldInit = jQuery.fn.init, |
| oldIsNumeric = jQuery.isNumeric, |
| oldFind = jQuery.find, |
| rattrHashTest = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/, |
| rattrHashGlob = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/g; |
| |
| jQuery.fn.init = function( arg1 ) { |
| var args = Array.prototype.slice.call( arguments ); |
| |
| if ( typeof arg1 === "string" && arg1 === "#" ) { |
| |
| // JQuery( "#" ) is a bogus ID selector, but it returned an empty set before jQuery 3.0 |
| migrateWarn( "jQuery( '#' ) is not a valid selector" ); |
| args[ 0 ] = []; |
| } |
| |
| return oldInit.apply( this, args ); |
| }; |
| jQuery.fn.init.prototype = jQuery.fn; |
| |
| jQuery.find = function( selector ) { |
| 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 ); |
| migrateWarn( "Attribute selector with '#' must be quoted: " + args[ 0 ] ); |
| args[ 0 ] = selector; |
| } catch ( err2 ) { |
| migrateWarn( "Attribute selector with '#' was not fixed: " + args[ 0 ] ); |
| } |
| } |
| } |
| |
| return oldFind.apply( this, args ); |
| }; |
| |
| // Copy properties attached to original jQuery.find method (e.g. .attr, .isXML) |
| var findProp; |
| 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 |
| jQuery.fn.size = function() { |
| migrateWarn( "jQuery.fn.size() is deprecated and removed; use the .length property" ); |
| return this.length; |
| }; |
| |
| jQuery.parseJSON = function() { |
| migrateWarn( "jQuery.parseJSON is deprecated; use JSON.parse" ); |
| return JSON.parse.apply( null, arguments ); |
| }; |
| |
| jQuery.isNumeric = function( val ) { |
| |
| // The jQuery 2.2.3 implementation of isNumeric |
| function isNumeric2( obj ) { |
| var realStringObj = obj && obj.toString(); |
| return !jQuery.isArray( obj ) && ( realStringObj - parseFloat( realStringObj ) + 1 ) >= 0; |
| } |
| |
| var newValue = oldIsNumeric( val ), |
| oldValue = isNumeric2( val ); |
| |
| if ( newValue !== oldValue ) { |
| migrateWarn( "jQuery.isNumeric() should not be called on constructed objects" ); |
| } |
| |
| return oldValue; |
| }; |
| |
| migrateWarnFunc( jQuery, "holdReady", jQuery.holdReady, |
| "jQuery.holdReady is deprecated" ); |
| |
| migrateWarnFunc( jQuery, "unique", jQuery.uniqueSort, |
| "jQuery.unique is deprecated; use jQuery.uniqueSort" ); |
| |
| // Now jQuery.expr.pseudos is the standard incantation |
| migrateWarnProp( jQuery.expr, "filters", jQuery.expr.pseudos, |
| "jQuery.expr.filters is deprecated; use jQuery.expr.pseudos" ); |
| migrateWarnProp( jQuery.expr, ":", jQuery.expr.pseudos, |
| "jQuery.expr[':'] is deprecated; use jQuery.expr.pseudos" ); |
| |
| |
| var oldAjax = jQuery.ajax; |
| |
| jQuery.ajax = function( ) { |
| var jQXHR = oldAjax.apply( this, arguments ); |
| |
| // Be sure we got a jQXHR (e.g., not sync) |
| if ( jQXHR.promise ) { |
| migrateWarnFunc( jQXHR, "success", jQXHR.done, |
| "jQXHR.success is deprecated and removed" ); |
| migrateWarnFunc( jQXHR, "error", jQXHR.fail, |
| "jQXHR.error is deprecated and removed" ); |
| migrateWarnFunc( jQXHR, "complete", jQXHR.always, |
| "jQXHR.complete is deprecated and removed" ); |
| } |
| |
| return jQXHR; |
| }; |
| |
| |
| var oldRemoveAttr = jQuery.fn.removeAttr, |
| oldToggleClass = jQuery.fn.toggleClass, |
| rmatchNonSpace = /\S+/g; |
| |
| jQuery.fn.removeAttr = function( name ) { |
| var self = this; |
| |
| jQuery.each( name.match( rmatchNonSpace ), function( i, attr ) { |
| if ( jQuery.expr.match.bool.test( attr ) ) { |
| migrateWarn( "jQuery.fn.removeAttr no longer sets boolean properties: " + attr ); |
| self.prop( attr, false ); |
| } |
| } ); |
| |
| return oldRemoveAttr.apply( this, arguments ); |
| }; |
| |
| jQuery.fn.toggleClass = function( state ) { |
| |
| // Only deprecating no-args or single boolean arg |
| if ( state !== undefined && typeof state !== "boolean" ) { |
| return oldToggleClass.apply( this, arguments ); |
| } |
| |
| migrateWarn( "jQuery.fn.toggleClass( boolean ) is deprecated" ); |
| |
| // Toggle entire class name of each element |
| return this.each( function() { |
| var className = this.getAttribute && this.getAttribute( "class" ) || ""; |
| |
| if ( className ) { |
| jQuery.data( 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 || state === false ? |
| "" : |
| jQuery.data( this, "__className__" ) || "" |
| ); |
| } |
| } ); |
| }; |
| |
| |
| var internalSwapCall = false; |
| |
| // If this version of jQuery has .swap(), don't false-alarm on internal uses |
| if ( jQuery.swap ) { |
| jQuery.each( [ "height", "width", "reliableMarginRight" ], function( _, name ) { |
| var oldHook = jQuery.cssHooks[ name ] && jQuery.cssHooks[ name ].get; |
| |
| if ( oldHook ) { |
| jQuery.cssHooks[ name ].get = function() { |
| var ret; |
| |
| internalSwapCall = true; |
| ret = oldHook.apply( this, arguments ); |
| internalSwapCall = false; |
| return ret; |
| }; |
| } |
| } ); |
| } |
| |
| jQuery.swap = function( elem, options, callback, args ) { |
| var ret, name, |
| old = {}; |
| |
| if ( !internalSwapCall ) { |
| migrateWarn( "jQuery.swap() is undocumented and deprecated" ); |
| } |
| |
| // 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.apply( elem, args || [] ); |
| |
| // Revert the old values |
| for ( name in options ) { |
| elem.style[ name ] = old[ name ]; |
| } |
| |
| return ret; |
| }; |
| |
| var oldData = jQuery.data; |
| |
| jQuery.data = function( elem, name, value ) { |
| var curData; |
| |
| // Name can be an object, and each entry in the object is meant to be set as data |
| if ( name && typeof name === "object" && arguments.length === 2 ) { |
| curData = jQuery.hasData( elem ) && oldData.call( this, elem ); |
| var sameKeys = {}; |
| for ( var key in name ) { |
| if ( key !== jQuery.camelCase( key ) ) { |
| migrateWarn( "jQuery.data() always sets/gets camelCased names: " + key ); |
| curData[ key ] = name[ key ]; |
| } else { |
| sameKeys[ key ] = name[ key ]; |
| } |
| } |
| |
| oldData.call( this, elem, sameKeys ); |
| |
| return name; |
| } |
| |
| // If the name is transformed, look for the un-transformed name in the data object |
| if ( name && typeof name === "string" && name !== jQuery.camelCase( name ) ) { |
| curData = jQuery.hasData( elem ) && oldData.call( this, elem ); |
| if ( curData && name in curData ) { |
| migrateWarn( "jQuery.data() always sets/gets camelCased names: " + name ); |
| if ( arguments.length > 2 ) { |
| curData[ name ] = value; |
| } |
| return curData[ name ]; |
| } |
| } |
| |
| return oldData.apply( this, arguments ); |
| }; |
| |
| var oldTweenRun = jQuery.Tween.prototype.run; |
| var linearEasing = function( pct ) { |
| return pct; |
| }; |
| |
| jQuery.Tween.prototype.run = function( ) { |
| if ( jQuery.easing[ this.easing ].length > 1 ) { |
| migrateWarn( |
| "'jQuery.easing." + this.easing.toString() + "' should use only one argument" |
| ); |
| |
| jQuery.easing[ this.easing ] = linearEasing; |
| } |
| |
| oldTweenRun.apply( this, arguments ); |
| }; |
| |
| jQuery.fx.interval = jQuery.fx.interval || 13; |
| |
| // Support: IE9, Android <=4.4 |
| // Avoid false positives on browsers that lack rAF |
| if ( window.requestAnimationFrame ) { |
| migrateWarnProp( jQuery.fx, "interval", jQuery.fx.interval, |
| "jQuery.fx.interval is deprecated" ); |
| } |
| |
| var oldLoad = jQuery.fn.load, |
| oldEventAdd = jQuery.event.add, |
| originalFix = jQuery.event.fix; |
| |
| jQuery.event.props = []; |
| jQuery.event.fixHooks = {}; |
| |
| migrateWarnProp( jQuery.event.props, "concat", jQuery.event.props.concat, |
| "jQuery.event.props.concat() is deprecated and removed" ); |
| |
| jQuery.event.fix = function( originalEvent ) { |
| var event, |
| type = originalEvent.type, |
| fixHook = this.fixHooks[ type ], |
| props = jQuery.event.props; |
| |
| if ( props.length ) { |
| migrateWarn( "jQuery.event.props are deprecated and removed: " + props.join() ); |
| while ( props.length ) { |
| jQuery.event.addProp( props.pop() ); |
| } |
| } |
| |
| if ( fixHook && !fixHook._migrated_ ) { |
| fixHook._migrated_ = true; |
| migrateWarn( "jQuery.event.fixHooks are deprecated and removed: " + type ); |
| if ( ( props = fixHook.props ) && props.length ) { |
| while ( props.length ) { |
| jQuery.event.addProp( props.pop() ); |
| } |
| } |
| } |
| |
| event = originalFix.call( this, originalEvent ); |
| |
| return fixHook && fixHook.filter ? fixHook.filter( event, originalEvent ) : event; |
| }; |
| |
| jQuery.event.add = function( elem, types ) { |
| |
| // This misses the multiple-types case but that seems awfully rare |
| if ( elem === window && types === "load" && window.document.readyState === "complete" ) { |
| migrateWarn( "jQuery(window).on('load'...) called after load event occurred" ); |
| } |
| return oldEventAdd.apply( this, arguments ); |
| }; |
| |
| jQuery.each( [ "load", "unload", "error" ], function( _, name ) { |
| |
| jQuery.fn[ name ] = function() { |
| var args = Array.prototype.slice.call( arguments, 0 ); |
| |
| // If this is an ajax load() the first arg should be the string URL; |
| // technically this could also be the "Anything" arg of the event .load() |
| // which just goes to show why this dumb signature has been deprecated! |
| // jQuery custom builds that exclude the Ajax module justifiably die here. |
| if ( name === "load" && typeof args[ 0 ] === "string" ) { |
| return oldLoad.apply( this, args ); |
| } |
| |
| migrateWarn( "jQuery.fn." + name + "() is deprecated" ); |
| |
| args.splice( 0, 0, name ); |
| if ( arguments.length ) { |
| return this.on.apply( this, args ); |
| } |
| |
| // Use .triggerHandler here because: |
| // - load and unload events don't need to bubble, only applied to window or image |
| // - error event should not bubble to window, although it does pre-1.7 |
| // See http://bugs.jquery.com/ticket/11820 |
| this.triggerHandler.apply( this, args ); |
| return this; |
| }; |
| |
| } ); |
| |
| jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " + |
| "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + |
| "change select submit keydown keypress keyup contextmenu" ).split( " " ), |
| function( i, name ) { |
| |
| // Handle event binding |
| jQuery.fn[ name ] = function( data, fn ) { |
| migrateWarn( "jQuery.fn." + name + "() event shorthand is deprecated" ); |
| return arguments.length > 0 ? |
| this.on( name, null, data, fn ) : |
| this.trigger( name ); |
| }; |
| } ); |
| |
| // Trigger "ready" event only once, on document ready |
| jQuery( function() { |
| jQuery( window.document ).triggerHandler( "ready" ); |
| } ); |
| |
| jQuery.event.special.ready = { |
| setup: function() { |
| if ( this === window.document ) { |
| migrateWarn( "'ready' event is deprecated" ); |
| } |
| } |
| }; |
| |
| jQuery.fn.extend( { |
| |
| bind: function( types, data, fn ) { |
| migrateWarn( "jQuery.fn.bind() is deprecated" ); |
| return this.on( types, null, data, fn ); |
| }, |
| unbind: function( types, fn ) { |
| migrateWarn( "jQuery.fn.unbind() is deprecated" ); |
| return this.off( types, null, fn ); |
| }, |
| delegate: function( selector, types, data, fn ) { |
| migrateWarn( "jQuery.fn.delegate() is deprecated" ); |
| return this.on( types, selector, data, fn ); |
| }, |
| undelegate: function( selector, types, fn ) { |
| migrateWarn( "jQuery.fn.undelegate() is deprecated" ); |
| return arguments.length === 1 ? |
| this.off( selector, "**" ) : |
| this.off( types, selector || "**", fn ); |
| }, |
| hover: function( fnOver, fnOut ) { |
| migrateWarn( "jQuery.fn.hover() is deprecated" ); |
| return this.on( "mouseenter", fnOver ).on( "mouseleave", fnOut || fnOver ); |
| } |
| } ); |
| |
| |
| var oldOffset = jQuery.fn.offset; |
| |
| jQuery.fn.offset = function() { |
| var docElem, |
| elem = this[ 0 ], |
| origin = { top: 0, left: 0 }; |
| |
| if ( !elem || !elem.nodeType ) { |
| migrateWarn( "jQuery.fn.offset() requires a valid DOM element" ); |
| return origin; |
| } |
| |
| docElem = ( elem.ownerDocument || window.document ).documentElement; |
| if ( !jQuery.contains( docElem, elem ) ) { |
| migrateWarn( "jQuery.fn.offset() requires an element connected to a document" ); |
| return origin; |
| } |
| |
| return oldOffset.apply( this, arguments ); |
| }; |
| |
| |
| var oldParam = jQuery.param; |
| |
| jQuery.param = function( data, traditional ) { |
| var ajaxTraditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional; |
| |
| if ( traditional === undefined && ajaxTraditional ) { |
| |
| migrateWarn( "jQuery.param() no longer uses jQuery.ajaxSettings.traditional" ); |
| traditional = ajaxTraditional; |
| } |
| |
| return oldParam.call( this, data, traditional ); |
| }; |
| |
| var oldSelf = jQuery.fn.andSelf || jQuery.fn.addBack; |
| |
| jQuery.fn.andSelf = function() { |
| migrateWarn( "jQuery.fn.andSelf() is deprecated and removed, use jQuery.fn.addBack()" ); |
| return oldSelf.apply( this, arguments ); |
| }; |
| |
| |
| var oldDeferred = jQuery.Deferred, |
| tuples = [ |
| |
| // Action, add listener, callbacks, .then handlers, final state |
| [ "resolve", "done", jQuery.Callbacks( "once memory" ), |
| jQuery.Callbacks( "once memory" ), "resolved" ], |
| [ "reject", "fail", jQuery.Callbacks( "once memory" ), |
| jQuery.Callbacks( "once memory" ), "rejected" ], |
| [ "notify", "progress", jQuery.Callbacks( "memory" ), |
| jQuery.Callbacks( "memory" ) ] |
| ]; |
| |
| jQuery.Deferred = function( func ) { |
| var deferred = oldDeferred(), |
| promise = deferred.promise(); |
| |
| deferred.pipe = promise.pipe = function( /* fnDone, fnFail, fnProgress */ ) { |
| var fns = arguments; |
| |
| migrateWarn( "deferred.pipe() is deprecated" ); |
| |
| return jQuery.Deferred( function( newDefer ) { |
| jQuery.each( tuples, function( i, tuple ) { |
| var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ]; |
| |
| // Deferred.done(function() { bind to newDefer or newDefer.resolve }) |
| // deferred.fail(function() { bind to newDefer or newDefer.reject }) |
| // deferred.progress(function() { bind to newDefer or newDefer.notify }) |
| deferred[ tuple[ 1 ] ]( function() { |
| var returned = fn && fn.apply( this, arguments ); |
| if ( returned && jQuery.isFunction( returned.promise ) ) { |
| returned.promise() |
| .done( newDefer.resolve ) |
| .fail( newDefer.reject ) |
| .progress( newDefer.notify ); |
| } else { |
| newDefer[ tuple[ 0 ] + "With" ]( |
| this === promise ? newDefer.promise() : this, |
| fn ? [ returned ] : arguments |
| ); |
| } |
| } ); |
| } ); |
| fns = null; |
| } ).promise(); |
| |
| }; |
| |
| if ( func ) { |
| func.call( deferred, deferred ); |
| } |
| |
| return deferred; |
| }; |
| |
| // Preserve handler of uncaught exceptions in promise chains |
| jQuery.Deferred.exceptionHook = oldDeferred.exceptionHook; |
| |
| return jQuery; |
| } ); |