+ jQuery.fx.off = true;

+ jQuery.fx.off = false;

+!jquery/dist/jquery.*

+ "version": "1.4.0",

+ "main": "jquery-migrate.js",

+ "_release": "1.4.0",

+ "tag": "1.4.0",

+ "commit": "d70e5a532864fdc2263f0d15030ef84671fc5807"

+ "_source": "https://github.com/appleboy/jquery-migrate.git",

+ "_target": "~1.4.0",

+ "_originalSource": "jquery-migrate"

+/*!

+ * jQuery Migrate - v1.4.0 - 2016-02-26

+ * Copyright jQuery Foundation and other contributors

+ */

+(function( jQuery, window, undefined ) {

+// See http://bugs.jquery.com/ticket/13335

+// "use strict";

+

+

+jQuery.migrateVersion = "1.4.0";

+

+

+var warnedAbout = {};

+

+// List of warnings already given; public read only

+jQuery.migrateWarnings = [];

+

+// Set to true to prevent console output; migrateWarnings still maintained

+// jQuery.migrateMute = false;

+

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

+if ( window.console && window.console.log ) {

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

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

+ ", version " + jQuery.migrateVersion );

+}

+

+// 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 ) {

+ if ( Object.defineProperty ) {

+ // On ES5 browsers (non-oldIE), warn if the code tries to get prop;

+ // allow property to be overwritten in case some other plugin wants it

+ try {

+ Object.defineProperty( obj, prop, {

+ configurable: true,

+ enumerable: true,

+ get: function() {

+ migrateWarn( msg );

+ return value;

+ },

+ set: function( newValue ) {

+ migrateWarn( msg );

+ value = newValue;

+ }

+ });

+ return;

+ } catch( err ) {

+ // IE8 is a dope about Object.defineProperty, can't warn there

+ }

+ }

+

+ // Non-ES5 (or broken) browser; just set the property

+ jQuery._definePropertyBroken = true;

+ obj[ prop ] = value;

+}

+

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

+ // jQuery has never supported or tested Quirks Mode

+ migrateWarn( "jQuery is not compatible with Quirks Mode" );

+}

+

+

+var attrFn = jQuery( "<input/>", { size: 1 } ).attr("size") && jQuery.attrFn,

+ oldAttr = jQuery.attr,

+ valueAttrGet = jQuery.attrHooks.value && jQuery.attrHooks.value.get ||

+ function() { return null; },

+ valueAttrSet = jQuery.attrHooks.value && jQuery.attrHooks.value.set ||

+ function() { return undefined; },

+ rnoType = /^(?:input|button)$/i,

+ rnoAttrNodeType = /^[238]$/,

+ rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,

+ ruseDefault = /^(?:checked|selected)$/i;

+

+// jQuery.attrFn

+migrateWarnProp( jQuery, "attrFn", attrFn || {}, "jQuery.attrFn is deprecated" );

+

+jQuery.attr = function( elem, name, value, pass ) {

+ var lowerName = name.toLowerCase(),

+ nType = elem && elem.nodeType;

+

+ if ( pass ) {

+ // Since pass is used internally, we only warn for new jQuery

+ // versions where there isn't a pass arg in the formal params

+ if ( oldAttr.length < 4 ) {

+ migrateWarn("jQuery.fn.attr( props, pass ) is deprecated");

+ }

+ if ( elem && !rnoAttrNodeType.test( nType ) &&

+ (attrFn ? name in attrFn : jQuery.isFunction(jQuery.fn[name])) ) {

+ return jQuery( elem )[ name ]( value );

+ }

+ }

+

+ // Warn if user tries to set `type`, since it breaks on IE 6/7/8; by checking

+ // for disconnected elements we don't warn on $( "<button>", { type: "button" } ).

+ if ( name === "type" && value !== undefined && rnoType.test( elem.nodeName ) && elem.parentNode ) {

+ migrateWarn("Can't change the 'type' of an input or button in IE 6/7/8");

+ }

+

+ // Restore boolHook for boolean property/attribute synchronization

+ if ( !jQuery.attrHooks[ lowerName ] && rboolean.test( lowerName ) ) {

+ jQuery.attrHooks[ lowerName ] = {

+ get: function( elem, name ) {

+ // Align boolean attributes with corresponding properties

+ // Fall back to attribute presence where some booleans are not supported

+ var attrNode,

+ property = jQuery.prop( elem, name );

+ return property === true || typeof property !== "boolean" &&

+ ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?

+

+ name.toLowerCase() :

+ undefined;

+ },

+ set: function( elem, value, name ) {

+ var propName;

+ if ( value === false ) {

+ // Remove boolean attributes when set to false

+ jQuery.removeAttr( elem, name );

+ } else {

+ // value is true since we know at this point it's type boolean and not false

+ // Set boolean attributes to the same name and set the DOM property

+ propName = jQuery.propFix[ name ] || name;

+ if ( propName in elem ) {

+ // Only set the IDL specifically if it already exists on the element

+ elem[ propName ] = true;

+ }

+

+ elem.setAttribute( name, name.toLowerCase() );

+ }

+ return name;

+ }

+ };

+

+ // Warn only for attributes that can remain distinct from their properties post-1.9

+ if ( ruseDefault.test( lowerName ) ) {

+ migrateWarn( "jQuery.fn.attr('" + lowerName + "') might use property instead of attribute" );

+ }

+ }

+

+ return oldAttr.call( jQuery, elem, name, value );

+};

+

+// attrHooks: value

+jQuery.attrHooks.value = {

+ get: function( elem, name ) {

+ var nodeName = ( elem.nodeName || "" ).toLowerCase();

+ if ( nodeName === "button" ) {

+ return valueAttrGet.apply( this, arguments );

+ }

+ if ( nodeName !== "input" && nodeName !== "option" ) {

+ migrateWarn("jQuery.fn.attr('value') no longer gets properties");

+ }

+ return name in elem ?

+ elem.value :

+ null;

+ },

+ set: function( elem, value ) {

+ var nodeName = ( elem.nodeName || "" ).toLowerCase();

+ if ( nodeName === "button" ) {

+ return valueAttrSet.apply( this, arguments );

+ }

+ if ( nodeName !== "input" && nodeName !== "option" ) {

+ migrateWarn("jQuery.fn.attr('value', val) no longer sets properties");

+ }

+ // Does not return so that setAttribute is also used

+ elem.value = value;

+ }

+};

+

+

+var matched, browser,

+ oldInit = jQuery.fn.init,

+ oldParseJSON = jQuery.parseJSON,

+ rspaceAngle = /^\s*</,

+ rattrHash = /\[\s*\w+\s*[~|^$*]?=\s*(?![\s'"])[^#\]]*#/,

+ // Note: XSS check is done below after string is trimmed

+ rquickExpr = /^([^<]*)(<[\w\W]+>)([^>]*)$/;

+

+// $(html) "looks like html" rule change

+jQuery.fn.init = function( selector, context, rootjQuery ) {

+ var match, ret;

+

+ if ( selector && typeof selector === "string" && !jQuery.isPlainObject( context ) &&

+ (match = rquickExpr.exec( jQuery.trim( selector ) )) && match[ 0 ] ) {

+ // This is an HTML string according to the "old" rules; is it still?

+ if ( !rspaceAngle.test( selector ) ) {

+ migrateWarn("$(html) HTML strings must start with '<' character");

+ }

+ if ( match[ 3 ] ) {

+ migrateWarn("$(html) HTML text after last tag is ignored");

+ }

+

+ // Consistently reject any HTML-like string starting with a hash (#9521)

+ // Note that this may break jQuery 1.6.x code that otherwise would work.

+ if ( match[ 0 ].charAt( 0 ) === "#" ) {

+ migrateWarn("HTML string cannot start with a '#' character");

+ jQuery.error("JQMIGRATE: Invalid selector string (XSS)");

+ }

+ // Now process using loose rules; let pre-1.8 play too

+ if ( context && context.context ) {

+ // jQuery object as context; parseHTML expects a DOM object

+ context = context.context;

+ }

+ if ( jQuery.parseHTML ) {

+ return oldInit.call( this,

+ jQuery.parseHTML( match[ 2 ], context && context.ownerDocument ||

+ context || document, true ), context, rootjQuery );

+ }

+ }

+

+ if ( selector === "#" ) {

+

+ // jQuery( "#" ) is a bogus ID selector, but it returned an empty set before jQuery 3.0

+ migrateWarn( "jQuery( '#' ) is not a valid selector" );

+ selector = [];

+

+ } else if ( rattrHash.test( selector ) ) {

+

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

+ // Note that this doesn't actually fix the selector due to potential false positives

+ migrateWarn( "Attribute selectors with '#' must be quoted: '" + selector + "'" );

+ }

+

+ ret = oldInit.apply( this, arguments );

+

+ // Fill in selector and context properties so .live() works

+ if ( selector && selector.selector !== undefined ) {

+ // A jQuery object, copy its properties

+ ret.selector = selector.selector;

+ ret.context = selector.context;

+

+ } else {

+ ret.selector = typeof selector === "string" ? selector : "";

+ if ( selector ) {

+ ret.context = selector.nodeType? selector : context || document;

+ }

+ }

+

+ return ret;

+};

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

+

+// Let $.parseJSON(falsy_value) return null

+jQuery.parseJSON = function( json ) {

+ if ( !json ) {

+ migrateWarn("jQuery.parseJSON requires a valid JSON string");

+ return null;

+ }

+ return oldParseJSON.apply( this, arguments );

+};

+

+jQuery.uaMatch = function( ua ) {

+ ua = ua.toLowerCase();

+

+ var match = /(chrome)[ \/]([\w.]+)/.exec( ua ) ||

+ /(webkit)[ \/]([\w.]+)/.exec( ua ) ||

+ /(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) ||

+ /(msie) ([\w.]+)/.exec( ua ) ||

+ ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) ||

+ [];

+

+ return {

+ browser: match[ 1 ] || "",

+ version: match[ 2 ] || "0"

+ };

+};

+

+// Don't clobber any existing jQuery.browser in case it's different

+if ( !jQuery.browser ) {

+ matched = jQuery.uaMatch( navigator.userAgent );

+ browser = {};

+

+ if ( matched.browser ) {

+ browser[ matched.browser ] = true;

+ browser.version = matched.version;

+ }

+

+ // Chrome is Webkit, but Webkit is also Safari.

+ if ( browser.chrome ) {

+ browser.webkit = true;

+ } else if ( browser.webkit ) {

+ browser.safari = true;

+ }

+

+ jQuery.browser = browser;

+}

+

+// Warn if the code tries to get jQuery.browser

+migrateWarnProp( jQuery, "browser", jQuery.browser, "jQuery.browser is deprecated" );

+

+// jQuery.boxModel deprecated in 1.3, jQuery.support.boxModel deprecated in 1.7

+jQuery.boxModel = jQuery.support.boxModel = (document.compatMode === "CSS1Compat");

+migrateWarnProp( jQuery, "boxModel", jQuery.boxModel, "jQuery.boxModel is deprecated" );

+migrateWarnProp( jQuery.support, "boxModel", jQuery.support.boxModel, "jQuery.support.boxModel is deprecated" );

+

+jQuery.sub = function() {

+ function jQuerySub( selector, context ) {

+ return new jQuerySub.fn.init( selector, context );

+ }

+ jQuery.extend( true, jQuerySub, this );

+ jQuerySub.superclass = this;

+ jQuerySub.fn = jQuerySub.prototype = this();

+ jQuerySub.fn.constructor = jQuerySub;

+ jQuerySub.sub = this.sub;

+ jQuerySub.fn.init = function init( selector, context ) {

+ var instance = jQuery.fn.init.call( this, selector, context, rootjQuerySub );

+ return instance instanceof jQuerySub ?

+ instance :

+ jQuerySub( instance );

+ };

+ jQuerySub.fn.init.prototype = jQuerySub.fn;

+ var rootjQuerySub = jQuerySub(document);

+ migrateWarn( "jQuery.sub() is deprecated" );

+ return jQuerySub;

+};

+

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

+jQuery.fn.size = function() {

+ migrateWarn( "jQuery.fn.size() is deprecated; use the .length property" );

+ return this.length;

+};

+

+

+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;

+};

+

+

+// Ensure that $.ajax gets the new parseJSON defined in core.js

+jQuery.ajaxSetup({

+ converters: {

+ "text json": jQuery.parseJSON

+ }

+});

+

+

+var oldFnData = jQuery.fn.data;

+

+jQuery.fn.data = function( name ) {

+ var ret, evt,

+ elem = this[0];

+

+ // Handles 1.7 which has this behavior and 1.8 which doesn't

+ if ( elem && name === "events" && arguments.length === 1 ) {

+ ret = jQuery.data( elem, name );

+ evt = jQuery._data( elem, name );

+ if ( ( ret === undefined || ret === evt ) && evt !== undefined ) {

+ migrateWarn("Use of jQuery.fn.data('events') is deprecated");

+ return evt;

+ }

+ }

+ return oldFnData.apply( this, arguments );

+};

+

+

+var rscriptType = /\/(java|ecma)script/i;

+

+// Since jQuery.clean is used internally on older versions, we only shim if it's missing

+if ( !jQuery.clean ) {

+ jQuery.clean = function( elems, context, fragment, scripts ) {

+ // Set context per 1.8 logic

+ context = context || document;

+ context = !context.nodeType && context[0] || context;

+ context = context.ownerDocument || context;

+

+ migrateWarn("jQuery.clean() is deprecated");

+

+ var i, elem, handleScript, jsTags,

+ ret = [];

+

+ jQuery.merge( ret, jQuery.buildFragment( elems, context ).childNodes );

+

+ // Complex logic lifted directly from jQuery 1.8

+ if ( fragment ) {

+ // Special handling of each script element

+ handleScript = function( elem ) {

+ // Check if we consider it executable

+ if ( !elem.type || rscriptType.test( elem.type ) ) {

+ // Detach the script and store it in the scripts array (if provided) or the fragment

+ // Return truthy to indicate that it has been handled

+ return scripts ?

+ scripts.push( elem.parentNode ? elem.parentNode.removeChild( elem ) : elem ) :

+ fragment.appendChild( elem );

+ }

+ };

+

+ for ( i = 0; (elem = ret[i]) != null; i++ ) {

+ // Check if we're done after handling an executable script

+ if ( !( jQuery.nodeName( elem, "script" ) && handleScript( elem ) ) ) {

+ // Append to fragment and handle embedded scripts

+ fragment.appendChild( elem );

+ if ( typeof elem.getElementsByTagName !== "undefined" ) {

+ // handleScript alters the DOM, so use jQuery.merge to ensure snapshot iteration

+ jsTags = jQuery.grep( jQuery.merge( [], elem.getElementsByTagName("script") ), handleScript );

+

+ // Splice the scripts into ret after their former ancestor and advance our index beyond them

+ ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );

+ i += jsTags.length;

+ }

+ }

+ }

+ }

+

+ return ret;

+ };

+}

+

+var eventAdd = jQuery.event.add,

+ eventRemove = jQuery.event.remove,

+ eventTrigger = jQuery.event.trigger,

+ oldToggle = jQuery.fn.toggle,

+ oldLive = jQuery.fn.live,

+ oldDie = jQuery.fn.die,

+ oldLoad = jQuery.fn.load,

+ ajaxEvents = "ajaxStart|ajaxStop|ajaxSend|ajaxComplete|ajaxError|ajaxSuccess",

+ rajaxEvent = new RegExp( "\\b(?:" + ajaxEvents + ")\\b" ),

+ rhoverHack = /(?:^|\s)hover(\.\S+|)\b/,

+ hoverHack = function( events ) {

+ if ( typeof( events ) !== "string" || jQuery.event.special.hover ) {

+ return events;

+ }

+ if ( rhoverHack.test( events ) ) {

+ migrateWarn("'hover' pseudo-event is deprecated, use 'mouseenter mouseleave'");

+ }

+ return events && events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );

+ };

+

+// Event props removed in 1.9, put them back if needed; no practical way to warn them

+if ( jQuery.event.props && jQuery.event.props[ 0 ] !== "attrChange" ) {

+ jQuery.event.props.unshift( "attrChange", "attrName", "relatedNode", "srcElement" );

+}

+

+// Undocumented jQuery.event.handle was "deprecated" in jQuery 1.7

+if ( jQuery.event.dispatch ) {

+ migrateWarnProp( jQuery.event, "handle", jQuery.event.dispatch, "jQuery.event.handle is undocumented and deprecated" );

+}

+

+// Support for 'hover' pseudo-event and ajax event warnings

+jQuery.event.add = function( elem, types, handler, data, selector ){

+ if ( elem !== document && rajaxEvent.test( types ) ) {

+ migrateWarn( "AJAX events should be attached to document: " + types );

+ }

+ eventAdd.call( this, elem, hoverHack( types || "" ), handler, data, selector );

+};

+jQuery.event.remove = function( elem, types, handler, selector, mappedTypes ){

+ eventRemove.call( this, elem, hoverHack( types ) || "", handler, selector, mappedTypes );

+};

+

+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.bind.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.fn.toggle = function( fn, fn2 ) {

+

+ // Don't mess with animation or css toggles

+ if ( !jQuery.isFunction( fn ) || !jQuery.isFunction( fn2 ) ) {

+ return oldToggle.apply( this, arguments );

+ }

+ migrateWarn("jQuery.fn.toggle(handler, handler...) is deprecated");

+

+ // Save reference to arguments for access in closure

+ var args = arguments,

+ guid = fn.guid || jQuery.guid++,

+ i = 0,

+ toggler = function( event ) {

+ // Figure out which function to execute

+ var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;

+ jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );

+

+ // Make sure that clicks stop

+ event.preventDefault();

+

+ // and execute the function

+ return args[ lastToggle ].apply( this, arguments ) || false;

+ };

+

+ // link all the functions, so any of them can unbind this click handler

+ toggler.guid = guid;

+ while ( i < args.length ) {

+ args[ i++ ].guid = guid;

+ }

+

+ return this.click( toggler );

+};

+

+jQuery.fn.live = function( types, data, fn ) {

+ migrateWarn("jQuery.fn.live() is deprecated");

+ if ( oldLive ) {

+ return oldLive.apply( this, arguments );

+ }

+ jQuery( this.context ).on( types, this.selector, data, fn );

+ return this;

+};

+

+jQuery.fn.die = function( types, fn ) {

+ migrateWarn("jQuery.fn.die() is deprecated");

+ if ( oldDie ) {

+ return oldDie.apply( this, arguments );

+ }

+ jQuery( this.context ).off( types, this.selector || "**", fn );

+ return this;

+};

+

+// Turn global events into document-triggered events

+jQuery.event.trigger = function( event, data, elem, onlyHandlers ){

+ if ( !elem && !rajaxEvent.test( event ) ) {

+ migrateWarn( "Global events are undocumented and deprecated" );

+ }

+ return eventTrigger.call( this, event, data, elem || document, onlyHandlers );

+};

+jQuery.each( ajaxEvents.split("|"),

+ function( _, name ) {

+ jQuery.event.special[ name ] = {

+ setup: function() {

+ var elem = this;

+

+ // The document needs no shimming; must be !== for oldIE

+ if ( elem !== document ) {

+ jQuery.event.add( document, name + "." + jQuery.guid, function() {

+ jQuery.event.trigger( name, Array.prototype.slice.call( arguments, 1 ), elem, true );

+ });

+ jQuery._data( this, name, jQuery.guid++ );

+ }

+ return false;

+ },

+ teardown: function() {

+ if ( this !== document ) {

+ jQuery.event.remove( document, name + "." + jQuery._data( this, name ) );

+ }

+ return false;

+ }

+ };

+ }

+);

+

+jQuery.event.special.ready = {

+ setup: function() {

+ if ( this === document ) {

+ migrateWarn( "'ready' event is deprecated" );

+ }

+ }

+};

+

+var oldSelf = jQuery.fn.andSelf || jQuery.fn.addBack,

+ oldFind = jQuery.fn.find;

+

+jQuery.fn.andSelf = function() {

+ migrateWarn("jQuery.fn.andSelf() replaced by jQuery.fn.addBack()");

+ return oldSelf.apply( this, arguments );

+};

+

+jQuery.fn.find = function( selector ) {

+ var ret = oldFind.apply( this, arguments );

+ ret.context = this.context;

+ ret.selector = this.selector ? this.selector + " " + selector : selector;

+ return ret;

+};

+

+

+// jQuery 1.6 did not support Callbacks, do not warn there

+if ( jQuery.Callbacks ) {

+

+ 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();

+

+ };

+

+ deferred.isResolved = function() {

+ migrateWarn( "deferred.isResolved is deprecated" );

+ return deferred.state() === "resolved";

+ };

+

+ deferred.isRejected = function() {

+ migrateWarn( "deferred.isRejected is deprecated" );

+ return deferred.state() === "rejected";

+ };

+

+ if ( func ) {

+ func.call( deferred, deferred );

+ }

+

+ return deferred;

+ };

+

+}

+

+})( jQuery, window );

+/*! jQuery Migrate v1.4.0 | (c) jQuery Foundation and other contributors | jquery.org/license */

+"undefined"==typeof jQuery.migrateMute&&(jQuery.migrateMute=!0),function(a,b,c){function d(c){var d=b.console;f[c]||(f[c]=!0,a.migrateWarnings.push(c),d&&d.warn&&!a.migrateMute&&(d.warn("JQMIGRATE: "+c),a.migrateTrace&&d.trace&&d.trace()))}function e(b,c,e,f){if(Object.defineProperty)try{return void Object.defineProperty(b,c,{configurable:!0,enumerable:!0,get:function(){return d(f),e},set:function(a){d(f),e=a}})}catch(g){}a._definePropertyBroken=!0,b[c]=e}a.migrateVersion="1.4.0";var f={};a.migrateWarnings=[],b.console&&b.console.log&&b.console.log("JQMIGRATE: Migrate is installed"+(a.migrateMute?"":" with logging active")+", version "+a.migrateVersion),a.migrateTrace===c&&(a.migrateTrace=!0),a.migrateReset=function(){f={},a.migrateWarnings.length=0},"BackCompat"===document.compatMode&&d("jQuery is not compatible with Quirks Mode");var g=a("<input/>",{size:1}).attr("size")&&a.attrFn,h=a.attr,i=a.attrHooks.value&&a.attrHooks.value.get||function(){return null},j=a.attrHooks.value&&a.attrHooks.value.set||function(){return c},k=/^(?:input|button)$/i,l=/^[238]$/,m=/^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,n=/^(?:checked|selected)$/i;e(a,"attrFn",g||{},"jQuery.attrFn is deprecated"),a.attr=function(b,e,f,i){var j=e.toLowerCase(),o=b&&b.nodeType;return i&&(h.length<4&&d("jQuery.fn.attr( props, pass ) is deprecated"),b&&!l.test(o)&&(g?e in g:a.isFunction(a.fn[e])))?a(b)[e](f):("type"===e&&f!==c&&k.test(b.nodeName)&&b.parentNode&&d("Can't change the 'type' of an input or button in IE 6/7/8"),!a.attrHooks[j]&&m.test(j)&&(a.attrHooks[j]={get:function(b,d){var e,f=a.prop(b,d);return f===!0||"boolean"!=typeof f&&(e=b.getAttributeNode(d))&&e.nodeValue!==!1?d.toLowerCase():c},set:function(b,c,d){var e;return c===!1?a.removeAttr(b,d):(e=a.propFix[d]||d,e in b&&(b[e]=!0),b.setAttribute(d,d.toLowerCase())),d}},n.test(j)&&d("jQuery.fn.attr('"+j+"') might use property instead of attribute")),h.call(a,b,e,f))},a.attrHooks.value={get:function(a,b){var c=(a.nodeName||"").toLowerCase();return"button"===c?i.apply(this,arguments):("input"!==c&&"option"!==c&&d("jQuery.fn.attr('value') no longer gets properties"),b in a?a.value:null)},set:function(a,b){var c=(a.nodeName||"").toLowerCase();return"button"===c?j.apply(this,arguments):("input"!==c&&"option"!==c&&d("jQuery.fn.attr('value', val) no longer sets properties"),void(a.value=b))}};var o,p,q=a.fn.init,r=a.parseJSON,s=/^\s*</,t=/\[\s*\w+\s*[~|^$*]?=\s*(?![\s'"])[^#\]]*#/,u=/^([^<]*)(<[\w\W]+>)([^>]*)$/;a.fn.init=function(b,e,f){var g,h;return b&&"string"==typeof b&&!a.isPlainObject(e)&&(g=u.exec(a.trim(b)))&&g[0]&&(s.test(b)||d("$(html) HTML strings must start with '<' character"),g[3]&&d("$(html) HTML text after last tag is ignored"),"#"===g[0].charAt(0)&&(d("HTML string cannot start with a '#' character"),a.error("JQMIGRATE: Invalid selector string (XSS)")),e&&e.context&&(e=e.context),a.parseHTML)?q.call(this,a.parseHTML(g[2],e&&e.ownerDocument||e||document,!0),e,f):("#"===b?(d("jQuery( '#' ) is not a valid selector"),b=[]):t.test(b)&&d("Attribute selectors with '#' must be quoted: '"+b+"'"),h=q.apply(this,arguments),b&&b.selector!==c?(h.selector=b.selector,h.context=b.context):(h.selector="string"==typeof b?b:"",b&&(h.context=b.nodeType?b:e||document)),h)},a.fn.init.prototype=a.fn,a.parseJSON=function(a){return a?r.apply(this,arguments):(d("jQuery.parseJSON requires a valid JSON string"),null)},a.uaMatch=function(a){a=a.toLowerCase();var b=/(chrome)[ \/]([\w.]+)/.exec(a)||/(webkit)[ \/]([\w.]+)/.exec(a)||/(opera)(?:.*version|)[ \/]([\w.]+)/.exec(a)||/(msie) ([\w.]+)/.exec(a)||a.indexOf("compatible")<0&&/(mozilla)(?:.*? rv:([\w.]+)|)/.exec(a)||[];return{browser:b[1]||"",version:b[2]||"0"}},a.browser||(o=a.uaMatch(navigator.userAgent),p={},o.browser&&(p[o.browser]=!0,p.version=o.version),p.chrome?p.webkit=!0:p.webkit&&(p.safari=!0),a.browser=p),e(a,"browser",a.browser,"jQuery.browser is deprecated"),a.boxModel=a.support.boxModel="CSS1Compat"===document.compatMode,e(a,"boxModel",a.boxModel,"jQuery.boxModel is deprecated"),e(a.support,"boxModel",a.support.boxModel,"jQuery.support.boxModel is deprecated"),a.sub=function(){function b(a,c){return new b.fn.init(a,c)}a.extend(!0,b,this),b.superclass=this,b.fn=b.prototype=this(),b.fn.constructor=b,b.sub=this.sub,b.fn.init=function(d,e){var f=a.fn.init.call(this,d,e,c);return f instanceof b?f:b(f)},b.fn.init.prototype=b.fn;var c=b(document);return d("jQuery.sub() is deprecated"),b},a.fn.size=function(){return d("jQuery.fn.size() is deprecated; use the .length property"),this.length};var v=!1;a.swap&&a.each(["height","width","reliableMarginRight"],function(b,c){var d=a.cssHooks[c]&&a.cssHooks[c].get;d&&(a.cssHooks[c].get=function(){var a;return v=!0,a=d.apply(this,arguments),v=!1,a})}),a.swap=function(a,b,c,e){var f,g,h={};v||d("jQuery.swap() is undocumented and deprecated");for(g in b)h[g]=a.style[g],a.style[g]=b[g];f=c.apply(a,e||[]);for(g in b)a.style[g]=h[g];return f},a.ajaxSetup({converters:{"text json":a.parseJSON}});var w=a.fn.data;a.fn.data=function(b){var e,f,g=this[0];return!g||"events"!==b||1!==arguments.length||(e=a.data(g,b),f=a._data(g,b),e!==c&&e!==f||f===c)?w.apply(this,arguments):(d("Use of jQuery.fn.data('events') is deprecated"),f)};var x=/\/(java|ecma)script/i;a.clean||(a.clean=function(b,c,e,f){c=c||document,c=!c.nodeType&&c[0]||c,c=c.ownerDocument||c,d("jQuery.clean() is deprecated");var g,h,i,j,k=[];if(a.merge(k,a.buildFragment(b,c).childNodes),e)for(i=function(a){return!a.type||x.test(a.type)?f?f.push(a.parentNode?a.parentNode.removeChild(a):a):e.appendChild(a):void 0},g=0;null!=(h=k[g]);g++)a.nodeName(h,"script")&&i(h)||(e.appendChild(h),"undefined"!=typeof h.getElementsByTagName&&(j=a.grep(a.merge([],h.getElementsByTagName("script")),i),k.splice.apply(k,[g+1,0].concat(j)),g+=j.length));return k});var y=a.event.add,z=a.event.remove,A=a.event.trigger,B=a.fn.toggle,C=a.fn.live,D=a.fn.die,E=a.fn.load,F="ajaxStart|ajaxStop|ajaxSend|ajaxComplete|ajaxError|ajaxSuccess",G=new RegExp("\\b(?:"+F+")\\b"),H=/(?:^|\s)hover(\.\S+|)\b/,I=function(b){return"string"!=typeof b||a.event.special.hover?b:(H.test(b)&&d("'hover' pseudo-event is deprecated, use 'mouseenter mouseleave'"),b&&b.replace(H,"mouseenter$1 mouseleave$1"))};a.event.props&&"attrChange"!==a.event.props[0]&&a.event.props.unshift("attrChange","attrName","relatedNode","srcElement"),a.event.dispatch&&e(a.event,"handle",a.event.dispatch,"jQuery.event.handle is undocumented and deprecated"),a.event.add=function(a,b,c,e,f){a!==document&&G.test(b)&&d("AJAX events should be attached to document: "+b),y.call(this,a,I(b||""),c,e,f)},a.event.remove=function(a,b,c,d,e){z.call(this,a,I(b)||"",c,d,e)},a.each(["load","unload","error"],function(b,c){a.fn[c]=function(){var a=Array.prototype.slice.call(arguments,0);return"load"===c&&"string"==typeof a[0]?E.apply(this,a):(d("jQuery.fn."+c+"() is deprecated"),a.splice(0,0,c),arguments.length?this.bind.apply(this,a):(this.triggerHandler.apply(this,a),this))}}),a.fn.toggle=function(b,c){if(!a.isFunction(b)||!a.isFunction(c))return B.apply(this,arguments);d("jQuery.fn.toggle(handler, handler...) is deprecated");var e=arguments,f=b.guid||a.guid++,g=0,h=function(c){var d=(a._data(this,"lastToggle"+b.guid)||0)%g;return a._data(this,"lastToggle"+b.guid,d+1),c.preventDefault(),e[d].apply(this,arguments)||!1};for(h.guid=f;g<e.length;)e[g++].guid=f;return this.click(h)},a.fn.live=function(b,c,e){return d("jQuery.fn.live() is deprecated"),C?C.apply(this,arguments):(a(this.context).on(b,this.selector,c,e),this)},a.fn.die=function(b,c){return d("jQuery.fn.die() is deprecated"),D?D.apply(this,arguments):(a(this.context).off(b,this.selector||"**",c),this)},a.event.trigger=function(a,b,c,e){return c||G.test(a)||d("Global events are undocumented and deprecated"),A.call(this,a,b,c||document,e)},a.each(F.split("|"),function(b,c){a.event.special[c]={setup:function(){var b=this;return b!==document&&(a.event.add(document,c+"."+a.guid,function(){a.event.trigger(c,Array.prototype.slice.call(arguments,1),b,!0)}),a._data(this,c,a.guid++)),!1},teardown:function(){return this!==document&&a.event.remove(document,c+"."+a._data(this,c)),!1}}}),a.event.special.ready={setup:function(){this===document&&d("'ready' event is deprecated")}};var J=a.fn.andSelf||a.fn.addBack,K=a.fn.find;if(a.fn.andSelf=function(){return d("jQuery.fn.andSelf() replaced by jQuery.fn.addBack()"),J.apply(this,arguments)},a.fn.find=function(a){var b=K.apply(this,arguments);return b.context=this.context,b.selector=this.selector?this.selector+" "+a:a,b},a.Callbacks){var L=a.Deferred,M=[["resolve","done",a.Callbacks("once memory"),a.Callbacks("once memory"),"resolved"],["reject","fail",a.Callbacks("once memory"),a.Callbacks("once memory"),"rejected"],["notify","progress",a.Callbacks("memory"),a.Callbacks("memory")]];a.Deferred=function(b){var c=L(),e=c.promise();return c.pipe=e.pipe=function(){var b=arguments;return d("deferred.pipe() is deprecated"),a.Deferred(function(d){a.each(M,function(f,g){var h=a.isFunction(b[f])&&b[f];c[g[1]](function(){var b=h&&h.apply(this,arguments);b&&a.isFunction(b.promise)?b.promise().done(d.resolve).fail(d.reject).progress(d.notify):d[g[0]+"With"](this===e?d.promise():this,h?[b]:arguments)})}),b=null}).promise()},c.isResolved=function(){return d("deferred.isResolved is deprecated"),"resolved"===c.state()},c.isRejected=function(){return d("deferred.isRejected is deprecated"),"rejected"===c.state()},b&&b.call(c,c),c}}}(jQuery,window); \ No newline at end of file

+ "version": "2.1.4",

+ "main": "dist/jquery.js",

+ "license": "MIT",

+ "ignore": [

+ "**/.*",

+ "build",

+ "dist/cdn",

+ "speed",

+ "test",

+ "*.md",

+ "AUTHORS.txt",

+ "Gruntfile.js",

+ "package.json"

+ ],

+ "devDependencies": {

+ "sizzle": "2.1.1-jquery.2.1.2",

+ "requirejs": "2.1.10",

+ "qunit": "1.14.0",

+ "sinon": "1.8.1"

+ },

+ "javascript",

+ "library"

+ "homepage": "https://github.com/jquery/jquery-dist",

+ "_release": "2.1.4",

+ "tag": "2.1.4",

+ "commit": "7751e69b615c6eca6f783a81e292a55725af6b85"

+ "_source": "https://github.com/jquery/jquery-dist.git",

+ "_target": "~2.1.0",

+Copyright 2014 jQuery Foundation and other contributors

+ * jQuery JavaScript Library v2.1.4

+ * Copyright 2005, 2014 jQuery Foundation, Inc. and other contributors

+ * Date: 2015-04-28T16:01Z

+(function( global, factory ) {

+

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

+ // For CommonJS and CommonJS-like environments where a proper `window`

+ // is present, execute the factory and get jQuery.

+ // For environments that do not have a `window` with a `document`

+ // (such as Node.js), expose a factory as module.exports.

+ // This accentuates the need for the creation of a real `window`.

+ // e.g. var jQuery = require("jquery")(window);

+ // See ticket #14549 for more info.

+ module.exports = global.document ?

+ factory( global, true ) :

+ function( w ) {

+ if ( !w.document ) {

+ throw new Error( "jQuery requires a window with a document" );

+ }

+ return factory( w );

+ };

+ } else {

+ factory( global );

+ }

+

+// Pass this if window is not defined yet

+}(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {

+

+// Support: Firefox 18+

+// Can't be in strict mode, several libs including ASP.NET trace

+//

+var arr = [];

+var slice = arr.slice;

+var concat = arr.concat;

+var push = arr.push;

+var indexOf = arr.indexOf;

+

+var class2type = {};

+

+var toString = class2type.toString;

+var hasOwn = class2type.hasOwnProperty;

+var support = {};

+

+var

+ // Use the correct document accordingly with window argument (sandbox)

+ document = window.document,

+

+ version = "2.1.4",

+ // Need init if jQuery is called (just allow error to be thrown if not included)

+ return new jQuery.fn.init( selector, context );

+ // Support: Android<4.1

+ // Make sure we trim BOM and NBSP

+ jquery: version,

+ return slice.call( this );

+ return num != null ?

+ // Return just the one element from the set

+ ( num < 0 ? this[ num + this.length ] : this[ num ] ) :

+ // Return all the elements in a clean array

+ slice.call( this );

+ map: function( callback ) {

+ return this.pushStack( jQuery.map(this, function( elem, i ) {

+ return callback.call( elem, i, elem );

+ }));

+ return this.pushStack( slice.apply( this, arguments ) );

+ push: push,

+ sort: arr.sort,

+ splice: arr.splice

+ var options, name, src, copy, copyIsArray, clone,

+

+ // Skip the boolean and the target

+ target = arguments[ i ] || {};

+ i++;

+ // Extend jQuery itself if only one argument is passed

+ if ( i === length ) {

+ i--;

+ expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),

+ // Assume jQuery is ready without the ready module

+ isReady: true,

+ error: function( msg ) {

+ throw new Error( msg );

+ noop: function() {},

+ isArray: Array.isArray,

+ return obj != null && obj === obj.window;

+ // parseFloat NaNs numeric-cast false positives (null|true|false|"")

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

+ // subtraction forces infinities to NaN

+ // adding 1 corrects loss of precision from parseFloat (#15100)

+ return !jQuery.isArray( obj ) && (obj - parseFloat( obj ) + 1) >= 0;

+ // Not plain objects:

+ // - Any object or value whose internal [[Class]] property is not "[object Object]"

+ // - DOM nodes

+ // - window

+ if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {

+ if ( obj.constructor &&

+ !hasOwn.call( obj.constructor.prototype, "isPrototypeOf" ) ) {

+ // If the function hasn't returned already, we're confident that

+ // |obj| is a plain object, created by {} or constructed with new Object

+ return true;

+ type: function( obj ) {

+ if ( obj == null ) {

+ return obj + "";

+ // Support: Android<4.0, iOS<6 (functionish RegExp)

+ return typeof obj === "object" || typeof obj === "function" ?

+ class2type[ toString.call(obj) ] || "object" :

+ typeof obj;

+ // Evaluates a script in a global context

+ globalEval: function( code ) {

+ var script,

+ indirect = eval;

+ code = jQuery.trim( code );

+ if ( code ) {

+ // If the code includes a valid, prologue position

+ // strict mode pragma, execute code by injecting a

+ // script tag into the document.

+ if ( code.indexOf("use strict") === 1 ) {

+ script = document.createElement("script");

+ script.text = code;

+ document.head.appendChild( script ).parentNode.removeChild( script );

+ } else {

+ // Otherwise, avoid the DOM node creation, insertion

+ // and removal by using an indirect global eval

+ indirect( code );

+ // Support: IE9-11+

+ // Support: Android<4.1

+ trim: function( text ) {

+ return text == null ?

+ "" :

+ ( text + "" ).replace( rtrim, "" );

+ },

+ push.call( ret, arr );

+ return arr == null ? -1 : indexOf.call( arr, elem, i );

+ var len = +second.length,

+ j = 0,

+ i = first.length;

+ for ( ; j < len; j++ ) {

+ first[ i++ ] = second[ j ];

+ grep: function( elems, callback, invert ) {

+ var callbackInverse,

+ matches = [],

+ length = elems.length,

+ callbackExpect = !invert;

+ callbackInverse = !callback( elems[ i ], i );

+ if ( callbackInverse !== callbackExpect ) {

+ matches.push( elems[ i ] );

+ return matches;

+ // Go through the array, translating each of the items to their new values

+ ret.push( value );

+ ret.push( value );

+ return concat.apply( [], ret );

+ var tmp, args, proxy;

+ args = slice.call( arguments, 2 );

+ return fn.apply( context || this, args.concat( slice.call( arguments ) ) );

+ now: Date.now,

+ // jQuery.support is not used in Core but other projects attach their

+ // properties to it so it needs to exist.

+ support: support

+

+ // Support: iOS 8.2 (not reproducible in simulator)

+ // `in` check used to prevent JIT error (gh-2145)

+ // hasOwn isn't used here due to false negatives

+ // regarding Nodelist length in IE

+ var length = "length" in obj && obj.length,

+ if ( type === "function" || jQuery.isWindow( obj ) ) {

+ return type === "array" || length === 0 ||

+ typeof length === "number" && length > 0 && ( length - 1 ) in obj;

+var Sizzle =

+ * Sizzle CSS Selector Engine v2.2.0-pre

+ * Copyright 2008, 2014 jQuery Foundation, Inc. and other contributors

+ * Date: 2014-12-16

+(function( window ) {

+ tokenize,

+ select,

+ hasDuplicate,

+ expando = "sizzle" + 1 * new Date(),

+ // Use a stripped-down indexOf as it's faster than native

+ // http://jsperf.com/thor-indexof-vs-for/5

+ indexOf = function( list, elem ) {

+ len = list.length;

+ if ( list[i] === elem ) {

+ // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors

+ attributes = "\\[" + whitespace + "*(" + characterEncoding + ")(?:" + whitespace +

+ // Operator (capture 2)

+ "*([*^$|!~]?=)" + whitespace +

+ // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"

+ "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +

+ "*\\]",

+

+ pseudos = ":(" + characterEncoding + ")(?:\\((" +

+ // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:

+ // 1. quoted (capture 3; capture 4 or capture 5)

+ "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +

+ // 2. simple (capture 6)

+ "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +

+ // 3. anything else (capture 2)

+ ".*" +

+ ")\\)|)",

+ rwhitespace = new RegExp( whitespace + "+", "g" ),

+ rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),

+ rinputs = /^(?:input|select|textarea|button)$/i,

+ rheader = /^h\d$/i,

+

+ rsibling = /[+~]/,

+ // Support: Firefox<24

+ // BMP codepoint

+ },

+

+ // Used for iframes

+ // See setDocument()

+ // Removing the function wrapper causes a "Permission Denied"

+ // error in IE

+ unloadHandler = function() {

+ setDocument();

+ nodeType = context.nodeType;

+ if ( typeof selector !== "string" || !selector ||

+ nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {

+ return results;

+ if ( !seed && documentIsHTML ) {

+ // Try to shortcut find operations when possible (e.g., not under DocumentFragment)

+ if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {

+ // nodes that are no longer in the document (jQuery #6963)

+ } else if ( (m = match[3]) && support.getElementsByClassName ) {

+ newSelector = nodeType !== 1 && selector;

+ newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context;

+ if ( keys.push( key + " " ) > Expr.cacheLength ) {

+ return (cache[ key + " " ] = value);

+ * Checks a node for validity as a Sizzle context

+ * @param {Element|Object=} context

+ * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value

+ */

+function testContext( context ) {

+ return context && typeof context.getElementsByTagName !== "undefined" && context;

+}

+

+// Expose support vars for convenience

+support = Sizzle.support = {};

+

+/**

+ * Detects XML nodes

+ * @returns {Boolean} True iff elem is a non-HTML XML node

+ var hasCompare, parent,

+ doc = node ? node.ownerDocument || node : preferredDoc;

+ parent = doc.defaultView;

+ if ( parent && parent !== parent.top ) {

+ // IE11 does not have attachEvent, so all must suffer

+ if ( parent.addEventListener ) {

+ parent.addEventListener( "unload", unloadHandler, false );

+ } else if ( parent.attachEvent ) {

+ parent.attachEvent( "onunload", unloadHandler );

+ }

+ /* Support tests

+ ---------------------------------------------------------------------- */

+ documentIsHTML = !isXML( doc );

+

+ // Verify that getAttribute really returns attributes and not properties

+ // (excepting IE8 booleans)

+ // Support: IE<9

+ support.getElementsByClassName = rnative.test( doc.getElementsByClassName );

+ if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {

+ return m && m.parentNode ? [ m ] : [];

+ var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");

+ if ( typeof context.getElementsByTagName !== "undefined" ) {

+

+ // DocumentFragment nodes don't have gEBTN

+ } else if ( support.qsa ) {

+ return context.querySelectorAll( tag );

+

+ // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too

+ if ( documentIsHTML ) {

+ docElem.appendChild( div ).innerHTML = "<a id='" + expando + "'></a>" +

+ "<select id='" + expando + "-\f]' msallowcapture=''>" +

+ "<option selected=''></option></select>";

+

+ // Support: IE8, Opera 11-12.16

+ // Nothing should be selected when empty strings follow ^= or $= or *=

+ // The test attribute must be unknown in Opera but "safe" for WinRT

+ // http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section

+ if ( div.querySelectorAll("[msallowcapture^='']").length ) {

+ rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );

+ }

+ // Support: Chrome<29, Android<4.2+, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.7+

+ if ( !div.querySelectorAll( "[id~=" + expando + "-]" ).length ) {

+ rbuggyQSA.push("~=");

+ }

+

+

+ // Support: Safari 8+, iOS 8+

+ // https://bugs.webkit.org/show_bug.cgi?id=136851

+ // In-page `selector#id sibing-combinator selector` fails

+ if ( !div.querySelectorAll( "a#" + expando + "+*" ).length ) {

+ rbuggyQSA.push(".#.+[+~]");

+ }

+ // The type and name attributes are restricted during .innerHTML assignment

+ div.appendChild( input ).setAttribute( "name", "D" );

+ // Support: IE8

+ // Enforce case-sensitivity of name attribute

+ if ( div.querySelectorAll("[name=d]").length ) {

+ rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );

+ if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||

+ docElem.webkitMatchesSelector ||

+ hasCompare = rnative.test( docElem.compareDocumentPosition );

+ contains = hasCompare || rnative.test( docElem.contains ) ?

+ sortOrder = hasCompare ?

+ // Sort on method existence if only one input has compareDocumentPosition

+ var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;

+ return compare;

+ }

+ // Calculate position if both inputs belong to the same document

+ compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?

+ a.compareDocumentPosition( b ) :

+

+ // Otherwise we know they are disconnected

+ 1;

+

+ // Disconnected nodes

+ if ( compare & 1 ||

+ (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {

+ // Choose the first element that is related to our preferred document

+ if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {

+ return -1;

+ }

+ if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {

+ return 1;

+ // Maintain original order

+ return sortInput ?

+ ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :

+ 0;

+ return compare & 4 ? -1 : 1;

+ // Exit early if the nodes are identical

+ if ( a === b ) {

+ hasDuplicate = true;

+ return 0;

+ }

+

+ if ( !aup || !bup ) {

+ ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :

+ } catch (e) {}

+ return Sizzle( expr, document, null, [ elem ] ).length > 0;

+ return val !== undefined ?

+ val :

+ null;

+ // Clear input after sorting to release objects

+ // See https://github.com/jquery/sizzle/pull/225

+ sortInput = null;

+

+ while ( (node = elem[i++]) ) {

+ // innerText usage removed for consistency of new lines (jQuery #11153)

+ match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );

+ unquoted = !match[6] && match[2];

+ if ( match[3] ) {

+ match[2] = match[4] || match[5] || "";

+ return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );

+ operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :

+ idx = indexOf( seed, matched[i] );

+ // Don't keep the element (issue #299)

+ input[0] = null;

+ text = text.replace( runescape, funescape );

+ // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),

+ // but not by others (comment: 8; processing instruction: 7; etc.)

+ // nodeType < 6 works because attributes (2) do not appear as children

+ if ( elem.nodeType < 6 ) {

+

+ // Support: IE<8

+ // New HTML5 attribute values (e.g., "search") appear with elem.type === "text"

+ ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );

+tokenize = Sizzle.tokenize = function( selector, parseOnly ) {

+ groups.push( (tokens = []) );

+};

+ var oldCache, outerCache,

+ newCache = [ dirruns, doneName ];

+ if ( (oldCache = outerCache[ dir ]) &&

+ oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {

+

+ // Assign to newCache so results back-propagate to previous elements

+ return (newCache[ 2 ] = oldCache[ 2 ]);

+ // Reuse newcache so results back-propagate to previous elements

+ outerCache[ dir ] = newCache;

+

+ // A match means we're done; a fail means we have to keep checking

+ if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {

+function multipleContexts( selector, contexts, results ) {

+ var i = 0,

+ len = contexts.length;

+ for ( ; i < len; i++ ) {

+ Sizzle( selector, contexts[i], results );

+ }

+ return results;

+}

+

+ (temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {

+ return indexOf( checkContext, elem ) > -1;

+ var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (

+ // Avoid hanging onto element (issue #299)

+ checkContext = null;

+ return ret;

+ var bySet = setMatchers.length > 0,

+ superMatcher = function( seed, context, xml, results, outermost ) {

+ setMatched = [],

+ // We must always have either seed elements or outermost context

+ elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),

+ dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),

+ len = elems.length;

+ // Support: IE<9, Safari

+ // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id

+ for ( ; i !== len && (elem = elems[i]) != null; i++ ) {

+compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {

+ if ( !match ) {

+ match = tokenize( selector );

+ i = match.length;

+ cached = matcherFromTokens( match[i] );

+

+ // Save selector and tokenization

+ cached.selector = selector;

+/**

+ * A low-level selection function that works with Sizzle's compiled

+ * selector functions

+ * @param {String|Function} selector A selector or a pre-compiled

+ * selector function built with Sizzle.compile

+ * @param {Element} context

+ * @param {Array} [results]

+ * @param {Array} [seed] A set of elements to match against

+ */

+select = Sizzle.select = function( selector, context, results, seed ) {

+ compiled = typeof selector === "function" && selector,

+ match = !seed && tokenize( (selector = compiled.selector || selector) );

+

+ results = results || [];

+ // Try to minimize operations if there is no seed and only one group

+ if ( match.length === 1 ) {

+ // Take a shortcut and set the context if the root selector is an ID

+ tokens = match[0] = match[0].slice( 0 );

+ if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&

+ support.getById && context.nodeType === 9 && documentIsHTML &&

+ Expr.relative[ tokens[1].type ] ) {

+ context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];

+ if ( !context ) {

+ return results;

+

+ // Precompiled matchers will still verify ancestry, so step up a level

+ } else if ( compiled ) {

+ context = context.parentNode;

+ selector = selector.slice( tokens.shift().value.length );

+ }

+ // Fetch a seed set for right-to-left matching

+ i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;

+ while ( i-- ) {

+ token = tokens[i];

+ // Abort if we hit a combinator

+ if ( Expr.relative[ (type = token.type) ] ) {

+ break;

+ }

+ if ( (find = Expr.find[ type ]) ) {

+ // Search, expanding context for leading sibling combinators

+ if ( (seed = find(

+ token.matches[0].replace( runescape, funescape ),

+ rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context

+ )) ) {

+

+ // If seed is empty or no tokens remain, we can return early

+ tokens.splice( i, 1 );

+ selector = seed.length && toSelector( tokens );

+ if ( !selector ) {

+ push.apply( results, seed );

+ return results;

+

+ break;

+ // Compile and execute a filtering function if one is not provided

+ ( compiled || compile( selector, match ) )(