--- /dev/null
+/*!
+ * jQuery JavaScript Library v3.6.0
+ * https://jquery.com/
+ *
+ * Includes Sizzle.js
+ * https://sizzlejs.com/
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license
+ * https://jquery.org/license
+ *
+ * Date: 2021-03-02T17:08Z
+ */
+( function( global, factory ) {
+
+ "use strict";
+
+ 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 ) {
+
+// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
+// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
+// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
+// enough that all such attempts are guarded in a try block.
+"use strict";
+
+var arr = [];
+
+var getProto = Object.getPrototypeOf;
+
+var slice = arr.slice;
+
+var flat = arr.flat ? function( array ) {
+ return arr.flat.call( array );
+} : function( array ) {
+ return arr.concat.apply( [], array );
+};
+
+
+var push = arr.push;
+
+var indexOf = arr.indexOf;
+
+var class2type = {};
+
+var toString = class2type.toString;
+
+var hasOwn = class2type.hasOwnProperty;
+
+var fnToString = hasOwn.toString;
+
+var ObjectFunctionString = fnToString.call( Object );
+
+var support = {};
+
+var isFunction = function isFunction( obj ) {
+
+ // Support: Chrome <=57, Firefox <=52
+ // In some browsers, typeof returns "function" for HTML <object> elements
+ // (i.e., `typeof document.createElement( "object" ) === "function"`).
+ // We don't want to classify *any* DOM node as a function.
+ // Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5
+ // Plus for old WebKit, typeof returns "function" for HTML collections
+ // (e.g., `typeof document.getElementsByTagName("div") === "function"`). (gh-4756)
+ return typeof obj === "function" && typeof obj.nodeType !== "number" &&
+ typeof obj.item !== "function";
+ };
+
+
+var isWindow = function isWindow( obj ) {
+ return obj != null && obj === obj.window;
+ };
+
+
+var document = window.document;
+
+
+
+ var preservedScriptAttributes = {
+ type: true,
+ src: true,
+ nonce: true,
+ noModule: true
+ };
+
+ function DOMEval( code, node, doc ) {
+ doc = doc || document;
+
+ var i, val,
+ script = doc.createElement( "script" );
+
+ script.text = code;
+ if ( node ) {
+ for ( i in preservedScriptAttributes ) {
+
+ // Support: Firefox 64+, Edge 18+
+ // Some browsers don't support the "nonce" property on scripts.
+ // On the other hand, just using `getAttribute` is not enough as
+ // the `nonce` attribute is reset to an empty string whenever it
+ // becomes browsing-context connected.
+ // See https://github.com/whatwg/html/issues/2369
+ // See https://html.spec.whatwg.org/#nonce-attributes
+ // The `node.getAttribute` check was added for the sake of
+ // `jQuery.globalEval` so that it can fake a nonce-containing node
+ // via an object.
+ val = node[ i ] || node.getAttribute && node.getAttribute( i );
+ if ( val ) {
+ script.setAttribute( i, val );
+ }
+ }
+ }
+ doc.head.appendChild( script ).parentNode.removeChild( script );
+ }
+
+
+function toType( obj ) {
+ if ( obj == null ) {
+ return obj + "";
+ }
+
+ // Support: Android <=2.3 only (functionish RegExp)
+ return typeof obj === "object" || typeof obj === "function" ?
+ class2type[ toString.call( obj ) ] || "object" :
+ typeof obj;
+}
+/* global Symbol */
+// Defining this global in .eslintrc.json would create a danger of using the global
+// unguarded in another place, it seems safer to define global only for this module
+
+
+
+var
+ version = "3.6.0",
+
+ // Define a local copy of jQuery
+ jQuery = function( selector, context ) {
+
+ // The jQuery object is actually just the init constructor 'enhanced'
+ // Need init if jQuery is called (just allow error to be thrown if not included)
+ return new jQuery.fn.init( selector, context );
+ };
+
+jQuery.fn = jQuery.prototype = {
+
+ // The current version of jQuery being used
+ jquery: version,
+
+ constructor: jQuery,
+
+ // The default length of a jQuery object is 0
+ length: 0,
+
+ toArray: function() {
+ return slice.call( this );
+ },
+
+ // Get the Nth element in the matched element set OR
+ // Get the whole matched element set as a clean array
+ get: function( num ) {
+
+ // Return all the elements in a clean array
+ if ( num == null ) {
+ return slice.call( this );
+ }
+
+ // Return just the one element from the set
+ return num < 0 ? this[ num + this.length ] : this[ num ];
+ },
+
+ // Take an array of elements and push it onto the stack
+ // (returning the new matched element set)
+ pushStack: function( elems ) {
+
+ // Build a new jQuery matched element set
+ var ret = jQuery.merge( this.constructor(), elems );
+
+ // Add the old object onto the stack (as a reference)
+ ret.prevObject = this;
+
+ // Return the newly-formed element set
+ return ret;
+ },
+
+ // Execute a callback for every element in the matched set.
+ each: function( callback ) {
+ return jQuery.each( this, callback );
+ },
+
+ map: function( callback ) {
+ return this.pushStack( jQuery.map( this, function( elem, i ) {
+ return callback.call( elem, i, elem );
+ } ) );
+ },
+
+ slice: function() {
+ return this.pushStack( slice.apply( this, arguments ) );
+ },
+
+ first: function() {
+ return this.eq( 0 );
+ },
+
+ last: function() {
+ return this.eq( -1 );
+ },
+
+ even: function() {
+ return this.pushStack( jQuery.grep( this, function( _elem, i ) {
+ return ( i + 1 ) % 2;
+ } ) );
+ },
+
+ odd: function() {
+ return this.pushStack( jQuery.grep( this, function( _elem, i ) {
+ return i % 2;
+ } ) );
+ },
+
+ eq: function( i ) {
+ var len = this.length,
+ j = +i + ( i < 0 ? len : 0 );
+ return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
+ },
+
+ end: function() {
+ return this.prevObject || this.constructor();
+ },
+
+ // For internal use only.
+ // Behaves like an Array's method, not like a jQuery method.
+ push: push,
+ sort: arr.sort,
+ splice: arr.splice
+};
+
+jQuery.extend = jQuery.fn.extend = function() {
+ var options, name, src, copy, copyIsArray, clone,
+ target = arguments[ 0 ] || {},
+ i = 1,
+ length = arguments.length,
+ deep = false;
+
+ // Handle a deep copy situation
+ if ( typeof target === "boolean" ) {
+ deep = target;
+
+ // Skip the boolean and the target
+ target = arguments[ i ] || {};
+ i++;
+ }
+
+ // Handle case when target is a string or something (possible in deep copy)
+ if ( typeof target !== "object" && !isFunction( target ) ) {
+ target = {};
+ }
+
+ // Extend jQuery itself if only one argument is passed
+ if ( i === length ) {
+ target = this;
+ i--;
+ }
+
+ for ( ; i < length; i++ ) {
+
+ // Only deal with non-null/undefined values
+ if ( ( options = arguments[ i ] ) != null ) {
+
+ // Extend the base object
+ for ( name in options ) {
+ copy = options[ name ];
+
+ // Prevent Object.prototype pollution
+ // Prevent never-ending loop
+ if ( name === "__proto__" || target === copy ) {
+ continue;
+ }
+
+ // Recurse if we're merging plain objects or arrays
+ if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
+ ( copyIsArray = Array.isArray( copy ) ) ) ) {
+ src = target[ name ];
+
+ // Ensure proper type for the source value
+ if ( copyIsArray && !Array.isArray( src ) ) {
+ clone = [];
+ } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
+ clone = {};
+ } else {
+ clone = src;
+ }
+ copyIsArray = false;
+
+ // Never move original objects, clone them
+ target[ name ] = jQuery.extend( deep, clone, copy );
+
+ // Don't bring in undefined values
+ } else if ( copy !== undefined ) {
+ target[ name ] = copy;
+ }
+ }
+ }
+ }
+
+ // Return the modified object
+ return target;
+};
+
+jQuery.extend( {
+
+ // Unique for each copy of jQuery on the page
+ 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() {},
+
+ isPlainObject: function( obj ) {
+ var proto, Ctor;
+
+ // Detect obvious negatives
+ // Use toString instead of jQuery.type to catch host objects
+ if ( !obj || toString.call( obj ) !== "[object Object]" ) {
+ return false;
+ }
+
+ proto = getProto( obj );
+
+ // Objects with no prototype (e.g., `Object.create( null )`) are plain
+ if ( !proto ) {
+ return true;
+ }
+
+ // Objects with prototype are plain iff they were constructed by a global Object function
+ Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
+ return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
+ },
+
+ isEmptyObject: function( obj ) {
+ var name;
+
+ for ( name in obj ) {
+ return false;
+ }
+ return true;
+ },
+
+ // Evaluates a script in a provided context; falls back to the global one
+ // if not specified.
+ globalEval: function( code, options, doc ) {
+ DOMEval( code, { nonce: options && options.nonce }, doc );
+ },
+
+ each: function( obj, callback ) {
+ var length, i = 0;
+
+ if ( isArrayLike( obj ) ) {
+ length = obj.length;
+ for ( ; i < length; i++ ) {
+ if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
+ break;
+ }
+ }
+ } else {
+ for ( i in obj ) {
+ if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
+ break;
+ }
+ }
+ }
+
+ return obj;
+ },
+
+ // results is for internal usage only
+ makeArray: function( arr, results ) {
+ var ret = results || [];
+
+ if ( arr != null ) {
+ if ( isArrayLike( Object( arr ) ) ) {
+ jQuery.merge( ret,
+ typeof arr === "string" ?
+ [ arr ] : arr
+ );
+ } else {
+ push.call( ret, arr );
+ }
+ }
+
+ return ret;
+ },
+
+ inArray: function( elem, arr, i ) {
+ return arr == null ? -1 : indexOf.call( arr, elem, i );
+ },
+
+ // Support: Android <=4.0 only, PhantomJS 1 only
+ // push.apply(_, arraylike) throws on ancient WebKit
+ merge: function( first, second ) {
+ var len = +second.length,
+ j = 0,
+ i = first.length;
+
+ for ( ; j < len; j++ ) {
+ first[ i++ ] = second[ j ];
+ }
+
+ first.length = i;
+
+ return first;
+ },
+
+ grep: function( elems, callback, invert ) {
+ var callbackInverse,
+ matches = [],
+ i = 0,
+ length = elems.length,
+ callbackExpect = !invert;
+
+ // Go through the array, only saving the items
+ // that pass the validator function
+ for ( ; i < length; i++ ) {
+ callbackInverse = !callback( elems[ i ], i );
+ if ( callbackInverse !== callbackExpect ) {
+ matches.push( elems[ i ] );
+ }
+ }
+
+ return matches;
+ },
+
+ // arg is for internal usage only
+ map: function( elems, callback, arg ) {
+ var length, value,
+ i = 0,
+ ret = [];
+
+ // Go through the array, translating each of the items to their new values
+ if ( isArrayLike( elems ) ) {
+ length = elems.length;
+ for ( ; i < length; i++ ) {
+ value = callback( elems[ i ], i, arg );
+
+ if ( value != null ) {
+ ret.push( value );
+ }
+ }
+
+ // Go through every key on the object,
+ } else {
+ for ( i in elems ) {
+ value = callback( elems[ i ], i, arg );
+
+ if ( value != null ) {
+ ret.push( value );
+ }
+ }
+ }
+
+ // Flatten any nested arrays
+ return flat( ret );
+ },
+
+ // A global GUID counter for objects
+ guid: 1,
+
+ // jQuery.support is not used in Core but other projects attach their
+ // properties to it so it needs to exist.
+ support: support
+} );
+
+if ( typeof Symbol === "function" ) {
+ jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
+}
+
+// Populate the class2type map
+jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
+ function( _i, name ) {
+ class2type[ "[object " + name + "]" ] = name.toLowerCase();
+ } );
+
+function isArrayLike( obj ) {
+
+ // Support: real iOS 8.2 only (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 = !!obj && "length" in obj && obj.length,
+ type = toType( obj );
+
+ if ( isFunction( obj ) || isWindow( obj ) ) {
+ return false;
+ }
+
+ return type === "array" || length === 0 ||
+ typeof length === "number" && length > 0 && ( length - 1 ) in obj;
+}
+var Sizzle =
+/*!
+ * Sizzle CSS Selector Engine v2.3.6
+ * https://sizzlejs.com/
+ *
+ * Copyright JS Foundation and other contributors
+ * Released under the MIT license
+ * https://js.foundation/
+ *
+ * Date: 2021-02-16
+ */
+( function( window ) {
+var i,
+ support,
+ Expr,
+ getText,
+ isXML,
+ tokenize,
+ compile,
+ select,
+ outermostContext,
+ sortInput,
+ hasDuplicate,
+
+ // Local document vars
+ setDocument,
+ document,
+ docElem,
+ documentIsHTML,
+ rbuggyQSA,
+ rbuggyMatches,
+ matches,
+ contains,
+
+ // Instance-specific data
+ expando = "sizzle" + 1 * new Date(),
+ preferredDoc = window.document,
+ dirruns = 0,
+ done = 0,
+ classCache = createCache(),
+ tokenCache = createCache(),
+ compilerCache = createCache(),
+ nonnativeSelectorCache = createCache(),
+ sortOrder = function( a, b ) {
+ if ( a === b ) {
+ hasDuplicate = true;
+ }
+ return 0;
+ },
+
+ // Instance methods
+ hasOwn = ( {} ).hasOwnProperty,
+ arr = [],
+ pop = arr.pop,
+ pushNative = arr.push,
+ push = arr.push,
+ slice = arr.slice,
+
+ // Use a stripped-down indexOf as it's faster than native
+ // https://jsperf.com/thor-indexof-vs-for/5
+ indexOf = function( list, elem ) {
+ var i = 0,
+ len = list.length;
+ for ( ; i < len; i++ ) {
+ if ( list[ i ] === elem ) {
+ return i;
+ }
+ }
+ return -1;
+ },
+
+ booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" +
+ "ismap|loop|multiple|open|readonly|required|scoped",
+
+ // Regular expressions
+
+ // http://www.w3.org/TR/css3-selectors/#whitespace
+ whitespace = "[\\x20\\t\\r\\n\\f]",
+
+ // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
+ identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
+ "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
+
+ // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
+ attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
+
+ // Operator (capture 2)
+ "*([*^$|!~]?=)" + whitespace +
+
+ // "Attribute values must be CSS identifiers [capture 5]
+ // or strings [capture 3 or capture 4]"
+ "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
+ whitespace + "*\\]",
+
+ pseudos = ":(" + identifier + ")(?:\\((" +
+
+ // 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)
+ ".*" +
+ ")\\)|)",
+
+ // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
+ rwhitespace = new RegExp( whitespace + "+", "g" ),
+ rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" +
+ whitespace + "+$", "g" ),
+
+ rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
+ rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace +
+ "*" ),
+ rdescend = new RegExp( whitespace + "|>" ),
+
+ rpseudo = new RegExp( pseudos ),
+ ridentifier = new RegExp( "^" + identifier + "$" ),
+
+ matchExpr = {
+ "ID": new RegExp( "^#(" + identifier + ")" ),
+ "CLASS": new RegExp( "^\\.(" + identifier + ")" ),
+ "TAG": new RegExp( "^(" + identifier + "|[*])" ),
+ "ATTR": new RegExp( "^" + attributes ),
+ "PSEUDO": new RegExp( "^" + pseudos ),
+ "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
+ whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
+ whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
+ "bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
+
+ // For use in libraries implementing .is()
+ // We use this for POS matching in `select`
+ "needsContext": new RegExp( "^" + whitespace +
+ "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
+ "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
+ },
+
+ rhtml = /HTML$/i,
+ rinputs = /^(?:input|select|textarea|button)$/i,
+ rheader = /^h\d$/i,
+
+ rnative = /^[^{]+\{\s*\[native \w/,
+
+ // Easily-parseable/retrievable ID or TAG or CLASS selectors
+ rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
+
+ rsibling = /[+~]/,
+
+ // CSS escapes
+ // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
+ runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ),
+ funescape = function( escape, nonHex ) {
+ var high = "0x" + escape.slice( 1 ) - 0x10000;
+
+ return nonHex ?
+
+ // Strip the backslash prefix from a non-hex escape sequence
+ nonHex :
+
+ // Replace a hexadecimal escape sequence with the encoded Unicode code point
+ // Support: IE <=11+
+ // For values outside the Basic Multilingual Plane (BMP), manually construct a
+ // surrogate pair
+ high < 0 ?
+ String.fromCharCode( high + 0x10000 ) :
+ String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
+ },
+
+ // CSS string/identifier serialization
+ // https://drafts.csswg.org/cssom/#common-serializing-idioms
+ rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
+ fcssescape = function( ch, asCodePoint ) {
+ if ( asCodePoint ) {
+
+ // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
+ if ( ch === "\0" ) {
+ return "\uFFFD";
+ }
+
+ // Control characters and (dependent upon position) numbers get escaped as code points
+ return ch.slice( 0, -1 ) + "\\" +
+ ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
+ }
+
+ // Other potentially-special ASCII characters get backslash-escaped
+ return "\\" + ch;
+ },
+
+ // Used for iframes
+ // See setDocument()
+ // Removing the function wrapper causes a "Permission Denied"
+ // error in IE
+ unloadHandler = function() {
+ setDocument();
+ },
+
+ inDisabledFieldset = addCombinator(
+ function( elem ) {
+ return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
+ },
+ { dir: "parentNode", next: "legend" }
+ );
+
+// Optimize for push.apply( _, NodeList )
+try {
+ push.apply(
+ ( arr = slice.call( preferredDoc.childNodes ) ),
+ preferredDoc.childNodes
+ );
+
+ // Support: Android<4.0
+ // Detect silently failing push.apply
+ // eslint-disable-next-line no-unused-expressions
+ arr[ preferredDoc.childNodes.length ].nodeType;
+} catch ( e ) {
+ push = { apply: arr.length ?
+
+ // Leverage slice if possible
+ function( target, els ) {
+ pushNative.apply( target, slice.call( els ) );
+ } :
+
+ // Support: IE<9
+ // Otherwise append directly
+ function( target, els ) {
+ var j = target.length,
+ i = 0;
+
+ // Can't trust NodeList.length
+ while ( ( target[ j++ ] = els[ i++ ] ) ) {}
+ target.length = j - 1;
+ }
+ };
+}
+
+function Sizzle( selector, context, results, seed ) {
+ var m, i, elem, nid, match, groups, newSelector,
+ newContext = context && context.ownerDocument,
+
+ // nodeType defaults to 9, since context defaults to document
+ nodeType = context ? context.nodeType : 9;
+
+ results = results || [];
+
+ // Return early from calls with invalid selector or context
+ if ( typeof selector !== "string" || !selector ||
+ nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
+
+ return results;
+ }
+
+ // Try to shortcut find operations (as opposed to filters) in HTML documents
+ if ( !seed ) {
+ setDocument( context );
+ context = context || document;
+
+ if ( documentIsHTML ) {
+
+ // If the selector is sufficiently simple, try using a "get*By*" DOM method
+ // (excepting DocumentFragment context, where the methods don't exist)
+ if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
+
+ // ID selector
+ if ( ( m = match[ 1 ] ) ) {
+
+ // Document context
+ if ( nodeType === 9 ) {
+ if ( ( elem = context.getElementById( m ) ) ) {
+
+ // Support: IE, Opera, Webkit
+ // TODO: identify versions
+ // getElementById can match elements by name instead of ID
+ if ( elem.id === m ) {
+ results.push( elem );
+ return results;
+ }
+ } else {
+ return results;
+ }
+
+ // Element context
+ } else {
+
+ // Support: IE, Opera, Webkit
+ // TODO: identify versions
+ // getElementById can match elements by name instead of ID
+ if ( newContext && ( elem = newContext.getElementById( m ) ) &&
+ contains( context, elem ) &&
+ elem.id === m ) {
+
+ results.push( elem );
+ return results;
+ }
+ }
+
+ // Type selector
+ } else if ( match[ 2 ] ) {
+ push.apply( results, context.getElementsByTagName( selector ) );
+ return results;
+
+ // Class selector
+ } else if ( ( m = match[ 3 ] ) && support.getElementsByClassName &&
+ context.getElementsByClassName ) {
+
+ push.apply( results, context.getElementsByClassName( m ) );
+ return results;
+ }
+ }
+
+ // Take advantage of querySelectorAll
+ if ( support.qsa &&
+ !nonnativeSelectorCache[ selector + " " ] &&
+ ( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&
+
+ // Support: IE 8 only
+ // Exclude object elements
+ ( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) {
+
+ newSelector = selector;
+ newContext = context;
+
+ // qSA considers elements outside a scoping root when evaluating child or
+ // descendant combinators, which is not what we want.
+ // In such cases, we work around the behavior by prefixing every selector in the
+ // list with an ID selector referencing the scope context.
+ // The technique has to be used as well when a leading combinator is used
+ // as such selectors are not recognized by querySelectorAll.
+ // Thanks to Andrew Dupont for this technique.
+ if ( nodeType === 1 &&
+ ( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {
+
+ // Expand context for sibling selectors
+ newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
+ context;
+
+ // We can use :scope instead of the ID hack if the browser
+ // supports it & if we're not changing the context.
+ if ( newContext !== context || !support.scope ) {
+
+ // Capture the context ID, setting it first if necessary
+ if ( ( nid = context.getAttribute( "id" ) ) ) {
+ nid = nid.replace( rcssescape, fcssescape );
+ } else {
+ context.setAttribute( "id", ( nid = expando ) );
+ }
+ }
+
+ // Prefix every selector in the list
+ groups = tokenize( selector );
+ i = groups.length;
+ while ( i-- ) {
+ groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
+ toSelector( groups[ i ] );
+ }
+ newSelector = groups.join( "," );
+ }
+
+ try {
+ push.apply( results,
+ newContext.querySelectorAll( newSelector )
+ );
+ return results;
+ } catch ( qsaError ) {
+ nonnativeSelectorCache( selector, true );
+ } finally {
+ if ( nid === expando ) {
+ context.removeAttribute( "id" );
+ }
+ }
+ }
+ }
+ }
+
+ // All others
+ return select( selector.replace( rtrim, "$1" ), context, results, seed );
+}
+
+/**
+ * Create key-value caches of limited size
+ * @returns {function(string, object)} Returns the Object data after storing it on itself with
+ * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
+ * deleting the oldest entry
+ */
+function createCache() {
+ var keys = [];
+
+ function cache( key, value ) {
+
+ // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
+ if ( keys.push( key + " " ) > Expr.cacheLength ) {
+
+ // Only keep the most recent entries
+ delete cache[ keys.shift() ];
+ }
+ return ( cache[ key + " " ] = value );
+ }
+ return cache;
+}
+
+/**
+ * Mark a function for special use by Sizzle
+ * @param {Function} fn The function to mark
+ */
+function markFunction( fn ) {
+ fn[ expando ] = true;
+ return fn;
+}
+
+/**
+ * Support testing using an element
+ * @param {Function} fn Passed the created element and returns a boolean result
+ */
+function assert( fn ) {
+ var el = document.createElement( "fieldset" );
+
+ try {
+ return !!fn( el );
+ } catch ( e ) {
+ return false;
+ } finally {
+
+ // Remove from its parent by default
+ if ( el.parentNode ) {
+ el.parentNode.removeChild( el );
+ }
+
+ // release memory in IE
+ el = null;
+ }
+}
+
+/**
+ * Adds the same handler for all of the specified attrs
+ * @param {String} attrs Pipe-separated list of attributes
+ * @param {Function} handler The method that will be applied
+ */
+function addHandle( attrs, handler ) {
+ var arr = attrs.split( "|" ),
+ i = arr.length;
+
+ while ( i-- ) {
+ Expr.attrHandle[ arr[ i ] ] = handler;
+ }
+}
+
+/**
+ * Checks document order of two siblings
+ * @param {Element} a
+ * @param {Element} b
+ * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
+ */
+function siblingCheck( a, b ) {
+ var cur = b && a,
+ diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
+ a.sourceIndex - b.sourceIndex;
+
+ // Use IE sourceIndex if available on both nodes
+ if ( diff ) {
+ return diff;
+ }
+
+ // Check if b follows a
+ if ( cur ) {
+ while ( ( cur = cur.nextSibling ) ) {
+ if ( cur === b ) {
+ return -1;
+ }
+ }
+ }
+
+ return a ? 1 : -1;
+}
+
+/**
+ * Returns a function to use in pseudos for input types
+ * @param {String} type
+ */
+function createInputPseudo( type ) {
+ return function( elem ) {
+ var name = elem.nodeName.toLowerCase();
+ return name === "input" && elem.type === type;
+ };
+}
+
+/**
+ * Returns a function to use in pseudos for buttons
+ * @param {String} type
+ */
+function createButtonPseudo( type ) {
+ return function( elem ) {
+ var name = elem.nodeName.toLowerCase();
+ return ( name === "input" || name === "button" ) && elem.type === type;
+ };
+}
+
+/**
+ * Returns a function to use in pseudos for :enabled/:disabled
+ * @param {Boolean} disabled true for :disabled; false for :enabled
+ */
+function createDisabledPseudo( disabled ) {
+
+ // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
+ return function( elem ) {
+
+ // Only certain elements can match :enabled or :disabled
+ // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
+ // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
+ if ( "form" in elem ) {
+
+ // Check for inherited disabledness on relevant non-disabled elements:
+ // * listed form-associated elements in a disabled fieldset
+ // https://html.spec.whatwg.org/multipage/forms.html#category-listed
+ // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
+ // * option elements in a disabled optgroup
+ // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
+ // All such elements have a "form" property.
+ if ( elem.parentNode && elem.disabled === false ) {
+
+ // Option elements defer to a parent optgroup if present
+ if ( "label" in elem ) {
+ if ( "label" in elem.parentNode ) {
+ return elem.parentNode.disabled === disabled;
+ } else {
+ return elem.disabled === disabled;
+ }
+ }
+
+ // Support: IE 6 - 11
+ // Use the isDisabled shortcut property to check for disabled fieldset ancestors
+ return elem.isDisabled === disabled ||
+
+ // Where there is no isDisabled, check manually
+ /* jshint -W018 */
+ elem.isDisabled !== !disabled &&
+ inDisabledFieldset( elem ) === disabled;
+ }
+
+ return elem.disabled === disabled;
+
+ // Try to winnow out elements that can't be disabled before trusting the disabled property.
+ // Some victims get caught in our net (label, legend, menu, track), but it shouldn't
+ // even exist on them, let alone have a boolean value.
+ } else if ( "label" in elem ) {
+ return elem.disabled === disabled;
+ }
+
+ // Remaining elements are neither :enabled nor :disabled
+ return false;
+ };
+}
+
+/**
+ * Returns a function to use in pseudos for positionals
+ * @param {Function} fn
+ */
+function createPositionalPseudo( fn ) {
+ return markFunction( function( argument ) {
+ argument = +argument;
+ return markFunction( function( seed, matches ) {
+ var j,
+ matchIndexes = fn( [], seed.length, argument ),
+ i = matchIndexes.length;
+
+ // Match elements found at the specified indexes
+ while ( i-- ) {
+ if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
+ seed[ j ] = !( matches[ j ] = seed[ j ] );
+ }
+ }
+ } );
+ } );
+}
+
+/**
+ * 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
+ * @param {Element|Object} elem An element or a document
+ * @returns {Boolean} True iff elem is a non-HTML XML node
+ */
+isXML = Sizzle.isXML = function( elem ) {
+ var namespace = elem && elem.namespaceURI,
+ docElem = elem && ( elem.ownerDocument || elem ).documentElement;
+
+ // Support: IE <=8
+ // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes
+ // https://bugs.jquery.com/ticket/4833
+ return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" );
+};
+
+/**
+ * Sets document-related variables once based on the current document
+ * @param {Element|Object} [doc] An element or document object to use to set the document
+ * @returns {Object} Returns the current document
+ */
+setDocument = Sizzle.setDocument = function( node ) {
+ var hasCompare, subWindow,
+ doc = node ? node.ownerDocument || node : preferredDoc;
+
+ // Return early if doc is invalid or already selected
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {
+ return document;
+ }
+
+ // Update global variables
+ document = doc;
+ docElem = document.documentElement;
+ documentIsHTML = !isXML( document );
+
+ // Support: IE 9 - 11+, Edge 12 - 18+
+ // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ if ( preferredDoc != document &&
+ ( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
+
+ // Support: IE 11, Edge
+ if ( subWindow.addEventListener ) {
+ subWindow.addEventListener( "unload", unloadHandler, false );
+
+ // Support: IE 9 - 10 only
+ } else if ( subWindow.attachEvent ) {
+ subWindow.attachEvent( "onunload", unloadHandler );
+ }
+ }
+
+ // Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,
+ // Safari 4 - 5 only, Opera <=11.6 - 12.x only
+ // IE/Edge & older browsers don't support the :scope pseudo-class.
+ // Support: Safari 6.0 only
+ // Safari 6.0 supports :scope but it's an alias of :root there.
+ support.scope = assert( function( el ) {
+ docElem.appendChild( el ).appendChild( document.createElement( "div" ) );
+ return typeof el.querySelectorAll !== "undefined" &&
+ !el.querySelectorAll( ":scope fieldset div" ).length;
+ } );
+
+ /* Attributes
+ ---------------------------------------------------------------------- */
+
+ // Support: IE<8
+ // Verify that getAttribute really returns attributes and not properties
+ // (excepting IE8 booleans)
+ support.attributes = assert( function( el ) {
+ el.className = "i";
+ return !el.getAttribute( "className" );
+ } );
+
+ /* getElement(s)By*
+ ---------------------------------------------------------------------- */
+
+ // Check if getElementsByTagName("*") returns only elements
+ support.getElementsByTagName = assert( function( el ) {
+ el.appendChild( document.createComment( "" ) );
+ return !el.getElementsByTagName( "*" ).length;
+ } );
+
+ // Support: IE<9
+ support.getElementsByClassName = rnative.test( document.getElementsByClassName );
+
+ // Support: IE<10
+ // Check if getElementById returns elements by name
+ // The broken getElementById methods don't pick up programmatically-set names,
+ // so use a roundabout getElementsByName test
+ support.getById = assert( function( el ) {
+ docElem.appendChild( el ).id = expando;
+ return !document.getElementsByName || !document.getElementsByName( expando ).length;
+ } );
+
+ // ID filter and find
+ if ( support.getById ) {
+ Expr.filter[ "ID" ] = function( id ) {
+ var attrId = id.replace( runescape, funescape );
+ return function( elem ) {
+ return elem.getAttribute( "id" ) === attrId;
+ };
+ };
+ Expr.find[ "ID" ] = function( id, context ) {
+ if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
+ var elem = context.getElementById( id );
+ return elem ? [ elem ] : [];
+ }
+ };
+ } else {
+ Expr.filter[ "ID" ] = function( id ) {
+ var attrId = id.replace( runescape, funescape );
+ return function( elem ) {
+ var node = typeof elem.getAttributeNode !== "undefined" &&
+ elem.getAttributeNode( "id" );
+ return node && node.value === attrId;
+ };
+ };
+
+ // Support: IE 6 - 7 only
+ // getElementById is not reliable as a find shortcut
+ Expr.find[ "ID" ] = function( id, context ) {
+ if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
+ var node, i, elems,
+ elem = context.getElementById( id );
+
+ if ( elem ) {
+
+ // Verify the id attribute
+ node = elem.getAttributeNode( "id" );
+ if ( node && node.value === id ) {
+ return [ elem ];
+ }
+
+ // Fall back on getElementsByName
+ elems = context.getElementsByName( id );
+ i = 0;
+ while ( ( elem = elems[ i++ ] ) ) {
+ node = elem.getAttributeNode( "id" );
+ if ( node && node.value === id ) {
+ return [ elem ];
+ }
+ }
+ }
+
+ return [];
+ }
+ };
+ }
+
+ // Tag
+ Expr.find[ "TAG" ] = support.getElementsByTagName ?
+ function( tag, context ) {
+ if ( typeof context.getElementsByTagName !== "undefined" ) {
+ return context.getElementsByTagName( tag );
+
+ // DocumentFragment nodes don't have gEBTN
+ } else if ( support.qsa ) {
+ return context.querySelectorAll( tag );
+ }
+ } :
+
+ function( tag, context ) {
+ var elem,
+ tmp = [],
+ i = 0,
+
+ // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
+ results = context.getElementsByTagName( tag );
+
+ // Filter out possible comments
+ if ( tag === "*" ) {
+ while ( ( elem = results[ i++ ] ) ) {
+ if ( elem.nodeType === 1 ) {
+ tmp.push( elem );
+ }
+ }
+
+ return tmp;
+ }
+ return results;
+ };
+
+ // Class
+ Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) {
+ if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
+ return context.getElementsByClassName( className );
+ }
+ };
+
+ /* QSA/matchesSelector
+ ---------------------------------------------------------------------- */
+
+ // QSA and matchesSelector support
+
+ // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
+ rbuggyMatches = [];
+
+ // qSa(:focus) reports false when true (Chrome 21)
+ // We allow this because of a bug in IE8/9 that throws an error
+ // whenever `document.activeElement` is accessed on an iframe
+ // So, we allow :focus to pass through QSA all the time to avoid the IE error
+ // See https://bugs.jquery.com/ticket/13378
+ rbuggyQSA = [];
+
+ if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {
+
+ // Build QSA regex
+ // Regex strategy adopted from Diego Perini
+ assert( function( el ) {
+
+ var input;
+
+ // Select is set to empty string on purpose
+ // This is to test IE's treatment of not explicitly
+ // setting a boolean content attribute,
+ // since its presence should be enough
+ // https://bugs.jquery.com/ticket/12359
+ docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
+ "<select id='" + expando + "-\r\\' 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
+ // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
+ if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) {
+ rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
+ }
+
+ // Support: IE8
+ // Boolean attributes and "value" are not treated correctly
+ if ( !el.querySelectorAll( "[selected]" ).length ) {
+ rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
+ }
+
+ // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
+ if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
+ rbuggyQSA.push( "~=" );
+ }
+
+ // Support: IE 11+, Edge 15 - 18+
+ // IE 11/Edge don't find elements on a `[name='']` query in some cases.
+ // Adding a temporary attribute to the document before the selection works
+ // around the issue.
+ // Interestingly, IE 10 & older don't seem to have the issue.
+ input = document.createElement( "input" );
+ input.setAttribute( "name", "" );
+ el.appendChild( input );
+ if ( !el.querySelectorAll( "[name='']" ).length ) {
+ rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" +
+ whitespace + "*(?:''|\"\")" );
+ }
+
+ // Webkit/Opera - :checked should return selected option elements
+ // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
+ // IE8 throws error here and will not see later tests
+ if ( !el.querySelectorAll( ":checked" ).length ) {
+ rbuggyQSA.push( ":checked" );
+ }
+
+ // Support: Safari 8+, iOS 8+
+ // https://bugs.webkit.org/show_bug.cgi?id=136851
+ // In-page `selector#id sibling-combinator selector` fails
+ if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
+ rbuggyQSA.push( ".#.+[+~]" );
+ }
+
+ // Support: Firefox <=3.6 - 5 only
+ // Old Firefox doesn't throw on a badly-escaped identifier.
+ el.querySelectorAll( "\\\f" );
+ rbuggyQSA.push( "[\\r\\n\\f]" );
+ } );
+
+ assert( function( el ) {
+ el.innerHTML = "<a href='' disabled='disabled'></a>" +
+ "<select disabled='disabled'><option/></select>";
+
+ // Support: Windows 8 Native Apps
+ // The type and name attributes are restricted during .innerHTML assignment
+ var input = document.createElement( "input" );
+ input.setAttribute( "type", "hidden" );
+ el.appendChild( input ).setAttribute( "name", "D" );
+
+ // Support: IE8
+ // Enforce case-sensitivity of name attribute
+ if ( el.querySelectorAll( "[name=d]" ).length ) {
+ rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
+ }
+
+ // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
+ // IE8 throws error here and will not see later tests
+ if ( el.querySelectorAll( ":enabled" ).length !== 2 ) {
+ rbuggyQSA.push( ":enabled", ":disabled" );
+ }
+
+ // Support: IE9-11+
+ // IE's :disabled selector does not pick up the children of disabled fieldsets
+ docElem.appendChild( el ).disabled = true;
+ if ( el.querySelectorAll( ":disabled" ).length !== 2 ) {
+ rbuggyQSA.push( ":enabled", ":disabled" );
+ }
+
+ // Support: Opera 10 - 11 only
+ // Opera 10-11 does not throw on post-comma invalid pseudos
+ el.querySelectorAll( "*,:x" );
+ rbuggyQSA.push( ",.*:" );
+ } );
+ }
+
+ if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches ||
+ docElem.webkitMatchesSelector ||
+ docElem.mozMatchesSelector ||
+ docElem.oMatchesSelector ||
+ docElem.msMatchesSelector ) ) ) ) {
+
+ assert( function( el ) {
+
+ // Check to see if it's possible to do matchesSelector
+ // on a disconnected node (IE 9)
+ support.disconnectedMatch = matches.call( el, "*" );
+
+ // This should fail with an exception
+ // Gecko does not error, returns false instead
+ matches.call( el, "[s!='']:x" );
+ rbuggyMatches.push( "!=", pseudos );
+ } );
+ }
+
+ rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) );
+ rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( "|" ) );
+
+ /* Contains
+ ---------------------------------------------------------------------- */
+ hasCompare = rnative.test( docElem.compareDocumentPosition );
+
+ // Element contains another
+ // Purposefully self-exclusive
+ // As in, an element does not contain itself
+ contains = hasCompare || rnative.test( docElem.contains ) ?
+ function( a, b ) {
+ var adown = a.nodeType === 9 ? a.documentElement : a,
+ bup = b && b.parentNode;
+ return a === bup || !!( bup && bup.nodeType === 1 && (
+ adown.contains ?
+ adown.contains( bup ) :
+ a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
+ ) );
+ } :
+ function( a, b ) {
+ if ( b ) {
+ while ( ( b = b.parentNode ) ) {
+ if ( b === a ) {
+ return true;
+ }
+ }
+ }
+ return false;
+ };
+
+ /* Sorting
+ ---------------------------------------------------------------------- */
+
+ // Document order sorting
+ sortOrder = hasCompare ?
+ function( a, b ) {
+
+ // Flag for duplicate removal
+ if ( a === b ) {
+ hasDuplicate = true;
+ return 0;
+ }
+
+ // Sort on method existence if only one input has compareDocumentPosition
+ var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
+ if ( compare ) {
+ return compare;
+ }
+
+ // Calculate position if both inputs belong to the same document
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ 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
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ if ( a == document || a.ownerDocument == preferredDoc &&
+ contains( preferredDoc, a ) ) {
+ return -1;
+ }
+
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ if ( b == document || 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;
+ } :
+ function( a, b ) {
+
+ // Exit early if the nodes are identical
+ if ( a === b ) {
+ hasDuplicate = true;
+ return 0;
+ }
+
+ var cur,
+ i = 0,
+ aup = a.parentNode,
+ bup = b.parentNode,
+ ap = [ a ],
+ bp = [ b ];
+
+ // Parentless nodes are either documents or disconnected
+ if ( !aup || !bup ) {
+
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ /* eslint-disable eqeqeq */
+ return a == document ? -1 :
+ b == document ? 1 :
+ /* eslint-enable eqeqeq */
+ aup ? -1 :
+ bup ? 1 :
+ sortInput ?
+ ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
+ 0;
+
+ // If the nodes are siblings, we can do a quick check
+ } else if ( aup === bup ) {
+ return siblingCheck( a, b );
+ }
+
+ // Otherwise we need full lists of their ancestors for comparison
+ cur = a;
+ while ( ( cur = cur.parentNode ) ) {
+ ap.unshift( cur );
+ }
+ cur = b;
+ while ( ( cur = cur.parentNode ) ) {
+ bp.unshift( cur );
+ }
+
+ // Walk down the tree looking for a discrepancy
+ while ( ap[ i ] === bp[ i ] ) {
+ i++;
+ }
+
+ return i ?
+
+ // Do a sibling check if the nodes have a common ancestor
+ siblingCheck( ap[ i ], bp[ i ] ) :
+
+ // Otherwise nodes in our document sort first
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ /* eslint-disable eqeqeq */
+ ap[ i ] == preferredDoc ? -1 :
+ bp[ i ] == preferredDoc ? 1 :
+ /* eslint-enable eqeqeq */
+ 0;
+ };
+
+ return document;
+};
+
+Sizzle.matches = function( expr, elements ) {
+ return Sizzle( expr, null, null, elements );
+};
+
+Sizzle.matchesSelector = function( elem, expr ) {
+ setDocument( elem );
+
+ if ( support.matchesSelector && documentIsHTML &&
+ !nonnativeSelectorCache[ expr + " " ] &&
+ ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
+ ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {
+
+ try {
+ var ret = matches.call( elem, expr );
+
+ // IE 9's matchesSelector returns false on disconnected nodes
+ if ( ret || support.disconnectedMatch ||
+
+ // As well, disconnected nodes are said to be in a document
+ // fragment in IE 9
+ elem.document && elem.document.nodeType !== 11 ) {
+ return ret;
+ }
+ } catch ( e ) {
+ nonnativeSelectorCache( expr, true );
+ }
+ }
+
+ return Sizzle( expr, document, null, [ elem ] ).length > 0;
+};
+
+Sizzle.contains = function( context, elem ) {
+
+ // Set document vars if needed
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ if ( ( context.ownerDocument || context ) != document ) {
+ setDocument( context );
+ }
+ return contains( context, elem );
+};
+
+Sizzle.attr = function( elem, name ) {
+
+ // Set document vars if needed
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ if ( ( elem.ownerDocument || elem ) != document ) {
+ setDocument( elem );
+ }
+
+ var fn = Expr.attrHandle[ name.toLowerCase() ],
+
+ // Don't get fooled by Object.prototype properties (jQuery #13807)
+ val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
+ fn( elem, name, !documentIsHTML ) :
+ undefined;
+
+ return val !== undefined ?
+ val :
+ support.attributes || !documentIsHTML ?
+ elem.getAttribute( name ) :
+ ( val = elem.getAttributeNode( name ) ) && val.specified ?
+ val.value :
+ null;
+};
+
+Sizzle.escape = function( sel ) {
+ return ( sel + "" ).replace( rcssescape, fcssescape );
+};
+
+Sizzle.error = function( msg ) {
+ throw new Error( "Syntax error, unrecognized expression: " + msg );
+};
+
+/**
+ * Document sorting and removing duplicates
+ * @param {ArrayLike} results
+ */
+Sizzle.uniqueSort = function( results ) {
+ var elem,
+ duplicates = [],
+ j = 0,
+ i = 0;
+
+ // Unless we *know* we can detect duplicates, assume their presence
+ hasDuplicate = !support.detectDuplicates;
+ sortInput = !support.sortStable && results.slice( 0 );
+ results.sort( sortOrder );
+
+ if ( hasDuplicate ) {
+ while ( ( elem = results[ i++ ] ) ) {
+ if ( elem === results[ i ] ) {
+ j = duplicates.push( i );
+ }
+ }
+ while ( j-- ) {
+ results.splice( duplicates[ j ], 1 );
+ }
+ }
+
+ // Clear input after sorting to release objects
+ // See https://github.com/jquery/sizzle/pull/225
+ sortInput = null;
+
+ return results;
+};
+
+/**
+ * Utility function for retrieving the text value of an array of DOM nodes
+ * @param {Array|Element} elem
+ */
+getText = Sizzle.getText = function( elem ) {
+ var node,
+ ret = "",
+ i = 0,
+ nodeType = elem.nodeType;
+
+ if ( !nodeType ) {
+
+ // If no nodeType, this is expected to be an array
+ while ( ( node = elem[ i++ ] ) ) {
+
+ // Do not traverse comment nodes
+ ret += getText( node );
+ }
+ } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
+
+ // Use textContent for elements
+ // innerText usage removed for consistency of new lines (jQuery #11153)
+ if ( typeof elem.textContent === "string" ) {
+ return elem.textContent;
+ } else {
+
+ // Traverse its children
+ for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
+ ret += getText( elem );
+ }
+ }
+ } else if ( nodeType === 3 || nodeType === 4 ) {
+ return elem.nodeValue;
+ }
+
+ // Do not include comment or processing instruction nodes
+
+ return ret;
+};
+
+Expr = Sizzle.selectors = {
+
+ // Can be adjusted by the user
+ cacheLength: 50,
+
+ createPseudo: markFunction,
+
+ match: matchExpr,
+
+ attrHandle: {},
+
+ find: {},
+
+ relative: {
+ ">": { dir: "parentNode", first: true },
+ " ": { dir: "parentNode" },
+ "+": { dir: "previousSibling", first: true },
+ "~": { dir: "previousSibling" }
+ },
+
+ preFilter: {
+ "ATTR": function( match ) {
+ match[ 1 ] = match[ 1 ].replace( runescape, funescape );
+
+ // Move the given value to match[3] whether quoted or unquoted
+ match[ 3 ] = ( match[ 3 ] || match[ 4 ] ||
+ match[ 5 ] || "" ).replace( runescape, funescape );
+
+ if ( match[ 2 ] === "~=" ) {
+ match[ 3 ] = " " + match[ 3 ] + " ";
+ }
+
+ return match.slice( 0, 4 );
+ },
+
+ "CHILD": function( match ) {
+
+ /* matches from matchExpr["CHILD"]
+ 1 type (only|nth|...)
+ 2 what (child|of-type)
+ 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
+ 4 xn-component of xn+y argument ([+-]?\d*n|)
+ 5 sign of xn-component
+ 6 x of xn-component
+ 7 sign of y-component
+ 8 y of y-component
+ */
+ match[ 1 ] = match[ 1 ].toLowerCase();
+
+ if ( match[ 1 ].slice( 0, 3 ) === "nth" ) {
+
+ // nth-* requires argument
+ if ( !match[ 3 ] ) {
+ Sizzle.error( match[ 0 ] );
+ }
+
+ // numeric x and y parameters for Expr.filter.CHILD
+ // remember that false/true cast respectively to 0/1
+ match[ 4 ] = +( match[ 4 ] ?
+ match[ 5 ] + ( match[ 6 ] || 1 ) :
+ 2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) );
+ match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" );
+
+ // other types prohibit arguments
+ } else if ( match[ 3 ] ) {
+ Sizzle.error( match[ 0 ] );
+ }
+
+ return match;
+ },
+
+ "PSEUDO": function( match ) {
+ var excess,
+ unquoted = !match[ 6 ] && match[ 2 ];
+
+ if ( matchExpr[ "CHILD" ].test( match[ 0 ] ) ) {
+ return null;
+ }
+
+ // Accept quoted arguments as-is
+ if ( match[ 3 ] ) {
+ match[ 2 ] = match[ 4 ] || match[ 5 ] || "";
+
+ // Strip excess characters from unquoted arguments
+ } else if ( unquoted && rpseudo.test( unquoted ) &&
+
+ // Get excess from tokenize (recursively)
+ ( excess = tokenize( unquoted, true ) ) &&
+
+ // advance to the next closing parenthesis
+ ( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) {
+
+ // excess is a negative index
+ match[ 0 ] = match[ 0 ].slice( 0, excess );
+ match[ 2 ] = unquoted.slice( 0, excess );
+ }
+
+ // Return only captures needed by the pseudo filter method (type and argument)
+ return match.slice( 0, 3 );
+ }
+ },
+
+ filter: {
+
+ "TAG": function( nodeNameSelector ) {
+ var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
+ return nodeNameSelector === "*" ?
+ function() {
+ return true;
+ } :
+ function( elem ) {
+ return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
+ };
+ },
+
+ "CLASS": function( className ) {
+ var pattern = classCache[ className + " " ];
+
+ return pattern ||
+ ( pattern = new RegExp( "(^|" + whitespace +
+ ")" + className + "(" + whitespace + "|$)" ) ) && classCache(
+ className, function( elem ) {
+ return pattern.test(
+ typeof elem.className === "string" && elem.className ||
+ typeof elem.getAttribute !== "undefined" &&
+ elem.getAttribute( "class" ) ||
+ ""
+ );
+ } );
+ },
+
+ "ATTR": function( name, operator, check ) {
+ return function( elem ) {
+ var result = Sizzle.attr( elem, name );
+
+ if ( result == null ) {
+ return operator === "!=";
+ }
+ if ( !operator ) {
+ return true;
+ }
+
+ result += "";
+
+ /* eslint-disable max-len */
+
+ return operator === "=" ? result === check :
+ operator === "!=" ? result !== check :
+ operator === "^=" ? check && result.indexOf( check ) === 0 :
+ operator === "*=" ? check && result.indexOf( check ) > -1 :
+ operator === "$=" ? check && result.slice( -check.length ) === check :
+ operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
+ operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
+ false;
+ /* eslint-enable max-len */
+
+ };
+ },
+
+ "CHILD": function( type, what, _argument, first, last ) {
+ var simple = type.slice( 0, 3 ) !== "nth",
+ forward = type.slice( -4 ) !== "last",
+ ofType = what === "of-type";
+
+ return first === 1 && last === 0 ?
+
+ // Shortcut for :nth-*(n)
+ function( elem ) {
+ return !!elem.parentNode;
+ } :
+
+ function( elem, _context, xml ) {
+ var cache, uniqueCache, outerCache, node, nodeIndex, start,
+ dir = simple !== forward ? "nextSibling" : "previousSibling",
+ parent = elem.parentNode,
+ name = ofType && elem.nodeName.toLowerCase(),
+ useCache = !xml && !ofType,
+ diff = false;
+
+ if ( parent ) {
+
+ // :(first|last|only)-(child|of-type)
+ if ( simple ) {
+ while ( dir ) {
+ node = elem;
+ while ( ( node = node[ dir ] ) ) {
+ if ( ofType ?
+ node.nodeName.toLowerCase() === name :
+ node.nodeType === 1 ) {
+
+ return false;
+ }
+ }
+
+ // Reverse direction for :only-* (if we haven't yet done so)
+ start = dir = type === "only" && !start && "nextSibling";
+ }
+ return true;
+ }
+
+ start = [ forward ? parent.firstChild : parent.lastChild ];
+
+ // non-xml :nth-child(...) stores cache data on `parent`
+ if ( forward && useCache ) {
+
+ // Seek `elem` from a previously-cached index
+
+ // ...in a gzip-friendly way
+ node = parent;
+ outerCache = node[ expando ] || ( node[ expando ] = {} );
+
+ // Support: IE <9 only
+ // Defend against cloned attroperties (jQuery gh-1709)
+ uniqueCache = outerCache[ node.uniqueID ] ||
+ ( outerCache[ node.uniqueID ] = {} );
+
+ cache = uniqueCache[ type ] || [];
+ nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
+ diff = nodeIndex && cache[ 2 ];
+ node = nodeIndex && parent.childNodes[ nodeIndex ];
+
+ while ( ( node = ++nodeIndex && node && node[ dir ] ||
+
+ // Fallback to seeking `elem` from the start
+ ( diff = nodeIndex = 0 ) || start.pop() ) ) {
+
+ // When found, cache indexes on `parent` and break
+ if ( node.nodeType === 1 && ++diff && node === elem ) {
+ uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
+ break;
+ }
+ }
+
+ } else {
+
+ // Use previously-cached element index if available
+ if ( useCache ) {
+
+ // ...in a gzip-friendly way
+ node = elem;
+ outerCache = node[ expando ] || ( node[ expando ] = {} );
+
+ // Support: IE <9 only
+ // Defend against cloned attroperties (jQuery gh-1709)
+ uniqueCache = outerCache[ node.uniqueID ] ||
+ ( outerCache[ node.uniqueID ] = {} );
+
+ cache = uniqueCache[ type ] || [];
+ nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
+ diff = nodeIndex;
+ }
+
+ // xml :nth-child(...)
+ // or :nth-last-child(...) or :nth(-last)?-of-type(...)
+ if ( diff === false ) {
+
+ // Use the same loop as above to seek `elem` from the start
+ while ( ( node = ++nodeIndex && node && node[ dir ] ||
+ ( diff = nodeIndex = 0 ) || start.pop() ) ) {
+
+ if ( ( ofType ?
+ node.nodeName.toLowerCase() === name :
+ node.nodeType === 1 ) &&
+ ++diff ) {
+
+ // Cache the index of each encountered element
+ if ( useCache ) {
+ outerCache = node[ expando ] ||
+ ( node[ expando ] = {} );
+
+ // Support: IE <9 only
+ // Defend against cloned attroperties (jQuery gh-1709)
+ uniqueCache = outerCache[ node.uniqueID ] ||
+ ( outerCache[ node.uniqueID ] = {} );
+
+ uniqueCache[ type ] = [ dirruns, diff ];
+ }
+
+ if ( node === elem ) {
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ // Incorporate the offset, then check against cycle size
+ diff -= last;
+ return diff === first || ( diff % first === 0 && diff / first >= 0 );
+ }
+ };
+ },
+
+ "PSEUDO": function( pseudo, argument ) {
+
+ // pseudo-class names are case-insensitive
+ // http://www.w3.org/TR/selectors/#pseudo-classes
+ // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
+ // Remember that setFilters inherits from pseudos
+ var args,
+ fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
+ Sizzle.error( "unsupported pseudo: " + pseudo );
+
+ // The user may use createPseudo to indicate that
+ // arguments are needed to create the filter function
+ // just as Sizzle does
+ if ( fn[ expando ] ) {
+ return fn( argument );
+ }
+
+ // But maintain support for old signatures
+ if ( fn.length > 1 ) {
+ args = [ pseudo, pseudo, "", argument ];
+ return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
+ markFunction( function( seed, matches ) {
+ var idx,
+ matched = fn( seed, argument ),
+ i = matched.length;
+ while ( i-- ) {
+ idx = indexOf( seed, matched[ i ] );
+ seed[ idx ] = !( matches[ idx ] = matched[ i ] );
+ }
+ } ) :
+ function( elem ) {
+ return fn( elem, 0, args );
+ };
+ }
+
+ return fn;
+ }
+ },
+
+ pseudos: {
+
+ // Potentially complex pseudos
+ "not": markFunction( function( selector ) {
+
+ // Trim the selector passed to compile
+ // to avoid treating leading and trailing
+ // spaces as combinators
+ var input = [],
+ results = [],
+ matcher = compile( selector.replace( rtrim, "$1" ) );
+
+ return matcher[ expando ] ?
+ markFunction( function( seed, matches, _context, xml ) {
+ var elem,
+ unmatched = matcher( seed, null, xml, [] ),
+ i = seed.length;
+
+ // Match elements unmatched by `matcher`
+ while ( i-- ) {
+ if ( ( elem = unmatched[ i ] ) ) {
+ seed[ i ] = !( matches[ i ] = elem );
+ }
+ }
+ } ) :
+ function( elem, _context, xml ) {
+ input[ 0 ] = elem;
+ matcher( input, null, xml, results );
+
+ // Don't keep the element (issue #299)
+ input[ 0 ] = null;
+ return !results.pop();
+ };
+ } ),
+
+ "has": markFunction( function( selector ) {
+ return function( elem ) {
+ return Sizzle( selector, elem ).length > 0;
+ };
+ } ),
+
+ "contains": markFunction( function( text ) {
+ text = text.replace( runescape, funescape );
+ return function( elem ) {
+ return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;
+ };
+ } ),
+
+ // "Whether an element is represented by a :lang() selector
+ // is based solely on the element's language value
+ // being equal to the identifier C,
+ // or beginning with the identifier C immediately followed by "-".
+ // The matching of C against the element's language value is performed case-insensitively.
+ // The identifier C does not have to be a valid language name."
+ // http://www.w3.org/TR/selectors/#lang-pseudo
+ "lang": markFunction( function( lang ) {
+
+ // lang value must be a valid identifier
+ if ( !ridentifier.test( lang || "" ) ) {
+ Sizzle.error( "unsupported lang: " + lang );
+ }
+ lang = lang.replace( runescape, funescape ).toLowerCase();
+ return function( elem ) {
+ var elemLang;
+ do {
+ if ( ( elemLang = documentIsHTML ?
+ elem.lang :
+ elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) {
+
+ elemLang = elemLang.toLowerCase();
+ return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
+ }
+ } while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );
+ return false;
+ };
+ } ),
+
+ // Miscellaneous
+ "target": function( elem ) {
+ var hash = window.location && window.location.hash;
+ return hash && hash.slice( 1 ) === elem.id;
+ },
+
+ "root": function( elem ) {
+ return elem === docElem;
+ },
+
+ "focus": function( elem ) {
+ return elem === document.activeElement &&
+ ( !document.hasFocus || document.hasFocus() ) &&
+ !!( elem.type || elem.href || ~elem.tabIndex );
+ },
+
+ // Boolean properties
+ "enabled": createDisabledPseudo( false ),
+ "disabled": createDisabledPseudo( true ),
+
+ "checked": function( elem ) {
+
+ // In CSS3, :checked should return both checked and selected elements
+ // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
+ var nodeName = elem.nodeName.toLowerCase();
+ return ( nodeName === "input" && !!elem.checked ) ||
+ ( nodeName === "option" && !!elem.selected );
+ },
+
+ "selected": function( elem ) {
+
+ // Accessing this property makes selected-by-default
+ // options in Safari work properly
+ if ( elem.parentNode ) {
+ // eslint-disable-next-line no-unused-expressions
+ elem.parentNode.selectedIndex;
+ }
+
+ return elem.selected === true;
+ },
+
+ // Contents
+ "empty": function( elem ) {
+
+ // http://www.w3.org/TR/selectors/#empty-pseudo
+ // :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
+ for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
+ if ( elem.nodeType < 6 ) {
+ return false;
+ }
+ }
+ return true;
+ },
+
+ "parent": function( elem ) {
+ return !Expr.pseudos[ "empty" ]( elem );
+ },
+
+ // Element/input types
+ "header": function( elem ) {
+ return rheader.test( elem.nodeName );
+ },
+
+ "input": function( elem ) {
+ return rinputs.test( elem.nodeName );
+ },
+
+ "button": function( elem ) {
+ var name = elem.nodeName.toLowerCase();
+ return name === "input" && elem.type === "button" || name === "button";
+ },
+
+ "text": function( elem ) {
+ var attr;
+ return elem.nodeName.toLowerCase() === "input" &&
+ elem.type === "text" &&
+
+ // Support: IE<8
+ // New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
+ ( ( attr = elem.getAttribute( "type" ) ) == null ||
+ attr.toLowerCase() === "text" );
+ },
+
+ // Position-in-collection
+ "first": createPositionalPseudo( function() {
+ return [ 0 ];
+ } ),
+
+ "last": createPositionalPseudo( function( _matchIndexes, length ) {
+ return [ length - 1 ];
+ } ),
+
+ "eq": createPositionalPseudo( function( _matchIndexes, length, argument ) {
+ return [ argument < 0 ? argument + length : argument ];
+ } ),
+
+ "even": createPositionalPseudo( function( matchIndexes, length ) {
+ var i = 0;
+ for ( ; i < length; i += 2 ) {
+ matchIndexes.push( i );
+ }
+ return matchIndexes;
+ } ),
+
+ "odd": createPositionalPseudo( function( matchIndexes, length ) {
+ var i = 1;
+ for ( ; i < length; i += 2 ) {
+ matchIndexes.push( i );
+ }
+ return matchIndexes;
+ } ),
+
+ "lt": createPositionalPseudo( function( matchIndexes, length, argument ) {
+ var i = argument < 0 ?
+ argument + length :
+ argument > length ?
+ length :
+ argument;
+ for ( ; --i >= 0; ) {
+ matchIndexes.push( i );
+ }
+ return matchIndexes;
+ } ),
+
+ "gt": createPositionalPseudo( function( matchIndexes, length, argument ) {
+ var i = argument < 0 ? argument + length : argument;
+ for ( ; ++i < length; ) {
+ matchIndexes.push( i );
+ }
+ return matchIndexes;
+ } )
+ }
+};
+
+Expr.pseudos[ "nth" ] = Expr.pseudos[ "eq" ];
+
+// Add button/input type pseudos
+for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
+ Expr.pseudos[ i ] = createInputPseudo( i );
+}
+for ( i in { submit: true, reset: true } ) {
+ Expr.pseudos[ i ] = createButtonPseudo( i );
+}
+
+// Easy API for creating new setFilters
+function setFilters() {}
+setFilters.prototype = Expr.filters = Expr.pseudos;
+Expr.setFilters = new setFilters();
+
+tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
+ var matched, match, tokens, type,
+ soFar, groups, preFilters,
+ cached = tokenCache[ selector + " " ];
+
+ if ( cached ) {
+ return parseOnly ? 0 : cached.slice( 0 );
+ }
+
+ soFar = selector;
+ groups = [];
+ preFilters = Expr.preFilter;
+
+ while ( soFar ) {
+
+ // Comma and first run
+ if ( !matched || ( match = rcomma.exec( soFar ) ) ) {
+ if ( match ) {
+
+ // Don't consume trailing commas as valid
+ soFar = soFar.slice( match[ 0 ].length ) || soFar;
+ }
+ groups.push( ( tokens = [] ) );
+ }
+
+ matched = false;
+
+ // Combinators
+ if ( ( match = rcombinators.exec( soFar ) ) ) {
+ matched = match.shift();
+ tokens.push( {
+ value: matched,
+
+ // Cast descendant combinators to space
+ type: match[ 0 ].replace( rtrim, " " )
+ } );
+ soFar = soFar.slice( matched.length );
+ }
+
+ // Filters
+ for ( type in Expr.filter ) {
+ if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||
+ ( match = preFilters[ type ]( match ) ) ) ) {
+ matched = match.shift();
+ tokens.push( {
+ value: matched,
+ type: type,
+ matches: match
+ } );
+ soFar = soFar.slice( matched.length );
+ }
+ }
+
+ if ( !matched ) {
+ break;
+ }
+ }
+
+ // Return the length of the invalid excess
+ // if we're just parsing
+ // Otherwise, throw an error or return tokens
+ return parseOnly ?
+ soFar.length :
+ soFar ?
+ Sizzle.error( selector ) :
+
+ // Cache the tokens
+ tokenCache( selector, groups ).slice( 0 );
+};
+
+function toSelector( tokens ) {
+ var i = 0,
+ len = tokens.length,
+ selector = "";
+ for ( ; i < len; i++ ) {
+ selector += tokens[ i ].value;
+ }
+ return selector;
+}
+
+function addCombinator( matcher, combinator, base ) {
+ var dir = combinator.dir,
+ skip = combinator.next,
+ key = skip || dir,
+ checkNonElements = base && key === "parentNode",
+ doneName = done++;
+
+ return combinator.first ?
+
+ // Check against closest ancestor/preceding element
+ function( elem, context, xml ) {
+ while ( ( elem = elem[ dir ] ) ) {
+ if ( elem.nodeType === 1 || checkNonElements ) {
+ return matcher( elem, context, xml );
+ }
+ }
+ return false;
+ } :
+
+ // Check against all ancestor/preceding elements
+ function( elem, context, xml ) {
+ var oldCache, uniqueCache, outerCache,
+ newCache = [ dirruns, doneName ];
+
+ // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
+ if ( xml ) {
+ while ( ( elem = elem[ dir ] ) ) {
+ if ( elem.nodeType === 1 || checkNonElements ) {
+ if ( matcher( elem, context, xml ) ) {
+ return true;
+ }
+ }
+ }
+ } else {
+ while ( ( elem = elem[ dir ] ) ) {
+ if ( elem.nodeType === 1 || checkNonElements ) {
+ outerCache = elem[ expando ] || ( elem[ expando ] = {} );
+
+ // Support: IE <9 only
+ // Defend against cloned attroperties (jQuery gh-1709)
+ uniqueCache = outerCache[ elem.uniqueID ] ||
+ ( outerCache[ elem.uniqueID ] = {} );
+
+ if ( skip && skip === elem.nodeName.toLowerCase() ) {
+ elem = elem[ dir ] || elem;
+ } else if ( ( oldCache = uniqueCache[ key ] ) &&
+ oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
+
+ // Assign to newCache so results back-propagate to previous elements
+ return ( newCache[ 2 ] = oldCache[ 2 ] );
+ } else {
+
+ // Reuse newcache so results back-propagate to previous elements
+ uniqueCache[ key ] = newCache;
+
+ // A match means we're done; a fail means we have to keep checking
+ if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {
+ return true;
+ }
+ }
+ }
+ }
+ }
+ return false;
+ };
+}
+
+function elementMatcher( matchers ) {
+ return matchers.length > 1 ?
+ function( elem, context, xml ) {
+ var i = matchers.length;
+ while ( i-- ) {
+ if ( !matchers[ i ]( elem, context, xml ) ) {
+ return false;
+ }
+ }
+ return true;
+ } :
+ matchers[ 0 ];
+}
+
+function multipleContexts( selector, contexts, results ) {
+ var i = 0,
+ len = contexts.length;
+ for ( ; i < len; i++ ) {
+ Sizzle( selector, contexts[ i ], results );
+ }
+ return results;
+}
+
+function condense( unmatched, map, filter, context, xml ) {
+ var elem,
+ newUnmatched = [],
+ i = 0,
+ len = unmatched.length,
+ mapped = map != null;
+
+ for ( ; i < len; i++ ) {
+ if ( ( elem = unmatched[ i ] ) ) {
+ if ( !filter || filter( elem, context, xml ) ) {
+ newUnmatched.push( elem );
+ if ( mapped ) {
+ map.push( i );
+ }
+ }
+ }
+ }
+
+ return newUnmatched;
+}
+
+function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
+ if ( postFilter && !postFilter[ expando ] ) {
+ postFilter = setMatcher( postFilter );
+ }
+ if ( postFinder && !postFinder[ expando ] ) {
+ postFinder = setMatcher( postFinder, postSelector );
+ }
+ return markFunction( function( seed, results, context, xml ) {
+ var temp, i, elem,
+ preMap = [],
+ postMap = [],
+ preexisting = results.length,
+
+ // Get initial elements from seed or context
+ elems = seed || multipleContexts(
+ selector || "*",
+ context.nodeType ? [ context ] : context,
+ []
+ ),
+
+ // Prefilter to get matcher input, preserving a map for seed-results synchronization
+ matcherIn = preFilter && ( seed || !selector ) ?
+ condense( elems, preMap, preFilter, context, xml ) :
+ elems,
+
+ matcherOut = matcher ?
+
+ // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
+ postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
+
+ // ...intermediate processing is necessary
+ [] :
+
+ // ...otherwise use results directly
+ results :
+ matcherIn;
+
+ // Find primary matches
+ if ( matcher ) {
+ matcher( matcherIn, matcherOut, context, xml );
+ }
+
+ // Apply postFilter
+ if ( postFilter ) {
+ temp = condense( matcherOut, postMap );
+ postFilter( temp, [], context, xml );
+
+ // Un-match failing elements by moving them back to matcherIn
+ i = temp.length;
+ while ( i-- ) {
+ if ( ( elem = temp[ i ] ) ) {
+ matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );
+ }
+ }
+ }
+
+ if ( seed ) {
+ if ( postFinder || preFilter ) {
+ if ( postFinder ) {
+
+ // Get the final matcherOut by condensing this intermediate into postFinder contexts
+ temp = [];
+ i = matcherOut.length;
+ while ( i-- ) {
+ if ( ( elem = matcherOut[ i ] ) ) {
+
+ // Restore matcherIn since elem is not yet a final match
+ temp.push( ( matcherIn[ i ] = elem ) );
+ }
+ }
+ postFinder( null, ( matcherOut = [] ), temp, xml );
+ }
+
+ // Move matched elements from seed to results to keep them synchronized
+ i = matcherOut.length;
+ while ( i-- ) {
+ if ( ( elem = matcherOut[ i ] ) &&
+ ( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) {
+
+ seed[ temp ] = !( results[ temp ] = elem );
+ }
+ }
+ }
+
+ // Add elements to results, through postFinder if defined
+ } else {
+ matcherOut = condense(
+ matcherOut === results ?
+ matcherOut.splice( preexisting, matcherOut.length ) :
+ matcherOut
+ );
+ if ( postFinder ) {
+ postFinder( null, results, matcherOut, xml );
+ } else {
+ push.apply( results, matcherOut );
+ }
+ }
+ } );
+}
+
+function matcherFromTokens( tokens ) {
+ var checkContext, matcher, j,
+ len = tokens.length,
+ leadingRelative = Expr.relative[ tokens[ 0 ].type ],
+ implicitRelative = leadingRelative || Expr.relative[ " " ],
+ i = leadingRelative ? 1 : 0,
+
+ // The foundational matcher ensures that elements are reachable from top-level context(s)
+ matchContext = addCombinator( function( elem ) {
+ return elem === checkContext;
+ }, implicitRelative, true ),
+ matchAnyContext = addCombinator( function( elem ) {
+ return indexOf( checkContext, elem ) > -1;
+ }, implicitRelative, true ),
+ matchers = [ function( elem, context, xml ) {
+ var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
+ ( checkContext = context ).nodeType ?
+ matchContext( elem, context, xml ) :
+ matchAnyContext( elem, context, xml ) );
+
+ // Avoid hanging onto element (issue #299)
+ checkContext = null;
+ return ret;
+ } ];
+
+ for ( ; i < len; i++ ) {
+ if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {
+ matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
+ } else {
+ matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );
+
+ // Return special upon seeing a positional matcher
+ if ( matcher[ expando ] ) {
+
+ // Find the next relative operator (if any) for proper handling
+ j = ++i;
+ for ( ; j < len; j++ ) {
+ if ( Expr.relative[ tokens[ j ].type ] ) {
+ break;
+ }
+ }
+ return setMatcher(
+ i > 1 && elementMatcher( matchers ),
+ i > 1 && toSelector(
+
+ // If the preceding token was a descendant combinator, insert an implicit any-element `*`
+ tokens
+ .slice( 0, i - 1 )
+ .concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } )
+ ).replace( rtrim, "$1" ),
+ matcher,
+ i < j && matcherFromTokens( tokens.slice( i, j ) ),
+ j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),
+ j < len && toSelector( tokens )
+ );
+ }
+ matchers.push( matcher );
+ }
+ }
+
+ return elementMatcher( matchers );
+}
+
+function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
+ var bySet = setMatchers.length > 0,
+ byElement = elementMatchers.length > 0,
+ superMatcher = function( seed, context, xml, results, outermost ) {
+ var elem, j, matcher,
+ matchedCount = 0,
+ i = "0",
+ unmatched = seed && [],
+ setMatched = [],
+ contextBackup = outermostContext,
+
+ // We must always have either seed elements or outermost context
+ elems = seed || byElement && Expr.find[ "TAG" ]( "*", outermost ),
+
+ // Use integer dirruns iff this is the outermost matcher
+ dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),
+ len = elems.length;
+
+ if ( outermost ) {
+
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ outermostContext = context == document || context || outermost;
+ }
+
+ // Add elements passing elementMatchers directly to results
+ // Support: IE<9, Safari
+ // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
+ for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {
+ if ( byElement && elem ) {
+ j = 0;
+
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ if ( !context && elem.ownerDocument != document ) {
+ setDocument( elem );
+ xml = !documentIsHTML;
+ }
+ while ( ( matcher = elementMatchers[ j++ ] ) ) {
+ if ( matcher( elem, context || document, xml ) ) {
+ results.push( elem );
+ break;
+ }
+ }
+ if ( outermost ) {
+ dirruns = dirrunsUnique;
+ }
+ }
+
+ // Track unmatched elements for set filters
+ if ( bySet ) {
+
+ // They will have gone through all possible matchers
+ if ( ( elem = !matcher && elem ) ) {
+ matchedCount--;
+ }
+
+ // Lengthen the array for every element, matched or not
+ if ( seed ) {
+ unmatched.push( elem );
+ }
+ }
+ }
+
+ // `i` is now the count of elements visited above, and adding it to `matchedCount`
+ // makes the latter nonnegative.
+ matchedCount += i;
+
+ // Apply set filters to unmatched elements
+ // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
+ // equals `i`), unless we didn't visit _any_ elements in the above loop because we have
+ // no element matchers and no seed.
+ // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
+ // case, which will result in a "00" `matchedCount` that differs from `i` but is also
+ // numerically zero.
+ if ( bySet && i !== matchedCount ) {
+ j = 0;
+ while ( ( matcher = setMatchers[ j++ ] ) ) {
+ matcher( unmatched, setMatched, context, xml );
+ }
+
+ if ( seed ) {
+
+ // Reintegrate element matches to eliminate the need for sorting
+ if ( matchedCount > 0 ) {
+ while ( i-- ) {
+ if ( !( unmatched[ i ] || setMatched[ i ] ) ) {
+ setMatched[ i ] = pop.call( results );
+ }
+ }
+ }
+
+ // Discard index placeholder values to get only actual matches
+ setMatched = condense( setMatched );
+ }
+
+ // Add matches to results
+ push.apply( results, setMatched );
+
+ // Seedless set matches succeeding multiple successful matchers stipulate sorting
+ if ( outermost && !seed && setMatched.length > 0 &&
+ ( matchedCount + setMatchers.length ) > 1 ) {
+
+ Sizzle.uniqueSort( results );
+ }
+ }
+
+ // Override manipulation of globals by nested matchers
+ if ( outermost ) {
+ dirruns = dirrunsUnique;
+ outermostContext = contextBackup;
+ }
+
+ return unmatched;
+ };
+
+ return bySet ?
+ markFunction( superMatcher ) :
+ superMatcher;
+}
+
+compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
+ var i,
+ setMatchers = [],
+ elementMatchers = [],
+ cached = compilerCache[ selector + " " ];
+
+ if ( !cached ) {
+
+ // Generate a function of recursive functions that can be used to check each element
+ if ( !match ) {
+ match = tokenize( selector );
+ }
+ i = match.length;
+ while ( i-- ) {
+ cached = matcherFromTokens( match[ i ] );
+ if ( cached[ expando ] ) {
+ setMatchers.push( cached );
+ } else {
+ elementMatchers.push( cached );
+ }
+ }
+
+ // Cache the compiled function
+ cached = compilerCache(
+ selector,
+ matcherFromGroupMatchers( elementMatchers, setMatchers )
+ );
+
+ // Save selector and tokenization
+ cached.selector = selector;
+ }
+ return cached;
+};
+
+/**
+ * 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 ) {
+ var i, tokens, token, type, find,
+ compiled = typeof selector === "function" && selector,
+ match = !seed && tokenize( ( selector = compiled.selector || selector ) );
+
+ results = results || [];
+
+ // Try to minimize operations if there is only one selector in the list and no seed
+ // (the latter of which guarantees us context)
+ if ( match.length === 1 ) {
+
+ // Reduce context if the leading compound selector is an ID
+ tokens = match[ 0 ] = match[ 0 ].slice( 0 );
+ if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
+ 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
+ // Provide `match` to avoid retokenization if we modified the selector above
+ ( compiled || compile( selector, match ) )(
+ seed,
+ context,
+ !documentIsHTML,
+ results,
+ !context || rsibling.test( selector ) && testContext( context.parentNode ) || context
+ );
+ return results;
+};
+
+// One-time assignments
+
+// Sort stability
+support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando;
+
+// Support: Chrome 14-35+
+// Always assume duplicates if they aren't passed to the comparison function
+support.detectDuplicates = !!hasDuplicate;
+
+// Initialize against the default document
+setDocument();
+
+// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
+// Detached nodes confoundingly follow *each other*
+support.sortDetached = assert( function( el ) {
+
+ // Should return 1, but returns 4 (following)
+ return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1;
+} );
+
+// Support: IE<8
+// Prevent attribute/property "interpolation"
+// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
+if ( !assert( function( el ) {
+ el.innerHTML = "<a href='#'></a>";
+ return el.firstChild.getAttribute( "href" ) === "#";
+} ) ) {
+ addHandle( "type|href|height|width", function( elem, name, isXML ) {
+ if ( !isXML ) {
+ return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
+ }
+ } );
+}
+
+// Support: IE<9
+// Use defaultValue in place of getAttribute("value")
+if ( !support.attributes || !assert( function( el ) {
+ el.innerHTML = "<input/>";
+ el.firstChild.setAttribute( "value", "" );
+ return el.firstChild.getAttribute( "value" ) === "";
+} ) ) {
+ addHandle( "value", function( elem, _name, isXML ) {
+ if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
+ return elem.defaultValue;
+ }
+ } );
+}
+
+// Support: IE<9
+// Use getAttributeNode to fetch booleans when getAttribute lies
+if ( !assert( function( el ) {
+ return el.getAttribute( "disabled" ) == null;
+} ) ) {
+ addHandle( booleans, function( elem, name, isXML ) {
+ var val;
+ if ( !isXML ) {
+ return elem[ name ] === true ? name.toLowerCase() :
+ ( val = elem.getAttributeNode( name ) ) && val.specified ?
+ val.value :
+ null;
+ }
+ } );
+}
+
+return Sizzle;
+
+} )( window );
+
+
+
+jQuery.find = Sizzle;
+jQuery.expr = Sizzle.selectors;
+
+// Deprecated
+jQuery.expr[ ":" ] = jQuery.expr.pseudos;
+jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
+jQuery.text = Sizzle.getText;
+jQuery.isXMLDoc = Sizzle.isXML;
+jQuery.contains = Sizzle.contains;
+jQuery.escapeSelector = Sizzle.escape;
+
+
+
+
+var dir = function( elem, dir, until ) {
+ var matched = [],
+ truncate = until !== undefined;
+
+ while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
+ if ( elem.nodeType === 1 ) {
+ if ( truncate && jQuery( elem ).is( until ) ) {
+ break;
+ }
+ matched.push( elem );
+ }
+ }
+ return matched;
+};
+
+
+var siblings = function( n, elem ) {
+ var matched = [];
+
+ for ( ; n; n = n.nextSibling ) {
+ if ( n.nodeType === 1 && n !== elem ) {
+ matched.push( n );
+ }
+ }
+
+ return matched;
+};
+
+
+var rneedsContext = jQuery.expr.match.needsContext;
+
+
+
+function nodeName( elem, name ) {
+
+ return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
+
+}
+var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
+
+
+
+// Implement the identical functionality for filter and not
+function winnow( elements, qualifier, not ) {
+ if ( isFunction( qualifier ) ) {
+ return jQuery.grep( elements, function( elem, i ) {
+ return !!qualifier.call( elem, i, elem ) !== not;
+ } );
+ }
+
+ // Single element
+ if ( qualifier.nodeType ) {
+ return jQuery.grep( elements, function( elem ) {
+ return ( elem === qualifier ) !== not;
+ } );
+ }
+
+ // Arraylike of elements (jQuery, arguments, Array)
+ if ( typeof qualifier !== "string" ) {
+ return jQuery.grep( elements, function( elem ) {
+ return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
+ } );
+ }
+
+ // Filtered directly for both simple and complex selectors
+ return jQuery.filter( qualifier, elements, not );
+}
+
+jQuery.filter = function( expr, elems, not ) {
+ var elem = elems[ 0 ];
+
+ if ( not ) {
+ expr = ":not(" + expr + ")";
+ }
+
+ if ( elems.length === 1 && elem.nodeType === 1 ) {
+ return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
+ }
+
+ return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
+ return elem.nodeType === 1;
+ } ) );
+};
+
+jQuery.fn.extend( {
+ find: function( selector ) {
+ var i, ret,
+ len = this.length,
+ self = this;
+
+ if ( typeof selector !== "string" ) {
+ return this.pushStack( jQuery( selector ).filter( function() {
+ for ( i = 0; i < len; i++ ) {
+ if ( jQuery.contains( self[ i ], this ) ) {
+ return true;
+ }
+ }
+ } ) );
+ }
+
+ ret = this.pushStack( [] );
+
+ for ( i = 0; i < len; i++ ) {
+ jQuery.find( selector, self[ i ], ret );
+ }
+
+ return len > 1 ? jQuery.uniqueSort( ret ) : ret;
+ },
+ filter: function( selector ) {
+ return this.pushStack( winnow( this, selector || [], false ) );
+ },
+ not: function( selector ) {
+ return this.pushStack( winnow( this, selector || [], true ) );
+ },
+ is: function( selector ) {
+ return !!winnow(
+ this,
+
+ // If this is a positional/relative selector, check membership in the returned set
+ // so $("p:first").is("p:last") won't return true for a doc with two "p".
+ typeof selector === "string" && rneedsContext.test( selector ) ?
+ jQuery( selector ) :
+ selector || [],
+ false
+ ).length;
+ }
+} );
+
+
+// Initialize a jQuery object
+
+
+// A central reference to the root jQuery(document)
+var rootjQuery,
+
+ // A simple way to check for HTML strings
+ // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
+ // Strict HTML recognition (#11290: must start with <)
+ // Shortcut simple #id case for speed
+ rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
+
+ init = jQuery.fn.init = function( selector, context, root ) {
+ var match, elem;
+
+ // HANDLE: $(""), $(null), $(undefined), $(false)
+ if ( !selector ) {
+ return this;
+ }
+
+ // Method init() accepts an alternate rootjQuery
+ // so migrate can support jQuery.sub (gh-2101)
+ root = root || rootjQuery;
+
+ // Handle HTML strings
+ if ( typeof selector === "string" ) {
+ if ( selector[ 0 ] === "<" &&
+ selector[ selector.length - 1 ] === ">" &&
+ selector.length >= 3 ) {
+
+ // Assume that strings that start and end with <> are HTML and skip the regex check
+ match = [ null, selector, null ];
+
+ } else {
+ match = rquickExpr.exec( selector );
+ }
+
+ // Match html or make sure no context is specified for #id
+ if ( match && ( match[ 1 ] || !context ) ) {
+
+ // HANDLE: $(html) -> $(array)
+ if ( match[ 1 ] ) {
+ context = context instanceof jQuery ? context[ 0 ] : context;
+
+ // Option to run scripts is true for back-compat
+ // Intentionally let the error be thrown if parseHTML is not present
+ jQuery.merge( this, jQuery.parseHTML(
+ match[ 1 ],
+ context && context.nodeType ? context.ownerDocument || context : document,
+ true
+ ) );
+
+ // HANDLE: $(html, props)
+ if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
+ for ( match in context ) {
+
+ // Properties of context are called as methods if possible
+ if ( isFunction( this[ match ] ) ) {
+ this[ match ]( context[ match ] );
+
+ // ...and otherwise set as attributes
+ } else {
+ this.attr( match, context[ match ] );
+ }
+ }
+ }
+
+ return this;
+
+ // HANDLE: $(#id)
+ } else {
+ elem = document.getElementById( match[ 2 ] );
+
+ if ( elem ) {
+
+ // Inject the element directly into the jQuery object
+ this[ 0 ] = elem;
+ this.length = 1;
+ }
+ return this;
+ }
+
+ // HANDLE: $(expr, $(...))
+ } else if ( !context || context.jquery ) {
+ return ( context || root ).find( selector );
+
+ // HANDLE: $(expr, context)
+ // (which is just equivalent to: $(context).find(expr)
+ } else {
+ return this.constructor( context ).find( selector );
+ }
+
+ // HANDLE: $(DOMElement)
+ } else if ( selector.nodeType ) {
+ this[ 0 ] = selector;
+ this.length = 1;
+ return this;
+
+ // HANDLE: $(function)
+ // Shortcut for document ready
+ } else if ( isFunction( selector ) ) {
+ return root.ready !== undefined ?
+ root.ready( selector ) :
+
+ // Execute immediately if ready is not present
+ selector( jQuery );
+ }
+
+ return jQuery.makeArray( selector, this );
+ };
+
+// Give the init function the jQuery prototype for later instantiation
+init.prototype = jQuery.fn;
+
+// Initialize central reference
+rootjQuery = jQuery( document );
+
+
+var rparentsprev = /^(?:parents|prev(?:Until|All))/,
+
+ // Methods guaranteed to produce a unique set when starting from a unique set
+ guaranteedUnique = {
+ children: true,
+ contents: true,
+ next: true,
+ prev: true
+ };
+
+jQuery.fn.extend( {
+ has: function( target ) {
+ var targets = jQuery( target, this ),
+ l = targets.length;
+
+ return this.filter( function() {
+ var i = 0;
+ for ( ; i < l; i++ ) {
+ if ( jQuery.contains( this, targets[ i ] ) ) {
+ return true;
+ }
+ }
+ } );
+ },
+
+ closest: function( selectors, context ) {
+ var cur,
+ i = 0,
+ l = this.length,
+ matched = [],
+ targets = typeof selectors !== "string" && jQuery( selectors );
+
+ // Positional selectors never match, since there's no _selection_ context
+ if ( !rneedsContext.test( selectors ) ) {
+ for ( ; i < l; i++ ) {
+ for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
+
+ // Always skip document fragments
+ if ( cur.nodeType < 11 && ( targets ?
+ targets.index( cur ) > -1 :
+
+ // Don't pass non-elements to Sizzle
+ cur.nodeType === 1 &&
+ jQuery.find.matchesSelector( cur, selectors ) ) ) {
+
+ matched.push( cur );
+ break;
+ }
+ }
+ }
+ }
+
+ return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
+ },
+
+ // Determine the position of an element within the set
+ index: function( elem ) {
+
+ // No argument, return index in parent
+ if ( !elem ) {
+ return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
+ }
+
+ // Index in selector
+ if ( typeof elem === "string" ) {
+ return indexOf.call( jQuery( elem ), this[ 0 ] );
+ }
+
+ // Locate the position of the desired element
+ return indexOf.call( this,
+
+ // If it receives a jQuery object, the first element is used
+ elem.jquery ? elem[ 0 ] : elem
+ );
+ },
+
+ add: function( selector, context ) {
+ return this.pushStack(
+ jQuery.uniqueSort(
+ jQuery.merge( this.get(), jQuery( selector, context ) )
+ )
+ );
+ },
+
+ addBack: function( selector ) {
+ return this.add( selector == null ?
+ this.prevObject : this.prevObject.filter( selector )
+ );
+ }
+} );
+
+function sibling( cur, dir ) {
+ while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
+ return cur;
+}
+
+jQuery.each( {
+ parent: function( elem ) {
+ var parent = elem.parentNode;
+ return parent && parent.nodeType !== 11 ? parent : null;
+ },
+ parents: function( elem ) {
+ return dir( elem, "parentNode" );
+ },
+ parentsUntil: function( elem, _i, until ) {
+ return dir( elem, "parentNode", until );
+ },
+ next: function( elem ) {
+ return sibling( elem, "nextSibling" );
+ },
+ prev: function( elem ) {
+ return sibling( elem, "previousSibling" );
+ },
+ nextAll: function( elem ) {
+ return dir( elem, "nextSibling" );
+ },
+ prevAll: function( elem ) {
+ return dir( elem, "previousSibling" );
+ },
+ nextUntil: function( elem, _i, until ) {
+ return dir( elem, "nextSibling", until );
+ },
+ prevUntil: function( elem, _i, until ) {
+ return dir( elem, "previousSibling", until );
+ },
+ siblings: function( elem ) {
+ return siblings( ( elem.parentNode || {} ).firstChild, elem );
+ },
+ children: function( elem ) {
+ return siblings( elem.firstChild );
+ },
+ contents: function( elem ) {
+ if ( elem.contentDocument != null &&
+
+ // Support: IE 11+
+ // <object> elements with no `data` attribute has an object
+ // `contentDocument` with a `null` prototype.
+ getProto( elem.contentDocument ) ) {
+
+ return elem.contentDocument;
+ }
+
+ // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
+ // Treat the template element as a regular one in browsers that
+ // don't support it.
+ if ( nodeName( elem, "template" ) ) {
+ elem = elem.content || elem;
+ }
+
+ return jQuery.merge( [], elem.childNodes );
+ }
+}, function( name, fn ) {
+ jQuery.fn[ name ] = function( until, selector ) {
+ var matched = jQuery.map( this, fn, until );
+
+ if ( name.slice( -5 ) !== "Until" ) {
+ selector = until;
+ }
+
+ if ( selector && typeof selector === "string" ) {
+ matched = jQuery.filter( selector, matched );
+ }
+
+ if ( this.length > 1 ) {
+
+ // Remove duplicates
+ if ( !guaranteedUnique[ name ] ) {
+ jQuery.uniqueSort( matched );
+ }
+
+ // Reverse order for parents* and prev-derivatives
+ if ( rparentsprev.test( name ) ) {
+ matched.reverse();
+ }
+ }
+
+ return this.pushStack( matched );
+ };
+} );
+var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
+
+
+
+// Convert String-formatted options into Object-formatted ones
+function createOptions( options ) {
+ var object = {};
+ jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
+ object[ flag ] = true;
+ } );
+ return object;
+}
+
+/*
+ * Create a callback list using the following parameters:
+ *
+ * options: an optional list of space-separated options that will change how
+ * the callback list behaves or a more traditional option object
+ *
+ * By default a callback list will act like an event callback list and can be
+ * "fired" multiple times.
+ *
+ * Possible options:
+ *
+ * once: will ensure the callback list can only be fired once (like a Deferred)
+ *
+ * memory: will keep track of previous values and will call any callback added
+ * after the list has been fired right away with the latest "memorized"
+ * values (like a Deferred)
+ *
+ * unique: will ensure a callback can only be added once (no duplicate in the list)
+ *
+ * stopOnFalse: interrupt callings when a callback returns false
+ *
+ */
+jQuery.Callbacks = function( options ) {
+
+ // Convert options from String-formatted to Object-formatted if needed
+ // (we check in cache first)
+ options = typeof options === "string" ?
+ createOptions( options ) :
+ jQuery.extend( {}, options );
+
+ var // Flag to know if list is currently firing
+ firing,
+
+ // Last fire value for non-forgettable lists
+ memory,
+
+ // Flag to know if list was already fired
+ fired,
+
+ // Flag to prevent firing
+ locked,
+
+ // Actual callback list
+ list = [],
+
+ // Queue of execution data for repeatable lists
+ queue = [],
+
+ // Index of currently firing callback (modified by add/remove as needed)
+ firingIndex = -1,
+
+ // Fire callbacks
+ fire = function() {
+
+ // Enforce single-firing
+ locked = locked || options.once;
+
+ // Execute callbacks for all pending executions,
+ // respecting firingIndex overrides and runtime changes
+ fired = firing = true;
+ for ( ; queue.length; firingIndex = -1 ) {
+ memory = queue.shift();
+ while ( ++firingIndex < list.length ) {
+
+ // Run callback and check for early termination
+ if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
+ options.stopOnFalse ) {
+
+ // Jump to end and forget the data so .add doesn't re-fire
+ firingIndex = list.length;
+ memory = false;
+ }
+ }
+ }
+
+ // Forget the data if we're done with it
+ if ( !options.memory ) {
+ memory = false;
+ }
+
+ firing = false;
+
+ // Clean up if we're done firing for good
+ if ( locked ) {
+
+ // Keep an empty list if we have data for future add calls
+ if ( memory ) {
+ list = [];
+
+ // Otherwise, this object is spent
+ } else {
+ list = "";
+ }
+ }
+ },
+
+ // Actual Callbacks object
+ self = {
+
+ // Add a callback or a collection of callbacks to the list
+ add: function() {
+ if ( list ) {
+
+ // If we have memory from a past run, we should fire after adding
+ if ( memory && !firing ) {
+ firingIndex = list.length - 1;
+ queue.push( memory );
+ }
+
+ ( function add( args ) {
+ jQuery.each( args, function( _, arg ) {
+ if ( isFunction( arg ) ) {
+ if ( !options.unique || !self.has( arg ) ) {
+ list.push( arg );
+ }
+ } else if ( arg && arg.length && toType( arg ) !== "string" ) {
+
+ // Inspect recursively
+ add( arg );
+ }
+ } );
+ } )( arguments );
+
+ if ( memory && !firing ) {
+ fire();
+ }
+ }
+ return this;
+ },
+
+ // Remove a callback from the list
+ remove: function() {
+ jQuery.each( arguments, function( _, arg ) {
+ var index;
+ while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
+ list.splice( index, 1 );
+
+ // Handle firing indexes
+ if ( index <= firingIndex ) {
+ firingIndex--;
+ }
+ }
+ } );
+ return this;
+ },
+
+ // Check if a given callback is in the list.
+ // If no argument is given, return whether or not list has callbacks attached.
+ has: function( fn ) {
+ return fn ?
+ jQuery.inArray( fn, list ) > -1 :
+ list.length > 0;
+ },
+
+ // Remove all callbacks from the list
+ empty: function() {
+ if ( list ) {
+ list = [];
+ }
+ return this;
+ },
+
+ // Disable .fire and .add
+ // Abort any current/pending executions
+ // Clear all callbacks and values
+ disable: function() {
+ locked = queue = [];
+ list = memory = "";
+ return this;
+ },
+ disabled: function() {
+ return !list;
+ },
+
+ // Disable .fire
+ // Also disable .add unless we have memory (since it would have no effect)
+ // Abort any pending executions
+ lock: function() {
+ locked = queue = [];
+ if ( !memory && !firing ) {
+ list = memory = "";
+ }
+ return this;
+ },
+ locked: function() {
+ return !!locked;
+ },
+
+ // Call all callbacks with the given context and arguments
+ fireWith: function( context, args ) {
+ if ( !locked ) {
+ args = args || [];
+ args = [ context, args.slice ? args.slice() : args ];
+ queue.push( args );
+ if ( !firing ) {
+ fire();
+ }
+ }
+ return this;
+ },
+
+ // Call all the callbacks with the given arguments
+ fire: function() {
+ self.fireWith( this, arguments );
+ return this;
+ },
+
+ // To know if the callbacks have already been called at least once
+ fired: function() {
+ return !!fired;
+ }
+ };
+
+ return self;
+};
+
+
+function Identity( v ) {
+ return v;
+}
+function Thrower( ex ) {
+ throw ex;
+}
+
+function adoptValue( value, resolve, reject, noValue ) {
+ var method;
+
+ try {
+
+ // Check for promise aspect first to privilege synchronous behavior
+ if ( value && isFunction( ( method = value.promise ) ) ) {
+ method.call( value ).done( resolve ).fail( reject );
+
+ // Other thenables
+ } else if ( value && isFunction( ( method = value.then ) ) ) {
+ method.call( value, resolve, reject );
+
+ // Other non-thenables
+ } else {
+
+ // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
+ // * false: [ value ].slice( 0 ) => resolve( value )
+ // * true: [ value ].slice( 1 ) => resolve()
+ resolve.apply( undefined, [ value ].slice( noValue ) );
+ }
+
+ // For Promises/A+, convert exceptions into rejections
+ // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
+ // Deferred#then to conditionally suppress rejection.
+ } catch ( value ) {
+
+ // Support: Android 4.0 only
+ // Strict mode functions invoked without .call/.apply get global-object context
+ reject.apply( undefined, [ value ] );
+ }
+}
+
+jQuery.extend( {
+
+ Deferred: function( func ) {
+ var tuples = [
+
+ // action, add listener, callbacks,
+ // ... .then handlers, argument index, [final state]
+ [ "notify", "progress", jQuery.Callbacks( "memory" ),
+ jQuery.Callbacks( "memory" ), 2 ],
+ [ "resolve", "done", jQuery.Callbacks( "once memory" ),
+ jQuery.Callbacks( "once memory" ), 0, "resolved" ],
+ [ "reject", "fail", jQuery.Callbacks( "once memory" ),
+ jQuery.Callbacks( "once memory" ), 1, "rejected" ]
+ ],
+ state = "pending",
+ promise = {
+ state: function() {
+ return state;
+ },
+ always: function() {
+ deferred.done( arguments ).fail( arguments );
+ return this;
+ },
+ "catch": function( fn ) {
+ return promise.then( null, fn );
+ },
+
+ // Keep pipe for back-compat
+ pipe: function( /* fnDone, fnFail, fnProgress */ ) {
+ var fns = arguments;
+
+ return jQuery.Deferred( function( newDefer ) {
+ jQuery.each( tuples, function( _i, tuple ) {
+
+ // Map tuples (progress, done, fail) to arguments (done, fail, progress)
+ var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
+
+ // deferred.progress(function() { bind to newDefer or newDefer.notify })
+ // deferred.done(function() { bind to newDefer or newDefer.resolve })
+ // deferred.fail(function() { bind to newDefer or newDefer.reject })
+ deferred[ tuple[ 1 ] ]( function() {
+ var returned = fn && fn.apply( this, arguments );
+ if ( returned && isFunction( returned.promise ) ) {
+ returned.promise()
+ .progress( newDefer.notify )
+ .done( newDefer.resolve )
+ .fail( newDefer.reject );
+ } else {
+ newDefer[ tuple[ 0 ] + "With" ](
+ this,
+ fn ? [ returned ] : arguments
+ );
+ }
+ } );
+ } );
+ fns = null;
+ } ).promise();
+ },
+ then: function( onFulfilled, onRejected, onProgress ) {
+ var maxDepth = 0;
+ function resolve( depth, deferred, handler, special ) {
+ return function() {
+ var that = this,
+ args = arguments,
+ mightThrow = function() {
+ var returned, then;
+
+ // Support: Promises/A+ section 2.3.3.3.3
+ // https://promisesaplus.com/#point-59
+ // Ignore double-resolution attempts
+ if ( depth < maxDepth ) {
+ return;
+ }
+
+ returned = handler.apply( that, args );
+
+ // Support: Promises/A+ section 2.3.1
+ // https://promisesaplus.com/#point-48
+ if ( returned === deferred.promise() ) {
+ throw new TypeError( "Thenable self-resolution" );
+ }
+
+ // Support: Promises/A+ sections 2.3.3.1, 3.5
+ // https://promisesaplus.com/#point-54
+ // https://promisesaplus.com/#point-75
+ // Retrieve `then` only once
+ then = returned &&
+
+ // Support: Promises/A+ section 2.3.4
+ // https://promisesaplus.com/#point-64
+ // Only check objects and functions for thenability
+ ( typeof returned === "object" ||
+ typeof returned === "function" ) &&
+ returned.then;
+
+ // Handle a returned thenable
+ if ( isFunction( then ) ) {
+
+ // Special processors (notify) just wait for resolution
+ if ( special ) {
+ then.call(
+ returned,
+ resolve( maxDepth, deferred, Identity, special ),
+ resolve( maxDepth, deferred, Thrower, special )
+ );
+
+ // Normal processors (resolve) also hook into progress
+ } else {
+
+ // ...and disregard older resolution values
+ maxDepth++;
+
+ then.call(
+ returned,
+ resolve( maxDepth, deferred, Identity, special ),
+ resolve( maxDepth, deferred, Thrower, special ),
+ resolve( maxDepth, deferred, Identity,
+ deferred.notifyWith )
+ );
+ }
+
+ // Handle all other returned values
+ } else {
+
+ // Only substitute handlers pass on context
+ // and multiple values (non-spec behavior)
+ if ( handler !== Identity ) {
+ that = undefined;
+ args = [ returned ];
+ }
+
+ // Process the value(s)
+ // Default process is resolve
+ ( special || deferred.resolveWith )( that, args );
+ }
+ },
+
+ // Only normal processors (resolve) catch and reject exceptions
+ process = special ?
+ mightThrow :
+ function() {
+ try {
+ mightThrow();
+ } catch ( e ) {
+
+ if ( jQuery.Deferred.exceptionHook ) {
+ jQuery.Deferred.exceptionHook( e,
+ process.stackTrace );
+ }
+
+ // Support: Promises/A+ section 2.3.3.3.4.1
+ // https://promisesaplus.com/#point-61
+ // Ignore post-resolution exceptions
+ if ( depth + 1 >= maxDepth ) {
+
+ // Only substitute handlers pass on context
+ // and multiple values (non-spec behavior)
+ if ( handler !== Thrower ) {
+ that = undefined;
+ args = [ e ];
+ }
+
+ deferred.rejectWith( that, args );
+ }
+ }
+ };
+
+ // Support: Promises/A+ section 2.3.3.3.1
+ // https://promisesaplus.com/#point-57
+ // Re-resolve promises immediately to dodge false rejection from
+ // subsequent errors
+ if ( depth ) {
+ process();
+ } else {
+
+ // Call an optional hook to record the stack, in case of exception
+ // since it's otherwise lost when execution goes async
+ if ( jQuery.Deferred.getStackHook ) {
+ process.stackTrace = jQuery.Deferred.getStackHook();
+ }
+ window.setTimeout( process );
+ }
+ };
+ }
+
+ return jQuery.Deferred( function( newDefer ) {
+
+ // progress_handlers.add( ... )
+ tuples[ 0 ][ 3 ].add(
+ resolve(
+ 0,
+ newDefer,
+ isFunction( onProgress ) ?
+ onProgress :
+ Identity,
+ newDefer.notifyWith
+ )
+ );
+
+ // fulfilled_handlers.add( ... )
+ tuples[ 1 ][ 3 ].add(
+ resolve(
+ 0,
+ newDefer,
+ isFunction( onFulfilled ) ?
+ onFulfilled :
+ Identity
+ )
+ );
+
+ // rejected_handlers.add( ... )
+ tuples[ 2 ][ 3 ].add(
+ resolve(
+ 0,
+ newDefer,
+ isFunction( onRejected ) ?
+ onRejected :
+ Thrower
+ )
+ );
+ } ).promise();
+ },
+
+ // Get a promise for this deferred
+ // If obj is provided, the promise aspect is added to the object
+ promise: function( obj ) {
+ return obj != null ? jQuery.extend( obj, promise ) : promise;
+ }
+ },
+ deferred = {};
+
+ // Add list-specific methods
+ jQuery.each( tuples, function( i, tuple ) {
+ var list = tuple[ 2 ],
+ stateString = tuple[ 5 ];
+
+ // promise.progress = list.add
+ // promise.done = list.add
+ // promise.fail = list.add
+ promise[ tuple[ 1 ] ] = list.add;
+
+ // Handle state
+ if ( stateString ) {
+ list.add(
+ function() {
+
+ // state = "resolved" (i.e., fulfilled)
+ // state = "rejected"
+ state = stateString;
+ },
+
+ // rejected_callbacks.disable
+ // fulfilled_callbacks.disable
+ tuples[ 3 - i ][ 2 ].disable,
+
+ // rejected_handlers.disable
+ // fulfilled_handlers.disable
+ tuples[ 3 - i ][ 3 ].disable,
+
+ // progress_callbacks.lock
+ tuples[ 0 ][ 2 ].lock,
+
+ // progress_handlers.lock
+ tuples[ 0 ][ 3 ].lock
+ );
+ }
+
+ // progress_handlers.fire
+ // fulfilled_handlers.fire
+ // rejected_handlers.fire
+ list.add( tuple[ 3 ].fire );
+
+ // deferred.notify = function() { deferred.notifyWith(...) }
+ // deferred.resolve = function() { deferred.resolveWith(...) }
+ // deferred.reject = function() { deferred.rejectWith(...) }
+ deferred[ tuple[ 0 ] ] = function() {
+ deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
+ return this;
+ };
+
+ // deferred.notifyWith = list.fireWith
+ // deferred.resolveWith = list.fireWith
+ // deferred.rejectWith = list.fireWith
+ deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
+ } );
+
+ // Make the deferred a promise
+ promise.promise( deferred );
+
+ // Call given func if any
+ if ( func ) {
+ func.call( deferred, deferred );
+ }
+
+ // All done!
+ return deferred;
+ },
+
+ // Deferred helper
+ when: function( singleValue ) {
+ var
+
+ // count of uncompleted subordinates
+ remaining = arguments.length,
+
+ // count of unprocessed arguments
+ i = remaining,
+
+ // subordinate fulfillment data
+ resolveContexts = Array( i ),
+ resolveValues = slice.call( arguments ),
+
+ // the primary Deferred
+ primary = jQuery.Deferred(),
+
+ // subordinate callback factory
+ updateFunc = function( i ) {
+ return function( value ) {
+ resolveContexts[ i ] = this;
+ resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
+ if ( !( --remaining ) ) {
+ primary.resolveWith( resolveContexts, resolveValues );
+ }
+ };
+ };
+
+ // Single- and empty arguments are adopted like Promise.resolve
+ if ( remaining <= 1 ) {
+ adoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject,
+ !remaining );
+
+ // Use .then() to unwrap secondary thenables (cf. gh-3000)
+ if ( primary.state() === "pending" ||
+ isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
+
+ return primary.then();
+ }
+ }
+
+ // Multiple arguments are aggregated like Promise.all array elements
+ while ( i-- ) {
+ adoptValue( resolveValues[ i ], updateFunc( i ), primary.reject );
+ }
+
+ return primary.promise();
+ }
+} );
+
+
+// These usually indicate a programmer mistake during development,
+// warn about them ASAP rather than swallowing them by default.
+var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
+
+jQuery.Deferred.exceptionHook = function( error, stack ) {
+
+ // Support: IE 8 - 9 only
+ // Console exists when dev tools are open, which can happen at any time
+ if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
+ window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
+ }
+};
+
+
+
+
+jQuery.readyException = function( error ) {
+ window.setTimeout( function() {
+ throw error;
+ } );
+};
+
+
+
+
+// The deferred used on DOM ready
+var readyList = jQuery.Deferred();
+
+jQuery.fn.ready = function( fn ) {
+
+ readyList
+ .then( fn )
+
+ // Wrap jQuery.readyException in a function so that the lookup
+ // happens at the time of error handling instead of callback
+ // registration.
+ .catch( function( error ) {
+ jQuery.readyException( error );
+ } );
+
+ return this;
+};
+
+jQuery.extend( {
+
+ // Is the DOM ready to be used? Set to true once it occurs.
+ isReady: false,
+
+ // A counter to track how many items to wait for before
+ // the ready event fires. See #6781
+ readyWait: 1,
+
+ // Handle when the DOM is ready
+ ready: function( wait ) {
+
+ // Abort if there are pending holds or we're already ready
+ if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
+ return;
+ }
+
+ // Remember that the DOM is ready
+ jQuery.isReady = true;
+
+ // If a normal DOM Ready event fired, decrement, and wait if need be
+ if ( wait !== true && --jQuery.readyWait > 0 ) {
+ return;
+ }
+
+ // If there are functions bound, to execute
+ readyList.resolveWith( document, [ jQuery ] );
+ }
+} );
+
+jQuery.ready.then = readyList.then;
+
+// The ready event handler and self cleanup method
+function completed() {
+ document.removeEventListener( "DOMContentLoaded", completed );
+ window.removeEventListener( "load", completed );
+ jQuery.ready();
+}
+
+// Catch cases where $(document).ready() is called
+// after the browser event has already occurred.
+// Support: IE <=9 - 10 only
+// Older IE sometimes signals "interactive" too soon
+if ( document.readyState === "complete" ||
+ ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
+
+ // Handle it asynchronously to allow scripts the opportunity to delay ready
+ window.setTimeout( jQuery.ready );
+
+} else {
+
+ // Use the handy event callback
+ document.addEventListener( "DOMContentLoaded", completed );
+
+ // A fallback to window.onload, that will always work
+ window.addEventListener( "load", completed );
+}
+
+
+
+
+// Multifunctional method to get and set values of a collection
+// The value/s can optionally be executed if it's a function
+var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
+ var i = 0,
+ len = elems.length,
+ bulk = key == null;
+
+ // Sets many values
+ if ( toType( key ) === "object" ) {
+ chainable = true;
+ for ( i in key ) {
+ access( elems, fn, i, key[ i ], true, emptyGet, raw );
+ }
+
+ // Sets one value
+ } else if ( value !== undefined ) {
+ chainable = true;
+
+ if ( !isFunction( value ) ) {
+ raw = true;
+ }
+
+ if ( bulk ) {
+
+ // Bulk operations run against the entire set
+ if ( raw ) {
+ fn.call( elems, value );
+ fn = null;
+
+ // ...except when executing function values
+ } else {
+ bulk = fn;
+ fn = function( elem, _key, value ) {
+ return bulk.call( jQuery( elem ), value );
+ };
+ }
+ }
+
+ if ( fn ) {
+ for ( ; i < len; i++ ) {
+ fn(
+ elems[ i ], key, raw ?
+ value :
+ value.call( elems[ i ], i, fn( elems[ i ], key ) )
+ );
+ }
+ }
+ }
+
+ if ( chainable ) {
+ return elems;
+ }
+
+ // Gets
+ if ( bulk ) {
+ return fn.call( elems );
+ }
+
+ return len ? fn( elems[ 0 ], key ) : emptyGet;
+};
+
+
+// Matches dashed string for camelizing
+var rmsPrefix = /^-ms-/,
+ rdashAlpha = /-([a-z])/g;
+
+// Used by camelCase as callback to replace()
+function fcamelCase( _all, letter ) {
+ return letter.toUpperCase();
+}
+
+// Convert dashed to camelCase; used by the css and data modules
+// Support: IE <=9 - 11, Edge 12 - 15
+// Microsoft forgot to hump their vendor prefix (#9572)
+function camelCase( string ) {
+ return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
+}
+var acceptData = function( owner ) {
+
+ // Accepts only:
+ // - Node
+ // - Node.ELEMENT_NODE
+ // - Node.DOCUMENT_NODE
+ // - Object
+ // - Any
+ return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
+};
+
+
+
+
+function Data() {
+ this.expando = jQuery.expando + Data.uid++;
+}
+
+Data.uid = 1;
+
+Data.prototype = {
+
+ cache: function( owner ) {
+
+ // Check if the owner object already has a cache
+ var value = owner[ this.expando ];
+
+ // If not, create one
+ if ( !value ) {
+ value = {};
+
+ // We can accept data for non-element nodes in modern browsers,
+ // but we should not, see #8335.
+ // Always return an empty object.
+ if ( acceptData( owner ) ) {
+
+ // If it is a node unlikely to be stringify-ed or looped over
+ // use plain assignment
+ if ( owner.nodeType ) {
+ owner[ this.expando ] = value;
+
+ // Otherwise secure it in a non-enumerable property
+ // configurable must be true to allow the property to be
+ // deleted when data is removed
+ } else {
+ Object.defineProperty( owner, this.expando, {
+ value: value,
+ configurable: true
+ } );
+ }
+ }
+ }
+
+ return value;
+ },
+ set: function( owner, data, value ) {
+ var prop,
+ cache = this.cache( owner );
+
+ // Handle: [ owner, key, value ] args
+ // Always use camelCase key (gh-2257)
+ if ( typeof data === "string" ) {
+ cache[ camelCase( data ) ] = value;
+
+ // Handle: [ owner, { properties } ] args
+ } else {
+
+ // Copy the properties one-by-one to the cache object
+ for ( prop in data ) {
+ cache[ camelCase( prop ) ] = data[ prop ];
+ }
+ }
+ return cache;
+ },
+ get: function( owner, key ) {
+ return key === undefined ?
+ this.cache( owner ) :
+
+ // Always use camelCase key (gh-2257)
+ owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];
+ },
+ access: function( owner, key, value ) {
+
+ // In cases where either:
+ //
+ // 1. No key was specified
+ // 2. A string key was specified, but no value provided
+ //
+ // Take the "read" path and allow the get method to determine
+ // which value to return, respectively either:
+ //
+ // 1. The entire cache object
+ // 2. The data stored at the key
+ //
+ if ( key === undefined ||
+ ( ( key && typeof key === "string" ) && value === undefined ) ) {
+
+ return this.get( owner, key );
+ }
+
+ // When the key is not a string, or both a key and value
+ // are specified, set or extend (existing objects) with either:
+ //
+ // 1. An object of properties
+ // 2. A key and value
+ //
+ this.set( owner, key, value );
+
+ // Since the "set" path can have two possible entry points
+ // return the expected data based on which path was taken[*]
+ return value !== undefined ? value : key;
+ },
+ remove: function( owner, key ) {
+ var i,
+ cache = owner[ this.expando ];
+
+ if ( cache === undefined ) {
+ return;
+ }
+
+ if ( key !== undefined ) {
+
+ // Support array or space separated string of keys
+ if ( Array.isArray( key ) ) {
+
+ // If key is an array of keys...
+ // We always set camelCase keys, so remove that.
+ key = key.map( camelCase );
+ } else {
+ key = camelCase( key );
+
+ // If a key with the spaces exists, use it.
+ // Otherwise, create an array by matching non-whitespace
+ key = key in cache ?
+ [ key ] :
+ ( key.match( rnothtmlwhite ) || [] );
+ }
+
+ i = key.length;
+
+ while ( i-- ) {
+ delete cache[ key[ i ] ];
+ }
+ }
+
+ // Remove the expando if there's no more data
+ if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
+
+ // Support: Chrome <=35 - 45
+ // Webkit & Blink performance suffers when deleting properties
+ // from DOM nodes, so set to undefined instead
+ // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
+ if ( owner.nodeType ) {
+ owner[ this.expando ] = undefined;
+ } else {
+ delete owner[ this.expando ];
+ }
+ }
+ },
+ hasData: function( owner ) {
+ var cache = owner[ this.expando ];
+ return cache !== undefined && !jQuery.isEmptyObject( cache );
+ }
+};
+var dataPriv = new Data();
+
+var dataUser = new Data();
+
+
+
+// Implementation Summary
+//
+// 1. Enforce API surface and semantic compatibility with 1.9.x branch
+// 2. Improve the module's maintainability by reducing the storage
+// paths to a single mechanism.
+// 3. Use the same single mechanism to support "private" and "user" data.
+// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
+// 5. Avoid exposing implementation details on user objects (eg. expando properties)
+// 6. Provide a clear path for implementation upgrade to WeakMap in 2014
+
+var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
+ rmultiDash = /[A-Z]/g;
+
+function getData( data ) {
+ if ( data === "true" ) {
+ return true;
+ }
+
+ if ( data === "false" ) {
+ return false;
+ }
+
+ if ( data === "null" ) {
+ return null;
+ }
+
+ // Only convert to a number if it doesn't change the string
+ if ( data === +data + "" ) {
+ return +data;
+ }
+
+ if ( rbrace.test( data ) ) {
+ return JSON.parse( data );
+ }
+
+ return data;
+}
+
+function dataAttr( elem, key, data ) {
+ var name;
+
+ // If nothing was found internally, try to fetch any
+ // data from the HTML5 data-* attribute
+ if ( data === undefined && elem.nodeType === 1 ) {
+ name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
+ data = elem.getAttribute( name );
+
+ if ( typeof data === "string" ) {
+ try {
+ data = getData( data );
+ } catch ( e ) {}
+
+ // Make sure we set the data so it isn't changed later
+ dataUser.set( elem, key, data );
+ } else {
+ data = undefined;
+ }
+ }
+ return data;
+}
+
+jQuery.extend( {
+ hasData: function( elem ) {
+ return dataUser.hasData( elem ) || dataPriv.hasData( elem );
+ },
+
+ data: function( elem, name, data ) {
+ return dataUser.access( elem, name, data );
+ },
+
+ removeData: function( elem, name ) {
+ dataUser.remove( elem, name );
+ },
+
+ // TODO: Now that all calls to _data and _removeData have been replaced
+ // with direct calls to dataPriv methods, these can be deprecated.
+ _data: function( elem, name, data ) {
+ return dataPriv.access( elem, name, data );
+ },
+
+ _removeData: function( elem, name ) {
+ dataPriv.remove( elem, name );
+ }
+} );
+
+jQuery.fn.extend( {
+ data: function( key, value ) {
+ var i, name, data,
+ elem = this[ 0 ],
+ attrs = elem && elem.attributes;
+
+ // Gets all values
+ if ( key === undefined ) {
+ if ( this.length ) {
+ data = dataUser.get( elem );
+
+ if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
+ i = attrs.length;
+ while ( i-- ) {
+
+ // Support: IE 11 only
+ // The attrs elements can be null (#14894)
+ if ( attrs[ i ] ) {
+ name = attrs[ i ].name;
+ if ( name.indexOf( "data-" ) === 0 ) {
+ name = camelCase( name.slice( 5 ) );
+ dataAttr( elem, name, data[ name ] );
+ }
+ }
+ }
+ dataPriv.set( elem, "hasDataAttrs", true );
+ }
+ }
+
+ return data;
+ }
+
+ // Sets multiple values
+ if ( typeof key === "object" ) {
+ return this.each( function() {
+ dataUser.set( this, key );
+ } );
+ }
+
+ return access( this, function( value ) {
+ var data;
+
+ // The calling jQuery object (element matches) is not empty
+ // (and therefore has an element appears at this[ 0 ]) and the
+ // `value` parameter was not undefined. An empty jQuery object
+ // will result in `undefined` for elem = this[ 0 ] which will
+ // throw an exception if an attempt to read a data cache is made.
+ if ( elem && value === undefined ) {
+
+ // Attempt to get data from the cache
+ // The key will always be camelCased in Data
+ data = dataUser.get( elem, key );
+ if ( data !== undefined ) {
+ return data;
+ }
+
+ // Attempt to "discover" the data in
+ // HTML5 custom data-* attrs
+ data = dataAttr( elem, key );
+ if ( data !== undefined ) {
+ return data;
+ }
+
+ // We tried really hard, but the data doesn't exist.
+ return;
+ }
+
+ // Set the data...
+ this.each( function() {
+
+ // We always store the camelCased key
+ dataUser.set( this, key, value );
+ } );
+ }, null, value, arguments.length > 1, null, true );
+ },
+
+ removeData: function( key ) {
+ return this.each( function() {
+ dataUser.remove( this, key );
+ } );
+ }
+} );
+
+
+jQuery.extend( {
+ queue: function( elem, type, data ) {
+ var queue;
+
+ if ( elem ) {
+ type = ( type || "fx" ) + "queue";
+ queue = dataPriv.get( elem, type );
+
+ // Speed up dequeue by getting out quickly if this is just a lookup
+ if ( data ) {
+ if ( !queue || Array.isArray( data ) ) {
+ queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
+ } else {
+ queue.push( data );
+ }
+ }
+ return queue || [];
+ }
+ },
+
+ dequeue: function( elem, type ) {
+ type = type || "fx";
+
+ var queue = jQuery.queue( elem, type ),
+ startLength = queue.length,
+ fn = queue.shift(),
+ hooks = jQuery._queueHooks( elem, type ),
+ next = function() {
+ jQuery.dequeue( elem, type );
+ };
+
+ // If the fx queue is dequeued, always remove the progress sentinel
+ if ( fn === "inprogress" ) {
+ fn = queue.shift();
+ startLength--;
+ }
+
+ if ( fn ) {
+
+ // Add a progress sentinel to prevent the fx queue from being
+ // automatically dequeued
+ if ( type === "fx" ) {
+ queue.unshift( "inprogress" );
+ }
+
+ // Clear up the last queue stop function
+ delete hooks.stop;
+ fn.call( elem, next, hooks );
+ }
+
+ if ( !startLength && hooks ) {
+ hooks.empty.fire();
+ }
+ },
+
+ // Not public - generate a queueHooks object, or return the current one
+ _queueHooks: function( elem, type ) {
+ var key = type + "queueHooks";
+ return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
+ empty: jQuery.Callbacks( "once memory" ).add( function() {
+ dataPriv.remove( elem, [ type + "queue", key ] );
+ } )
+ } );
+ }
+} );
+
+jQuery.fn.extend( {
+ queue: function( type, data ) {
+ var setter = 2;
+
+ if ( typeof type !== "string" ) {
+ data = type;
+ type = "fx";
+ setter--;
+ }
+
+ if ( arguments.length < setter ) {
+ return jQuery.queue( this[ 0 ], type );
+ }
+
+ return data === undefined ?
+ this :
+ this.each( function() {
+ var queue = jQuery.queue( this, type, data );
+
+ // Ensure a hooks for this queue
+ jQuery._queueHooks( this, type );
+
+ if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
+ jQuery.dequeue( this, type );
+ }
+ } );
+ },
+ dequeue: function( type ) {
+ return this.each( function() {
+ jQuery.dequeue( this, type );
+ } );
+ },
+ clearQueue: function( type ) {
+ return this.queue( type || "fx", [] );
+ },
+
+ // Get a promise resolved when queues of a certain type
+ // are emptied (fx is the type by default)
+ promise: function( type, obj ) {
+ var tmp,
+ count = 1,
+ defer = jQuery.Deferred(),
+ elements = this,
+ i = this.length,
+ resolve = function() {
+ if ( !( --count ) ) {
+ defer.resolveWith( elements, [ elements ] );
+ }
+ };
+
+ if ( typeof type !== "string" ) {
+ obj = type;
+ type = undefined;
+ }
+ type = type || "fx";
+
+ while ( i-- ) {
+ tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
+ if ( tmp && tmp.empty ) {
+ count++;
+ tmp.empty.add( resolve );
+ }
+ }
+ resolve();
+ return defer.promise( obj );
+ }
+} );
+var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
+
+var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
+
+
+var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
+
+var documentElement = document.documentElement;
+
+
+
+ var isAttached = function( elem ) {
+ return jQuery.contains( elem.ownerDocument, elem );
+ },
+ composed = { composed: true };
+
+ // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only
+ // Check attachment across shadow DOM boundaries when possible (gh-3504)
+ // Support: iOS 10.0-10.2 only
+ // Early iOS 10 versions support `attachShadow` but not `getRootNode`,
+ // leading to errors. We need to check for `getRootNode`.
+ if ( documentElement.getRootNode ) {
+ isAttached = function( elem ) {
+ return jQuery.contains( elem.ownerDocument, elem ) ||
+ elem.getRootNode( composed ) === elem.ownerDocument;
+ };
+ }
+var isHiddenWithinTree = function( elem, el ) {
+
+ // isHiddenWithinTree might be called from jQuery#filter function;
+ // in that case, element will be second argument
+ elem = el || elem;
+
+ // Inline style trumps all
+ return elem.style.display === "none" ||
+ elem.style.display === "" &&
+
+ // Otherwise, check computed style
+ // Support: Firefox <=43 - 45
+ // Disconnected elements can have computed display: none, so first confirm that elem is
+ // in the document.
+ isAttached( elem ) &&
+
+ jQuery.css( elem, "display" ) === "none";
+ };
+
+
+
+function adjustCSS( elem, prop, valueParts, tween ) {
+ var adjusted, scale,
+ maxIterations = 20,
+ currentValue = tween ?
+ function() {
+ return tween.cur();
+ } :
+ function() {
+ return jQuery.css( elem, prop, "" );
+ },
+ initial = currentValue(),
+ unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
+
+ // Starting value computation is required for potential unit mismatches
+ initialInUnit = elem.nodeType &&
+ ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
+ rcssNum.exec( jQuery.css( elem, prop ) );
+
+ if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
+
+ // Support: Firefox <=54
+ // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)
+ initial = initial / 2;
+
+ // Trust units reported by jQuery.css
+ unit = unit || initialInUnit[ 3 ];
+
+ // Iteratively approximate from a nonzero starting point
+ initialInUnit = +initial || 1;
+
+ while ( maxIterations-- ) {
+
+ // Evaluate and update our best guess (doubling guesses that zero out).
+ // Finish if the scale equals or crosses 1 (making the old*new product non-positive).
+ jQuery.style( elem, prop, initialInUnit + unit );
+ if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {
+ maxIterations = 0;
+ }
+ initialInUnit = initialInUnit / scale;
+
+ }
+
+ initialInUnit = initialInUnit * 2;
+ jQuery.style( elem, prop, initialInUnit + unit );
+
+ // Make sure we update the tween properties later on
+ valueParts = valueParts || [];
+ }
+
+ if ( valueParts ) {
+ initialInUnit = +initialInUnit || +initial || 0;
+
+ // Apply relative offset (+=/-=) if specified
+ adjusted = valueParts[ 1 ] ?
+ initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
+ +valueParts[ 2 ];
+ if ( tween ) {
+ tween.unit = unit;
+ tween.start = initialInUnit;
+ tween.end = adjusted;
+ }
+ }
+ return adjusted;
+}
+
+
+var defaultDisplayMap = {};
+
+function getDefaultDisplay( elem ) {
+ var temp,
+ doc = elem.ownerDocument,
+ nodeName = elem.nodeName,
+ display = defaultDisplayMap[ nodeName ];
+
+ if ( display ) {
+ return display;
+ }
+
+ temp = doc.body.appendChild( doc.createElement( nodeName ) );
+ display = jQuery.css( temp, "display" );
+
+ temp.parentNode.removeChild( temp );
+
+ if ( display === "none" ) {
+ display = "block";
+ }
+ defaultDisplayMap[ nodeName ] = display;
+
+ return display;
+}
+
+function showHide( elements, show ) {
+ var display, elem,
+ values = [],
+ index = 0,
+ length = elements.length;
+
+ // Determine new display value for elements that need to change
+ for ( ; index < length; index++ ) {
+ elem = elements[ index ];
+ if ( !elem.style ) {
+ continue;
+ }
+
+ display = elem.style.display;
+ if ( show ) {
+
+ // Since we force visibility upon cascade-hidden elements, an immediate (and slow)
+ // check is required in this first loop unless we have a nonempty display value (either
+ // inline or about-to-be-restored)
+ if ( display === "none" ) {
+ values[ index ] = dataPriv.get( elem, "display" ) || null;
+ if ( !values[ index ] ) {
+ elem.style.display = "";
+ }
+ }
+ if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
+ values[ index ] = getDefaultDisplay( elem );
+ }
+ } else {
+ if ( display !== "none" ) {
+ values[ index ] = "none";
+
+ // Remember what we're overwriting
+ dataPriv.set( elem, "display", display );
+ }
+ }
+ }
+
+ // Set the display of the elements in a second loop to avoid constant reflow
+ for ( index = 0; index < length; index++ ) {
+ if ( values[ index ] != null ) {
+ elements[ index ].style.display = values[ index ];
+ }
+ }
+
+ return elements;
+}
+
+jQuery.fn.extend( {
+ show: function() {
+ return showHide( this, true );
+ },
+ hide: function() {
+ return showHide( this );
+ },
+ toggle: function( state ) {
+ if ( typeof state === "boolean" ) {
+ return state ? this.show() : this.hide();
+ }
+
+ return this.each( function() {
+ if ( isHiddenWithinTree( this ) ) {
+ jQuery( this ).show();
+ } else {
+ jQuery( this ).hide();
+ }
+ } );
+ }
+} );
+var rcheckableType = ( /^(?:checkbox|radio)$/i );
+
+var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i );
+
+var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i );
+
+
+
+( function() {
+ var fragment = document.createDocumentFragment(),
+ div = fragment.appendChild( document.createElement( "div" ) ),
+ input = document.createElement( "input" );
+
+ // Support: Android 4.0 - 4.3 only
+ // Check state lost if the name is set (#11217)
+ // Support: Windows Web Apps (WWA)
+ // `name` and `type` must use .setAttribute for WWA (#14901)
+ input.setAttribute( "type", "radio" );
+ input.setAttribute( "checked", "checked" );
+ input.setAttribute( "name", "t" );
+
+ div.appendChild( input );
+
+ // Support: Android <=4.1 only
+ // Older WebKit doesn't clone checked state correctly in fragments
+ support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
+
+ // Support: IE <=11 only
+ // Make sure textarea (and checkbox) defaultValue is properly cloned
+ div.innerHTML = "<textarea>x</textarea>";
+ support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
+
+ // Support: IE <=9 only
+ // IE <=9 replaces <option> tags with their contents when inserted outside of
+ // the select element.
+ div.innerHTML = "<option></option>";
+ support.option = !!div.lastChild;
+} )();
+
+
+// We have to close these tags to support XHTML (#13200)
+var wrapMap = {
+
+ // XHTML parsers do not magically insert elements in the
+ // same way that tag soup parsers do. So we cannot shorten
+ // this by omitting <tbody> or other required elements.
+ thead: [ 1, "<table>", "</table>" ],
+ col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
+ tr: [ 2, "<table><tbody>", "</tbody></table>" ],
+ td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
+
+ _default: [ 0, "", "" ]
+};
+
+wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
+wrapMap.th = wrapMap.td;
+
+// Support: IE <=9 only
+if ( !support.option ) {
+ wrapMap.optgroup = wrapMap.option = [ 1, "<select multiple='multiple'>", "</select>" ];
+}
+
+
+function getAll( context, tag ) {
+
+ // Support: IE <=9 - 11 only
+ // Use typeof to avoid zero-argument method invocation on host objects (#15151)
+ var ret;
+
+ if ( typeof context.getElementsByTagName !== "undefined" ) {
+ ret = context.getElementsByTagName( tag || "*" );
+
+ } else if ( typeof context.querySelectorAll !== "undefined" ) {
+ ret = context.querySelectorAll( tag || "*" );
+
+ } else {
+ ret = [];
+ }
+
+ if ( tag === undefined || tag && nodeName( context, tag ) ) {
+ return jQuery.merge( [ context ], ret );
+ }
+
+ return ret;
+}
+
+
+// Mark scripts as having already been evaluated
+function setGlobalEval( elems, refElements ) {
+ var i = 0,
+ l = elems.length;
+
+ for ( ; i < l; i++ ) {
+ dataPriv.set(
+ elems[ i ],
+ "globalEval",
+ !refElements || dataPriv.get( refElements[ i ], "globalEval" )
+ );
+ }
+}
+
+
+var rhtml = /<|&#?\w+;/;
+
+function buildFragment( elems, context, scripts, selection, ignored ) {
+ var elem, tmp, tag, wrap, attached, j,
+ fragment = context.createDocumentFragment(),
+ nodes = [],
+ i = 0,
+ l = elems.length;
+
+ for ( ; i < l; i++ ) {
+ elem = elems[ i ];
+
+ if ( elem || elem === 0 ) {
+
+ // Add nodes directly
+ if ( toType( elem ) === "object" ) {
+
+ // Support: Android <=4.0 only, PhantomJS 1 only
+ // push.apply(_, arraylike) throws on ancient WebKit
+ jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
+
+ // Convert non-html into a text node
+ } else if ( !rhtml.test( elem ) ) {
+ nodes.push( context.createTextNode( elem ) );
+
+ // Convert html into DOM nodes
+ } else {
+ tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
+
+ // Deserialize a standard representation
+ tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
+ wrap = wrapMap[ tag ] || wrapMap._default;
+ tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
+
+ // Descend through wrappers to the right content
+ j = wrap[ 0 ];
+ while ( j-- ) {
+ tmp = tmp.lastChild;
+ }
+
+ // Support: Android <=4.0 only, PhantomJS 1 only
+ // push.apply(_, arraylike) throws on ancient WebKit
+ jQuery.merge( nodes, tmp.childNodes );
+
+ // Remember the top-level container
+ tmp = fragment.firstChild;
+
+ // Ensure the created nodes are orphaned (#12392)
+ tmp.textContent = "";
+ }
+ }
+ }
+
+ // Remove wrapper from fragment
+ fragment.textContent = "";
+
+ i = 0;
+ while ( ( elem = nodes[ i++ ] ) ) {
+
+ // Skip elements already in the context collection (trac-4087)
+ if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
+ if ( ignored ) {
+ ignored.push( elem );
+ }
+ continue;
+ }
+
+ attached = isAttached( elem );
+
+ // Append to fragment
+ tmp = getAll( fragment.appendChild( elem ), "script" );
+
+ // Preserve script evaluation history
+ if ( attached ) {
+ setGlobalEval( tmp );
+ }
+
+ // Capture executables
+ if ( scripts ) {
+ j = 0;
+ while ( ( elem = tmp[ j++ ] ) ) {
+ if ( rscriptType.test( elem.type || "" ) ) {
+ scripts.push( elem );
+ }
+ }
+ }
+ }
+
+ return fragment;
+}
+
+
+var rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
+
+function returnTrue() {
+ return true;
+}
+
+function returnFalse() {
+ return false;
+}
+
+// Support: IE <=9 - 11+
+// focus() and blur() are asynchronous, except when they are no-op.
+// So expect focus to be synchronous when the element is already active,
+// and blur to be synchronous when the element is not already active.
+// (focus and blur are always synchronous in other supported browsers,
+// this just defines when we can count on it).
+function expectSync( elem, type ) {
+ return ( elem === safeActiveElement() ) === ( type === "focus" );
+}
+
+// Support: IE <=9 only
+// Accessing document.activeElement can throw unexpectedly
+// https://bugs.jquery.com/ticket/13393
+function safeActiveElement() {
+ try {
+ return document.activeElement;
+ } catch ( err ) { }
+}
+
+function on( elem, types, selector, data, fn, one ) {
+ var origFn, type;
+
+ // Types can be a map of types/handlers
+ if ( typeof types === "object" ) {
+
+ // ( types-Object, selector, data )
+ if ( typeof selector !== "string" ) {
+
+ // ( types-Object, data )
+ data = data || selector;
+ selector = undefined;
+ }
+ for ( type in types ) {
+ on( elem, type, selector, data, types[ type ], one );
+ }
+ return elem;
+ }
+
+ if ( data == null && fn == null ) {
+
+ // ( types, fn )
+ fn = selector;
+ data = selector = undefined;
+ } else if ( fn == null ) {
+ if ( typeof selector === "string" ) {
+
+ // ( types, selector, fn )
+ fn = data;
+ data = undefined;
+ } else {
+
+ // ( types, data, fn )
+ fn = data;
+ data = selector;
+ selector = undefined;
+ }
+ }
+ if ( fn === false ) {
+ fn = returnFalse;
+ } else if ( !fn ) {
+ return elem;
+ }
+
+ if ( one === 1 ) {
+ origFn = fn;
+ fn = function( event ) {
+
+ // Can use an empty set, since event contains the info
+ jQuery().off( event );
+ return origFn.apply( this, arguments );
+ };
+
+ // Use same guid so caller can remove using origFn
+ fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
+ }
+ return elem.each( function() {
+ jQuery.event.add( this, types, fn, data, selector );
+ } );
+}
+
+/*
+ * Helper functions for managing events -- not part of the public interface.
+ * Props to Dean Edwards' addEvent library for many of the ideas.
+ */
+jQuery.event = {
+
+ global: {},
+
+ add: function( elem, types, handler, data, selector ) {
+
+ var handleObjIn, eventHandle, tmp,
+ events, t, handleObj,
+ special, handlers, type, namespaces, origType,
+ elemData = dataPriv.get( elem );
+
+ // Only attach events to objects that accept data
+ if ( !acceptData( elem ) ) {
+ return;
+ }
+
+ // Caller can pass in an object of custom data in lieu of the handler
+ if ( handler.handler ) {
+ handleObjIn = handler;
+ handler = handleObjIn.handler;
+ selector = handleObjIn.selector;
+ }
+
+ // Ensure that invalid selectors throw exceptions at attach time
+ // Evaluate against documentElement in case elem is a non-element node (e.g., document)
+ if ( selector ) {
+ jQuery.find.matchesSelector( documentElement, selector );
+ }
+
+ // Make sure that the handler has a unique ID, used to find/remove it later
+ if ( !handler.guid ) {
+ handler.guid = jQuery.guid++;
+ }
+
+ // Init the element's event structure and main handler, if this is the first
+ if ( !( events = elemData.events ) ) {
+ events = elemData.events = Object.create( null );
+ }
+ if ( !( eventHandle = elemData.handle ) ) {
+ eventHandle = elemData.handle = function( e ) {
+
+ // Discard the second event of a jQuery.event.trigger() and
+ // when an event is called after a page has unloaded
+ return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
+ jQuery.event.dispatch.apply( elem, arguments ) : undefined;
+ };
+ }
+
+ // Handle multiple events separated by a space
+ types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
+ t = types.length;
+ while ( t-- ) {
+ tmp = rtypenamespace.exec( types[ t ] ) || [];
+ type = origType = tmp[ 1 ];
+ namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
+
+ // There *must* be a type, no attaching namespace-only handlers
+ if ( !type ) {
+ continue;
+ }
+
+ // If event changes its type, use the special event handlers for the changed type
+ special = jQuery.event.special[ type ] || {};
+
+ // If selector defined, determine special event api type, otherwise given type
+ type = ( selector ? special.delegateType : special.bindType ) || type;
+
+ // Update special based on newly reset type
+ special = jQuery.event.special[ type ] || {};
+
+ // handleObj is passed to all event handlers
+ handleObj = jQuery.extend( {
+ type: type,
+ origType: origType,
+ data: data,
+ handler: handler,
+ guid: handler.guid,
+ selector: selector,
+ needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
+ namespace: namespaces.join( "." )
+ }, handleObjIn );
+
+ // Init the event handler queue if we're the first
+ if ( !( handlers = events[ type ] ) ) {
+ handlers = events[ type ] = [];
+ handlers.delegateCount = 0;
+
+ // Only use addEventListener if the special events handler returns false
+ if ( !special.setup ||
+ special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
+
+ if ( elem.addEventListener ) {
+ elem.addEventListener( type, eventHandle );
+ }
+ }
+ }
+
+ if ( special.add ) {
+ special.add.call( elem, handleObj );
+
+ if ( !handleObj.handler.guid ) {
+ handleObj.handler.guid = handler.guid;
+ }
+ }
+
+ // Add to the element's handler list, delegates in front
+ if ( selector ) {
+ handlers.splice( handlers.delegateCount++, 0, handleObj );
+ } else {
+ handlers.push( handleObj );
+ }
+
+ // Keep track of which events have ever been used, for event optimization
+ jQuery.event.global[ type ] = true;
+ }
+
+ },
+
+ // Detach an event or set of events from an element
+ remove: function( elem, types, handler, selector, mappedTypes ) {
+
+ var j, origCount, tmp,
+ events, t, handleObj,
+ special, handlers, type, namespaces, origType,
+ elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
+
+ if ( !elemData || !( events = elemData.events ) ) {
+ return;
+ }
+
+ // Once for each type.namespace in types; type may be omitted
+ types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
+ t = types.length;
+ while ( t-- ) {
+ tmp = rtypenamespace.exec( types[ t ] ) || [];
+ type = origType = tmp[ 1 ];
+ namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
+
+ // Unbind all events (on this namespace, if provided) for the element
+ if ( !type ) {
+ for ( type in events ) {
+ jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
+ }
+ continue;
+ }
+
+ special = jQuery.event.special[ type ] || {};
+ type = ( selector ? special.delegateType : special.bindType ) || type;
+ handlers = events[ type ] || [];
+ tmp = tmp[ 2 ] &&
+ new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
+
+ // Remove matching events
+ origCount = j = handlers.length;
+ while ( j-- ) {
+ handleObj = handlers[ j ];
+
+ if ( ( mappedTypes || origType === handleObj.origType ) &&
+ ( !handler || handler.guid === handleObj.guid ) &&
+ ( !tmp || tmp.test( handleObj.namespace ) ) &&
+ ( !selector || selector === handleObj.selector ||
+ selector === "**" && handleObj.selector ) ) {
+ handlers.splice( j, 1 );
+
+ if ( handleObj.selector ) {
+ handlers.delegateCount--;
+ }
+ if ( special.remove ) {
+ special.remove.call( elem, handleObj );
+ }
+ }
+ }
+
+ // Remove generic event handler if we removed something and no more handlers exist
+ // (avoids potential for endless recursion during removal of special event handlers)
+ if ( origCount && !handlers.length ) {
+ if ( !special.teardown ||
+ special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
+
+ jQuery.removeEvent( elem, type, elemData.handle );
+ }
+
+ delete events[ type ];
+ }
+ }
+
+ // Remove data and the expando if it's no longer used
+ if ( jQuery.isEmptyObject( events ) ) {
+ dataPriv.remove( elem, "handle events" );
+ }
+ },
+
+ dispatch: function( nativeEvent ) {
+
+ var i, j, ret, matched, handleObj, handlerQueue,
+ args = new Array( arguments.length ),
+
+ // Make a writable jQuery.Event from the native event object
+ event = jQuery.event.fix( nativeEvent ),
+
+ handlers = (
+ dataPriv.get( this, "events" ) || Object.create( null )
+ )[ event.type ] || [],
+ special = jQuery.event.special[ event.type ] || {};
+
+ // Use the fix-ed jQuery.Event rather than the (read-only) native event
+ args[ 0 ] = event;
+
+ for ( i = 1; i < arguments.length; i++ ) {
+ args[ i ] = arguments[ i ];
+ }
+
+ event.delegateTarget = this;
+
+ // Call the preDispatch hook for the mapped type, and let it bail if desired
+ if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
+ return;
+ }
+
+ // Determine handlers
+ handlerQueue = jQuery.event.handlers.call( this, event, handlers );
+
+ // Run delegates first; they may want to stop propagation beneath us
+ i = 0;
+ while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
+ event.currentTarget = matched.elem;
+
+ j = 0;
+ while ( ( handleObj = matched.handlers[ j++ ] ) &&
+ !event.isImmediatePropagationStopped() ) {
+
+ // If the event is namespaced, then each handler is only invoked if it is
+ // specially universal or its namespaces are a superset of the event's.
+ if ( !event.rnamespace || handleObj.namespace === false ||
+ event.rnamespace.test( handleObj.namespace ) ) {
+
+ event.handleObj = handleObj;
+ event.data = handleObj.data;
+
+ ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
+ handleObj.handler ).apply( matched.elem, args );
+
+ if ( ret !== undefined ) {
+ if ( ( event.result = ret ) === false ) {
+ event.preventDefault();
+ event.stopPropagation();
+ }
+ }
+ }
+ }
+ }
+
+ // Call the postDispatch hook for the mapped type
+ if ( special.postDispatch ) {
+ special.postDispatch.call( this, event );
+ }
+
+ return event.result;
+ },
+
+ handlers: function( event, handlers ) {
+ var i, handleObj, sel, matchedHandlers, matchedSelectors,
+ handlerQueue = [],
+ delegateCount = handlers.delegateCount,
+ cur = event.target;
+
+ // Find delegate handlers
+ if ( delegateCount &&
+
+ // Support: IE <=9
+ // Black-hole SVG <use> instance trees (trac-13180)
+ cur.nodeType &&
+
+ // Support: Firefox <=42
+ // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
+ // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
+ // Support: IE 11 only
+ // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
+ !( event.type === "click" && event.button >= 1 ) ) {
+
+ for ( ; cur !== this; cur = cur.parentNode || this ) {
+
+ // Don't check non-elements (#13208)
+ // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
+ if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
+ matchedHandlers = [];
+ matchedSelectors = {};
+ for ( i = 0; i < delegateCount; i++ ) {
+ handleObj = handlers[ i ];
+
+ // Don't conflict with Object.prototype properties (#13203)
+ sel = handleObj.selector + " ";
+
+ if ( matchedSelectors[ sel ] === undefined ) {
+ matchedSelectors[ sel ] = handleObj.needsContext ?
+ jQuery( sel, this ).index( cur ) > -1 :
+ jQuery.find( sel, this, null, [ cur ] ).length;
+ }
+ if ( matchedSelectors[ sel ] ) {
+ matchedHandlers.push( handleObj );
+ }
+ }
+ if ( matchedHandlers.length ) {
+ handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
+ }
+ }
+ }
+ }
+
+ // Add the remaining (directly-bound) handlers
+ cur = this;
+ if ( delegateCount < handlers.length ) {
+ handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
+ }
+
+ return handlerQueue;
+ },
+
+ addProp: function( name, hook ) {
+ Object.defineProperty( jQuery.Event.prototype, name, {
+ enumerable: true,
+ configurable: true,
+
+ get: isFunction( hook ) ?
+ function() {
+ if ( this.originalEvent ) {
+ return hook( this.originalEvent );
+ }
+ } :
+ function() {
+ if ( this.originalEvent ) {
+ return this.originalEvent[ name ];
+ }
+ },
+
+ set: function( value ) {
+ Object.defineProperty( this, name, {
+ enumerable: true,
+ configurable: true,
+ writable: true,
+ value: value
+ } );
+ }
+ } );
+ },
+
+ fix: function( originalEvent ) {
+ return originalEvent[ jQuery.expando ] ?
+ originalEvent :
+ new jQuery.Event( originalEvent );
+ },
+
+ special: {
+ load: {
+
+ // Prevent triggered image.load events from bubbling to window.load
+ noBubble: true
+ },
+ click: {
+
+ // Utilize native event to ensure correct state for checkable inputs
+ setup: function( data ) {
+
+ // For mutual compressibility with _default, replace `this` access with a local var.
+ // `|| data` is dead code meant only to preserve the variable through minification.
+ var el = this || data;
+
+ // Claim the first handler
+ if ( rcheckableType.test( el.type ) &&
+ el.click && nodeName( el, "input" ) ) {
+
+ // dataPriv.set( el, "click", ... )
+ leverageNative( el, "click", returnTrue );
+ }
+
+ // Return false to allow normal processing in the caller
+ return false;
+ },
+ trigger: function( data ) {
+
+ // For mutual compressibility with _default, replace `this` access with a local var.
+ // `|| data` is dead code meant only to preserve the variable through minification.
+ var el = this || data;
+
+ // Force setup before triggering a click
+ if ( rcheckableType.test( el.type ) &&
+ el.click && nodeName( el, "input" ) ) {
+
+ leverageNative( el, "click" );
+ }
+
+ // Return non-false to allow normal event-path propagation
+ return true;
+ },
+
+ // For cross-browser consistency, suppress native .click() on links
+ // Also prevent it if we're currently inside a leveraged native-event stack
+ _default: function( event ) {
+ var target = event.target;
+ return rcheckableType.test( target.type ) &&
+ target.click && nodeName( target, "input" ) &&
+ dataPriv.get( target, "click" ) ||
+ nodeName( target, "a" );
+ }
+ },
+
+ beforeunload: {
+ postDispatch: function( event ) {
+
+ // Support: Firefox 20+
+ // Firefox doesn't alert if the returnValue field is not set.
+ if ( event.result !== undefined && event.originalEvent ) {
+ event.originalEvent.returnValue = event.result;
+ }
+ }
+ }
+ }
+};
+
+// Ensure the presence of an event listener that handles manually-triggered
+// synthetic events by interrupting progress until reinvoked in response to
+// *native* events that it fires directly, ensuring that state changes have
+// already occurred before other listeners are invoked.
+function leverageNative( el, type, expectSync ) {
+
+ // Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add
+ if ( !expectSync ) {
+ if ( dataPriv.get( el, type ) === undefined ) {
+ jQuery.event.add( el, type, returnTrue );
+ }
+ return;
+ }
+
+ // Register the controller as a special universal handler for all event namespaces
+ dataPriv.set( el, type, false );
+ jQuery.event.add( el, type, {
+ namespace: false,
+ handler: function( event ) {
+ var notAsync, result,
+ saved = dataPriv.get( this, type );
+
+ if ( ( event.isTrigger & 1 ) && this[ type ] ) {
+
+ // Interrupt processing of the outer synthetic .trigger()ed event
+ // Saved data should be false in such cases, but might be a leftover capture object
+ // from an async native handler (gh-4350)
+ if ( !saved.length ) {
+
+ // Store arguments for use when handling the inner native event
+ // There will always be at least one argument (an event object), so this array
+ // will not be confused with a leftover capture object.
+ saved = slice.call( arguments );
+ dataPriv.set( this, type, saved );
+
+ // Trigger the native event and capture its result
+ // Support: IE <=9 - 11+
+ // focus() and blur() are asynchronous
+ notAsync = expectSync( this, type );
+ this[ type ]();
+ result = dataPriv.get( this, type );
+ if ( saved !== result || notAsync ) {
+ dataPriv.set( this, type, false );
+ } else {
+ result = {};
+ }
+ if ( saved !== result ) {
+
+ // Cancel the outer synthetic event
+ event.stopImmediatePropagation();
+ event.preventDefault();
+
+ // Support: Chrome 86+
+ // In Chrome, if an element having a focusout handler is blurred by
+ // clicking outside of it, it invokes the handler synchronously. If
+ // that handler calls `.remove()` on the element, the data is cleared,
+ // leaving `result` undefined. We need to guard against this.
+ return result && result.value;
+ }
+
+ // If this is an inner synthetic event for an event with a bubbling surrogate
+ // (focus or blur), assume that the surrogate already propagated from triggering the
+ // native event and prevent that from happening again here.
+ // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the
+ // bubbling surrogate propagates *after* the non-bubbling base), but that seems
+ // less bad than duplication.
+ } else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {
+ event.stopPropagation();
+ }
+
+ // If this is a native event triggered above, everything is now in order
+ // Fire an inner synthetic event with the original arguments
+ } else if ( saved.length ) {
+
+ // ...and capture the result
+ dataPriv.set( this, type, {
+ value: jQuery.event.trigger(
+
+ // Support: IE <=9 - 11+
+ // Extend with the prototype to reset the above stopImmediatePropagation()
+ jQuery.extend( saved[ 0 ], jQuery.Event.prototype ),
+ saved.slice( 1 ),
+ this
+ )
+ } );
+
+ // Abort handling of the native event
+ event.stopImmediatePropagation();
+ }
+ }
+ } );
+}
+
+jQuery.removeEvent = function( elem, type, handle ) {
+
+ // This "if" is needed for plain objects
+ if ( elem.removeEventListener ) {
+ elem.removeEventListener( type, handle );
+ }
+};
+
+jQuery.Event = function( src, props ) {
+
+ // Allow instantiation without the 'new' keyword
+ if ( !( this instanceof jQuery.Event ) ) {
+ return new jQuery.Event( src, props );
+ }
+
+ // Event object
+ if ( src && src.type ) {
+ this.originalEvent = src;
+ this.type = src.type;
+
+ // Events bubbling up the document may have been marked as prevented
+ // by a handler lower down the tree; reflect the correct value.
+ this.isDefaultPrevented = src.defaultPrevented ||
+ src.defaultPrevented === undefined &&
+
+ // Support: Android <=2.3 only
+ src.returnValue === false ?
+ returnTrue :
+ returnFalse;
+
+ // Create target properties
+ // Support: Safari <=6 - 7 only
+ // Target should not be a text node (#504, #13143)
+ this.target = ( src.target && src.target.nodeType === 3 ) ?
+ src.target.parentNode :
+ src.target;
+
+ this.currentTarget = src.currentTarget;
+ this.relatedTarget = src.relatedTarget;
+
+ // Event type
+ } else {
+ this.type = src;
+ }
+
+ // Put explicitly provided properties onto the event object
+ if ( props ) {
+ jQuery.extend( this, props );
+ }
+
+ // Create a timestamp if incoming event doesn't have one
+ this.timeStamp = src && src.timeStamp || Date.now();
+
+ // Mark it as fixed
+ this[ jQuery.expando ] = true;
+};
+
+// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
+// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
+jQuery.Event.prototype = {
+ constructor: jQuery.Event,
+ isDefaultPrevented: returnFalse,
+ isPropagationStopped: returnFalse,
+ isImmediatePropagationStopped: returnFalse,
+ isSimulated: false,
+
+ preventDefault: function() {
+ var e = this.originalEvent;
+
+ this.isDefaultPrevented = returnTrue;
+
+ if ( e && !this.isSimulated ) {
+ e.preventDefault();
+ }
+ },
+ stopPropagation: function() {
+ var e = this.originalEvent;
+
+ this.isPropagationStopped = returnTrue;
+
+ if ( e && !this.isSimulated ) {
+ e.stopPropagation();
+ }
+ },
+ stopImmediatePropagation: function() {
+ var e = this.originalEvent;
+
+ this.isImmediatePropagationStopped = returnTrue;
+
+ if ( e && !this.isSimulated ) {
+ e.stopImmediatePropagation();
+ }
+
+ this.stopPropagation();
+ }
+};
+
+// Includes all common event props including KeyEvent and MouseEvent specific props
+jQuery.each( {
+ altKey: true,
+ bubbles: true,
+ cancelable: true,
+ changedTouches: true,
+ ctrlKey: true,
+ detail: true,
+ eventPhase: true,
+ metaKey: true,
+ pageX: true,
+ pageY: true,
+ shiftKey: true,
+ view: true,
+ "char": true,
+ code: true,
+ charCode: true,
+ key: true,
+ keyCode: true,
+ button: true,
+ buttons: true,
+ clientX: true,
+ clientY: true,
+ offsetX: true,
+ offsetY: true,
+ pointerId: true,
+ pointerType: true,
+ screenX: true,
+ screenY: true,
+ targetTouches: true,
+ toElement: true,
+ touches: true,
+ which: true
+}, jQuery.event.addProp );
+
+jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) {
+ jQuery.event.special[ type ] = {
+
+ // Utilize native event if possible so blur/focus sequence is correct
+ setup: function() {
+
+ // Claim the first handler
+ // dataPriv.set( this, "focus", ... )
+ // dataPriv.set( this, "blur", ... )
+ leverageNative( this, type, expectSync );
+
+ // Return false to allow normal processing in the caller
+ return false;
+ },
+ trigger: function() {
+
+ // Force setup before trigger
+ leverageNative( this, type );
+
+ // Return non-false to allow normal event-path propagation
+ return true;
+ },
+
+ // Suppress native focus or blur as it's already being fired
+ // in leverageNative.
+ _default: function() {
+ return true;
+ },
+
+ delegateType: delegateType
+ };
+} );
+
+// Create mouseenter/leave events using mouseover/out and event-time checks
+// so that event delegation works in jQuery.
+// Do the same for pointerenter/pointerleave and pointerover/pointerout
+//
+// Support: Safari 7 only
+// Safari sends mouseenter too often; see:
+// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
+// for the description of the bug (it existed in older Chrome versions as well).
+jQuery.each( {
+ mouseenter: "mouseover",
+ mouseleave: "mouseout",
+ pointerenter: "pointerover",
+ pointerleave: "pointerout"
+}, function( orig, fix ) {
+ jQuery.event.special[ orig ] = {
+ delegateType: fix,
+ bindType: fix,
+
+ handle: function( event ) {
+ var ret,
+ target = this,
+ related = event.relatedTarget,
+ handleObj = event.handleObj;
+
+ // For mouseenter/leave call the handler if related is outside the target.
+ // NB: No relatedTarget if the mouse left/entered the browser window
+ if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
+ event.type = handleObj.origType;
+ ret = handleObj.handler.apply( this, arguments );
+ event.type = fix;
+ }
+ return ret;
+ }
+ };
+} );
+
+jQuery.fn.extend( {
+
+ on: function( types, selector, data, fn ) {
+ return on( this, types, selector, data, fn );
+ },
+ one: function( types, selector, data, fn ) {
+ return on( this, types, selector, data, fn, 1 );
+ },
+ off: function( types, selector, fn ) {
+ var handleObj, type;
+ if ( types && types.preventDefault && types.handleObj ) {
+
+ // ( event ) dispatched jQuery.Event
+ handleObj = types.handleObj;
+ jQuery( types.delegateTarget ).off(
+ handleObj.namespace ?
+ handleObj.origType + "." + handleObj.namespace :
+ handleObj.origType,
+ handleObj.selector,
+ handleObj.handler
+ );
+ return this;
+ }
+ if ( typeof types === "object" ) {
+
+ // ( types-object [, selector] )
+ for ( type in types ) {
+ this.off( type, selector, types[ type ] );
+ }
+ return this;
+ }
+ if ( selector === false || typeof selector === "function" ) {
+
+ // ( types [, fn] )
+ fn = selector;
+ selector = undefined;
+ }
+ if ( fn === false ) {
+ fn = returnFalse;
+ }
+ return this.each( function() {
+ jQuery.event.remove( this, types, fn, selector );
+ } );
+ }
+} );
+
+
+var
+
+ // Support: IE <=10 - 11, Edge 12 - 13 only
+ // In IE/Edge using regex groups here causes severe slowdowns.
+ // See https://connect.microsoft.com/IE/feedback/details/1736512/
+ rnoInnerhtml = /<script|<style|<link/i,
+
+ // checked="checked" or checked
+ rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
+ rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\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( html ) {
+ return html;
+ },
+
+ clone: function( 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( 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( selector ) {
+ return remove( this, selector, true );
+ },
+
+ remove: function( selector ) {
+ return remove( this, selector );
+ },
+
+ text: function( 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() {
+ 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() {
+ 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() {
+ return domManip( this, arguments, function( elem ) {
+ if ( this.parentNode ) {
+ this.parentNode.insertBefore( elem, this );
+ }
+ } );
+ },
+
+ after: function() {
+ return domManip( this, arguments, function( elem ) {
+ if ( this.parentNode ) {
+ this.parentNode.insertBefore( elem, this.nextSibling );
+ }
+ } );
+ },
+
+ empty: function() {
+ 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( dataAndEvents, deepDataAndEvents ) {
+ dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
+ deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
+
+ return this.map( function() {
+ return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
+ } );
+ },
+
+ html: function( 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() {
+ 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( 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( 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() {
+ computeStyleTests();
+ return boxSizingReliableVal;
+ },
+ pixelBoxStyles: function() {
+ computeStyleTests();
+ return pixelBoxStylesVal;
+ },
+ pixelPosition: function() {
+ computeStyleTests();
+ return pixelPositionVal;
+ },
+ reliableMarginLeft: function() {
+ computeStyleTests();
+ return reliableMarginLeftVal;
+ },
+ scrollboxSize: function() {
+ 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!
+ //
+ // Support: Firefox 70+
+ // Only Firefox includes border widths
+ // in computed dimensions. (gh-4529)
+ reliableTrDimensions: function() {
+ 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;border-collapse:separate";
+ tr.style.cssText = "border:1px solid";
+
+ // Support: Chrome 86+
+ // Height set through cssText does not get applied.
+ // Computed height then comes back as 0.
+ tr.style.height = "1px";
+ trChild.style.height = "9px";
+
+ // Support: Android 8 Chrome 86+
+ // In our bodyBackground.html iframe,
+ // display for all div elements is set to "inline",
+ // which causes a problem only in Android 8 Chrome 86.
+ // Ensuring the div is display: block
+ // gets around this issue.
+ trChild.style.display = "block";
+
+ documentElement
+ .appendChild( table )
+ .appendChild( tr )
+ .appendChild( trChild );
+
+ trStyle = window.getComputedStyle( tr );
+ reliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) +
+ parseInt( trStyle.borderTopWidth, 10 ) +
+ parseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight;
+
+ 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() {
+ 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( 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( 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( 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( 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( 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( 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( 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( 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() {
+ var hooks = Tween.propHooks[ this.prop ];
+
+ return hooks && hooks.get ?
+ hooks.get( this ) :
+ Tween.propHooks._default.get( this );
+ },
+ run: function( 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( 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( 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( tween ) {
+ if ( tween.elem.nodeType && tween.elem.parentNode ) {
+ tween.elem[ tween.prop ] = tween.now;
+ }
+ }
+};
+
+jQuery.easing = {
+ linear: function( p ) {
+ return p;
+ },
+ swing: function( 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() {
+ 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( 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( 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( 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( 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( 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( prop, speed, easing, callback ) {
+ var empty = jQuery.isEmptyObject( prop ),
+ optall = jQuery.speed( speed, easing, callback ),
+ doAnimation = function() {
+
+ // 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( type, clearQueue, gotoEnd ) {
+ var stopQueue = function( 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( 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( name, value ) {
+ return access( this, jQuery.attr, name, value, arguments.length > 1 );
+ },
+
+ removeAttr: function( name ) {
+ return this.each( function() {
+ jQuery.removeAttr( this, name );
+ } );
+ }
+} );
+
+jQuery.extend( {
+ attr: function( 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( 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( 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( 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( name, value ) {
+ return access( this, jQuery.prop, name, value, arguments.length > 1 );
+ },
+
+ removeProp: function( name ) {
+ return this.each( function() {
+ delete this[ jQuery.propFix[ name ] || name ];
+ } );
+ }
+} );
+
+jQuery.extend( {
+ prop: function( 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( 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( elem ) {
+
+ /* eslint no-unused-expressions: "off" */
+
+ var parent = elem.parentNode;
+ if ( parent && parent.parentNode ) {
+ parent.parentNode.selectedIndex;
+ }
+ return null;
+ },
+ set: function( 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( 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( 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( 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( 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( 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( 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( 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( 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( 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( e ) {
+ e.stopPropagation();
+ };
+
+jQuery.extend( jQuery.event, {
+
+ trigger: function( 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( 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( type, data ) {
+ return this.each( function() {
+ jQuery.event.trigger( type, data, this );
+ } );
+ },
+ triggerHandler: function( 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( event ) {
+ jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
+ };
+
+ jQuery.event.special[ fix ] = {
+ setup: function() {
+
+ // 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() {
+ 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, parserErrorElem;
+ 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 ) {}
+
+ parserErrorElem = xml && xml.getElementsByTagName( "parsererror" )[ 0 ];
+ if ( !xml || parserErrorElem ) {
+ jQuery.error( "Invalid XML: " + (
+ parserErrorElem ?
+ jQuery.map( parserErrorElem.childNodes, function( el ) {
+ return el.textContent;
+ } ).join( "\n" ) :
+ 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( 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() {
+ return jQuery.param( this.serializeArray() );
+ },
+ serializeArray: function() {
+ 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( 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( 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( 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() {
+ return completed ? responseHeadersString : null;
+ },
+
+ // Caches the header
+ setRequestHeader: function( 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( type ) {
+ if ( completed == null ) {
+ s.mimeType = type;
+ }
+ return this;
+ },
+
+ // Status-dependent callbacks
+ statusCode: function( 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( 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 but not if jsonp
+ if ( !isSuccess &&
+ jQuery.inArray( "script", s.dataTypes ) > -1 &&
+ jQuery.inArray( "json", s.dataTypes ) < 0 ) {
+ 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( url, data, callback ) {
+ return jQuery.get( url, data, callback, "json" );
+ },
+
+ getScript: function( 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() {}
+ },
+ dataFilter: function( response ) {
+ jQuery.globalEval( response, options, doc );
+ }
+ } );
+};
+
+
+jQuery.fn.extend( {
+ wrapAll: function( 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( 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( html ) {
+ var htmlIsFunction = isFunction( html );
+
+ return this.each( function( i ) {
+ jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );
+ } );
+ },
+
+ unwrap: function( 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( 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( 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() {
+ 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( 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, callback;
+ return {
+ send: function( _, complete ) {
+ script = jQuery( "<script>" )
+ .attr( s.scriptAttrs || {} )
+ .prop( { charset: s.scriptCharset, src: s.url } )
+ .on( "load error", callback = function( evt ) {
+ script.remove();
+ callback = null;
+ if ( evt ) {
+ complete( evt.type === "error" ? 404 : 200, evt.type );
+ }
+ } );
+
+ // Use native DOM manipulation to avoid our domManip AJAX trickery
+ document.head.appendChild( script[ 0 ] );
+ },
+ abort: function() {
+ if ( callback ) {
+ callback();
+ }
+ }
+ };
+ }
+} );
+
+
+
+
+var oldCallbacks = [],
+ rjsonp = /(=)\?(?=&|$)|\?\?/;
+
+// Default jsonp settings
+jQuery.ajaxSetup( {
+ jsonp: "callback",
+ jsonpCallback: function() {
+ var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce.guid++ ) );
+ this[ callback ] = true;
+ return callback;
+ }
+} );
+
+// Detect, normalize options and install callbacks for jsonp requests
+jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
+
+ var callbackName, overwritten, responseContainer,
+ jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
+ "url" :
+ typeof s.data === "string" &&
+ ( s.contentType || "" )
+ .indexOf( "application/x-www-form-urlencoded" ) === 0 &&
+ rjsonp.test( s.data ) && "data"
+ );
+
+ // Handle iff the expected data type is "jsonp" or we have a parameter to set
+ if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
+
+ // Get callback name, remembering preexisting value associated with it
+ callbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?
+ s.jsonpCallback() :
+ s.jsonpCallback;
+
+ // Insert callback into url or form data
+ if ( jsonProp ) {
+ s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
+ } else if ( s.jsonp !== false ) {
+ s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
+ }
+
+ // Use data converter to retrieve json after script execution
+ s.converters[ "script json" ] = function() {
+ if ( !responseContainer ) {
+ jQuery.error( callbackName + " was not called" );
+ }
+ return responseContainer[ 0 ];
+ };
+
+ // Force json dataType
+ s.dataTypes[ 0 ] = "json";
+
+ // Install callback
+ overwritten = window[ callbackName ];
+ window[ callbackName ] = function() {
+ responseContainer = arguments;
+ };
+
+ // Clean-up function (fires after converters)
+ jqXHR.always( function() {
+
+ // If previous value didn't exist - remove it
+ if ( overwritten === undefined ) {
+ jQuery( window ).removeProp( callbackName );
+
+ // Otherwise restore preexisting value
+ } else {
+ window[ callbackName ] = overwritten;
+ }
+
+ // Save back as free
+ if ( s[ callbackName ] ) {
+
+ // Make sure that re-using the options doesn't screw things around
+ s.jsonpCallback = originalSettings.jsonpCallback;
+
+ // Save the callback name for future use
+ oldCallbacks.push( callbackName );
+ }
+
+ // Call if it was a function and we have a response
+ if ( responseContainer && isFunction( overwritten ) ) {
+ overwritten( responseContainer[ 0 ] );
+ }
+
+ responseContainer = overwritten = undefined;
+ } );
+
+ // Delegate to script
+ return "script";
+ }
+} );
+
+
+
+
+// Support: Safari 8 only
+// In Safari 8 documents created via document.implementation.createHTMLDocument
+// collapse sibling forms: the second one becomes a child of the first one.
+// Because of that, this security measure has to be disabled in Safari 8.
+// https://bugs.webkit.org/show_bug.cgi?id=137337
+support.createHTMLDocument = ( function() {
+ var body = document.implementation.createHTMLDocument( "" ).body;
+ body.innerHTML = "<form></form><form></form>";
+ return body.childNodes.length === 2;
+} )();
+
+
+// Argument "data" should be string of html
+// context (optional): If specified, the fragment will be created in this context,
+// defaults to document
+// keepScripts (optional): If true, will include scripts passed in the html string
+jQuery.parseHTML = function( data, context, keepScripts ) {
+ if ( typeof data !== "string" ) {
+ return [];
+ }
+ if ( typeof context === "boolean" ) {
+ keepScripts = context;
+ context = false;
+ }
+
+ var base, parsed, scripts;
+
+ if ( !context ) {
+
+ // Stop scripts or inline event handlers from being executed immediately
+ // by using document.implementation
+ if ( support.createHTMLDocument ) {
+ context = document.implementation.createHTMLDocument( "" );
+
+ // Set the base href for the created document
+ // so any parsed elements with URLs
+ // are based on the document's URL (gh-2965)
+ base = context.createElement( "base" );
+ base.href = document.location.href;
+ context.head.appendChild( base );
+ } else {
+ context = document;
+ }
+ }
+
+ parsed = rsingleTag.exec( data );
+ scripts = !keepScripts && [];
+
+ // Single tag
+ if ( parsed ) {
+ return [ context.createElement( parsed[ 1 ] ) ];
+ }
+
+ parsed = buildFragment( [ data ], context, scripts );
+
+ if ( scripts && scripts.length ) {
+ jQuery( scripts ).remove();
+ }
+
+ return jQuery.merge( [], parsed.childNodes );
+};
+
+
+/**
+ * Load a url into a page
+ */
+jQuery.fn.load = function( url, params, callback ) {
+ var selector, type, response,
+ self = this,
+ off = url.indexOf( " " );
+
+ if ( off > -1 ) {
+ selector = stripAndCollapse( url.slice( off ) );
+ url = url.slice( 0, off );
+ }
+
+ // If it's a function
+ if ( isFunction( params ) ) {
+
+ // We assume that it's the callback
+ callback = params;
+ params = undefined;
+
+ // Otherwise, build a param string
+ } else if ( params && typeof params === "object" ) {
+ type = "POST";
+ }
+
+ // If we have elements to modify, make the request
+ if ( self.length > 0 ) {
+ jQuery.ajax( {
+ url: url,
+
+ // If "type" variable is undefined, then "GET" method will be used.
+ // Make value of this field explicit since
+ // user can override it through ajaxSetup method
+ type: type || "GET",
+ dataType: "html",
+ data: params
+ } ).done( function( responseText ) {
+
+ // Save response for use in complete callback
+ response = arguments;
+
+ self.html( selector ?
+
+ // If a selector was specified, locate the right elements in a dummy div
+ // Exclude scripts to avoid IE 'Permission Denied' errors
+ jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
+
+ // Otherwise use the full result
+ responseText );
+
+ // If the request succeeds, this function gets "data", "status", "jqXHR"
+ // but they are ignored because response was set above.
+ // If it fails, this function gets "jqXHR", "status", "error"
+ } ).always( callback && function( jqXHR, status ) {
+ self.each( function() {
+ callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
+ } );
+ } );
+ }
+
+ return this;
+};
+
+
+
+
+jQuery.expr.pseudos.animated = function( elem ) {
+ return jQuery.grep( jQuery.timers, function( fn ) {
+ return elem === fn.elem;
+ } ).length;
+};
+
+
+
+
+jQuery.offset = {
+ setOffset: function( elem, options, i ) {
+ var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
+ position = jQuery.css( elem, "position" ),
+ curElem = jQuery( elem ),
+ props = {};
+
+ // Set position first, in-case top/left are set even on static elem
+ if ( position === "static" ) {
+ elem.style.position = "relative";
+ }
+
+ curOffset = curElem.offset();
+ curCSSTop = jQuery.css( elem, "top" );
+ curCSSLeft = jQuery.css( elem, "left" );
+ calculatePosition = ( position === "absolute" || position === "fixed" ) &&
+ ( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;
+
+ // Need to be able to calculate position if either
+ // top or left is auto and position is either absolute or fixed
+ if ( calculatePosition ) {
+ curPosition = curElem.position();
+ curTop = curPosition.top;
+ curLeft = curPosition.left;
+
+ } else {
+ curTop = parseFloat( curCSSTop ) || 0;
+ curLeft = parseFloat( curCSSLeft ) || 0;
+ }
+
+ if ( isFunction( options ) ) {
+
+ // Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
+ options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
+ }
+
+ if ( options.top != null ) {
+ props.top = ( options.top - curOffset.top ) + curTop;
+ }
+ if ( options.left != null ) {
+ props.left = ( options.left - curOffset.left ) + curLeft;
+ }
+
+ if ( "using" in options ) {
+ options.using.call( elem, props );
+
+ } else {
+ curElem.css( props );
+ }
+ }
+};
+
+jQuery.fn.extend( {
+
+ // offset() relates an element's border box to the document origin
+ offset: function( options ) {
+
+ // Preserve chaining for setter
+ if ( arguments.length ) {
+ return options === undefined ?
+ this :
+ this.each( function( i ) {
+ jQuery.offset.setOffset( this, options, i );
+ } );
+ }
+
+ var rect, win,
+ elem = this[ 0 ];
+
+ if ( !elem ) {
+ return;
+ }
+
+ // Return zeros for disconnected and hidden (display: none) elements (gh-2310)
+ // Support: IE <=11 only
+ // Running getBoundingClientRect on a
+ // disconnected node in IE throws an error
+ if ( !elem.getClientRects().length ) {
+ return { top: 0, left: 0 };
+ }
+
+ // Get document-relative position by adding viewport scroll to viewport-relative gBCR
+ rect = elem.getBoundingClientRect();
+ win = elem.ownerDocument.defaultView;
+ return {
+ top: rect.top + win.pageYOffset,
+ left: rect.left + win.pageXOffset
+ };
+ },
+
+ // position() relates an element's margin box to its offset parent's padding box
+ // This corresponds to the behavior of CSS absolute positioning
+ position: function() {
+ if ( !this[ 0 ] ) {
+ return;
+ }
+
+ var offsetParent, offset, doc,
+ elem = this[ 0 ],
+ parentOffset = { top: 0, left: 0 };
+
+ // position:fixed elements are offset from the viewport, which itself always has zero offset
+ if ( jQuery.css( elem, "position" ) === "fixed" ) {
+
+ // Assume position:fixed implies availability of getBoundingClientRect
+ offset = elem.getBoundingClientRect();
+
+ } else {
+ offset = this.offset();
+
+ // Account for the *real* offset parent, which can be the document or its root element
+ // when a statically positioned element is identified
+ doc = elem.ownerDocument;
+ offsetParent = elem.offsetParent || doc.documentElement;
+ while ( offsetParent &&
+ ( offsetParent === doc.body || offsetParent === doc.documentElement ) &&
+ jQuery.css( offsetParent, "position" ) === "static" ) {
+
+ offsetParent = offsetParent.parentNode;
+ }
+ if ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {
+
+ // Incorporate borders into its offset, since they are outside its content origin
+ parentOffset = jQuery( offsetParent ).offset();
+ parentOffset.top += jQuery.css( offsetParent, "borderTopWidth", true );
+ parentOffset.left += jQuery.css( offsetParent, "borderLeftWidth", true );
+ }
+ }
+
+ // Subtract parent offsets and element margins
+ return {
+ top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
+ left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
+ };
+ },
+
+ // This method will return documentElement in the following cases:
+ // 1) For the element inside the iframe without offsetParent, this method will return
+ // documentElement of the parent window
+ // 2) For the hidden or detached element
+ // 3) For body or html element, i.e. in case of the html node - it will return itself
+ //
+ // but those exceptions were never presented as a real life use-cases
+ // and might be considered as more preferable results.
+ //
+ // This logic, however, is not guaranteed and can change at any point in the future
+ offsetParent: function() {
+ return this.map( function() {
+ var offsetParent = this.offsetParent;
+
+ while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {
+ offsetParent = offsetParent.offsetParent;
+ }
+
+ return offsetParent || documentElement;
+ } );
+ }
+} );
+
+// Create scrollLeft and scrollTop methods
+jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
+ var top = "pageYOffset" === prop;
+
+ jQuery.fn[ method ] = function( val ) {
+ return access( this, function( elem, method, val ) {
+
+ // Coalesce documents and windows
+ var win;
+ if ( isWindow( elem ) ) {
+ win = elem;
+ } else if ( elem.nodeType === 9 ) {
+ win = elem.defaultView;
+ }
+
+ if ( val === undefined ) {
+ return win ? win[ prop ] : elem[ method ];
+ }
+
+ if ( win ) {
+ win.scrollTo(
+ !top ? val : win.pageXOffset,
+ top ? val : win.pageYOffset
+ );
+
+ } else {
+ elem[ method ] = val;
+ }
+ }, method, val, arguments.length );
+ };
+} );
+
+// Support: Safari <=7 - 9.1, Chrome <=37 - 49
+// Add the top/left cssHooks using jQuery.fn.position
+// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
+// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
+// getComputedStyle returns percent when specified for top/left/bottom/right;
+// rather than make the css module depend on the offset module, just check for it here
+jQuery.each( [ "top", "left" ], function( _i, prop ) {
+ jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
+ function( elem, computed ) {
+ if ( computed ) {
+ computed = curCSS( elem, prop );
+
+ // If curCSS returns percentage, fallback to offset
+ return rnumnonpx.test( computed ) ?
+ jQuery( elem ).position()[ prop ] + "px" :
+ computed;
+ }
+ }
+ );
+} );
+
+
+// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
+jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
+ jQuery.each( {
+ padding: "inner" + name,
+ content: type,
+ "": "outer" + name
+ }, function( defaultExtra, funcName ) {
+
+ // Margin is only for outerHeight, outerWidth
+ jQuery.fn[ funcName ] = function( margin, value ) {
+ var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
+ extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
+
+ return access( this, function( elem, type, value ) {
+ var doc;
+
+ if ( isWindow( elem ) ) {
+
+ // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
+ return funcName.indexOf( "outer" ) === 0 ?
+ elem[ "inner" + name ] :
+ elem.document.documentElement[ "client" + name ];
+ }
+
+ // Get document width or height
+ if ( elem.nodeType === 9 ) {
+ doc = elem.documentElement;
+
+ // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
+ // whichever is greatest
+ return Math.max(
+ elem.body[ "scroll" + name ], doc[ "scroll" + name ],
+ elem.body[ "offset" + name ], doc[ "offset" + name ],
+ doc[ "client" + name ]
+ );
+ }
+
+ return value === undefined ?
+
+ // Get width or height on the element, requesting but not forcing parseFloat
+ jQuery.css( elem, type, extra ) :
+
+ // Set width or height on the element
+ jQuery.style( elem, type, value, extra );
+ }, type, chainable ? margin : undefined, chainable );
+ };
+ } );
+} );
+
+
+jQuery.each( [
+ "ajaxStart",
+ "ajaxStop",
+ "ajaxComplete",
+ "ajaxError",
+ "ajaxSuccess",
+ "ajaxSend"
+], function( _i, type ) {
+ jQuery.fn[ type ] = function( fn ) {
+ return this.on( type, fn );
+ };
+} );
+
+
+
+
+jQuery.fn.extend( {
+
+ bind: function( types, data, fn ) {
+ return this.on( types, null, data, fn );
+ },
+ unbind: function( types, fn ) {
+ return this.off( types, null, fn );
+ },
+
+ delegate: function( selector, types, data, fn ) {
+ return this.on( types, selector, data, fn );
+ },
+ undelegate: function( selector, types, fn ) {
+
+ // ( namespace ) or ( selector, types [, fn] )
+ return arguments.length === 1 ?
+ this.off( selector, "**" ) :
+ this.off( types, selector || "**", fn );
+ },
+
+ hover: function( fnOver, fnOut ) {
+ return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
+ }
+} );
+
+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 ) {
+ return arguments.length > 0 ?
+ this.on( name, null, data, fn ) :
+ this.trigger( name );
+ };
+ }
+);
+
+
+
+
+// Support: Android <=4.0 only
+// Make sure we trim BOM and NBSP
+var rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
+
+// Bind a function to a context, optionally partially applying any
+// arguments.
+// jQuery.proxy is deprecated to promote standards (specifically Function#bind)
+// However, it is not slated for removal any time soon
+jQuery.proxy = function( fn, context ) {
+ var tmp, args, proxy;
+
+ if ( typeof context === "string" ) {
+ tmp = fn[ context ];
+ context = fn;
+ fn = tmp;
+ }
+
+ // Quick check to determine if target is callable, in the spec
+ // this throws a TypeError, but we will just return undefined.
+ if ( !isFunction( fn ) ) {
+ return undefined;
+ }
+
+ // Simulated bind
+ args = slice.call( arguments, 2 );
+ proxy = function() {
+ return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
+ };
+
+ // Set the guid of unique handler to the same of original handler, so it can be removed
+ proxy.guid = fn.guid = fn.guid || jQuery.guid++;
+
+ return proxy;
+};
+
+jQuery.holdReady = function( hold ) {
+ if ( hold ) {
+ jQuery.readyWait++;
+ } else {
+ jQuery.ready( true );
+ }
+};
+jQuery.isArray = Array.isArray;
+jQuery.parseJSON = JSON.parse;
+jQuery.nodeName = nodeName;
+jQuery.isFunction = isFunction;
+jQuery.isWindow = isWindow;
+jQuery.camelCase = camelCase;
+jQuery.type = toType;
+
+jQuery.now = Date.now;
+
+jQuery.isNumeric = function( obj ) {
+
+ // 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 = jQuery.type( obj );
+ return ( type === "number" || type === "string" ) &&
+
+ // parseFloat NaNs numeric-cast false positives ("")
+ // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
+ // subtraction forces infinities to NaN
+ !isNaN( obj - parseFloat( obj ) );
+};
+
+jQuery.trim = function( text ) {
+ return text == null ?
+ "" :
+ ( text + "" ).replace( rtrim, "" );
+};
+
+
+
+// Register as a named AMD module, since jQuery can be concatenated with other
+// files that may use define, but not via a proper concatenation script that
+// understands anonymous AMD modules. A named AMD is safest and most robust
+// way to register. Lowercase jquery is used because AMD module names are
+// derived from file names, and jQuery is normally delivered in a lowercase
+// file name. Do this after creating the global so that if an AMD module wants
+// to call noConflict to hide this version of jQuery, it will work.
+
+// Note that for maximum portability, libraries that are not jQuery should
+// declare themselves as anonymous modules, and avoid setting a global if an
+// AMD loader is present. jQuery is a special case. For more information, see
+// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
+
+if ( typeof define === "function" && define.amd ) {
+ define( "jquery", [], function() {
+ return jQuery;
+ } );
+}
+
+
+
+
+var
+
+ // Map over jQuery in case of overwrite
+ _jQuery = window.jQuery,
+
+ // Map over the $ in case of overwrite
+ _$ = window.$;
+
+jQuery.noConflict = function( deep ) {
+ if ( window.$ === jQuery ) {
+ window.$ = _$;
+ }
+
+ if ( deep && window.jQuery === jQuery ) {
+ window.jQuery = _jQuery;
+ }
+
+ return jQuery;
+};
+
+// Expose jQuery and $ identifiers, even in AMD
+// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
+// and CommonJS for browser emulators (#13566)
+if ( typeof noGlobal === "undefined" ) {
+ window.jQuery = window.$ = jQuery;
+}
+
+
+
+
+return jQuery;
+} );
+/*! jQuery UI - v1.12.1 - 2016-09-14
+* http://jqueryui.com
+* Includes: widget.js, position.js, data.js, disable-selection.js, effect.js, effects/effect-blind.js, effects/effect-bounce.js, effects/effect-clip.js, effects/effect-drop.js, effects/effect-explode.js, effects/effect-fade.js, effects/effect-fold.js, effects/effect-highlight.js, effects/effect-puff.js, effects/effect-pulsate.js, effects/effect-scale.js, effects/effect-shake.js, effects/effect-size.js, effects/effect-slide.js, effects/effect-transfer.js, focusable.js, form-reset-mixin.js, jquery-1-7.js, keycode.js, labels.js, scroll-parent.js, tabbable.js, unique-id.js, widgets/accordion.js, widgets/autocomplete.js, widgets/button.js, widgets/checkboxradio.js, widgets/controlgroup.js, widgets/datepicker.js, widgets/dialog.js, widgets/draggable.js, widgets/droppable.js, widgets/menu.js, widgets/mouse.js, widgets/progressbar.js, widgets/resizable.js, widgets/selectable.js, widgets/selectmenu.js, widgets/slider.js, widgets/sortable.js, widgets/spinner.js, widgets/tabs.js, widgets/tooltip.js
+* Copyright jQuery Foundation and other contributors; Licensed MIT */
+
+(function (factory) {
+ if (typeof define === "function" && define.amd) {
+
+ // AMD. Register as an anonymous module.
+ define(["jquery"], factory);
+ } else {
+
+ // Browser globals
+ factory(jQuery);
+ }
+}(function ($) {
+
+ $.ui = $.ui || {};
+
+ var version = $.ui.version = "1.12.1";
+
+
+ /*!
+ * jQuery UI Widget 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Widget
+ //>>group: Core
+ //>>description: Provides a factory for creating stateful widgets with a common API.
+ //>>docs: http://api.jqueryui.com/jQuery.widget/
+ //>>demos: http://jqueryui.com/widget/
+
+
+
+ var widgetUuid = 0;
+ var widgetSlice = Array.prototype.slice;
+
+ $.cleanData = (function (orig) {
+ return function (elems) {
+ var events, elem, i;
+ for (i = 0; (elem = elems[i]) != null; i++) {
+ try {
+
+ // Only trigger remove when necessary to save time
+ events = $._data(elem, "events");
+ if (events && events.remove) {
+ $(elem).triggerHandler("remove");
+ }
+
+ // Http://bugs.jquery.com/ticket/8235
+ } catch (e) { }
+ }
+ orig(elems);
+ };
+ })($.cleanData);
+
+ $.widget = function (name, base, prototype) {
+ var existingConstructor, constructor, basePrototype;
+
+ // ProxiedPrototype allows the provided prototype to remain unmodified
+ // so that it can be used as a mixin for multiple widgets (#8876)
+ var proxiedPrototype = {};
+
+ var namespace = name.split(".")[0];
+ name = name.split(".")[1];
+ var fullName = namespace + "-" + name;
+
+ if (!prototype) {
+ prototype = base;
+ base = $.Widget;
+ }
+
+ if ($.isArray(prototype)) {
+ prototype = $.extend.apply(null, [{}].concat(prototype));
+ }
+
+ // Create selector for plugin
+ $.expr[":"][fullName.toLowerCase()] = function (elem) {
+ return !!$.data(elem, fullName);
+ };
+
+ $[namespace] = $[namespace] || {};
+ existingConstructor = $[namespace][name];
+ constructor = $[namespace][name] = function (options, element) {
+
+ // Allow instantiation without "new" keyword
+ if (!this._createWidget) {
+ return new constructor(options, element);
+ }
+
+ // Allow instantiation without initializing for simple inheritance
+ // must use "new" keyword (the code above always passes args)
+ if (arguments.length) {
+ this._createWidget(options, element);
+ }
+ };
+
+ // Extend with the existing constructor to carry over any static properties
+ $.extend(constructor, existingConstructor, {
+ version: prototype.version,
+
+ // Copy the object used to create the prototype in case we need to
+ // redefine the widget later
+ _proto: $.extend({}, prototype),
+
+ // Track widgets that inherit from this widget in case this widget is
+ // redefined after a widget inherits from it
+ _childConstructors: []
+ });
+
+ basePrototype = new base();
+
+ // We need to make the options hash a property directly on the new instance
+ // otherwise we'll modify the options hash on the prototype that we're
+ // inheriting from
+ basePrototype.options = $.widget.extend({}, basePrototype.options);
+ $.each(prototype, function (prop, value) {
+ if (!$.isFunction(value)) {
+ proxiedPrototype[prop] = value;
+ return;
+ }
+ proxiedPrototype[prop] = (function () {
+ function _super() {
+ return base.prototype[prop].apply(this, arguments);
+ }
+
+ function _superApply(args) {
+ return base.prototype[prop].apply(this, args);
+ }
+
+ return function () {
+ var __super = this._super;
+ var __superApply = this._superApply;
+ var returnValue;
+
+ this._super = _super;
+ this._superApply = _superApply;
+
+ returnValue = value.apply(this, arguments);
+
+ this._super = __super;
+ this._superApply = __superApply;
+
+ return returnValue;
+ };
+ })();
+ });
+ constructor.prototype = $.widget.extend(basePrototype, {
+
+ // TODO: remove support for widgetEventPrefix
+ // always use the name + a colon as the prefix, e.g., draggable:start
+ // don't prefix for widgets that aren't DOM-based
+ widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
+ }, proxiedPrototype, {
+ constructor: constructor,
+ namespace: namespace,
+ widgetName: name,
+ widgetFullName: fullName
+ });
+
+ // If this widget is being redefined then we need to find all widgets that
+ // are inheriting from it and redefine all of them so that they inherit from
+ // the new version of this widget. We're essentially trying to replace one
+ // level in the prototype chain.
+ if (existingConstructor) {
+ $.each(existingConstructor._childConstructors, function (i, child) {
+ var childPrototype = child.prototype;
+
+ // Redefine the child widget using the same prototype that was
+ // originally used, but inherit from the new version of the base
+ $.widget(childPrototype.namespace + "." + childPrototype.widgetName, constructor,
+ child._proto);
+ });
+
+ // Remove the list of existing child constructors from the old constructor
+ // so the old child constructors can be garbage collected
+ delete existingConstructor._childConstructors;
+ } else {
+ base._childConstructors.push(constructor);
+ }
+
+ $.widget.bridge(name, constructor);
+
+ return constructor;
+ };
+
+ $.widget.extend = function (target) {
+ var input = widgetSlice.call(arguments, 1);
+ var inputIndex = 0;
+ var inputLength = input.length;
+ var key;
+ var value;
+
+ for (; inputIndex < inputLength; inputIndex++) {
+ for (key in input[inputIndex]) {
+ value = input[inputIndex][key];
+ if (input[inputIndex].hasOwnProperty(key) && value !== undefined) {
+
+ // Clone objects
+ if ($.isPlainObject(value)) {
+ target[key] = $.isPlainObject(target[key]) ?
+ $.widget.extend({}, target[key], value) :
+
+ // Don't extend strings, arrays, etc. with objects
+ $.widget.extend({}, value);
+
+ // Copy everything else by reference
+ } else {
+ target[key] = value;
+ }
+ }
+ }
+ }
+ return target;
+ };
+
+ $.widget.bridge = function (name, object) {
+ var fullName = object.prototype.widgetFullName || name;
+ $.fn[name] = function (options) {
+ var isMethodCall = typeof options === "string";
+ var args = widgetSlice.call(arguments, 1);
+ var returnValue = this;
+
+ if (isMethodCall) {
+
+ // If this is an empty collection, we need to have the instance method
+ // return undefined instead of the jQuery instance
+ if (!this.length && options === "instance") {
+ returnValue = undefined;
+ } else {
+ this.each(function () {
+ var methodValue;
+ var instance = $.data(this, fullName);
+
+ if (options === "instance") {
+ returnValue = instance;
+ return false;
+ }
+
+ if (!instance) {
+ return $.error("cannot call methods on " + name +
+ " prior to initialization; " +
+ "attempted to call method '" + options + "'");
+ }
+
+ if (!$.isFunction(instance[options]) || options.charAt(0) === "_") {
+ return $.error("no such method '" + options + "' for " + name +
+ " widget instance");
+ }
+
+ methodValue = instance[options].apply(instance, args);
+
+ if (methodValue !== instance && methodValue !== undefined) {
+ returnValue = methodValue && methodValue.jquery ?
+ returnValue.pushStack(methodValue.get()) :
+ methodValue;
+ return false;
+ }
+ });
+ }
+ } else {
+
+ // Allow multiple hashes to be passed on init
+ if (args.length) {
+ options = $.widget.extend.apply(null, [options].concat(args));
+ }
+
+ this.each(function () {
+ var instance = $.data(this, fullName);
+ if (instance) {
+ instance.option(options || {});
+ if (instance._init) {
+ instance._init();
+ }
+ } else {
+ $.data(this, fullName, new object(options, this));
+ }
+ });
+ }
+
+ return returnValue;
+ };
+ };
+
+ $.Widget = function ( /* options, element */) { };
+ $.Widget._childConstructors = [];
+
+ $.Widget.prototype = {
+ widgetName: "widget",
+ widgetEventPrefix: "",
+ defaultElement: "<div>",
+
+ options: {
+ classes: {},
+ disabled: false,
+
+ // Callbacks
+ create: null
+ },
+
+ _createWidget: function (options, element) {
+ element = $(element || this.defaultElement || this)[0];
+ this.element = $(element);
+ this.uuid = widgetUuid++;
+ this.eventNamespace = "." + this.widgetName + this.uuid;
+
+ this.bindings = $();
+ this.hoverable = $();
+ this.focusable = $();
+ this.classesElementLookup = {};
+
+ if (element !== this) {
+ $.data(element, this.widgetFullName, this);
+ this._on(true, this.element, {
+ remove: function (event) {
+ if (event.target === element) {
+ this.destroy();
+ }
+ }
+ });
+ this.document = $(element.style ?
+
+ // Element within the document
+ element.ownerDocument :
+
+ // Element is window or document
+ element.document || element);
+ this.window = $(this.document[0].defaultView || this.document[0].parentWindow);
+ }
+
+ this.options = $.widget.extend({},
+ this.options,
+ this._getCreateOptions(),
+ options);
+
+ this._create();
+
+ if (this.options.disabled) {
+ this._setOptionDisabled(this.options.disabled);
+ }
+
+ this._trigger("create", null, this._getCreateEventData());
+ this._init();
+ },
+
+ _getCreateOptions: function () {
+ return {};
+ },
+
+ _getCreateEventData: $.noop,
+
+ _create: $.noop,
+
+ _init: $.noop,
+
+ destroy: function () {
+ var that = this;
+
+ this._destroy();
+ $.each(this.classesElementLookup, function (key, value) {
+ that._removeClass(value, key);
+ });
+
+ // We can probably remove the unbind calls in 2.0
+ // all event bindings should go through this._on()
+ this.element
+ .off(this.eventNamespace)
+ .removeData(this.widgetFullName);
+ this.widget()
+ .off(this.eventNamespace)
+ .removeAttr("aria-disabled");
+
+ // Clean up events and states
+ this.bindings.off(this.eventNamespace);
+ },
+
+ _destroy: $.noop,
+
+ widget: function () {
+ return this.element;
+ },
+
+ option: function (key, value) {
+ var options = key;
+ var parts;
+ var curOption;
+ var i;
+
+ if (arguments.length === 0) {
+
+ // Don't return a reference to the internal hash
+ return $.widget.extend({}, this.options);
+ }
+
+ if (typeof key === "string") {
+
+ // Handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
+ options = {};
+ parts = key.split(".");
+ key = parts.shift();
+ if (parts.length) {
+ curOption = options[key] = $.widget.extend({}, this.options[key]);
+ for (i = 0; i < parts.length - 1; i++) {
+ curOption[parts[i]] = curOption[parts[i]] || {};
+ curOption = curOption[parts[i]];
+ }
+ key = parts.pop();
+ if (arguments.length === 1) {
+ return curOption[key] === undefined ? null : curOption[key];
+ }
+ curOption[key] = value;
+ } else {
+ if (arguments.length === 1) {
+ return this.options[key] === undefined ? null : this.options[key];
+ }
+ options[key] = value;
+ }
+ }
+
+ this._setOptions(options);
+
+ return this;
+ },
+
+ _setOptions: function (options) {
+ var key;
+
+ for (key in options) {
+ this._setOption(key, options[key]);
+ }
+
+ return this;
+ },
+
+ _setOption: function (key, value) {
+ if (key === "classes") {
+ this._setOptionClasses(value);
+ }
+
+ this.options[key] = value;
+
+ if (key === "disabled") {
+ this._setOptionDisabled(value);
+ }
+
+ return this;
+ },
+
+ _setOptionClasses: function (value) {
+ var classKey, elements, currentElements;
+
+ for (classKey in value) {
+ currentElements = this.classesElementLookup[classKey];
+ if (value[classKey] === this.options.classes[classKey] ||
+ !currentElements ||
+ !currentElements.length) {
+ continue;
+ }
+
+ // We are doing this to create a new jQuery object because the _removeClass() call
+ // on the next line is going to destroy the reference to the current elements being
+ // tracked. We need to save a copy of this collection so that we can add the new classes
+ // below.
+ elements = $(currentElements.get());
+ this._removeClass(currentElements, classKey);
+
+ // We don't use _addClass() here, because that uses this.options.classes
+ // for generating the string of classes. We want to use the value passed in from
+ // _setOption(), this is the new value of the classes option which was passed to
+ // _setOption(). We pass this value directly to _classes().
+ elements.addClass(this._classes({
+ element: elements,
+ keys: classKey,
+ classes: value,
+ add: true
+ }));
+ }
+ },
+
+ _setOptionDisabled: function (value) {
+ this._toggleClass(this.widget(), this.widgetFullName + "-disabled", null, !!value);
+
+ // If the widget is becoming disabled, then nothing is interactive
+ if (value) {
+ this._removeClass(this.hoverable, null, "ui-state-hover");
+ this._removeClass(this.focusable, null, "ui-state-focus");
+ }
+ },
+
+ enable: function () {
+ return this._setOptions({ disabled: false });
+ },
+
+ disable: function () {
+ return this._setOptions({ disabled: true });
+ },
+
+ _classes: function (options) {
+ var full = [];
+ var that = this;
+
+ options = $.extend({
+ element: this.element,
+ classes: this.options.classes || {}
+ }, options);
+
+ function processClassString(classes, checkOption) {
+ var current, i;
+ for (i = 0; i < classes.length; i++) {
+ current = that.classesElementLookup[classes[i]] || $();
+ if (options.add) {
+ current = $($.unique(current.get().concat(options.element.get())));
+ } else {
+ current = $(current.not(options.element).get());
+ }
+ that.classesElementLookup[classes[i]] = current;
+ full.push(classes[i]);
+ if (checkOption && options.classes[classes[i]]) {
+ full.push(options.classes[classes[i]]);
+ }
+ }
+ }
+
+ this._on(options.element, {
+ "remove": "_untrackClassesElement"
+ });
+
+ if (options.keys) {
+ processClassString(options.keys.match(/\S+/g) || [], true);
+ }
+ if (options.extra) {
+ processClassString(options.extra.match(/\S+/g) || []);
+ }
+
+ return full.join(" ");
+ },
+
+ _untrackClassesElement: function (event) {
+ var that = this;
+ $.each(that.classesElementLookup, function (key, value) {
+ if ($.inArray(event.target, value) !== -1) {
+ that.classesElementLookup[key] = $(value.not(event.target).get());
+ }
+ });
+ },
+
+ _removeClass: function (element, keys, extra) {
+ return this._toggleClass(element, keys, extra, false);
+ },
+
+ _addClass: function (element, keys, extra) {
+ return this._toggleClass(element, keys, extra, true);
+ },
+
+ _toggleClass: function (element, keys, extra, add) {
+ add = (typeof add === "boolean") ? add : extra;
+ var shift = (typeof element === "string" || element === null),
+ options = {
+ extra: shift ? keys : extra,
+ keys: shift ? element : keys,
+ element: shift ? this.element : element,
+ add: add
+ };
+ options.element.toggleClass(this._classes(options), add);
+ return this;
+ },
+
+ _on: function (suppressDisabledCheck, element, handlers) {
+ var delegateElement;
+ var instance = this;
+
+ // No suppressDisabledCheck flag, shuffle arguments
+ if (typeof suppressDisabledCheck !== "boolean") {
+ handlers = element;
+ element = suppressDisabledCheck;
+ suppressDisabledCheck = false;
+ }
+
+ // No element argument, shuffle and use this.element
+ if (!handlers) {
+ handlers = element;
+ element = this.element;
+ delegateElement = this.widget();
+ } else {
+ element = delegateElement = $(element);
+ this.bindings = this.bindings.add(element);
+ }
+
+ $.each(handlers, function (event, handler) {
+ function handlerProxy() {
+
+ // Allow widgets to customize the disabled handling
+ // - disabled as an array instead of boolean
+ // - disabled class as method for disabling individual parts
+ if (!suppressDisabledCheck &&
+ (instance.options.disabled === true ||
+ $(this).hasClass("ui-state-disabled"))) {
+ return;
+ }
+ return (typeof handler === "string" ? instance[handler] : handler)
+ .apply(instance, arguments);
+ }
+
+ // Copy the guid so direct unbinding works
+ if (typeof handler !== "string") {
+ handlerProxy.guid = handler.guid =
+ handler.guid || handlerProxy.guid || $.guid++;
+ }
+
+ var match = event.match(/^([\w:-]*)\s*(.*)$/);
+ var eventName = match[1] + instance.eventNamespace;
+ var selector = match[2];
+
+ if (selector) {
+ delegateElement.on(eventName, selector, handlerProxy);
+ } else {
+ element.on(eventName, handlerProxy);
+ }
+ });
+ },
+
+ _off: function (element, eventName) {
+ eventName = (eventName || "").split(" ").join(this.eventNamespace + " ") +
+ this.eventNamespace;
+ element.off(eventName).off(eventName);
+
+ // Clear the stack to avoid memory leaks (#10056)
+ this.bindings = $(this.bindings.not(element).get());
+ this.focusable = $(this.focusable.not(element).get());
+ this.hoverable = $(this.hoverable.not(element).get());
+ },
+
+ _delay: function (handler, delay) {
+ function handlerProxy() {
+ return (typeof handler === "string" ? instance[handler] : handler)
+ .apply(instance, arguments);
+ }
+ var instance = this;
+ return setTimeout(handlerProxy, delay || 0);
+ },
+
+ _hoverable: function (element) {
+ this.hoverable = this.hoverable.add(element);
+ this._on(element, {
+ mouseenter: function (event) {
+ this._addClass($(event.currentTarget), null, "ui-state-hover");
+ },
+ mouseleave: function (event) {
+ this._removeClass($(event.currentTarget), null, "ui-state-hover");
+ }
+ });
+ },
+
+ _focusable: function (element) {
+ this.focusable = this.focusable.add(element);
+ this._on(element, {
+ focusin: function (event) {
+ this._addClass($(event.currentTarget), null, "ui-state-focus");
+ },
+ focusout: function (event) {
+ this._removeClass($(event.currentTarget), null, "ui-state-focus");
+ }
+ });
+ },
+
+ _trigger: function (type, event, data) {
+ var prop, orig;
+ var callback = this.options[type];
+
+ data = data || {};
+ event = $.Event(event);
+ event.type = (type === this.widgetEventPrefix ?
+ type :
+ this.widgetEventPrefix + type).toLowerCase();
+
+ // The original event may come from any element
+ // so we need to reset the target on the new event
+ event.target = this.element[0];
+
+ // Copy original event properties over to the new event
+ orig = event.originalEvent;
+ if (orig) {
+ for (prop in orig) {
+ if (!(prop in event)) {
+ event[prop] = orig[prop];
+ }
+ }
+ }
+
+ this.element.trigger(event, data);
+ return !($.isFunction(callback) &&
+ callback.apply(this.element[0], [event].concat(data)) === false ||
+ event.isDefaultPrevented());
+ }
+ };
+
+ $.each({ show: "fadeIn", hide: "fadeOut" }, function (method, defaultEffect) {
+ $.Widget.prototype["_" + method] = function (element, options, callback) {
+ if (typeof options === "string") {
+ options = { effect: options };
+ }
+
+ var hasOptions;
+ var effectName = !options ?
+ method :
+ options === true || typeof options === "number" ?
+ defaultEffect :
+ options.effect || defaultEffect;
+
+ options = options || {};
+ if (typeof options === "number") {
+ options = { duration: options };
+ }
+
+ hasOptions = !$.isEmptyObject(options);
+ options.complete = callback;
+
+ if (options.delay) {
+ element.delay(options.delay);
+ }
+
+ if (hasOptions && $.effects && $.effects.effect[effectName]) {
+ element[method](options);
+ } else if (effectName !== method && element[effectName]) {
+ element[effectName](options.duration, options.easing, callback);
+ } else {
+ element.queue(function (next) {
+ $(this)[method]();
+ if (callback) {
+ callback.call(element[0]);
+ }
+ next();
+ });
+ }
+ };
+ });
+
+ var widget = $.widget;
+
+
+ /*!
+ * jQuery UI Position 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * http://api.jqueryui.com/position/
+ */
+
+ //>>label: Position
+ //>>group: Core
+ //>>description: Positions elements relative to other elements.
+ //>>docs: http://api.jqueryui.com/position/
+ //>>demos: http://jqueryui.com/position/
+
+
+ (function () {
+ var cachedScrollbarWidth,
+ max = Math.max,
+ abs = Math.abs,
+ rhorizontal = /left|center|right/,
+ rvertical = /top|center|bottom/,
+ roffset = /[\+\-]\d+(\.[\d]+)?%?/,
+ rposition = /^\w+/,
+ rpercent = /%$/,
+ _position = $.fn.position;
+
+ function getOffsets(offsets, width, height) {
+ return [
+ parseFloat(offsets[0]) * (rpercent.test(offsets[0]) ? width / 100 : 1),
+ parseFloat(offsets[1]) * (rpercent.test(offsets[1]) ? height / 100 : 1)
+ ];
+ }
+
+ function parseCss(element, property) {
+ return parseInt($.css(element, property), 10) || 0;
+ }
+
+ function getDimensions(elem) {
+ var raw = elem[0];
+ if (raw.nodeType === 9) {
+ return {
+ width: elem.width(),
+ height: elem.height(),
+ offset: { top: 0, left: 0 }
+ };
+ }
+ if ($.isWindow(raw)) {
+ return {
+ width: elem.width(),
+ height: elem.height(),
+ offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
+ };
+ }
+ if (raw.preventDefault) {
+ return {
+ width: 0,
+ height: 0,
+ offset: { top: raw.pageY, left: raw.pageX }
+ };
+ }
+ return {
+ width: elem.outerWidth(),
+ height: elem.outerHeight(),
+ offset: elem.offset()
+ };
+ }
+
+ $.position = {
+ scrollbarWidth: function () {
+ if (cachedScrollbarWidth !== undefined) {
+ return cachedScrollbarWidth;
+ }
+ var w1, w2,
+ div = $("<div " +
+ "style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'>" +
+ "<div style='height:100px;width:auto;'></div></div>"),
+ innerDiv = div.children()[0];
+
+ $("body").append(div);
+ w1 = innerDiv.offsetWidth;
+ div.css("overflow", "scroll");
+
+ w2 = innerDiv.offsetWidth;
+
+ if (w1 === w2) {
+ w2 = div[0].clientWidth;
+ }
+
+ div.remove();
+
+ return (cachedScrollbarWidth = w1 - w2);
+ },
+ getScrollInfo: function (within) {
+ var overflowX = within.isWindow || within.isDocument ? "" :
+ within.element.css("overflow-x"),
+ overflowY = within.isWindow || within.isDocument ? "" :
+ within.element.css("overflow-y"),
+ hasOverflowX = overflowX === "scroll" ||
+ (overflowX === "auto" && within.width < within.element[0].scrollWidth),
+ hasOverflowY = overflowY === "scroll" ||
+ (overflowY === "auto" && within.height < within.element[0].scrollHeight);
+ return {
+ width: hasOverflowY ? $.position.scrollbarWidth() : 0,
+ height: hasOverflowX ? $.position.scrollbarWidth() : 0
+ };
+ },
+ getWithinInfo: function (element) {
+ var withinElement = $(element || window),
+ isWindow = $.isWindow(withinElement[0]),
+ isDocument = !!withinElement[0] && withinElement[0].nodeType === 9,
+ hasOffset = !isWindow && !isDocument;
+ return {
+ element: withinElement,
+ isWindow: isWindow,
+ isDocument: isDocument,
+ offset: hasOffset ? $(element).offset() : { left: 0, top: 0 },
+ scrollLeft: withinElement.scrollLeft(),
+ scrollTop: withinElement.scrollTop(),
+ width: withinElement.outerWidth(),
+ height: withinElement.outerHeight()
+ };
+ }
+ };
+
+ $.fn.position = function (options) {
+ if (!options || !options.of) {
+ return _position.apply(this, arguments);
+ }
+
+ // Make a copy, we don't want to modify arguments
+ options = $.extend({}, options);
+
+ var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
+ target = $(options.of),
+ within = $.position.getWithinInfo(options.within),
+ scrollInfo = $.position.getScrollInfo(within),
+ collision = (options.collision || "flip").split(" "),
+ offsets = {};
+
+ dimensions = getDimensions(target);
+ if (target[0].preventDefault) {
+
+ // Force left top to allow flipping
+ options.at = "left top";
+ }
+ targetWidth = dimensions.width;
+ targetHeight = dimensions.height;
+ targetOffset = dimensions.offset;
+
+ // Clone to reuse original targetOffset later
+ basePosition = $.extend({}, targetOffset);
+
+ // Force my and at to have valid horizontal and vertical positions
+ // if a value is missing or invalid, it will be converted to center
+ $.each(["my", "at"], function () {
+ var pos = (options[this] || "").split(" "),
+ horizontalOffset,
+ verticalOffset;
+
+ if (pos.length === 1) {
+ pos = rhorizontal.test(pos[0]) ?
+ pos.concat(["center"]) :
+ rvertical.test(pos[0]) ?
+ ["center"].concat(pos) :
+ ["center", "center"];
+ }
+ pos[0] = rhorizontal.test(pos[0]) ? pos[0] : "center";
+ pos[1] = rvertical.test(pos[1]) ? pos[1] : "center";
+
+ // Calculate offsets
+ horizontalOffset = roffset.exec(pos[0]);
+ verticalOffset = roffset.exec(pos[1]);
+ offsets[this] = [
+ horizontalOffset ? horizontalOffset[0] : 0,
+ verticalOffset ? verticalOffset[0] : 0
+ ];
+
+ // Reduce to just the positions without the offsets
+ options[this] = [
+ rposition.exec(pos[0])[0],
+ rposition.exec(pos[1])[0]
+ ];
+ });
+
+ // Normalize collision option
+ if (collision.length === 1) {
+ collision[1] = collision[0];
+ }
+
+ if (options.at[0] === "right") {
+ basePosition.left += targetWidth;
+ } else if (options.at[0] === "center") {
+ basePosition.left += targetWidth / 2;
+ }
+
+ if (options.at[1] === "bottom") {
+ basePosition.top += targetHeight;
+ } else if (options.at[1] === "center") {
+ basePosition.top += targetHeight / 2;
+ }
+
+ atOffset = getOffsets(offsets.at, targetWidth, targetHeight);
+ basePosition.left += atOffset[0];
+ basePosition.top += atOffset[1];
+
+ return this.each(function () {
+ var collisionPosition, using,
+ elem = $(this),
+ elemWidth = elem.outerWidth(),
+ elemHeight = elem.outerHeight(),
+ marginLeft = parseCss(this, "marginLeft"),
+ marginTop = parseCss(this, "marginTop"),
+ collisionWidth = elemWidth + marginLeft + parseCss(this, "marginRight") +
+ scrollInfo.width,
+ collisionHeight = elemHeight + marginTop + parseCss(this, "marginBottom") +
+ scrollInfo.height,
+ position = $.extend({}, basePosition),
+ myOffset = getOffsets(offsets.my, elem.outerWidth(), elem.outerHeight());
+
+ if (options.my[0] === "right") {
+ position.left -= elemWidth;
+ } else if (options.my[0] === "center") {
+ position.left -= elemWidth / 2;
+ }
+
+ if (options.my[1] === "bottom") {
+ position.top -= elemHeight;
+ } else if (options.my[1] === "center") {
+ position.top -= elemHeight / 2;
+ }
+
+ position.left += myOffset[0];
+ position.top += myOffset[1];
+
+ collisionPosition = {
+ marginLeft: marginLeft,
+ marginTop: marginTop
+ };
+
+ $.each(["left", "top"], function (i, dir) {
+ if ($.ui.position[collision[i]]) {
+ $.ui.position[collision[i]][dir](position, {
+ targetWidth: targetWidth,
+ targetHeight: targetHeight,
+ elemWidth: elemWidth,
+ elemHeight: elemHeight,
+ collisionPosition: collisionPosition,
+ collisionWidth: collisionWidth,
+ collisionHeight: collisionHeight,
+ offset: [atOffset[0] + myOffset[0], atOffset[1] + myOffset[1]],
+ my: options.my,
+ at: options.at,
+ within: within,
+ elem: elem
+ });
+ }
+ });
+
+ if (options.using) {
+
+ // Adds feedback as second argument to using callback, if present
+ using = function (props) {
+ var left = targetOffset.left - position.left,
+ right = left + targetWidth - elemWidth,
+ top = targetOffset.top - position.top,
+ bottom = top + targetHeight - elemHeight,
+ feedback = {
+ target: {
+ element: target,
+ left: targetOffset.left,
+ top: targetOffset.top,
+ width: targetWidth,
+ height: targetHeight
+ },
+ element: {
+ element: elem,
+ left: position.left,
+ top: position.top,
+ width: elemWidth,
+ height: elemHeight
+ },
+ horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
+ vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
+ };
+ if (targetWidth < elemWidth && abs(left + right) < targetWidth) {
+ feedback.horizontal = "center";
+ }
+ if (targetHeight < elemHeight && abs(top + bottom) < targetHeight) {
+ feedback.vertical = "middle";
+ }
+ if (max(abs(left), abs(right)) > max(abs(top), abs(bottom))) {
+ feedback.important = "horizontal";
+ } else {
+ feedback.important = "vertical";
+ }
+ options.using.call(this, props, feedback);
+ };
+ }
+
+ elem.offset($.extend(position, { using: using }));
+ });
+ };
+
+ $.ui.position = {
+ fit: {
+ left: function (position, data) {
+ var within = data.within,
+ withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
+ outerWidth = within.width,
+ collisionPosLeft = position.left - data.collisionPosition.marginLeft,
+ overLeft = withinOffset - collisionPosLeft,
+ overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
+ newOverRight;
+
+ // Element is wider than within
+ if (data.collisionWidth > outerWidth) {
+
+ // Element is initially over the left side of within
+ if (overLeft > 0 && overRight <= 0) {
+ newOverRight = position.left + overLeft + data.collisionWidth - outerWidth -
+ withinOffset;
+ position.left += overLeft - newOverRight;
+
+ // Element is initially over right side of within
+ } else if (overRight > 0 && overLeft <= 0) {
+ position.left = withinOffset;
+
+ // Element is initially over both left and right sides of within
+ } else {
+ if (overLeft > overRight) {
+ position.left = withinOffset + outerWidth - data.collisionWidth;
+ } else {
+ position.left = withinOffset;
+ }
+ }
+
+ // Too far left -> align with left edge
+ } else if (overLeft > 0) {
+ position.left += overLeft;
+
+ // Too far right -> align with right edge
+ } else if (overRight > 0) {
+ position.left -= overRight;
+
+ // Adjust based on position and margin
+ } else {
+ position.left = max(position.left - collisionPosLeft, position.left);
+ }
+ },
+ top: function (position, data) {
+ var within = data.within,
+ withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
+ outerHeight = data.within.height,
+ collisionPosTop = position.top - data.collisionPosition.marginTop,
+ overTop = withinOffset - collisionPosTop,
+ overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
+ newOverBottom;
+
+ // Element is taller than within
+ if (data.collisionHeight > outerHeight) {
+
+ // Element is initially over the top of within
+ if (overTop > 0 && overBottom <= 0) {
+ newOverBottom = position.top + overTop + data.collisionHeight - outerHeight -
+ withinOffset;
+ position.top += overTop - newOverBottom;
+
+ // Element is initially over bottom of within
+ } else if (overBottom > 0 && overTop <= 0) {
+ position.top = withinOffset;
+
+ // Element is initially over both top and bottom of within
+ } else {
+ if (overTop > overBottom) {
+ position.top = withinOffset + outerHeight - data.collisionHeight;
+ } else {
+ position.top = withinOffset;
+ }
+ }
+
+ // Too far up -> align with top
+ } else if (overTop > 0) {
+ position.top += overTop;
+
+ // Too far down -> align with bottom edge
+ } else if (overBottom > 0) {
+ position.top -= overBottom;
+
+ // Adjust based on position and margin
+ } else {
+ position.top = max(position.top - collisionPosTop, position.top);
+ }
+ }
+ },
+ flip: {
+ left: function (position, data) {
+ var within = data.within,
+ withinOffset = within.offset.left + within.scrollLeft,
+ outerWidth = within.width,
+ offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
+ collisionPosLeft = position.left - data.collisionPosition.marginLeft,
+ overLeft = collisionPosLeft - offsetLeft,
+ overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
+ myOffset = data.my[0] === "left" ?
+ -data.elemWidth :
+ data.my[0] === "right" ?
+ data.elemWidth :
+ 0,
+ atOffset = data.at[0] === "left" ?
+ data.targetWidth :
+ data.at[0] === "right" ?
+ -data.targetWidth :
+ 0,
+ offset = -2 * data.offset[0],
+ newOverRight,
+ newOverLeft;
+
+ if (overLeft < 0) {
+ newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth -
+ outerWidth - withinOffset;
+ if (newOverRight < 0 || newOverRight < abs(overLeft)) {
+ position.left += myOffset + atOffset + offset;
+ }
+ } else if (overRight > 0) {
+ newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset +
+ atOffset + offset - offsetLeft;
+ if (newOverLeft > 0 || abs(newOverLeft) < overRight) {
+ position.left += myOffset + atOffset + offset;
+ }
+ }
+ },
+ top: function (position, data) {
+ var within = data.within,
+ withinOffset = within.offset.top + within.scrollTop,
+ outerHeight = within.height,
+ offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
+ collisionPosTop = position.top - data.collisionPosition.marginTop,
+ overTop = collisionPosTop - offsetTop,
+ overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
+ top = data.my[1] === "top",
+ myOffset = top ?
+ -data.elemHeight :
+ data.my[1] === "bottom" ?
+ data.elemHeight :
+ 0,
+ atOffset = data.at[1] === "top" ?
+ data.targetHeight :
+ data.at[1] === "bottom" ?
+ -data.targetHeight :
+ 0,
+ offset = -2 * data.offset[1],
+ newOverTop,
+ newOverBottom;
+ if (overTop < 0) {
+ newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight -
+ outerHeight - withinOffset;
+ if (newOverBottom < 0 || newOverBottom < abs(overTop)) {
+ position.top += myOffset + atOffset + offset;
+ }
+ } else if (overBottom > 0) {
+ newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset +
+ offset - offsetTop;
+ if (newOverTop > 0 || abs(newOverTop) < overBottom) {
+ position.top += myOffset + atOffset + offset;
+ }
+ }
+ }
+ },
+ flipfit: {
+ left: function () {
+ $.ui.position.flip.left.apply(this, arguments);
+ $.ui.position.fit.left.apply(this, arguments);
+ },
+ top: function () {
+ $.ui.position.flip.top.apply(this, arguments);
+ $.ui.position.fit.top.apply(this, arguments);
+ }
+ }
+ };
+
+ })();
+
+ var position = $.ui.position;
+
+
+ /*!
+ * jQuery UI :data 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: :data Selector
+ //>>group: Core
+ //>>description: Selects elements which have data stored under the specified key.
+ //>>docs: http://api.jqueryui.com/data-selector/
+
+
+ var data = $.extend($.expr[":"], {
+ data: $.expr.createPseudo ?
+ $.expr.createPseudo(function (dataName) {
+ return function (elem) {
+ return !!$.data(elem, dataName);
+ };
+ }) :
+
+ // Support: jQuery <1.8
+ function (elem, i, match) {
+ return !!$.data(elem, match[3]);
+ }
+ });
+
+ /*!
+ * jQuery UI Disable Selection 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: disableSelection
+ //>>group: Core
+ //>>description: Disable selection of text content within the set of matched elements.
+ //>>docs: http://api.jqueryui.com/disableSelection/
+
+ // This file is deprecated
+
+
+ var disableSelection = $.fn.extend({
+ disableSelection: (function () {
+ var eventType = "onselectstart" in document.createElement("div") ?
+ "selectstart" :
+ "mousedown";
+
+ return function () {
+ return this.on(eventType + ".ui-disableSelection", function (event) {
+ event.preventDefault();
+ });
+ };
+ })(),
+
+ enableSelection: function () {
+ return this.off(".ui-disableSelection");
+ }
+ });
+
+
+ /*!
+ * jQuery UI Effects 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Effects Core
+ //>>group: Effects
+ // jscs:disable maximumLineLength
+ //>>description: Extends the internal jQuery effects. Includes morphing and easing. Required by all other effects.
+ // jscs:enable maximumLineLength
+ //>>docs: http://api.jqueryui.com/category/effects-core/
+ //>>demos: http://jqueryui.com/effect/
+
+
+
+ var dataSpace = "ui-effects-",
+ dataSpaceStyle = "ui-effects-style",
+ dataSpaceAnimated = "ui-effects-animated",
+
+ // Create a local jQuery because jQuery Color relies on it and the
+ // global may not exist with AMD and a custom build (#10199)
+ jQuery = $;
+
+ $.effects = {
+ effect: {}
+ };
+
+ /*!
+ * jQuery Color Animations v2.1.2
+ * https://github.com/jquery/jquery-color
+ *
+ * Copyright 2014 jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * Date: Wed Jan 16 08:47:09 2013 -0600
+ */
+ (function (jQuery, undefined) {
+
+ var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor " +
+ "borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
+
+ // Plusequals test for += 100 -= 100
+ rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
+
+ // A set of RE's that can match strings and generate color tuples.
+ stringParsers = [{
+ re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
+ parse: function (execResult) {
+ return [
+ execResult[1],
+ execResult[2],
+ execResult[3],
+ execResult[4]
+ ];
+ }
+ }, {
+ re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
+ parse: function (execResult) {
+ return [
+ execResult[1] * 2.55,
+ execResult[2] * 2.55,
+ execResult[3] * 2.55,
+ execResult[4]
+ ];
+ }
+ }, {
+
+ // This regex ignores A-F because it's compared against an already lowercased string
+ re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
+ parse: function (execResult) {
+ return [
+ parseInt(execResult[1], 16),
+ parseInt(execResult[2], 16),
+ parseInt(execResult[3], 16)
+ ];
+ }
+ }, {
+
+ // This regex ignores A-F because it's compared against an already lowercased string
+ re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
+ parse: function (execResult) {
+ return [
+ parseInt(execResult[1] + execResult[1], 16),
+ parseInt(execResult[2] + execResult[2], 16),
+ parseInt(execResult[3] + execResult[3], 16)
+ ];
+ }
+ }, {
+ re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
+ space: "hsla",
+ parse: function (execResult) {
+ return [
+ execResult[1],
+ execResult[2] / 100,
+ execResult[3] / 100,
+ execResult[4]
+ ];
+ }
+ }],
+
+ // JQuery.Color( )
+ color = jQuery.Color = function (color, green, blue, alpha) {
+ return new jQuery.Color.fn.parse(color, green, blue, alpha);
+ },
+ spaces = {
+ rgba: {
+ props: {
+ red: {
+ idx: 0,
+ type: "byte"
+ },
+ green: {
+ idx: 1,
+ type: "byte"
+ },
+ blue: {
+ idx: 2,
+ type: "byte"
+ }
+ }
+ },
+
+ hsla: {
+ props: {
+ hue: {
+ idx: 0,
+ type: "degrees"
+ },
+ saturation: {
+ idx: 1,
+ type: "percent"
+ },
+ lightness: {
+ idx: 2,
+ type: "percent"
+ }
+ }
+ }
+ },
+ propTypes = {
+ "byte": {
+ floor: true,
+ max: 255
+ },
+ "percent": {
+ max: 1
+ },
+ "degrees": {
+ mod: 360,
+ floor: true
+ }
+ },
+ support = color.support = {},
+
+ // Element for support tests
+ supportElem = jQuery("<p>")[0],
+
+ // Colors = jQuery.Color.names
+ colors,
+
+ // Local aliases of functions called often
+ each = jQuery.each;
+
+ // Determine rgba support immediately
+ supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
+ support.rgba = supportElem.style.backgroundColor.indexOf("rgba") > -1;
+
+ // Define cache name and alpha properties
+ // for rgba and hsla spaces
+ each(spaces, function (spaceName, space) {
+ space.cache = "_" + spaceName;
+ space.props.alpha = {
+ idx: 3,
+ type: "percent",
+ def: 1
+ };
+ });
+
+ function clamp(value, prop, allowEmpty) {
+ var type = propTypes[prop.type] || {};
+
+ if (value == null) {
+ return (allowEmpty || !prop.def) ? null : prop.def;
+ }
+
+ // ~~ is an short way of doing floor for positive numbers
+ value = type.floor ? ~~value : parseFloat(value);
+
+ // IE will pass in empty strings as value for alpha,
+ // which will hit this case
+ if (isNaN(value)) {
+ return prop.def;
+ }
+
+ if (type.mod) {
+
+ // We add mod before modding to make sure that negatives values
+ // get converted properly: -10 -> 350
+ return (value + type.mod) % type.mod;
+ }
+
+ // For now all property types without mod have min and max
+ return 0 > value ? 0 : type.max < value ? type.max : value;
+ }
+
+ function stringParse(string) {
+ var inst = color(),
+ rgba = inst._rgba = [];
+
+ string = string.toLowerCase();
+
+ each(stringParsers, function (i, parser) {
+ var parsed,
+ match = parser.re.exec(string),
+ values = match && parser.parse(match),
+ spaceName = parser.space || "rgba";
+
+ if (values) {
+ parsed = inst[spaceName](values);
+
+ // If this was an rgba parse the assignment might happen twice
+ // oh well....
+ inst[spaces[spaceName].cache] = parsed[spaces[spaceName].cache];
+ rgba = inst._rgba = parsed._rgba;
+
+ // Exit each( stringParsers ) here because we matched
+ return false;
+ }
+ });
+
+ // Found a stringParser that handled it
+ if (rgba.length) {
+
+ // If this came from a parsed string, force "transparent" when alpha is 0
+ // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
+ if (rgba.join() === "0,0,0,0") {
+ jQuery.extend(rgba, colors.transparent);
+ }
+ return inst;
+ }
+
+ // Named colors
+ return colors[string];
+ }
+
+ color.fn = jQuery.extend(color.prototype, {
+ parse: function (red, green, blue, alpha) {
+ if (red === undefined) {
+ this._rgba = [null, null, null, null];
+ return this;
+ }
+ if (red.jquery || red.nodeType) {
+ red = jQuery(red).css(green);
+ green = undefined;
+ }
+
+ var inst = this,
+ type = jQuery.type(red),
+ rgba = this._rgba = [];
+
+ // More than 1 argument specified - assume ( red, green, blue, alpha )
+ if (green !== undefined) {
+ red = [red, green, blue, alpha];
+ type = "array";
+ }
+
+ if (type === "string") {
+ return this.parse(stringParse(red) || colors._default);
+ }
+
+ if (type === "array") {
+ each(spaces.rgba.props, function (key, prop) {
+ rgba[prop.idx] = clamp(red[prop.idx], prop);
+ });
+ return this;
+ }
+
+ if (type === "object") {
+ if (red instanceof color) {
+ each(spaces, function (spaceName, space) {
+ if (red[space.cache]) {
+ inst[space.cache] = red[space.cache].slice();
+ }
+ });
+ } else {
+ each(spaces, function (spaceName, space) {
+ var cache = space.cache;
+ each(space.props, function (key, prop) {
+
+ // If the cache doesn't exist, and we know how to convert
+ if (!inst[cache] && space.to) {
+
+ // If the value was null, we don't need to copy it
+ // if the key was alpha, we don't need to copy it either
+ if (key === "alpha" || red[key] == null) {
+ return;
+ }
+ inst[cache] = space.to(inst._rgba);
+ }
+
+ // This is the only case where we allow nulls for ALL properties.
+ // call clamp with alwaysAllowEmpty
+ inst[cache][prop.idx] = clamp(red[key], prop, true);
+ });
+
+ // Everything defined but alpha?
+ if (inst[cache] &&
+ jQuery.inArray(null, inst[cache].slice(0, 3)) < 0) {
+
+ // Use the default of 1
+ inst[cache][3] = 1;
+ if (space.from) {
+ inst._rgba = space.from(inst[cache]);
+ }
+ }
+ });
+ }
+ return this;
+ }
+ },
+ is: function (compare) {
+ var is = color(compare),
+ same = true,
+ inst = this;
+
+ each(spaces, function (_, space) {
+ var localCache,
+ isCache = is[space.cache];
+ if (isCache) {
+ localCache = inst[space.cache] || space.to && space.to(inst._rgba) || [];
+ each(space.props, function (_, prop) {
+ if (isCache[prop.idx] != null) {
+ same = (isCache[prop.idx] === localCache[prop.idx]);
+ return same;
+ }
+ });
+ }
+ return same;
+ });
+ return same;
+ },
+ _space: function () {
+ var used = [],
+ inst = this;
+ each(spaces, function (spaceName, space) {
+ if (inst[space.cache]) {
+ used.push(spaceName);
+ }
+ });
+ return used.pop();
+ },
+ transition: function (other, distance) {
+ var end = color(other),
+ spaceName = end._space(),
+ space = spaces[spaceName],
+ startColor = this.alpha() === 0 ? color("transparent") : this,
+ start = startColor[space.cache] || space.to(startColor._rgba),
+ result = start.slice();
+
+ end = end[space.cache];
+ each(space.props, function (key, prop) {
+ var index = prop.idx,
+ startValue = start[index],
+ endValue = end[index],
+ type = propTypes[prop.type] || {};
+
+ // If null, don't override start value
+ if (endValue === null) {
+ return;
+ }
+
+ // If null - use end
+ if (startValue === null) {
+ result[index] = endValue;
+ } else {
+ if (type.mod) {
+ if (endValue - startValue > type.mod / 2) {
+ startValue += type.mod;
+ } else if (startValue - endValue > type.mod / 2) {
+ startValue -= type.mod;
+ }
+ }
+ result[index] = clamp((endValue - startValue) * distance + startValue, prop);
+ }
+ });
+ return this[spaceName](result);
+ },
+ blend: function (opaque) {
+
+ // If we are already opaque - return ourself
+ if (this._rgba[3] === 1) {
+ return this;
+ }
+
+ var rgb = this._rgba.slice(),
+ a = rgb.pop(),
+ blend = color(opaque)._rgba;
+
+ return color(jQuery.map(rgb, function (v, i) {
+ return (1 - a) * blend[i] + a * v;
+ }));
+ },
+ toRgbaString: function () {
+ var prefix = "rgba(",
+ rgba = jQuery.map(this._rgba, function (v, i) {
+ return v == null ? (i > 2 ? 1 : 0) : v;
+ });
+
+ if (rgba[3] === 1) {
+ rgba.pop();
+ prefix = "rgb(";
+ }
+
+ return prefix + rgba.join() + ")";
+ },
+ toHslaString: function () {
+ var prefix = "hsla(",
+ hsla = jQuery.map(this.hsla(), function (v, i) {
+ if (v == null) {
+ v = i > 2 ? 1 : 0;
+ }
+
+ // Catch 1 and 2
+ if (i && i < 3) {
+ v = Math.round(v * 100) + "%";
+ }
+ return v;
+ });
+
+ if (hsla[3] === 1) {
+ hsla.pop();
+ prefix = "hsl(";
+ }
+ return prefix + hsla.join() + ")";
+ },
+ toHexString: function (includeAlpha) {
+ var rgba = this._rgba.slice(),
+ alpha = rgba.pop();
+
+ if (includeAlpha) {
+ rgba.push(~~(alpha * 255));
+ }
+
+ return "#" + jQuery.map(rgba, function (v) {
+
+ // Default to 0 when nulls exist
+ v = (v || 0).toString(16);
+ return v.length === 1 ? "0" + v : v;
+ }).join("");
+ },
+ toString: function () {
+ return this._rgba[3] === 0 ? "transparent" : this.toRgbaString();
+ }
+ });
+ color.fn.parse.prototype = color.fn;
+
+ // Hsla conversions adapted from:
+ // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
+
+ function hue2rgb(p, q, h) {
+ h = (h + 1) % 1;
+ if (h * 6 < 1) {
+ return p + (q - p) * h * 6;
+ }
+ if (h * 2 < 1) {
+ return q;
+ }
+ if (h * 3 < 2) {
+ return p + (q - p) * ((2 / 3) - h) * 6;
+ }
+ return p;
+ }
+
+ spaces.hsla.to = function (rgba) {
+ if (rgba[0] == null || rgba[1] == null || rgba[2] == null) {
+ return [null, null, null, rgba[3]];
+ }
+ var r = rgba[0] / 255,
+ g = rgba[1] / 255,
+ b = rgba[2] / 255,
+ a = rgba[3],
+ max = Math.max(r, g, b),
+ min = Math.min(r, g, b),
+ diff = max - min,
+ add = max + min,
+ l = add * 0.5,
+ h, s;
+
+ if (min === max) {
+ h = 0;
+ } else if (r === max) {
+ h = (60 * (g - b) / diff) + 360;
+ } else if (g === max) {
+ h = (60 * (b - r) / diff) + 120;
+ } else {
+ h = (60 * (r - g) / diff) + 240;
+ }
+
+ // Chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
+ // otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
+ if (diff === 0) {
+ s = 0;
+ } else if (l <= 0.5) {
+ s = diff / add;
+ } else {
+ s = diff / (2 - add);
+ }
+ return [Math.round(h) % 360, s, l, a == null ? 1 : a];
+ };
+
+ spaces.hsla.from = function (hsla) {
+ if (hsla[0] == null || hsla[1] == null || hsla[2] == null) {
+ return [null, null, null, hsla[3]];
+ }
+ var h = hsla[0] / 360,
+ s = hsla[1],
+ l = hsla[2],
+ a = hsla[3],
+ q = l <= 0.5 ? l * (1 + s) : l + s - l * s,
+ p = 2 * l - q;
+
+ return [
+ Math.round(hue2rgb(p, q, h + (1 / 3)) * 255),
+ Math.round(hue2rgb(p, q, h) * 255),
+ Math.round(hue2rgb(p, q, h - (1 / 3)) * 255),
+ a
+ ];
+ };
+
+ each(spaces, function (spaceName, space) {
+ var props = space.props,
+ cache = space.cache,
+ to = space.to,
+ from = space.from;
+
+ // Makes rgba() and hsla()
+ color.fn[spaceName] = function (value) {
+
+ // Generate a cache for this space if it doesn't exist
+ if (to && !this[cache]) {
+ this[cache] = to(this._rgba);
+ }
+ if (value === undefined) {
+ return this[cache].slice();
+ }
+
+ var ret,
+ type = jQuery.type(value),
+ arr = (type === "array" || type === "object") ? value : arguments,
+ local = this[cache].slice();
+
+ each(props, function (key, prop) {
+ var val = arr[type === "object" ? key : prop.idx];
+ if (val == null) {
+ val = local[prop.idx];
+ }
+ local[prop.idx] = clamp(val, prop);
+ });
+
+ if (from) {
+ ret = color(from(local));
+ ret[cache] = local;
+ return ret;
+ } else {
+ return color(local);
+ }
+ };
+
+ // Makes red() green() blue() alpha() hue() saturation() lightness()
+ each(props, function (key, prop) {
+
+ // Alpha is included in more than one space
+ if (color.fn[key]) {
+ return;
+ }
+ color.fn[key] = function (value) {
+ var vtype = jQuery.type(value),
+ fn = (key === "alpha" ? (this._hsla ? "hsla" : "rgba") : spaceName),
+ local = this[fn](),
+ cur = local[prop.idx],
+ match;
+
+ if (vtype === "undefined") {
+ return cur;
+ }
+
+ if (vtype === "function") {
+ value = value.call(this, cur);
+ vtype = jQuery.type(value);
+ }
+ if (value == null && prop.empty) {
+ return this;
+ }
+ if (vtype === "string") {
+ match = rplusequals.exec(value);
+ if (match) {
+ value = cur + parseFloat(match[2]) * (match[1] === "+" ? 1 : -1);
+ }
+ }
+ local[prop.idx] = value;
+ return this[fn](local);
+ };
+ });
+ });
+
+ // Add cssHook and .fx.step function for each named hook.
+ // accept a space separated string of properties
+ color.hook = function (hook) {
+ var hooks = hook.split(" ");
+ each(hooks, function (i, hook) {
+ jQuery.cssHooks[hook] = {
+ set: function (elem, value) {
+ var parsed, curElem,
+ backgroundColor = "";
+
+ if (value !== "transparent" && (jQuery.type(value) !== "string" ||
+ (parsed = stringParse(value)))) {
+ value = color(parsed || value);
+ if (!support.rgba && value._rgba[3] !== 1) {
+ curElem = hook === "backgroundColor" ? elem.parentNode : elem;
+ while (
+ (backgroundColor === "" || backgroundColor === "transparent") &&
+ curElem && curElem.style
+ ) {
+ try {
+ backgroundColor = jQuery.css(curElem, "backgroundColor");
+ curElem = curElem.parentNode;
+ } catch (e) {
+ }
+ }
+
+ value = value.blend(backgroundColor && backgroundColor !== "transparent" ?
+ backgroundColor :
+ "_default");
+ }
+
+ value = value.toRgbaString();
+ }
+ try {
+ elem.style[hook] = value;
+ } catch (e) {
+
+ // Wrapped to prevent IE from throwing errors on "invalid" values like
+ // 'auto' or 'inherit'
+ }
+ }
+ };
+ jQuery.fx.step[hook] = function (fx) {
+ if (!fx.colorInit) {
+ fx.start = color(fx.elem, hook);
+ fx.end = color(fx.end);
+ fx.colorInit = true;
+ }
+ jQuery.cssHooks[hook].set(fx.elem, fx.start.transition(fx.end, fx.pos));
+ };
+ });
+
+ };
+
+ color.hook(stepHooks);
+
+ jQuery.cssHooks.borderColor = {
+ expand: function (value) {
+ var expanded = {};
+
+ each(["Top", "Right", "Bottom", "Left"], function (i, part) {
+ expanded["border" + part + "Color"] = value;
+ });
+ return expanded;
+ }
+ };
+
+ // Basic color names only.
+ // Usage of any of the other color names requires adding yourself or including
+ // jquery.color.svg-names.js.
+ colors = jQuery.Color.names = {
+
+ // 4.1. Basic color keywords
+ aqua: "#00ffff",
+ black: "#000000",
+ blue: "#0000ff",
+ fuchsia: "#ff00ff",
+ gray: "#808080",
+ green: "#008000",
+ lime: "#00ff00",
+ maroon: "#800000",
+ navy: "#000080",
+ olive: "#808000",
+ purple: "#800080",
+ red: "#ff0000",
+ silver: "#c0c0c0",
+ teal: "#008080",
+ white: "#ffffff",
+ yellow: "#ffff00",
+
+ // 4.2.3. "transparent" color keyword
+ transparent: [null, null, null, 0],
+
+ _default: "#ffffff"
+ };
+
+ })(jQuery);
+
+ /******************************************************************************/
+ /****************************** CLASS ANIMATIONS ******************************/
+ /******************************************************************************/
+ (function () {
+
+ var classAnimationActions = ["add", "remove", "toggle"],
+ shorthandStyles = {
+ border: 1,
+ borderBottom: 1,
+ borderColor: 1,
+ borderLeft: 1,
+ borderRight: 1,
+ borderTop: 1,
+ borderWidth: 1,
+ margin: 1,
+ padding: 1
+ };
+
+ $.each(
+ ["borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle"],
+ function (_, prop) {
+ $.fx.step[prop] = function (fx) {
+ if (fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr) {
+ jQuery.style(fx.elem, prop, fx.end);
+ fx.setAttr = true;
+ }
+ };
+ }
+ );
+
+ function getElementStyles(elem) {
+ var key, len,
+ style = elem.ownerDocument.defaultView ?
+ elem.ownerDocument.defaultView.getComputedStyle(elem, null) :
+ elem.currentStyle,
+ styles = {};
+
+ if (style && style.length && style[0] && style[style[0]]) {
+ len = style.length;
+ while (len--) {
+ key = style[len];
+ if (typeof style[key] === "string") {
+ styles[$.camelCase(key)] = style[key];
+ }
+ }
+
+ // Support: Opera, IE <9
+ } else {
+ for (key in style) {
+ if (typeof style[key] === "string") {
+ styles[key] = style[key];
+ }
+ }
+ }
+
+ return styles;
+ }
+
+ function styleDifference(oldStyle, newStyle) {
+ var diff = {},
+ name, value;
+
+ for (name in newStyle) {
+ value = newStyle[name];
+ if (oldStyle[name] !== value) {
+ if (!shorthandStyles[name]) {
+ if ($.fx.step[name] || !isNaN(parseFloat(value))) {
+ diff[name] = value;
+ }
+ }
+ }
+ }
+
+ return diff;
+ }
+
+ // Support: jQuery <1.8
+ if (!$.fn.addBack) {
+ $.fn.addBack = function (selector) {
+ return this.add(selector == null ?
+ this.prevObject : this.prevObject.filter(selector)
+ );
+ };
+ }
+
+ $.effects.animateClass = function (value, duration, easing, callback) {
+ var o = $.speed(duration, easing, callback);
+
+ return this.queue(function () {
+ var animated = $(this),
+ baseClass = animated.attr("class") || "",
+ applyClassChange,
+ allAnimations = o.children ? animated.find("*").addBack() : animated;
+
+ // Map the animated objects to store the original styles.
+ allAnimations = allAnimations.map(function () {
+ var el = $(this);
+ return {
+ el: el,
+ start: getElementStyles(this)
+ };
+ });
+
+ // Apply class change
+ applyClassChange = function () {
+ $.each(classAnimationActions, function (i, action) {
+ if (value[action]) {
+ animated[action + "Class"](value[action]);
+ }
+ });
+ };
+ applyClassChange();
+
+ // Map all animated objects again - calculate new styles and diff
+ allAnimations = allAnimations.map(function () {
+ this.end = getElementStyles(this.el[0]);
+ this.diff = styleDifference(this.start, this.end);
+ return this;
+ });
+
+ // Apply original class
+ animated.attr("class", baseClass);
+
+ // Map all animated objects again - this time collecting a promise
+ allAnimations = allAnimations.map(function () {
+ var styleInfo = this,
+ dfd = $.Deferred(),
+ opts = $.extend({}, o, {
+ queue: false,
+ complete: function () {
+ dfd.resolve(styleInfo);
+ }
+ });
+
+ this.el.animate(this.diff, opts);
+ return dfd.promise();
+ });
+
+ // Once all animations have completed:
+ $.when.apply($, allAnimations.get()).done(function () {
+
+ // Set the final class
+ applyClassChange();
+
+ // For each animated element,
+ // clear all css properties that were animated
+ $.each(arguments, function () {
+ var el = this.el;
+ $.each(this.diff, function (key) {
+ el.css(key, "");
+ });
+ });
+
+ // This is guarnteed to be there if you use jQuery.speed()
+ // it also handles dequeuing the next anim...
+ o.complete.call(animated[0]);
+ });
+ });
+ };
+
+ $.fn.extend({
+ addClass: (function (orig) {
+ return function (classNames, speed, easing, callback) {
+ return speed ?
+ $.effects.animateClass.call(this,
+ { add: classNames }, speed, easing, callback) :
+ orig.apply(this, arguments);
+ };
+ })($.fn.addClass),
+
+ removeClass: (function (orig) {
+ return function (classNames, speed, easing, callback) {
+ return arguments.length > 1 ?
+ $.effects.animateClass.call(this,
+ { remove: classNames }, speed, easing, callback) :
+ orig.apply(this, arguments);
+ };
+ })($.fn.removeClass),
+
+ toggleClass: (function (orig) {
+ return function (classNames, force, speed, easing, callback) {
+ if (typeof force === "boolean" || force === undefined) {
+ if (!speed) {
+
+ // Without speed parameter
+ return orig.apply(this, arguments);
+ } else {
+ return $.effects.animateClass.call(this,
+ (force ? { add: classNames } : { remove: classNames }),
+ speed, easing, callback);
+ }
+ } else {
+
+ // Without force parameter
+ return $.effects.animateClass.call(this,
+ { toggle: classNames }, force, speed, easing);
+ }
+ };
+ })($.fn.toggleClass),
+
+ switchClass: function (remove, add, speed, easing, callback) {
+ return $.effects.animateClass.call(this, {
+ add: add,
+ remove: remove
+ }, speed, easing, callback);
+ }
+ });
+
+ })();
+
+ /******************************************************************************/
+ /*********************************** EFFECTS **********************************/
+ /******************************************************************************/
+
+ (function () {
+
+ if ($.expr && $.expr.filters && $.expr.filters.animated) {
+ $.expr.filters.animated = (function (orig) {
+ return function (elem) {
+ return !!$(elem).data(dataSpaceAnimated) || orig(elem);
+ };
+ })($.expr.filters.animated);
+ }
+
+ if ($.uiBackCompat !== false) {
+ $.extend($.effects, {
+
+ // Saves a set of properties in a data storage
+ save: function (element, set) {
+ var i = 0, length = set.length;
+ for (; i < length; i++) {
+ if (set[i] !== null) {
+ element.data(dataSpace + set[i], element[0].style[set[i]]);
+ }
+ }
+ },
+
+ // Restores a set of previously saved properties from a data storage
+ restore: function (element, set) {
+ var val, i = 0, length = set.length;
+ for (; i < length; i++) {
+ if (set[i] !== null) {
+ val = element.data(dataSpace + set[i]);
+ element.css(set[i], val);
+ }
+ }
+ },
+
+ setMode: function (el, mode) {
+ if (mode === "toggle") {
+ mode = el.is(":hidden") ? "show" : "hide";
+ }
+ return mode;
+ },
+
+ // Wraps the element around a wrapper that copies position properties
+ createWrapper: function (element) {
+
+ // If the element is already wrapped, return it
+ if (element.parent().is(".ui-effects-wrapper")) {
+ return element.parent();
+ }
+
+ // Wrap the element
+ var props = {
+ width: element.outerWidth(true),
+ height: element.outerHeight(true),
+ "float": element.css("float")
+ },
+ wrapper = $("<div></div>")
+ .addClass("ui-effects-wrapper")
+ .css({
+ fontSize: "100%",
+ background: "transparent",
+ border: "none",
+ margin: 0,
+ padding: 0
+ }),
+
+ // Store the size in case width/height are defined in % - Fixes #5245
+ size = {
+ width: element.width(),
+ height: element.height()
+ },
+ active = document.activeElement;
+
+ // Support: Firefox
+ // Firefox incorrectly exposes anonymous content
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=561664
+ try {
+ active.id;
+ } catch (e) {
+ active = document.body;
+ }
+
+ element.wrap(wrapper);
+
+ // Fixes #7595 - Elements lose focus when wrapped.
+ if (element[0] === active || $.contains(element[0], active)) {
+ $(active).trigger("focus");
+ }
+
+ // Hotfix for jQuery 1.4 since some change in wrap() seems to actually
+ // lose the reference to the wrapped element
+ wrapper = element.parent();
+
+ // Transfer positioning properties to the wrapper
+ if (element.css("position") === "static") {
+ wrapper.css({ position: "relative" });
+ element.css({ position: "relative" });
+ } else {
+ $.extend(props, {
+ position: element.css("position"),
+ zIndex: element.css("z-index")
+ });
+ $.each(["top", "left", "bottom", "right"], function (i, pos) {
+ props[pos] = element.css(pos);
+ if (isNaN(parseInt(props[pos], 10))) {
+ props[pos] = "auto";
+ }
+ });
+ element.css({
+ position: "relative",
+ top: 0,
+ left: 0,
+ right: "auto",
+ bottom: "auto"
+ });
+ }
+ element.css(size);
+
+ return wrapper.css(props).show();
+ },
+
+ removeWrapper: function (element) {
+ var active = document.activeElement;
+
+ if (element.parent().is(".ui-effects-wrapper")) {
+ element.parent().replaceWith(element);
+
+ // Fixes #7595 - Elements lose focus when wrapped.
+ if (element[0] === active || $.contains(element[0], active)) {
+ $(active).trigger("focus");
+ }
+ }
+
+ return element;
+ }
+ });
+ }
+
+ $.extend($.effects, {
+ version: "1.12.1",
+
+ define: function (name, mode, effect) {
+ if (!effect) {
+ effect = mode;
+ mode = "effect";
+ }
+
+ $.effects.effect[name] = effect;
+ $.effects.effect[name].mode = mode;
+
+ return effect;
+ },
+
+ scaledDimensions: function (element, percent, direction) {
+ if (percent === 0) {
+ return {
+ height: 0,
+ width: 0,
+ outerHeight: 0,
+ outerWidth: 0
+ };
+ }
+
+ var x = direction !== "horizontal" ? ((percent || 100) / 100) : 1,
+ y = direction !== "vertical" ? ((percent || 100) / 100) : 1;
+
+ return {
+ height: element.height() * y,
+ width: element.width() * x,
+ outerHeight: element.outerHeight() * y,
+ outerWidth: element.outerWidth() * x
+ };
+
+ },
+
+ clipToBox: function (animation) {
+ return {
+ width: animation.clip.right - animation.clip.left,
+ height: animation.clip.bottom - animation.clip.top,
+ left: animation.clip.left,
+ top: animation.clip.top
+ };
+ },
+
+ // Injects recently queued functions to be first in line (after "inprogress")
+ unshift: function (element, queueLength, count) {
+ var queue = element.queue();
+
+ if (queueLength > 1) {
+ queue.splice.apply(queue,
+ [1, 0].concat(queue.splice(queueLength, count)));
+ }
+ element.dequeue();
+ },
+
+ saveStyle: function (element) {
+ element.data(dataSpaceStyle, element[0].style.cssText);
+ },
+
+ restoreStyle: function (element) {
+ element[0].style.cssText = element.data(dataSpaceStyle) || "";
+ element.removeData(dataSpaceStyle);
+ },
+
+ mode: function (element, mode) {
+ var hidden = element.is(":hidden");
+
+ if (mode === "toggle") {
+ mode = hidden ? "show" : "hide";
+ }
+ if (hidden ? mode === "hide" : mode === "show") {
+ mode = "none";
+ }
+ return mode;
+ },
+
+ // Translates a [top,left] array into a baseline value
+ getBaseline: function (origin, original) {
+ var y, x;
+
+ switch (origin[0]) {
+ case "top":
+ y = 0;
+ break;
+ case "middle":
+ y = 0.5;
+ break;
+ case "bottom":
+ y = 1;
+ break;
+ default:
+ y = origin[0] / original.height;
+ }
+
+ switch (origin[1]) {
+ case "left":
+ x = 0;
+ break;
+ case "center":
+ x = 0.5;
+ break;
+ case "right":
+ x = 1;
+ break;
+ default:
+ x = origin[1] / original.width;
+ }
+
+ return {
+ x: x,
+ y: y
+ };
+ },
+
+ // Creates a placeholder element so that the original element can be made absolute
+ createPlaceholder: function (element) {
+ var placeholder,
+ cssPosition = element.css("position"),
+ position = element.position();
+
+ // Lock in margins first to account for form elements, which
+ // will change margin if you explicitly set height
+ // see: http://jsfiddle.net/JZSMt/3/ https://bugs.webkit.org/show_bug.cgi?id=107380
+ // Support: Safari
+ element.css({
+ marginTop: element.css("marginTop"),
+ marginBottom: element.css("marginBottom"),
+ marginLeft: element.css("marginLeft"),
+ marginRight: element.css("marginRight")
+ })
+ .outerWidth(element.outerWidth())
+ .outerHeight(element.outerHeight());
+
+ if (/^(static|relative)/.test(cssPosition)) {
+ cssPosition = "absolute";
+
+ placeholder = $("<" + element[0].nodeName + ">").insertAfter(element).css({
+
+ // Convert inline to inline block to account for inline elements
+ // that turn to inline block based on content (like img)
+ display: /^(inline|ruby)/.test(element.css("display")) ?
+ "inline-block" :
+ "block",
+ visibility: "hidden",
+
+ // Margins need to be set to account for margin collapse
+ marginTop: element.css("marginTop"),
+ marginBottom: element.css("marginBottom"),
+ marginLeft: element.css("marginLeft"),
+ marginRight: element.css("marginRight"),
+ "float": element.css("float")
+ })
+ .outerWidth(element.outerWidth())
+ .outerHeight(element.outerHeight())
+ .addClass("ui-effects-placeholder");
+
+ element.data(dataSpace + "placeholder", placeholder);
+ }
+
+ element.css({
+ position: cssPosition,
+ left: position.left,
+ top: position.top
+ });
+
+ return placeholder;
+ },
+
+ removePlaceholder: function (element) {
+ var dataKey = dataSpace + "placeholder",
+ placeholder = element.data(dataKey);
+
+ if (placeholder) {
+ placeholder.remove();
+ element.removeData(dataKey);
+ }
+ },
+
+ // Removes a placeholder if it exists and restores
+ // properties that were modified during placeholder creation
+ cleanUp: function (element) {
+ $.effects.restoreStyle(element);
+ $.effects.removePlaceholder(element);
+ },
+
+ setTransition: function (element, list, factor, value) {
+ value = value || {};
+ $.each(list, function (i, x) {
+ var unit = element.cssUnit(x);
+ if (unit[0] > 0) {
+ value[x] = unit[0] * factor + unit[1];
+ }
+ });
+ return value;
+ }
+ });
+
+ // Return an effect options object for the given parameters:
+ function _normalizeArguments(effect, options, speed, callback) {
+
+ // Allow passing all options as the first parameter
+ if ($.isPlainObject(effect)) {
+ options = effect;
+ effect = effect.effect;
+ }
+
+ // Convert to an object
+ effect = { effect: effect };
+
+ // Catch (effect, null, ...)
+ if (options == null) {
+ options = {};
+ }
+
+ // Catch (effect, callback)
+ if ($.isFunction(options)) {
+ callback = options;
+ speed = null;
+ options = {};
+ }
+
+ // Catch (effect, speed, ?)
+ if (typeof options === "number" || $.fx.speeds[options]) {
+ callback = speed;
+ speed = options;
+ options = {};
+ }
+
+ // Catch (effect, options, callback)
+ if ($.isFunction(speed)) {
+ callback = speed;
+ speed = null;
+ }
+
+ // Add options to effect
+ if (options) {
+ $.extend(effect, options);
+ }
+
+ speed = speed || options.duration;
+ effect.duration = $.fx.off ? 0 :
+ typeof speed === "number" ? speed :
+ speed in $.fx.speeds ? $.fx.speeds[speed] :
+ $.fx.speeds._default;
+
+ effect.complete = callback || options.complete;
+
+ return effect;
+ }
+
+ function standardAnimationOption(option) {
+
+ // Valid standard speeds (nothing, number, named speed)
+ if (!option || typeof option === "number" || $.fx.speeds[option]) {
+ return true;
+ }
+
+ // Invalid strings - treat as "normal" speed
+ if (typeof option === "string" && !$.effects.effect[option]) {
+ return true;
+ }
+
+ // Complete callback
+ if ($.isFunction(option)) {
+ return true;
+ }
+
+ // Options hash (but not naming an effect)
+ if (typeof option === "object" && !option.effect) {
+ return true;
+ }
+
+ // Didn't match any standard API
+ return false;
+ }
+
+ $.fn.extend({
+ effect: function ( /* effect, options, speed, callback */) {
+ var args = _normalizeArguments.apply(this, arguments),
+ effectMethod = $.effects.effect[args.effect],
+ defaultMode = effectMethod.mode,
+ queue = args.queue,
+ queueName = queue || "fx",
+ complete = args.complete,
+ mode = args.mode,
+ modes = [],
+ prefilter = function (next) {
+ var el = $(this),
+ normalizedMode = $.effects.mode(el, mode) || defaultMode;
+
+ // Sentinel for duck-punching the :animated psuedo-selector
+ el.data(dataSpaceAnimated, true);
+
+ // Save effect mode for later use,
+ // we can't just call $.effects.mode again later,
+ // as the .show() below destroys the initial state
+ modes.push(normalizedMode);
+
+ // See $.uiBackCompat inside of run() for removal of defaultMode in 1.13
+ if (defaultMode && (normalizedMode === "show" ||
+ (normalizedMode === defaultMode && normalizedMode === "hide"))) {
+ el.show();
+ }
+
+ if (!defaultMode || normalizedMode !== "none") {
+ $.effects.saveStyle(el);
+ }
+
+ if ($.isFunction(next)) {
+ next();
+ }
+ };
+
+ if ($.fx.off || !effectMethod) {
+
+ // Delegate to the original method (e.g., .show()) if possible
+ if (mode) {
+ return this[mode](args.duration, complete);
+ } else {
+ return this.each(function () {
+ if (complete) {
+ complete.call(this);
+ }
+ });
+ }
+ }
+
+ function run(next) {
+ var elem = $(this);
+
+ function cleanup() {
+ elem.removeData(dataSpaceAnimated);
+
+ $.effects.cleanUp(elem);
+
+ if (args.mode === "hide") {
+ elem.hide();
+ }
+
+ done();
+ }
+
+ function done() {
+ if ($.isFunction(complete)) {
+ complete.call(elem[0]);
+ }
+
+ if ($.isFunction(next)) {
+ next();
+ }
+ }
+
+ // Override mode option on a per element basis,
+ // as toggle can be either show or hide depending on element state
+ args.mode = modes.shift();
+
+ if ($.uiBackCompat !== false && !defaultMode) {
+ if (elem.is(":hidden") ? mode === "hide" : mode === "show") {
+
+ // Call the core method to track "olddisplay" properly
+ elem[mode]();
+ done();
+ } else {
+ effectMethod.call(elem[0], args, done);
+ }
+ } else {
+ if (args.mode === "none") {
+
+ // Call the core method to track "olddisplay" properly
+ elem[mode]();
+ done();
+ } else {
+ effectMethod.call(elem[0], args, cleanup);
+ }
+ }
+ }
+
+ // Run prefilter on all elements first to ensure that
+ // any showing or hiding happens before placeholder creation,
+ // which ensures that any layout changes are correctly captured.
+ return queue === false ?
+ this.each(prefilter).each(run) :
+ this.queue(queueName, prefilter).queue(queueName, run);
+ },
+
+ show: (function (orig) {
+ return function (option) {
+ if (standardAnimationOption(option)) {
+ return orig.apply(this, arguments);
+ } else {
+ var args = _normalizeArguments.apply(this, arguments);
+ args.mode = "show";
+ return this.effect.call(this, args);
+ }
+ };
+ })($.fn.show),
+
+ hide: (function (orig) {
+ return function (option) {
+ if (standardAnimationOption(option)) {
+ return orig.apply(this, arguments);
+ } else {
+ var args = _normalizeArguments.apply(this, arguments);
+ args.mode = "hide";
+ return this.effect.call(this, args);
+ }
+ };
+ })($.fn.hide),
+
+ toggle: (function (orig) {
+ return function (option) {
+ if (standardAnimationOption(option) || typeof option === "boolean") {
+ return orig.apply(this, arguments);
+ } else {
+ var args = _normalizeArguments.apply(this, arguments);
+ args.mode = "toggle";
+ return this.effect.call(this, args);
+ }
+ };
+ })($.fn.toggle),
+
+ cssUnit: function (key) {
+ var style = this.css(key),
+ val = [];
+
+ $.each(["em", "px", "%", "pt"], function (i, unit) {
+ if (style.indexOf(unit) > 0) {
+ val = [parseFloat(style), unit];
+ }
+ });
+ return val;
+ },
+
+ cssClip: function (clipObj) {
+ if (clipObj) {
+ return this.css("clip", "rect(" + clipObj.top + "px " + clipObj.right + "px " +
+ clipObj.bottom + "px " + clipObj.left + "px)");
+ }
+ return parseClip(this.css("clip"), this);
+ },
+
+ transfer: function (options, done) {
+ var element = $(this),
+ target = $(options.to),
+ targetFixed = target.css("position") === "fixed",
+ body = $("body"),
+ fixTop = targetFixed ? body.scrollTop() : 0,
+ fixLeft = targetFixed ? body.scrollLeft() : 0,
+ endPosition = target.offset(),
+ animation = {
+ top: endPosition.top - fixTop,
+ left: endPosition.left - fixLeft,
+ height: target.innerHeight(),
+ width: target.innerWidth()
+ },
+ startPosition = element.offset(),
+ transfer = $("<div class='ui-effects-transfer'></div>")
+ .appendTo("body")
+ .addClass(options.className)
+ .css({
+ top: startPosition.top - fixTop,
+ left: startPosition.left - fixLeft,
+ height: element.innerHeight(),
+ width: element.innerWidth(),
+ position: targetFixed ? "fixed" : "absolute"
+ })
+ .animate(animation, options.duration, options.easing, function () {
+ transfer.remove();
+ if ($.isFunction(done)) {
+ done();
+ }
+ });
+ }
+ });
+
+ function parseClip(str, element) {
+ var outerWidth = element.outerWidth(),
+ outerHeight = element.outerHeight(),
+ clipRegex = /^rect\((-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto)\)$/,
+ values = clipRegex.exec(str) || ["", 0, outerWidth, outerHeight, 0];
+
+ return {
+ top: parseFloat(values[1]) || 0,
+ right: values[2] === "auto" ? outerWidth : parseFloat(values[2]),
+ bottom: values[3] === "auto" ? outerHeight : parseFloat(values[3]),
+ left: parseFloat(values[4]) || 0
+ };
+ }
+
+ $.fx.step.clip = function (fx) {
+ if (!fx.clipInit) {
+ fx.start = $(fx.elem).cssClip();
+ if (typeof fx.end === "string") {
+ fx.end = parseClip(fx.end, fx.elem);
+ }
+ fx.clipInit = true;
+ }
+
+ $(fx.elem).cssClip({
+ top: fx.pos * (fx.end.top - fx.start.top) + fx.start.top,
+ right: fx.pos * (fx.end.right - fx.start.right) + fx.start.right,
+ bottom: fx.pos * (fx.end.bottom - fx.start.bottom) + fx.start.bottom,
+ left: fx.pos * (fx.end.left - fx.start.left) + fx.start.left
+ });
+ };
+
+ })();
+
+ /******************************************************************************/
+ /*********************************** EASING ***********************************/
+ /******************************************************************************/
+
+ (function () {
+
+ // Based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
+
+ var baseEasings = {};
+
+ $.each(["Quad", "Cubic", "Quart", "Quint", "Expo"], function (i, name) {
+ baseEasings[name] = function (p) {
+ return Math.pow(p, i + 2);
+ };
+ });
+
+ $.extend(baseEasings, {
+ Sine: function (p) {
+ return 1 - Math.cos(p * Math.PI / 2);
+ },
+ Circ: function (p) {
+ return 1 - Math.sqrt(1 - p * p);
+ },
+ Elastic: function (p) {
+ return p === 0 || p === 1 ? p :
+ -Math.pow(2, 8 * (p - 1)) * Math.sin(((p - 1) * 80 - 7.5) * Math.PI / 15);
+ },
+ Back: function (p) {
+ return p * p * (3 * p - 2);
+ },
+ Bounce: function (p) {
+ var pow2,
+ bounce = 4;
+
+ while (p < ((pow2 = Math.pow(2, --bounce)) - 1) / 11) { }
+ return 1 / Math.pow(4, 3 - bounce) - 7.5625 * Math.pow((pow2 * 3 - 2) / 22 - p, 2);
+ }
+ });
+
+ $.each(baseEasings, function (name, easeIn) {
+ $.easing["easeIn" + name] = easeIn;
+ $.easing["easeOut" + name] = function (p) {
+ return 1 - easeIn(1 - p);
+ };
+ $.easing["easeInOut" + name] = function (p) {
+ return p < 0.5 ?
+ easeIn(p * 2) / 2 :
+ 1 - easeIn(p * -2 + 2) / 2;
+ };
+ });
+
+ })();
+
+ var effect = $.effects;
+
+
+ /*!
+ * jQuery UI Effects Blind 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Blind Effect
+ //>>group: Effects
+ //>>description: Blinds the element.
+ //>>docs: http://api.jqueryui.com/blind-effect/
+ //>>demos: http://jqueryui.com/effect/
+
+
+
+ var effectsEffectBlind = $.effects.define("blind", "hide", function (options, done) {
+ var map = {
+ up: ["bottom", "top"],
+ vertical: ["bottom", "top"],
+ down: ["top", "bottom"],
+ left: ["right", "left"],
+ horizontal: ["right", "left"],
+ right: ["left", "right"]
+ },
+ element = $(this),
+ direction = options.direction || "up",
+ start = element.cssClip(),
+ animate = { clip: $.extend({}, start) },
+ placeholder = $.effects.createPlaceholder(element);
+
+ animate.clip[map[direction][0]] = animate.clip[map[direction][1]];
+
+ if (options.mode === "show") {
+ element.cssClip(animate.clip);
+ if (placeholder) {
+ placeholder.css($.effects.clipToBox(animate));
+ }
+
+ animate.clip = start;
+ }
+
+ if (placeholder) {
+ placeholder.animate($.effects.clipToBox(animate), options.duration, options.easing);
+ }
+
+ element.animate(animate, {
+ queue: false,
+ duration: options.duration,
+ easing: options.easing,
+ complete: done
+ });
+ });
+
+
+ /*!
+ * jQuery UI Effects Bounce 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Bounce Effect
+ //>>group: Effects
+ //>>description: Bounces an element horizontally or vertically n times.
+ //>>docs: http://api.jqueryui.com/bounce-effect/
+ //>>demos: http://jqueryui.com/effect/
+
+
+
+ var effectsEffectBounce = $.effects.define("bounce", function (options, done) {
+ var upAnim, downAnim, refValue,
+ element = $(this),
+
+ // Defaults:
+ mode = options.mode,
+ hide = mode === "hide",
+ show = mode === "show",
+ direction = options.direction || "up",
+ distance = options.distance,
+ times = options.times || 5,
+
+ // Number of internal animations
+ anims = times * 2 + (show || hide ? 1 : 0),
+ speed = options.duration / anims,
+ easing = options.easing,
+
+ // Utility:
+ ref = (direction === "up" || direction === "down") ? "top" : "left",
+ motion = (direction === "up" || direction === "left"),
+ i = 0,
+
+ queuelen = element.queue().length;
+
+ $.effects.createPlaceholder(element);
+
+ refValue = element.css(ref);
+
+ // Default distance for the BIGGEST bounce is the outer Distance / 3
+ if (!distance) {
+ distance = element[ref === "top" ? "outerHeight" : "outerWidth"]() / 3;
+ }
+
+ if (show) {
+ downAnim = { opacity: 1 };
+ downAnim[ref] = refValue;
+
+ // If we are showing, force opacity 0 and set the initial position
+ // then do the "first" animation
+ element
+ .css("opacity", 0)
+ .css(ref, motion ? -distance * 2 : distance * 2)
+ .animate(downAnim, speed, easing);
+ }
+
+ // Start at the smallest distance if we are hiding
+ if (hide) {
+ distance = distance / Math.pow(2, times - 1);
+ }
+
+ downAnim = {};
+ downAnim[ref] = refValue;
+
+ // Bounces up/down/left/right then back to 0 -- times * 2 animations happen here
+ for (; i < times; i++) {
+ upAnim = {};
+ upAnim[ref] = (motion ? "-=" : "+=") + distance;
+
+ element
+ .animate(upAnim, speed, easing)
+ .animate(downAnim, speed, easing);
+
+ distance = hide ? distance * 2 : distance / 2;
+ }
+
+ // Last Bounce when Hiding
+ if (hide) {
+ upAnim = { opacity: 0 };
+ upAnim[ref] = (motion ? "-=" : "+=") + distance;
+
+ element.animate(upAnim, speed, easing);
+ }
+
+ element.queue(done);
+
+ $.effects.unshift(element, queuelen, anims + 1);
+ });
+
+
+ /*!
+ * jQuery UI Effects Clip 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Clip Effect
+ //>>group: Effects
+ //>>description: Clips the element on and off like an old TV.
+ //>>docs: http://api.jqueryui.com/clip-effect/
+ //>>demos: http://jqueryui.com/effect/
+
+
+
+ var effectsEffectClip = $.effects.define("clip", "hide", function (options, done) {
+ var start,
+ animate = {},
+ element = $(this),
+ direction = options.direction || "vertical",
+ both = direction === "both",
+ horizontal = both || direction === "horizontal",
+ vertical = both || direction === "vertical";
+
+ start = element.cssClip();
+ animate.clip = {
+ top: vertical ? (start.bottom - start.top) / 2 : start.top,
+ right: horizontal ? (start.right - start.left) / 2 : start.right,
+ bottom: vertical ? (start.bottom - start.top) / 2 : start.bottom,
+ left: horizontal ? (start.right - start.left) / 2 : start.left
+ };
+
+ $.effects.createPlaceholder(element);
+
+ if (options.mode === "show") {
+ element.cssClip(animate.clip);
+ animate.clip = start;
+ }
+
+ element.animate(animate, {
+ queue: false,
+ duration: options.duration,
+ easing: options.easing,
+ complete: done
+ });
+
+ });
+
+
+ /*!
+ * jQuery UI Effects Drop 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Drop Effect
+ //>>group: Effects
+ //>>description: Moves an element in one direction and hides it at the same time.
+ //>>docs: http://api.jqueryui.com/drop-effect/
+ //>>demos: http://jqueryui.com/effect/
+
+
+
+ var effectsEffectDrop = $.effects.define("drop", "hide", function (options, done) {
+
+ var distance,
+ element = $(this),
+ mode = options.mode,
+ show = mode === "show",
+ direction = options.direction || "left",
+ ref = (direction === "up" || direction === "down") ? "top" : "left",
+ motion = (direction === "up" || direction === "left") ? "-=" : "+=",
+ oppositeMotion = (motion === "+=") ? "-=" : "+=",
+ animation = {
+ opacity: 0
+ };
+
+ $.effects.createPlaceholder(element);
+
+ distance = options.distance ||
+ element[ref === "top" ? "outerHeight" : "outerWidth"](true) / 2;
+
+ animation[ref] = motion + distance;
+
+ if (show) {
+ element.css(animation);
+
+ animation[ref] = oppositeMotion + distance;
+ animation.opacity = 1;
+ }
+
+ // Animate
+ element.animate(animation, {
+ queue: false,
+ duration: options.duration,
+ easing: options.easing,
+ complete: done
+ });
+ });
+
+
+ /*!
+ * jQuery UI Effects Explode 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Explode Effect
+ //>>group: Effects
+ // jscs:disable maximumLineLength
+ //>>description: Explodes an element in all directions into n pieces. Implodes an element to its original wholeness.
+ // jscs:enable maximumLineLength
+ //>>docs: http://api.jqueryui.com/explode-effect/
+ //>>demos: http://jqueryui.com/effect/
+
+
+
+ var effectsEffectExplode = $.effects.define("explode", "hide", function (options, done) {
+
+ var i, j, left, top, mx, my,
+ rows = options.pieces ? Math.round(Math.sqrt(options.pieces)) : 3,
+ cells = rows,
+ element = $(this),
+ mode = options.mode,
+ show = mode === "show",
+
+ // Show and then visibility:hidden the element before calculating offset
+ offset = element.show().css("visibility", "hidden").offset(),
+
+ // Width and height of a piece
+ width = Math.ceil(element.outerWidth() / cells),
+ height = Math.ceil(element.outerHeight() / rows),
+ pieces = [];
+
+ // Children animate complete:
+ function childComplete() {
+ pieces.push(this);
+ if (pieces.length === rows * cells) {
+ animComplete();
+ }
+ }
+
+ // Clone the element for each row and cell.
+ for (i = 0; i < rows; i++) { // ===>
+ top = offset.top + i * height;
+ my = i - (rows - 1) / 2;
+
+ for (j = 0; j < cells; j++) { // |||
+ left = offset.left + j * width;
+ mx = j - (cells - 1) / 2;
+
+ // Create a clone of the now hidden main element that will be absolute positioned
+ // within a wrapper div off the -left and -top equal to size of our pieces
+ element
+ .clone()
+ .appendTo("body")
+ .wrap("<div></div>")
+ .css({
+ position: "absolute",
+ visibility: "visible",
+ left: -j * width,
+ top: -i * height
+ })
+
+ // Select the wrapper - make it overflow: hidden and absolute positioned based on
+ // where the original was located +left and +top equal to the size of pieces
+ .parent()
+ .addClass("ui-effects-explode")
+ .css({
+ position: "absolute",
+ overflow: "hidden",
+ width: width,
+ height: height,
+ left: left + (show ? mx * width : 0),
+ top: top + (show ? my * height : 0),
+ opacity: show ? 0 : 1
+ })
+ .animate({
+ left: left + (show ? 0 : mx * width),
+ top: top + (show ? 0 : my * height),
+ opacity: show ? 1 : 0
+ }, options.duration || 500, options.easing, childComplete);
+ }
+ }
+
+ function animComplete() {
+ element.css({
+ visibility: "visible"
+ });
+ $(pieces).remove();
+ done();
+ }
+ });
+
+
+ /*!
+ * jQuery UI Effects Fade 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Fade Effect
+ //>>group: Effects
+ //>>description: Fades the element.
+ //>>docs: http://api.jqueryui.com/fade-effect/
+ //>>demos: http://jqueryui.com/effect/
+
+
+
+ var effectsEffectFade = $.effects.define("fade", "toggle", function (options, done) {
+ var show = options.mode === "show";
+
+ $(this)
+ .css("opacity", show ? 0 : 1)
+ .animate({
+ opacity: show ? 1 : 0
+ }, {
+ queue: false,
+ duration: options.duration,
+ easing: options.easing,
+ complete: done
+ });
+ });
+
+
+ /*!
+ * jQuery UI Effects Fold 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Fold Effect
+ //>>group: Effects
+ //>>description: Folds an element first horizontally and then vertically.
+ //>>docs: http://api.jqueryui.com/fold-effect/
+ //>>demos: http://jqueryui.com/effect/
+
+
+
+ var effectsEffectFold = $.effects.define("fold", "hide", function (options, done) {
+
+ // Create element
+ var element = $(this),
+ mode = options.mode,
+ show = mode === "show",
+ hide = mode === "hide",
+ size = options.size || 15,
+ percent = /([0-9]+)%/.exec(size),
+ horizFirst = !!options.horizFirst,
+ ref = horizFirst ? ["right", "bottom"] : ["bottom", "right"],
+ duration = options.duration / 2,
+
+ placeholder = $.effects.createPlaceholder(element),
+
+ start = element.cssClip(),
+ animation1 = { clip: $.extend({}, start) },
+ animation2 = { clip: $.extend({}, start) },
+
+ distance = [start[ref[0]], start[ref[1]]],
+
+ queuelen = element.queue().length;
+
+ if (percent) {
+ size = parseInt(percent[1], 10) / 100 * distance[hide ? 0 : 1];
+ }
+ animation1.clip[ref[0]] = size;
+ animation2.clip[ref[0]] = size;
+ animation2.clip[ref[1]] = 0;
+
+ if (show) {
+ element.cssClip(animation2.clip);
+ if (placeholder) {
+ placeholder.css($.effects.clipToBox(animation2));
+ }
+
+ animation2.clip = start;
+ }
+
+ // Animate
+ element
+ .queue(function (next) {
+ if (placeholder) {
+ placeholder
+ .animate($.effects.clipToBox(animation1), duration, options.easing)
+ .animate($.effects.clipToBox(animation2), duration, options.easing);
+ }
+
+ next();
+ })
+ .animate(animation1, duration, options.easing)
+ .animate(animation2, duration, options.easing)
+ .queue(done);
+
+ $.effects.unshift(element, queuelen, 4);
+ });
+
+
+ /*!
+ * jQuery UI Effects Highlight 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Highlight Effect
+ //>>group: Effects
+ //>>description: Highlights the background of an element in a defined color for a custom duration.
+ //>>docs: http://api.jqueryui.com/highlight-effect/
+ //>>demos: http://jqueryui.com/effect/
+
+
+
+ var effectsEffectHighlight = $.effects.define("highlight", "show", function (options, done) {
+ var element = $(this),
+ animation = {
+ backgroundColor: element.css("backgroundColor")
+ };
+
+ if (options.mode === "hide") {
+ animation.opacity = 0;
+ }
+
+ $.effects.saveStyle(element);
+
+ element
+ .css({
+ backgroundImage: "none",
+ backgroundColor: options.color || "#ffff99"
+ })
+ .animate(animation, {
+ queue: false,
+ duration: options.duration,
+ easing: options.easing,
+ complete: done
+ });
+ });
+
+
+ /*!
+ * jQuery UI Effects Size 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Size Effect
+ //>>group: Effects
+ //>>description: Resize an element to a specified width and height.
+ //>>docs: http://api.jqueryui.com/size-effect/
+ //>>demos: http://jqueryui.com/effect/
+
+
+
+ var effectsEffectSize = $.effects.define("size", function (options, done) {
+
+ // Create element
+ var baseline, factor, temp,
+ element = $(this),
+
+ // Copy for children
+ cProps = ["fontSize"],
+ vProps = ["borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom"],
+ hProps = ["borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight"],
+
+ // Set options
+ mode = options.mode,
+ restore = mode !== "effect",
+ scale = options.scale || "both",
+ origin = options.origin || ["middle", "center"],
+ position = element.css("position"),
+ pos = element.position(),
+ original = $.effects.scaledDimensions(element),
+ from = options.from || original,
+ to = options.to || $.effects.scaledDimensions(element, 0);
+
+ $.effects.createPlaceholder(element);
+
+ if (mode === "show") {
+ temp = from;
+ from = to;
+ to = temp;
+ }
+
+ // Set scaling factor
+ factor = {
+ from: {
+ y: from.height / original.height,
+ x: from.width / original.width
+ },
+ to: {
+ y: to.height / original.height,
+ x: to.width / original.width
+ }
+ };
+
+ // Scale the css box
+ if (scale === "box" || scale === "both") {
+
+ // Vertical props scaling
+ if (factor.from.y !== factor.to.y) {
+ from = $.effects.setTransition(element, vProps, factor.from.y, from);
+ to = $.effects.setTransition(element, vProps, factor.to.y, to);
+ }
+
+ // Horizontal props scaling
+ if (factor.from.x !== factor.to.x) {
+ from = $.effects.setTransition(element, hProps, factor.from.x, from);
+ to = $.effects.setTransition(element, hProps, factor.to.x, to);
+ }
+ }
+
+ // Scale the content
+ if (scale === "content" || scale === "both") {
+
+ // Vertical props scaling
+ if (factor.from.y !== factor.to.y) {
+ from = $.effects.setTransition(element, cProps, factor.from.y, from);
+ to = $.effects.setTransition(element, cProps, factor.to.y, to);
+ }
+ }
+
+ // Adjust the position properties based on the provided origin points
+ if (origin) {
+ baseline = $.effects.getBaseline(origin, original);
+ from.top = (original.outerHeight - from.outerHeight) * baseline.y + pos.top;
+ from.left = (original.outerWidth - from.outerWidth) * baseline.x + pos.left;
+ to.top = (original.outerHeight - to.outerHeight) * baseline.y + pos.top;
+ to.left = (original.outerWidth - to.outerWidth) * baseline.x + pos.left;
+ }
+ element.css(from);
+
+ // Animate the children if desired
+ if (scale === "content" || scale === "both") {
+
+ vProps = vProps.concat(["marginTop", "marginBottom"]).concat(cProps);
+ hProps = hProps.concat(["marginLeft", "marginRight"]);
+
+ // Only animate children with width attributes specified
+ // TODO: is this right? should we include anything with css width specified as well
+ element.find("*[width]").each(function () {
+ var child = $(this),
+ childOriginal = $.effects.scaledDimensions(child),
+ childFrom = {
+ height: childOriginal.height * factor.from.y,
+ width: childOriginal.width * factor.from.x,
+ outerHeight: childOriginal.outerHeight * factor.from.y,
+ outerWidth: childOriginal.outerWidth * factor.from.x
+ },
+ childTo = {
+ height: childOriginal.height * factor.to.y,
+ width: childOriginal.width * factor.to.x,
+ outerHeight: childOriginal.height * factor.to.y,
+ outerWidth: childOriginal.width * factor.to.x
+ };
+
+ // Vertical props scaling
+ if (factor.from.y !== factor.to.y) {
+ childFrom = $.effects.setTransition(child, vProps, factor.from.y, childFrom);
+ childTo = $.effects.setTransition(child, vProps, factor.to.y, childTo);
+ }
+
+ // Horizontal props scaling
+ if (factor.from.x !== factor.to.x) {
+ childFrom = $.effects.setTransition(child, hProps, factor.from.x, childFrom);
+ childTo = $.effects.setTransition(child, hProps, factor.to.x, childTo);
+ }
+
+ if (restore) {
+ $.effects.saveStyle(child);
+ }
+
+ // Animate children
+ child.css(childFrom);
+ child.animate(childTo, options.duration, options.easing, function () {
+
+ // Restore children
+ if (restore) {
+ $.effects.restoreStyle(child);
+ }
+ });
+ });
+ }
+
+ // Animate
+ element.animate(to, {
+ queue: false,
+ duration: options.duration,
+ easing: options.easing,
+ complete: function () {
+
+ var offset = element.offset();
+
+ if (to.opacity === 0) {
+ element.css("opacity", from.opacity);
+ }
+
+ if (!restore) {
+ element
+ .css("position", position === "static" ? "relative" : position)
+ .offset(offset);
+
+ // Need to save style here so that automatic style restoration
+ // doesn't restore to the original styles from before the animation.
+ $.effects.saveStyle(element);
+ }
+
+ done();
+ }
+ });
+
+ });
+
+
+ /*!
+ * jQuery UI Effects Scale 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Scale Effect
+ //>>group: Effects
+ //>>description: Grows or shrinks an element and its content.
+ //>>docs: http://api.jqueryui.com/scale-effect/
+ //>>demos: http://jqueryui.com/effect/
+
+
+
+ var effectsEffectScale = $.effects.define("scale", function (options, done) {
+
+ // Create element
+ var el = $(this),
+ mode = options.mode,
+ percent = parseInt(options.percent, 10) ||
+ (parseInt(options.percent, 10) === 0 ? 0 : (mode !== "effect" ? 0 : 100)),
+
+ newOptions = $.extend(true, {
+ from: $.effects.scaledDimensions(el),
+ to: $.effects.scaledDimensions(el, percent, options.direction || "both"),
+ origin: options.origin || ["middle", "center"]
+ }, options);
+
+ // Fade option to support puff
+ if (options.fade) {
+ newOptions.from.opacity = 1;
+ newOptions.to.opacity = 0;
+ }
+
+ $.effects.effect.size.call(this, newOptions, done);
+ });
+
+
+ /*!
+ * jQuery UI Effects Puff 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Puff Effect
+ //>>group: Effects
+ //>>description: Creates a puff effect by scaling the element up and hiding it at the same time.
+ //>>docs: http://api.jqueryui.com/puff-effect/
+ //>>demos: http://jqueryui.com/effect/
+
+
+
+ var effectsEffectPuff = $.effects.define("puff", "hide", function (options, done) {
+ var newOptions = $.extend(true, {}, options, {
+ fade: true,
+ percent: parseInt(options.percent, 10) || 150
+ });
+
+ $.effects.effect.scale.call(this, newOptions, done);
+ });
+
+
+ /*!
+ * jQuery UI Effects Pulsate 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Pulsate Effect
+ //>>group: Effects
+ //>>description: Pulsates an element n times by changing the opacity to zero and back.
+ //>>docs: http://api.jqueryui.com/pulsate-effect/
+ //>>demos: http://jqueryui.com/effect/
+
+
+
+ var effectsEffectPulsate = $.effects.define("pulsate", "show", function (options, done) {
+ var element = $(this),
+ mode = options.mode,
+ show = mode === "show",
+ hide = mode === "hide",
+ showhide = show || hide,
+
+ // Showing or hiding leaves off the "last" animation
+ anims = ((options.times || 5) * 2) + (showhide ? 1 : 0),
+ duration = options.duration / anims,
+ animateTo = 0,
+ i = 1,
+ queuelen = element.queue().length;
+
+ if (show || !element.is(":visible")) {
+ element.css("opacity", 0).show();
+ animateTo = 1;
+ }
+
+ // Anims - 1 opacity "toggles"
+ for (; i < anims; i++) {
+ element.animate({ opacity: animateTo }, duration, options.easing);
+ animateTo = 1 - animateTo;
+ }
+
+ element.animate({ opacity: animateTo }, duration, options.easing);
+
+ element.queue(done);
+
+ $.effects.unshift(element, queuelen, anims + 1);
+ });
+
+
+ /*!
+ * jQuery UI Effects Shake 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Shake Effect
+ //>>group: Effects
+ //>>description: Shakes an element horizontally or vertically n times.
+ //>>docs: http://api.jqueryui.com/shake-effect/
+ //>>demos: http://jqueryui.com/effect/
+
+
+
+ var effectsEffectShake = $.effects.define("shake", function (options, done) {
+
+ var i = 1,
+ element = $(this),
+ direction = options.direction || "left",
+ distance = options.distance || 20,
+ times = options.times || 3,
+ anims = times * 2 + 1,
+ speed = Math.round(options.duration / anims),
+ ref = (direction === "up" || direction === "down") ? "top" : "left",
+ positiveMotion = (direction === "up" || direction === "left"),
+ animation = {},
+ animation1 = {},
+ animation2 = {},
+
+ queuelen = element.queue().length;
+
+ $.effects.createPlaceholder(element);
+
+ // Animation
+ animation[ref] = (positiveMotion ? "-=" : "+=") + distance;
+ animation1[ref] = (positiveMotion ? "+=" : "-=") + distance * 2;
+ animation2[ref] = (positiveMotion ? "-=" : "+=") + distance * 2;
+
+ // Animate
+ element.animate(animation, speed, options.easing);
+
+ // Shakes
+ for (; i < times; i++) {
+ element
+ .animate(animation1, speed, options.easing)
+ .animate(animation2, speed, options.easing);
+ }
+
+ element
+ .animate(animation1, speed, options.easing)
+ .animate(animation, speed / 2, options.easing)
+ .queue(done);
+
+ $.effects.unshift(element, queuelen, anims + 1);
+ });
+
+
+ /*!
+ * jQuery UI Effects Slide 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Slide Effect
+ //>>group: Effects
+ //>>description: Slides an element in and out of the viewport.
+ //>>docs: http://api.jqueryui.com/slide-effect/
+ //>>demos: http://jqueryui.com/effect/
+
+
+
+ var effectsEffectSlide = $.effects.define("slide", "show", function (options, done) {
+ var startClip, startRef,
+ element = $(this),
+ map = {
+ up: ["bottom", "top"],
+ down: ["top", "bottom"],
+ left: ["right", "left"],
+ right: ["left", "right"]
+ },
+ mode = options.mode,
+ direction = options.direction || "left",
+ ref = (direction === "up" || direction === "down") ? "top" : "left",
+ positiveMotion = (direction === "up" || direction === "left"),
+ distance = options.distance ||
+ element[ref === "top" ? "outerHeight" : "outerWidth"](true),
+ animation = {};
+
+ $.effects.createPlaceholder(element);
+
+ startClip = element.cssClip();
+ startRef = element.position()[ref];
+
+ // Define hide animation
+ animation[ref] = (positiveMotion ? -1 : 1) * distance + startRef;
+ animation.clip = element.cssClip();
+ animation.clip[map[direction][1]] = animation.clip[map[direction][0]];
+
+ // Reverse the animation if we're showing
+ if (mode === "show") {
+ element.cssClip(animation.clip);
+ element.css(ref, animation[ref]);
+ animation.clip = startClip;
+ animation[ref] = startRef;
+ }
+
+ // Actually animate
+ element.animate(animation, {
+ queue: false,
+ duration: options.duration,
+ easing: options.easing,
+ complete: done
+ });
+ });
+
+
+ /*!
+ * jQuery UI Effects Transfer 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Transfer Effect
+ //>>group: Effects
+ //>>description: Displays a transfer effect from one element to another.
+ //>>docs: http://api.jqueryui.com/transfer-effect/
+ //>>demos: http://jqueryui.com/effect/
+
+
+
+ var effect;
+ if ($.uiBackCompat !== false) {
+ effect = $.effects.define("transfer", function (options, done) {
+ $(this).transfer(options, done);
+ });
+ }
+ var effectsEffectTransfer = effect;
+
+
+ /*!
+ * jQuery UI Focusable 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: :focusable Selector
+ //>>group: Core
+ //>>description: Selects elements which can be focused.
+ //>>docs: http://api.jqueryui.com/focusable-selector/
+
+
+
+ // Selectors
+ $.ui.focusable = function (element, hasTabindex) {
+ var map, mapName, img, focusableIfVisible, fieldset,
+ nodeName = element.nodeName.toLowerCase();
+
+ if ("area" === nodeName) {
+ map = element.parentNode;
+ mapName = map.name;
+ if (!element.href || !mapName || map.nodeName.toLowerCase() !== "map") {
+ return false;
+ }
+ img = $("img[usemap='#" + mapName + "']");
+ return img.length > 0 && img.is(":visible");
+ }
+
+ if (/^(input|select|textarea|button|object)$/.test(nodeName)) {
+ focusableIfVisible = !element.disabled;
+
+ if (focusableIfVisible) {
+
+ // Form controls within a disabled fieldset are disabled.
+ // However, controls within the fieldset's legend do not get disabled.
+ // Since controls generally aren't placed inside legends, we skip
+ // this portion of the check.
+ fieldset = $(element).closest("fieldset")[0];
+ if (fieldset) {
+ focusableIfVisible = !fieldset.disabled;
+ }
+ }
+ } else if ("a" === nodeName) {
+ focusableIfVisible = element.href || hasTabindex;
+ } else {
+ focusableIfVisible = hasTabindex;
+ }
+
+ return focusableIfVisible && $(element).is(":visible") && visible($(element));
+ };
+
+ // Support: IE 8 only
+ // IE 8 doesn't resolve inherit to visible/hidden for computed values
+ function visible(element) {
+ var visibility = element.css("visibility");
+ while (visibility === "inherit") {
+ element = element.parent();
+ visibility = element.css("visibility");
+ }
+ return visibility !== "hidden";
+ }
+
+ $.extend($.expr[":"], {
+ focusable: function (element) {
+ return $.ui.focusable(element, $.attr(element, "tabindex") != null);
+ }
+ });
+
+ var focusable = $.ui.focusable;
+
+
+
+
+ // Support: IE8 Only
+ // IE8 does not support the form attribute and when it is supplied. It overwrites the form prop
+ // with a string, so we need to find the proper form.
+ var form = $.fn.form = function () {
+ return typeof this[0].form === "string" ? this.closest("form") : $(this[0].form);
+ };
+
+
+ /*!
+ * jQuery UI Form Reset Mixin 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Form Reset Mixin
+ //>>group: Core
+ //>>description: Refresh input widgets when their form is reset
+ //>>docs: http://api.jqueryui.com/form-reset-mixin/
+
+
+
+ var formResetMixin = $.ui.formResetMixin = {
+ _formResetHandler: function () {
+ var form = $(this);
+
+ // Wait for the form reset to actually happen before refreshing
+ setTimeout(function () {
+ var instances = form.data("ui-form-reset-instances");
+ $.each(instances, function () {
+ this.refresh();
+ });
+ });
+ },
+
+ _bindFormResetHandler: function () {
+ this.form = this.element.form();
+ if (!this.form.length) {
+ return;
+ }
+
+ var instances = this.form.data("ui-form-reset-instances") || [];
+ if (!instances.length) {
+
+ // We don't use _on() here because we use a single event handler per form
+ this.form.on("reset.ui-form-reset", this._formResetHandler);
+ }
+ instances.push(this);
+ this.form.data("ui-form-reset-instances", instances);
+ },
+
+ _unbindFormResetHandler: function () {
+ if (!this.form.length) {
+ return;
+ }
+
+ var instances = this.form.data("ui-form-reset-instances");
+ instances.splice($.inArray(this, instances), 1);
+ if (instances.length) {
+ this.form.data("ui-form-reset-instances", instances);
+ } else {
+ this.form
+ .removeData("ui-form-reset-instances")
+ .off("reset.ui-form-reset");
+ }
+ }
+ };
+
+
+ /*!
+ * jQuery UI Support for jQuery core 1.7.x 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ */
+
+ //>>label: jQuery 1.7 Support
+ //>>group: Core
+ //>>description: Support version 1.7.x of jQuery core
+
+
+
+ // Support: jQuery 1.7 only
+ // Not a great way to check versions, but since we only support 1.7+ and only
+ // need to detect <1.8, this is a simple check that should suffice. Checking
+ // for "1.7." would be a bit safer, but the version string is 1.7, not 1.7.0
+ // and we'll never reach 1.70.0 (if we do, we certainly won't be supporting
+ // 1.7 anymore). See #11197 for why we're not using feature detection.
+ if ($.fn.jquery.substring(0, 3) === "1.7") {
+
+ // Setters for .innerWidth(), .innerHeight(), .outerWidth(), .outerHeight()
+ // Unlike jQuery Core 1.8+, these only support numeric values to set the
+ // dimensions in pixels
+ $.each(["Width", "Height"], function (i, name) {
+ var side = name === "Width" ? ["Left", "Right"] : ["Top", "Bottom"],
+ type = name.toLowerCase(),
+ orig = {
+ innerWidth: $.fn.innerWidth,
+ innerHeight: $.fn.innerHeight,
+ outerWidth: $.fn.outerWidth,
+ outerHeight: $.fn.outerHeight
+ };
+
+ function reduce(elem, size, border, margin) {
+ $.each(side, function () {
+ size -= parseFloat($.css(elem, "padding" + this)) || 0;
+ if (border) {
+ size -= parseFloat($.css(elem, "border" + this + "Width")) || 0;
+ }
+ if (margin) {
+ size -= parseFloat($.css(elem, "margin" + this)) || 0;
+ }
+ });
+ return size;
+ }
+
+ $.fn["inner" + name] = function (size) {
+ if (size === undefined) {
+ return orig["inner" + name].call(this);
+ }
+
+ return this.each(function () {
+ $(this).css(type, reduce(this, size) + "px");
+ });
+ };
+
+ $.fn["outer" + name] = function (size, margin) {
+ if (typeof size !== "number") {
+ return orig["outer" + name].call(this, size);
+ }
+
+ return this.each(function () {
+ $(this).css(type, reduce(this, size, true, margin) + "px");
+ });
+ };
+ });
+
+ $.fn.addBack = function (selector) {
+ return this.add(selector == null ?
+ this.prevObject : this.prevObject.filter(selector)
+ );
+ };
+ }
+
+ ;
+ /*!
+ * jQuery UI Keycode 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Keycode
+ //>>group: Core
+ //>>description: Provide keycodes as keynames
+ //>>docs: http://api.jqueryui.com/jQuery.ui.keyCode/
+
+
+ var keycode = $.ui.keyCode = {
+ BACKSPACE: 8,
+ COMMA: 188,
+ DELETE: 46,
+ DOWN: 40,
+ END: 35,
+ ENTER: 13,
+ ESCAPE: 27,
+ HOME: 36,
+ LEFT: 37,
+ PAGE_DOWN: 34,
+ PAGE_UP: 33,
+ PERIOD: 190,
+ RIGHT: 39,
+ SPACE: 32,
+ TAB: 9,
+ UP: 38
+ };
+
+
+
+
+ // Internal use only
+ var escapeSelector = $.ui.escapeSelector = (function () {
+ var selectorEscape = /([!"#$%&'()*+,./:;<=>?@[\]^`{|}~])/g;
+ return function (selector) {
+ return selector.replace(selectorEscape, "\\$1");
+ };
+ })();
+
+
+ /*!
+ * jQuery UI Labels 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: labels
+ //>>group: Core
+ //>>description: Find all the labels associated with a given input
+ //>>docs: http://api.jqueryui.com/labels/
+
+
+
+ var labels = $.fn.labels = function () {
+ var ancestor, selector, id, labels, ancestors;
+
+ // Check control.labels first
+ if (this[0].labels && this[0].labels.length) {
+ return this.pushStack(this[0].labels);
+ }
+
+ // Support: IE <= 11, FF <= 37, Android <= 2.3 only
+ // Above browsers do not support control.labels. Everything below is to support them
+ // as well as document fragments. control.labels does not work on document fragments
+ labels = this.eq(0).parents("label");
+
+ // Look for the label based on the id
+ id = this.attr("id");
+ if (id) {
+
+ // We don't search against the document in case the element
+ // is disconnected from the DOM
+ ancestor = this.eq(0).parents().last();
+
+ // Get a full set of top level ancestors
+ ancestors = ancestor.add(ancestor.length ? ancestor.siblings() : this.siblings());
+
+ // Create a selector for the label based on the id
+ selector = "label[for='" + $.ui.escapeSelector(id) + "']";
+
+ labels = labels.add(ancestors.find(selector).addBack(selector));
+
+ }
+
+ // Return whatever we have found for labels
+ return this.pushStack(labels);
+ };
+
+
+ /*!
+ * jQuery UI Scroll Parent 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: scrollParent
+ //>>group: Core
+ //>>description: Get the closest ancestor element that is scrollable.
+ //>>docs: http://api.jqueryui.com/scrollParent/
+
+
+
+ var scrollParent = $.fn.scrollParent = function (includeHidden) {
+ var position = this.css("position"),
+ excludeStaticParent = position === "absolute",
+ overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/,
+ scrollParent = this.parents().filter(function () {
+ var parent = $(this);
+ if (excludeStaticParent && parent.css("position") === "static") {
+ return false;
+ }
+ return overflowRegex.test(parent.css("overflow") + parent.css("overflow-y") +
+ parent.css("overflow-x"));
+ }).eq(0);
+
+ return position === "fixed" || !scrollParent.length ?
+ $(this[0].ownerDocument || document) :
+ scrollParent;
+ };
+
+
+ /*!
+ * jQuery UI Tabbable 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: :tabbable Selector
+ //>>group: Core
+ //>>description: Selects elements which can be tabbed to.
+ //>>docs: http://api.jqueryui.com/tabbable-selector/
+
+
+
+ var tabbable = $.extend($.expr[":"], {
+ tabbable: function (element) {
+ var tabIndex = $.attr(element, "tabindex"),
+ hasTabindex = tabIndex != null;
+ return (!hasTabindex || tabIndex >= 0) && $.ui.focusable(element, hasTabindex);
+ }
+ });
+
+
+ /*!
+ * jQuery UI Unique ID 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: uniqueId
+ //>>group: Core
+ //>>description: Functions to generate and remove uniqueId's
+ //>>docs: http://api.jqueryui.com/uniqueId/
+
+
+
+ var uniqueId = $.fn.extend({
+ uniqueId: (function () {
+ var uuid = 0;
+
+ return function () {
+ return this.each(function () {
+ if (!this.id) {
+ this.id = "ui-id-" + (++uuid);
+ }
+ });
+ };
+ })(),
+
+ removeUniqueId: function () {
+ return this.each(function () {
+ if (/^ui-id-\d+$/.test(this.id)) {
+ $(this).removeAttr("id");
+ }
+ });
+ }
+ });
+
+
+ /*!
+ * jQuery UI Accordion 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Accordion
+ //>>group: Widgets
+ // jscs:disable maximumLineLength
+ //>>description: Displays collapsible content panels for presenting information in a limited amount of space.
+ // jscs:enable maximumLineLength
+ //>>docs: http://api.jqueryui.com/accordion/
+ //>>demos: http://jqueryui.com/accordion/
+ //>>css.structure: ../../themes/base/core.css
+ //>>css.structure: ../../themes/base/accordion.css
+ //>>css.theme: ../../themes/base/theme.css
+
+
+
+ var widgetsAccordion = $.widget("ui.accordion", {
+ version: "1.12.1",
+ options: {
+ active: 0,
+ animate: {},
+ classes: {
+ "ui-accordion-header": "ui-corner-top",
+ "ui-accordion-header-collapsed": "ui-corner-all",
+ "ui-accordion-content": "ui-corner-bottom"
+ },
+ collapsible: false,
+ event: "click",
+ header: "> li > :first-child, > :not(li):even",
+ heightStyle: "auto",
+ icons: {
+ activeHeader: "ui-icon-triangle-1-s",
+ header: "ui-icon-triangle-1-e"
+ },
+
+ // Callbacks
+ activate: null,
+ beforeActivate: null
+ },
+
+ hideProps: {
+ borderTopWidth: "hide",
+ borderBottomWidth: "hide",
+ paddingTop: "hide",
+ paddingBottom: "hide",
+ height: "hide"
+ },
+
+ showProps: {
+ borderTopWidth: "show",
+ borderBottomWidth: "show",
+ paddingTop: "show",
+ paddingBottom: "show",
+ height: "show"
+ },
+
+ _create: function () {
+ var options = this.options;
+
+ this.prevShow = this.prevHide = $();
+ this._addClass("ui-accordion", "ui-widget ui-helper-reset");
+ this.element.attr("role", "tablist");
+
+ // Don't allow collapsible: false and active: false / null
+ if (!options.collapsible && (options.active === false || options.active == null)) {
+ options.active = 0;
+ }
+
+ this._processPanels();
+
+ // handle negative values
+ if (options.active < 0) {
+ options.active += this.headers.length;
+ }
+ this._refresh();
+ },
+
+ _getCreateEventData: function () {
+ return {
+ header: this.active,
+ panel: !this.active.length ? $() : this.active.next()
+ };
+ },
+
+ _createIcons: function () {
+ var icon, children,
+ icons = this.options.icons;
+
+ if (icons) {
+ icon = $("<span>");
+ this._addClass(icon, "ui-accordion-header-icon", "ui-icon " + icons.header);
+ icon.prependTo(this.headers);
+ children = this.active.children(".ui-accordion-header-icon");
+ this._removeClass(children, icons.header)
+ ._addClass(children, null, icons.activeHeader)
+ ._addClass(this.headers, "ui-accordion-icons");
+ }
+ },
+
+ _destroyIcons: function () {
+ this._removeClass(this.headers, "ui-accordion-icons");
+ this.headers.children(".ui-accordion-header-icon").remove();
+ },
+
+ _destroy: function () {
+ var contents;
+
+ // Clean up main element
+ this.element.removeAttr("role");
+
+ // Clean up headers
+ this.headers
+ .removeAttr("role aria-expanded aria-selected aria-controls tabIndex")
+ .removeUniqueId();
+
+ this._destroyIcons();
+
+ // Clean up content panels
+ contents = this.headers.next()
+ .css("display", "")
+ .removeAttr("role aria-hidden aria-labelledby")
+ .removeUniqueId();
+
+ if (this.options.heightStyle !== "content") {
+ contents.css("height", "");
+ }
+ },
+
+ _setOption: function (key, value) {
+ if (key === "active") {
+
+ // _activate() will handle invalid values and update this.options
+ this._activate(value);
+ return;
+ }
+
+ if (key === "event") {
+ if (this.options.event) {
+ this._off(this.headers, this.options.event);
+ }
+ this._setupEvents(value);
+ }
+
+ this._super(key, value);
+
+ // Setting collapsible: false while collapsed; open first panel
+ if (key === "collapsible" && !value && this.options.active === false) {
+ this._activate(0);
+ }
+
+ if (key === "icons") {
+ this._destroyIcons();
+ if (value) {
+ this._createIcons();
+ }
+ }
+ },
+
+ _setOptionDisabled: function (value) {
+ this._super(value);
+
+ this.element.attr("aria-disabled", value);
+
+ // Support: IE8 Only
+ // #5332 / #6059 - opacity doesn't cascade to positioned elements in IE
+ // so we need to add the disabled class to the headers and panels
+ this._toggleClass(null, "ui-state-disabled", !!value);
+ this._toggleClass(this.headers.add(this.headers.next()), null, "ui-state-disabled",
+ !!value);
+ },
+
+ _keydown: function (event) {
+ if (event.altKey || event.ctrlKey) {
+ return;
+ }
+
+ var keyCode = $.ui.keyCode,
+ length = this.headers.length,
+ currentIndex = this.headers.index(event.target),
+ toFocus = false;
+
+ switch (event.keyCode) {
+ case keyCode.RIGHT:
+ case keyCode.DOWN:
+ toFocus = this.headers[(currentIndex + 1) % length];
+ break;
+ case keyCode.LEFT:
+ case keyCode.UP:
+ toFocus = this.headers[(currentIndex - 1 + length) % length];
+ break;
+ case keyCode.SPACE:
+ case keyCode.ENTER:
+ this._eventHandler(event);
+ break;
+ case keyCode.HOME:
+ toFocus = this.headers[0];
+ break;
+ case keyCode.END:
+ toFocus = this.headers[length - 1];
+ break;
+ }
+
+ if (toFocus) {
+ $(event.target).attr("tabIndex", -1);
+ $(toFocus).attr("tabIndex", 0);
+ $(toFocus).trigger("focus");
+ event.preventDefault();
+ }
+ },
+
+ _panelKeyDown: function (event) {
+ if (event.keyCode === $.ui.keyCode.UP && event.ctrlKey) {
+ $(event.currentTarget).prev().trigger("focus");
+ }
+ },
+
+ refresh: function () {
+ var options = this.options;
+ this._processPanels();
+
+ // Was collapsed or no panel
+ if ((options.active === false && options.collapsible === true) ||
+ !this.headers.length) {
+ options.active = false;
+ this.active = $();
+
+ // active false only when collapsible is true
+ } else if (options.active === false) {
+ this._activate(0);
+
+ // was active, but active panel is gone
+ } else if (this.active.length && !$.contains(this.element[0], this.active[0])) {
+
+ // all remaining panel are disabled
+ if (this.headers.length === this.headers.find(".ui-state-disabled").length) {
+ options.active = false;
+ this.active = $();
+
+ // activate previous panel
+ } else {
+ this._activate(Math.max(0, options.active - 1));
+ }
+
+ // was active, active panel still exists
+ } else {
+
+ // make sure active index is correct
+ options.active = this.headers.index(this.active);
+ }
+
+ this._destroyIcons();
+
+ this._refresh();
+ },
+
+ _processPanels: function () {
+ var prevHeaders = this.headers,
+ prevPanels = this.panels;
+
+ this.headers = this.element.find(this.options.header);
+ this._addClass(this.headers, "ui-accordion-header ui-accordion-header-collapsed",
+ "ui-state-default");
+
+ this.panels = this.headers.next().filter(":not(.ui-accordion-content-active)").hide();
+ this._addClass(this.panels, "ui-accordion-content", "ui-helper-reset ui-widget-content");
+
+ // Avoid memory leaks (#10056)
+ if (prevPanels) {
+ this._off(prevHeaders.not(this.headers));
+ this._off(prevPanels.not(this.panels));
+ }
+ },
+
+ _refresh: function () {
+ var maxHeight,
+ options = this.options,
+ heightStyle = options.heightStyle,
+ parent = this.element.parent();
+
+ this.active = this._findActive(options.active);
+ this._addClass(this.active, "ui-accordion-header-active", "ui-state-active")
+ ._removeClass(this.active, "ui-accordion-header-collapsed");
+ this._addClass(this.active.next(), "ui-accordion-content-active");
+ this.active.next().show();
+
+ this.headers
+ .attr("role", "tab")
+ .each(function () {
+ var header = $(this),
+ headerId = header.uniqueId().attr("id"),
+ panel = header.next(),
+ panelId = panel.uniqueId().attr("id");
+ header.attr("aria-controls", panelId);
+ panel.attr("aria-labelledby", headerId);
+ })
+ .next()
+ .attr("role", "tabpanel");
+
+ this.headers
+ .not(this.active)
+ .attr({
+ "aria-selected": "false",
+ "aria-expanded": "false",
+ tabIndex: -1
+ })
+ .next()
+ .attr({
+ "aria-hidden": "true"
+ })
+ .hide();
+
+ // Make sure at least one header is in the tab order
+ if (!this.active.length) {
+ this.headers.eq(0).attr("tabIndex", 0);
+ } else {
+ this.active.attr({
+ "aria-selected": "true",
+ "aria-expanded": "true",
+ tabIndex: 0
+ })
+ .next()
+ .attr({
+ "aria-hidden": "false"
+ });
+ }
+
+ this._createIcons();
+
+ this._setupEvents(options.event);
+
+ if (heightStyle === "fill") {
+ maxHeight = parent.height();
+ this.element.siblings(":visible").each(function () {
+ var elem = $(this),
+ position = elem.css("position");
+
+ if (position === "absolute" || position === "fixed") {
+ return;
+ }
+ maxHeight -= elem.outerHeight(true);
+ });
+
+ this.headers.each(function () {
+ maxHeight -= $(this).outerHeight(true);
+ });
+
+ this.headers.next()
+ .each(function () {
+ $(this).height(Math.max(0, maxHeight -
+ $(this).innerHeight() + $(this).height()));
+ })
+ .css("overflow", "auto");
+ } else if (heightStyle === "auto") {
+ maxHeight = 0;
+ this.headers.next()
+ .each(function () {
+ var isVisible = $(this).is(":visible");
+ if (!isVisible) {
+ $(this).show();
+ }
+ maxHeight = Math.max(maxHeight, $(this).css("height", "").height());
+ if (!isVisible) {
+ $(this).hide();
+ }
+ })
+ .height(maxHeight);
+ }
+ },
+
+ _activate: function (index) {
+ var active = this._findActive(index)[0];
+
+ // Trying to activate the already active panel
+ if (active === this.active[0]) {
+ return;
+ }
+
+ // Trying to collapse, simulate a click on the currently active header
+ active = active || this.active[0];
+
+ this._eventHandler({
+ target: active,
+ currentTarget: active,
+ preventDefault: $.noop
+ });
+ },
+
+ _findActive: function (selector) {
+ return typeof selector === "number" ? this.headers.eq(selector) : $();
+ },
+
+ _setupEvents: function (event) {
+ var events = {
+ keydown: "_keydown"
+ };
+ if (event) {
+ $.each(event.split(" "), function (index, eventName) {
+ events[eventName] = "_eventHandler";
+ });
+ }
+
+ this._off(this.headers.add(this.headers.next()));
+ this._on(this.headers, events);
+ this._on(this.headers.next(), { keydown: "_panelKeyDown" });
+ this._hoverable(this.headers);
+ this._focusable(this.headers);
+ },
+
+ _eventHandler: function (event) {
+ var activeChildren, clickedChildren,
+ options = this.options,
+ active = this.active,
+ clicked = $(event.currentTarget),
+ clickedIsActive = clicked[0] === active[0],
+ collapsing = clickedIsActive && options.collapsible,
+ toShow = collapsing ? $() : clicked.next(),
+ toHide = active.next(),
+ eventData = {
+ oldHeader: active,
+ oldPanel: toHide,
+ newHeader: collapsing ? $() : clicked,
+ newPanel: toShow
+ };
+
+ event.preventDefault();
+
+ if (
+
+ // click on active header, but not collapsible
+ (clickedIsActive && !options.collapsible) ||
+
+ // allow canceling activation
+ (this._trigger("beforeActivate", event, eventData) === false)) {
+ return;
+ }
+
+ options.active = collapsing ? false : this.headers.index(clicked);
+
+ // When the call to ._toggle() comes after the class changes
+ // it causes a very odd bug in IE 8 (see #6720)
+ this.active = clickedIsActive ? $() : clicked;
+ this._toggle(eventData);
+
+ // Switch classes
+ // corner classes on the previously active header stay after the animation
+ this._removeClass(active, "ui-accordion-header-active", "ui-state-active");
+ if (options.icons) {
+ activeChildren = active.children(".ui-accordion-header-icon");
+ this._removeClass(activeChildren, null, options.icons.activeHeader)
+ ._addClass(activeChildren, null, options.icons.header);
+ }
+
+ if (!clickedIsActive) {
+ this._removeClass(clicked, "ui-accordion-header-collapsed")
+ ._addClass(clicked, "ui-accordion-header-active", "ui-state-active");
+ if (options.icons) {
+ clickedChildren = clicked.children(".ui-accordion-header-icon");
+ this._removeClass(clickedChildren, null, options.icons.header)
+ ._addClass(clickedChildren, null, options.icons.activeHeader);
+ }
+
+ this._addClass(clicked.next(), "ui-accordion-content-active");
+ }
+ },
+
+ _toggle: function (data) {
+ var toShow = data.newPanel,
+ toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
+
+ // Handle activating a panel during the animation for another activation
+ this.prevShow.add(this.prevHide).stop(true, true);
+ this.prevShow = toShow;
+ this.prevHide = toHide;
+
+ if (this.options.animate) {
+ this._animate(toShow, toHide, data);
+ } else {
+ toHide.hide();
+ toShow.show();
+ this._toggleComplete(data);
+ }
+
+ toHide.attr({
+ "aria-hidden": "true"
+ });
+ toHide.prev().attr({
+ "aria-selected": "false",
+ "aria-expanded": "false"
+ });
+
+ // if we're switching panels, remove the old header from the tab order
+ // if we're opening from collapsed state, remove the previous header from the tab order
+ // if we're collapsing, then keep the collapsing header in the tab order
+ if (toShow.length && toHide.length) {
+ toHide.prev().attr({
+ "tabIndex": -1,
+ "aria-expanded": "false"
+ });
+ } else if (toShow.length) {
+ this.headers.filter(function () {
+ return parseInt($(this).attr("tabIndex"), 10) === 0;
+ })
+ .attr("tabIndex", -1);
+ }
+
+ toShow
+ .attr("aria-hidden", "false")
+ .prev()
+ .attr({
+ "aria-selected": "true",
+ "aria-expanded": "true",
+ tabIndex: 0
+ });
+ },
+
+ _animate: function (toShow, toHide, data) {
+ var total, easing, duration,
+ that = this,
+ adjust = 0,
+ boxSizing = toShow.css("box-sizing"),
+ down = toShow.length &&
+ (!toHide.length || (toShow.index() < toHide.index())),
+ animate = this.options.animate || {},
+ options = down && animate.down || animate,
+ complete = function () {
+ that._toggleComplete(data);
+ };
+
+ if (typeof options === "number") {
+ duration = options;
+ }
+ if (typeof options === "string") {
+ easing = options;
+ }
+
+ // fall back from options to animation in case of partial down settings
+ easing = easing || options.easing || animate.easing;
+ duration = duration || options.duration || animate.duration;
+
+ if (!toHide.length) {
+ return toShow.animate(this.showProps, duration, easing, complete);
+ }
+ if (!toShow.length) {
+ return toHide.animate(this.hideProps, duration, easing, complete);
+ }
+
+ total = toShow.show().outerHeight();
+ toHide.animate(this.hideProps, {
+ duration: duration,
+ easing: easing,
+ step: function (now, fx) {
+ fx.now = Math.round(now);
+ }
+ });
+ toShow
+ .hide()
+ .animate(this.showProps, {
+ duration: duration,
+ easing: easing,
+ complete: complete,
+ step: function (now, fx) {
+ fx.now = Math.round(now);
+ if (fx.prop !== "height") {
+ if (boxSizing === "content-box") {
+ adjust += fx.now;
+ }
+ } else if (that.options.heightStyle !== "content") {
+ fx.now = Math.round(total - toHide.outerHeight() - adjust);
+ adjust = 0;
+ }
+ }
+ });
+ },
+
+ _toggleComplete: function (data) {
+ var toHide = data.oldPanel,
+ prev = toHide.prev();
+
+ this._removeClass(toHide, "ui-accordion-content-active");
+ this._removeClass(prev, "ui-accordion-header-active")
+ ._addClass(prev, "ui-accordion-header-collapsed");
+
+ // Work around for rendering bug in IE (#5421)
+ if (toHide.length) {
+ toHide.parent()[0].className = toHide.parent()[0].className;
+ }
+ this._trigger("activate", null, data);
+ }
+ });
+
+
+
+ var safeActiveElement = $.ui.safeActiveElement = function (document) {
+ var activeElement;
+
+ // Support: IE 9 only
+ // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
+ try {
+ activeElement = document.activeElement;
+ } catch (error) {
+ activeElement = document.body;
+ }
+
+ // Support: IE 9 - 11 only
+ // IE may return null instead of an element
+ // Interestingly, this only seems to occur when NOT in an iframe
+ if (!activeElement) {
+ activeElement = document.body;
+ }
+
+ // Support: IE 11 only
+ // IE11 returns a seemingly empty object in some cases when accessing
+ // document.activeElement from an <iframe>
+ if (!activeElement.nodeName) {
+ activeElement = document.body;
+ }
+
+ return activeElement;
+ };
+
+
+ /*!
+ * jQuery UI Menu 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Menu
+ //>>group: Widgets
+ //>>description: Creates nestable menus.
+ //>>docs: http://api.jqueryui.com/menu/
+ //>>demos: http://jqueryui.com/menu/
+ //>>css.structure: ../../themes/base/core.css
+ //>>css.structure: ../../themes/base/menu.css
+ //>>css.theme: ../../themes/base/theme.css
+
+
+
+ var widgetsMenu = $.widget("ui.menu", {
+ version: "1.12.1",
+ defaultElement: "<ul>",
+ delay: 300,
+ options: {
+ icons: {
+ submenu: "ui-icon-caret-1-e"
+ },
+ items: "> *",
+ menus: "ul",
+ position: {
+ my: "left top",
+ at: "right top"
+ },
+ role: "menu",
+
+ // Callbacks
+ blur: null,
+ focus: null,
+ select: null
+ },
+
+ _create: function () {
+ this.activeMenu = this.element;
+
+ // Flag used to prevent firing of the click handler
+ // as the event bubbles up through nested menus
+ this.mouseHandled = false;
+ this.element
+ .uniqueId()
+ .attr({
+ role: this.options.role,
+ tabIndex: 0
+ });
+
+ this._addClass("ui-menu", "ui-widget ui-widget-content");
+ this._on({
+
+ // Prevent focus from sticking to links inside menu after clicking
+ // them (focus should always stay on UL during navigation).
+ "mousedown .ui-menu-item": function (event) {
+ event.preventDefault();
+ },
+ "click .ui-menu-item": function (event) {
+ var target = $(event.target);
+ var active = $($.ui.safeActiveElement(this.document[0]));
+ if (!this.mouseHandled && target.not(".ui-state-disabled").length) {
+ this.select(event);
+
+ // Only set the mouseHandled flag if the event will bubble, see #9469.
+ if (!event.isPropagationStopped()) {
+ this.mouseHandled = true;
+ }
+
+ // Open submenu on click
+ if (target.has(".ui-menu").length) {
+ this.expand(event);
+ } else if (!this.element.is(":focus") &&
+ active.closest(".ui-menu").length) {
+
+ // Redirect focus to the menu
+ this.element.trigger("focus", [true]);
+
+ // If the active item is on the top level, let it stay active.
+ // Otherwise, blur the active item since it is no longer visible.
+ if (this.active && this.active.parents(".ui-menu").length === 1) {
+ clearTimeout(this.timer);
+ }
+ }
+ }
+ },
+ "mouseenter .ui-menu-item": function (event) {
+
+ // Ignore mouse events while typeahead is active, see #10458.
+ // Prevents focusing the wrong item when typeahead causes a scroll while the mouse
+ // is over an item in the menu
+ if (this.previousFilter) {
+ return;
+ }
+
+ var actualTarget = $(event.target).closest(".ui-menu-item"),
+ target = $(event.currentTarget);
+
+ // Ignore bubbled events on parent items, see #11641
+ if (actualTarget[0] !== target[0]) {
+ return;
+ }
+
+ // Remove ui-state-active class from siblings of the newly focused menu item
+ // to avoid a jump caused by adjacent elements both having a class with a border
+ this._removeClass(target.siblings().children(".ui-state-active"),
+ null, "ui-state-active");
+ this.focus(event, target);
+ },
+ mouseleave: "collapseAll",
+ "mouseleave .ui-menu": "collapseAll",
+ focus: function (event, keepActiveItem) {
+
+ // If there's already an active item, keep it active
+ // If not, activate the first item
+ var item = this.active || this.element.find(this.options.items).eq(0);
+
+ if (!keepActiveItem) {
+ this.focus(event, item);
+ }
+ },
+ blur: function (event) {
+ this._delay(function () {
+ var notContained = !$.contains(
+ this.element[0],
+ $.ui.safeActiveElement(this.document[0])
+ );
+ if (notContained) {
+ this.collapseAll(event);
+ }
+ });
+ },
+ keydown: "_keydown"
+ });
+
+ this.refresh();
+
+ // Clicks outside of a menu collapse any open menus
+ this._on(this.document, {
+ click: function (event) {
+ if (this._closeOnDocumentClick(event)) {
+ this.collapseAll(event);
+ }
+
+ // Reset the mouseHandled flag
+ this.mouseHandled = false;
+ }
+ });
+ },
+
+ _destroy: function () {
+ var items = this.element.find(".ui-menu-item")
+ .removeAttr("role aria-disabled"),
+ submenus = items.children(".ui-menu-item-wrapper")
+ .removeUniqueId()
+ .removeAttr("tabIndex role aria-haspopup");
+
+ // Destroy (sub)menus
+ this.element
+ .removeAttr("aria-activedescendant")
+ .find(".ui-menu").addBack()
+ .removeAttr("role aria-labelledby aria-expanded aria-hidden aria-disabled " +
+ "tabIndex")
+ .removeUniqueId()
+ .show();
+
+ submenus.children().each(function () {
+ var elem = $(this);
+ if (elem.data("ui-menu-submenu-caret")) {
+ elem.remove();
+ }
+ });
+ },
+
+ _keydown: function (event) {
+ var match, prev, character, skip,
+ preventDefault = true;
+
+ switch (event.keyCode) {
+ case $.ui.keyCode.PAGE_UP:
+ this.previousPage(event);
+ break;
+ case $.ui.keyCode.PAGE_DOWN:
+ this.nextPage(event);
+ break;
+ case $.ui.keyCode.HOME:
+ this._move("first", "first", event);
+ break;
+ case $.ui.keyCode.END:
+ this._move("last", "last", event);
+ break;
+ case $.ui.keyCode.UP:
+ this.previous(event);
+ break;
+ case $.ui.keyCode.DOWN:
+ this.next(event);
+ break;
+ case $.ui.keyCode.LEFT:
+ this.collapse(event);
+ break;
+ case $.ui.keyCode.RIGHT:
+ if (this.active && !this.active.is(".ui-state-disabled")) {
+ this.expand(event);
+ }
+ break;
+ case $.ui.keyCode.ENTER:
+ case $.ui.keyCode.SPACE:
+ this._activate(event);
+ break;
+ case $.ui.keyCode.ESCAPE:
+ this.collapse(event);
+ break;
+ default:
+ preventDefault = false;
+ prev = this.previousFilter || "";
+ skip = false;
+
+ // Support number pad values
+ character = event.keyCode >= 96 && event.keyCode <= 105 ?
+ (event.keyCode - 96).toString() : String.fromCharCode(event.keyCode);
+
+ clearTimeout(this.filterTimer);
+
+ if (character === prev) {
+ skip = true;
+ } else {
+ character = prev + character;
+ }
+
+ match = this._filterMenuItems(character);
+ match = skip && match.index(this.active.next()) !== -1 ?
+ this.active.nextAll(".ui-menu-item") :
+ match;
+
+ // If no matches on the current filter, reset to the last character pressed
+ // to move down the menu to the first item that starts with that character
+ if (!match.length) {
+ character = String.fromCharCode(event.keyCode);
+ match = this._filterMenuItems(character);
+ }
+
+ if (match.length) {
+ this.focus(event, match);
+ this.previousFilter = character;
+ this.filterTimer = this._delay(function () {
+ delete this.previousFilter;
+ }, 1000);
+ } else {
+ delete this.previousFilter;
+ }
+ }
+
+ if (preventDefault) {
+ event.preventDefault();
+ }
+ },
+
+ _activate: function (event) {
+ if (this.active && !this.active.is(".ui-state-disabled")) {
+ if (this.active.children("[aria-haspopup='true']").length) {
+ this.expand(event);
+ } else {
+ this.select(event);
+ }
+ }
+ },
+
+ refresh: function () {
+ var menus, items, newSubmenus, newItems, newWrappers,
+ that = this,
+ icon = this.options.icons.submenu,
+ submenus = this.element.find(this.options.menus);
+
+ this._toggleClass("ui-menu-icons", null, !!this.element.find(".ui-icon").length);
+
+ // Initialize nested menus
+ newSubmenus = submenus.filter(":not(.ui-menu)")
+ .hide()
+ .attr({
+ role: this.options.role,
+ "aria-hidden": "true",
+ "aria-expanded": "false"
+ })
+ .each(function () {
+ var menu = $(this),
+ item = menu.prev(),
+ submenuCaret = $("<span>").data("ui-menu-submenu-caret", true);
+
+ that._addClass(submenuCaret, "ui-menu-icon", "ui-icon " + icon);
+ item
+ .attr("aria-haspopup", "true")
+ .prepend(submenuCaret);
+ menu.attr("aria-labelledby", item.attr("id"));
+ });
+
+ this._addClass(newSubmenus, "ui-menu", "ui-widget ui-widget-content ui-front");
+
+ menus = submenus.add(this.element);
+ items = menus.find(this.options.items);
+
+ // Initialize menu-items containing spaces and/or dashes only as dividers
+ items.not(".ui-menu-item").each(function () {
+ var item = $(this);
+ if (that._isDivider(item)) {
+ that._addClass(item, "ui-menu-divider", "ui-widget-content");
+ }
+ });
+
+ // Don't refresh list items that are already adapted
+ newItems = items.not(".ui-menu-item, .ui-menu-divider");
+ newWrappers = newItems.children()
+ .not(".ui-menu")
+ .uniqueId()
+ .attr({
+ tabIndex: -1,
+ role: this._itemRole()
+ });
+ this._addClass(newItems, "ui-menu-item")
+ ._addClass(newWrappers, "ui-menu-item-wrapper");
+
+ // Add aria-disabled attribute to any disabled menu item
+ items.filter(".ui-state-disabled").attr("aria-disabled", "true");
+
+ // If the active item has been removed, blur the menu
+ if (this.active && !$.contains(this.element[0], this.active[0])) {
+ this.blur();
+ }
+ },
+
+ _itemRole: function () {
+ return {
+ menu: "menuitem",
+ listbox: "option"
+ }[this.options.role];
+ },
+
+ _setOption: function (key, value) {
+ if (key === "icons") {
+ var icons = this.element.find(".ui-menu-icon");
+ this._removeClass(icons, null, this.options.icons.submenu)
+ ._addClass(icons, null, value.submenu);
+ }
+ this._super(key, value);
+ },
+
+ _setOptionDisabled: function (value) {
+ this._super(value);
+
+ this.element.attr("aria-disabled", String(value));
+ this._toggleClass(null, "ui-state-disabled", !!value);
+ },
+
+ focus: function (event, item) {
+ var nested, focused, activeParent;
+ this.blur(event, event && event.type === "focus");
+
+ this._scrollIntoView(item);
+
+ this.active = item.first();
+
+ focused = this.active.children(".ui-menu-item-wrapper");
+ this._addClass(focused, null, "ui-state-active");
+
+ // Only update aria-activedescendant if there's a role
+ // otherwise we assume focus is managed elsewhere
+ if (this.options.role) {
+ this.element.attr("aria-activedescendant", focused.attr("id"));
+ }
+
+ // Highlight active parent menu item, if any
+ activeParent = this.active
+ .parent()
+ .closest(".ui-menu-item")
+ .children(".ui-menu-item-wrapper");
+ this._addClass(activeParent, null, "ui-state-active");
+
+ if (event && event.type === "keydown") {
+ this._close();
+ } else {
+ this.timer = this._delay(function () {
+ this._close();
+ }, this.delay);
+ }
+
+ nested = item.children(".ui-menu");
+ if (nested.length && event && (/^mouse/.test(event.type))) {
+ this._startOpening(nested);
+ }
+ this.activeMenu = item.parent();
+
+ this._trigger("focus", event, { item: item });
+ },
+
+ _scrollIntoView: function (item) {
+ var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
+ if (this._hasScroll()) {
+ borderTop = parseFloat($.css(this.activeMenu[0], "borderTopWidth")) || 0;
+ paddingTop = parseFloat($.css(this.activeMenu[0], "paddingTop")) || 0;
+ offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
+ scroll = this.activeMenu.scrollTop();
+ elementHeight = this.activeMenu.height();
+ itemHeight = item.outerHeight();
+
+ if (offset < 0) {
+ this.activeMenu.scrollTop(scroll + offset);
+ } else if (offset + itemHeight > elementHeight) {
+ this.activeMenu.scrollTop(scroll + offset - elementHeight + itemHeight);
+ }
+ }
+ },
+
+ blur: function (event, fromFocus) {
+ if (!fromFocus) {
+ clearTimeout(this.timer);
+ }
+
+ if (!this.active) {
+ return;
+ }
+
+ this._removeClass(this.active.children(".ui-menu-item-wrapper"),
+ null, "ui-state-active");
+
+ this._trigger("blur", event, { item: this.active });
+ this.active = null;
+ },
+
+ _startOpening: function (submenu) {
+ clearTimeout(this.timer);
+
+ // Don't open if already open fixes a Firefox bug that caused a .5 pixel
+ // shift in the submenu position when mousing over the caret icon
+ if (submenu.attr("aria-hidden") !== "true") {
+ return;
+ }
+
+ this.timer = this._delay(function () {
+ this._close();
+ this._open(submenu);
+ }, this.delay);
+ },
+
+ _open: function (submenu) {
+ var position = $.extend({
+ of: this.active
+ }, this.options.position);
+
+ clearTimeout(this.timer);
+ this.element.find(".ui-menu").not(submenu.parents(".ui-menu"))
+ .hide()
+ .attr("aria-hidden", "true");
+
+ submenu
+ .show()
+ .removeAttr("aria-hidden")
+ .attr("aria-expanded", "true")
+ .position(position);
+ },
+
+ collapseAll: function (event, all) {
+ clearTimeout(this.timer);
+ this.timer = this._delay(function () {
+
+ // If we were passed an event, look for the submenu that contains the event
+ var currentMenu = all ? this.element :
+ $(event && event.target).closest(this.element.find(".ui-menu"));
+
+ // If we found no valid submenu ancestor, use the main menu to close all
+ // sub menus anyway
+ if (!currentMenu.length) {
+ currentMenu = this.element;
+ }
+
+ this._close(currentMenu);
+
+ this.blur(event);
+
+ // Work around active item staying active after menu is blurred
+ this._removeClass(currentMenu.find(".ui-state-active"), null, "ui-state-active");
+
+ this.activeMenu = currentMenu;
+ }, this.delay);
+ },
+
+ // With no arguments, closes the currently active menu - if nothing is active
+ // it closes all menus. If passed an argument, it will search for menus BELOW
+ _close: function (startMenu) {
+ if (!startMenu) {
+ startMenu = this.active ? this.active.parent() : this.element;
+ }
+
+ startMenu.find(".ui-menu")
+ .hide()
+ .attr("aria-hidden", "true")
+ .attr("aria-expanded", "false");
+ },
+
+ _closeOnDocumentClick: function (event) {
+ return !$(event.target).closest(".ui-menu").length;
+ },
+
+ _isDivider: function (item) {
+
+ // Match hyphen, em dash, en dash
+ return !/[^\-\u2014\u2013\s]/.test(item.text());
+ },
+
+ collapse: function (event) {
+ var newItem = this.active &&
+ this.active.parent().closest(".ui-menu-item", this.element);
+ if (newItem && newItem.length) {
+ this._close();
+ this.focus(event, newItem);
+ }
+ },
+
+ expand: function (event) {
+ var newItem = this.active &&
+ this.active
+ .children(".ui-menu ")
+ .find(this.options.items)
+ .first();
+
+ if (newItem && newItem.length) {
+ this._open(newItem.parent());
+
+ // Delay so Firefox will not hide activedescendant change in expanding submenu from AT
+ this._delay(function () {
+ this.focus(event, newItem);
+ });
+ }
+ },
+
+ next: function (event) {
+ this._move("next", "first", event);
+ },
+
+ previous: function (event) {
+ this._move("prev", "last", event);
+ },
+
+ isFirstItem: function () {
+ return this.active && !this.active.prevAll(".ui-menu-item").length;
+ },
+
+ isLastItem: function () {
+ return this.active && !this.active.nextAll(".ui-menu-item").length;
+ },
+
+ _move: function (direction, filter, event) {
+ var next;
+ if (this.active) {
+ if (direction === "first" || direction === "last") {
+ next = this.active
+ [direction === "first" ? "prevAll" : "nextAll"](".ui-menu-item")
+ .eq(-1);
+ } else {
+ next = this.active
+ [direction + "All"](".ui-menu-item")
+ .eq(0);
+ }
+ }
+ if (!next || !next.length || !this.active) {
+ next = this.activeMenu.find(this.options.items)[filter]();
+ }
+
+ this.focus(event, next);
+ },
+
+ nextPage: function (event) {
+ var item, base, height;
+
+ if (!this.active) {
+ this.next(event);
+ return;
+ }
+ if (this.isLastItem()) {
+ return;
+ }
+ if (this._hasScroll()) {
+ base = this.active.offset().top;
+ height = this.element.height();
+ this.active.nextAll(".ui-menu-item").each(function () {
+ item = $(this);
+ return item.offset().top - base - height < 0;
+ });
+
+ this.focus(event, item);
+ } else {
+ this.focus(event, this.activeMenu.find(this.options.items)
+ [!this.active ? "first" : "last"]());
+ }
+ },
+
+ previousPage: function (event) {
+ var item, base, height;
+ if (!this.active) {
+ this.next(event);
+ return;
+ }
+ if (this.isFirstItem()) {
+ return;
+ }
+ if (this._hasScroll()) {
+ base = this.active.offset().top;
+ height = this.element.height();
+ this.active.prevAll(".ui-menu-item").each(function () {
+ item = $(this);
+ return item.offset().top - base + height > 0;
+ });
+
+ this.focus(event, item);
+ } else {
+ this.focus(event, this.activeMenu.find(this.options.items).first());
+ }
+ },
+
+ _hasScroll: function () {
+ return this.element.outerHeight() < this.element.prop("scrollHeight");
+ },
+
+ select: function (event) {
+
+ // TODO: It should never be possible to not have an active item at this
+ // point, but the tests don't trigger mouseenter before click.
+ this.active = this.active || $(event.target).closest(".ui-menu-item");
+ var ui = { item: this.active };
+ if (!this.active.has(".ui-menu").length) {
+ this.collapseAll(event, true);
+ }
+ this._trigger("select", event, ui);
+ },
+
+ _filterMenuItems: function (character) {
+ var escapedCharacter = character.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&"),
+ regex = new RegExp("^" + escapedCharacter, "i");
+
+ return this.activeMenu
+ .find(this.options.items)
+
+ // Only match on items, not dividers or other content (#10571)
+ .filter(".ui-menu-item")
+ .filter(function () {
+ return regex.test(
+ $.trim($(this).children(".ui-menu-item-wrapper").text()));
+ });
+ }
+ });
+
+
+ /*!
+ * jQuery UI Autocomplete 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Autocomplete
+ //>>group: Widgets
+ //>>description: Lists suggested words as the user is typing.
+ //>>docs: http://api.jqueryui.com/autocomplete/
+ //>>demos: http://jqueryui.com/autocomplete/
+ //>>css.structure: ../../themes/base/core.css
+ //>>css.structure: ../../themes/base/autocomplete.css
+ //>>css.theme: ../../themes/base/theme.css
+
+
+
+ $.widget("ui.autocomplete", {
+ version: "1.12.1",
+ defaultElement: "<input>",
+ options: {
+ appendTo: null,
+ autoFocus: false,
+ delay: 300,
+ minLength: 1,
+ position: {
+ my: "left top",
+ at: "left bottom",
+ collision: "none"
+ },
+ source: null,
+
+ // Callbacks
+ change: null,
+ close: null,
+ focus: null,
+ open: null,
+ response: null,
+ search: null,
+ select: null
+ },
+
+ requestIndex: 0,
+ pending: 0,
+
+ _create: function () {
+
+ // Some browsers only repeat keydown events, not keypress events,
+ // so we use the suppressKeyPress flag to determine if we've already
+ // handled the keydown event. #7269
+ // Unfortunately the code for & in keypress is the same as the up arrow,
+ // so we use the suppressKeyPressRepeat flag to avoid handling keypress
+ // events when we know the keydown event was used to modify the
+ // search term. #7799
+ var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
+ nodeName = this.element[0].nodeName.toLowerCase(),
+ isTextarea = nodeName === "textarea",
+ isInput = nodeName === "input";
+
+ // Textareas are always multi-line
+ // Inputs are always single-line, even if inside a contentEditable element
+ // IE also treats inputs as contentEditable
+ // All other element types are determined by whether or not they're contentEditable
+ this.isMultiLine = isTextarea || !isInput && this._isContentEditable(this.element);
+
+ this.valueMethod = this.element[isTextarea || isInput ? "val" : "text"];
+ this.isNewMenu = true;
+
+ this._addClass("ui-autocomplete-input");
+ this.element.attr("autocomplete", "off");
+
+ this._on(this.element, {
+ keydown: function (event) {
+ if (this.element.prop("readOnly")) {
+ suppressKeyPress = true;
+ suppressInput = true;
+ suppressKeyPressRepeat = true;
+ return;
+ }
+
+ suppressKeyPress = false;
+ suppressInput = false;
+ suppressKeyPressRepeat = false;
+ var keyCode = $.ui.keyCode;
+ switch (event.keyCode) {
+ case keyCode.PAGE_UP:
+ suppressKeyPress = true;
+ this._move("previousPage", event);
+ break;
+ case keyCode.PAGE_DOWN:
+ suppressKeyPress = true;
+ this._move("nextPage", event);
+ break;
+ case keyCode.UP:
+ suppressKeyPress = true;
+ this._keyEvent("previous", event);
+ break;
+ case keyCode.DOWN:
+ suppressKeyPress = true;
+ this._keyEvent("next", event);
+ break;
+ case keyCode.ENTER:
+
+ // when menu is open and has focus
+ if (this.menu.active) {
+
+ // #6055 - Opera still allows the keypress to occur
+ // which causes forms to submit
+ suppressKeyPress = true;
+ event.preventDefault();
+ this.menu.select(event);
+ }
+ break;
+ case keyCode.TAB:
+ if (this.menu.active) {
+ this.menu.select(event);
+ }
+ break;
+ case keyCode.ESCAPE:
+ if (this.menu.element.is(":visible")) {
+ if (!this.isMultiLine) {
+ this._value(this.term);
+ }
+ this.close(event);
+
+ // Different browsers have different default behavior for escape
+ // Single press can mean undo or clear
+ // Double press in IE means clear the whole form
+ event.preventDefault();
+ }
+ break;
+ default:
+ suppressKeyPressRepeat = true;
+
+ // search timeout should be triggered before the input value is changed
+ this._searchTimeout(event);
+ break;
+ }
+ },
+ keypress: function (event) {
+ if (suppressKeyPress) {
+ suppressKeyPress = false;
+ if (!this.isMultiLine || this.menu.element.is(":visible")) {
+ event.preventDefault();
+ }
+ return;
+ }
+ if (suppressKeyPressRepeat) {
+ return;
+ }
+
+ // Replicate some key handlers to allow them to repeat in Firefox and Opera
+ var keyCode = $.ui.keyCode;
+ switch (event.keyCode) {
+ case keyCode.PAGE_UP:
+ this._move("previousPage", event);
+ break;
+ case keyCode.PAGE_DOWN:
+ this._move("nextPage", event);
+ break;
+ case keyCode.UP:
+ this._keyEvent("previous", event);
+ break;
+ case keyCode.DOWN:
+ this._keyEvent("next", event);
+ break;
+ }
+ },
+ input: function (event) {
+ if (suppressInput) {
+ suppressInput = false;
+ event.preventDefault();
+ return;
+ }
+ this._searchTimeout(event);
+ },
+ focus: function () {
+ this.selectedItem = null;
+ this.previous = this._value();
+ },
+ blur: function (event) {
+ if (this.cancelBlur) {
+ delete this.cancelBlur;
+ return;
+ }
+
+ clearTimeout(this.searching);
+ this.close(event);
+ this._change(event);
+ }
+ });
+
+ this._initSource();
+ this.menu = $("<ul>")
+ .appendTo(this._appendTo())
+ .menu({
+
+ // disable ARIA support, the live region takes care of that
+ role: null
+ })
+ .hide()
+ .menu("instance");
+
+ this._addClass(this.menu.element, "ui-autocomplete", "ui-front");
+ this._on(this.menu.element, {
+ mousedown: function (event) {
+
+ // prevent moving focus out of the text field
+ event.preventDefault();
+
+ // IE doesn't prevent moving focus even with event.preventDefault()
+ // so we set a flag to know when we should ignore the blur event
+ this.cancelBlur = true;
+ this._delay(function () {
+ delete this.cancelBlur;
+
+ // Support: IE 8 only
+ // Right clicking a menu item or selecting text from the menu items will
+ // result in focus moving out of the input. However, we've already received
+ // and ignored the blur event because of the cancelBlur flag set above. So
+ // we restore focus to ensure that the menu closes properly based on the user's
+ // next actions.
+ if (this.element[0] !== $.ui.safeActiveElement(this.document[0])) {
+ this.element.trigger("focus");
+ }
+ });
+ },
+ menufocus: function (event, ui) {
+ var label, item;
+
+ // support: Firefox
+ // Prevent accidental activation of menu items in Firefox (#7024 #9118)
+ if (this.isNewMenu) {
+ this.isNewMenu = false;
+ if (event.originalEvent && /^mouse/.test(event.originalEvent.type)) {
+ this.menu.blur();
+
+ this.document.one("mousemove", function () {
+ $(event.target).trigger(event.originalEvent);
+ });
+
+ return;
+ }
+ }
+
+ item = ui.item.data("ui-autocomplete-item");
+ if (false !== this._trigger("focus", event, { item: item })) {
+
+ // use value to match what will end up in the input, if it was a key event
+ if (event.originalEvent && /^key/.test(event.originalEvent.type)) {
+ this._value(item.value);
+ }
+ }
+
+ // Announce the value in the liveRegion
+ label = ui.item.attr("aria-label") || item.value;
+ if (label && $.trim(label).length) {
+ this.liveRegion.children().hide();
+ $("<div>").text(label).appendTo(this.liveRegion);
+ }
+ },
+ menuselect: function (event, ui) {
+ var item = ui.item.data("ui-autocomplete-item"),
+ previous = this.previous;
+
+ // Only trigger when focus was lost (click on menu)
+ if (this.element[0] !== $.ui.safeActiveElement(this.document[0])) {
+ this.element.trigger("focus");
+ this.previous = previous;
+
+ // #6109 - IE triggers two focus events and the second
+ // is asynchronous, so we need to reset the previous
+ // term synchronously and asynchronously :-(
+ this._delay(function () {
+ this.previous = previous;
+ this.selectedItem = item;
+ });
+ }
+
+ if (false !== this._trigger("select", event, { item: item })) {
+ this._value(item.value);
+ }
+
+ // reset the term after the select event
+ // this allows custom select handling to work properly
+ this.term = this._value();
+
+ this.close(event);
+ this.selectedItem = item;
+ }
+ });
+
+ this.liveRegion = $("<div>", {
+ role: "status",
+ "aria-live": "assertive",
+ "aria-relevant": "additions"
+ })
+ .appendTo(this.document[0].body);
+
+ this._addClass(this.liveRegion, null, "ui-helper-hidden-accessible");
+
+ // Turning off autocomplete prevents the browser from remembering the
+ // value when navigating through history, so we re-enable autocomplete
+ // if the page is unloaded before the widget is destroyed. #7790
+ this._on(this.window, {
+ beforeunload: function () {
+ this.element.removeAttr("autocomplete");
+ }
+ });
+ },
+
+ _destroy: function () {
+ clearTimeout(this.searching);
+ this.element.removeAttr("autocomplete");
+ this.menu.element.remove();
+ this.liveRegion.remove();
+ },
+
+ _setOption: function (key, value) {
+ this._super(key, value);
+ if (key === "source") {
+ this._initSource();
+ }
+ if (key === "appendTo") {
+ this.menu.element.appendTo(this._appendTo());
+ }
+ if (key === "disabled" && value && this.xhr) {
+ this.xhr.abort();
+ }
+ },
+
+ _isEventTargetInWidget: function (event) {
+ var menuElement = this.menu.element[0];
+
+ return event.target === this.element[0] ||
+ event.target === menuElement ||
+ $.contains(menuElement, event.target);
+ },
+
+ _closeOnClickOutside: function (event) {
+ if (!this._isEventTargetInWidget(event)) {
+ this.close();
+ }
+ },
+
+ _appendTo: function () {
+ var element = this.options.appendTo;
+
+ if (element) {
+ element = element.jquery || element.nodeType ?
+ $(element) :
+ this.document.find(element).eq(0);
+ }
+
+ if (!element || !element[0]) {
+ element = this.element.closest(".ui-front, dialog");
+ }
+
+ if (!element.length) {
+ element = this.document[0].body;
+ }
+
+ return element;
+ },
+
+ _initSource: function () {
+ var array, url,
+ that = this;
+ if ($.isArray(this.options.source)) {
+ array = this.options.source;
+ this.source = function (request, response) {
+ response($.ui.autocomplete.filter(array, request.term));
+ };
+ } else if (typeof this.options.source === "string") {
+ url = this.options.source;
+ this.source = function (request, response) {
+ if (that.xhr) {
+ that.xhr.abort();
+ }
+ that.xhr = $.ajax({
+ url: url,
+ data: request,
+ dataType: "json",
+ success: function (data) {
+ response(data);
+ },
+ error: function () {
+ response([]);
+ }
+ });
+ };
+ } else {
+ this.source = this.options.source;
+ }
+ },
+
+ _searchTimeout: function (event) {
+ clearTimeout(this.searching);
+ this.searching = this._delay(function () {
+
+ // Search if the value has changed, or if the user retypes the same value (see #7434)
+ var equalValues = this.term === this._value(),
+ menuVisible = this.menu.element.is(":visible"),
+ modifierKey = event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
+
+ if (!equalValues || (equalValues && !menuVisible && !modifierKey)) {
+ this.selectedItem = null;
+ this.search(null, event);
+ }
+ }, this.options.delay);
+ },
+
+ search: function (value, event) {
+ value = value != null ? value : this._value();
+
+ // Always save the actual value, not the one passed as an argument
+ this.term = this._value();
+
+ if (value.length < this.options.minLength) {
+ return this.close(event);
+ }
+
+ if (this._trigger("search", event) === false) {
+ return;
+ }
+
+ return this._search(value);
+ },
+
+ _search: function (value) {
+ this.pending++;
+ this._addClass("ui-autocomplete-loading");
+ this.cancelSearch = false;
+
+ this.source({ term: value }, this._response());
+ },
+
+ _response: function () {
+ var index = ++this.requestIndex;
+
+ return $.proxy(function (content) {
+ if (index === this.requestIndex) {
+ this.__response(content);
+ }
+
+ this.pending--;
+ if (!this.pending) {
+ this._removeClass("ui-autocomplete-loading");
+ }
+ }, this);
+ },
+
+ __response: function (content) {
+ if (content) {
+ content = this._normalize(content);
+ }
+ this._trigger("response", null, { content: content });
+ if (!this.options.disabled && content && content.length && !this.cancelSearch) {
+ this._suggest(content);
+ this._trigger("open");
+ } else {
+
+ // use ._close() instead of .close() so we don't cancel future searches
+ this._close();
+ }
+ },
+
+ close: function (event) {
+ this.cancelSearch = true;
+ this._close(event);
+ },
+
+ _close: function (event) {
+
+ // Remove the handler that closes the menu on outside clicks
+ this._off(this.document, "mousedown");
+
+ if (this.menu.element.is(":visible")) {
+ this.menu.element.hide();
+ this.menu.blur();
+ this.isNewMenu = true;
+ this._trigger("close", event);
+ }
+ },
+
+ _change: function (event) {
+ if (this.previous !== this._value()) {
+ this._trigger("change", event, { item: this.selectedItem });
+ }
+ },
+
+ _normalize: function (items) {
+
+ // assume all items have the right format when the first item is complete
+ if (items.length && items[0].label && items[0].value) {
+ return items;
+ }
+ return $.map(items, function (item) {
+ if (typeof item === "string") {
+ return {
+ label: item,
+ value: item
+ };
+ }
+ return $.extend({}, item, {
+ label: item.label || item.value,
+ value: item.value || item.label
+ });
+ });
+ },
+
+ _suggest: function (items) {
+ var ul = this.menu.element.empty();
+ this._renderMenu(ul, items);
+ this.isNewMenu = true;
+ this.menu.refresh();
+
+ // Size and position menu
+ ul.show();
+ this._resizeMenu();
+ ul.position($.extend({
+ of: this.element
+ }, this.options.position));
+
+ if (this.options.autoFocus) {
+ this.menu.next();
+ }
+
+ // Listen for interactions outside of the widget (#6642)
+ this._on(this.document, {
+ mousedown: "_closeOnClickOutside"
+ });
+ },
+
+ _resizeMenu: function () {
+ var ul = this.menu.element;
+ ul.outerWidth(Math.max(
+
+ // Firefox wraps long text (possibly a rounding bug)
+ // so we add 1px to avoid the wrapping (#7513)
+ ul.width("").outerWidth() + 1,
+ this.element.outerWidth()
+ ));
+ },
+
+ _renderMenu: function (ul, items) {
+ var that = this;
+ $.each(items, function (index, item) {
+ that._renderItemData(ul, item);
+ });
+ },
+
+ _renderItemData: function (ul, item) {
+ return this._renderItem(ul, item).data("ui-autocomplete-item", item);
+ },
+
+ _renderItem: function (ul, item) {
+ return $("<li>")
+ .append($("<div>").text(item.label))
+ .appendTo(ul);
+ },
+
+ _move: function (direction, event) {
+ if (!this.menu.element.is(":visible")) {
+ this.search(null, event);
+ return;
+ }
+ if (this.menu.isFirstItem() && /^previous/.test(direction) ||
+ this.menu.isLastItem() && /^next/.test(direction)) {
+
+ if (!this.isMultiLine) {
+ this._value(this.term);
+ }
+
+ this.menu.blur();
+ return;
+ }
+ this.menu[direction](event);
+ },
+
+ widget: function () {
+ return this.menu.element;
+ },
+
+ _value: function () {
+ return this.valueMethod.apply(this.element, arguments);
+ },
+
+ _keyEvent: function (keyEvent, event) {
+ if (!this.isMultiLine || this.menu.element.is(":visible")) {
+ this._move(keyEvent, event);
+
+ // Prevents moving cursor to beginning/end of the text field in some browsers
+ event.preventDefault();
+ }
+ },
+
+ // Support: Chrome <=50
+ // We should be able to just use this.element.prop( "isContentEditable" )
+ // but hidden elements always report false in Chrome.
+ // https://code.google.com/p/chromium/issues/detail?id=313082
+ _isContentEditable: function (element) {
+ if (!element.length) {
+ return false;
+ }
+
+ var editable = element.prop("contentEditable");
+
+ if (editable === "inherit") {
+ return this._isContentEditable(element.parent());
+ }
+
+ return editable === "true";
+ }
+ });
+
+ $.extend($.ui.autocomplete, {
+ escapeRegex: function (value) {
+ return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
+ },
+ filter: function (array, term) {
+ var matcher = new RegExp($.ui.autocomplete.escapeRegex(term), "i");
+ return $.grep(array, function (value) {
+ return matcher.test(value.label || value.value || value);
+ });
+ }
+ });
+
+ // Live region extension, adding a `messages` option
+ // NOTE: This is an experimental API. We are still investigating
+ // a full solution for string manipulation and internationalization.
+ $.widget("ui.autocomplete", $.ui.autocomplete, {
+ options: {
+ messages: {
+ noResults: "No search results.",
+ results: function (amount) {
+ return amount + (amount > 1 ? " results are" : " result is") +
+ " available, use up and down arrow keys to navigate.";
+ }
+ }
+ },
+
+ __response: function (content) {
+ var message;
+ this._superApply(arguments);
+ if (this.options.disabled || this.cancelSearch) {
+ return;
+ }
+ if (content && content.length) {
+ message = this.options.messages.results(content.length);
+ } else {
+ message = this.options.messages.noResults;
+ }
+ this.liveRegion.children().hide();
+ $("<div>").text(message).appendTo(this.liveRegion);
+ }
+ });
+
+ var widgetsAutocomplete = $.ui.autocomplete;
+
+
+ /*!
+ * jQuery UI Controlgroup 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Controlgroup
+ //>>group: Widgets
+ //>>description: Visually groups form control widgets
+ //>>docs: http://api.jqueryui.com/controlgroup/
+ //>>demos: http://jqueryui.com/controlgroup/
+ //>>css.structure: ../../themes/base/core.css
+ //>>css.structure: ../../themes/base/controlgroup.css
+ //>>css.theme: ../../themes/base/theme.css
+
+
+ var controlgroupCornerRegex = /ui-corner-([a-z]){2,6}/g;
+
+ var widgetsControlgroup = $.widget("ui.controlgroup", {
+ version: "1.12.1",
+ defaultElement: "<div>",
+ options: {
+ direction: "horizontal",
+ disabled: null,
+ onlyVisible: true,
+ items: {
+ "button": "input[type=button], input[type=submit], input[type=reset], button, a",
+ "controlgroupLabel": ".ui-controlgroup-label",
+ "checkboxradio": "input[type='checkbox'], input[type='radio']",
+ "selectmenu": "select",
+ "spinner": ".ui-spinner-input"
+ }
+ },
+
+ _create: function () {
+ this._enhance();
+ },
+
+ // To support the enhanced option in jQuery Mobile, we isolate DOM manipulation
+ _enhance: function () {
+ this.element.attr("role", "toolbar");
+ this.refresh();
+ },
+
+ _destroy: function () {
+ this._callChildMethod("destroy");
+ this.childWidgets.removeData("ui-controlgroup-data");
+ this.element.removeAttr("role");
+ if (this.options.items.controlgroupLabel) {
+ this.element
+ .find(this.options.items.controlgroupLabel)
+ .find(".ui-controlgroup-label-contents")
+ .contents().unwrap();
+ }
+ },
+
+ _initWidgets: function () {
+ var that = this,
+ childWidgets = [];
+
+ // First we iterate over each of the items options
+ $.each(this.options.items, function (widget, selector) {
+ var labels;
+ var options = {};
+
+ // Make sure the widget has a selector set
+ if (!selector) {
+ return;
+ }
+
+ if (widget === "controlgroupLabel") {
+ labels = that.element.find(selector);
+ labels.each(function () {
+ var element = $(this);
+
+ if (element.children(".ui-controlgroup-label-contents").length) {
+ return;
+ }
+ element.contents()
+ .wrapAll("<span class='ui-controlgroup-label-contents'></span>");
+ });
+ that._addClass(labels, null, "ui-widget ui-widget-content ui-state-default");
+ childWidgets = childWidgets.concat(labels.get());
+ return;
+ }
+
+ // Make sure the widget actually exists
+ if (!$.fn[widget]) {
+ return;
+ }
+
+ // We assume everything is in the middle to start because we can't determine
+ // first / last elements until all enhancments are done.
+ if (that["_" + widget + "Options"]) {
+ options = that["_" + widget + "Options"]("middle");
+ } else {
+ options = { classes: {} };
+ }
+
+ // Find instances of this widget inside controlgroup and init them
+ that.element
+ .find(selector)
+ .each(function () {
+ var element = $(this);
+ var instance = element[widget]("instance");
+
+ // We need to clone the default options for this type of widget to avoid
+ // polluting the variable options which has a wider scope than a single widget.
+ var instanceOptions = $.widget.extend({}, options);
+
+ // If the button is the child of a spinner ignore it
+ // TODO: Find a more generic solution
+ if (widget === "button" && element.parent(".ui-spinner").length) {
+ return;
+ }
+
+ // Create the widget if it doesn't exist
+ if (!instance) {
+ instance = element[widget]()[widget]("instance");
+ }
+ if (instance) {
+ instanceOptions.classes =
+ that._resolveClassesValues(instanceOptions.classes, instance);
+ }
+ element[widget](instanceOptions);
+
+ // Store an instance of the controlgroup to be able to reference
+ // from the outermost element for changing options and refresh
+ var widgetElement = element[widget]("widget");
+ $.data(widgetElement[0], "ui-controlgroup-data",
+ instance ? instance : element[widget]("instance"));
+
+ childWidgets.push(widgetElement[0]);
+ });
+ });
+
+ this.childWidgets = $($.unique(childWidgets));
+ this._addClass(this.childWidgets, "ui-controlgroup-item");
+ },
+
+ _callChildMethod: function (method) {
+ this.childWidgets.each(function () {
+ var element = $(this),
+ data = element.data("ui-controlgroup-data");
+ if (data && data[method]) {
+ data[method]();
+ }
+ });
+ },
+
+ _updateCornerClass: function (element, position) {
+ var remove = "ui-corner-top ui-corner-bottom ui-corner-left ui-corner-right ui-corner-all";
+ var add = this._buildSimpleOptions(position, "label").classes.label;
+
+ this._removeClass(element, null, remove);
+ this._addClass(element, null, add);
+ },
+
+ _buildSimpleOptions: function (position, key) {
+ var direction = this.options.direction === "vertical";
+ var result = {
+ classes: {}
+ };
+ result.classes[key] = {
+ "middle": "",
+ "first": "ui-corner-" + (direction ? "top" : "left"),
+ "last": "ui-corner-" + (direction ? "bottom" : "right"),
+ "only": "ui-corner-all"
+ }[position];
+
+ return result;
+ },
+
+ _spinnerOptions: function (position) {
+ var options = this._buildSimpleOptions(position, "ui-spinner");
+
+ options.classes["ui-spinner-up"] = "";
+ options.classes["ui-spinner-down"] = "";
+
+ return options;
+ },
+
+ _buttonOptions: function (position) {
+ return this._buildSimpleOptions(position, "ui-button");
+ },
+
+ _checkboxradioOptions: function (position) {
+ return this._buildSimpleOptions(position, "ui-checkboxradio-label");
+ },
+
+ _selectmenuOptions: function (position) {
+ var direction = this.options.direction === "vertical";
+ return {
+ width: direction ? "auto" : false,
+ classes: {
+ middle: {
+ "ui-selectmenu-button-open": "",
+ "ui-selectmenu-button-closed": ""
+ },
+ first: {
+ "ui-selectmenu-button-open": "ui-corner-" + (direction ? "top" : "tl"),
+ "ui-selectmenu-button-closed": "ui-corner-" + (direction ? "top" : "left")
+ },
+ last: {
+ "ui-selectmenu-button-open": direction ? "" : "ui-corner-tr",
+ "ui-selectmenu-button-closed": "ui-corner-" + (direction ? "bottom" : "right")
+ },
+ only: {
+ "ui-selectmenu-button-open": "ui-corner-top",
+ "ui-selectmenu-button-closed": "ui-corner-all"
+ }
+
+ }[position]
+ };
+ },
+
+ _resolveClassesValues: function (classes, instance) {
+ var result = {};
+ $.each(classes, function (key) {
+ var current = instance.options.classes[key] || "";
+ current = $.trim(current.replace(controlgroupCornerRegex, ""));
+ result[key] = (current + " " + classes[key]).replace(/\s+/g, " ");
+ });
+ return result;
+ },
+
+ _setOption: function (key, value) {
+ if (key === "direction") {
+ this._removeClass("ui-controlgroup-" + this.options.direction);
+ }
+
+ this._super(key, value);
+ if (key === "disabled") {
+ this._callChildMethod(value ? "disable" : "enable");
+ return;
+ }
+
+ this.refresh();
+ },
+
+ refresh: function () {
+ var children,
+ that = this;
+
+ this._addClass("ui-controlgroup ui-controlgroup-" + this.options.direction);
+
+ if (this.options.direction === "horizontal") {
+ this._addClass(null, "ui-helper-clearfix");
+ }
+ this._initWidgets();
+
+ children = this.childWidgets;
+
+ // We filter here because we need to track all childWidgets not just the visible ones
+ if (this.options.onlyVisible) {
+ children = children.filter(":visible");
+ }
+
+ if (children.length) {
+
+ // We do this last because we need to make sure all enhancment is done
+ // before determining first and last
+ $.each(["first", "last"], function (index, value) {
+ var instance = children[value]().data("ui-controlgroup-data");
+
+ if (instance && that["_" + instance.widgetName + "Options"]) {
+ var options = that["_" + instance.widgetName + "Options"](
+ children.length === 1 ? "only" : value
+ );
+ options.classes = that._resolveClassesValues(options.classes, instance);
+ instance.element[instance.widgetName](options);
+ } else {
+ that._updateCornerClass(children[value](), value);
+ }
+ });
+
+ // Finally call the refresh method on each of the child widgets.
+ this._callChildMethod("refresh");
+ }
+ }
+ });
+
+ /*!
+ * jQuery UI Checkboxradio 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Checkboxradio
+ //>>group: Widgets
+ //>>description: Enhances a form with multiple themeable checkboxes or radio buttons.
+ //>>docs: http://api.jqueryui.com/checkboxradio/
+ //>>demos: http://jqueryui.com/checkboxradio/
+ //>>css.structure: ../../themes/base/core.css
+ //>>css.structure: ../../themes/base/button.css
+ //>>css.structure: ../../themes/base/checkboxradio.css
+ //>>css.theme: ../../themes/base/theme.css
+
+
+
+ $.widget("ui.checkboxradio", [$.ui.formResetMixin, {
+ version: "1.12.1",
+ options: {
+ disabled: null,
+ label: null,
+ icon: true,
+ classes: {
+ "ui-checkboxradio-label": "ui-corner-all",
+ "ui-checkboxradio-icon": "ui-corner-all"
+ }
+ },
+
+ _getCreateOptions: function () {
+ var disabled, labels;
+ var that = this;
+ var options = this._super() || {};
+
+ // We read the type here, because it makes more sense to throw a element type error first,
+ // rather then the error for lack of a label. Often if its the wrong type, it
+ // won't have a label (e.g. calling on a div, btn, etc)
+ this._readType();
+
+ labels = this.element.labels();
+
+ // If there are multiple labels, use the last one
+ this.label = $(labels[labels.length - 1]);
+ if (!this.label.length) {
+ $.error("No label found for checkboxradio widget");
+ }
+
+ this.originalLabel = "";
+
+ // We need to get the label text but this may also need to make sure it does not contain the
+ // input itself.
+ this.label.contents().not(this.element[0]).each(function () {
+
+ // The label contents could be text, html, or a mix. We concat each element to get a
+ // string representation of the label, without the input as part of it.
+ that.originalLabel += this.nodeType === 3 ? $(this).text() : this.outerHTML;
+ });
+
+ // Set the label option if we found label text
+ if (this.originalLabel) {
+ options.label = this.originalLabel;
+ }
+
+ disabled = this.element[0].disabled;
+ if (disabled != null) {
+ options.disabled = disabled;
+ }
+ return options;
+ },
+
+ _create: function () {
+ var checked = this.element[0].checked;
+
+ this._bindFormResetHandler();
+
+ if (this.options.disabled == null) {
+ this.options.disabled = this.element[0].disabled;
+ }
+
+ this._setOption("disabled", this.options.disabled);
+ this._addClass("ui-checkboxradio", "ui-helper-hidden-accessible");
+ this._addClass(this.label, "ui-checkboxradio-label", "ui-button ui-widget");
+
+ if (this.type === "radio") {
+ this._addClass(this.label, "ui-checkboxradio-radio-label");
+ }
+
+ if (this.options.label && this.options.label !== this.originalLabel) {
+ this._updateLabel();
+ } else if (this.originalLabel) {
+ this.options.label = this.originalLabel;
+ }
+
+ this._enhance();
+
+ if (checked) {
+ this._addClass(this.label, "ui-checkboxradio-checked", "ui-state-active");
+ if (this.icon) {
+ this._addClass(this.icon, null, "ui-state-hover");
+ }
+ }
+
+ this._on({
+ change: "_toggleClasses",
+ focus: function () {
+ this._addClass(this.label, null, "ui-state-focus ui-visual-focus");
+ },
+ blur: function () {
+ this._removeClass(this.label, null, "ui-state-focus ui-visual-focus");
+ }
+ });
+ },
+
+ _readType: function () {
+ var nodeName = this.element[0].nodeName.toLowerCase();
+ this.type = this.element[0].type;
+ if (nodeName !== "input" || !/radio|checkbox/.test(this.type)) {
+ $.error("Can't create checkboxradio on element.nodeName=" + nodeName +
+ " and element.type=" + this.type);
+ }
+ },
+
+ // Support jQuery Mobile enhanced option
+ _enhance: function () {
+ this._updateIcon(this.element[0].checked);
+ },
+
+ widget: function () {
+ return this.label;
+ },
+
+ _getRadioGroup: function () {
+ var group;
+ var name = this.element[0].name;
+ var nameSelector = "input[name='" + $.ui.escapeSelector(name) + "']";
+
+ if (!name) {
+ return $([]);
+ }
+
+ if (this.form.length) {
+ group = $(this.form[0].elements).filter(nameSelector);
+ } else {
+
+ // Not inside a form, check all inputs that also are not inside a form
+ group = $(nameSelector).filter(function () {
+ return $(this).form().length === 0;
+ });
+ }
+
+ return group.not(this.element);
+ },
+
+ _toggleClasses: function () {
+ var checked = this.element[0].checked;
+ this._toggleClass(this.label, "ui-checkboxradio-checked", "ui-state-active", checked);
+
+ if (this.options.icon && this.type === "checkbox") {
+ this._toggleClass(this.icon, null, "ui-icon-check ui-state-checked", checked)
+ ._toggleClass(this.icon, null, "ui-icon-blank", !checked);
+ }
+
+ if (this.type === "radio") {
+ this._getRadioGroup()
+ .each(function () {
+ var instance = $(this).checkboxradio("instance");
+
+ if (instance) {
+ instance._removeClass(instance.label,
+ "ui-checkboxradio-checked", "ui-state-active");
+ }
+ });
+ }
+ },
+
+ _destroy: function () {
+ this._unbindFormResetHandler();
+
+ if (this.icon) {
+ this.icon.remove();
+ this.iconSpace.remove();
+ }
+ },
+
+ _setOption: function (key, value) {
+
+ // We don't allow the value to be set to nothing
+ if (key === "label" && !value) {
+ return;
+ }
+
+ this._super(key, value);
+
+ if (key === "disabled") {
+ this._toggleClass(this.label, null, "ui-state-disabled", value);
+ this.element[0].disabled = value;
+
+ // Don't refresh when setting disabled
+ return;
+ }
+ this.refresh();
+ },
+
+ _updateIcon: function (checked) {
+ var toAdd = "ui-icon ui-icon-background ";
+
+ if (this.options.icon) {
+ if (!this.icon) {
+ this.icon = $("<span>");
+ this.iconSpace = $("<span> </span>");
+ this._addClass(this.iconSpace, "ui-checkboxradio-icon-space");
+ }
+
+ if (this.type === "checkbox") {
+ toAdd += checked ? "ui-icon-check ui-state-checked" : "ui-icon-blank";
+ this._removeClass(this.icon, null, checked ? "ui-icon-blank" : "ui-icon-check");
+ } else {
+ toAdd += "ui-icon-blank";
+ }
+ this._addClass(this.icon, "ui-checkboxradio-icon", toAdd);
+ if (!checked) {
+ this._removeClass(this.icon, null, "ui-icon-check ui-state-checked");
+ }
+ this.icon.prependTo(this.label).after(this.iconSpace);
+ } else if (this.icon !== undefined) {
+ this.icon.remove();
+ this.iconSpace.remove();
+ delete this.icon;
+ }
+ },
+
+ _updateLabel: function () {
+
+ // Remove the contents of the label ( minus the icon, icon space, and input )
+ var contents = this.label.contents().not(this.element[0]);
+ if (this.icon) {
+ contents = contents.not(this.icon[0]);
+ }
+ if (this.iconSpace) {
+ contents = contents.not(this.iconSpace[0]);
+ }
+ contents.remove();
+
+ this.label.append(this.options.label);
+ },
+
+ refresh: function () {
+ var checked = this.element[0].checked,
+ isDisabled = this.element[0].disabled;
+
+ this._updateIcon(checked);
+ this._toggleClass(this.label, "ui-checkboxradio-checked", "ui-state-active", checked);
+ if (this.options.label !== null) {
+ this._updateLabel();
+ }
+
+ if (isDisabled !== this.options.disabled) {
+ this._setOptions({ "disabled": isDisabled });
+ }
+ }
+
+ }]);
+
+ var widgetsCheckboxradio = $.ui.checkboxradio;
+
+
+ /*!
+ * jQuery UI Button 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Button
+ //>>group: Widgets
+ //>>description: Enhances a form with themeable buttons.
+ //>>docs: http://api.jqueryui.com/button/
+ //>>demos: http://jqueryui.com/button/
+ //>>css.structure: ../../themes/base/core.css
+ //>>css.structure: ../../themes/base/button.css
+ //>>css.theme: ../../themes/base/theme.css
+
+
+
+ $.widget("ui.button", {
+ version: "1.12.1",
+ defaultElement: "<button>",
+ options: {
+ classes: {
+ "ui-button": "ui-corner-all"
+ },
+ disabled: null,
+ icon: null,
+ iconPosition: "beginning",
+ label: null,
+ showLabel: true
+ },
+
+ _getCreateOptions: function () {
+ var disabled,
+
+ // This is to support cases like in jQuery Mobile where the base widget does have
+ // an implementation of _getCreateOptions
+ options = this._super() || {};
+
+ this.isInput = this.element.is("input");
+
+ disabled = this.element[0].disabled;
+ if (disabled != null) {
+ options.disabled = disabled;
+ }
+
+ this.originalLabel = this.isInput ? this.element.val() : this.element.html();
+ if (this.originalLabel) {
+ options.label = this.originalLabel;
+ }
+
+ return options;
+ },
+
+ _create: function () {
+ if (!this.option.showLabel & !this.options.icon) {
+ this.options.showLabel = true;
+ }
+
+ // We have to check the option again here even though we did in _getCreateOptions,
+ // because null may have been passed on init which would override what was set in
+ // _getCreateOptions
+ if (this.options.disabled == null) {
+ this.options.disabled = this.element[0].disabled || false;
+ }
+
+ this.hasTitle = !!this.element.attr("title");
+
+ // Check to see if the label needs to be set or if its already correct
+ if (this.options.label && this.options.label !== this.originalLabel) {
+ if (this.isInput) {
+ this.element.val(this.options.label);
+ } else {
+ this.element.html(this.options.label);
+ }
+ }
+ this._addClass("ui-button", "ui-widget");
+ this._setOption("disabled", this.options.disabled);
+ this._enhance();
+
+ if (this.element.is("a")) {
+ this._on({
+ "keyup": function (event) {
+ if (event.keyCode === $.ui.keyCode.SPACE) {
+ event.preventDefault();
+
+ // Support: PhantomJS <= 1.9, IE 8 Only
+ // If a native click is available use it so we actually cause navigation
+ // otherwise just trigger a click event
+ if (this.element[0].click) {
+ this.element[0].click();
+ } else {
+ this.element.trigger("click");
+ }
+ }
+ }
+ });
+ }
+ },
+
+ _enhance: function () {
+ if (!this.element.is("button")) {
+ this.element.attr("role", "button");
+ }
+
+ if (this.options.icon) {
+ this._updateIcon("icon", this.options.icon);
+ this._updateTooltip();
+ }
+ },
+
+ _updateTooltip: function () {
+ this.title = this.element.attr("title");
+
+ if (!this.options.showLabel && !this.title) {
+ this.element.attr("title", this.options.label);
+ }
+ },
+
+ _updateIcon: function (option, value) {
+ var icon = option !== "iconPosition",
+ position = icon ? this.options.iconPosition : value,
+ displayBlock = position === "top" || position === "bottom";
+
+ // Create icon
+ if (!this.icon) {
+ this.icon = $("<span>");
+
+ this._addClass(this.icon, "ui-button-icon", "ui-icon");
+
+ if (!this.options.showLabel) {
+ this._addClass("ui-button-icon-only");
+ }
+ } else if (icon) {
+
+ // If we are updating the icon remove the old icon class
+ this._removeClass(this.icon, null, this.options.icon);
+ }
+
+ // If we are updating the icon add the new icon class
+ if (icon) {
+ this._addClass(this.icon, null, value);
+ }
+
+ this._attachIcon(position);
+
+ // If the icon is on top or bottom we need to add the ui-widget-icon-block class and remove
+ // the iconSpace if there is one.
+ if (displayBlock) {
+ this._addClass(this.icon, null, "ui-widget-icon-block");
+ if (this.iconSpace) {
+ this.iconSpace.remove();
+ }
+ } else {
+
+ // Position is beginning or end so remove the ui-widget-icon-block class and add the
+ // space if it does not exist
+ if (!this.iconSpace) {
+ this.iconSpace = $("<span> </span>");
+ this._addClass(this.iconSpace, "ui-button-icon-space");
+ }
+ this._removeClass(this.icon, null, "ui-wiget-icon-block");
+ this._attachIconSpace(position);
+ }
+ },
+
+ _destroy: function () {
+ this.element.removeAttr("role");
+
+ if (this.icon) {
+ this.icon.remove();
+ }
+ if (this.iconSpace) {
+ this.iconSpace.remove();
+ }
+ if (!this.hasTitle) {
+ this.element.removeAttr("title");
+ }
+ },
+
+ _attachIconSpace: function (iconPosition) {
+ this.icon[/^(?:end|bottom)/.test(iconPosition) ? "before" : "after"](this.iconSpace);
+ },
+
+ _attachIcon: function (iconPosition) {
+ this.element[/^(?:end|bottom)/.test(iconPosition) ? "append" : "prepend"](this.icon);
+ },
+
+ _setOptions: function (options) {
+ var newShowLabel = options.showLabel === undefined ?
+ this.options.showLabel :
+ options.showLabel,
+ newIcon = options.icon === undefined ? this.options.icon : options.icon;
+
+ if (!newShowLabel && !newIcon) {
+ options.showLabel = true;
+ }
+ this._super(options);
+ },
+
+ _setOption: function (key, value) {
+ if (key === "icon") {
+ if (value) {
+ this._updateIcon(key, value);
+ } else if (this.icon) {
+ this.icon.remove();
+ if (this.iconSpace) {
+ this.iconSpace.remove();
+ }
+ }
+ }
+
+ if (key === "iconPosition") {
+ this._updateIcon(key, value);
+ }
+
+ // Make sure we can't end up with a button that has neither text nor icon
+ if (key === "showLabel") {
+ this._toggleClass("ui-button-icon-only", null, !value);
+ this._updateTooltip();
+ }
+
+ if (key === "label") {
+ if (this.isInput) {
+ this.element.val(value);
+ } else {
+
+ // If there is an icon, append it, else nothing then append the value
+ // this avoids removal of the icon when setting label text
+ this.element.html(value);
+ if (this.icon) {
+ this._attachIcon(this.options.iconPosition);
+ this._attachIconSpace(this.options.iconPosition);
+ }
+ }
+ }
+
+ this._super(key, value);
+
+ if (key === "disabled") {
+ this._toggleClass(null, "ui-state-disabled", value);
+ this.element[0].disabled = value;
+ if (value) {
+ this.element.blur();
+ }
+ }
+ },
+
+ refresh: function () {
+
+ // Make sure to only check disabled if its an element that supports this otherwise
+ // check for the disabled class to determine state
+ var isDisabled = this.element.is("input, button") ?
+ this.element[0].disabled : this.element.hasClass("ui-button-disabled");
+
+ if (isDisabled !== this.options.disabled) {
+ this._setOptions({ disabled: isDisabled });
+ }
+
+ this._updateTooltip();
+ }
+ });
+
+ // DEPRECATED
+ if ($.uiBackCompat !== false) {
+
+ // Text and Icons options
+ $.widget("ui.button", $.ui.button, {
+ options: {
+ text: true,
+ icons: {
+ primary: null,
+ secondary: null
+ }
+ },
+
+ _create: function () {
+ if (this.options.showLabel && !this.options.text) {
+ this.options.showLabel = this.options.text;
+ }
+ if (!this.options.showLabel && this.options.text) {
+ this.options.text = this.options.showLabel;
+ }
+ if (!this.options.icon && (this.options.icons.primary ||
+ this.options.icons.secondary)) {
+ if (this.options.icons.primary) {
+ this.options.icon = this.options.icons.primary;
+ } else {
+ this.options.icon = this.options.icons.secondary;
+ this.options.iconPosition = "end";
+ }
+ } else if (this.options.icon) {
+ this.options.icons.primary = this.options.icon;
+ }
+ this._super();
+ },
+
+ _setOption: function (key, value) {
+ if (key === "text") {
+ this._super("showLabel", value);
+ return;
+ }
+ if (key === "showLabel") {
+ this.options.text = value;
+ }
+ if (key === "icon") {
+ this.options.icons.primary = value;
+ }
+ if (key === "icons") {
+ if (value.primary) {
+ this._super("icon", value.primary);
+ this._super("iconPosition", "beginning");
+ } else if (value.secondary) {
+ this._super("icon", value.secondary);
+ this._super("iconPosition", "end");
+ }
+ }
+ this._superApply(arguments);
+ }
+ });
+
+ $.fn.button = (function (orig) {
+ return function () {
+ if (!this.length || (this.length && this[0].tagName !== "INPUT") ||
+ (this.length && this[0].tagName === "INPUT" && (
+ this.attr("type") !== "checkbox" && this.attr("type") !== "radio"
+ ))) {
+ return orig.apply(this, arguments);
+ }
+ if (!$.ui.checkboxradio) {
+ $.error("Checkboxradio widget missing");
+ }
+ if (arguments.length === 0) {
+ return this.checkboxradio({
+ "icon": false
+ });
+ }
+ return this.checkboxradio.apply(this, arguments);
+ };
+ })($.fn.button);
+
+ $.fn.buttonset = function () {
+ if (!$.ui.controlgroup) {
+ $.error("Controlgroup widget missing");
+ }
+ if (arguments[0] === "option" && arguments[1] === "items" && arguments[2]) {
+ return this.controlgroup.apply(this,
+ [arguments[0], "items.button", arguments[2]]);
+ }
+ if (arguments[0] === "option" && arguments[1] === "items") {
+ return this.controlgroup.apply(this, [arguments[0], "items.button"]);
+ }
+ if (typeof arguments[0] === "object" && arguments[0].items) {
+ arguments[0].items = {
+ button: arguments[0].items
+ };
+ }
+ return this.controlgroup.apply(this, arguments);
+ };
+ }
+
+ var widgetsButton = $.ui.button;
+
+
+ // jscs:disable maximumLineLength
+ /* jscs:disable requireCamelCaseOrUpperCaseIdentifiers */
+ /*!
+ * jQuery UI Datepicker 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Datepicker
+ //>>group: Widgets
+ //>>description: Displays a calendar from an input or inline for selecting dates.
+ //>>docs: http://api.jqueryui.com/datepicker/
+ //>>demos: http://jqueryui.com/datepicker/
+ //>>css.structure: ../../themes/base/core.css
+ //>>css.structure: ../../themes/base/datepicker.css
+ //>>css.theme: ../../themes/base/theme.css
+
+
+
+ $.extend($.ui, { datepicker: { version: "1.12.1" } });
+
+ var datepicker_instActive;
+
+ function datepicker_getZindex(elem) {
+ var position, value;
+ while (elem.length && elem[0] !== document) {
+
+ // Ignore z-index if position is set to a value where z-index is ignored by the browser
+ // This makes behavior of this function consistent across browsers
+ // WebKit always returns auto if the element is positioned
+ position = elem.css("position");
+ if (position === "absolute" || position === "relative" || position === "fixed") {
+
+ // IE returns 0 when zIndex is not specified
+ // other browsers return a string
+ // we ignore the case of nested elements with an explicit value of 0
+ // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
+ value = parseInt(elem.css("zIndex"), 10);
+ if (!isNaN(value) && value !== 0) {
+ return value;
+ }
+ }
+ elem = elem.parent();
+ }
+
+ return 0;
+ }
+ /* Date picker manager.
+ Use the singleton instance of this class, $.datepicker, to interact with the date picker.
+ Settings for (groups of) date pickers are maintained in an instance object,
+ allowing multiple different settings on the same page. */
+
+ function Datepicker() {
+ this._curInst = null; // The current instance in use
+ this._keyEvent = false; // If the last event was a key event
+ this._disabledInputs = []; // List of date picker inputs that have been disabled
+ this._datepickerShowing = false; // True if the popup picker is showing , false if not
+ this._inDialog = false; // True if showing within a "dialog", false if not
+ this._mainDivId = "ui-datepicker-div"; // The ID of the main datepicker division
+ this._inlineClass = "ui-datepicker-inline"; // The name of the inline marker class
+ this._appendClass = "ui-datepicker-append"; // The name of the append marker class
+ this._triggerClass = "ui-datepicker-trigger"; // The name of the trigger marker class
+ this._dialogClass = "ui-datepicker-dialog"; // The name of the dialog marker class
+ this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class
+ this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class
+ this._currentClass = "ui-datepicker-current-day"; // The name of the current day marker class
+ this._dayOverClass = "ui-datepicker-days-cell-over"; // The name of the day hover marker class
+ this.regional = []; // Available regional settings, indexed by language code
+ this.regional[""] = { // Default regional settings
+ closeText: "Done", // Display text for close link
+ prevText: "Prev", // Display text for previous month link
+ nextText: "Next", // Display text for next month link
+ currentText: "Today", // Display text for current month link
+ monthNames: ["January", "February", "March", "April", "May", "June",
+ "July", "August", "September", "October", "November", "December"], // Names of months for drop-down and formatting
+ monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], // For formatting
+ dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], // For formatting
+ dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], // For formatting
+ dayNamesMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"], // Column headings for days starting at Sunday
+ weekHeader: "Wk", // Column header for week of the year
+ dateFormat: "mm/dd/yy", // See format options on parseDate
+ firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
+ isRTL: false, // True if right-to-left language, false if left-to-right
+ showMonthAfterYear: false, // True if the year select precedes month, false for month then year
+ yearSuffix: "" // Additional text to append to the year in the month headers
+ };
+ this._defaults = { // Global defaults for all the date picker instances
+ showOn: "focus", // "focus" for popup on focus,
+ // "button" for trigger button, or "both" for either
+ showAnim: "fadeIn", // Name of jQuery animation for popup
+ showOptions: {}, // Options for enhanced animations
+ defaultDate: null, // Used when field is blank: actual date,
+ // +/-number for offset from today, null for today
+ appendText: "", // Display text following the input box, e.g. showing the format
+ buttonText: "...", // Text for trigger button
+ buttonImage: "", // URL for trigger button image
+ buttonImageOnly: false, // True if the image appears alone, false if it appears on a button
+ hideIfNoPrevNext: false, // True to hide next/previous month links
+ // if not applicable, false to just disable them
+ navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links
+ gotoCurrent: false, // True if today link goes back to current selection instead
+ changeMonth: false, // True if month can be selected directly, false if only prev/next
+ changeYear: false, // True if year can be selected directly, false if only prev/next
+ yearRange: "c-10:c+10", // Range of years to display in drop-down,
+ // either relative to today's year (-nn:+nn), relative to currently displayed year
+ // (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n)
+ showOtherMonths: false, // True to show dates in other months, false to leave blank
+ selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable
+ showWeek: false, // True to show week of the year, false to not show it
+ calculateWeek: this.iso8601Week, // How to calculate the week of the year,
+ // takes a Date and returns the number of the week for it
+ shortYearCutoff: "+10", // Short year values < this are in the current century,
+ // > this are in the previous century,
+ // string value starting with "+" for current year + value
+ minDate: null, // The earliest selectable date, or null for no limit
+ maxDate: null, // The latest selectable date, or null for no limit
+ duration: "fast", // Duration of display/closure
+ beforeShowDay: null, // Function that takes a date and returns an array with
+ // [0] = true if selectable, false if not, [1] = custom CSS class name(s) or "",
+ // [2] = cell title (optional), e.g. $.datepicker.noWeekends
+ beforeShow: null, // Function that takes an input field and
+ // returns a set of custom settings for the date picker
+ onSelect: null, // Define a callback function when a date is selected
+ onChangeMonthYear: null, // Define a callback function when the month or year is changed
+ onClose: null, // Define a callback function when the datepicker is closed
+ numberOfMonths: 1, // Number of months to show at a time
+ showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0)
+ stepMonths: 1, // Number of months to step back/forward
+ stepBigMonths: 12, // Number of months to step back/forward for the big links
+ altField: "", // Selector for an alternate field to store selected dates into
+ altFormat: "", // The date format to use for the alternate field
+ constrainInput: true, // The input is constrained by the current date format
+ showButtonPanel: false, // True to show button panel, false to not show it
+ autoSize: false, // True to size the input for the date format, false to leave as is
+ disabled: false // The initial disabled state
+ };
+ $.extend(this._defaults, this.regional[""]);
+ this.regional.en = $.extend(true, {}, this.regional[""]);
+ this.regional["en-US"] = $.extend(true, {}, this.regional.en);
+ this.dpDiv = datepicker_bindHover($("<div id='" + this._mainDivId + "' class='ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>"));
+ }
+
+ $.extend(Datepicker.prototype, {
+ /* Class name added to elements to indicate already configured with a date picker. */
+ markerClassName: "hasDatepicker",
+
+ //Keep track of the maximum number of rows displayed (see #7043)
+ maxRows: 4,
+
+ // TODO rename to "widget" when switching to widget factory
+ _widgetDatepicker: function () {
+ return this.dpDiv;
+ },
+
+ /* Override the default settings for all instances of the date picker.
+ * @param settings object - the new settings to use as defaults (anonymous object)
+ * @return the manager object
+ */
+ setDefaults: function (settings) {
+ datepicker_extendRemove(this._defaults, settings || {});
+ return this;
+ },
+
+ /* Attach the date picker to a jQuery selection.
+ * @param target element - the target input field or division or span
+ * @param settings object - the new settings to use for this date picker instance (anonymous)
+ */
+ _attachDatepicker: function (target, settings) {
+ var nodeName, inline, inst;
+ nodeName = target.nodeName.toLowerCase();
+ inline = (nodeName === "div" || nodeName === "span");
+ if (!target.id) {
+ this.uuid += 1;
+ target.id = "dp" + this.uuid;
+ }
+ inst = this._newInst($(target), inline);
+ inst.settings = $.extend({}, settings || {});
+ if (nodeName === "input") {
+ this._connectDatepicker(target, inst);
+ } else if (inline) {
+ this._inlineDatepicker(target, inst);
+ }
+ },
+
+ /* Create a new instance object. */
+ _newInst: function (target, inline) {
+ var id = target[0].id.replace(/([^A-Za-z0-9_\-])/g, "\\\\$1"); // escape jQuery meta chars
+ return {
+ id: id, input: target, // associated target
+ selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection
+ drawMonth: 0, drawYear: 0, // month being drawn
+ inline: inline, // is datepicker inline or not
+ dpDiv: (!inline ? this.dpDiv : // presentation div
+ datepicker_bindHover($("<div class='" + this._inlineClass + " ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>")))
+ };
+ },
+
+ /* Attach the date picker to an input field. */
+ _connectDatepicker: function (target, inst) {
+ var input = $(target);
+ inst.append = $([]);
+ inst.trigger = $([]);
+ if (input.hasClass(this.markerClassName)) {
+ return;
+ }
+ this._attachments(input, inst);
+ input.addClass(this.markerClassName).on("keydown", this._doKeyDown).
+ on("keypress", this._doKeyPress).on("keyup", this._doKeyUp);
+ this._autoSize(inst);
+ $.data(target, "datepicker", inst);
+
+ //If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665)
+ if (inst.settings.disabled) {
+ this._disableDatepicker(target);
+ }
+ },
+
+ /* Make attachments based on settings. */
+ _attachments: function (input, inst) {
+ var showOn, buttonText, buttonImage,
+ appendText = this._get(inst, "appendText"),
+ isRTL = this._get(inst, "isRTL");
+
+ if (inst.append) {
+ inst.append.remove();
+ }
+ if (appendText) {
+ inst.append = $("<span class='" + this._appendClass + "'>" + appendText + "</span>");
+ input[isRTL ? "before" : "after"](inst.append);
+ }
+
+ input.off("focus", this._showDatepicker);
+
+ if (inst.trigger) {
+ inst.trigger.remove();
+ }
+
+ showOn = this._get(inst, "showOn");
+ if (showOn === "focus" || showOn === "both") { // pop-up date picker when in the marked field
+ input.on("focus", this._showDatepicker);
+ }
+ if (showOn === "button" || showOn === "both") { // pop-up date picker when button clicked
+ buttonText = this._get(inst, "buttonText");
+ buttonImage = this._get(inst, "buttonImage");
+ inst.trigger = $(this._get(inst, "buttonImageOnly") ?
+ $("<img/>").addClass(this._triggerClass).
+ attr({ src: buttonImage, alt: buttonText, title: buttonText }) :
+ $("<button type='button'></button>").addClass(this._triggerClass).
+ html(!buttonImage ? buttonText : $("<img/>").attr(
+ { src: buttonImage, alt: buttonText, title: buttonText })));
+ input[isRTL ? "before" : "after"](inst.trigger);
+ inst.trigger.on("click", function () {
+ if ($.datepicker._datepickerShowing && $.datepicker._lastInput === input[0]) {
+ $.datepicker._hideDatepicker();
+ } else if ($.datepicker._datepickerShowing && $.datepicker._lastInput !== input[0]) {
+ $.datepicker._hideDatepicker();
+ $.datepicker._showDatepicker(input[0]);
+ } else {
+ $.datepicker._showDatepicker(input[0]);
+ }
+ return false;
+ });
+ }
+ },
+
+ /* Apply the maximum length for the date format. */
+ _autoSize: function (inst) {
+ if (this._get(inst, "autoSize") && !inst.inline) {
+ var findMax, max, maxI, i,
+ date = new Date(2009, 12 - 1, 20), // Ensure double digits
+ dateFormat = this._get(inst, "dateFormat");
+
+ if (dateFormat.match(/[DM]/)) {
+ findMax = function (names) {
+ max = 0;
+ maxI = 0;
+ for (i = 0; i < names.length; i++) {
+ if (names[i].length > max) {
+ max = names[i].length;
+ maxI = i;
+ }
+ }
+ return maxI;
+ };
+ date.setMonth(findMax(this._get(inst, (dateFormat.match(/MM/) ?
+ "monthNames" : "monthNamesShort"))));
+ date.setDate(findMax(this._get(inst, (dateFormat.match(/DD/) ?
+ "dayNames" : "dayNamesShort"))) + 20 - date.getDay());
+ }
+ inst.input.attr("size", this._formatDate(inst, date).length);
+ }
+ },
+
+ /* Attach an inline date picker to a div. */
+ _inlineDatepicker: function (target, inst) {
+ var divSpan = $(target);
+ if (divSpan.hasClass(this.markerClassName)) {
+ return;
+ }
+ divSpan.addClass(this.markerClassName).append(inst.dpDiv);
+ $.data(target, "datepicker", inst);
+ this._setDate(inst, this._getDefaultDate(inst), true);
+ this._updateDatepicker(inst);
+ this._updateAlternate(inst);
+
+ //If disabled option is true, disable the datepicker before showing it (see ticket #5665)
+ if (inst.settings.disabled) {
+ this._disableDatepicker(target);
+ }
+
+ // Set display:block in place of inst.dpDiv.show() which won't work on disconnected elements
+ // http://bugs.jqueryui.com/ticket/7552 - A Datepicker created on a detached div has zero height
+ inst.dpDiv.css("display", "block");
+ },
+
+ /* Pop-up the date picker in a "dialog" box.
+ * @param input element - ignored
+ * @param date string or Date - the initial date to display
+ * @param onSelect function - the function to call when a date is selected
+ * @param settings object - update the dialog date picker instance's settings (anonymous object)
+ * @param pos int[2] - coordinates for the dialog's position within the screen or
+ * event - with x/y coordinates or
+ * leave empty for default (screen centre)
+ * @return the manager object
+ */
+ _dialogDatepicker: function (input, date, onSelect, settings, pos) {
+ var id, browserWidth, browserHeight, scrollX, scrollY,
+ inst = this._dialogInst; // internal instance
+
+ if (!inst) {
+ this.uuid += 1;
+ id = "dp" + this.uuid;
+ this._dialogInput = $("<input type='text' id='" + id +
+ "' style='position: absolute; top: -100px; width: 0px;'/>");
+ this._dialogInput.on("keydown", this._doKeyDown);
+ $("body").append(this._dialogInput);
+ inst = this._dialogInst = this._newInst(this._dialogInput, false);
+ inst.settings = {};
+ $.data(this._dialogInput[0], "datepicker", inst);
+ }
+ datepicker_extendRemove(inst.settings, settings || {});
+ date = (date && date.constructor === Date ? this._formatDate(inst, date) : date);
+ this._dialogInput.val(date);
+
+ this._pos = (pos ? (pos.length ? pos : [pos.pageX, pos.pageY]) : null);
+ if (!this._pos) {
+ browserWidth = document.documentElement.clientWidth;
+ browserHeight = document.documentElement.clientHeight;
+ scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
+ scrollY = document.documentElement.scrollTop || document.body.scrollTop;
+ this._pos = // should use actual width/height below
+ [(browserWidth / 2) - 100 + scrollX, (browserHeight / 2) - 150 + scrollY];
+ }
+
+ // Move input on screen for focus, but hidden behind dialog
+ this._dialogInput.css("left", (this._pos[0] + 20) + "px").css("top", this._pos[1] + "px");
+ inst.settings.onSelect = onSelect;
+ this._inDialog = true;
+ this.dpDiv.addClass(this._dialogClass);
+ this._showDatepicker(this._dialogInput[0]);
+ if ($.blockUI) {
+ $.blockUI(this.dpDiv);
+ }
+ $.data(this._dialogInput[0], "datepicker", inst);
+ return this;
+ },
+
+ /* Detach a datepicker from its control.
+ * @param target element - the target input field or division or span
+ */
+ _destroyDatepicker: function (target) {
+ var nodeName,
+ $target = $(target),
+ inst = $.data(target, "datepicker");
+
+ if (!$target.hasClass(this.markerClassName)) {
+ return;
+ }
+
+ nodeName = target.nodeName.toLowerCase();
+ $.removeData(target, "datepicker");
+ if (nodeName === "input") {
+ inst.append.remove();
+ inst.trigger.remove();
+ $target.removeClass(this.markerClassName).
+ off("focus", this._showDatepicker).
+ off("keydown", this._doKeyDown).
+ off("keypress", this._doKeyPress).
+ off("keyup", this._doKeyUp);
+ } else if (nodeName === "div" || nodeName === "span") {
+ $target.removeClass(this.markerClassName).empty();
+ }
+
+ if (datepicker_instActive === inst) {
+ datepicker_instActive = null;
+ }
+ },
+
+ /* Enable the date picker to a jQuery selection.
+ * @param target element - the target input field or division or span
+ */
+ _enableDatepicker: function (target) {
+ var nodeName, inline,
+ $target = $(target),
+ inst = $.data(target, "datepicker");
+
+ if (!$target.hasClass(this.markerClassName)) {
+ return;
+ }
+
+ nodeName = target.nodeName.toLowerCase();
+ if (nodeName === "input") {
+ target.disabled = false;
+ inst.trigger.filter("button").
+ each(function () { this.disabled = false; }).end().
+ filter("img").css({ opacity: "1.0", cursor: "" });
+ } else if (nodeName === "div" || nodeName === "span") {
+ inline = $target.children("." + this._inlineClass);
+ inline.children().removeClass("ui-state-disabled");
+ inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
+ prop("disabled", false);
+ }
+ this._disabledInputs = $.map(this._disabledInputs,
+ function (value) { return (value === target ? null : value); }); // delete entry
+ },
+
+ /* Disable the date picker to a jQuery selection.
+ * @param target element - the target input field or division or span
+ */
+ _disableDatepicker: function (target) {
+ var nodeName, inline,
+ $target = $(target),
+ inst = $.data(target, "datepicker");
+
+ if (!$target.hasClass(this.markerClassName)) {
+ return;
+ }
+
+ nodeName = target.nodeName.toLowerCase();
+ if (nodeName === "input") {
+ target.disabled = true;
+ inst.trigger.filter("button").
+ each(function () { this.disabled = true; }).end().
+ filter("img").css({ opacity: "0.5", cursor: "default" });
+ } else if (nodeName === "div" || nodeName === "span") {
+ inline = $target.children("." + this._inlineClass);
+ inline.children().addClass("ui-state-disabled");
+ inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
+ prop("disabled", true);
+ }
+ this._disabledInputs = $.map(this._disabledInputs,
+ function (value) { return (value === target ? null : value); }); // delete entry
+ this._disabledInputs[this._disabledInputs.length] = target;
+ },
+
+ /* Is the first field in a jQuery collection disabled as a datepicker?
+ * @param target element - the target input field or division or span
+ * @return boolean - true if disabled, false if enabled
+ */
+ _isDisabledDatepicker: function (target) {
+ if (!target) {
+ return false;
+ }
+ for (var i = 0; i < this._disabledInputs.length; i++) {
+ if (this._disabledInputs[i] === target) {
+ return true;
+ }
+ }
+ return false;
+ },
+
+ /* Retrieve the instance data for the target control.
+ * @param target element - the target input field or division or span
+ * @return object - the associated instance data
+ * @throws error if a jQuery problem getting data
+ */
+ _getInst: function (target) {
+ try {
+ return $.data(target, "datepicker");
+ }
+ catch (err) {
+ throw "Missing instance data for this datepicker";
+ }
+ },
+
+ /* Update or retrieve the settings for a date picker attached to an input field or division.
+ * @param target element - the target input field or division or span
+ * @param name object - the new settings to update or
+ * string - the name of the setting to change or retrieve,
+ * when retrieving also "all" for all instance settings or
+ * "defaults" for all global defaults
+ * @param value any - the new value for the setting
+ * (omit if above is an object or to retrieve a value)
+ */
+ _optionDatepicker: function (target, name, value) {
+ var settings, date, minDate, maxDate,
+ inst = this._getInst(target);
+
+ if (arguments.length === 2 && typeof name === "string") {
+ return (name === "defaults" ? $.extend({}, $.datepicker._defaults) :
+ (inst ? (name === "all" ? $.extend({}, inst.settings) :
+ this._get(inst, name)) : null));
+ }
+
+ settings = name || {};
+ if (typeof name === "string") {
+ settings = {};
+ settings[name] = value;
+ }
+
+ if (inst) {
+ if (this._curInst === inst) {
+ this._hideDatepicker();
+ }
+
+ date = this._getDateDatepicker(target, true);
+ minDate = this._getMinMaxDate(inst, "min");
+ maxDate = this._getMinMaxDate(inst, "max");
+ datepicker_extendRemove(inst.settings, settings);
+
+ // reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided
+ if (minDate !== null && settings.dateFormat !== undefined && settings.minDate === undefined) {
+ inst.settings.minDate = this._formatDate(inst, minDate);
+ }
+ if (maxDate !== null && settings.dateFormat !== undefined && settings.maxDate === undefined) {
+ inst.settings.maxDate = this._formatDate(inst, maxDate);
+ }
+ if ("disabled" in settings) {
+ if (settings.disabled) {
+ this._disableDatepicker(target);
+ } else {
+ this._enableDatepicker(target);
+ }
+ }
+ this._attachments($(target), inst);
+ this._autoSize(inst);
+ this._setDate(inst, date);
+ this._updateAlternate(inst);
+ this._updateDatepicker(inst);
+ }
+ },
+
+ // Change method deprecated
+ _changeDatepicker: function (target, name, value) {
+ this._optionDatepicker(target, name, value);
+ },
+
+ /* Redraw the date picker attached to an input field or division.
+ * @param target element - the target input field or division or span
+ */
+ _refreshDatepicker: function (target) {
+ var inst = this._getInst(target);
+ if (inst) {
+ this._updateDatepicker(inst);
+ }
+ },
+
+ /* Set the dates for a jQuery selection.
+ * @param target element - the target input field or division or span
+ * @param date Date - the new date
+ */
+ _setDateDatepicker: function (target, date) {
+ var inst = this._getInst(target);
+ if (inst) {
+ this._setDate(inst, date);
+ this._updateDatepicker(inst);
+ this._updateAlternate(inst);
+ }
+ },
+
+ /* Get the date(s) for the first entry in a jQuery selection.
+ * @param target element - the target input field or division or span
+ * @param noDefault boolean - true if no default date is to be used
+ * @return Date - the current date
+ */
+ _getDateDatepicker: function (target, noDefault) {
+ var inst = this._getInst(target);
+ if (inst && !inst.inline) {
+ this._setDateFromField(inst, noDefault);
+ }
+ return (inst ? this._getDate(inst) : null);
+ },
+
+ /* Handle keystrokes. */
+ _doKeyDown: function (event) {
+ var onSelect, dateStr, sel,
+ inst = $.datepicker._getInst(event.target),
+ handled = true,
+ isRTL = inst.dpDiv.is(".ui-datepicker-rtl");
+
+ inst._keyEvent = true;
+ if ($.datepicker._datepickerShowing) {
+ switch (event.keyCode) {
+ case 9: $.datepicker._hideDatepicker();
+ handled = false;
+ break; // hide on tab out
+ case 13: sel = $("td." + $.datepicker._dayOverClass + ":not(." +
+ $.datepicker._currentClass + ")", inst.dpDiv);
+ if (sel[0]) {
+ $.datepicker._selectDay(event.target, inst.selectedMonth, inst.selectedYear, sel[0]);
+ }
+
+ onSelect = $.datepicker._get(inst, "onSelect");
+ if (onSelect) {
+ dateStr = $.datepicker._formatDate(inst);
+
+ // Trigger custom callback
+ onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);
+ } else {
+ $.datepicker._hideDatepicker();
+ }
+
+ return false; // don't submit the form
+ case 27: $.datepicker._hideDatepicker();
+ break; // hide on escape
+ case 33: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
+ -$.datepicker._get(inst, "stepBigMonths") :
+ -$.datepicker._get(inst, "stepMonths")), "M");
+ break; // previous month/year on page up/+ ctrl
+ case 34: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
+ +$.datepicker._get(inst, "stepBigMonths") :
+ +$.datepicker._get(inst, "stepMonths")), "M");
+ break; // next month/year on page down/+ ctrl
+ case 35: if (event.ctrlKey || event.metaKey) {
+ $.datepicker._clearDate(event.target);
+ }
+ handled = event.ctrlKey || event.metaKey;
+ break; // clear on ctrl or command +end
+ case 36: if (event.ctrlKey || event.metaKey) {
+ $.datepicker._gotoToday(event.target);
+ }
+ handled = event.ctrlKey || event.metaKey;
+ break; // current on ctrl or command +home
+ case 37: if (event.ctrlKey || event.metaKey) {
+ $.datepicker._adjustDate(event.target, (isRTL ? +1 : -1), "D");
+ }
+ handled = event.ctrlKey || event.metaKey;
+
+ // -1 day on ctrl or command +left
+ if (event.originalEvent.altKey) {
+ $.datepicker._adjustDate(event.target, (event.ctrlKey ?
+ -$.datepicker._get(inst, "stepBigMonths") :
+ -$.datepicker._get(inst, "stepMonths")), "M");
+ }
+
+ // next month/year on alt +left on Mac
+ break;
+ case 38: if (event.ctrlKey || event.metaKey) {
+ $.datepicker._adjustDate(event.target, -7, "D");
+ }
+ handled = event.ctrlKey || event.metaKey;
+ break; // -1 week on ctrl or command +up
+ case 39: if (event.ctrlKey || event.metaKey) {
+ $.datepicker._adjustDate(event.target, (isRTL ? -1 : +1), "D");
+ }
+ handled = event.ctrlKey || event.metaKey;
+
+ // +1 day on ctrl or command +right
+ if (event.originalEvent.altKey) {
+ $.datepicker._adjustDate(event.target, (event.ctrlKey ?
+ +$.datepicker._get(inst, "stepBigMonths") :
+ +$.datepicker._get(inst, "stepMonths")), "M");
+ }
+
+ // next month/year on alt +right
+ break;
+ case 40: if (event.ctrlKey || event.metaKey) {
+ $.datepicker._adjustDate(event.target, +7, "D");
+ }
+ handled = event.ctrlKey || event.metaKey;
+ break; // +1 week on ctrl or command +down
+ default: handled = false;
+ }
+ } else if (event.keyCode === 36 && event.ctrlKey) { // display the date picker on ctrl+home
+ $.datepicker._showDatepicker(this);
+ } else {
+ handled = false;
+ }
+
+ if (handled) {
+ event.preventDefault();
+ event.stopPropagation();
+ }
+ },
+
+ /* Filter entered characters - based on date format. */
+ _doKeyPress: function (event) {
+ var chars, chr,
+ inst = $.datepicker._getInst(event.target);
+
+ if ($.datepicker._get(inst, "constrainInput")) {
+ chars = $.datepicker._possibleChars($.datepicker._get(inst, "dateFormat"));
+ chr = String.fromCharCode(event.charCode == null ? event.keyCode : event.charCode);
+ return event.ctrlKey || event.metaKey || (chr < " " || !chars || chars.indexOf(chr) > -1);
+ }
+ },
+
+ /* Synchronise manual entry and field/alternate field. */
+ _doKeyUp: function (event) {
+ var date,
+ inst = $.datepicker._getInst(event.target);
+
+ if (inst.input.val() !== inst.lastVal) {
+ try {
+ date = $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
+ (inst.input ? inst.input.val() : null),
+ $.datepicker._getFormatConfig(inst));
+
+ if (date) { // only if valid
+ $.datepicker._setDateFromField(inst);
+ $.datepicker._updateAlternate(inst);
+ $.datepicker._updateDatepicker(inst);
+ }
+ }
+ catch (err) {
+ }
+ }
+ return true;
+ },
+
+ /* Pop-up the date picker for a given input field.
+ * If false returned from beforeShow event handler do not show.
+ * @param input element - the input field attached to the date picker or
+ * event - if triggered by focus
+ */
+ _showDatepicker: function (input) {
+ input = input.target || input;
+ if (input.nodeName.toLowerCase() !== "input") { // find from button/image trigger
+ input = $("input", input.parentNode)[0];
+ }
+
+ if ($.datepicker._isDisabledDatepicker(input) || $.datepicker._lastInput === input) { // already here
+ return;
+ }
+
+ var inst, beforeShow, beforeShowSettings, isFixed,
+ offset, showAnim, duration;
+
+ inst = $.datepicker._getInst(input);
+ if ($.datepicker._curInst && $.datepicker._curInst !== inst) {
+ $.datepicker._curInst.dpDiv.stop(true, true);
+ if (inst && $.datepicker._datepickerShowing) {
+ $.datepicker._hideDatepicker($.datepicker._curInst.input[0]);
+ }
+ }
+
+ beforeShow = $.datepicker._get(inst, "beforeShow");
+ beforeShowSettings = beforeShow ? beforeShow.apply(input, [input, inst]) : {};
+ if (beforeShowSettings === false) {
+ return;
+ }
+ datepicker_extendRemove(inst.settings, beforeShowSettings);
+
+ inst.lastVal = null;
+ $.datepicker._lastInput = input;
+ $.datepicker._setDateFromField(inst);
+
+ if ($.datepicker._inDialog) { // hide cursor
+ input.value = "";
+ }
+ if (!$.datepicker._pos) { // position below input
+ $.datepicker._pos = $.datepicker._findPos(input);
+ $.datepicker._pos[1] += input.offsetHeight; // add the height
+ }
+
+ isFixed = false;
+ $(input).parents().each(function () {
+ isFixed |= $(this).css("position") === "fixed";
+ return !isFixed;
+ });
+
+ offset = { left: $.datepicker._pos[0], top: $.datepicker._pos[1] };
+ $.datepicker._pos = null;
+
+ //to avoid flashes on Firefox
+ inst.dpDiv.empty();
+
+ // determine sizing offscreen
+ inst.dpDiv.css({ position: "absolute", display: "block", top: "-1000px" });
+ $.datepicker._updateDatepicker(inst);
+
+ // fix width for dynamic number of date pickers
+ // and adjust position before showing
+ offset = $.datepicker._checkOffset(inst, offset, isFixed);
+ inst.dpDiv.css({
+ position: ($.datepicker._inDialog && $.blockUI ?
+ "static" : (isFixed ? "fixed" : "absolute")), display: "none",
+ left: offset.left + "px", top: offset.top + "px"
+ });
+
+ if (!inst.inline) {
+ showAnim = $.datepicker._get(inst, "showAnim");
+ duration = $.datepicker._get(inst, "duration");
+ inst.dpDiv.css("z-index", datepicker_getZindex($(input)) + 1);
+ $.datepicker._datepickerShowing = true;
+
+ if ($.effects && $.effects.effect[showAnim]) {
+ inst.dpDiv.show(showAnim, $.datepicker._get(inst, "showOptions"), duration);
+ } else {
+ inst.dpDiv[showAnim || "show"](showAnim ? duration : null);
+ }
+
+ if ($.datepicker._shouldFocusInput(inst)) {
+ inst.input.trigger("focus");
+ }
+
+ $.datepicker._curInst = inst;
+ }
+ },
+
+ /* Generate the date picker content. */
+ _updateDatepicker: function (inst) {
+ this.maxRows = 4; //Reset the max number of rows being displayed (see #7043)
+ datepicker_instActive = inst; // for delegate hover events
+ inst.dpDiv.empty().append(this._generateHTML(inst));
+ this._attachHandlers(inst);
+
+ var origyearshtml,
+ numMonths = this._getNumberOfMonths(inst),
+ cols = numMonths[1],
+ width = 17,
+ activeCell = inst.dpDiv.find("." + this._dayOverClass + " a");
+
+ if (activeCell.length > 0) {
+ datepicker_handleMouseover.apply(activeCell.get(0));
+ }
+
+ inst.dpDiv.removeClass("ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4").width("");
+ if (cols > 1) {
+ inst.dpDiv.addClass("ui-datepicker-multi-" + cols).css("width", (width * cols) + "em");
+ }
+ inst.dpDiv[(numMonths[0] !== 1 || numMonths[1] !== 1 ? "add" : "remove") +
+ "Class"]("ui-datepicker-multi");
+ inst.dpDiv[(this._get(inst, "isRTL") ? "add" : "remove") +
+ "Class"]("ui-datepicker-rtl");
+
+ if (inst === $.datepicker._curInst && $.datepicker._datepickerShowing && $.datepicker._shouldFocusInput(inst)) {
+ inst.input.trigger("focus");
+ }
+
+ // Deffered render of the years select (to avoid flashes on Firefox)
+ if (inst.yearshtml) {
+ origyearshtml = inst.yearshtml;
+ setTimeout(function () {
+
+ //assure that inst.yearshtml didn't change.
+ if (origyearshtml === inst.yearshtml && inst.yearshtml) {
+ inst.dpDiv.find("select.ui-datepicker-year:first").replaceWith(inst.yearshtml);
+ }
+ origyearshtml = inst.yearshtml = null;
+ }, 0);
+ }
+ },
+
+ // #6694 - don't focus the input if it's already focused
+ // this breaks the change event in IE
+ // Support: IE and jQuery <1.9
+ _shouldFocusInput: function (inst) {
+ return inst.input && inst.input.is(":visible") && !inst.input.is(":disabled") && !inst.input.is(":focus");
+ },
+
+ /* Check positioning to remain on screen. */
+ _checkOffset: function (inst, offset, isFixed) {
+ var dpWidth = inst.dpDiv.outerWidth(),
+ dpHeight = inst.dpDiv.outerHeight(),
+ inputWidth = inst.input ? inst.input.outerWidth() : 0,
+ inputHeight = inst.input ? inst.input.outerHeight() : 0,
+ viewWidth = document.documentElement.clientWidth + (isFixed ? 0 : $(document).scrollLeft()),
+ viewHeight = document.documentElement.clientHeight + (isFixed ? 0 : $(document).scrollTop());
+
+ offset.left -= (this._get(inst, "isRTL") ? (dpWidth - inputWidth) : 0);
+ offset.left -= (isFixed && offset.left === inst.input.offset().left) ? $(document).scrollLeft() : 0;
+ offset.top -= (isFixed && offset.top === (inst.input.offset().top + inputHeight)) ? $(document).scrollTop() : 0;
+
+ // Now check if datepicker is showing outside window viewport - move to a better place if so.
+ offset.left -= Math.min(offset.left, (offset.left + dpWidth > viewWidth && viewWidth > dpWidth) ?
+ Math.abs(offset.left + dpWidth - viewWidth) : 0);
+ offset.top -= Math.min(offset.top, (offset.top + dpHeight > viewHeight && viewHeight > dpHeight) ?
+ Math.abs(dpHeight + inputHeight) : 0);
+
+ return offset;
+ },
+
+ /* Find an object's position on the screen. */
+ _findPos: function (obj) {
+ var position,
+ inst = this._getInst(obj),
+ isRTL = this._get(inst, "isRTL");
+
+ while (obj && (obj.type === "hidden" || obj.nodeType !== 1 || $.expr.filters.hidden(obj))) {
+ obj = obj[isRTL ? "previousSibling" : "nextSibling"];
+ }
+
+ position = $(obj).offset();
+ return [position.left, position.top];
+ },
+
+ /* Hide the date picker from view.
+ * @param input element - the input field attached to the date picker
+ */
+ _hideDatepicker: function (input) {
+ var showAnim, duration, postProcess, onClose,
+ inst = this._curInst;
+
+ if (!inst || (input && inst !== $.data(input, "datepicker"))) {
+ return;
+ }
+
+ if (this._datepickerShowing) {
+ showAnim = this._get(inst, "showAnim");
+ duration = this._get(inst, "duration");
+ postProcess = function () {
+ $.datepicker._tidyDialog(inst);
+ };
+
+ // DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed
+ if ($.effects && ($.effects.effect[showAnim] || $.effects[showAnim])) {
+ inst.dpDiv.hide(showAnim, $.datepicker._get(inst, "showOptions"), duration, postProcess);
+ } else {
+ inst.dpDiv[(showAnim === "slideDown" ? "slideUp" :
+ (showAnim === "fadeIn" ? "fadeOut" : "hide"))]((showAnim ? duration : null), postProcess);
+ }
+
+ if (!showAnim) {
+ postProcess();
+ }
+ this._datepickerShowing = false;
+
+ onClose = this._get(inst, "onClose");
+ if (onClose) {
+ onClose.apply((inst.input ? inst.input[0] : null), [(inst.input ? inst.input.val() : ""), inst]);
+ }
+
+ this._lastInput = null;
+ if (this._inDialog) {
+ this._dialogInput.css({ position: "absolute", left: "0", top: "-100px" });
+ if ($.blockUI) {
+ $.unblockUI();
+ $("body").append(this.dpDiv);
+ }
+ }
+ this._inDialog = false;
+ }
+ },
+
+ /* Tidy up after a dialog display. */
+ _tidyDialog: function (inst) {
+ inst.dpDiv.removeClass(this._dialogClass).off(".ui-datepicker-calendar");
+ },
+
+ /* Close date picker if clicked elsewhere. */
+ _checkExternalClick: function (event) {
+ if (!$.datepicker._curInst) {
+ return;
+ }
+
+ var $target = $(event.target),
+ inst = $.datepicker._getInst($target[0]);
+
+ if ((($target[0].id !== $.datepicker._mainDivId &&
+ $target.parents("#" + $.datepicker._mainDivId).length === 0 &&
+ !$target.hasClass($.datepicker.markerClassName) &&
+ !$target.closest("." + $.datepicker._triggerClass).length &&
+ $.datepicker._datepickerShowing && !($.datepicker._inDialog && $.blockUI))) ||
+ ($target.hasClass($.datepicker.markerClassName) && $.datepicker._curInst !== inst)) {
+ $.datepicker._hideDatepicker();
+ }
+ },
+
+ /* Adjust one of the date sub-fields. */
+ _adjustDate: function (id, offset, period) {
+ var target = $(id),
+ inst = this._getInst(target[0]);
+
+ if (this._isDisabledDatepicker(target[0])) {
+ return;
+ }
+ this._adjustInstDate(inst, offset +
+ (period === "M" ? this._get(inst, "showCurrentAtPos") : 0), // undo positioning
+ period);
+ this._updateDatepicker(inst);
+ },
+
+ /* Action for current link. */
+ _gotoToday: function (id) {
+ var date,
+ target = $(id),
+ inst = this._getInst(target[0]);
+
+ if (this._get(inst, "gotoCurrent") && inst.currentDay) {
+ inst.selectedDay = inst.currentDay;
+ inst.drawMonth = inst.selectedMonth = inst.currentMonth;
+ inst.drawYear = inst.selectedYear = inst.currentYear;
+ } else {
+ date = new Date();
+ inst.selectedDay = date.getDate();
+ inst.drawMonth = inst.selectedMonth = date.getMonth();
+ inst.drawYear = inst.selectedYear = date.getFullYear();
+ }
+ this._notifyChange(inst);
+ this._adjustDate(target);
+ },
+
+ /* Action for selecting a new month/year. */
+ _selectMonthYear: function (id, select, period) {
+ var target = $(id),
+ inst = this._getInst(target[0]);
+
+ inst["selected" + (period === "M" ? "Month" : "Year")] =
+ inst["draw" + (period === "M" ? "Month" : "Year")] =
+ parseInt(select.options[select.selectedIndex].value, 10);
+
+ this._notifyChange(inst);
+ this._adjustDate(target);
+ },
+
+ /* Action for selecting a day. */
+ _selectDay: function (id, month, year, td) {
+ var inst,
+ target = $(id);
+
+ if ($(td).hasClass(this._unselectableClass) || this._isDisabledDatepicker(target[0])) {
+ return;
+ }
+
+ inst = this._getInst(target[0]);
+ inst.selectedDay = inst.currentDay = $("a", td).html();
+ inst.selectedMonth = inst.currentMonth = month;
+ inst.selectedYear = inst.currentYear = year;
+ this._selectDate(id, this._formatDate(inst,
+ inst.currentDay, inst.currentMonth, inst.currentYear));
+ },
+
+ /* Erase the input field and hide the date picker. */
+ _clearDate: function (id) {
+ var target = $(id);
+ this._selectDate(target, "");
+ },
+
+ /* Update the input field with the selected date. */
+ _selectDate: function (id, dateStr) {
+ var onSelect,
+ target = $(id),
+ inst = this._getInst(target[0]);
+
+ dateStr = (dateStr != null ? dateStr : this._formatDate(inst));
+ if (inst.input) {
+ inst.input.val(dateStr);
+ }
+ this._updateAlternate(inst);
+
+ onSelect = this._get(inst, "onSelect");
+ if (onSelect) {
+ onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]); // trigger custom callback
+ } else if (inst.input) {
+ inst.input.trigger("change"); // fire the change event
+ }
+
+ if (inst.inline) {
+ this._updateDatepicker(inst);
+ } else {
+ this._hideDatepicker();
+ this._lastInput = inst.input[0];
+ if (typeof (inst.input[0]) !== "object") {
+ inst.input.trigger("focus"); // restore focus
+ }
+ this._lastInput = null;
+ }
+ },
+
+ /* Update any alternate field to synchronise with the main field. */
+ _updateAlternate: function (inst) {
+ var altFormat, date, dateStr,
+ altField = this._get(inst, "altField");
+
+ if (altField) { // update alternate field too
+ altFormat = this._get(inst, "altFormat") || this._get(inst, "dateFormat");
+ date = this._getDate(inst);
+ dateStr = this.formatDate(altFormat, date, this._getFormatConfig(inst));
+ $(altField).val(dateStr);
+ }
+ },
+
+ /* Set as beforeShowDay function to prevent selection of weekends.
+ * @param date Date - the date to customise
+ * @return [boolean, string] - is this date selectable?, what is its CSS class?
+ */
+ noWeekends: function (date) {
+ var day = date.getDay();
+ return [(day > 0 && day < 6), ""];
+ },
+
+ /* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
+ * @param date Date - the date to get the week for
+ * @return number - the number of the week within the year that contains this date
+ */
+ iso8601Week: function (date) {
+ var time,
+ checkDate = new Date(date.getTime());
+
+ // Find Thursday of this week starting on Monday
+ checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
+
+ time = checkDate.getTime();
+ checkDate.setMonth(0); // Compare with Jan 1
+ checkDate.setDate(1);
+ return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
+ },
+
+ /* Parse a string value into a date object.
+ * See formatDate below for the possible formats.
+ *
+ * @param format string - the expected format of the date
+ * @param value string - the date in the above format
+ * @param settings Object - attributes include:
+ * shortYearCutoff number - the cutoff year for determining the century (optional)
+ * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
+ * dayNames string[7] - names of the days from Sunday (optional)
+ * monthNamesShort string[12] - abbreviated names of the months (optional)
+ * monthNames string[12] - names of the months (optional)
+ * @return Date - the extracted date value or null if value is blank
+ */
+ parseDate: function (format, value, settings) {
+ if (format == null || value == null) {
+ throw "Invalid arguments";
+ }
+
+ value = (typeof value === "object" ? value.toString() : value + "");
+ if (value === "") {
+ return null;
+ }
+
+ var iFormat, dim, extra,
+ iValue = 0,
+ shortYearCutoffTemp = (settings ? settings.shortYearCutoff : null) || this._defaults.shortYearCutoff,
+ shortYearCutoff = (typeof shortYearCutoffTemp !== "string" ? shortYearCutoffTemp :
+ new Date().getFullYear() % 100 + parseInt(shortYearCutoffTemp, 10)),
+ dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
+ dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
+ monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
+ monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
+ year = -1,
+ month = -1,
+ day = -1,
+ doy = -1,
+ literal = false,
+ date,
+
+ // Check whether a format character is doubled
+ lookAhead = function (match) {
+ var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
+ if (matches) {
+ iFormat++;
+ }
+ return matches;
+ },
+
+ // Extract a number from the string value
+ getNumber = function (match) {
+ var isDoubled = lookAhead(match),
+ size = (match === "@" ? 14 : (match === "!" ? 20 :
+ (match === "y" && isDoubled ? 4 : (match === "o" ? 3 : 2)))),
+ minSize = (match === "y" ? size : 1),
+ digits = new RegExp("^\\d{" + minSize + "," + size + "}"),
+ num = value.substring(iValue).match(digits);
+ if (!num) {
+ throw "Missing number at position " + iValue;
+ }
+ iValue += num[0].length;
+ return parseInt(num[0], 10);
+ },
+
+ // Extract a name from the string value and convert to an index
+ getName = function (match, shortNames, longNames) {
+ var index = -1,
+ names = $.map(lookAhead(match) ? longNames : shortNames, function (v, k) {
+ return [[k, v]];
+ }).sort(function (a, b) {
+ return -(a[1].length - b[1].length);
+ });
+
+ $.each(names, function (i, pair) {
+ var name = pair[1];
+ if (value.substr(iValue, name.length).toLowerCase() === name.toLowerCase()) {
+ index = pair[0];
+ iValue += name.length;
+ return false;
+ }
+ });
+ if (index !== -1) {
+ return index + 1;
+ } else {
+ throw "Unknown name at position " + iValue;
+ }
+ },
+
+ // Confirm that a literal character matches the string value
+ checkLiteral = function () {
+ if (value.charAt(iValue) !== format.charAt(iFormat)) {
+ throw "Unexpected literal at position " + iValue;
+ }
+ iValue++;
+ };
+
+ for (iFormat = 0; iFormat < format.length; iFormat++) {
+ if (literal) {
+ if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
+ literal = false;
+ } else {
+ checkLiteral();
+ }
+ } else {
+ switch (format.charAt(iFormat)) {
+ case "d":
+ day = getNumber("d");
+ break;
+ case "D":
+ getName("D", dayNamesShort, dayNames);
+ break;
+ case "o":
+ doy = getNumber("o");
+ break;
+ case "m":
+ month = getNumber("m");
+ break;
+ case "M":
+ month = getName("M", monthNamesShort, monthNames);
+ break;
+ case "y":
+ year = getNumber("y");
+ break;
+ case "@":
+ date = new Date(getNumber("@"));
+ year = date.getFullYear();
+ month = date.getMonth() + 1;
+ day = date.getDate();
+ break;
+ case "!":
+ date = new Date((getNumber("!") - this._ticksTo1970) / 10000);
+ year = date.getFullYear();
+ month = date.getMonth() + 1;
+ day = date.getDate();
+ break;
+ case "'":
+ if (lookAhead("'")) {
+ checkLiteral();
+ } else {
+ literal = true;
+ }
+ break;
+ default:
+ checkLiteral();
+ }
+ }
+ }
+
+ if (iValue < value.length) {
+ extra = value.substr(iValue);
+ if (!/^\s+/.test(extra)) {
+ throw "Extra/unparsed characters found in date: " + extra;
+ }
+ }
+
+ if (year === -1) {
+ year = new Date().getFullYear();
+ } else if (year < 100) {
+ year += new Date().getFullYear() - new Date().getFullYear() % 100 +
+ (year <= shortYearCutoff ? 0 : -100);
+ }
+
+ if (doy > -1) {
+ month = 1;
+ day = doy;
+ do {
+ dim = this._getDaysInMonth(year, month - 1);
+ if (day <= dim) {
+ break;
+ }
+ month++;
+ day -= dim;
+ } while (true);
+ }
+
+ date = this._daylightSavingAdjust(new Date(year, month - 1, day));
+ if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day) {
+ throw "Invalid date"; // E.g. 31/02/00
+ }
+ return date;
+ },
+
+ /* Standard date formats. */
+ ATOM: "yy-mm-dd", // RFC 3339 (ISO 8601)
+ COOKIE: "D, dd M yy",
+ ISO_8601: "yy-mm-dd",
+ RFC_822: "D, d M y",
+ RFC_850: "DD, dd-M-y",
+ RFC_1036: "D, d M y",
+ RFC_1123: "D, d M yy",
+ RFC_2822: "D, d M yy",
+ RSS: "D, d M y", // RFC 822
+ TICKS: "!",
+ TIMESTAMP: "@",
+ W3C: "yy-mm-dd", // ISO 8601
+
+ _ticksTo1970: (((1970 - 1) * 365 + Math.floor(1970 / 4) - Math.floor(1970 / 100) +
+ Math.floor(1970 / 400)) * 24 * 60 * 60 * 10000000),
+
+ /* Format a date object into a string value.
+ * The format can be combinations of the following:
+ * d - day of month (no leading zero)
+ * dd - day of month (two digit)
+ * o - day of year (no leading zeros)
+ * oo - day of year (three digit)
+ * D - day name short
+ * DD - day name long
+ * m - month of year (no leading zero)
+ * mm - month of year (two digit)
+ * M - month name short
+ * MM - month name long
+ * y - year (two digit)
+ * yy - year (four digit)
+ * @ - Unix timestamp (ms since 01/01/1970)
+ * ! - Windows ticks (100ns since 01/01/0001)
+ * "..." - literal text
+ * '' - single quote
+ *
+ * @param format string - the desired format of the date
+ * @param date Date - the date value to format
+ * @param settings Object - attributes include:
+ * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
+ * dayNames string[7] - names of the days from Sunday (optional)
+ * monthNamesShort string[12] - abbreviated names of the months (optional)
+ * monthNames string[12] - names of the months (optional)
+ * @return string - the date in the above format
+ */
+ formatDate: function (format, date, settings) {
+ if (!date) {
+ return "";
+ }
+
+ var iFormat,
+ dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
+ dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
+ monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
+ monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
+
+ // Check whether a format character is doubled
+ lookAhead = function (match) {
+ var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
+ if (matches) {
+ iFormat++;
+ }
+ return matches;
+ },
+
+ // Format a number, with leading zero if necessary
+ formatNumber = function (match, value, len) {
+ var num = "" + value;
+ if (lookAhead(match)) {
+ while (num.length < len) {
+ num = "0" + num;
+ }
+ }
+ return num;
+ },
+
+ // Format a name, short or long as requested
+ formatName = function (match, value, shortNames, longNames) {
+ return (lookAhead(match) ? longNames[value] : shortNames[value]);
+ },
+ output = "",
+ literal = false;
+
+ if (date) {
+ for (iFormat = 0; iFormat < format.length; iFormat++) {
+ if (literal) {
+ if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
+ literal = false;
+ } else {
+ output += format.charAt(iFormat);
+ }
+ } else {
+ switch (format.charAt(iFormat)) {
+ case "d":
+ output += formatNumber("d", date.getDate(), 2);
+ break;
+ case "D":
+ output += formatName("D", date.getDay(), dayNamesShort, dayNames);
+ break;
+ case "o":
+ output += formatNumber("o",
+ Math.round((new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000), 3);
+ break;
+ case "m":
+ output += formatNumber("m", date.getMonth() + 1, 2);
+ break;
+ case "M":
+ output += formatName("M", date.getMonth(), monthNamesShort, monthNames);
+ break;
+ case "y":
+ output += (lookAhead("y") ? date.getFullYear() :
+ (date.getFullYear() % 100 < 10 ? "0" : "") + date.getFullYear() % 100);
+ break;
+ case "@":
+ output += date.getTime();
+ break;
+ case "!":
+ output += date.getTime() * 10000 + this._ticksTo1970;
+ break;
+ case "'":
+ if (lookAhead("'")) {
+ output += "'";
+ } else {
+ literal = true;
+ }
+ break;
+ default:
+ output += format.charAt(iFormat);
+ }
+ }
+ }
+ }
+ return output;
+ },
+
+ /* Extract all possible characters from the date format. */
+ _possibleChars: function (format) {
+ var iFormat,
+ chars = "",
+ literal = false,
+
+ // Check whether a format character is doubled
+ lookAhead = function (match) {
+ var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
+ if (matches) {
+ iFormat++;
+ }
+ return matches;
+ };
+
+ for (iFormat = 0; iFormat < format.length; iFormat++) {
+ if (literal) {
+ if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
+ literal = false;
+ } else {
+ chars += format.charAt(iFormat);
+ }
+ } else {
+ switch (format.charAt(iFormat)) {
+ case "d": case "m": case "y": case "@":
+ chars += "0123456789";
+ break;
+ case "D": case "M":
+ return null; // Accept anything
+ case "'":
+ if (lookAhead("'")) {
+ chars += "'";
+ } else {
+ literal = true;
+ }
+ break;
+ default:
+ chars += format.charAt(iFormat);
+ }
+ }
+ }
+ return chars;
+ },
+
+ /* Get a setting value, defaulting if necessary. */
+ _get: function (inst, name) {
+ return inst.settings[name] !== undefined ?
+ inst.settings[name] : this._defaults[name];
+ },
+
+ /* Parse existing date and initialise date picker. */
+ _setDateFromField: function (inst, noDefault) {
+ if (inst.input.val() === inst.lastVal) {
+ return;
+ }
+
+ var dateFormat = this._get(inst, "dateFormat"),
+ dates = inst.lastVal = inst.input ? inst.input.val() : null,
+ defaultDate = this._getDefaultDate(inst),
+ date = defaultDate,
+ settings = this._getFormatConfig(inst);
+
+ try {
+ date = this.parseDate(dateFormat, dates, settings) || defaultDate;
+ } catch (event) {
+ dates = (noDefault ? "" : dates);
+ }
+ inst.selectedDay = date.getDate();
+ inst.drawMonth = inst.selectedMonth = date.getMonth();
+ inst.drawYear = inst.selectedYear = date.getFullYear();
+ inst.currentDay = (dates ? date.getDate() : 0);
+ inst.currentMonth = (dates ? date.getMonth() : 0);
+ inst.currentYear = (dates ? date.getFullYear() : 0);
+ this._adjustInstDate(inst);
+ },
+
+ /* Retrieve the default date shown on opening. */
+ _getDefaultDate: function (inst) {
+ return this._restrictMinMax(inst,
+ this._determineDate(inst, this._get(inst, "defaultDate"), new Date()));
+ },
+
+ /* A date may be specified as an exact value or a relative one. */
+ _determineDate: function (inst, date, defaultDate) {
+ var offsetNumeric = function (offset) {
+ var date = new Date();
+ date.setDate(date.getDate() + offset);
+ return date;
+ },
+ offsetString = function (offset) {
+ try {
+ return $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
+ offset, $.datepicker._getFormatConfig(inst));
+ }
+ catch (e) {
+
+ // Ignore
+ }
+
+ var date = (offset.toLowerCase().match(/^c/) ?
+ $.datepicker._getDate(inst) : null) || new Date(),
+ year = date.getFullYear(),
+ month = date.getMonth(),
+ day = date.getDate(),
+ pattern = /([+\-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g,
+ matches = pattern.exec(offset);
+
+ while (matches) {
+ switch (matches[2] || "d") {
+ case "d": case "D":
+ day += parseInt(matches[1], 10); break;
+ case "w": case "W":
+ day += parseInt(matches[1], 10) * 7; break;
+ case "m": case "M":
+ month += parseInt(matches[1], 10);
+ day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
+ break;
+ case "y": case "Y":
+ year += parseInt(matches[1], 10);
+ day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
+ break;
+ }
+ matches = pattern.exec(offset);
+ }
+ return new Date(year, month, day);
+ },
+ newDate = (date == null || date === "" ? defaultDate : (typeof date === "string" ? offsetString(date) :
+ (typeof date === "number" ? (isNaN(date) ? defaultDate : offsetNumeric(date)) : new Date(date.getTime()))));
+
+ newDate = (newDate && newDate.toString() === "Invalid Date" ? defaultDate : newDate);
+ if (newDate) {
+ newDate.setHours(0);
+ newDate.setMinutes(0);
+ newDate.setSeconds(0);
+ newDate.setMilliseconds(0);
+ }
+ return this._daylightSavingAdjust(newDate);
+ },
+
+ /* Handle switch to/from daylight saving.
+ * Hours may be non-zero on daylight saving cut-over:
+ * > 12 when midnight changeover, but then cannot generate
+ * midnight datetime, so jump to 1AM, otherwise reset.
+ * @param date (Date) the date to check
+ * @return (Date) the corrected date
+ */
+ _daylightSavingAdjust: function (date) {
+ if (!date) {
+ return null;
+ }
+ date.setHours(date.getHours() > 12 ? date.getHours() + 2 : 0);
+ return date;
+ },
+
+ /* Set the date(s) directly. */
+ _setDate: function (inst, date, noChange) {
+ var clear = !date,
+ origMonth = inst.selectedMonth,
+ origYear = inst.selectedYear,
+ newDate = this._restrictMinMax(inst, this._determineDate(inst, date, new Date()));
+
+ inst.selectedDay = inst.currentDay = newDate.getDate();
+ inst.drawMonth = inst.selectedMonth = inst.currentMonth = newDate.getMonth();
+ inst.drawYear = inst.selectedYear = inst.currentYear = newDate.getFullYear();
+ if ((origMonth !== inst.selectedMonth || origYear !== inst.selectedYear) && !noChange) {
+ this._notifyChange(inst);
+ }
+ this._adjustInstDate(inst);
+ if (inst.input) {
+ inst.input.val(clear ? "" : this._formatDate(inst));
+ }
+ },
+
+ /* Retrieve the date(s) directly. */
+ _getDate: function (inst) {
+ var startDate = (!inst.currentYear || (inst.input && inst.input.val() === "") ? null :
+ this._daylightSavingAdjust(new Date(
+ inst.currentYear, inst.currentMonth, inst.currentDay)));
+ return startDate;
+ },
+
+ /* Attach the onxxx handlers. These are declared statically so
+ * they work with static code transformers like Caja.
+ */
+ _attachHandlers: function (inst) {
+ var stepMonths = this._get(inst, "stepMonths"),
+ id = "#" + inst.id.replace(/\\\\/g, "\\");
+ inst.dpDiv.find("[data-handler]").map(function () {
+ var handler = {
+ prev: function () {
+ $.datepicker._adjustDate(id, -stepMonths, "M");
+ },
+ next: function () {
+ $.datepicker._adjustDate(id, +stepMonths, "M");
+ },
+ hide: function () {
+ $.datepicker._hideDatepicker();
+ },
+ today: function () {
+ $.datepicker._gotoToday(id);
+ },
+ selectDay: function () {
+ $.datepicker._selectDay(id, +this.getAttribute("data-month"), +this.getAttribute("data-year"), this);
+ return false;
+ },
+ selectMonth: function () {
+ $.datepicker._selectMonthYear(id, this, "M");
+ return false;
+ },
+ selectYear: function () {
+ $.datepicker._selectMonthYear(id, this, "Y");
+ return false;
+ }
+ };
+ $(this).on(this.getAttribute("data-event"), handler[this.getAttribute("data-handler")]);
+ });
+ },
+
+ /* Generate the HTML for the current state of the date picker. */
+ _generateHTML: function (inst) {
+ var maxDraw, prevText, prev, nextText, next, currentText, gotoDate,
+ controls, buttonPanel, firstDay, showWeek, dayNames, dayNamesMin,
+ monthNames, monthNamesShort, beforeShowDay, showOtherMonths,
+ selectOtherMonths, defaultDate, html, dow, row, group, col, selectedDate,
+ cornerClass, calender, thead, day, daysInMonth, leadDays, curRows, numRows,
+ printDate, dRow, tbody, daySettings, otherMonth, unselectable,
+ tempDate = new Date(),
+ today = this._daylightSavingAdjust(
+ new Date(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate())), // clear time
+ isRTL = this._get(inst, "isRTL"),
+ showButtonPanel = this._get(inst, "showButtonPanel"),
+ hideIfNoPrevNext = this._get(inst, "hideIfNoPrevNext"),
+ navigationAsDateFormat = this._get(inst, "navigationAsDateFormat"),
+ numMonths = this._getNumberOfMonths(inst),
+ showCurrentAtPos = this._get(inst, "showCurrentAtPos"),
+ stepMonths = this._get(inst, "stepMonths"),
+ isMultiMonth = (numMonths[0] !== 1 || numMonths[1] !== 1),
+ currentDate = this._daylightSavingAdjust((!inst.currentDay ? new Date(9999, 9, 9) :
+ new Date(inst.currentYear, inst.currentMonth, inst.currentDay))),
+ minDate = this._getMinMaxDate(inst, "min"),
+ maxDate = this._getMinMaxDate(inst, "max"),
+ drawMonth = inst.drawMonth - showCurrentAtPos,
+ drawYear = inst.drawYear;
+
+ if (drawMonth < 0) {
+ drawMonth += 12;
+ drawYear--;
+ }
+ if (maxDate) {
+ maxDraw = this._daylightSavingAdjust(new Date(maxDate.getFullYear(),
+ maxDate.getMonth() - (numMonths[0] * numMonths[1]) + 1, maxDate.getDate()));
+ maxDraw = (minDate && maxDraw < minDate ? minDate : maxDraw);
+ while (this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1)) > maxDraw) {
+ drawMonth--;
+ if (drawMonth < 0) {
+ drawMonth = 11;
+ drawYear--;
+ }
+ }
+ }
+ inst.drawMonth = drawMonth;
+ inst.drawYear = drawYear;
+
+ prevText = this._get(inst, "prevText");
+ prevText = (!navigationAsDateFormat ? prevText : this.formatDate(prevText,
+ this._daylightSavingAdjust(new Date(drawYear, drawMonth - stepMonths, 1)),
+ this._getFormatConfig(inst)));
+
+ prev = (this._canAdjustMonth(inst, -1, drawYear, drawMonth) ?
+ "<a class='ui-datepicker-prev ui-corner-all' data-handler='prev' data-event='click'" +
+ " title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + (isRTL ? "e" : "w") + "'>" + prevText + "</span></a>" :
+ (hideIfNoPrevNext ? "" : "<a class='ui-datepicker-prev ui-corner-all ui-state-disabled' title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + (isRTL ? "e" : "w") + "'>" + prevText + "</span></a>"));
+
+ nextText = this._get(inst, "nextText");
+ nextText = (!navigationAsDateFormat ? nextText : this.formatDate(nextText,
+ this._daylightSavingAdjust(new Date(drawYear, drawMonth + stepMonths, 1)),
+ this._getFormatConfig(inst)));
+
+ next = (this._canAdjustMonth(inst, +1, drawYear, drawMonth) ?
+ "<a class='ui-datepicker-next ui-corner-all' data-handler='next' data-event='click'" +
+ " title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + (isRTL ? "w" : "e") + "'>" + nextText + "</span></a>" :
+ (hideIfNoPrevNext ? "" : "<a class='ui-datepicker-next ui-corner-all ui-state-disabled' title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + (isRTL ? "w" : "e") + "'>" + nextText + "</span></a>"));
+
+ currentText = this._get(inst, "currentText");
+ gotoDate = (this._get(inst, "gotoCurrent") && inst.currentDay ? currentDate : today);
+ currentText = (!navigationAsDateFormat ? currentText :
+ this.formatDate(currentText, gotoDate, this._getFormatConfig(inst)));
+
+ controls = (!inst.inline ? "<button type='button' class='ui-datepicker-close ui-state-default ui-priority-primary ui-corner-all' data-handler='hide' data-event='click'>" +
+ this._get(inst, "closeText") + "</button>" : "");
+
+ buttonPanel = (showButtonPanel) ? "<div class='ui-datepicker-buttonpane ui-widget-content'>" + (isRTL ? controls : "") +
+ (this._isInRange(inst, gotoDate) ? "<button type='button' class='ui-datepicker-current ui-state-default ui-priority-secondary ui-corner-all' data-handler='today' data-event='click'" +
+ ">" + currentText + "</button>" : "") + (isRTL ? "" : controls) + "</div>" : "";
+
+ firstDay = parseInt(this._get(inst, "firstDay"), 10);
+ firstDay = (isNaN(firstDay) ? 0 : firstDay);
+
+ showWeek = this._get(inst, "showWeek");
+ dayNames = this._get(inst, "dayNames");
+ dayNamesMin = this._get(inst, "dayNamesMin");
+ monthNames = this._get(inst, "monthNames");
+ monthNamesShort = this._get(inst, "monthNamesShort");
+ beforeShowDay = this._get(inst, "beforeShowDay");
+ showOtherMonths = this._get(inst, "showOtherMonths");
+ selectOtherMonths = this._get(inst, "selectOtherMonths");
+ defaultDate = this._getDefaultDate(inst);
+ html = "";
+
+ for (row = 0; row < numMonths[0]; row++) {
+ group = "";
+ this.maxRows = 4;
+ for (col = 0; col < numMonths[1]; col++) {
+ selectedDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, inst.selectedDay));
+ cornerClass = " ui-corner-all";
+ calender = "";
+ if (isMultiMonth) {
+ calender += "<div class='ui-datepicker-group";
+ if (numMonths[1] > 1) {
+ switch (col) {
+ case 0: calender += " ui-datepicker-group-first";
+ cornerClass = " ui-corner-" + (isRTL ? "right" : "left"); break;
+ case numMonths[1] - 1: calender += " ui-datepicker-group-last";
+ cornerClass = " ui-corner-" + (isRTL ? "left" : "right"); break;
+ default: calender += " ui-datepicker-group-middle"; cornerClass = ""; break;
+ }
+ }
+ calender += "'>";
+ }
+ calender += "<div class='ui-datepicker-header ui-widget-header ui-helper-clearfix" + cornerClass + "'>" +
+ (/all|left/.test(cornerClass) && row === 0 ? (isRTL ? next : prev) : "") +
+ (/all|right/.test(cornerClass) && row === 0 ? (isRTL ? prev : next) : "") +
+ this._generateMonthYearHeader(inst, drawMonth, drawYear, minDate, maxDate,
+ row > 0 || col > 0, monthNames, monthNamesShort) + // draw month headers
+ "</div><table class='ui-datepicker-calendar'><thead>" +
+ "<tr>";
+ thead = (showWeek ? "<th class='ui-datepicker-week-col'>" + this._get(inst, "weekHeader") + "</th>" : "");
+ for (dow = 0; dow < 7; dow++) { // days of the week
+ day = (dow + firstDay) % 7;
+ thead += "<th scope='col'" + ((dow + firstDay + 6) % 7 >= 5 ? " class='ui-datepicker-week-end'" : "") + ">" +
+ "<span title='" + dayNames[day] + "'>" + dayNamesMin[day] + "</span></th>";
+ }
+ calender += thead + "</tr></thead><tbody>";
+ daysInMonth = this._getDaysInMonth(drawYear, drawMonth);
+ if (drawYear === inst.selectedYear && drawMonth === inst.selectedMonth) {
+ inst.selectedDay = Math.min(inst.selectedDay, daysInMonth);
+ }
+ leadDays = (this._getFirstDayOfMonth(drawYear, drawMonth) - firstDay + 7) % 7;
+ curRows = Math.ceil((leadDays + daysInMonth) / 7); // calculate the number of rows to generate
+ numRows = (isMultiMonth ? this.maxRows > curRows ? this.maxRows : curRows : curRows); //If multiple months, use the higher number of rows (see #7043)
+ this.maxRows = numRows;
+ printDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1 - leadDays));
+ for (dRow = 0; dRow < numRows; dRow++) { // create date picker rows
+ calender += "<tr>";
+ tbody = (!showWeek ? "" : "<td class='ui-datepicker-week-col'>" +
+ this._get(inst, "calculateWeek")(printDate) + "</td>");
+ for (dow = 0; dow < 7; dow++) { // create date picker days
+ daySettings = (beforeShowDay ?
+ beforeShowDay.apply((inst.input ? inst.input[0] : null), [printDate]) : [true, ""]);
+ otherMonth = (printDate.getMonth() !== drawMonth);
+ unselectable = (otherMonth && !selectOtherMonths) || !daySettings[0] ||
+ (minDate && printDate < minDate) || (maxDate && printDate > maxDate);
+ tbody += "<td class='" +
+ ((dow + firstDay + 6) % 7 >= 5 ? " ui-datepicker-week-end" : "") + // highlight weekends
+ (otherMonth ? " ui-datepicker-other-month" : "") + // highlight days from other months
+ ((printDate.getTime() === selectedDate.getTime() && drawMonth === inst.selectedMonth && inst._keyEvent) || // user pressed key
+ (defaultDate.getTime() === printDate.getTime() && defaultDate.getTime() === selectedDate.getTime()) ?
+
+ // or defaultDate is current printedDate and defaultDate is selectedDate
+ " " + this._dayOverClass : "") + // highlight selected day
+ (unselectable ? " " + this._unselectableClass + " ui-state-disabled" : "") + // highlight unselectable days
+ (otherMonth && !showOtherMonths ? "" : " " + daySettings[1] + // highlight custom dates
+ (printDate.getTime() === currentDate.getTime() ? " " + this._currentClass : "") + // highlight selected day
+ (printDate.getTime() === today.getTime() ? " ui-datepicker-today" : "")) + "'" + // highlight today (if different)
+ ((!otherMonth || showOtherMonths) && daySettings[2] ? " title='" + daySettings[2].replace(/'/g, "'") + "'" : "") + // cell title
+ (unselectable ? "" : " data-handler='selectDay' data-event='click' data-month='" + printDate.getMonth() + "' data-year='" + printDate.getFullYear() + "'") + ">" + // actions
+ (otherMonth && !showOtherMonths ? " " : // display for other months
+ (unselectable ? "<span class='ui-state-default'>" + printDate.getDate() + "</span>" : "<a class='ui-state-default" +
+ (printDate.getTime() === today.getTime() ? " ui-state-highlight" : "") +
+ (printDate.getTime() === currentDate.getTime() ? " ui-state-active" : "") + // highlight selected day
+ (otherMonth ? " ui-priority-secondary" : "") + // distinguish dates from other months
+ "' href='#'>" + printDate.getDate() + "</a>")) + "</td>"; // display selectable date
+ printDate.setDate(printDate.getDate() + 1);
+ printDate = this._daylightSavingAdjust(printDate);
+ }
+ calender += tbody + "</tr>";
+ }
+ drawMonth++;
+ if (drawMonth > 11) {
+ drawMonth = 0;
+ drawYear++;
+ }
+ calender += "</tbody></table>" + (isMultiMonth ? "</div>" +
+ ((numMonths[0] > 0 && col === numMonths[1] - 1) ? "<div class='ui-datepicker-row-break'></div>" : "") : "");
+ group += calender;
+ }
+ html += group;
+ }
+ html += buttonPanel;
+ inst._keyEvent = false;
+ return html;
+ },
+
+ /* Generate the month and year header. */
+ _generateMonthYearHeader: function (inst, drawMonth, drawYear, minDate, maxDate,
+ secondary, monthNames, monthNamesShort) {
+
+ var inMinYear, inMaxYear, month, years, thisYear, determineYear, year, endYear,
+ changeMonth = this._get(inst, "changeMonth"),
+ changeYear = this._get(inst, "changeYear"),
+ showMonthAfterYear = this._get(inst, "showMonthAfterYear"),
+ html = "<div class='ui-datepicker-title'>",
+ monthHtml = "";
+
+ // Month selection
+ if (secondary || !changeMonth) {
+ monthHtml += "<span class='ui-datepicker-month'>" + monthNames[drawMonth] + "</span>";
+ } else {
+ inMinYear = (minDate && minDate.getFullYear() === drawYear);
+ inMaxYear = (maxDate && maxDate.getFullYear() === drawYear);
+ monthHtml += "<select class='ui-datepicker-month' data-handler='selectMonth' data-event='change'>";
+ for (month = 0; month < 12; month++) {
+ if ((!inMinYear || month >= minDate.getMonth()) && (!inMaxYear || month <= maxDate.getMonth())) {
+ monthHtml += "<option value='" + month + "'" +
+ (month === drawMonth ? " selected='selected'" : "") +
+ ">" + monthNamesShort[month] + "</option>";
+ }
+ }
+ monthHtml += "</select>";
+ }
+
+ if (!showMonthAfterYear) {
+ html += monthHtml + (secondary || !(changeMonth && changeYear) ? " " : "");
+ }
+
+ // Year selection
+ if (!inst.yearshtml) {
+ inst.yearshtml = "";
+ if (secondary || !changeYear) {
+ html += "<span class='ui-datepicker-year'>" + drawYear + "</span>";
+ } else {
+
+ // determine range of years to display
+ years = this._get(inst, "yearRange").split(":");
+ thisYear = new Date().getFullYear();
+ determineYear = function (value) {
+ var year = (value.match(/c[+\-].*/) ? drawYear + parseInt(value.substring(1), 10) :
+ (value.match(/[+\-].*/) ? thisYear + parseInt(value, 10) :
+ parseInt(value, 10)));
+ return (isNaN(year) ? thisYear : year);
+ };
+ year = determineYear(years[0]);
+ endYear = Math.max(year, determineYear(years[1] || ""));
+ year = (minDate ? Math.max(year, minDate.getFullYear()) : year);
+ endYear = (maxDate ? Math.min(endYear, maxDate.getFullYear()) : endYear);
+ inst.yearshtml += "<select class='ui-datepicker-year' data-handler='selectYear' data-event='change'>";
+ for (; year <= endYear; year++) {
+ inst.yearshtml += "<option value='" + year + "'" +
+ (year === drawYear ? " selected='selected'" : "") +
+ ">" + year + "</option>";
+ }
+ inst.yearshtml += "</select>";
+
+ html += inst.yearshtml;
+ inst.yearshtml = null;
+ }
+ }
+
+ html += this._get(inst, "yearSuffix");
+ if (showMonthAfterYear) {
+ html += (secondary || !(changeMonth && changeYear) ? " " : "") + monthHtml;
+ }
+ html += "</div>"; // Close datepicker_header
+ return html;
+ },
+
+ /* Adjust one of the date sub-fields. */
+ _adjustInstDate: function (inst, offset, period) {
+ var year = inst.selectedYear + (period === "Y" ? offset : 0),
+ month = inst.selectedMonth + (period === "M" ? offset : 0),
+ day = Math.min(inst.selectedDay, this._getDaysInMonth(year, month)) + (period === "D" ? offset : 0),
+ date = this._restrictMinMax(inst, this._daylightSavingAdjust(new Date(year, month, day)));
+
+ inst.selectedDay = date.getDate();
+ inst.drawMonth = inst.selectedMonth = date.getMonth();
+ inst.drawYear = inst.selectedYear = date.getFullYear();
+ if (period === "M" || period === "Y") {
+ this._notifyChange(inst);
+ }
+ },
+
+ /* Ensure a date is within any min/max bounds. */
+ _restrictMinMax: function (inst, date) {
+ var minDate = this._getMinMaxDate(inst, "min"),
+ maxDate = this._getMinMaxDate(inst, "max"),
+ newDate = (minDate && date < minDate ? minDate : date);
+ return (maxDate && newDate > maxDate ? maxDate : newDate);
+ },
+
+ /* Notify change of month/year. */
+ _notifyChange: function (inst) {
+ var onChange = this._get(inst, "onChangeMonthYear");
+ if (onChange) {
+ onChange.apply((inst.input ? inst.input[0] : null),
+ [inst.selectedYear, inst.selectedMonth + 1, inst]);
+ }
+ },
+
+ /* Determine the number of months to show. */
+ _getNumberOfMonths: function (inst) {
+ var numMonths = this._get(inst, "numberOfMonths");
+ return (numMonths == null ? [1, 1] : (typeof numMonths === "number" ? [1, numMonths] : numMonths));
+ },
+
+ /* Determine the current maximum date - ensure no time components are set. */
+ _getMinMaxDate: function (inst, minMax) {
+ return this._determineDate(inst, this._get(inst, minMax + "Date"), null);
+ },
+
+ /* Find the number of days in a given month. */
+ _getDaysInMonth: function (year, month) {
+ return 32 - this._daylightSavingAdjust(new Date(year, month, 32)).getDate();
+ },
+
+ /* Find the day of the week of the first of a month. */
+ _getFirstDayOfMonth: function (year, month) {
+ return new Date(year, month, 1).getDay();
+ },
+
+ /* Determines if we should allow a "next/prev" month display change. */
+ _canAdjustMonth: function (inst, offset, curYear, curMonth) {
+ var numMonths = this._getNumberOfMonths(inst),
+ date = this._daylightSavingAdjust(new Date(curYear,
+ curMonth + (offset < 0 ? offset : numMonths[0] * numMonths[1]), 1));
+
+ if (offset < 0) {
+ date.setDate(this._getDaysInMonth(date.getFullYear(), date.getMonth()));
+ }
+ return this._isInRange(inst, date);
+ },
+
+ /* Is the given date in the accepted range? */
+ _isInRange: function (inst, date) {
+ var yearSplit, currentYear,
+ minDate = this._getMinMaxDate(inst, "min"),
+ maxDate = this._getMinMaxDate(inst, "max"),
+ minYear = null,
+ maxYear = null,
+ years = this._get(inst, "yearRange");
+ if (years) {
+ yearSplit = years.split(":");
+ currentYear = new Date().getFullYear();
+ minYear = parseInt(yearSplit[0], 10);
+ maxYear = parseInt(yearSplit[1], 10);
+ if (yearSplit[0].match(/[+\-].*/)) {
+ minYear += currentYear;
+ }
+ if (yearSplit[1].match(/[+\-].*/)) {
+ maxYear += currentYear;
+ }
+ }
+
+ return ((!minDate || date.getTime() >= minDate.getTime()) &&
+ (!maxDate || date.getTime() <= maxDate.getTime()) &&
+ (!minYear || date.getFullYear() >= minYear) &&
+ (!maxYear || date.getFullYear() <= maxYear));
+ },
+
+ /* Provide the configuration settings for formatting/parsing. */
+ _getFormatConfig: function (inst) {
+ var shortYearCutoff = this._get(inst, "shortYearCutoff");
+ shortYearCutoff = (typeof shortYearCutoff !== "string" ? shortYearCutoff :
+ new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10));
+ return {
+ shortYearCutoff: shortYearCutoff,
+ dayNamesShort: this._get(inst, "dayNamesShort"), dayNames: this._get(inst, "dayNames"),
+ monthNamesShort: this._get(inst, "monthNamesShort"), monthNames: this._get(inst, "monthNames")
+ };
+ },
+
+ /* Format the given date for display. */
+ _formatDate: function (inst, day, month, year) {
+ if (!day) {
+ inst.currentDay = inst.selectedDay;
+ inst.currentMonth = inst.selectedMonth;
+ inst.currentYear = inst.selectedYear;
+ }
+ var date = (day ? (typeof day === "object" ? day :
+ this._daylightSavingAdjust(new Date(year, month, day))) :
+ this._daylightSavingAdjust(new Date(inst.currentYear, inst.currentMonth, inst.currentDay)));
+ return this.formatDate(this._get(inst, "dateFormat"), date, this._getFormatConfig(inst));
+ }
+ });
+
+ /*
+ * Bind hover events for datepicker elements.
+ * Done via delegate so the binding only occurs once in the lifetime of the parent div.
+ * Global datepicker_instActive, set by _updateDatepicker allows the handlers to find their way back to the active picker.
+ */
+ function datepicker_bindHover(dpDiv) {
+ var selector = "button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a";
+ return dpDiv.on("mouseout", selector, function () {
+ $(this).removeClass("ui-state-hover");
+ if (this.className.indexOf("ui-datepicker-prev") !== -1) {
+ $(this).removeClass("ui-datepicker-prev-hover");
+ }
+ if (this.className.indexOf("ui-datepicker-next") !== -1) {
+ $(this).removeClass("ui-datepicker-next-hover");
+ }
+ })
+ .on("mouseover", selector, datepicker_handleMouseover);
+ }
+
+ function datepicker_handleMouseover() {
+ if (!$.datepicker._isDisabledDatepicker(datepicker_instActive.inline ? datepicker_instActive.dpDiv.parent()[0] : datepicker_instActive.input[0])) {
+ $(this).parents(".ui-datepicker-calendar").find("a").removeClass("ui-state-hover");
+ $(this).addClass("ui-state-hover");
+ if (this.className.indexOf("ui-datepicker-prev") !== -1) {
+ $(this).addClass("ui-datepicker-prev-hover");
+ }
+ if (this.className.indexOf("ui-datepicker-next") !== -1) {
+ $(this).addClass("ui-datepicker-next-hover");
+ }
+ }
+ }
+
+ /* jQuery extend now ignores nulls! */
+ function datepicker_extendRemove(target, props) {
+ $.extend(target, props);
+ for (var name in props) {
+ if (props[name] == null) {
+ target[name] = props[name];
+ }
+ }
+ return target;
+ }
+
+ /* Invoke the datepicker functionality.
+ @param options string - a command, optionally followed by additional parameters or
+ Object - settings for attaching new datepicker functionality
+ @return jQuery object */
+ $.fn.datepicker = function (options) {
+
+ /* Verify an empty collection wasn't passed - Fixes #6976 */
+ if (!this.length) {
+ return this;
+ }
+
+ /* Initialise the date picker. */
+ if (!$.datepicker.initialized) {
+ $(document).on("mousedown", $.datepicker._checkExternalClick);
+ $.datepicker.initialized = true;
+ }
+
+ /* Append datepicker main container to body if not exist. */
+ if ($("#" + $.datepicker._mainDivId).length === 0) {
+ $("body").append($.datepicker.dpDiv);
+ }
+
+ var otherArgs = Array.prototype.slice.call(arguments, 1);
+ if (typeof options === "string" && (options === "isDisabled" || options === "getDate" || options === "widget")) {
+ return $.datepicker["_" + options + "Datepicker"].
+ apply($.datepicker, [this[0]].concat(otherArgs));
+ }
+ if (options === "option" && arguments.length === 2 && typeof arguments[1] === "string") {
+ return $.datepicker["_" + options + "Datepicker"].
+ apply($.datepicker, [this[0]].concat(otherArgs));
+ }
+ return this.each(function () {
+ typeof options === "string" ?
+ $.datepicker["_" + options + "Datepicker"].
+ apply($.datepicker, [this].concat(otherArgs)) :
+ $.datepicker._attachDatepicker(this, options);
+ });
+ };
+
+ $.datepicker = new Datepicker(); // singleton instance
+ $.datepicker.initialized = false;
+ $.datepicker.uuid = new Date().getTime();
+ $.datepicker.version = "1.12.1";
+
+ var widgetsDatepicker = $.datepicker;
+
+
+
+
+ // This file is deprecated
+ var ie = $.ui.ie = !!/msie [\w.]+/.exec(navigator.userAgent.toLowerCase());
+
+ /*!
+ * jQuery UI Mouse 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Mouse
+ //>>group: Widgets
+ //>>description: Abstracts mouse-based interactions to assist in creating certain widgets.
+ //>>docs: http://api.jqueryui.com/mouse/
+
+
+
+ var mouseHandled = false;
+ $(document).on("mouseup", function () {
+ mouseHandled = false;
+ });
+
+ var widgetsMouse = $.widget("ui.mouse", {
+ version: "1.12.1",
+ options: {
+ cancel: "input, textarea, button, select, option",
+ distance: 1,
+ delay: 0
+ },
+ _mouseInit: function () {
+ var that = this;
+
+ this.element
+ .on("mousedown." + this.widgetName, function (event) {
+ return that._mouseDown(event);
+ })
+ .on("click." + this.widgetName, function (event) {
+ if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
+ $.removeData(event.target, that.widgetName + ".preventClickEvent");
+ event.stopImmediatePropagation();
+ return false;
+ }
+ });
+
+ this.started = false;
+ },
+
+ // TODO: make sure destroying one instance of mouse doesn't mess with
+ // other instances of mouse
+ _mouseDestroy: function () {
+ this.element.off("." + this.widgetName);
+ if (this._mouseMoveDelegate) {
+ this.document
+ .off("mousemove." + this.widgetName, this._mouseMoveDelegate)
+ .off("mouseup." + this.widgetName, this._mouseUpDelegate);
+ }
+ },
+
+ _mouseDown: function (event) {
+
+ // don't let more than one widget handle mouseStart
+ if (mouseHandled) {
+ return;
+ }
+
+ this._mouseMoved = false;
+
+ // We may have missed mouseup (out of window)
+ (this._mouseStarted && this._mouseUp(event));
+
+ this._mouseDownEvent = event;
+
+ var that = this,
+ btnIsLeft = (event.which === 1),
+
+ // event.target.nodeName works around a bug in IE 8 with
+ // disabled inputs (#7620)
+ elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ?
+ $(event.target).closest(this.options.cancel).length : false);
+ if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
+ return true;
+ }
+
+ this.mouseDelayMet = !this.options.delay;
+ if (!this.mouseDelayMet) {
+ this._mouseDelayTimer = setTimeout(function () {
+ that.mouseDelayMet = true;
+ }, this.options.delay);
+ }
+
+ if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
+ this._mouseStarted = (this._mouseStart(event) !== false);
+ if (!this._mouseStarted) {
+ event.preventDefault();
+ return true;
+ }
+ }
+
+ // Click event may never have fired (Gecko & Opera)
+ if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
+ $.removeData(event.target, this.widgetName + ".preventClickEvent");
+ }
+
+ // These delegates are required to keep context
+ this._mouseMoveDelegate = function (event) {
+ return that._mouseMove(event);
+ };
+ this._mouseUpDelegate = function (event) {
+ return that._mouseUp(event);
+ };
+
+ this.document
+ .on("mousemove." + this.widgetName, this._mouseMoveDelegate)
+ .on("mouseup." + this.widgetName, this._mouseUpDelegate);
+
+ event.preventDefault();
+
+ mouseHandled = true;
+ return true;
+ },
+
+ _mouseMove: function (event) {
+
+ // Only check for mouseups outside the document if you've moved inside the document
+ // at least once. This prevents the firing of mouseup in the case of IE<9, which will
+ // fire a mousemove event if content is placed under the cursor. See #7778
+ // Support: IE <9
+ if (this._mouseMoved) {
+
+ // IE mouseup check - mouseup happened when mouse was out of window
+ if ($.ui.ie && (!document.documentMode || document.documentMode < 9) &&
+ !event.button) {
+ return this._mouseUp(event);
+
+ // Iframe mouseup check - mouseup occurred in another document
+ } else if (!event.which) {
+
+ // Support: Safari <=8 - 9
+ // Safari sets which to 0 if you press any of the following keys
+ // during a drag (#14461)
+ if (event.originalEvent.altKey || event.originalEvent.ctrlKey ||
+ event.originalEvent.metaKey || event.originalEvent.shiftKey) {
+ this.ignoreMissingWhich = true;
+ } else if (!this.ignoreMissingWhich) {
+ return this._mouseUp(event);
+ }
+ }
+ }
+
+ if (event.which || event.button) {
+ this._mouseMoved = true;
+ }
+
+ if (this._mouseStarted) {
+ this._mouseDrag(event);
+ return event.preventDefault();
+ }
+
+ if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
+ this._mouseStarted =
+ (this._mouseStart(this._mouseDownEvent, event) !== false);
+ (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
+ }
+
+ return !this._mouseStarted;
+ },
+
+ _mouseUp: function (event) {
+ this.document
+ .off("mousemove." + this.widgetName, this._mouseMoveDelegate)
+ .off("mouseup." + this.widgetName, this._mouseUpDelegate);
+
+ if (this._mouseStarted) {
+ this._mouseStarted = false;
+
+ if (event.target === this._mouseDownEvent.target) {
+ $.data(event.target, this.widgetName + ".preventClickEvent", true);
+ }
+
+ this._mouseStop(event);
+ }
+
+ if (this._mouseDelayTimer) {
+ clearTimeout(this._mouseDelayTimer);
+ delete this._mouseDelayTimer;
+ }
+
+ this.ignoreMissingWhich = false;
+ mouseHandled = false;
+ event.preventDefault();
+ },
+
+ _mouseDistanceMet: function (event) {
+ return (Math.max(
+ Math.abs(this._mouseDownEvent.pageX - event.pageX),
+ Math.abs(this._mouseDownEvent.pageY - event.pageY)
+ ) >= this.options.distance
+ );
+ },
+
+ _mouseDelayMet: function ( /* event */) {
+ return this.mouseDelayMet;
+ },
+
+ // These are placeholder methods, to be overriden by extending plugin
+ _mouseStart: function ( /* event */) { },
+ _mouseDrag: function ( /* event */) { },
+ _mouseStop: function ( /* event */) { },
+ _mouseCapture: function ( /* event */) { return true; }
+ });
+
+
+
+
+ // $.ui.plugin is deprecated. Use $.widget() extensions instead.
+ var plugin = $.ui.plugin = {
+ add: function (module, option, set) {
+ var i,
+ proto = $.ui[module].prototype;
+ for (i in set) {
+ proto.plugins[i] = proto.plugins[i] || [];
+ proto.plugins[i].push([option, set[i]]);
+ }
+ },
+ call: function (instance, name, args, allowDisconnected) {
+ var i,
+ set = instance.plugins[name];
+
+ if (!set) {
+ return;
+ }
+
+ if (!allowDisconnected && (!instance.element[0].parentNode ||
+ instance.element[0].parentNode.nodeType === 11)) {
+ return;
+ }
+
+ for (i = 0; i < set.length; i++) {
+ if (instance.options[set[i][0]]) {
+ set[i][1].apply(instance.element, args);
+ }
+ }
+ }
+ };
+
+
+
+ var safeBlur = $.ui.safeBlur = function (element) {
+
+ // Support: IE9 - 10 only
+ // If the <body> is blurred, IE will switch windows, see #9420
+ if (element && element.nodeName.toLowerCase() !== "body") {
+ $(element).trigger("blur");
+ }
+ };
+
+
+ /*!
+ * jQuery UI Draggable 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Draggable
+ //>>group: Interactions
+ //>>description: Enables dragging functionality for any element.
+ //>>docs: http://api.jqueryui.com/draggable/
+ //>>demos: http://jqueryui.com/draggable/
+ //>>css.structure: ../../themes/base/draggable.css
+
+
+
+ $.widget("ui.draggable", $.ui.mouse, {
+ version: "1.12.1",
+ widgetEventPrefix: "drag",
+ options: {
+ addClasses: true,
+ appendTo: "parent",
+ axis: false,
+ connectToSortable: false,
+ containment: false,
+ cursor: "auto",
+ cursorAt: false,
+ grid: false,
+ handle: false,
+ helper: "original",
+ iframeFix: false,
+ opacity: false,
+ refreshPositions: false,
+ revert: false,
+ revertDuration: 500,
+ scope: "default",
+ scroll: true,
+ scrollSensitivity: 20,
+ scrollSpeed: 20,
+ snap: false,
+ snapMode: "both",
+ snapTolerance: 20,
+ stack: false,
+ zIndex: false,
+
+ // Callbacks
+ drag: null,
+ start: null,
+ stop: null
+ },
+ _create: function () {
+
+ if (this.options.helper === "original") {
+ this._setPositionRelative();
+ }
+ if (this.options.addClasses) {
+ this._addClass("ui-draggable");
+ }
+ this._setHandleClassName();
+
+ this._mouseInit();
+ },
+
+ _setOption: function (key, value) {
+ this._super(key, value);
+ if (key === "handle") {
+ this._removeHandleClassName();
+ this._setHandleClassName();
+ }
+ },
+
+ _destroy: function () {
+ if ((this.helper || this.element).is(".ui-draggable-dragging")) {
+ this.destroyOnClear = true;
+ return;
+ }
+ this._removeHandleClassName();
+ this._mouseDestroy();
+ },
+
+ _mouseCapture: function (event) {
+ var o = this.options;
+
+ // Among others, prevent a drag on a resizable-handle
+ if (this.helper || o.disabled ||
+ $(event.target).closest(".ui-resizable-handle").length > 0) {
+ return false;
+ }
+
+ //Quit if we're not on a valid handle
+ this.handle = this._getHandle(event);
+ if (!this.handle) {
+ return false;
+ }
+
+ this._blurActiveElement(event);
+
+ this._blockFrames(o.iframeFix === true ? "iframe" : o.iframeFix);
+
+ return true;
+
+ },
+
+ _blockFrames: function (selector) {
+ this.iframeBlocks = this.document.find(selector).map(function () {
+ var iframe = $(this);
+
+ return $("<div>")
+ .css("position", "absolute")
+ .appendTo(iframe.parent())
+ .outerWidth(iframe.outerWidth())
+ .outerHeight(iframe.outerHeight())
+ .offset(iframe.offset())[0];
+ });
+ },
+
+ _unblockFrames: function () {
+ if (this.iframeBlocks) {
+ this.iframeBlocks.remove();
+ delete this.iframeBlocks;
+ }
+ },
+
+ _blurActiveElement: function (event) {
+ var activeElement = $.ui.safeActiveElement(this.document[0]),
+ target = $(event.target);
+
+ // Don't blur if the event occurred on an element that is within
+ // the currently focused element
+ // See #10527, #12472
+ if (target.closest(activeElement).length) {
+ return;
+ }
+
+ // Blur any element that currently has focus, see #4261
+ $.ui.safeBlur(activeElement);
+ },
+
+ _mouseStart: function (event) {
+
+ var o = this.options;
+
+ //Create and append the visible helper
+ this.helper = this._createHelper(event);
+
+ this._addClass(this.helper, "ui-draggable-dragging");
+
+ //Cache the helper size
+ this._cacheHelperProportions();
+
+ //If ddmanager is used for droppables, set the global draggable
+ if ($.ui.ddmanager) {
+ $.ui.ddmanager.current = this;
+ }
+
+ /*
+ * - Position generation -
+ * This block generates everything position related - it's the core of draggables.
+ */
+
+ //Cache the margins of the original element
+ this._cacheMargins();
+
+ //Store the helper's css position
+ this.cssPosition = this.helper.css("position");
+ this.scrollParent = this.helper.scrollParent(true);
+ this.offsetParent = this.helper.offsetParent();
+ this.hasFixedAncestor = this.helper.parents().filter(function () {
+ return $(this).css("position") === "fixed";
+ }).length > 0;
+
+ //The element's absolute position on the page minus margins
+ this.positionAbs = this.element.offset();
+ this._refreshOffsets(event);
+
+ //Generate the original position
+ this.originalPosition = this.position = this._generatePosition(event, false);
+ this.originalPageX = event.pageX;
+ this.originalPageY = event.pageY;
+
+ //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
+ (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
+
+ //Set a containment if given in the options
+ this._setContainment();
+
+ //Trigger event + callbacks
+ if (this._trigger("start", event) === false) {
+ this._clear();
+ return false;
+ }
+
+ //Recache the helper size
+ this._cacheHelperProportions();
+
+ //Prepare the droppable offsets
+ if ($.ui.ddmanager && !o.dropBehaviour) {
+ $.ui.ddmanager.prepareOffsets(this, event);
+ }
+
+ // Execute the drag once - this causes the helper not to be visible before getting its
+ // correct position
+ this._mouseDrag(event, true);
+
+ // If the ddmanager is used for droppables, inform the manager that dragging has started
+ // (see #5003)
+ if ($.ui.ddmanager) {
+ $.ui.ddmanager.dragStart(this, event);
+ }
+
+ return true;
+ },
+
+ _refreshOffsets: function (event) {
+ this.offset = {
+ top: this.positionAbs.top - this.margins.top,
+ left: this.positionAbs.left - this.margins.left,
+ scroll: false,
+ parent: this._getParentOffset(),
+ relative: this._getRelativeOffset()
+ };
+
+ this.offset.click = {
+ left: event.pageX - this.offset.left,
+ top: event.pageY - this.offset.top
+ };
+ },
+
+ _mouseDrag: function (event, noPropagation) {
+
+ // reset any necessary cached properties (see #5009)
+ if (this.hasFixedAncestor) {
+ this.offset.parent = this._getParentOffset();
+ }
+
+ //Compute the helpers position
+ this.position = this._generatePosition(event, true);
+ this.positionAbs = this._convertPositionTo("absolute");
+
+ //Call plugins and callbacks and use the resulting position if something is returned
+ if (!noPropagation) {
+ var ui = this._uiHash();
+ if (this._trigger("drag", event, ui) === false) {
+ this._mouseUp(new $.Event("mouseup", event));
+ return false;
+ }
+ this.position = ui.position;
+ }
+
+ this.helper[0].style.left = this.position.left + "px";
+ this.helper[0].style.top = this.position.top + "px";
+
+ if ($.ui.ddmanager) {
+ $.ui.ddmanager.drag(this, event);
+ }
+
+ return false;
+ },
+
+ _mouseStop: function (event) {
+
+ //If we are using droppables, inform the manager about the drop
+ var that = this,
+ dropped = false;
+ if ($.ui.ddmanager && !this.options.dropBehaviour) {
+ dropped = $.ui.ddmanager.drop(this, event);
+ }
+
+ //if a drop comes from outside (a sortable)
+ if (this.dropped) {
+ dropped = this.dropped;
+ this.dropped = false;
+ }
+
+ if ((this.options.revert === "invalid" && !dropped) ||
+ (this.options.revert === "valid" && dropped) ||
+ this.options.revert === true || ($.isFunction(this.options.revert) &&
+ this.options.revert.call(this.element, dropped))
+ ) {
+ $(this.helper).animate(
+ this.originalPosition,
+ parseInt(this.options.revertDuration, 10),
+ function () {
+ if (that._trigger("stop", event) !== false) {
+ that._clear();
+ }
+ }
+ );
+ } else {
+ if (this._trigger("stop", event) !== false) {
+ this._clear();
+ }
+ }
+
+ return false;
+ },
+
+ _mouseUp: function (event) {
+ this._unblockFrames();
+
+ // If the ddmanager is used for droppables, inform the manager that dragging has stopped
+ // (see #5003)
+ if ($.ui.ddmanager) {
+ $.ui.ddmanager.dragStop(this, event);
+ }
+
+ // Only need to focus if the event occurred on the draggable itself, see #10527
+ if (this.handleElement.is(event.target)) {
+
+ // The interaction is over; whether or not the click resulted in a drag,
+ // focus the element
+ this.element.trigger("focus");
+ }
+
+ return $.ui.mouse.prototype._mouseUp.call(this, event);
+ },
+
+ cancel: function () {
+
+ if (this.helper.is(".ui-draggable-dragging")) {
+ this._mouseUp(new $.Event("mouseup", { target: this.element[0] }));
+ } else {
+ this._clear();
+ }
+
+ return this;
+
+ },
+
+ _getHandle: function (event) {
+ return this.options.handle ?
+ !!$(event.target).closest(this.element.find(this.options.handle)).length :
+ true;
+ },
+
+ _setHandleClassName: function () {
+ this.handleElement = this.options.handle ?
+ this.element.find(this.options.handle) : this.element;
+ this._addClass(this.handleElement, "ui-draggable-handle");
+ },
+
+ _removeHandleClassName: function () {
+ this._removeClass(this.handleElement, "ui-draggable-handle");
+ },
+
+ _createHelper: function (event) {
+
+ var o = this.options,
+ helperIsFunction = $.isFunction(o.helper),
+ helper = helperIsFunction ?
+ $(o.helper.apply(this.element[0], [event])) :
+ (o.helper === "clone" ?
+ this.element.clone().removeAttr("id") :
+ this.element);
+
+ if (!helper.parents("body").length) {
+ helper.appendTo((o.appendTo === "parent" ?
+ this.element[0].parentNode :
+ o.appendTo));
+ }
+
+ // Http://bugs.jqueryui.com/ticket/9446
+ // a helper function can return the original element
+ // which wouldn't have been set to relative in _create
+ if (helperIsFunction && helper[0] === this.element[0]) {
+ this._setPositionRelative();
+ }
+
+ if (helper[0] !== this.element[0] &&
+ !(/(fixed|absolute)/).test(helper.css("position"))) {
+ helper.css("position", "absolute");
+ }
+
+ return helper;
+
+ },
+
+ _setPositionRelative: function () {
+ if (!(/^(?:r|a|f)/).test(this.element.css("position"))) {
+ this.element[0].style.position = "relative";
+ }
+ },
+
+ _adjustOffsetFromHelper: function (obj) {
+ if (typeof obj === "string") {
+ obj = obj.split(" ");
+ }
+ if ($.isArray(obj)) {
+ obj = { left: +obj[0], top: +obj[1] || 0 };
+ }
+ if ("left" in obj) {
+ this.offset.click.left = obj.left + this.margins.left;
+ }
+ if ("right" in obj) {
+ this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
+ }
+ if ("top" in obj) {
+ this.offset.click.top = obj.top + this.margins.top;
+ }
+ if ("bottom" in obj) {
+ this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
+ }
+ },
+
+ _isRootNode: function (element) {
+ return (/(html|body)/i).test(element.tagName) || element === this.document[0];
+ },
+
+ _getParentOffset: function () {
+
+ //Get the offsetParent and cache its position
+ var po = this.offsetParent.offset(),
+ document = this.document[0];
+
+ // This is a special case where we need to modify a offset calculated on start, since the
+ // following happened:
+ // 1. The position of the helper is absolute, so it's position is calculated based on the
+ // next positioned parent
+ // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't
+ // the document, which means that the scroll is included in the initial calculation of the
+ // offset of the parent, and never recalculated upon drag
+ if (this.cssPosition === "absolute" && this.scrollParent[0] !== document &&
+ $.contains(this.scrollParent[0], this.offsetParent[0])) {
+ po.left += this.scrollParent.scrollLeft();
+ po.top += this.scrollParent.scrollTop();
+ }
+
+ if (this._isRootNode(this.offsetParent[0])) {
+ po = { top: 0, left: 0 };
+ }
+
+ return {
+ top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"), 10) || 0),
+ left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"), 10) || 0)
+ };
+
+ },
+
+ _getRelativeOffset: function () {
+ if (this.cssPosition !== "relative") {
+ return { top: 0, left: 0 };
+ }
+
+ var p = this.element.position(),
+ scrollIsRootNode = this._isRootNode(this.scrollParent[0]);
+
+ return {
+ top: p.top - (parseInt(this.helper.css("top"), 10) || 0) +
+ (!scrollIsRootNode ? this.scrollParent.scrollTop() : 0),
+ left: p.left - (parseInt(this.helper.css("left"), 10) || 0) +
+ (!scrollIsRootNode ? this.scrollParent.scrollLeft() : 0)
+ };
+
+ },
+
+ _cacheMargins: function () {
+ this.margins = {
+ left: (parseInt(this.element.css("marginLeft"), 10) || 0),
+ top: (parseInt(this.element.css("marginTop"), 10) || 0),
+ right: (parseInt(this.element.css("marginRight"), 10) || 0),
+ bottom: (parseInt(this.element.css("marginBottom"), 10) || 0)
+ };
+ },
+
+ _cacheHelperProportions: function () {
+ this.helperProportions = {
+ width: this.helper.outerWidth(),
+ height: this.helper.outerHeight()
+ };
+ },
+
+ _setContainment: function () {
+
+ var isUserScrollable, c, ce,
+ o = this.options,
+ document = this.document[0];
+
+ this.relativeContainer = null;
+
+ if (!o.containment) {
+ this.containment = null;
+ return;
+ }
+
+ if (o.containment === "window") {
+ this.containment = [
+ $(window).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
+ $(window).scrollTop() - this.offset.relative.top - this.offset.parent.top,
+ $(window).scrollLeft() + $(window).width() -
+ this.helperProportions.width - this.margins.left,
+ $(window).scrollTop() +
+ ($(window).height() || document.body.parentNode.scrollHeight) -
+ this.helperProportions.height - this.margins.top
+ ];
+ return;
+ }
+
+ if (o.containment === "document") {
+ this.containment = [
+ 0,
+ 0,
+ $(document).width() - this.helperProportions.width - this.margins.left,
+ ($(document).height() || document.body.parentNode.scrollHeight) -
+ this.helperProportions.height - this.margins.top
+ ];
+ return;
+ }
+
+ if (o.containment.constructor === Array) {
+ this.containment = o.containment;
+ return;
+ }
+
+ if (o.containment === "parent") {
+ o.containment = this.helper[0].parentNode;
+ }
+
+ c = $(o.containment);
+ ce = c[0];
+
+ if (!ce) {
+ return;
+ }
+
+ isUserScrollable = /(scroll|auto)/.test(c.css("overflow"));
+
+ this.containment = [
+ (parseInt(c.css("borderLeftWidth"), 10) || 0) +
+ (parseInt(c.css("paddingLeft"), 10) || 0),
+ (parseInt(c.css("borderTopWidth"), 10) || 0) +
+ (parseInt(c.css("paddingTop"), 10) || 0),
+ (isUserScrollable ? Math.max(ce.scrollWidth, ce.offsetWidth) : ce.offsetWidth) -
+ (parseInt(c.css("borderRightWidth"), 10) || 0) -
+ (parseInt(c.css("paddingRight"), 10) || 0) -
+ this.helperProportions.width -
+ this.margins.left -
+ this.margins.right,
+ (isUserScrollable ? Math.max(ce.scrollHeight, ce.offsetHeight) : ce.offsetHeight) -
+ (parseInt(c.css("borderBottomWidth"), 10) || 0) -
+ (parseInt(c.css("paddingBottom"), 10) || 0) -
+ this.helperProportions.height -
+ this.margins.top -
+ this.margins.bottom
+ ];
+ this.relativeContainer = c;
+ },
+
+ _convertPositionTo: function (d, pos) {
+
+ if (!pos) {
+ pos = this.position;
+ }
+
+ var mod = d === "absolute" ? 1 : -1,
+ scrollIsRootNode = this._isRootNode(this.scrollParent[0]);
+
+ return {
+ top: (
+
+ // The absolute mouse position
+ pos.top +
+
+ // Only for relative positioned nodes: Relative offset from element to offset parent
+ this.offset.relative.top * mod +
+
+ // The offsetParent's offset without borders (offset + border)
+ this.offset.parent.top * mod -
+ ((this.cssPosition === "fixed" ?
+ -this.offset.scroll.top :
+ (scrollIsRootNode ? 0 : this.offset.scroll.top)) * mod)
+ ),
+ left: (
+
+ // The absolute mouse position
+ pos.left +
+
+ // Only for relative positioned nodes: Relative offset from element to offset parent
+ this.offset.relative.left * mod +
+
+ // The offsetParent's offset without borders (offset + border)
+ this.offset.parent.left * mod -
+ ((this.cssPosition === "fixed" ?
+ -this.offset.scroll.left :
+ (scrollIsRootNode ? 0 : this.offset.scroll.left)) * mod)
+ )
+ };
+
+ },
+
+ _generatePosition: function (event, constrainPosition) {
+
+ var containment, co, top, left,
+ o = this.options,
+ scrollIsRootNode = this._isRootNode(this.scrollParent[0]),
+ pageX = event.pageX,
+ pageY = event.pageY;
+
+ // Cache the scroll
+ if (!scrollIsRootNode || !this.offset.scroll) {
+ this.offset.scroll = {
+ top: this.scrollParent.scrollTop(),
+ left: this.scrollParent.scrollLeft()
+ };
+ }
+
+ /*
+ * - Position constraining -
+ * Constrain the position to a mix of grid, containment.
+ */
+
+ // If we are not dragging yet, we won't check for options
+ if (constrainPosition) {
+ if (this.containment) {
+ if (this.relativeContainer) {
+ co = this.relativeContainer.offset();
+ containment = [
+ this.containment[0] + co.left,
+ this.containment[1] + co.top,
+ this.containment[2] + co.left,
+ this.containment[3] + co.top
+ ];
+ } else {
+ containment = this.containment;
+ }
+
+ if (event.pageX - this.offset.click.left < containment[0]) {
+ pageX = containment[0] + this.offset.click.left;
+ }
+ if (event.pageY - this.offset.click.top < containment[1]) {
+ pageY = containment[1] + this.offset.click.top;
+ }
+ if (event.pageX - this.offset.click.left > containment[2]) {
+ pageX = containment[2] + this.offset.click.left;
+ }
+ if (event.pageY - this.offset.click.top > containment[3]) {
+ pageY = containment[3] + this.offset.click.top;
+ }
+ }
+
+ if (o.grid) {
+
+ //Check for grid elements set to 0 to prevent divide by 0 error causing invalid
+ // argument errors in IE (see ticket #6950)
+ top = o.grid[1] ? this.originalPageY + Math.round((pageY -
+ this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
+ pageY = containment ? ((top - this.offset.click.top >= containment[1] ||
+ top - this.offset.click.top > containment[3]) ?
+ top :
+ ((top - this.offset.click.top >= containment[1]) ?
+ top - o.grid[1] : top + o.grid[1])) : top;
+
+ left = o.grid[0] ? this.originalPageX +
+ Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] :
+ this.originalPageX;
+ pageX = containment ? ((left - this.offset.click.left >= containment[0] ||
+ left - this.offset.click.left > containment[2]) ?
+ left :
+ ((left - this.offset.click.left >= containment[0]) ?
+ left - o.grid[0] : left + o.grid[0])) : left;
+ }
+
+ if (o.axis === "y") {
+ pageX = this.originalPageX;
+ }
+
+ if (o.axis === "x") {
+ pageY = this.originalPageY;
+ }
+ }
+
+ return {
+ top: (
+
+ // The absolute mouse position
+ pageY -
+
+ // Click offset (relative to the element)
+ this.offset.click.top -
+
+ // Only for relative positioned nodes: Relative offset from element to offset parent
+ this.offset.relative.top -
+
+ // The offsetParent's offset without borders (offset + border)
+ this.offset.parent.top +
+ (this.cssPosition === "fixed" ?
+ -this.offset.scroll.top :
+ (scrollIsRootNode ? 0 : this.offset.scroll.top))
+ ),
+ left: (
+
+ // The absolute mouse position
+ pageX -
+
+ // Click offset (relative to the element)
+ this.offset.click.left -
+
+ // Only for relative positioned nodes: Relative offset from element to offset parent
+ this.offset.relative.left -
+
+ // The offsetParent's offset without borders (offset + border)
+ this.offset.parent.left +
+ (this.cssPosition === "fixed" ?
+ -this.offset.scroll.left :
+ (scrollIsRootNode ? 0 : this.offset.scroll.left))
+ )
+ };
+
+ },
+
+ _clear: function () {
+ this._removeClass(this.helper, "ui-draggable-dragging");
+ if (this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
+ this.helper.remove();
+ }
+ this.helper = null;
+ this.cancelHelperRemoval = false;
+ if (this.destroyOnClear) {
+ this.destroy();
+ }
+ },
+
+ // From now on bulk stuff - mainly helpers
+
+ _trigger: function (type, event, ui) {
+ ui = ui || this._uiHash();
+ $.ui.plugin.call(this, type, [event, ui, this], true);
+
+ // Absolute position and offset (see #6884 ) have to be recalculated after plugins
+ if (/^(drag|start|stop)/.test(type)) {
+ this.positionAbs = this._convertPositionTo("absolute");
+ ui.offset = this.positionAbs;
+ }
+ return $.Widget.prototype._trigger.call(this, type, event, ui);
+ },
+
+ plugins: {},
+
+ _uiHash: function () {
+ return {
+ helper: this.helper,
+ position: this.position,
+ originalPosition: this.originalPosition,
+ offset: this.positionAbs
+ };
+ }
+
+ });
+
+ $.ui.plugin.add("draggable", "connectToSortable", {
+ start: function (event, ui, draggable) {
+ var uiSortable = $.extend({}, ui, {
+ item: draggable.element
+ });
+
+ draggable.sortables = [];
+ $(draggable.options.connectToSortable).each(function () {
+ var sortable = $(this).sortable("instance");
+
+ if (sortable && !sortable.options.disabled) {
+ draggable.sortables.push(sortable);
+
+ // RefreshPositions is called at drag start to refresh the containerCache
+ // which is used in drag. This ensures it's initialized and synchronized
+ // with any changes that might have happened on the page since initialization.
+ sortable.refreshPositions();
+ sortable._trigger("activate", event, uiSortable);
+ }
+ });
+ },
+ stop: function (event, ui, draggable) {
+ var uiSortable = $.extend({}, ui, {
+ item: draggable.element
+ });
+
+ draggable.cancelHelperRemoval = false;
+
+ $.each(draggable.sortables, function () {
+ var sortable = this;
+
+ if (sortable.isOver) {
+ sortable.isOver = 0;
+
+ // Allow this sortable to handle removing the helper
+ draggable.cancelHelperRemoval = true;
+ sortable.cancelHelperRemoval = false;
+
+ // Use _storedCSS To restore properties in the sortable,
+ // as this also handles revert (#9675) since the draggable
+ // may have modified them in unexpected ways (#8809)
+ sortable._storedCSS = {
+ position: sortable.placeholder.css("position"),
+ top: sortable.placeholder.css("top"),
+ left: sortable.placeholder.css("left")
+ };
+
+ sortable._mouseStop(event);
+
+ // Once drag has ended, the sortable should return to using
+ // its original helper, not the shared helper from draggable
+ sortable.options.helper = sortable.options._helper;
+ } else {
+
+ // Prevent this Sortable from removing the helper.
+ // However, don't set the draggable to remove the helper
+ // either as another connected Sortable may yet handle the removal.
+ sortable.cancelHelperRemoval = true;
+
+ sortable._trigger("deactivate", event, uiSortable);
+ }
+ });
+ },
+ drag: function (event, ui, draggable) {
+ $.each(draggable.sortables, function () {
+ var innermostIntersecting = false,
+ sortable = this;
+
+ // Copy over variables that sortable's _intersectsWith uses
+ sortable.positionAbs = draggable.positionAbs;
+ sortable.helperProportions = draggable.helperProportions;
+ sortable.offset.click = draggable.offset.click;
+
+ if (sortable._intersectsWith(sortable.containerCache)) {
+ innermostIntersecting = true;
+
+ $.each(draggable.sortables, function () {
+
+ // Copy over variables that sortable's _intersectsWith uses
+ this.positionAbs = draggable.positionAbs;
+ this.helperProportions = draggable.helperProportions;
+ this.offset.click = draggable.offset.click;
+
+ if (this !== sortable &&
+ this._intersectsWith(this.containerCache) &&
+ $.contains(sortable.element[0], this.element[0])) {
+ innermostIntersecting = false;
+ }
+
+ return innermostIntersecting;
+ });
+ }
+
+ if (innermostIntersecting) {
+
+ // If it intersects, we use a little isOver variable and set it once,
+ // so that the move-in stuff gets fired only once.
+ if (!sortable.isOver) {
+ sortable.isOver = 1;
+
+ // Store draggable's parent in case we need to reappend to it later.
+ draggable._parent = ui.helper.parent();
+
+ sortable.currentItem = ui.helper
+ .appendTo(sortable.element)
+ .data("ui-sortable-item", true);
+
+ // Store helper option to later restore it
+ sortable.options._helper = sortable.options.helper;
+
+ sortable.options.helper = function () {
+ return ui.helper[0];
+ };
+
+ // Fire the start events of the sortable with our passed browser event,
+ // and our own helper (so it doesn't create a new one)
+ event.target = sortable.currentItem[0];
+ sortable._mouseCapture(event, true);
+ sortable._mouseStart(event, true, true);
+
+ // Because the browser event is way off the new appended portlet,
+ // modify necessary variables to reflect the changes
+ sortable.offset.click.top = draggable.offset.click.top;
+ sortable.offset.click.left = draggable.offset.click.left;
+ sortable.offset.parent.left -= draggable.offset.parent.left -
+ sortable.offset.parent.left;
+ sortable.offset.parent.top -= draggable.offset.parent.top -
+ sortable.offset.parent.top;
+
+ draggable._trigger("toSortable", event);
+
+ // Inform draggable that the helper is in a valid drop zone,
+ // used solely in the revert option to handle "valid/invalid".
+ draggable.dropped = sortable.element;
+
+ // Need to refreshPositions of all sortables in the case that
+ // adding to one sortable changes the location of the other sortables (#9675)
+ $.each(draggable.sortables, function () {
+ this.refreshPositions();
+ });
+
+ // Hack so receive/update callbacks work (mostly)
+ draggable.currentItem = draggable.element;
+ sortable.fromOutside = draggable;
+ }
+
+ if (sortable.currentItem) {
+ sortable._mouseDrag(event);
+
+ // Copy the sortable's position because the draggable's can potentially reflect
+ // a relative position, while sortable is always absolute, which the dragged
+ // element has now become. (#8809)
+ ui.position = sortable.position;
+ }
+ } else {
+
+ // If it doesn't intersect with the sortable, and it intersected before,
+ // we fake the drag stop of the sortable, but make sure it doesn't remove
+ // the helper by using cancelHelperRemoval.
+ if (sortable.isOver) {
+
+ sortable.isOver = 0;
+ sortable.cancelHelperRemoval = true;
+
+ // Calling sortable's mouseStop would trigger a revert,
+ // so revert must be temporarily false until after mouseStop is called.
+ sortable.options._revert = sortable.options.revert;
+ sortable.options.revert = false;
+
+ sortable._trigger("out", event, sortable._uiHash(sortable));
+ sortable._mouseStop(event, true);
+
+ // Restore sortable behaviors that were modfied
+ // when the draggable entered the sortable area (#9481)
+ sortable.options.revert = sortable.options._revert;
+ sortable.options.helper = sortable.options._helper;
+
+ if (sortable.placeholder) {
+ sortable.placeholder.remove();
+ }
+
+ // Restore and recalculate the draggable's offset considering the sortable
+ // may have modified them in unexpected ways. (#8809, #10669)
+ ui.helper.appendTo(draggable._parent);
+ draggable._refreshOffsets(event);
+ ui.position = draggable._generatePosition(event, true);
+
+ draggable._trigger("fromSortable", event);
+
+ // Inform draggable that the helper is no longer in a valid drop zone
+ draggable.dropped = false;
+
+ // Need to refreshPositions of all sortables just in case removing
+ // from one sortable changes the location of other sortables (#9675)
+ $.each(draggable.sortables, function () {
+ this.refreshPositions();
+ });
+ }
+ }
+ });
+ }
+ });
+
+ $.ui.plugin.add("draggable", "cursor", {
+ start: function (event, ui, instance) {
+ var t = $("body"),
+ o = instance.options;
+
+ if (t.css("cursor")) {
+ o._cursor = t.css("cursor");
+ }
+ t.css("cursor", o.cursor);
+ },
+ stop: function (event, ui, instance) {
+ var o = instance.options;
+ if (o._cursor) {
+ $("body").css("cursor", o._cursor);
+ }
+ }
+ });
+
+ $.ui.plugin.add("draggable", "opacity", {
+ start: function (event, ui, instance) {
+ var t = $(ui.helper),
+ o = instance.options;
+ if (t.css("opacity")) {
+ o._opacity = t.css("opacity");
+ }
+ t.css("opacity", o.opacity);
+ },
+ stop: function (event, ui, instance) {
+ var o = instance.options;
+ if (o._opacity) {
+ $(ui.helper).css("opacity", o._opacity);
+ }
+ }
+ });
+
+ $.ui.plugin.add("draggable", "scroll", {
+ start: function (event, ui, i) {
+ if (!i.scrollParentNotHidden) {
+ i.scrollParentNotHidden = i.helper.scrollParent(false);
+ }
+
+ if (i.scrollParentNotHidden[0] !== i.document[0] &&
+ i.scrollParentNotHidden[0].tagName !== "HTML") {
+ i.overflowOffset = i.scrollParentNotHidden.offset();
+ }
+ },
+ drag: function (event, ui, i) {
+
+ var o = i.options,
+ scrolled = false,
+ scrollParent = i.scrollParentNotHidden[0],
+ document = i.document[0];
+
+ if (scrollParent !== document && scrollParent.tagName !== "HTML") {
+ if (!o.axis || o.axis !== "x") {
+ if ((i.overflowOffset.top + scrollParent.offsetHeight) - event.pageY <
+ o.scrollSensitivity) {
+ scrollParent.scrollTop = scrolled = scrollParent.scrollTop + o.scrollSpeed;
+ } else if (event.pageY - i.overflowOffset.top < o.scrollSensitivity) {
+ scrollParent.scrollTop = scrolled = scrollParent.scrollTop - o.scrollSpeed;
+ }
+ }
+
+ if (!o.axis || o.axis !== "y") {
+ if ((i.overflowOffset.left + scrollParent.offsetWidth) - event.pageX <
+ o.scrollSensitivity) {
+ scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft + o.scrollSpeed;
+ } else if (event.pageX - i.overflowOffset.left < o.scrollSensitivity) {
+ scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft - o.scrollSpeed;
+ }
+ }
+
+ } else {
+
+ if (!o.axis || o.axis !== "x") {
+ if (event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
+ scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
+ } else if ($(window).height() - (event.pageY - $(document).scrollTop()) <
+ o.scrollSensitivity) {
+ scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
+ }
+ }
+
+ if (!o.axis || o.axis !== "y") {
+ if (event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
+ scrolled = $(document).scrollLeft(
+ $(document).scrollLeft() - o.scrollSpeed
+ );
+ } else if ($(window).width() - (event.pageX - $(document).scrollLeft()) <
+ o.scrollSensitivity) {
+ scrolled = $(document).scrollLeft(
+ $(document).scrollLeft() + o.scrollSpeed
+ );
+ }
+ }
+
+ }
+
+ if (scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
+ $.ui.ddmanager.prepareOffsets(i, event);
+ }
+
+ }
+ });
+
+ $.ui.plugin.add("draggable", "snap", {
+ start: function (event, ui, i) {
+
+ var o = i.options;
+
+ i.snapElements = [];
+
+ $(o.snap.constructor !== String ? (o.snap.items || ":data(ui-draggable)") : o.snap)
+ .each(function () {
+ var $t = $(this),
+ $o = $t.offset();
+ if (this !== i.element[0]) {
+ i.snapElements.push({
+ item: this,
+ width: $t.outerWidth(), height: $t.outerHeight(),
+ top: $o.top, left: $o.left
+ });
+ }
+ });
+
+ },
+ drag: function (event, ui, inst) {
+
+ var ts, bs, ls, rs, l, r, t, b, i, first,
+ o = inst.options,
+ d = o.snapTolerance,
+ x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
+ y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
+
+ for (i = inst.snapElements.length - 1; i >= 0; i--) {
+
+ l = inst.snapElements[i].left - inst.margins.left;
+ r = l + inst.snapElements[i].width;
+ t = inst.snapElements[i].top - inst.margins.top;
+ b = t + inst.snapElements[i].height;
+
+ if (x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d ||
+ !$.contains(inst.snapElements[i].item.ownerDocument,
+ inst.snapElements[i].item)) {
+ if (inst.snapElements[i].snapping) {
+ (inst.options.snap.release &&
+ inst.options.snap.release.call(
+ inst.element,
+ event,
+ $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })
+ ));
+ }
+ inst.snapElements[i].snapping = false;
+ continue;
+ }
+
+ if (o.snapMode !== "inner") {
+ ts = Math.abs(t - y2) <= d;
+ bs = Math.abs(b - y1) <= d;
+ ls = Math.abs(l - x2) <= d;
+ rs = Math.abs(r - x1) <= d;
+ if (ts) {
+ ui.position.top = inst._convertPositionTo("relative", {
+ top: t - inst.helperProportions.height,
+ left: 0
+ }).top;
+ }
+ if (bs) {
+ ui.position.top = inst._convertPositionTo("relative", {
+ top: b,
+ left: 0
+ }).top;
+ }
+ if (ls) {
+ ui.position.left = inst._convertPositionTo("relative", {
+ top: 0,
+ left: l - inst.helperProportions.width
+ }).left;
+ }
+ if (rs) {
+ ui.position.left = inst._convertPositionTo("relative", {
+ top: 0,
+ left: r
+ }).left;
+ }
+ }
+
+ first = (ts || bs || ls || rs);
+
+ if (o.snapMode !== "outer") {
+ ts = Math.abs(t - y1) <= d;
+ bs = Math.abs(b - y2) <= d;
+ ls = Math.abs(l - x1) <= d;
+ rs = Math.abs(r - x2) <= d;
+ if (ts) {
+ ui.position.top = inst._convertPositionTo("relative", {
+ top: t,
+ left: 0
+ }).top;
+ }
+ if (bs) {
+ ui.position.top = inst._convertPositionTo("relative", {
+ top: b - inst.helperProportions.height,
+ left: 0
+ }).top;
+ }
+ if (ls) {
+ ui.position.left = inst._convertPositionTo("relative", {
+ top: 0,
+ left: l
+ }).left;
+ }
+ if (rs) {
+ ui.position.left = inst._convertPositionTo("relative", {
+ top: 0,
+ left: r - inst.helperProportions.width
+ }).left;
+ }
+ }
+
+ if (!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
+ (inst.options.snap.snap &&
+ inst.options.snap.snap.call(
+ inst.element,
+ event,
+ $.extend(inst._uiHash(), {
+ snapItem: inst.snapElements[i].item
+ })));
+ }
+ inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
+
+ }
+
+ }
+ });
+
+ $.ui.plugin.add("draggable", "stack", {
+ start: function (event, ui, instance) {
+ var min,
+ o = instance.options,
+ group = $.makeArray($(o.stack)).sort(function (a, b) {
+ return (parseInt($(a).css("zIndex"), 10) || 0) -
+ (parseInt($(b).css("zIndex"), 10) || 0);
+ });
+
+ if (!group.length) { return; }
+
+ min = parseInt($(group[0]).css("zIndex"), 10) || 0;
+ $(group).each(function (i) {
+ $(this).css("zIndex", min + i);
+ });
+ this.css("zIndex", (min + group.length));
+ }
+ });
+
+ $.ui.plugin.add("draggable", "zIndex", {
+ start: function (event, ui, instance) {
+ var t = $(ui.helper),
+ o = instance.options;
+
+ if (t.css("zIndex")) {
+ o._zIndex = t.css("zIndex");
+ }
+ t.css("zIndex", o.zIndex);
+ },
+ stop: function (event, ui, instance) {
+ var o = instance.options;
+
+ if (o._zIndex) {
+ $(ui.helper).css("zIndex", o._zIndex);
+ }
+ }
+ });
+
+ var widgetsDraggable = $.ui.draggable;
+
+
+ /*!
+ * jQuery UI Resizable 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Resizable
+ //>>group: Interactions
+ //>>description: Enables resize functionality for any element.
+ //>>docs: http://api.jqueryui.com/resizable/
+ //>>demos: http://jqueryui.com/resizable/
+ //>>css.structure: ../../themes/base/core.css
+ //>>css.structure: ../../themes/base/resizable.css
+ //>>css.theme: ../../themes/base/theme.css
+
+
+
+ $.widget("ui.resizable", $.ui.mouse, {
+ version: "1.12.1",
+ widgetEventPrefix: "resize",
+ options: {
+ alsoResize: false,
+ animate: false,
+ animateDuration: "slow",
+ animateEasing: "swing",
+ aspectRatio: false,
+ autoHide: false,
+ classes: {
+ "ui-resizable-se": "ui-icon ui-icon-gripsmall-diagonal-se"
+ },
+ containment: false,
+ ghost: false,
+ grid: false,
+ handles: "e,s,se",
+ helper: false,
+ maxHeight: null,
+ maxWidth: null,
+ minHeight: 10,
+ minWidth: 10,
+
+ // See #7960
+ zIndex: 90,
+
+ // Callbacks
+ resize: null,
+ start: null,
+ stop: null
+ },
+
+ _num: function (value) {
+ return parseFloat(value) || 0;
+ },
+
+ _isNumber: function (value) {
+ return !isNaN(parseFloat(value));
+ },
+
+ _hasScroll: function (el, a) {
+
+ if ($(el).css("overflow") === "hidden") {
+ return false;
+ }
+
+ var scroll = (a && a === "left") ? "scrollLeft" : "scrollTop",
+ has = false;
+
+ if (el[scroll] > 0) {
+ return true;
+ }
+
+ // TODO: determine which cases actually cause this to happen
+ // if the element doesn't have the scroll set, see if it's possible to
+ // set the scroll
+ el[scroll] = 1;
+ has = (el[scroll] > 0);
+ el[scroll] = 0;
+ return has;
+ },
+
+ _create: function () {
+
+ var margins,
+ o = this.options,
+ that = this;
+ this._addClass("ui-resizable");
+
+ $.extend(this, {
+ _aspectRatio: !!(o.aspectRatio),
+ aspectRatio: o.aspectRatio,
+ originalElement: this.element,
+ _proportionallyResizeElements: [],
+ _helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
+ });
+
+ // Wrap the element if it cannot hold child nodes
+ if (this.element[0].nodeName.match(/^(canvas|textarea|input|select|button|img)$/i)) {
+
+ this.element.wrap(
+ $("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({
+ position: this.element.css("position"),
+ width: this.element.outerWidth(),
+ height: this.element.outerHeight(),
+ top: this.element.css("top"),
+ left: this.element.css("left")
+ })
+ );
+
+ this.element = this.element.parent().data(
+ "ui-resizable", this.element.resizable("instance")
+ );
+
+ this.elementIsWrapper = true;
+
+ margins = {
+ marginTop: this.originalElement.css("marginTop"),
+ marginRight: this.originalElement.css("marginRight"),
+ marginBottom: this.originalElement.css("marginBottom"),
+ marginLeft: this.originalElement.css("marginLeft")
+ };
+
+ this.element.css(margins);
+ this.originalElement.css("margin", 0);
+
+ // support: Safari
+ // Prevent Safari textarea resize
+ this.originalResizeStyle = this.originalElement.css("resize");
+ this.originalElement.css("resize", "none");
+
+ this._proportionallyResizeElements.push(this.originalElement.css({
+ position: "static",
+ zoom: 1,
+ display: "block"
+ }));
+
+ // Support: IE9
+ // avoid IE jump (hard set the margin)
+ this.originalElement.css(margins);
+
+ this._proportionallyResize();
+ }
+
+ this._setupHandles();
+
+ if (o.autoHide) {
+ $(this.element)
+ .on("mouseenter", function () {
+ if (o.disabled) {
+ return;
+ }
+ that._removeClass("ui-resizable-autohide");
+ that._handles.show();
+ })
+ .on("mouseleave", function () {
+ if (o.disabled) {
+ return;
+ }
+ if (!that.resizing) {
+ that._addClass("ui-resizable-autohide");
+ that._handles.hide();
+ }
+ });
+ }
+
+ this._mouseInit();
+ },
+
+ _destroy: function () {
+
+ this._mouseDestroy();
+
+ var wrapper,
+ _destroy = function (exp) {
+ $(exp)
+ .removeData("resizable")
+ .removeData("ui-resizable")
+ .off(".resizable")
+ .find(".ui-resizable-handle")
+ .remove();
+ };
+
+ // TODO: Unwrap at same DOM position
+ if (this.elementIsWrapper) {
+ _destroy(this.element);
+ wrapper = this.element;
+ this.originalElement.css({
+ position: wrapper.css("position"),
+ width: wrapper.outerWidth(),
+ height: wrapper.outerHeight(),
+ top: wrapper.css("top"),
+ left: wrapper.css("left")
+ }).insertAfter(wrapper);
+ wrapper.remove();
+ }
+
+ this.originalElement.css("resize", this.originalResizeStyle);
+ _destroy(this.originalElement);
+
+ return this;
+ },
+
+ _setOption: function (key, value) {
+ this._super(key, value);
+
+ switch (key) {
+ case "handles":
+ this._removeHandles();
+ this._setupHandles();
+ break;
+ default:
+ break;
+ }
+ },
+
+ _setupHandles: function () {
+ var o = this.options, handle, i, n, hname, axis, that = this;
+ this.handles = o.handles ||
+ (!$(".ui-resizable-handle", this.element).length ?
+ "e,s,se" : {
+ n: ".ui-resizable-n",
+ e: ".ui-resizable-e",
+ s: ".ui-resizable-s",
+ w: ".ui-resizable-w",
+ se: ".ui-resizable-se",
+ sw: ".ui-resizable-sw",
+ ne: ".ui-resizable-ne",
+ nw: ".ui-resizable-nw"
+ });
+
+ this._handles = $();
+ if (this.handles.constructor === String) {
+
+ if (this.handles === "all") {
+ this.handles = "n,e,s,w,se,sw,ne,nw";
+ }
+
+ n = this.handles.split(",");
+ this.handles = {};
+
+ for (i = 0; i < n.length; i++) {
+
+ handle = $.trim(n[i]);
+ hname = "ui-resizable-" + handle;
+ axis = $("<div>");
+ this._addClass(axis, "ui-resizable-handle " + hname);
+
+ axis.css({ zIndex: o.zIndex });
+
+ this.handles[handle] = ".ui-resizable-" + handle;
+ this.element.append(axis);
+ }
+
+ }
+
+ this._renderAxis = function (target) {
+
+ var i, axis, padPos, padWrapper;
+
+ target = target || this.element;
+
+ for (i in this.handles) {
+
+ if (this.handles[i].constructor === String) {
+ this.handles[i] = this.element.children(this.handles[i]).first().show();
+ } else if (this.handles[i].jquery || this.handles[i].nodeType) {
+ this.handles[i] = $(this.handles[i]);
+ this._on(this.handles[i], { "mousedown": that._mouseDown });
+ }
+
+ if (this.elementIsWrapper &&
+ this.originalElement[0]
+ .nodeName
+ .match(/^(textarea|input|select|button)$/i)) {
+ axis = $(this.handles[i], this.element);
+
+ padWrapper = /sw|ne|nw|se|n|s/.test(i) ?
+ axis.outerHeight() :
+ axis.outerWidth();
+
+ padPos = ["padding",
+ /ne|nw|n/.test(i) ? "Top" :
+ /se|sw|s/.test(i) ? "Bottom" :
+ /^e$/.test(i) ? "Right" : "Left"].join("");
+
+ target.css(padPos, padWrapper);
+
+ this._proportionallyResize();
+ }
+
+ this._handles = this._handles.add(this.handles[i]);
+ }
+ };
+
+ // TODO: make renderAxis a prototype function
+ this._renderAxis(this.element);
+
+ this._handles = this._handles.add(this.element.find(".ui-resizable-handle"));
+ this._handles.disableSelection();
+
+ this._handles.on("mouseover", function () {
+ if (!that.resizing) {
+ if (this.className) {
+ axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
+ }
+ that.axis = axis && axis[1] ? axis[1] : "se";
+ }
+ });
+
+ if (o.autoHide) {
+ this._handles.hide();
+ this._addClass("ui-resizable-autohide");
+ }
+ },
+
+ _removeHandles: function () {
+ this._handles.remove();
+ },
+
+ _mouseCapture: function (event) {
+ var i, handle,
+ capture = false;
+
+ for (i in this.handles) {
+ handle = $(this.handles[i])[0];
+ if (handle === event.target || $.contains(handle, event.target)) {
+ capture = true;
+ }
+ }
+
+ return !this.options.disabled && capture;
+ },
+
+ _mouseStart: function (event) {
+
+ var curleft, curtop, cursor,
+ o = this.options,
+ el = this.element;
+
+ this.resizing = true;
+
+ this._renderProxy();
+
+ curleft = this._num(this.helper.css("left"));
+ curtop = this._num(this.helper.css("top"));
+
+ if (o.containment) {
+ curleft += $(o.containment).scrollLeft() || 0;
+ curtop += $(o.containment).scrollTop() || 0;
+ }
+
+ this.offset = this.helper.offset();
+ this.position = { left: curleft, top: curtop };
+
+ this.size = this._helper ? {
+ width: this.helper.width(),
+ height: this.helper.height()
+ } : {
+ width: el.width(),
+ height: el.height()
+ };
+
+ this.originalSize = this._helper ? {
+ width: el.outerWidth(),
+ height: el.outerHeight()
+ } : {
+ width: el.width(),
+ height: el.height()
+ };
+
+ this.sizeDiff = {
+ width: el.outerWidth() - el.width(),
+ height: el.outerHeight() - el.height()
+ };
+
+ this.originalPosition = { left: curleft, top: curtop };
+ this.originalMousePosition = { left: event.pageX, top: event.pageY };
+
+ this.aspectRatio = (typeof o.aspectRatio === "number") ?
+ o.aspectRatio :
+ ((this.originalSize.width / this.originalSize.height) || 1);
+
+ cursor = $(".ui-resizable-" + this.axis).css("cursor");
+ $("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
+
+ this._addClass("ui-resizable-resizing");
+ this._propagate("start", event);
+ return true;
+ },
+
+ _mouseDrag: function (event) {
+
+ var data, props,
+ smp = this.originalMousePosition,
+ a = this.axis,
+ dx = (event.pageX - smp.left) || 0,
+ dy = (event.pageY - smp.top) || 0,
+ trigger = this._change[a];
+
+ this._updatePrevProperties();
+
+ if (!trigger) {
+ return false;
+ }
+
+ data = trigger.apply(this, [event, dx, dy]);
+
+ this._updateVirtualBoundaries(event.shiftKey);
+ if (this._aspectRatio || event.shiftKey) {
+ data = this._updateRatio(data, event);
+ }
+
+ data = this._respectSize(data, event);
+
+ this._updateCache(data);
+
+ this._propagate("resize", event);
+
+ props = this._applyChanges();
+
+ if (!this._helper && this._proportionallyResizeElements.length) {
+ this._proportionallyResize();
+ }
+
+ if (!$.isEmptyObject(props)) {
+ this._updatePrevProperties();
+ this._trigger("resize", event, this.ui());
+ this._applyChanges();
+ }
+
+ return false;
+ },
+
+ _mouseStop: function (event) {
+
+ this.resizing = false;
+ var pr, ista, soffseth, soffsetw, s, left, top,
+ o = this.options, that = this;
+
+ if (this._helper) {
+
+ pr = this._proportionallyResizeElements;
+ ista = pr.length && (/textarea/i).test(pr[0].nodeName);
+ soffseth = ista && this._hasScroll(pr[0], "left") ? 0 : that.sizeDiff.height;
+ soffsetw = ista ? 0 : that.sizeDiff.width;
+
+ s = {
+ width: (that.helper.width() - soffsetw),
+ height: (that.helper.height() - soffseth)
+ };
+ left = (parseFloat(that.element.css("left")) +
+ (that.position.left - that.originalPosition.left)) || null;
+ top = (parseFloat(that.element.css("top")) +
+ (that.position.top - that.originalPosition.top)) || null;
+
+ if (!o.animate) {
+ this.element.css($.extend(s, { top: top, left: left }));
+ }
+
+ that.helper.height(that.size.height);
+ that.helper.width(that.size.width);
+
+ if (this._helper && !o.animate) {
+ this._proportionallyResize();
+ }
+ }
+
+ $("body").css("cursor", "auto");
+
+ this._removeClass("ui-resizable-resizing");
+
+ this._propagate("stop", event);
+
+ if (this._helper) {
+ this.helper.remove();
+ }
+
+ return false;
+
+ },
+
+ _updatePrevProperties: function () {
+ this.prevPosition = {
+ top: this.position.top,
+ left: this.position.left
+ };
+ this.prevSize = {
+ width: this.size.width,
+ height: this.size.height
+ };
+ },
+
+ _applyChanges: function () {
+ var props = {};
+
+ if (this.position.top !== this.prevPosition.top) {
+ props.top = this.position.top + "px";
+ }
+ if (this.position.left !== this.prevPosition.left) {
+ props.left = this.position.left + "px";
+ }
+ if (this.size.width !== this.prevSize.width) {
+ props.width = this.size.width + "px";
+ }
+ if (this.size.height !== this.prevSize.height) {
+ props.height = this.size.height + "px";
+ }
+
+ this.helper.css(props);
+
+ return props;
+ },
+
+ _updateVirtualBoundaries: function (forceAspectRatio) {
+ var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
+ o = this.options;
+
+ b = {
+ minWidth: this._isNumber(o.minWidth) ? o.minWidth : 0,
+ maxWidth: this._isNumber(o.maxWidth) ? o.maxWidth : Infinity,
+ minHeight: this._isNumber(o.minHeight) ? o.minHeight : 0,
+ maxHeight: this._isNumber(o.maxHeight) ? o.maxHeight : Infinity
+ };
+
+ if (this._aspectRatio || forceAspectRatio) {
+ pMinWidth = b.minHeight * this.aspectRatio;
+ pMinHeight = b.minWidth / this.aspectRatio;
+ pMaxWidth = b.maxHeight * this.aspectRatio;
+ pMaxHeight = b.maxWidth / this.aspectRatio;
+
+ if (pMinWidth > b.minWidth) {
+ b.minWidth = pMinWidth;
+ }
+ if (pMinHeight > b.minHeight) {
+ b.minHeight = pMinHeight;
+ }
+ if (pMaxWidth < b.maxWidth) {
+ b.maxWidth = pMaxWidth;
+ }
+ if (pMaxHeight < b.maxHeight) {
+ b.maxHeight = pMaxHeight;
+ }
+ }
+ this._vBoundaries = b;
+ },
+
+ _updateCache: function (data) {
+ this.offset = this.helper.offset();
+ if (this._isNumber(data.left)) {
+ this.position.left = data.left;
+ }
+ if (this._isNumber(data.top)) {
+ this.position.top = data.top;
+ }
+ if (this._isNumber(data.height)) {
+ this.size.height = data.height;
+ }
+ if (this._isNumber(data.width)) {
+ this.size.width = data.width;
+ }
+ },
+
+ _updateRatio: function (data) {
+
+ var cpos = this.position,
+ csize = this.size,
+ a = this.axis;
+
+ if (this._isNumber(data.height)) {
+ data.width = (data.height * this.aspectRatio);
+ } else if (this._isNumber(data.width)) {
+ data.height = (data.width / this.aspectRatio);
+ }
+
+ if (a === "sw") {
+ data.left = cpos.left + (csize.width - data.width);
+ data.top = null;
+ }
+ if (a === "nw") {
+ data.top = cpos.top + (csize.height - data.height);
+ data.left = cpos.left + (csize.width - data.width);
+ }
+
+ return data;
+ },
+
+ _respectSize: function (data) {
+
+ var o = this._vBoundaries,
+ a = this.axis,
+ ismaxw = this._isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width),
+ ismaxh = this._isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
+ isminw = this._isNumber(data.width) && o.minWidth && (o.minWidth > data.width),
+ isminh = this._isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
+ dw = this.originalPosition.left + this.originalSize.width,
+ dh = this.originalPosition.top + this.originalSize.height,
+ cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
+ if (isminw) {
+ data.width = o.minWidth;
+ }
+ if (isminh) {
+ data.height = o.minHeight;
+ }
+ if (ismaxw) {
+ data.width = o.maxWidth;
+ }
+ if (ismaxh) {
+ data.height = o.maxHeight;
+ }
+
+ if (isminw && cw) {
+ data.left = dw - o.minWidth;
+ }
+ if (ismaxw && cw) {
+ data.left = dw - o.maxWidth;
+ }
+ if (isminh && ch) {
+ data.top = dh - o.minHeight;
+ }
+ if (ismaxh && ch) {
+ data.top = dh - o.maxHeight;
+ }
+
+ // Fixing jump error on top/left - bug #2330
+ if (!data.width && !data.height && !data.left && data.top) {
+ data.top = null;
+ } else if (!data.width && !data.height && !data.top && data.left) {
+ data.left = null;
+ }
+
+ return data;
+ },
+
+ _getPaddingPlusBorderDimensions: function (element) {
+ var i = 0,
+ widths = [],
+ borders = [
+ element.css("borderTopWidth"),
+ element.css("borderRightWidth"),
+ element.css("borderBottomWidth"),
+ element.css("borderLeftWidth")
+ ],
+ paddings = [
+ element.css("paddingTop"),
+ element.css("paddingRight"),
+ element.css("paddingBottom"),
+ element.css("paddingLeft")
+ ];
+
+ for (; i < 4; i++) {
+ widths[i] = (parseFloat(borders[i]) || 0);
+ widths[i] += (parseFloat(paddings[i]) || 0);
+ }
+
+ return {
+ height: widths[0] + widths[2],
+ width: widths[1] + widths[3]
+ };
+ },
+
+ _proportionallyResize: function () {
+
+ if (!this._proportionallyResizeElements.length) {
+ return;
+ }
+
+ var prel,
+ i = 0,
+ element = this.helper || this.element;
+
+ for (; i < this._proportionallyResizeElements.length; i++) {
+
+ prel = this._proportionallyResizeElements[i];
+
+ // TODO: Seems like a bug to cache this.outerDimensions
+ // considering that we are in a loop.
+ if (!this.outerDimensions) {
+ this.outerDimensions = this._getPaddingPlusBorderDimensions(prel);
+ }
+
+ prel.css({
+ height: (element.height() - this.outerDimensions.height) || 0,
+ width: (element.width() - this.outerDimensions.width) || 0
+ });
+
+ }
+
+ },
+
+ _renderProxy: function () {
+
+ var el = this.element, o = this.options;
+ this.elementOffset = el.offset();
+
+ if (this._helper) {
+
+ this.helper = this.helper || $("<div style='overflow:hidden;'></div>");
+
+ this._addClass(this.helper, this._helper);
+ this.helper.css({
+ width: this.element.outerWidth(),
+ height: this.element.outerHeight(),
+ position: "absolute",
+ left: this.elementOffset.left + "px",
+ top: this.elementOffset.top + "px",
+ zIndex: ++o.zIndex //TODO: Don't modify option
+ });
+
+ this.helper
+ .appendTo("body")
+ .disableSelection();
+
+ } else {
+ this.helper = this.element;
+ }
+
+ },
+
+ _change: {
+ e: function (event, dx) {
+ return { width: this.originalSize.width + dx };
+ },
+ w: function (event, dx) {
+ var cs = this.originalSize, sp = this.originalPosition;
+ return { left: sp.left + dx, width: cs.width - dx };
+ },
+ n: function (event, dx, dy) {
+ var cs = this.originalSize, sp = this.originalPosition;
+ return { top: sp.top + dy, height: cs.height - dy };
+ },
+ s: function (event, dx, dy) {
+ return { height: this.originalSize.height + dy };
+ },
+ se: function (event, dx, dy) {
+ return $.extend(this._change.s.apply(this, arguments),
+ this._change.e.apply(this, [event, dx, dy]));
+ },
+ sw: function (event, dx, dy) {
+ return $.extend(this._change.s.apply(this, arguments),
+ this._change.w.apply(this, [event, dx, dy]));
+ },
+ ne: function (event, dx, dy) {
+ return $.extend(this._change.n.apply(this, arguments),
+ this._change.e.apply(this, [event, dx, dy]));
+ },
+ nw: function (event, dx, dy) {
+ return $.extend(this._change.n.apply(this, arguments),
+ this._change.w.apply(this, [event, dx, dy]));
+ }
+ },
+
+ _propagate: function (n, event) {
+ $.ui.plugin.call(this, n, [event, this.ui()]);
+ (n !== "resize" && this._trigger(n, event, this.ui()));
+ },
+
+ plugins: {},
+
+ ui: function () {
+ return {
+ originalElement: this.originalElement,
+ element: this.element,
+ helper: this.helper,
+ position: this.position,
+ size: this.size,
+ originalSize: this.originalSize,
+ originalPosition: this.originalPosition
+ };
+ }
+
+ });
+
+ /*
+ * Resizable Extensions
+ */
+
+ $.ui.plugin.add("resizable", "animate", {
+
+ stop: function (event) {
+ var that = $(this).resizable("instance"),
+ o = that.options,
+ pr = that._proportionallyResizeElements,
+ ista = pr.length && (/textarea/i).test(pr[0].nodeName),
+ soffseth = ista && that._hasScroll(pr[0], "left") ? 0 : that.sizeDiff.height,
+ soffsetw = ista ? 0 : that.sizeDiff.width,
+ style = {
+ width: (that.size.width - soffsetw),
+ height: (that.size.height - soffseth)
+ },
+ left = (parseFloat(that.element.css("left")) +
+ (that.position.left - that.originalPosition.left)) || null,
+ top = (parseFloat(that.element.css("top")) +
+ (that.position.top - that.originalPosition.top)) || null;
+
+ that.element.animate(
+ $.extend(style, top && left ? { top: top, left: left } : {}), {
+ duration: o.animateDuration,
+ easing: o.animateEasing,
+ step: function () {
+
+ var data = {
+ width: parseFloat(that.element.css("width")),
+ height: parseFloat(that.element.css("height")),
+ top: parseFloat(that.element.css("top")),
+ left: parseFloat(that.element.css("left"))
+ };
+
+ if (pr && pr.length) {
+ $(pr[0]).css({ width: data.width, height: data.height });
+ }
+
+ // Propagating resize, and updating values for each animation step
+ that._updateCache(data);
+ that._propagate("resize", event);
+
+ }
+ }
+ );
+ }
+
+ });
+
+ $.ui.plugin.add("resizable", "containment", {
+
+ start: function () {
+ var element, p, co, ch, cw, width, height,
+ that = $(this).resizable("instance"),
+ o = that.options,
+ el = that.element,
+ oc = o.containment,
+ ce = (oc instanceof $) ?
+ oc.get(0) :
+ (/parent/.test(oc)) ? el.parent().get(0) : oc;
+
+ if (!ce) {
+ return;
+ }
+
+ that.containerElement = $(ce);
+
+ if (/document/.test(oc) || oc === document) {
+ that.containerOffset = {
+ left: 0,
+ top: 0
+ };
+ that.containerPosition = {
+ left: 0,
+ top: 0
+ };
+
+ that.parentData = {
+ element: $(document),
+ left: 0,
+ top: 0,
+ width: $(document).width(),
+ height: $(document).height() || document.body.parentNode.scrollHeight
+ };
+ } else {
+ element = $(ce);
+ p = [];
+ $(["Top", "Right", "Left", "Bottom"]).each(function (i, name) {
+ p[i] = that._num(element.css("padding" + name));
+ });
+
+ that.containerOffset = element.offset();
+ that.containerPosition = element.position();
+ that.containerSize = {
+ height: (element.innerHeight() - p[3]),
+ width: (element.innerWidth() - p[1])
+ };
+
+ co = that.containerOffset;
+ ch = that.containerSize.height;
+ cw = that.containerSize.width;
+ width = (that._hasScroll(ce, "left") ? ce.scrollWidth : cw);
+ height = (that._hasScroll(ce) ? ce.scrollHeight : ch);
+
+ that.parentData = {
+ element: ce,
+ left: co.left,
+ top: co.top,
+ width: width,
+ height: height
+ };
+ }
+ },
+
+ resize: function (event) {
+ var woset, hoset, isParent, isOffsetRelative,
+ that = $(this).resizable("instance"),
+ o = that.options,
+ co = that.containerOffset,
+ cp = that.position,
+ pRatio = that._aspectRatio || event.shiftKey,
+ cop = {
+ top: 0,
+ left: 0
+ },
+ ce = that.containerElement,
+ continueResize = true;
+
+ if (ce[0] !== document && (/static/).test(ce.css("position"))) {
+ cop = co;
+ }
+
+ if (cp.left < (that._helper ? co.left : 0)) {
+ that.size.width = that.size.width +
+ (that._helper ?
+ (that.position.left - co.left) :
+ (that.position.left - cop.left));
+
+ if (pRatio) {
+ that.size.height = that.size.width / that.aspectRatio;
+ continueResize = false;
+ }
+ that.position.left = o.helper ? co.left : 0;
+ }
+
+ if (cp.top < (that._helper ? co.top : 0)) {
+ that.size.height = that.size.height +
+ (that._helper ?
+ (that.position.top - co.top) :
+ that.position.top);
+
+ if (pRatio) {
+ that.size.width = that.size.height * that.aspectRatio;
+ continueResize = false;
+ }
+ that.position.top = that._helper ? co.top : 0;
+ }
+
+ isParent = that.containerElement.get(0) === that.element.parent().get(0);
+ isOffsetRelative = /relative|absolute/.test(that.containerElement.css("position"));
+
+ if (isParent && isOffsetRelative) {
+ that.offset.left = that.parentData.left + that.position.left;
+ that.offset.top = that.parentData.top + that.position.top;
+ } else {
+ that.offset.left = that.element.offset().left;
+ that.offset.top = that.element.offset().top;
+ }
+
+ woset = Math.abs(that.sizeDiff.width +
+ (that._helper ?
+ that.offset.left - cop.left :
+ (that.offset.left - co.left)));
+
+ hoset = Math.abs(that.sizeDiff.height +
+ (that._helper ?
+ that.offset.top - cop.top :
+ (that.offset.top - co.top)));
+
+ if (woset + that.size.width >= that.parentData.width) {
+ that.size.width = that.parentData.width - woset;
+ if (pRatio) {
+ that.size.height = that.size.width / that.aspectRatio;
+ continueResize = false;
+ }
+ }
+
+ if (hoset + that.size.height >= that.parentData.height) {
+ that.size.height = that.parentData.height - hoset;
+ if (pRatio) {
+ that.size.width = that.size.height * that.aspectRatio;
+ continueResize = false;
+ }
+ }
+
+ if (!continueResize) {
+ that.position.left = that.prevPosition.left;
+ that.position.top = that.prevPosition.top;
+ that.size.width = that.prevSize.width;
+ that.size.height = that.prevSize.height;
+ }
+ },
+
+ stop: function () {
+ var that = $(this).resizable("instance"),
+ o = that.options,
+ co = that.containerOffset,
+ cop = that.containerPosition,
+ ce = that.containerElement,
+ helper = $(that.helper),
+ ho = helper.offset(),
+ w = helper.outerWidth() - that.sizeDiff.width,
+ h = helper.outerHeight() - that.sizeDiff.height;
+
+ if (that._helper && !o.animate && (/relative/).test(ce.css("position"))) {
+ $(this).css({
+ left: ho.left - cop.left - co.left,
+ width: w,
+ height: h
+ });
+ }
+
+ if (that._helper && !o.animate && (/static/).test(ce.css("position"))) {
+ $(this).css({
+ left: ho.left - cop.left - co.left,
+ width: w,
+ height: h
+ });
+ }
+ }
+ });
+
+ $.ui.plugin.add("resizable", "alsoResize", {
+
+ start: function () {
+ var that = $(this).resizable("instance"),
+ o = that.options;
+
+ $(o.alsoResize).each(function () {
+ var el = $(this);
+ el.data("ui-resizable-alsoresize", {
+ width: parseFloat(el.width()), height: parseFloat(el.height()),
+ left: parseFloat(el.css("left")), top: parseFloat(el.css("top"))
+ });
+ });
+ },
+
+ resize: function (event, ui) {
+ var that = $(this).resizable("instance"),
+ o = that.options,
+ os = that.originalSize,
+ op = that.originalPosition,
+ delta = {
+ height: (that.size.height - os.height) || 0,
+ width: (that.size.width - os.width) || 0,
+ top: (that.position.top - op.top) || 0,
+ left: (that.position.left - op.left) || 0
+ };
+
+ $(o.alsoResize).each(function () {
+ var el = $(this), start = $(this).data("ui-resizable-alsoresize"), style = {},
+ css = el.parents(ui.originalElement[0]).length ?
+ ["width", "height"] :
+ ["width", "height", "top", "left"];
+
+ $.each(css, function (i, prop) {
+ var sum = (start[prop] || 0) + (delta[prop] || 0);
+ if (sum && sum >= 0) {
+ style[prop] = sum || null;
+ }
+ });
+
+ el.css(style);
+ });
+ },
+
+ stop: function () {
+ $(this).removeData("ui-resizable-alsoresize");
+ }
+ });
+
+ $.ui.plugin.add("resizable", "ghost", {
+
+ start: function () {
+
+ var that = $(this).resizable("instance"), cs = that.size;
+
+ that.ghost = that.originalElement.clone();
+ that.ghost.css({
+ opacity: 0.25,
+ display: "block",
+ position: "relative",
+ height: cs.height,
+ width: cs.width,
+ margin: 0,
+ left: 0,
+ top: 0
+ });
+
+ that._addClass(that.ghost, "ui-resizable-ghost");
+
+ // DEPRECATED
+ // TODO: remove after 1.12
+ if ($.uiBackCompat !== false && typeof that.options.ghost === "string") {
+
+ // Ghost option
+ that.ghost.addClass(this.options.ghost);
+ }
+
+ that.ghost.appendTo(that.helper);
+
+ },
+
+ resize: function () {
+ var that = $(this).resizable("instance");
+ if (that.ghost) {
+ that.ghost.css({
+ position: "relative",
+ height: that.size.height,
+ width: that.size.width
+ });
+ }
+ },
+
+ stop: function () {
+ var that = $(this).resizable("instance");
+ if (that.ghost && that.helper) {
+ that.helper.get(0).removeChild(that.ghost.get(0));
+ }
+ }
+
+ });
+
+ $.ui.plugin.add("resizable", "grid", {
+
+ resize: function () {
+ var outerDimensions,
+ that = $(this).resizable("instance"),
+ o = that.options,
+ cs = that.size,
+ os = that.originalSize,
+ op = that.originalPosition,
+ a = that.axis,
+ grid = typeof o.grid === "number" ? [o.grid, o.grid] : o.grid,
+ gridX = (grid[0] || 1),
+ gridY = (grid[1] || 1),
+ ox = Math.round((cs.width - os.width) / gridX) * gridX,
+ oy = Math.round((cs.height - os.height) / gridY) * gridY,
+ newWidth = os.width + ox,
+ newHeight = os.height + oy,
+ isMaxWidth = o.maxWidth && (o.maxWidth < newWidth),
+ isMaxHeight = o.maxHeight && (o.maxHeight < newHeight),
+ isMinWidth = o.minWidth && (o.minWidth > newWidth),
+ isMinHeight = o.minHeight && (o.minHeight > newHeight);
+
+ o.grid = grid;
+
+ if (isMinWidth) {
+ newWidth += gridX;
+ }
+ if (isMinHeight) {
+ newHeight += gridY;
+ }
+ if (isMaxWidth) {
+ newWidth -= gridX;
+ }
+ if (isMaxHeight) {
+ newHeight -= gridY;
+ }
+
+ if (/^(se|s|e)$/.test(a)) {
+ that.size.width = newWidth;
+ that.size.height = newHeight;
+ } else if (/^(ne)$/.test(a)) {
+ that.size.width = newWidth;
+ that.size.height = newHeight;
+ that.position.top = op.top - oy;
+ } else if (/^(sw)$/.test(a)) {
+ that.size.width = newWidth;
+ that.size.height = newHeight;
+ that.position.left = op.left - ox;
+ } else {
+ if (newHeight - gridY <= 0 || newWidth - gridX <= 0) {
+ outerDimensions = that._getPaddingPlusBorderDimensions(this);
+ }
+
+ if (newHeight - gridY > 0) {
+ that.size.height = newHeight;
+ that.position.top = op.top - oy;
+ } else {
+ newHeight = gridY - outerDimensions.height;
+ that.size.height = newHeight;
+ that.position.top = op.top + os.height - newHeight;
+ }
+ if (newWidth - gridX > 0) {
+ that.size.width = newWidth;
+ that.position.left = op.left - ox;
+ } else {
+ newWidth = gridX - outerDimensions.width;
+ that.size.width = newWidth;
+ that.position.left = op.left + os.width - newWidth;
+ }
+ }
+ }
+
+ });
+
+ var widgetsResizable = $.ui.resizable;
+
+
+ /*!
+ * jQuery UI Dialog 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Dialog
+ //>>group: Widgets
+ //>>description: Displays customizable dialog windows.
+ //>>docs: http://api.jqueryui.com/dialog/
+ //>>demos: http://jqueryui.com/dialog/
+ //>>css.structure: ../../themes/base/core.css
+ //>>css.structure: ../../themes/base/dialog.css
+ //>>css.theme: ../../themes/base/theme.css
+
+
+
+ $.widget("ui.dialog", {
+ version: "1.12.1",
+ options: {
+ appendTo: "body",
+ autoOpen: true,
+ buttons: [],
+ classes: {
+ "ui-dialog": "ui-corner-all",
+ "ui-dialog-titlebar": "ui-corner-all"
+ },
+ closeOnEscape: true,
+ closeText: "Close",
+ draggable: true,
+ hide: null,
+ height: "auto",
+ maxHeight: null,
+ maxWidth: null,
+ minHeight: 150,
+ minWidth: 150,
+ modal: false,
+ position: {
+ my: "center",
+ at: "center",
+ of: window,
+ collision: "fit",
+
+ // Ensure the titlebar is always visible
+ using: function (pos) {
+ var topOffset = $(this).css(pos).offset().top;
+ if (topOffset < 0) {
+ $(this).css("top", pos.top - topOffset);
+ }
+ }
+ },
+ resizable: true,
+ show: null,
+ title: null,
+ width: 300,
+
+ // Callbacks
+ beforeClose: null,
+ close: null,
+ drag: null,
+ dragStart: null,
+ dragStop: null,
+ focus: null,
+ open: null,
+ resize: null,
+ resizeStart: null,
+ resizeStop: null
+ },
+
+ sizeRelatedOptions: {
+ buttons: true,
+ height: true,
+ maxHeight: true,
+ maxWidth: true,
+ minHeight: true,
+ minWidth: true,
+ width: true
+ },
+
+ resizableRelatedOptions: {
+ maxHeight: true,
+ maxWidth: true,
+ minHeight: true,
+ minWidth: true
+ },
+
+ _create: function () {
+ this.originalCss = {
+ display: this.element[0].style.display,
+ width: this.element[0].style.width,
+ minHeight: this.element[0].style.minHeight,
+ maxHeight: this.element[0].style.maxHeight,
+ height: this.element[0].style.height
+ };
+ this.originalPosition = {
+ parent: this.element.parent(),
+ index: this.element.parent().children().index(this.element)
+ };
+ this.originalTitle = this.element.attr("title");
+ if (this.options.title == null && this.originalTitle != null) {
+ this.options.title = this.originalTitle;
+ }
+
+ // Dialogs can't be disabled
+ if (this.options.disabled) {
+ this.options.disabled = false;
+ }
+
+ this._createWrapper();
+
+ this.element
+ .show()
+ .removeAttr("title")
+ .appendTo(this.uiDialog);
+
+ this._addClass("ui-dialog-content", "ui-widget-content");
+
+ this._createTitlebar();
+ this._createButtonPane();
+
+ if (this.options.draggable && $.fn.draggable) {
+ this._makeDraggable();
+ }
+ if (this.options.resizable && $.fn.resizable) {
+ this._makeResizable();
+ }
+
+ this._isOpen = false;
+
+ this._trackFocus();
+ },
+
+ _init: function () {
+ if (this.options.autoOpen) {
+ this.open();
+ }
+ },
+
+ _appendTo: function () {
+ var element = this.options.appendTo;
+ if (element && (element.jquery || element.nodeType)) {
+ return $(element);
+ }
+ return this.document.find(element || "body").eq(0);
+ },
+
+ _destroy: function () {
+ var next,
+ originalPosition = this.originalPosition;
+
+ this._untrackInstance();
+ this._destroyOverlay();
+
+ this.element
+ .removeUniqueId()
+ .css(this.originalCss)
+
+ // Without detaching first, the following becomes really slow
+ .detach();
+
+ this.uiDialog.remove();
+
+ if (this.originalTitle) {
+ this.element.attr("title", this.originalTitle);
+ }
+
+ next = originalPosition.parent.children().eq(originalPosition.index);
+
+ // Don't try to place the dialog next to itself (#8613)
+ if (next.length && next[0] !== this.element[0]) {
+ next.before(this.element);
+ } else {
+ originalPosition.parent.append(this.element);
+ }
+ },
+
+ widget: function () {
+ return this.uiDialog;
+ },
+
+ disable: $.noop,
+ enable: $.noop,
+
+ close: function (event) {
+ var that = this;
+
+ if (!this._isOpen || this._trigger("beforeClose", event) === false) {
+ return;
+ }
+
+ this._isOpen = false;
+ this._focusedElement = null;
+ this._destroyOverlay();
+ this._untrackInstance();
+
+ if (!this.opener.filter(":focusable").trigger("focus").length) {
+
+ // Hiding a focused element doesn't trigger blur in WebKit
+ // so in case we have nothing to focus on, explicitly blur the active element
+ // https://bugs.webkit.org/show_bug.cgi?id=47182
+ $.ui.safeBlur($.ui.safeActiveElement(this.document[0]));
+ }
+
+ this._hide(this.uiDialog, this.options.hide, function () {
+ that._trigger("close", event);
+ });
+ },
+
+ isOpen: function () {
+ return this._isOpen;
+ },
+
+ moveToTop: function () {
+ this._moveToTop();
+ },
+
+ _moveToTop: function (event, silent) {
+ var moved = false,
+ zIndices = this.uiDialog.siblings(".ui-front:visible").map(function () {
+ return +$(this).css("z-index");
+ }).get(),
+ zIndexMax = Math.max.apply(null, zIndices);
+
+ if (zIndexMax >= +this.uiDialog.css("z-index")) {
+ this.uiDialog.css("z-index", zIndexMax + 1);
+ moved = true;
+ }
+
+ if (moved && !silent) {
+ this._trigger("focus", event);
+ }
+ return moved;
+ },
+
+ open: function () {
+ var that = this;
+ if (this._isOpen) {
+ if (this._moveToTop()) {
+ this._focusTabbable();
+ }
+ return;
+ }
+
+ this._isOpen = true;
+ this.opener = $($.ui.safeActiveElement(this.document[0]));
+
+ this._size();
+ this._position();
+ this._createOverlay();
+ this._moveToTop(null, true);
+
+ // Ensure the overlay is moved to the top with the dialog, but only when
+ // opening. The overlay shouldn't move after the dialog is open so that
+ // modeless dialogs opened after the modal dialog stack properly.
+ if (this.overlay) {
+ this.overlay.css("z-index", this.uiDialog.css("z-index") - 1);
+ }
+
+ this._show(this.uiDialog, this.options.show, function () {
+ that._focusTabbable();
+ that._trigger("focus");
+ });
+
+ // Track the dialog immediately upon openening in case a focus event
+ // somehow occurs outside of the dialog before an element inside the
+ // dialog is focused (#10152)
+ this._makeFocusTarget();
+
+ this._trigger("open");
+ },
+
+ _focusTabbable: function () {
+
+ // Set focus to the first match:
+ // 1. An element that was focused previously
+ // 2. First element inside the dialog matching [autofocus]
+ // 3. Tabbable element inside the content element
+ // 4. Tabbable element inside the buttonpane
+ // 5. The close button
+ // 6. The dialog itself
+ var hasFocus = this._focusedElement;
+ if (!hasFocus) {
+ hasFocus = this.element.find("[autofocus]");
+ }
+ if (!hasFocus.length) {
+ hasFocus = this.element.find(":tabbable");
+ }
+ if (!hasFocus.length) {
+ hasFocus = this.uiDialogButtonPane.find(":tabbable");
+ }
+ if (!hasFocus.length) {
+ hasFocus = this.uiDialogTitlebarClose.filter(":tabbable");
+ }
+ if (!hasFocus.length) {
+ hasFocus = this.uiDialog;
+ }
+ hasFocus.eq(0).trigger("focus");
+ },
+
+ _keepFocus: function (event) {
+ function checkFocus() {
+ var activeElement = $.ui.safeActiveElement(this.document[0]),
+ isActive = this.uiDialog[0] === activeElement ||
+ $.contains(this.uiDialog[0], activeElement);
+ if (!isActive) {
+ this._focusTabbable();
+ }
+ }
+ event.preventDefault();
+ checkFocus.call(this);
+
+ // support: IE
+ // IE <= 8 doesn't prevent moving focus even with event.preventDefault()
+ // so we check again later
+ this._delay(checkFocus);
+ },
+
+ _createWrapper: function () {
+ this.uiDialog = $("<div>")
+ .hide()
+ .attr({
+
+ // Setting tabIndex makes the div focusable
+ tabIndex: -1,
+ role: "dialog"
+ })
+ .appendTo(this._appendTo());
+
+ this._addClass(this.uiDialog, "ui-dialog", "ui-widget ui-widget-content ui-front");
+ this._on(this.uiDialog, {
+ keydown: function (event) {
+ if (this.options.closeOnEscape && !event.isDefaultPrevented() && event.keyCode &&
+ event.keyCode === $.ui.keyCode.ESCAPE) {
+ event.preventDefault();
+ this.close(event);
+ return;
+ }
+
+ // Prevent tabbing out of dialogs
+ if (event.keyCode !== $.ui.keyCode.TAB || event.isDefaultPrevented()) {
+ return;
+ }
+ var tabbables = this.uiDialog.find(":tabbable"),
+ first = tabbables.filter(":first"),
+ last = tabbables.filter(":last");
+
+ if ((event.target === last[0] || event.target === this.uiDialog[0]) &&
+ !event.shiftKey) {
+ this._delay(function () {
+ first.trigger("focus");
+ });
+ event.preventDefault();
+ } else if ((event.target === first[0] ||
+ event.target === this.uiDialog[0]) && event.shiftKey) {
+ this._delay(function () {
+ last.trigger("focus");
+ });
+ event.preventDefault();
+ }
+ },
+ mousedown: function (event) {
+ if (this._moveToTop(event)) {
+ this._focusTabbable();
+ }
+ }
+ });
+
+ // We assume that any existing aria-describedby attribute means
+ // that the dialog content is marked up properly
+ // otherwise we brute force the content as the description
+ if (!this.element.find("[aria-describedby]").length) {
+ this.uiDialog.attr({
+ "aria-describedby": this.element.uniqueId().attr("id")
+ });
+ }
+ },
+
+ _createTitlebar: function () {
+ var uiDialogTitle;
+
+ this.uiDialogTitlebar = $("<div>");
+ this._addClass(this.uiDialogTitlebar,
+ "ui-dialog-titlebar", "ui-widget-header ui-helper-clearfix");
+ this._on(this.uiDialogTitlebar, {
+ mousedown: function (event) {
+
+ // Don't prevent click on close button (#8838)
+ // Focusing a dialog that is partially scrolled out of view
+ // causes the browser to scroll it into view, preventing the click event
+ if (!$(event.target).closest(".ui-dialog-titlebar-close")) {
+
+ // Dialog isn't getting focus when dragging (#8063)
+ this.uiDialog.trigger("focus");
+ }
+ }
+ });
+
+ // Support: IE
+ // Use type="button" to prevent enter keypresses in textboxes from closing the
+ // dialog in IE (#9312)
+ this.uiDialogTitlebarClose = $("<button type='button'></button>")
+ .button({
+ label: $("<a>").text(this.options.closeText).html(),
+ icon: "ui-icon-closethick",
+ showLabel: false
+ })
+ .appendTo(this.uiDialogTitlebar);
+
+ this._addClass(this.uiDialogTitlebarClose, "ui-dialog-titlebar-close");
+ this._on(this.uiDialogTitlebarClose, {
+ click: function (event) {
+ event.preventDefault();
+ this.close(event);
+ }
+ });
+
+ uiDialogTitle = $("<span>").uniqueId().prependTo(this.uiDialogTitlebar);
+ this._addClass(uiDialogTitle, "ui-dialog-title");
+ this._title(uiDialogTitle);
+
+ this.uiDialogTitlebar.prependTo(this.uiDialog);
+
+ this.uiDialog.attr({
+ "aria-labelledby": uiDialogTitle.attr("id")
+ });
+ },
+
+ _title: function (title) {
+ if (this.options.title) {
+ title.text(this.options.title);
+ } else {
+ title.html(" ");
+ }
+ },
+
+ _createButtonPane: function () {
+ this.uiDialogButtonPane = $("<div>");
+ this._addClass(this.uiDialogButtonPane, "ui-dialog-buttonpane",
+ "ui-widget-content ui-helper-clearfix");
+
+ this.uiButtonSet = $("<div>")
+ .appendTo(this.uiDialogButtonPane);
+ this._addClass(this.uiButtonSet, "ui-dialog-buttonset");
+
+ this._createButtons();
+ },
+
+ _createButtons: function () {
+ var that = this,
+ buttons = this.options.buttons;
+
+ // If we already have a button pane, remove it
+ this.uiDialogButtonPane.remove();
+ this.uiButtonSet.empty();
+
+ if ($.isEmptyObject(buttons) || ($.isArray(buttons) && !buttons.length)) {
+ this._removeClass(this.uiDialog, "ui-dialog-buttons");
+ return;
+ }
+
+ $.each(buttons, function (name, props) {
+ var click, buttonOptions;
+ props = $.isFunction(props) ?
+ { click: props, text: name } :
+ props;
+
+ // Default to a non-submitting button
+ props = $.extend({ type: "button" }, props);
+
+ // Change the context for the click callback to be the main element
+ click = props.click;
+ buttonOptions = {
+ icon: props.icon,
+ iconPosition: props.iconPosition,
+ showLabel: props.showLabel,
+
+ // Deprecated options
+ icons: props.icons,
+ text: props.text
+ };
+
+ delete props.click;
+ delete props.icon;
+ delete props.iconPosition;
+ delete props.showLabel;
+
+ // Deprecated options
+ delete props.icons;
+ if (typeof props.text === "boolean") {
+ delete props.text;
+ }
+
+ $("<button></button>", props)
+ .button(buttonOptions)
+ .appendTo(that.uiButtonSet)
+ .on("click", function () {
+ click.apply(that.element[0], arguments);
+ });
+ });
+ this._addClass(this.uiDialog, "ui-dialog-buttons");
+ this.uiDialogButtonPane.appendTo(this.uiDialog);
+ },
+
+ _makeDraggable: function () {
+ var that = this,
+ options = this.options;
+
+ function filteredUi(ui) {
+ return {
+ position: ui.position,
+ offset: ui.offset
+ };
+ }
+
+ this.uiDialog.draggable({
+ cancel: ".ui-dialog-content, .ui-dialog-titlebar-close",
+ handle: ".ui-dialog-titlebar",
+ containment: "document",
+ start: function (event, ui) {
+ that._addClass($(this), "ui-dialog-dragging");
+ that._blockFrames();
+ that._trigger("dragStart", event, filteredUi(ui));
+ },
+ drag: function (event, ui) {
+ that._trigger("drag", event, filteredUi(ui));
+ },
+ stop: function (event, ui) {
+ var left = ui.offset.left - that.document.scrollLeft(),
+ top = ui.offset.top - that.document.scrollTop();
+
+ options.position = {
+ my: "left top",
+ at: "left" + (left >= 0 ? "+" : "") + left + " " +
+ "top" + (top >= 0 ? "+" : "") + top,
+ of: that.window
+ };
+ that._removeClass($(this), "ui-dialog-dragging");
+ that._unblockFrames();
+ that._trigger("dragStop", event, filteredUi(ui));
+ }
+ });
+ },
+
+ _makeResizable: function () {
+ var that = this,
+ options = this.options,
+ handles = options.resizable,
+
+ // .ui-resizable has position: relative defined in the stylesheet
+ // but dialogs have to use absolute or fixed positioning
+ position = this.uiDialog.css("position"),
+ resizeHandles = typeof handles === "string" ?
+ handles :
+ "n,e,s,w,se,sw,ne,nw";
+
+ function filteredUi(ui) {
+ return {
+ originalPosition: ui.originalPosition,
+ originalSize: ui.originalSize,
+ position: ui.position,
+ size: ui.size
+ };
+ }
+
+ this.uiDialog.resizable({
+ cancel: ".ui-dialog-content",
+ containment: "document",
+ alsoResize: this.element,
+ maxWidth: options.maxWidth,
+ maxHeight: options.maxHeight,
+ minWidth: options.minWidth,
+ minHeight: this._minHeight(),
+ handles: resizeHandles,
+ start: function (event, ui) {
+ that._addClass($(this), "ui-dialog-resizing");
+ that._blockFrames();
+ that._trigger("resizeStart", event, filteredUi(ui));
+ },
+ resize: function (event, ui) {
+ that._trigger("resize", event, filteredUi(ui));
+ },
+ stop: function (event, ui) {
+ var offset = that.uiDialog.offset(),
+ left = offset.left - that.document.scrollLeft(),
+ top = offset.top - that.document.scrollTop();
+
+ options.height = that.uiDialog.height();
+ options.width = that.uiDialog.width();
+ options.position = {
+ my: "left top",
+ at: "left" + (left >= 0 ? "+" : "") + left + " " +
+ "top" + (top >= 0 ? "+" : "") + top,
+ of: that.window
+ };
+ that._removeClass($(this), "ui-dialog-resizing");
+ that._unblockFrames();
+ that._trigger("resizeStop", event, filteredUi(ui));
+ }
+ })
+ .css("position", position);
+ },
+
+ _trackFocus: function () {
+ this._on(this.widget(), {
+ focusin: function (event) {
+ this._makeFocusTarget();
+ this._focusedElement = $(event.target);
+ }
+ });
+ },
+
+ _makeFocusTarget: function () {
+ this._untrackInstance();
+ this._trackingInstances().unshift(this);
+ },
+
+ _untrackInstance: function () {
+ var instances = this._trackingInstances(),
+ exists = $.inArray(this, instances);
+ if (exists !== -1) {
+ instances.splice(exists, 1);
+ }
+ },
+
+ _trackingInstances: function () {
+ var instances = this.document.data("ui-dialog-instances");
+ if (!instances) {
+ instances = [];
+ this.document.data("ui-dialog-instances", instances);
+ }
+ return instances;
+ },
+
+ _minHeight: function () {
+ var options = this.options;
+
+ return options.height === "auto" ?
+ options.minHeight :
+ Math.min(options.minHeight, options.height);
+ },
+
+ _position: function () {
+
+ // Need to show the dialog to get the actual offset in the position plugin
+ var isVisible = this.uiDialog.is(":visible");
+ if (!isVisible) {
+ this.uiDialog.show();
+ }
+ this.uiDialog.position(this.options.position);
+ if (!isVisible) {
+ this.uiDialog.hide();
+ }
+ },
+
+ _setOptions: function (options) {
+ var that = this,
+ resize = false,
+ resizableOptions = {};
+
+ $.each(options, function (key, value) {
+ that._setOption(key, value);
+
+ if (key in that.sizeRelatedOptions) {
+ resize = true;
+ }
+ if (key in that.resizableRelatedOptions) {
+ resizableOptions[key] = value;
+ }
+ });
+
+ if (resize) {
+ this._size();
+ this._position();
+ }
+ if (this.uiDialog.is(":data(ui-resizable)")) {
+ this.uiDialog.resizable("option", resizableOptions);
+ }
+ },
+
+ _setOption: function (key, value) {
+ var isDraggable, isResizable,
+ uiDialog = this.uiDialog;
+
+ if (key === "disabled") {
+ return;
+ }
+
+ this._super(key, value);
+
+ if (key === "appendTo") {
+ this.uiDialog.appendTo(this._appendTo());
+ }
+
+ if (key === "buttons") {
+ this._createButtons();
+ }
+
+ if (key === "closeText") {
+ this.uiDialogTitlebarClose.button({
+
+ // Ensure that we always pass a string
+ label: $("<a>").text("" + this.options.closeText).html()
+ });
+ }
+
+ if (key === "draggable") {
+ isDraggable = uiDialog.is(":data(ui-draggable)");
+ if (isDraggable && !value) {
+ uiDialog.draggable("destroy");
+ }
+
+ if (!isDraggable && value) {
+ this._makeDraggable();
+ }
+ }
+
+ if (key === "position") {
+ this._position();
+ }
+
+ if (key === "resizable") {
+
+ // currently resizable, becoming non-resizable
+ isResizable = uiDialog.is(":data(ui-resizable)");
+ if (isResizable && !value) {
+ uiDialog.resizable("destroy");
+ }
+
+ // Currently resizable, changing handles
+ if (isResizable && typeof value === "string") {
+ uiDialog.resizable("option", "handles", value);
+ }
+
+ // Currently non-resizable, becoming resizable
+ if (!isResizable && value !== false) {
+ this._makeResizable();
+ }
+ }
+
+ if (key === "title") {
+ this._title(this.uiDialogTitlebar.find(".ui-dialog-title"));
+ }
+ },
+
+ _size: function () {
+
+ // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
+ // divs will both have width and height set, so we need to reset them
+ var nonContentHeight, minContentHeight, maxContentHeight,
+ options = this.options;
+
+ // Reset content sizing
+ this.element.show().css({
+ width: "auto",
+ minHeight: 0,
+ maxHeight: "none",
+ height: 0
+ });
+
+ if (options.minWidth > options.width) {
+ options.width = options.minWidth;
+ }
+
+ // Reset wrapper sizing
+ // determine the height of all the non-content elements
+ nonContentHeight = this.uiDialog.css({
+ height: "auto",
+ width: options.width
+ })
+ .outerHeight();
+ minContentHeight = Math.max(0, options.minHeight - nonContentHeight);
+ maxContentHeight = typeof options.maxHeight === "number" ?
+ Math.max(0, options.maxHeight - nonContentHeight) :
+ "none";
+
+ if (options.height === "auto") {
+ this.element.css({
+ minHeight: minContentHeight,
+ maxHeight: maxContentHeight,
+ height: "auto"
+ });
+ } else {
+ this.element.height(Math.max(0, options.height - nonContentHeight));
+ }
+
+ if (this.uiDialog.is(":data(ui-resizable)")) {
+ this.uiDialog.resizable("option", "minHeight", this._minHeight());
+ }
+ },
+
+ _blockFrames: function () {
+ this.iframeBlocks = this.document.find("iframe").map(function () {
+ var iframe = $(this);
+
+ return $("<div>")
+ .css({
+ position: "absolute",
+ width: iframe.outerWidth(),
+ height: iframe.outerHeight()
+ })
+ .appendTo(iframe.parent())
+ .offset(iframe.offset())[0];
+ });
+ },
+
+ _unblockFrames: function () {
+ if (this.iframeBlocks) {
+ this.iframeBlocks.remove();
+ delete this.iframeBlocks;
+ }
+ },
+
+ _allowInteraction: function (event) {
+ if ($(event.target).closest(".ui-dialog").length) {
+ return true;
+ }
+
+ // TODO: Remove hack when datepicker implements
+ // the .ui-front logic (#8989)
+ return !!$(event.target).closest(".ui-datepicker").length;
+ },
+
+ _createOverlay: function () {
+ if (!this.options.modal) {
+ return;
+ }
+
+ // We use a delay in case the overlay is created from an
+ // event that we're going to be cancelling (#2804)
+ var isOpening = true;
+ this._delay(function () {
+ isOpening = false;
+ });
+
+ if (!this.document.data("ui-dialog-overlays")) {
+
+ // Prevent use of anchors and inputs
+ // Using _on() for an event handler shared across many instances is
+ // safe because the dialogs stack and must be closed in reverse order
+ this._on(this.document, {
+ focusin: function (event) {
+ if (isOpening) {
+ return;
+ }
+
+ if (!this._allowInteraction(event)) {
+ event.preventDefault();
+ this._trackingInstances()[0]._focusTabbable();
+ }
+ }
+ });
+ }
+
+ this.overlay = $("<div>")
+ .appendTo(this._appendTo());
+
+ this._addClass(this.overlay, null, "ui-widget-overlay ui-front");
+ this._on(this.overlay, {
+ mousedown: "_keepFocus"
+ });
+ this.document.data("ui-dialog-overlays",
+ (this.document.data("ui-dialog-overlays") || 0) + 1);
+ },
+
+ _destroyOverlay: function () {
+ if (!this.options.modal) {
+ return;
+ }
+
+ if (this.overlay) {
+ var overlays = this.document.data("ui-dialog-overlays") - 1;
+
+ if (!overlays) {
+ this._off(this.document, "focusin");
+ this.document.removeData("ui-dialog-overlays");
+ } else {
+ this.document.data("ui-dialog-overlays", overlays);
+ }
+
+ this.overlay.remove();
+ this.overlay = null;
+ }
+ }
+ });
+
+ // DEPRECATED
+ // TODO: switch return back to widget declaration at top of file when this is removed
+ if ($.uiBackCompat !== false) {
+
+ // Backcompat for dialogClass option
+ $.widget("ui.dialog", $.ui.dialog, {
+ options: {
+ dialogClass: ""
+ },
+ _createWrapper: function () {
+ this._super();
+ this.uiDialog.addClass(this.options.dialogClass);
+ },
+ _setOption: function (key, value) {
+ if (key === "dialogClass") {
+ this.uiDialog
+ .removeClass(this.options.dialogClass)
+ .addClass(value);
+ }
+ this._superApply(arguments);
+ }
+ });
+ }
+
+ var widgetsDialog = $.ui.dialog;
+
+
+ /*!
+ * jQuery UI Droppable 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Droppable
+ //>>group: Interactions
+ //>>description: Enables drop targets for draggable elements.
+ //>>docs: http://api.jqueryui.com/droppable/
+ //>>demos: http://jqueryui.com/droppable/
+
+
+
+ $.widget("ui.droppable", {
+ version: "1.12.1",
+ widgetEventPrefix: "drop",
+ options: {
+ accept: "*",
+ addClasses: true,
+ greedy: false,
+ scope: "default",
+ tolerance: "intersect",
+
+ // Callbacks
+ activate: null,
+ deactivate: null,
+ drop: null,
+ out: null,
+ over: null
+ },
+ _create: function () {
+
+ var proportions,
+ o = this.options,
+ accept = o.accept;
+
+ this.isover = false;
+ this.isout = true;
+
+ this.accept = $.isFunction(accept) ? accept : function (d) {
+ return d.is(accept);
+ };
+
+ this.proportions = function ( /* valueToWrite */) {
+ if (arguments.length) {
+
+ // Store the droppable's proportions
+ proportions = arguments[0];
+ } else {
+
+ // Retrieve or derive the droppable's proportions
+ return proportions ?
+ proportions :
+ proportions = {
+ width: this.element[0].offsetWidth,
+ height: this.element[0].offsetHeight
+ };
+ }
+ };
+
+ this._addToManager(o.scope);
+
+ o.addClasses && this._addClass("ui-droppable");
+
+ },
+
+ _addToManager: function (scope) {
+
+ // Add the reference and positions to the manager
+ $.ui.ddmanager.droppables[scope] = $.ui.ddmanager.droppables[scope] || [];
+ $.ui.ddmanager.droppables[scope].push(this);
+ },
+
+ _splice: function (drop) {
+ var i = 0;
+ for (; i < drop.length; i++) {
+ if (drop[i] === this) {
+ drop.splice(i, 1);
+ }
+ }
+ },
+
+ _destroy: function () {
+ var drop = $.ui.ddmanager.droppables[this.options.scope];
+
+ this._splice(drop);
+ },
+
+ _setOption: function (key, value) {
+
+ if (key === "accept") {
+ this.accept = $.isFunction(value) ? value : function (d) {
+ return d.is(value);
+ };
+ } else if (key === "scope") {
+ var drop = $.ui.ddmanager.droppables[this.options.scope];
+
+ this._splice(drop);
+ this._addToManager(value);
+ }
+
+ this._super(key, value);
+ },
+
+ _activate: function (event) {
+ var draggable = $.ui.ddmanager.current;
+
+ this._addActiveClass();
+ if (draggable) {
+ this._trigger("activate", event, this.ui(draggable));
+ }
+ },
+
+ _deactivate: function (event) {
+ var draggable = $.ui.ddmanager.current;
+
+ this._removeActiveClass();
+ if (draggable) {
+ this._trigger("deactivate", event, this.ui(draggable));
+ }
+ },
+
+ _over: function (event) {
+
+ var draggable = $.ui.ddmanager.current;
+
+ // Bail if draggable and droppable are same element
+ if (!draggable || (draggable.currentItem ||
+ draggable.element)[0] === this.element[0]) {
+ return;
+ }
+
+ if (this.accept.call(this.element[0], (draggable.currentItem ||
+ draggable.element))) {
+ this._addHoverClass();
+ this._trigger("over", event, this.ui(draggable));
+ }
+
+ },
+
+ _out: function (event) {
+
+ var draggable = $.ui.ddmanager.current;
+
+ // Bail if draggable and droppable are same element
+ if (!draggable || (draggable.currentItem ||
+ draggable.element)[0] === this.element[0]) {
+ return;
+ }
+
+ if (this.accept.call(this.element[0], (draggable.currentItem ||
+ draggable.element))) {
+ this._removeHoverClass();
+ this._trigger("out", event, this.ui(draggable));
+ }
+
+ },
+
+ _drop: function (event, custom) {
+
+ var draggable = custom || $.ui.ddmanager.current,
+ childrenIntersection = false;
+
+ // Bail if draggable and droppable are same element
+ if (!draggable || (draggable.currentItem ||
+ draggable.element)[0] === this.element[0]) {
+ return false;
+ }
+
+ this.element
+ .find(":data(ui-droppable)")
+ .not(".ui-draggable-dragging")
+ .each(function () {
+ var inst = $(this).droppable("instance");
+ if (
+ inst.options.greedy &&
+ !inst.options.disabled &&
+ inst.options.scope === draggable.options.scope &&
+ inst.accept.call(
+ inst.element[0], (draggable.currentItem || draggable.element)
+ ) &&
+ intersect(
+ draggable,
+ $.extend(inst, { offset: inst.element.offset() }),
+ inst.options.tolerance, event
+ )
+ ) {
+ childrenIntersection = true;
+ return false;
+ }
+ });
+ if (childrenIntersection) {
+ return false;
+ }
+
+ if (this.accept.call(this.element[0],
+ (draggable.currentItem || draggable.element))) {
+ this._removeActiveClass();
+ this._removeHoverClass();
+
+ this._trigger("drop", event, this.ui(draggable));
+ return this.element;
+ }
+
+ return false;
+
+ },
+
+ ui: function (c) {
+ return {
+ draggable: (c.currentItem || c.element),
+ helper: c.helper,
+ position: c.position,
+ offset: c.positionAbs
+ };
+ },
+
+ // Extension points just to make backcompat sane and avoid duplicating logic
+ // TODO: Remove in 1.13 along with call to it below
+ _addHoverClass: function () {
+ this._addClass("ui-droppable-hover");
+ },
+
+ _removeHoverClass: function () {
+ this._removeClass("ui-droppable-hover");
+ },
+
+ _addActiveClass: function () {
+ this._addClass("ui-droppable-active");
+ },
+
+ _removeActiveClass: function () {
+ this._removeClass("ui-droppable-active");
+ }
+ });
+
+ var intersect = $.ui.intersect = (function () {
+ function isOverAxis(x, reference, size) {
+ return (x >= reference) && (x < (reference + size));
+ }
+
+ return function (draggable, droppable, toleranceMode, event) {
+
+ if (!droppable.offset) {
+ return false;
+ }
+
+ var x1 = (draggable.positionAbs ||
+ draggable.position.absolute).left + draggable.margins.left,
+ y1 = (draggable.positionAbs ||
+ draggable.position.absolute).top + draggable.margins.top,
+ x2 = x1 + draggable.helperProportions.width,
+ y2 = y1 + draggable.helperProportions.height,
+ l = droppable.offset.left,
+ t = droppable.offset.top,
+ r = l + droppable.proportions().width,
+ b = t + droppable.proportions().height;
+
+ switch (toleranceMode) {
+ case "fit":
+ return (l <= x1 && x2 <= r && t <= y1 && y2 <= b);
+ case "intersect":
+ return (l < x1 + (draggable.helperProportions.width / 2) && // Right Half
+ x2 - (draggable.helperProportions.width / 2) < r && // Left Half
+ t < y1 + (draggable.helperProportions.height / 2) && // Bottom Half
+ y2 - (draggable.helperProportions.height / 2) < b); // Top Half
+ case "pointer":
+ return isOverAxis(event.pageY, t, droppable.proportions().height) &&
+ isOverAxis(event.pageX, l, droppable.proportions().width);
+ case "touch":
+ return (
+ (y1 >= t && y1 <= b) || // Top edge touching
+ (y2 >= t && y2 <= b) || // Bottom edge touching
+ (y1 < t && y2 > b) // Surrounded vertically
+ ) && (
+ (x1 >= l && x1 <= r) || // Left edge touching
+ (x2 >= l && x2 <= r) || // Right edge touching
+ (x1 < l && x2 > r) // Surrounded horizontally
+ );
+ default:
+ return false;
+ }
+ };
+ })();
+
+ /*
+ This manager tracks offsets of draggables and droppables
+ */
+ $.ui.ddmanager = {
+ current: null,
+ droppables: { "default": [] },
+ prepareOffsets: function (t, event) {
+
+ var i, j,
+ m = $.ui.ddmanager.droppables[t.options.scope] || [],
+ type = event ? event.type : null, // workaround for #2317
+ list = (t.currentItem || t.element).find(":data(ui-droppable)").addBack();
+
+ droppablesLoop: for (i = 0; i < m.length; i++) {
+
+ // No disabled and non-accepted
+ if (m[i].options.disabled || (t && !m[i].accept.call(m[i].element[0],
+ (t.currentItem || t.element)))) {
+ continue;
+ }
+
+ // Filter out elements in the current dragged item
+ for (j = 0; j < list.length; j++) {
+ if (list[j] === m[i].element[0]) {
+ m[i].proportions().height = 0;
+ continue droppablesLoop;
+ }
+ }
+
+ m[i].visible = m[i].element.css("display") !== "none";
+ if (!m[i].visible) {
+ continue;
+ }
+
+ // Activate the droppable if used directly from draggables
+ if (type === "mousedown") {
+ m[i]._activate.call(m[i], event);
+ }
+
+ m[i].offset = m[i].element.offset();
+ m[i].proportions({
+ width: m[i].element[0].offsetWidth,
+ height: m[i].element[0].offsetHeight
+ });
+
+ }
+
+ },
+ drop: function (draggable, event) {
+
+ var dropped = false;
+
+ // Create a copy of the droppables in case the list changes during the drop (#9116)
+ $.each(($.ui.ddmanager.droppables[draggable.options.scope] || []).slice(), function () {
+
+ if (!this.options) {
+ return;
+ }
+ if (!this.options.disabled && this.visible &&
+ intersect(draggable, this, this.options.tolerance, event)) {
+ dropped = this._drop.call(this, event) || dropped;
+ }
+
+ if (!this.options.disabled && this.visible && this.accept.call(this.element[0],
+ (draggable.currentItem || draggable.element))) {
+ this.isout = true;
+ this.isover = false;
+ this._deactivate.call(this, event);
+ }
+
+ });
+ return dropped;
+
+ },
+ dragStart: function (draggable, event) {
+
+ // Listen for scrolling so that if the dragging causes scrolling the position of the
+ // droppables can be recalculated (see #5003)
+ draggable.element.parentsUntil("body").on("scroll.droppable", function () {
+ if (!draggable.options.refreshPositions) {
+ $.ui.ddmanager.prepareOffsets(draggable, event);
+ }
+ });
+ },
+ drag: function (draggable, event) {
+
+ // If you have a highly dynamic page, you might try this option. It renders positions
+ // every time you move the mouse.
+ if (draggable.options.refreshPositions) {
+ $.ui.ddmanager.prepareOffsets(draggable, event);
+ }
+
+ // Run through all droppables and check their positions based on specific tolerance options
+ $.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function () {
+
+ if (this.options.disabled || this.greedyChild || !this.visible) {
+ return;
+ }
+
+ var parentInstance, scope, parent,
+ intersects = intersect(draggable, this, this.options.tolerance, event),
+ c = !intersects && this.isover ?
+ "isout" :
+ (intersects && !this.isover ? "isover" : null);
+ if (!c) {
+ return;
+ }
+
+ if (this.options.greedy) {
+
+ // find droppable parents with same scope
+ scope = this.options.scope;
+ parent = this.element.parents(":data(ui-droppable)").filter(function () {
+ return $(this).droppable("instance").options.scope === scope;
+ });
+
+ if (parent.length) {
+ parentInstance = $(parent[0]).droppable("instance");
+ parentInstance.greedyChild = (c === "isover");
+ }
+ }
+
+ // We just moved into a greedy child
+ if (parentInstance && c === "isover") {
+ parentInstance.isover = false;
+ parentInstance.isout = true;
+ parentInstance._out.call(parentInstance, event);
+ }
+
+ this[c] = true;
+ this[c === "isout" ? "isover" : "isout"] = false;
+ this[c === "isover" ? "_over" : "_out"].call(this, event);
+
+ // We just moved out of a greedy child
+ if (parentInstance && c === "isout") {
+ parentInstance.isout = false;
+ parentInstance.isover = true;
+ parentInstance._over.call(parentInstance, event);
+ }
+ });
+
+ },
+ dragStop: function (draggable, event) {
+ draggable.element.parentsUntil("body").off("scroll.droppable");
+
+ // Call prepareOffsets one final time since IE does not fire return scroll events when
+ // overflow was caused by drag (see #5003)
+ if (!draggable.options.refreshPositions) {
+ $.ui.ddmanager.prepareOffsets(draggable, event);
+ }
+ }
+ };
+
+ // DEPRECATED
+ // TODO: switch return back to widget declaration at top of file when this is removed
+ if ($.uiBackCompat !== false) {
+
+ // Backcompat for activeClass and hoverClass options
+ $.widget("ui.droppable", $.ui.droppable, {
+ options: {
+ hoverClass: false,
+ activeClass: false
+ },
+ _addActiveClass: function () {
+ this._super();
+ if (this.options.activeClass) {
+ this.element.addClass(this.options.activeClass);
+ }
+ },
+ _removeActiveClass: function () {
+ this._super();
+ if (this.options.activeClass) {
+ this.element.removeClass(this.options.activeClass);
+ }
+ },
+ _addHoverClass: function () {
+ this._super();
+ if (this.options.hoverClass) {
+ this.element.addClass(this.options.hoverClass);
+ }
+ },
+ _removeHoverClass: function () {
+ this._super();
+ if (this.options.hoverClass) {
+ this.element.removeClass(this.options.hoverClass);
+ }
+ }
+ });
+ }
+
+ var widgetsDroppable = $.ui.droppable;
+
+
+ /*!
+ * jQuery UI Progressbar 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Progressbar
+ //>>group: Widgets
+ // jscs:disable maximumLineLength
+ //>>description: Displays a status indicator for loading state, standard percentage, and other progress indicators.
+ // jscs:enable maximumLineLength
+ //>>docs: http://api.jqueryui.com/progressbar/
+ //>>demos: http://jqueryui.com/progressbar/
+ //>>css.structure: ../../themes/base/core.css
+ //>>css.structure: ../../themes/base/progressbar.css
+ //>>css.theme: ../../themes/base/theme.css
+
+
+
+ var widgetsProgressbar = $.widget("ui.progressbar", {
+ version: "1.12.1",
+ options: {
+ classes: {
+ "ui-progressbar": "ui-corner-all",
+ "ui-progressbar-value": "ui-corner-left",
+ "ui-progressbar-complete": "ui-corner-right"
+ },
+ max: 100,
+ value: 0,
+
+ change: null,
+ complete: null
+ },
+
+ min: 0,
+
+ _create: function () {
+
+ // Constrain initial value
+ this.oldValue = this.options.value = this._constrainedValue();
+
+ this.element.attr({
+
+ // Only set static values; aria-valuenow and aria-valuemax are
+ // set inside _refreshValue()
+ role: "progressbar",
+ "aria-valuemin": this.min
+ });
+ this._addClass("ui-progressbar", "ui-widget ui-widget-content");
+
+ this.valueDiv = $("<div>").appendTo(this.element);
+ this._addClass(this.valueDiv, "ui-progressbar-value", "ui-widget-header");
+ this._refreshValue();
+ },
+
+ _destroy: function () {
+ this.element.removeAttr("role aria-valuemin aria-valuemax aria-valuenow");
+
+ this.valueDiv.remove();
+ },
+
+ value: function (newValue) {
+ if (newValue === undefined) {
+ return this.options.value;
+ }
+
+ this.options.value = this._constrainedValue(newValue);
+ this._refreshValue();
+ },
+
+ _constrainedValue: function (newValue) {
+ if (newValue === undefined) {
+ newValue = this.options.value;
+ }
+
+ this.indeterminate = newValue === false;
+
+ // Sanitize value
+ if (typeof newValue !== "number") {
+ newValue = 0;
+ }
+
+ return this.indeterminate ? false :
+ Math.min(this.options.max, Math.max(this.min, newValue));
+ },
+
+ _setOptions: function (options) {
+
+ // Ensure "value" option is set after other values (like max)
+ var value = options.value;
+ delete options.value;
+
+ this._super(options);
+
+ this.options.value = this._constrainedValue(value);
+ this._refreshValue();
+ },
+
+ _setOption: function (key, value) {
+ if (key === "max") {
+
+ // Don't allow a max less than min
+ value = Math.max(this.min, value);
+ }
+ this._super(key, value);
+ },
+
+ _setOptionDisabled: function (value) {
+ this._super(value);
+
+ this.element.attr("aria-disabled", value);
+ this._toggleClass(null, "ui-state-disabled", !!value);
+ },
+
+ _percentage: function () {
+ return this.indeterminate ?
+ 100 :
+ 100 * (this.options.value - this.min) / (this.options.max - this.min);
+ },
+
+ _refreshValue: function () {
+ var value = this.options.value,
+ percentage = this._percentage();
+
+ this.valueDiv
+ .toggle(this.indeterminate || value > this.min)
+ .width(percentage.toFixed(0) + "%");
+
+ this
+ ._toggleClass(this.valueDiv, "ui-progressbar-complete", null,
+ value === this.options.max)
+ ._toggleClass("ui-progressbar-indeterminate", null, this.indeterminate);
+
+ if (this.indeterminate) {
+ this.element.removeAttr("aria-valuenow");
+ if (!this.overlayDiv) {
+ this.overlayDiv = $("<div>").appendTo(this.valueDiv);
+ this._addClass(this.overlayDiv, "ui-progressbar-overlay");
+ }
+ } else {
+ this.element.attr({
+ "aria-valuemax": this.options.max,
+ "aria-valuenow": value
+ });
+ if (this.overlayDiv) {
+ this.overlayDiv.remove();
+ this.overlayDiv = null;
+ }
+ }
+
+ if (this.oldValue !== value) {
+ this.oldValue = value;
+ this._trigger("change");
+ }
+ if (value === this.options.max) {
+ this._trigger("complete");
+ }
+ }
+ });
+
+
+ /*!
+ * jQuery UI Selectable 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Selectable
+ //>>group: Interactions
+ //>>description: Allows groups of elements to be selected with the mouse.
+ //>>docs: http://api.jqueryui.com/selectable/
+ //>>demos: http://jqueryui.com/selectable/
+ //>>css.structure: ../../themes/base/selectable.css
+
+
+
+ var widgetsSelectable = $.widget("ui.selectable", $.ui.mouse, {
+ version: "1.12.1",
+ options: {
+ appendTo: "body",
+ autoRefresh: true,
+ distance: 0,
+ filter: "*",
+ tolerance: "touch",
+
+ // Callbacks
+ selected: null,
+ selecting: null,
+ start: null,
+ stop: null,
+ unselected: null,
+ unselecting: null
+ },
+ _create: function () {
+ var that = this;
+
+ this._addClass("ui-selectable");
+
+ this.dragged = false;
+
+ // Cache selectee children based on filter
+ this.refresh = function () {
+ that.elementPos = $(that.element[0]).offset();
+ that.selectees = $(that.options.filter, that.element[0]);
+ that._addClass(that.selectees, "ui-selectee");
+ that.selectees.each(function () {
+ var $this = $(this),
+ selecteeOffset = $this.offset(),
+ pos = {
+ left: selecteeOffset.left - that.elementPos.left,
+ top: selecteeOffset.top - that.elementPos.top
+ };
+ $.data(this, "selectable-item", {
+ element: this,
+ $element: $this,
+ left: pos.left,
+ top: pos.top,
+ right: pos.left + $this.outerWidth(),
+ bottom: pos.top + $this.outerHeight(),
+ startselected: false,
+ selected: $this.hasClass("ui-selected"),
+ selecting: $this.hasClass("ui-selecting"),
+ unselecting: $this.hasClass("ui-unselecting")
+ });
+ });
+ };
+ this.refresh();
+
+ this._mouseInit();
+
+ this.helper = $("<div>");
+ this._addClass(this.helper, "ui-selectable-helper");
+ },
+
+ _destroy: function () {
+ this.selectees.removeData("selectable-item");
+ this._mouseDestroy();
+ },
+
+ _mouseStart: function (event) {
+ var that = this,
+ options = this.options;
+
+ this.opos = [event.pageX, event.pageY];
+ this.elementPos = $(this.element[0]).offset();
+
+ if (this.options.disabled) {
+ return;
+ }
+
+ this.selectees = $(options.filter, this.element[0]);
+
+ this._trigger("start", event);
+
+ $(options.appendTo).append(this.helper);
+
+ // position helper (lasso)
+ this.helper.css({
+ "left": event.pageX,
+ "top": event.pageY,
+ "width": 0,
+ "height": 0
+ });
+
+ if (options.autoRefresh) {
+ this.refresh();
+ }
+
+ this.selectees.filter(".ui-selected").each(function () {
+ var selectee = $.data(this, "selectable-item");
+ selectee.startselected = true;
+ if (!event.metaKey && !event.ctrlKey) {
+ that._removeClass(selectee.$element, "ui-selected");
+ selectee.selected = false;
+ that._addClass(selectee.$element, "ui-unselecting");
+ selectee.unselecting = true;
+
+ // selectable UNSELECTING callback
+ that._trigger("unselecting", event, {
+ unselecting: selectee.element
+ });
+ }
+ });
+
+ $(event.target).parents().addBack().each(function () {
+ var doSelect,
+ selectee = $.data(this, "selectable-item");
+ if (selectee) {
+ doSelect = (!event.metaKey && !event.ctrlKey) ||
+ !selectee.$element.hasClass("ui-selected");
+ that._removeClass(selectee.$element, doSelect ? "ui-unselecting" : "ui-selected")
+ ._addClass(selectee.$element, doSelect ? "ui-selecting" : "ui-unselecting");
+ selectee.unselecting = !doSelect;
+ selectee.selecting = doSelect;
+ selectee.selected = doSelect;
+
+ // selectable (UN)SELECTING callback
+ if (doSelect) {
+ that._trigger("selecting", event, {
+ selecting: selectee.element
+ });
+ } else {
+ that._trigger("unselecting", event, {
+ unselecting: selectee.element
+ });
+ }
+ return false;
+ }
+ });
+
+ },
+
+ _mouseDrag: function (event) {
+
+ this.dragged = true;
+
+ if (this.options.disabled) {
+ return;
+ }
+
+ var tmp,
+ that = this,
+ options = this.options,
+ x1 = this.opos[0],
+ y1 = this.opos[1],
+ x2 = event.pageX,
+ y2 = event.pageY;
+
+ if (x1 > x2) { tmp = x2; x2 = x1; x1 = tmp; }
+ if (y1 > y2) { tmp = y2; y2 = y1; y1 = tmp; }
+ this.helper.css({ left: x1, top: y1, width: x2 - x1, height: y2 - y1 });
+
+ this.selectees.each(function () {
+ var selectee = $.data(this, "selectable-item"),
+ hit = false,
+ offset = {};
+
+ //prevent helper from being selected if appendTo: selectable
+ if (!selectee || selectee.element === that.element[0]) {
+ return;
+ }
+
+ offset.left = selectee.left + that.elementPos.left;
+ offset.right = selectee.right + that.elementPos.left;
+ offset.top = selectee.top + that.elementPos.top;
+ offset.bottom = selectee.bottom + that.elementPos.top;
+
+ if (options.tolerance === "touch") {
+ hit = (!(offset.left > x2 || offset.right < x1 || offset.top > y2 ||
+ offset.bottom < y1));
+ } else if (options.tolerance === "fit") {
+ hit = (offset.left > x1 && offset.right < x2 && offset.top > y1 &&
+ offset.bottom < y2);
+ }
+
+ if (hit) {
+
+ // SELECT
+ if (selectee.selected) {
+ that._removeClass(selectee.$element, "ui-selected");
+ selectee.selected = false;
+ }
+ if (selectee.unselecting) {
+ that._removeClass(selectee.$element, "ui-unselecting");
+ selectee.unselecting = false;
+ }
+ if (!selectee.selecting) {
+ that._addClass(selectee.$element, "ui-selecting");
+ selectee.selecting = true;
+
+ // selectable SELECTING callback
+ that._trigger("selecting", event, {
+ selecting: selectee.element
+ });
+ }
+ } else {
+
+ // UNSELECT
+ if (selectee.selecting) {
+ if ((event.metaKey || event.ctrlKey) && selectee.startselected) {
+ that._removeClass(selectee.$element, "ui-selecting");
+ selectee.selecting = false;
+ that._addClass(selectee.$element, "ui-selected");
+ selectee.selected = true;
+ } else {
+ that._removeClass(selectee.$element, "ui-selecting");
+ selectee.selecting = false;
+ if (selectee.startselected) {
+ that._addClass(selectee.$element, "ui-unselecting");
+ selectee.unselecting = true;
+ }
+
+ // selectable UNSELECTING callback
+ that._trigger("unselecting", event, {
+ unselecting: selectee.element
+ });
+ }
+ }
+ if (selectee.selected) {
+ if (!event.metaKey && !event.ctrlKey && !selectee.startselected) {
+ that._removeClass(selectee.$element, "ui-selected");
+ selectee.selected = false;
+
+ that._addClass(selectee.$element, "ui-unselecting");
+ selectee.unselecting = true;
+
+ // selectable UNSELECTING callback
+ that._trigger("unselecting", event, {
+ unselecting: selectee.element
+ });
+ }
+ }
+ }
+ });
+
+ return false;
+ },
+
+ _mouseStop: function (event) {
+ var that = this;
+
+ this.dragged = false;
+
+ $(".ui-unselecting", this.element[0]).each(function () {
+ var selectee = $.data(this, "selectable-item");
+ that._removeClass(selectee.$element, "ui-unselecting");
+ selectee.unselecting = false;
+ selectee.startselected = false;
+ that._trigger("unselected", event, {
+ unselected: selectee.element
+ });
+ });
+ $(".ui-selecting", this.element[0]).each(function () {
+ var selectee = $.data(this, "selectable-item");
+ that._removeClass(selectee.$element, "ui-selecting")
+ ._addClass(selectee.$element, "ui-selected");
+ selectee.selecting = false;
+ selectee.selected = true;
+ selectee.startselected = true;
+ that._trigger("selected", event, {
+ selected: selectee.element
+ });
+ });
+ this._trigger("stop", event);
+
+ this.helper.remove();
+
+ return false;
+ }
+
+ });
+
+
+ /*!
+ * jQuery UI Selectmenu 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Selectmenu
+ //>>group: Widgets
+ // jscs:disable maximumLineLength
+ //>>description: Duplicates and extends the functionality of a native HTML select element, allowing it to be customizable in behavior and appearance far beyond the limitations of a native select.
+ // jscs:enable maximumLineLength
+ //>>docs: http://api.jqueryui.com/selectmenu/
+ //>>demos: http://jqueryui.com/selectmenu/
+ //>>css.structure: ../../themes/base/core.css
+ //>>css.structure: ../../themes/base/selectmenu.css, ../../themes/base/button.css
+ //>>css.theme: ../../themes/base/theme.css
+
+
+
+ var widgetsSelectmenu = $.widget("ui.selectmenu", [$.ui.formResetMixin, {
+ version: "1.12.1",
+ defaultElement: "<select>",
+ options: {
+ appendTo: null,
+ classes: {
+ "ui-selectmenu-button-open": "ui-corner-top",
+ "ui-selectmenu-button-closed": "ui-corner-all"
+ },
+ disabled: null,
+ icons: {
+ button: "ui-icon-triangle-1-s"
+ },
+ position: {
+ my: "left top",
+ at: "left bottom",
+ collision: "none"
+ },
+ width: false,
+
+ // Callbacks
+ change: null,
+ close: null,
+ focus: null,
+ open: null,
+ select: null
+ },
+
+ _create: function () {
+ var selectmenuId = this.element.uniqueId().attr("id");
+ this.ids = {
+ element: selectmenuId,
+ button: selectmenuId + "-button",
+ menu: selectmenuId + "-menu"
+ };
+
+ this._drawButton();
+ this._drawMenu();
+ this._bindFormResetHandler();
+
+ this._rendered = false;
+ this.menuItems = $();
+ },
+
+ _drawButton: function () {
+ var icon,
+ that = this,
+ item = this._parseOption(
+ this.element.find("option:selected"),
+ this.element[0].selectedIndex
+ );
+
+ // Associate existing label with the new button
+ this.labels = this.element.labels().attr("for", this.ids.button);
+ this._on(this.labels, {
+ click: function (event) {
+ this.button.focus();
+ event.preventDefault();
+ }
+ });
+
+ // Hide original select element
+ this.element.hide();
+
+ // Create button
+ this.button = $("<span>", {
+ tabindex: this.options.disabled ? -1 : 0,
+ id: this.ids.button,
+ role: "combobox",
+ "aria-expanded": "false",
+ "aria-autocomplete": "list",
+ "aria-owns": this.ids.menu,
+ "aria-haspopup": "true",
+ title: this.element.attr("title")
+ })
+ .insertAfter(this.element);
+
+ this._addClass(this.button, "ui-selectmenu-button ui-selectmenu-button-closed",
+ "ui-button ui-widget");
+
+ icon = $("<span>").appendTo(this.button);
+ this._addClass(icon, "ui-selectmenu-icon", "ui-icon " + this.options.icons.button);
+ this.buttonItem = this._renderButtonItem(item)
+ .appendTo(this.button);
+
+ if (this.options.width !== false) {
+ this._resizeButton();
+ }
+
+ this._on(this.button, this._buttonEvents);
+ this.button.one("focusin", function () {
+
+ // Delay rendering the menu items until the button receives focus.
+ // The menu may have already been rendered via a programmatic open.
+ if (!that._rendered) {
+ that._refreshMenu();
+ }
+ });
+ },
+
+ _drawMenu: function () {
+ var that = this;
+
+ // Create menu
+ this.menu = $("<ul>", {
+ "aria-hidden": "true",
+ "aria-labelledby": this.ids.button,
+ id: this.ids.menu
+ });
+
+ // Wrap menu
+ this.menuWrap = $("<div>").append(this.menu);
+ this._addClass(this.menuWrap, "ui-selectmenu-menu", "ui-front");
+ this.menuWrap.appendTo(this._appendTo());
+
+ // Initialize menu widget
+ this.menuInstance = this.menu
+ .menu({
+ classes: {
+ "ui-menu": "ui-corner-bottom"
+ },
+ role: "listbox",
+ select: function (event, ui) {
+ event.preventDefault();
+
+ // Support: IE8
+ // If the item was selected via a click, the text selection
+ // will be destroyed in IE
+ that._setSelection();
+
+ that._select(ui.item.data("ui-selectmenu-item"), event);
+ },
+ focus: function (event, ui) {
+ var item = ui.item.data("ui-selectmenu-item");
+
+ // Prevent inital focus from firing and check if its a newly focused item
+ if (that.focusIndex != null && item.index !== that.focusIndex) {
+ that._trigger("focus", event, { item: item });
+ if (!that.isOpen) {
+ that._select(item, event);
+ }
+ }
+ that.focusIndex = item.index;
+
+ that.button.attr("aria-activedescendant",
+ that.menuItems.eq(item.index).attr("id"));
+ }
+ })
+ .menu("instance");
+
+ // Don't close the menu on mouseleave
+ this.menuInstance._off(this.menu, "mouseleave");
+
+ // Cancel the menu's collapseAll on document click
+ this.menuInstance._closeOnDocumentClick = function () {
+ return false;
+ };
+
+ // Selects often contain empty items, but never contain dividers
+ this.menuInstance._isDivider = function () {
+ return false;
+ };
+ },
+
+ refresh: function () {
+ this._refreshMenu();
+ this.buttonItem.replaceWith(
+ this.buttonItem = this._renderButtonItem(
+
+ // Fall back to an empty object in case there are no options
+ this._getSelectedItem().data("ui-selectmenu-item") || {}
+ )
+ );
+ if (this.options.width === null) {
+ this._resizeButton();
+ }
+ },
+
+ _refreshMenu: function () {
+ var item,
+ options = this.element.find("option");
+
+ this.menu.empty();
+
+ this._parseOptions(options);
+ this._renderMenu(this.menu, this.items);
+
+ this.menuInstance.refresh();
+ this.menuItems = this.menu.find("li")
+ .not(".ui-selectmenu-optgroup")
+ .find(".ui-menu-item-wrapper");
+
+ this._rendered = true;
+
+ if (!options.length) {
+ return;
+ }
+
+ item = this._getSelectedItem();
+
+ // Update the menu to have the correct item focused
+ this.menuInstance.focus(null, item);
+ this._setAria(item.data("ui-selectmenu-item"));
+
+ // Set disabled state
+ this._setOption("disabled", this.element.prop("disabled"));
+ },
+
+ open: function (event) {
+ if (this.options.disabled) {
+ return;
+ }
+
+ // If this is the first time the menu is being opened, render the items
+ if (!this._rendered) {
+ this._refreshMenu();
+ } else {
+
+ // Menu clears focus on close, reset focus to selected item
+ this._removeClass(this.menu.find(".ui-state-active"), null, "ui-state-active");
+ this.menuInstance.focus(null, this._getSelectedItem());
+ }
+
+ // If there are no options, don't open the menu
+ if (!this.menuItems.length) {
+ return;
+ }
+
+ this.isOpen = true;
+ this._toggleAttr();
+ this._resizeMenu();
+ this._position();
+
+ this._on(this.document, this._documentClick);
+
+ this._trigger("open", event);
+ },
+
+ _position: function () {
+ this.menuWrap.position($.extend({ of: this.button }, this.options.position));
+ },
+
+ close: function (event) {
+ if (!this.isOpen) {
+ return;
+ }
+
+ this.isOpen = false;
+ this._toggleAttr();
+
+ this.range = null;
+ this._off(this.document);
+
+ this._trigger("close", event);
+ },
+
+ widget: function () {
+ return this.button;
+ },
+
+ menuWidget: function () {
+ return this.menu;
+ },
+
+ _renderButtonItem: function (item) {
+ var buttonItem = $("<span>");
+
+ this._setText(buttonItem, item.label);
+ this._addClass(buttonItem, "ui-selectmenu-text");
+
+ return buttonItem;
+ },
+
+ _renderMenu: function (ul, items) {
+ var that = this,
+ currentOptgroup = "";
+
+ $.each(items, function (index, item) {
+ var li;
+
+ if (item.optgroup !== currentOptgroup) {
+ li = $("<li>", {
+ text: item.optgroup
+ });
+ that._addClass(li, "ui-selectmenu-optgroup", "ui-menu-divider" +
+ (item.element.parent("optgroup").prop("disabled") ?
+ " ui-state-disabled" :
+ ""));
+
+ li.appendTo(ul);
+
+ currentOptgroup = item.optgroup;
+ }
+
+ that._renderItemData(ul, item);
+ });
+ },
+
+ _renderItemData: function (ul, item) {
+ return this._renderItem(ul, item).data("ui-selectmenu-item", item);
+ },
+
+ _renderItem: function (ul, item) {
+ var li = $("<li>"),
+ wrapper = $("<div>", {
+ title: item.element.attr("title")
+ });
+
+ if (item.disabled) {
+ this._addClass(li, null, "ui-state-disabled");
+ }
+ this._setText(wrapper, item.label);
+
+ return li.append(wrapper).appendTo(ul);
+ },
+
+ _setText: function (element, value) {
+ if (value) {
+ element.text(value);
+ } else {
+ element.html(" ");
+ }
+ },
+
+ _move: function (direction, event) {
+ var item, next,
+ filter = ".ui-menu-item";
+
+ if (this.isOpen) {
+ item = this.menuItems.eq(this.focusIndex).parent("li");
+ } else {
+ item = this.menuItems.eq(this.element[0].selectedIndex).parent("li");
+ filter += ":not(.ui-state-disabled)";
+ }
+
+ if (direction === "first" || direction === "last") {
+ next = item[direction === "first" ? "prevAll" : "nextAll"](filter).eq(-1);
+ } else {
+ next = item[direction + "All"](filter).eq(0);
+ }
+
+ if (next.length) {
+ this.menuInstance.focus(event, next);
+ }
+ },
+
+ _getSelectedItem: function () {
+ return this.menuItems.eq(this.element[0].selectedIndex).parent("li");
+ },
+
+ _toggle: function (event) {
+ this[this.isOpen ? "close" : "open"](event);
+ },
+
+ _setSelection: function () {
+ var selection;
+
+ if (!this.range) {
+ return;
+ }
+
+ if (window.getSelection) {
+ selection = window.getSelection();
+ selection.removeAllRanges();
+ selection.addRange(this.range);
+
+ // Support: IE8
+ } else {
+ this.range.select();
+ }
+
+ // Support: IE
+ // Setting the text selection kills the button focus in IE, but
+ // restoring the focus doesn't kill the selection.
+ this.button.focus();
+ },
+
+ _documentClick: {
+ mousedown: function (event) {
+ if (!this.isOpen) {
+ return;
+ }
+
+ if (!$(event.target).closest(".ui-selectmenu-menu, #" +
+ $.ui.escapeSelector(this.ids.button)).length) {
+ this.close(event);
+ }
+ }
+ },
+
+ _buttonEvents: {
+
+ // Prevent text selection from being reset when interacting with the selectmenu (#10144)
+ mousedown: function () {
+ var selection;
+
+ if (window.getSelection) {
+ selection = window.getSelection();
+ if (selection.rangeCount) {
+ this.range = selection.getRangeAt(0);
+ }
+
+ // Support: IE8
+ } else {
+ this.range = document.selection.createRange();
+ }
+ },
+
+ click: function (event) {
+ this._setSelection();
+ this._toggle(event);
+ },
+
+ keydown: function (event) {
+ var preventDefault = true;
+ switch (event.keyCode) {
+ case $.ui.keyCode.TAB:
+ case $.ui.keyCode.ESCAPE:
+ this.close(event);
+ preventDefault = false;
+ break;
+ case $.ui.keyCode.ENTER:
+ if (this.isOpen) {
+ this._selectFocusedItem(event);
+ }
+ break;
+ case $.ui.keyCode.UP:
+ if (event.altKey) {
+ this._toggle(event);
+ } else {
+ this._move("prev", event);
+ }
+ break;
+ case $.ui.keyCode.DOWN:
+ if (event.altKey) {
+ this._toggle(event);
+ } else {
+ this._move("next", event);
+ }
+ break;
+ case $.ui.keyCode.SPACE:
+ if (this.isOpen) {
+ this._selectFocusedItem(event);
+ } else {
+ this._toggle(event);
+ }
+ break;
+ case $.ui.keyCode.LEFT:
+ this._move("prev", event);
+ break;
+ case $.ui.keyCode.RIGHT:
+ this._move("next", event);
+ break;
+ case $.ui.keyCode.HOME:
+ case $.ui.keyCode.PAGE_UP:
+ this._move("first", event);
+ break;
+ case $.ui.keyCode.END:
+ case $.ui.keyCode.PAGE_DOWN:
+ this._move("last", event);
+ break;
+ default:
+ this.menu.trigger(event);
+ preventDefault = false;
+ }
+
+ if (preventDefault) {
+ event.preventDefault();
+ }
+ }
+ },
+
+ _selectFocusedItem: function (event) {
+ var item = this.menuItems.eq(this.focusIndex).parent("li");
+ if (!item.hasClass("ui-state-disabled")) {
+ this._select(item.data("ui-selectmenu-item"), event);
+ }
+ },
+
+ _select: function (item, event) {
+ var oldIndex = this.element[0].selectedIndex;
+
+ // Change native select element
+ this.element[0].selectedIndex = item.index;
+ this.buttonItem.replaceWith(this.buttonItem = this._renderButtonItem(item));
+ this._setAria(item);
+ this._trigger("select", event, { item: item });
+
+ if (item.index !== oldIndex) {
+ this._trigger("change", event, { item: item });
+ }
+
+ this.close(event);
+ },
+
+ _setAria: function (item) {
+ var id = this.menuItems.eq(item.index).attr("id");
+
+ this.button.attr({
+ "aria-labelledby": id,
+ "aria-activedescendant": id
+ });
+ this.menu.attr("aria-activedescendant", id);
+ },
+
+ _setOption: function (key, value) {
+ if (key === "icons") {
+ var icon = this.button.find("span.ui-icon");
+ this._removeClass(icon, null, this.options.icons.button)
+ ._addClass(icon, null, value.button);
+ }
+
+ this._super(key, value);
+
+ if (key === "appendTo") {
+ this.menuWrap.appendTo(this._appendTo());
+ }
+
+ if (key === "width") {
+ this._resizeButton();
+ }
+ },
+
+ _setOptionDisabled: function (value) {
+ this._super(value);
+
+ this.menuInstance.option("disabled", value);
+ this.button.attr("aria-disabled", value);
+ this._toggleClass(this.button, null, "ui-state-disabled", value);
+
+ this.element.prop("disabled", value);
+ if (value) {
+ this.button.attr("tabindex", -1);
+ this.close();
+ } else {
+ this.button.attr("tabindex", 0);
+ }
+ },
+
+ _appendTo: function () {
+ var element = this.options.appendTo;
+
+ if (element) {
+ element = element.jquery || element.nodeType ?
+ $(element) :
+ this.document.find(element).eq(0);
+ }
+
+ if (!element || !element[0]) {
+ element = this.element.closest(".ui-front, dialog");
+ }
+
+ if (!element.length) {
+ element = this.document[0].body;
+ }
+
+ return element;
+ },
+
+ _toggleAttr: function () {
+ this.button.attr("aria-expanded", this.isOpen);
+
+ // We can't use two _toggleClass() calls here, because we need to make sure
+ // we always remove classes first and add them second, otherwise if both classes have the
+ // same theme class, it will be removed after we add it.
+ this._removeClass(this.button, "ui-selectmenu-button-" +
+ (this.isOpen ? "closed" : "open"))
+ ._addClass(this.button, "ui-selectmenu-button-" +
+ (this.isOpen ? "open" : "closed"))
+ ._toggleClass(this.menuWrap, "ui-selectmenu-open", null, this.isOpen);
+
+ this.menu.attr("aria-hidden", !this.isOpen);
+ },
+
+ _resizeButton: function () {
+ var width = this.options.width;
+
+ // For `width: false`, just remove inline style and stop
+ if (width === false) {
+ this.button.css("width", "");
+ return;
+ }
+
+ // For `width: null`, match the width of the original element
+ if (width === null) {
+ width = this.element.show().outerWidth();
+ this.element.hide();
+ }
+
+ this.button.outerWidth(width);
+ },
+
+ _resizeMenu: function () {
+ this.menu.outerWidth(Math.max(
+ this.button.outerWidth(),
+
+ // Support: IE10
+ // IE10 wraps long text (possibly a rounding bug)
+ // so we add 1px to avoid the wrapping
+ this.menu.width("").outerWidth() + 1
+ ));
+ },
+
+ _getCreateOptions: function () {
+ var options = this._super();
+
+ options.disabled = this.element.prop("disabled");
+
+ return options;
+ },
+
+ _parseOptions: function (options) {
+ var that = this,
+ data = [];
+ options.each(function (index, item) {
+ data.push(that._parseOption($(item), index));
+ });
+ this.items = data;
+ },
+
+ _parseOption: function (option, index) {
+ var optgroup = option.parent("optgroup");
+
+ return {
+ element: option,
+ index: index,
+ value: option.val(),
+ label: option.text(),
+ optgroup: optgroup.attr("label") || "",
+ disabled: optgroup.prop("disabled") || option.prop("disabled")
+ };
+ },
+
+ _destroy: function () {
+ this._unbindFormResetHandler();
+ this.menuWrap.remove();
+ this.button.remove();
+ this.element.show();
+ this.element.removeUniqueId();
+ this.labels.attr("for", this.ids.element);
+ }
+ }]);
+
+
+ /*!
+ * jQuery UI Slider 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Slider
+ //>>group: Widgets
+ //>>description: Displays a flexible slider with ranges and accessibility via keyboard.
+ //>>docs: http://api.jqueryui.com/slider/
+ //>>demos: http://jqueryui.com/slider/
+ //>>css.structure: ../../themes/base/core.css
+ //>>css.structure: ../../themes/base/slider.css
+ //>>css.theme: ../../themes/base/theme.css
+
+
+
+ var widgetsSlider = $.widget("ui.slider", $.ui.mouse, {
+ version: "1.12.1",
+ widgetEventPrefix: "slide",
+
+ options: {
+ animate: false,
+ classes: {
+ "ui-slider": "ui-corner-all",
+ "ui-slider-handle": "ui-corner-all",
+
+ // Note: ui-widget-header isn't the most fittingly semantic framework class for this
+ // element, but worked best visually with a variety of themes
+ "ui-slider-range": "ui-corner-all ui-widget-header"
+ },
+ distance: 0,
+ max: 100,
+ min: 0,
+ orientation: "horizontal",
+ range: false,
+ step: 1,
+ value: 0,
+ values: null,
+
+ // Callbacks
+ change: null,
+ slide: null,
+ start: null,
+ stop: null
+ },
+
+ // Number of pages in a slider
+ // (how many times can you page up/down to go through the whole range)
+ numPages: 5,
+
+ _create: function () {
+ this._keySliding = false;
+ this._mouseSliding = false;
+ this._animateOff = true;
+ this._handleIndex = null;
+ this._detectOrientation();
+ this._mouseInit();
+ this._calculateNewMax();
+
+ this._addClass("ui-slider ui-slider-" + this.orientation,
+ "ui-widget ui-widget-content");
+
+ this._refresh();
+
+ this._animateOff = false;
+ },
+
+ _refresh: function () {
+ this._createRange();
+ this._createHandles();
+ this._setupEvents();
+ this._refreshValue();
+ },
+
+ _createHandles: function () {
+ var i, handleCount,
+ options = this.options,
+ existingHandles = this.element.find(".ui-slider-handle"),
+ handle = "<span tabindex='0'></span>",
+ handles = [];
+
+ handleCount = (options.values && options.values.length) || 1;
+
+ if (existingHandles.length > handleCount) {
+ existingHandles.slice(handleCount).remove();
+ existingHandles = existingHandles.slice(0, handleCount);
+ }
+
+ for (i = existingHandles.length; i < handleCount; i++) {
+ handles.push(handle);
+ }
+
+ this.handles = existingHandles.add($(handles.join("")).appendTo(this.element));
+
+ this._addClass(this.handles, "ui-slider-handle", "ui-state-default");
+
+ this.handle = this.handles.eq(0);
+
+ this.handles.each(function (i) {
+ $(this)
+ .data("ui-slider-handle-index", i)
+ .attr("tabIndex", 0);
+ });
+ },
+
+ _createRange: function () {
+ var options = this.options;
+
+ if (options.range) {
+ if (options.range === true) {
+ if (!options.values) {
+ options.values = [this._valueMin(), this._valueMin()];
+ } else if (options.values.length && options.values.length !== 2) {
+ options.values = [options.values[0], options.values[0]];
+ } else if ($.isArray(options.values)) {
+ options.values = options.values.slice(0);
+ }
+ }
+
+ if (!this.range || !this.range.length) {
+ this.range = $("<div>")
+ .appendTo(this.element);
+
+ this._addClass(this.range, "ui-slider-range");
+ } else {
+ this._removeClass(this.range, "ui-slider-range-min ui-slider-range-max");
+
+ // Handle range switching from true to min/max
+ this.range.css({
+ "left": "",
+ "bottom": ""
+ });
+ }
+ if (options.range === "min" || options.range === "max") {
+ this._addClass(this.range, "ui-slider-range-" + options.range);
+ }
+ } else {
+ if (this.range) {
+ this.range.remove();
+ }
+ this.range = null;
+ }
+ },
+
+ _setupEvents: function () {
+ this._off(this.handles);
+ this._on(this.handles, this._handleEvents);
+ this._hoverable(this.handles);
+ this._focusable(this.handles);
+ },
+
+ _destroy: function () {
+ this.handles.remove();
+ if (this.range) {
+ this.range.remove();
+ }
+
+ this._mouseDestroy();
+ },
+
+ _mouseCapture: function (event) {
+ var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
+ that = this,
+ o = this.options;
+
+ if (o.disabled) {
+ return false;
+ }
+
+ this.elementSize = {
+ width: this.element.outerWidth(),
+ height: this.element.outerHeight()
+ };
+ this.elementOffset = this.element.offset();
+
+ position = { x: event.pageX, y: event.pageY };
+ normValue = this._normValueFromMouse(position);
+ distance = this._valueMax() - this._valueMin() + 1;
+ this.handles.each(function (i) {
+ var thisDistance = Math.abs(normValue - that.values(i));
+ if ((distance > thisDistance) ||
+ (distance === thisDistance &&
+ (i === that._lastChangedValue || that.values(i) === o.min))) {
+ distance = thisDistance;
+ closestHandle = $(this);
+ index = i;
+ }
+ });
+
+ allowed = this._start(event, index);
+ if (allowed === false) {
+ return false;
+ }
+ this._mouseSliding = true;
+
+ this._handleIndex = index;
+
+ this._addClass(closestHandle, null, "ui-state-active");
+ closestHandle.trigger("focus");
+
+ offset = closestHandle.offset();
+ mouseOverHandle = !$(event.target).parents().addBack().is(".ui-slider-handle");
+ this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
+ left: event.pageX - offset.left - (closestHandle.width() / 2),
+ top: event.pageY - offset.top -
+ (closestHandle.height() / 2) -
+ (parseInt(closestHandle.css("borderTopWidth"), 10) || 0) -
+ (parseInt(closestHandle.css("borderBottomWidth"), 10) || 0) +
+ (parseInt(closestHandle.css("marginTop"), 10) || 0)
+ };
+
+ if (!this.handles.hasClass("ui-state-hover")) {
+ this._slide(event, index, normValue);
+ }
+ this._animateOff = true;
+ return true;
+ },
+
+ _mouseStart: function () {
+ return true;
+ },
+
+ _mouseDrag: function (event) {
+ var position = { x: event.pageX, y: event.pageY },
+ normValue = this._normValueFromMouse(position);
+
+ this._slide(event, this._handleIndex, normValue);
+
+ return false;
+ },
+
+ _mouseStop: function (event) {
+ this._removeClass(this.handles, null, "ui-state-active");
+ this._mouseSliding = false;
+
+ this._stop(event, this._handleIndex);
+ this._change(event, this._handleIndex);
+
+ this._handleIndex = null;
+ this._clickOffset = null;
+ this._animateOff = false;
+
+ return false;
+ },
+
+ _detectOrientation: function () {
+ this.orientation = (this.options.orientation === "vertical") ? "vertical" : "horizontal";
+ },
+
+ _normValueFromMouse: function (position) {
+ var pixelTotal,
+ pixelMouse,
+ percentMouse,
+ valueTotal,
+ valueMouse;
+
+ if (this.orientation === "horizontal") {
+ pixelTotal = this.elementSize.width;
+ pixelMouse = position.x - this.elementOffset.left -
+ (this._clickOffset ? this._clickOffset.left : 0);
+ } else {
+ pixelTotal = this.elementSize.height;
+ pixelMouse = position.y - this.elementOffset.top -
+ (this._clickOffset ? this._clickOffset.top : 0);
+ }
+
+ percentMouse = (pixelMouse / pixelTotal);
+ if (percentMouse > 1) {
+ percentMouse = 1;
+ }
+ if (percentMouse < 0) {
+ percentMouse = 0;
+ }
+ if (this.orientation === "vertical") {
+ percentMouse = 1 - percentMouse;
+ }
+
+ valueTotal = this._valueMax() - this._valueMin();
+ valueMouse = this._valueMin() + percentMouse * valueTotal;
+
+ return this._trimAlignValue(valueMouse);
+ },
+
+ _uiHash: function (index, value, values) {
+ var uiHash = {
+ handle: this.handles[index],
+ handleIndex: index,
+ value: value !== undefined ? value : this.value()
+ };
+
+ if (this._hasMultipleValues()) {
+ uiHash.value = value !== undefined ? value : this.values(index);
+ uiHash.values = values || this.values();
+ }
+
+ return uiHash;
+ },
+
+ _hasMultipleValues: function () {
+ return this.options.values && this.options.values.length;
+ },
+
+ _start: function (event, index) {
+ return this._trigger("start", event, this._uiHash(index));
+ },
+
+ _slide: function (event, index, newVal) {
+ var allowed, otherVal,
+ currentValue = this.value(),
+ newValues = this.values();
+
+ if (this._hasMultipleValues()) {
+ otherVal = this.values(index ? 0 : 1);
+ currentValue = this.values(index);
+
+ if (this.options.values.length === 2 && this.options.range === true) {
+ newVal = index === 0 ? Math.min(otherVal, newVal) : Math.max(otherVal, newVal);
+ }
+
+ newValues[index] = newVal;
+ }
+
+ if (newVal === currentValue) {
+ return;
+ }
+
+ allowed = this._trigger("slide", event, this._uiHash(index, newVal, newValues));
+
+ // A slide can be canceled by returning false from the slide callback
+ if (allowed === false) {
+ return;
+ }
+
+ if (this._hasMultipleValues()) {
+ this.values(index, newVal);
+ } else {
+ this.value(newVal);
+ }
+ },
+
+ _stop: function (event, index) {
+ this._trigger("stop", event, this._uiHash(index));
+ },
+
+ _change: function (event, index) {
+ if (!this._keySliding && !this._mouseSliding) {
+
+ //store the last changed value index for reference when handles overlap
+ this._lastChangedValue = index;
+ this._trigger("change", event, this._uiHash(index));
+ }
+ },
+
+ value: function (newValue) {
+ if (arguments.length) {
+ this.options.value = this._trimAlignValue(newValue);
+ this._refreshValue();
+ this._change(null, 0);
+ return;
+ }
+
+ return this._value();
+ },
+
+ values: function (index, newValue) {
+ var vals,
+ newValues,
+ i;
+
+ if (arguments.length > 1) {
+ this.options.values[index] = this._trimAlignValue(newValue);
+ this._refreshValue();
+ this._change(null, index);
+ return;
+ }
+
+ if (arguments.length) {
+ if ($.isArray(arguments[0])) {
+ vals = this.options.values;
+ newValues = arguments[0];
+ for (i = 0; i < vals.length; i += 1) {
+ vals[i] = this._trimAlignValue(newValues[i]);
+ this._change(null, i);
+ }
+ this._refreshValue();
+ } else {
+ if (this._hasMultipleValues()) {
+ return this._values(index);
+ } else {
+ return this.value();
+ }
+ }
+ } else {
+ return this._values();
+ }
+ },
+
+ _setOption: function (key, value) {
+ var i,
+ valsLength = 0;
+
+ if (key === "range" && this.options.range === true) {
+ if (value === "min") {
+ this.options.value = this._values(0);
+ this.options.values = null;
+ } else if (value === "max") {
+ this.options.value = this._values(this.options.values.length - 1);
+ this.options.values = null;
+ }
+ }
+
+ if ($.isArray(this.options.values)) {
+ valsLength = this.options.values.length;
+ }
+
+ this._super(key, value);
+
+ switch (key) {
+ case "orientation":
+ this._detectOrientation();
+ this._removeClass("ui-slider-horizontal ui-slider-vertical")
+ ._addClass("ui-slider-" + this.orientation);
+ this._refreshValue();
+ if (this.options.range) {
+ this._refreshRange(value);
+ }
+
+ // Reset positioning from previous orientation
+ this.handles.css(value === "horizontal" ? "bottom" : "left", "");
+ break;
+ case "value":
+ this._animateOff = true;
+ this._refreshValue();
+ this._change(null, 0);
+ this._animateOff = false;
+ break;
+ case "values":
+ this._animateOff = true;
+ this._refreshValue();
+
+ // Start from the last handle to prevent unreachable handles (#9046)
+ for (i = valsLength - 1; i >= 0; i--) {
+ this._change(null, i);
+ }
+ this._animateOff = false;
+ break;
+ case "step":
+ case "min":
+ case "max":
+ this._animateOff = true;
+ this._calculateNewMax();
+ this._refreshValue();
+ this._animateOff = false;
+ break;
+ case "range":
+ this._animateOff = true;
+ this._refresh();
+ this._animateOff = false;
+ break;
+ }
+ },
+
+ _setOptionDisabled: function (value) {
+ this._super(value);
+
+ this._toggleClass(null, "ui-state-disabled", !!value);
+ },
+
+ //internal value getter
+ // _value() returns value trimmed by min and max, aligned by step
+ _value: function () {
+ var val = this.options.value;
+ val = this._trimAlignValue(val);
+
+ return val;
+ },
+
+ //internal values getter
+ // _values() returns array of values trimmed by min and max, aligned by step
+ // _values( index ) returns single value trimmed by min and max, aligned by step
+ _values: function (index) {
+ var val,
+ vals,
+ i;
+
+ if (arguments.length) {
+ val = this.options.values[index];
+ val = this._trimAlignValue(val);
+
+ return val;
+ } else if (this._hasMultipleValues()) {
+
+ // .slice() creates a copy of the array
+ // this copy gets trimmed by min and max and then returned
+ vals = this.options.values.slice();
+ for (i = 0; i < vals.length; i += 1) {
+ vals[i] = this._trimAlignValue(vals[i]);
+ }
+
+ return vals;
+ } else {
+ return [];
+ }
+ },
+
+ // Returns the step-aligned value that val is closest to, between (inclusive) min and max
+ _trimAlignValue: function (val) {
+ if (val <= this._valueMin()) {
+ return this._valueMin();
+ }
+ if (val >= this._valueMax()) {
+ return this._valueMax();
+ }
+ var step = (this.options.step > 0) ? this.options.step : 1,
+ valModStep = (val - this._valueMin()) % step,
+ alignValue = val - valModStep;
+
+ if (Math.abs(valModStep) * 2 >= step) {
+ alignValue += (valModStep > 0) ? step : (-step);
+ }
+
+ // Since JavaScript has problems with large floats, round
+ // the final value to 5 digits after the decimal point (see #4124)
+ return parseFloat(alignValue.toFixed(5));
+ },
+
+ _calculateNewMax: function () {
+ var max = this.options.max,
+ min = this._valueMin(),
+ step = this.options.step,
+ aboveMin = Math.round((max - min) / step) * step;
+ max = aboveMin + min;
+ if (max > this.options.max) {
+
+ //If max is not divisible by step, rounding off may increase its value
+ max -= step;
+ }
+ this.max = parseFloat(max.toFixed(this._precision()));
+ },
+
+ _precision: function () {
+ var precision = this._precisionOf(this.options.step);
+ if (this.options.min !== null) {
+ precision = Math.max(precision, this._precisionOf(this.options.min));
+ }
+ return precision;
+ },
+
+ _precisionOf: function (num) {
+ var str = num.toString(),
+ decimal = str.indexOf(".");
+ return decimal === -1 ? 0 : str.length - decimal - 1;
+ },
+
+ _valueMin: function () {
+ return this.options.min;
+ },
+
+ _valueMax: function () {
+ return this.max;
+ },
+
+ _refreshRange: function (orientation) {
+ if (orientation === "vertical") {
+ this.range.css({ "width": "", "left": "" });
+ }
+ if (orientation === "horizontal") {
+ this.range.css({ "height": "", "bottom": "" });
+ }
+ },
+
+ _refreshValue: function () {
+ var lastValPercent, valPercent, value, valueMin, valueMax,
+ oRange = this.options.range,
+ o = this.options,
+ that = this,
+ animate = (!this._animateOff) ? o.animate : false,
+ _set = {};
+
+ if (this._hasMultipleValues()) {
+ this.handles.each(function (i) {
+ valPercent = (that.values(i) - that._valueMin()) / (that._valueMax() -
+ that._valueMin()) * 100;
+ _set[that.orientation === "horizontal" ? "left" : "bottom"] = valPercent + "%";
+ $(this).stop(1, 1)[animate ? "animate" : "css"](_set, o.animate);
+ if (that.options.range === true) {
+ if (that.orientation === "horizontal") {
+ if (i === 0) {
+ that.range.stop(1, 1)[animate ? "animate" : "css"]({
+ left: valPercent + "%"
+ }, o.animate);
+ }
+ if (i === 1) {
+ that.range[animate ? "animate" : "css"]({
+ width: (valPercent - lastValPercent) + "%"
+ }, {
+ queue: false,
+ duration: o.animate
+ });
+ }
+ } else {
+ if (i === 0) {
+ that.range.stop(1, 1)[animate ? "animate" : "css"]({
+ bottom: (valPercent) + "%"
+ }, o.animate);
+ }
+ if (i === 1) {
+ that.range[animate ? "animate" : "css"]({
+ height: (valPercent - lastValPercent) + "%"
+ }, {
+ queue: false,
+ duration: o.animate
+ });
+ }
+ }
+ }
+ lastValPercent = valPercent;
+ });
+ } else {
+ value = this.value();
+ valueMin = this._valueMin();
+ valueMax = this._valueMax();
+ valPercent = (valueMax !== valueMin) ?
+ (value - valueMin) / (valueMax - valueMin) * 100 :
+ 0;
+ _set[this.orientation === "horizontal" ? "left" : "bottom"] = valPercent + "%";
+ this.handle.stop(1, 1)[animate ? "animate" : "css"](_set, o.animate);
+
+ if (oRange === "min" && this.orientation === "horizontal") {
+ this.range.stop(1, 1)[animate ? "animate" : "css"]({
+ width: valPercent + "%"
+ }, o.animate);
+ }
+ if (oRange === "max" && this.orientation === "horizontal") {
+ this.range.stop(1, 1)[animate ? "animate" : "css"]({
+ width: (100 - valPercent) + "%"
+ }, o.animate);
+ }
+ if (oRange === "min" && this.orientation === "vertical") {
+ this.range.stop(1, 1)[animate ? "animate" : "css"]({
+ height: valPercent + "%"
+ }, o.animate);
+ }
+ if (oRange === "max" && this.orientation === "vertical") {
+ this.range.stop(1, 1)[animate ? "animate" : "css"]({
+ height: (100 - valPercent) + "%"
+ }, o.animate);
+ }
+ }
+ },
+
+ _handleEvents: {
+ keydown: function (event) {
+ var allowed, curVal, newVal, step,
+ index = $(event.target).data("ui-slider-handle-index");
+
+ switch (event.keyCode) {
+ case $.ui.keyCode.HOME:
+ case $.ui.keyCode.END:
+ case $.ui.keyCode.PAGE_UP:
+ case $.ui.keyCode.PAGE_DOWN:
+ case $.ui.keyCode.UP:
+ case $.ui.keyCode.RIGHT:
+ case $.ui.keyCode.DOWN:
+ case $.ui.keyCode.LEFT:
+ event.preventDefault();
+ if (!this._keySliding) {
+ this._keySliding = true;
+ this._addClass($(event.target), null, "ui-state-active");
+ allowed = this._start(event, index);
+ if (allowed === false) {
+ return;
+ }
+ }
+ break;
+ }
+
+ step = this.options.step;
+ if (this._hasMultipleValues()) {
+ curVal = newVal = this.values(index);
+ } else {
+ curVal = newVal = this.value();
+ }
+
+ switch (event.keyCode) {
+ case $.ui.keyCode.HOME:
+ newVal = this._valueMin();
+ break;
+ case $.ui.keyCode.END:
+ newVal = this._valueMax();
+ break;
+ case $.ui.keyCode.PAGE_UP:
+ newVal = this._trimAlignValue(
+ curVal + ((this._valueMax() - this._valueMin()) / this.numPages)
+ );
+ break;
+ case $.ui.keyCode.PAGE_DOWN:
+ newVal = this._trimAlignValue(
+ curVal - ((this._valueMax() - this._valueMin()) / this.numPages));
+ break;
+ case $.ui.keyCode.UP:
+ case $.ui.keyCode.RIGHT:
+ if (curVal === this._valueMax()) {
+ return;
+ }
+ newVal = this._trimAlignValue(curVal + step);
+ break;
+ case $.ui.keyCode.DOWN:
+ case $.ui.keyCode.LEFT:
+ if (curVal === this._valueMin()) {
+ return;
+ }
+ newVal = this._trimAlignValue(curVal - step);
+ break;
+ }
+
+ this._slide(event, index, newVal);
+ },
+ keyup: function (event) {
+ var index = $(event.target).data("ui-slider-handle-index");
+
+ if (this._keySliding) {
+ this._keySliding = false;
+ this._stop(event, index);
+ this._change(event, index);
+ this._removeClass($(event.target), null, "ui-state-active");
+ }
+ }
+ }
+ });
+
+
+ /*!
+ * jQuery UI Sortable 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Sortable
+ //>>group: Interactions
+ //>>description: Enables items in a list to be sorted using the mouse.
+ //>>docs: http://api.jqueryui.com/sortable/
+ //>>demos: http://jqueryui.com/sortable/
+ //>>css.structure: ../../themes/base/sortable.css
+
+
+
+ var widgetsSortable = $.widget("ui.sortable", $.ui.mouse, {
+ version: "1.12.1",
+ widgetEventPrefix: "sort",
+ ready: false,
+ options: {
+ appendTo: "parent",
+ axis: false,
+ connectWith: false,
+ containment: false,
+ cursor: "auto",
+ cursorAt: false,
+ dropOnEmpty: true,
+ forcePlaceholderSize: false,
+ forceHelperSize: false,
+ grid: false,
+ handle: false,
+ helper: "original",
+ items: "> *",
+ opacity: false,
+ placeholder: false,
+ revert: false,
+ scroll: true,
+ scrollSensitivity: 20,
+ scrollSpeed: 20,
+ scope: "default",
+ tolerance: "intersect",
+ zIndex: 1000,
+
+ // Callbacks
+ activate: null,
+ beforeStop: null,
+ change: null,
+ deactivate: null,
+ out: null,
+ over: null,
+ receive: null,
+ remove: null,
+ sort: null,
+ start: null,
+ stop: null,
+ update: null
+ },
+
+ _isOverAxis: function (x, reference, size) {
+ return (x >= reference) && (x < (reference + size));
+ },
+
+ _isFloating: function (item) {
+ return (/left|right/).test(item.css("float")) ||
+ (/inline|table-cell/).test(item.css("display"));
+ },
+
+ _create: function () {
+ this.containerCache = {};
+ this._addClass("ui-sortable");
+
+ //Get the items
+ this.refresh();
+
+ //Let's determine the parent's offset
+ this.offset = this.element.offset();
+
+ //Initialize mouse events for interaction
+ this._mouseInit();
+
+ this._setHandleClassName();
+
+ //We're ready to go
+ this.ready = true;
+
+ },
+
+ _setOption: function (key, value) {
+ this._super(key, value);
+
+ if (key === "handle") {
+ this._setHandleClassName();
+ }
+ },
+
+ _setHandleClassName: function () {
+ var that = this;
+ this._removeClass(this.element.find(".ui-sortable-handle"), "ui-sortable-handle");
+ $.each(this.items, function () {
+ that._addClass(
+ this.instance.options.handle ?
+ this.item.find(this.instance.options.handle) :
+ this.item,
+ "ui-sortable-handle"
+ );
+ });
+ },
+
+ _destroy: function () {
+ this._mouseDestroy();
+
+ for (var i = this.items.length - 1; i >= 0; i--) {
+ this.items[i].item.removeData(this.widgetName + "-item");
+ }
+
+ return this;
+ },
+
+ _mouseCapture: function (event, overrideHandle) {
+ var currentItem = null,
+ validHandle = false,
+ that = this;
+
+ if (this.reverting) {
+ return false;
+ }
+
+ if (this.options.disabled || this.options.type === "static") {
+ return false;
+ }
+
+ //We have to refresh the items data once first
+ this._refreshItems(event);
+
+ //Find out if the clicked node (or one of its parents) is a actual item in this.items
+ $(event.target).parents().each(function () {
+ if ($.data(this, that.widgetName + "-item") === that) {
+ currentItem = $(this);
+ return false;
+ }
+ });
+ if ($.data(event.target, that.widgetName + "-item") === that) {
+ currentItem = $(event.target);
+ }
+
+ if (!currentItem) {
+ return false;
+ }
+ if (this.options.handle && !overrideHandle) {
+ $(this.options.handle, currentItem).find("*").addBack().each(function () {
+ if (this === event.target) {
+ validHandle = true;
+ }
+ });
+ if (!validHandle) {
+ return false;
+ }
+ }
+
+ this.currentItem = currentItem;
+ this._removeCurrentsFromItems();
+ return true;
+
+ },
+
+ _mouseStart: function (event, overrideHandle, noActivation) {
+
+ var i, body,
+ o = this.options;
+
+ this.currentContainer = this;
+
+ //We only need to call refreshPositions, because the refreshItems call has been moved to
+ // mouseCapture
+ this.refreshPositions();
+
+ //Create and append the visible helper
+ this.helper = this._createHelper(event);
+
+ //Cache the helper size
+ this._cacheHelperProportions();
+
+ /*
+ * - Position generation -
+ * This block generates everything position related - it's the core of draggables.
+ */
+
+ //Cache the margins of the original element
+ this._cacheMargins();
+
+ //Get the next scrolling parent
+ this.scrollParent = this.helper.scrollParent();
+
+ //The element's absolute position on the page minus margins
+ this.offset = this.currentItem.offset();
+ this.offset = {
+ top: this.offset.top - this.margins.top,
+ left: this.offset.left - this.margins.left
+ };
+
+ $.extend(this.offset, {
+ click: { //Where the click happened, relative to the element
+ left: event.pageX - this.offset.left,
+ top: event.pageY - this.offset.top
+ },
+ parent: this._getParentOffset(),
+
+ // This is a relative to absolute position minus the actual position calculation -
+ // only used for relative positioned helper
+ relative: this._getRelativeOffset()
+ });
+
+ // Only after we got the offset, we can change the helper's position to absolute
+ // TODO: Still need to figure out a way to make relative sorting possible
+ this.helper.css("position", "absolute");
+ this.cssPosition = this.helper.css("position");
+
+ //Generate the original position
+ this.originalPosition = this._generatePosition(event);
+ this.originalPageX = event.pageX;
+ this.originalPageY = event.pageY;
+
+ //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
+ (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
+
+ //Cache the former DOM position
+ this.domPosition = {
+ prev: this.currentItem.prev()[0],
+ parent: this.currentItem.parent()[0]
+ };
+
+ // If the helper is not the original, hide the original so it's not playing any role during
+ // the drag, won't cause anything bad this way
+ if (this.helper[0] !== this.currentItem[0]) {
+ this.currentItem.hide();
+ }
+
+ //Create the placeholder
+ this._createPlaceholder();
+
+ //Set a containment if given in the options
+ if (o.containment) {
+ this._setContainment();
+ }
+
+ if (o.cursor && o.cursor !== "auto") { // cursor option
+ body = this.document.find("body");
+
+ // Support: IE
+ this.storedCursor = body.css("cursor");
+ body.css("cursor", o.cursor);
+
+ this.storedStylesheet =
+ $("<style>*{ cursor: " + o.cursor + " !important; }</style>").appendTo(body);
+ }
+
+ if (o.opacity) { // opacity option
+ if (this.helper.css("opacity")) {
+ this._storedOpacity = this.helper.css("opacity");
+ }
+ this.helper.css("opacity", o.opacity);
+ }
+
+ if (o.zIndex) { // zIndex option
+ if (this.helper.css("zIndex")) {
+ this._storedZIndex = this.helper.css("zIndex");
+ }
+ this.helper.css("zIndex", o.zIndex);
+ }
+
+ //Prepare scrolling
+ if (this.scrollParent[0] !== this.document[0] &&
+ this.scrollParent[0].tagName !== "HTML") {
+ this.overflowOffset = this.scrollParent.offset();
+ }
+
+ //Call callbacks
+ this._trigger("start", event, this._uiHash());
+
+ //Recache the helper size
+ if (!this._preserveHelperProportions) {
+ this._cacheHelperProportions();
+ }
+
+ //Post "activate" events to possible containers
+ if (!noActivation) {
+ for (i = this.containers.length - 1; i >= 0; i--) {
+ this.containers[i]._trigger("activate", event, this._uiHash(this));
+ }
+ }
+
+ //Prepare possible droppables
+ if ($.ui.ddmanager) {
+ $.ui.ddmanager.current = this;
+ }
+
+ if ($.ui.ddmanager && !o.dropBehaviour) {
+ $.ui.ddmanager.prepareOffsets(this, event);
+ }
+
+ this.dragging = true;
+
+ this._addClass(this.helper, "ui-sortable-helper");
+
+ // Execute the drag once - this causes the helper not to be visiblebefore getting its
+ // correct position
+ this._mouseDrag(event);
+ return true;
+
+ },
+
+ _mouseDrag: function (event) {
+ var i, item, itemElement, intersection,
+ o = this.options,
+ scrolled = false;
+
+ //Compute the helpers position
+ this.position = this._generatePosition(event);
+ this.positionAbs = this._convertPositionTo("absolute");
+
+ if (!this.lastPositionAbs) {
+ this.lastPositionAbs = this.positionAbs;
+ }
+
+ //Do scrolling
+ if (this.options.scroll) {
+ if (this.scrollParent[0] !== this.document[0] &&
+ this.scrollParent[0].tagName !== "HTML") {
+
+ if ((this.overflowOffset.top + this.scrollParent[0].offsetHeight) -
+ event.pageY < o.scrollSensitivity) {
+ this.scrollParent[0].scrollTop =
+ scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
+ } else if (event.pageY - this.overflowOffset.top < o.scrollSensitivity) {
+ this.scrollParent[0].scrollTop =
+ scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
+ }
+
+ if ((this.overflowOffset.left + this.scrollParent[0].offsetWidth) -
+ event.pageX < o.scrollSensitivity) {
+ this.scrollParent[0].scrollLeft = scrolled =
+ this.scrollParent[0].scrollLeft + o.scrollSpeed;
+ } else if (event.pageX - this.overflowOffset.left < o.scrollSensitivity) {
+ this.scrollParent[0].scrollLeft = scrolled =
+ this.scrollParent[0].scrollLeft - o.scrollSpeed;
+ }
+
+ } else {
+
+ if (event.pageY - this.document.scrollTop() < o.scrollSensitivity) {
+ scrolled = this.document.scrollTop(this.document.scrollTop() - o.scrollSpeed);
+ } else if (this.window.height() - (event.pageY - this.document.scrollTop()) <
+ o.scrollSensitivity) {
+ scrolled = this.document.scrollTop(this.document.scrollTop() + o.scrollSpeed);
+ }
+
+ if (event.pageX - this.document.scrollLeft() < o.scrollSensitivity) {
+ scrolled = this.document.scrollLeft(
+ this.document.scrollLeft() - o.scrollSpeed
+ );
+ } else if (this.window.width() - (event.pageX - this.document.scrollLeft()) <
+ o.scrollSensitivity) {
+ scrolled = this.document.scrollLeft(
+ this.document.scrollLeft() + o.scrollSpeed
+ );
+ }
+
+ }
+
+ if (scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
+ $.ui.ddmanager.prepareOffsets(this, event);
+ }
+ }
+
+ //Regenerate the absolute position used for position checks
+ this.positionAbs = this._convertPositionTo("absolute");
+
+ //Set the helper position
+ if (!this.options.axis || this.options.axis !== "y") {
+ this.helper[0].style.left = this.position.left + "px";
+ }
+ if (!this.options.axis || this.options.axis !== "x") {
+ this.helper[0].style.top = this.position.top + "px";
+ }
+
+ //Rearrange
+ for (i = this.items.length - 1; i >= 0; i--) {
+
+ //Cache variables and intersection, continue if no intersection
+ item = this.items[i];
+ itemElement = item.item[0];
+ intersection = this._intersectsWithPointer(item);
+ if (!intersection) {
+ continue;
+ }
+
+ // Only put the placeholder inside the current Container, skip all
+ // items from other containers. This works because when moving
+ // an item from one container to another the
+ // currentContainer is switched before the placeholder is moved.
+ //
+ // Without this, moving items in "sub-sortables" can cause
+ // the placeholder to jitter between the outer and inner container.
+ if (item.instance !== this.currentContainer) {
+ continue;
+ }
+
+ // Cannot intersect with itself
+ // no useless actions that have been done before
+ // no action if the item moved is the parent of the item checked
+ if (itemElement !== this.currentItem[0] &&
+ this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement &&
+ !$.contains(this.placeholder[0], itemElement) &&
+ (this.options.type === "semi-dynamic" ?
+ !$.contains(this.element[0], itemElement) :
+ true
+ )
+ ) {
+
+ this.direction = intersection === 1 ? "down" : "up";
+
+ if (this.options.tolerance === "pointer" || this._intersectsWithSides(item)) {
+ this._rearrange(event, item);
+ } else {
+ break;
+ }
+
+ this._trigger("change", event, this._uiHash());
+ break;
+ }
+ }
+
+ //Post events to containers
+ this._contactContainers(event);
+
+ //Interconnect with droppables
+ if ($.ui.ddmanager) {
+ $.ui.ddmanager.drag(this, event);
+ }
+
+ //Call callbacks
+ this._trigger("sort", event, this._uiHash());
+
+ this.lastPositionAbs = this.positionAbs;
+ return false;
+
+ },
+
+ _mouseStop: function (event, noPropagation) {
+
+ if (!event) {
+ return;
+ }
+
+ //If we are using droppables, inform the manager about the drop
+ if ($.ui.ddmanager && !this.options.dropBehaviour) {
+ $.ui.ddmanager.drop(this, event);
+ }
+
+ if (this.options.revert) {
+ var that = this,
+ cur = this.placeholder.offset(),
+ axis = this.options.axis,
+ animation = {};
+
+ if (!axis || axis === "x") {
+ animation.left = cur.left - this.offset.parent.left - this.margins.left +
+ (this.offsetParent[0] === this.document[0].body ?
+ 0 :
+ this.offsetParent[0].scrollLeft
+ );
+ }
+ if (!axis || axis === "y") {
+ animation.top = cur.top - this.offset.parent.top - this.margins.top +
+ (this.offsetParent[0] === this.document[0].body ?
+ 0 :
+ this.offsetParent[0].scrollTop
+ );
+ }
+ this.reverting = true;
+ $(this.helper).animate(
+ animation,
+ parseInt(this.options.revert, 10) || 500,
+ function () {
+ that._clear(event);
+ }
+ );
+ } else {
+ this._clear(event, noPropagation);
+ }
+
+ return false;
+
+ },
+
+ cancel: function () {
+
+ if (this.dragging) {
+
+ this._mouseUp(new $.Event("mouseup", { target: null }));
+
+ if (this.options.helper === "original") {
+ this.currentItem.css(this._storedCSS);
+ this._removeClass(this.currentItem, "ui-sortable-helper");
+ } else {
+ this.currentItem.show();
+ }
+
+ //Post deactivating events to containers
+ for (var i = this.containers.length - 1; i >= 0; i--) {
+ this.containers[i]._trigger("deactivate", null, this._uiHash(this));
+ if (this.containers[i].containerCache.over) {
+ this.containers[i]._trigger("out", null, this._uiHash(this));
+ this.containers[i].containerCache.over = 0;
+ }
+ }
+
+ }
+
+ if (this.placeholder) {
+
+ //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately,
+ // it unbinds ALL events from the original node!
+ if (this.placeholder[0].parentNode) {
+ this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
+ }
+ if (this.options.helper !== "original" && this.helper &&
+ this.helper[0].parentNode) {
+ this.helper.remove();
+ }
+
+ $.extend(this, {
+ helper: null,
+ dragging: false,
+ reverting: false,
+ _noFinalSort: null
+ });
+
+ if (this.domPosition.prev) {
+ $(this.domPosition.prev).after(this.currentItem);
+ } else {
+ $(this.domPosition.parent).prepend(this.currentItem);
+ }
+ }
+
+ return this;
+
+ },
+
+ serialize: function (o) {
+
+ var items = this._getItemsAsjQuery(o && o.connected),
+ str = [];
+ o = o || {};
+
+ $(items).each(function () {
+ var res = ($(o.item || this).attr(o.attribute || "id") || "")
+ .match(o.expression || (/(.+)[\-=_](.+)/));
+ if (res) {
+ str.push(
+ (o.key || res[1] + "[]") +
+ "=" + (o.key && o.expression ? res[1] : res[2]));
+ }
+ });
+
+ if (!str.length && o.key) {
+ str.push(o.key + "=");
+ }
+
+ return str.join("&");
+
+ },
+
+ toArray: function (o) {
+
+ var items = this._getItemsAsjQuery(o && o.connected),
+ ret = [];
+
+ o = o || {};
+
+ items.each(function () {
+ ret.push($(o.item || this).attr(o.attribute || "id") || "");
+ });
+ return ret;
+
+ },
+
+ /* Be careful with the following core functions */
+ _intersectsWith: function (item) {
+
+ var x1 = this.positionAbs.left,
+ x2 = x1 + this.helperProportions.width,
+ y1 = this.positionAbs.top,
+ y2 = y1 + this.helperProportions.height,
+ l = item.left,
+ r = l + item.width,
+ t = item.top,
+ b = t + item.height,
+ dyClick = this.offset.click.top,
+ dxClick = this.offset.click.left,
+ isOverElementHeight = (this.options.axis === "x") || ((y1 + dyClick) > t &&
+ (y1 + dyClick) < b),
+ isOverElementWidth = (this.options.axis === "y") || ((x1 + dxClick) > l &&
+ (x1 + dxClick) < r),
+ isOverElement = isOverElementHeight && isOverElementWidth;
+
+ if (this.options.tolerance === "pointer" ||
+ this.options.forcePointerForContainers ||
+ (this.options.tolerance !== "pointer" &&
+ this.helperProportions[this.floating ? "width" : "height"] >
+ item[this.floating ? "width" : "height"])
+ ) {
+ return isOverElement;
+ } else {
+
+ return (l < x1 + (this.helperProportions.width / 2) && // Right Half
+ x2 - (this.helperProportions.width / 2) < r && // Left Half
+ t < y1 + (this.helperProportions.height / 2) && // Bottom Half
+ y2 - (this.helperProportions.height / 2) < b); // Top Half
+
+ }
+ },
+
+ _intersectsWithPointer: function (item) {
+ var verticalDirection, horizontalDirection,
+ isOverElementHeight = (this.options.axis === "x") ||
+ this._isOverAxis(
+ this.positionAbs.top + this.offset.click.top, item.top, item.height),
+ isOverElementWidth = (this.options.axis === "y") ||
+ this._isOverAxis(
+ this.positionAbs.left + this.offset.click.left, item.left, item.width),
+ isOverElement = isOverElementHeight && isOverElementWidth;
+
+ if (!isOverElement) {
+ return false;
+ }
+
+ verticalDirection = this._getDragVerticalDirection();
+ horizontalDirection = this._getDragHorizontalDirection();
+
+ return this.floating ?
+ ((horizontalDirection === "right" || verticalDirection === "down") ? 2 : 1)
+ : (verticalDirection && (verticalDirection === "down" ? 2 : 1));
+
+ },
+
+ _intersectsWithSides: function (item) {
+
+ var isOverBottomHalf = this._isOverAxis(this.positionAbs.top +
+ this.offset.click.top, item.top + (item.height / 2), item.height),
+ isOverRightHalf = this._isOverAxis(this.positionAbs.left +
+ this.offset.click.left, item.left + (item.width / 2), item.width),
+ verticalDirection = this._getDragVerticalDirection(),
+ horizontalDirection = this._getDragHorizontalDirection();
+
+ if (this.floating && horizontalDirection) {
+ return ((horizontalDirection === "right" && isOverRightHalf) ||
+ (horizontalDirection === "left" && !isOverRightHalf));
+ } else {
+ return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) ||
+ (verticalDirection === "up" && !isOverBottomHalf));
+ }
+
+ },
+
+ _getDragVerticalDirection: function () {
+ var delta = this.positionAbs.top - this.lastPositionAbs.top;
+ return delta !== 0 && (delta > 0 ? "down" : "up");
+ },
+
+ _getDragHorizontalDirection: function () {
+ var delta = this.positionAbs.left - this.lastPositionAbs.left;
+ return delta !== 0 && (delta > 0 ? "right" : "left");
+ },
+
+ refresh: function (event) {
+ this._refreshItems(event);
+ this._setHandleClassName();
+ this.refreshPositions();
+ return this;
+ },
+
+ _connectWith: function () {
+ var options = this.options;
+ return options.connectWith.constructor === String ?
+ [options.connectWith] :
+ options.connectWith;
+ },
+
+ _getItemsAsjQuery: function (connected) {
+
+ var i, j, cur, inst,
+ items = [],
+ queries = [],
+ connectWith = this._connectWith();
+
+ if (connectWith && connected) {
+ for (i = connectWith.length - 1; i >= 0; i--) {
+ cur = $(connectWith[i], this.document[0]);
+ for (j = cur.length - 1; j >= 0; j--) {
+ inst = $.data(cur[j], this.widgetFullName);
+ if (inst && inst !== this && !inst.options.disabled) {
+ queries.push([$.isFunction(inst.options.items) ?
+ inst.options.items.call(inst.element) :
+ $(inst.options.items, inst.element)
+ .not(".ui-sortable-helper")
+ .not(".ui-sortable-placeholder"), inst]);
+ }
+ }
+ }
+ }
+
+ queries.push([$.isFunction(this.options.items) ?
+ this.options.items
+ .call(this.element, null, { options: this.options, item: this.currentItem }) :
+ $(this.options.items, this.element)
+ .not(".ui-sortable-helper")
+ .not(".ui-sortable-placeholder"), this]);
+
+ function addItems() {
+ items.push(this);
+ }
+ for (i = queries.length - 1; i >= 0; i--) {
+ queries[i][0].each(addItems);
+ }
+
+ return $(items);
+
+ },
+
+ _removeCurrentsFromItems: function () {
+
+ var list = this.currentItem.find(":data(" + this.widgetName + "-item)");
+
+ this.items = $.grep(this.items, function (item) {
+ for (var j = 0; j < list.length; j++) {
+ if (list[j] === item.item[0]) {
+ return false;
+ }
+ }
+ return true;
+ });
+
+ },
+
+ _refreshItems: function (event) {
+
+ this.items = [];
+ this.containers = [this];
+
+ var i, j, cur, inst, targetData, _queries, item, queriesLength,
+ items = this.items,
+ queries = [[$.isFunction(this.options.items) ?
+ this.options.items.call(this.element[0], event, { item: this.currentItem }) :
+ $(this.options.items, this.element), this]],
+ connectWith = this._connectWith();
+
+ //Shouldn't be run the first time through due to massive slow-down
+ if (connectWith && this.ready) {
+ for (i = connectWith.length - 1; i >= 0; i--) {
+ cur = $(connectWith[i], this.document[0]);
+ for (j = cur.length - 1; j >= 0; j--) {
+ inst = $.data(cur[j], this.widgetFullName);
+ if (inst && inst !== this && !inst.options.disabled) {
+ queries.push([$.isFunction(inst.options.items) ?
+ inst.options.items
+ .call(inst.element[0], event, { item: this.currentItem }) :
+ $(inst.options.items, inst.element), inst]);
+ this.containers.push(inst);
+ }
+ }
+ }
+ }
+
+ for (i = queries.length - 1; i >= 0; i--) {
+ targetData = queries[i][1];
+ _queries = queries[i][0];
+
+ for (j = 0, queriesLength = _queries.length; j < queriesLength; j++) {
+ item = $(_queries[j]);
+
+ // Data for target checking (mouse manager)
+ item.data(this.widgetName + "-item", targetData);
+
+ items.push({
+ item: item,
+ instance: targetData,
+ width: 0, height: 0,
+ left: 0, top: 0
+ });
+ }
+ }
+
+ },
+
+ refreshPositions: function (fast) {
+
+ // Determine whether items are being displayed horizontally
+ this.floating = this.items.length ?
+ this.options.axis === "x" || this._isFloating(this.items[0].item) :
+ false;
+
+ //This has to be redone because due to the item being moved out/into the offsetParent,
+ // the offsetParent's position will change
+ if (this.offsetParent && this.helper) {
+ this.offset.parent = this._getParentOffset();
+ }
+
+ var i, item, t, p;
+
+ for (i = this.items.length - 1; i >= 0; i--) {
+ item = this.items[i];
+
+ //We ignore calculating positions of all connected containers when we're not over them
+ if (item.instance !== this.currentContainer && this.currentContainer &&
+ item.item[0] !== this.currentItem[0]) {
+ continue;
+ }
+
+ t = this.options.toleranceElement ?
+ $(this.options.toleranceElement, item.item) :
+ item.item;
+
+ if (!fast) {
+ item.width = t.outerWidth();
+ item.height = t.outerHeight();
+ }
+
+ p = t.offset();
+ item.left = p.left;
+ item.top = p.top;
+ }
+
+ if (this.options.custom && this.options.custom.refreshContainers) {
+ this.options.custom.refreshContainers.call(this);
+ } else {
+ for (i = this.containers.length - 1; i >= 0; i--) {
+ p = this.containers[i].element.offset();
+ this.containers[i].containerCache.left = p.left;
+ this.containers[i].containerCache.top = p.top;
+ this.containers[i].containerCache.width =
+ this.containers[i].element.outerWidth();
+ this.containers[i].containerCache.height =
+ this.containers[i].element.outerHeight();
+ }
+ }
+
+ return this;
+ },
+
+ _createPlaceholder: function (that) {
+ that = that || this;
+ var className,
+ o = that.options;
+
+ if (!o.placeholder || o.placeholder.constructor === String) {
+ className = o.placeholder;
+ o.placeholder = {
+ element: function () {
+
+ var nodeName = that.currentItem[0].nodeName.toLowerCase(),
+ element = $("<" + nodeName + ">", that.document[0]);
+
+ that._addClass(element, "ui-sortable-placeholder",
+ className || that.currentItem[0].className)
+ ._removeClass(element, "ui-sortable-helper");
+
+ if (nodeName === "tbody") {
+ that._createTrPlaceholder(
+ that.currentItem.find("tr").eq(0),
+ $("<tr>", that.document[0]).appendTo(element)
+ );
+ } else if (nodeName === "tr") {
+ that._createTrPlaceholder(that.currentItem, element);
+ } else if (nodeName === "img") {
+ element.attr("src", that.currentItem.attr("src"));
+ }
+
+ if (!className) {
+ element.css("visibility", "hidden");
+ }
+
+ return element;
+ },
+ update: function (container, p) {
+
+ // 1. If a className is set as 'placeholder option, we don't force sizes -
+ // the class is responsible for that
+ // 2. The option 'forcePlaceholderSize can be enabled to force it even if a
+ // class name is specified
+ if (className && !o.forcePlaceholderSize) {
+ return;
+ }
+
+ //If the element doesn't have a actual height by itself (without styles coming
+ // from a stylesheet), it receives the inline height from the dragged item
+ if (!p.height()) {
+ p.height(
+ that.currentItem.innerHeight() -
+ parseInt(that.currentItem.css("paddingTop") || 0, 10) -
+ parseInt(that.currentItem.css("paddingBottom") || 0, 10));
+ }
+ if (!p.width()) {
+ p.width(
+ that.currentItem.innerWidth() -
+ parseInt(that.currentItem.css("paddingLeft") || 0, 10) -
+ parseInt(that.currentItem.css("paddingRight") || 0, 10));
+ }
+ }
+ };
+ }
+
+ //Create the placeholder
+ that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem));
+
+ //Append it after the actual current item
+ that.currentItem.after(that.placeholder);
+
+ //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
+ o.placeholder.update(that, that.placeholder);
+
+ },
+
+ _createTrPlaceholder: function (sourceTr, targetTr) {
+ var that = this;
+
+ sourceTr.children().each(function () {
+ $("<td> </td>", that.document[0])
+ .attr("colspan", $(this).attr("colspan") || 1)
+ .appendTo(targetTr);
+ });
+ },
+
+ _contactContainers: function (event) {
+ var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, cur, nearBottom,
+ floating, axis,
+ innermostContainer = null,
+ innermostIndex = null;
+
+ // Get innermost container that intersects with item
+ for (i = this.containers.length - 1; i >= 0; i--) {
+
+ // Never consider a container that's located within the item itself
+ if ($.contains(this.currentItem[0], this.containers[i].element[0])) {
+ continue;
+ }
+
+ if (this._intersectsWith(this.containers[i].containerCache)) {
+
+ // If we've already found a container and it's more "inner" than this, then continue
+ if (innermostContainer &&
+ $.contains(
+ this.containers[i].element[0],
+ innermostContainer.element[0])) {
+ continue;
+ }
+
+ innermostContainer = this.containers[i];
+ innermostIndex = i;
+
+ } else {
+
+ // container doesn't intersect. trigger "out" event if necessary
+ if (this.containers[i].containerCache.over) {
+ this.containers[i]._trigger("out", event, this._uiHash(this));
+ this.containers[i].containerCache.over = 0;
+ }
+ }
+
+ }
+
+ // If no intersecting containers found, return
+ if (!innermostContainer) {
+ return;
+ }
+
+ // Move the item into the container if it's not there already
+ if (this.containers.length === 1) {
+ if (!this.containers[innermostIndex].containerCache.over) {
+ this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
+ this.containers[innermostIndex].containerCache.over = 1;
+ }
+ } else {
+
+ // When entering a new container, we will find the item with the least distance and
+ // append our item near it
+ dist = 10000;
+ itemWithLeastDistance = null;
+ floating = innermostContainer.floating || this._isFloating(this.currentItem);
+ posProperty = floating ? "left" : "top";
+ sizeProperty = floating ? "width" : "height";
+ axis = floating ? "pageX" : "pageY";
+
+ for (j = this.items.length - 1; j >= 0; j--) {
+ if (!$.contains(
+ this.containers[innermostIndex].element[0], this.items[j].item[0])
+ ) {
+ continue;
+ }
+ if (this.items[j].item[0] === this.currentItem[0]) {
+ continue;
+ }
+
+ cur = this.items[j].item.offset()[posProperty];
+ nearBottom = false;
+ if (event[axis] - cur > this.items[j][sizeProperty] / 2) {
+ nearBottom = true;
+ }
+
+ if (Math.abs(event[axis] - cur) < dist) {
+ dist = Math.abs(event[axis] - cur);
+ itemWithLeastDistance = this.items[j];
+ this.direction = nearBottom ? "up" : "down";
+ }
+ }
+
+ //Check if dropOnEmpty is enabled
+ if (!itemWithLeastDistance && !this.options.dropOnEmpty) {
+ return;
+ }
+
+ if (this.currentContainer === this.containers[innermostIndex]) {
+ if (!this.currentContainer.containerCache.over) {
+ this.containers[innermostIndex]._trigger("over", event, this._uiHash());
+ this.currentContainer.containerCache.over = 1;
+ }
+ return;
+ }
+
+ itemWithLeastDistance ?
+ this._rearrange(event, itemWithLeastDistance, null, true) :
+ this._rearrange(event, null, this.containers[innermostIndex].element, true);
+ this._trigger("change", event, this._uiHash());
+ this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));
+ this.currentContainer = this.containers[innermostIndex];
+
+ //Update the placeholder
+ this.options.placeholder.update(this.currentContainer, this.placeholder);
+
+ this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
+ this.containers[innermostIndex].containerCache.over = 1;
+ }
+
+ },
+
+ _createHelper: function (event) {
+
+ var o = this.options,
+ helper = $.isFunction(o.helper) ?
+ $(o.helper.apply(this.element[0], [event, this.currentItem])) :
+ (o.helper === "clone" ? this.currentItem.clone() : this.currentItem);
+
+ //Add the helper to the DOM if that didn't happen already
+ if (!helper.parents("body").length) {
+ $(o.appendTo !== "parent" ?
+ o.appendTo :
+ this.currentItem[0].parentNode)[0].appendChild(helper[0]);
+ }
+
+ if (helper[0] === this.currentItem[0]) {
+ this._storedCSS = {
+ width: this.currentItem[0].style.width,
+ height: this.currentItem[0].style.height,
+ position: this.currentItem.css("position"),
+ top: this.currentItem.css("top"),
+ left: this.currentItem.css("left")
+ };
+ }
+
+ if (!helper[0].style.width || o.forceHelperSize) {
+ helper.width(this.currentItem.width());
+ }
+ if (!helper[0].style.height || o.forceHelperSize) {
+ helper.height(this.currentItem.height());
+ }
+
+ return helper;
+
+ },
+
+ _adjustOffsetFromHelper: function (obj) {
+ if (typeof obj === "string") {
+ obj = obj.split(" ");
+ }
+ if ($.isArray(obj)) {
+ obj = { left: +obj[0], top: +obj[1] || 0 };
+ }
+ if ("left" in obj) {
+ this.offset.click.left = obj.left + this.margins.left;
+ }
+ if ("right" in obj) {
+ this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
+ }
+ if ("top" in obj) {
+ this.offset.click.top = obj.top + this.margins.top;
+ }
+ if ("bottom" in obj) {
+ this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
+ }
+ },
+
+ _getParentOffset: function () {
+
+ //Get the offsetParent and cache its position
+ this.offsetParent = this.helper.offsetParent();
+ var po = this.offsetParent.offset();
+
+ // This is a special case where we need to modify a offset calculated on start, since the
+ // following happened:
+ // 1. The position of the helper is absolute, so it's position is calculated based on the
+ // next positioned parent
+ // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't
+ // the document, which means that the scroll is included in the initial calculation of the
+ // offset of the parent, and never recalculated upon drag
+ if (this.cssPosition === "absolute" && this.scrollParent[0] !== this.document[0] &&
+ $.contains(this.scrollParent[0], this.offsetParent[0])) {
+ po.left += this.scrollParent.scrollLeft();
+ po.top += this.scrollParent.scrollTop();
+ }
+
+ // This needs to be actually done for all browsers, since pageX/pageY includes this
+ // information with an ugly IE fix
+ if (this.offsetParent[0] === this.document[0].body ||
+ (this.offsetParent[0].tagName &&
+ this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
+ po = { top: 0, left: 0 };
+ }
+
+ return {
+ top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"), 10) || 0),
+ left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"), 10) || 0)
+ };
+
+ },
+
+ _getRelativeOffset: function () {
+
+ if (this.cssPosition === "relative") {
+ var p = this.currentItem.position();
+ return {
+ top: p.top - (parseInt(this.helper.css("top"), 10) || 0) +
+ this.scrollParent.scrollTop(),
+ left: p.left - (parseInt(this.helper.css("left"), 10) || 0) +
+ this.scrollParent.scrollLeft()
+ };
+ } else {
+ return { top: 0, left: 0 };
+ }
+
+ },
+
+ _cacheMargins: function () {
+ this.margins = {
+ left: (parseInt(this.currentItem.css("marginLeft"), 10) || 0),
+ top: (parseInt(this.currentItem.css("marginTop"), 10) || 0)
+ };
+ },
+
+ _cacheHelperProportions: function () {
+ this.helperProportions = {
+ width: this.helper.outerWidth(),
+ height: this.helper.outerHeight()
+ };
+ },
+
+ _setContainment: function () {
+
+ var ce, co, over,
+ o = this.options;
+ if (o.containment === "parent") {
+ o.containment = this.helper[0].parentNode;
+ }
+ if (o.containment === "document" || o.containment === "window") {
+ this.containment = [
+ 0 - this.offset.relative.left - this.offset.parent.left,
+ 0 - this.offset.relative.top - this.offset.parent.top,
+ o.containment === "document" ?
+ this.document.width() :
+ this.window.width() - this.helperProportions.width - this.margins.left,
+ (o.containment === "document" ?
+ (this.document.height() || document.body.parentNode.scrollHeight) :
+ this.window.height() || this.document[0].body.parentNode.scrollHeight
+ ) - this.helperProportions.height - this.margins.top
+ ];
+ }
+
+ if (!(/^(document|window|parent)$/).test(o.containment)) {
+ ce = $(o.containment)[0];
+ co = $(o.containment).offset();
+ over = ($(ce).css("overflow") !== "hidden");
+
+ this.containment = [
+ co.left + (parseInt($(ce).css("borderLeftWidth"), 10) || 0) +
+ (parseInt($(ce).css("paddingLeft"), 10) || 0) - this.margins.left,
+ co.top + (parseInt($(ce).css("borderTopWidth"), 10) || 0) +
+ (parseInt($(ce).css("paddingTop"), 10) || 0) - this.margins.top,
+ co.left + (over ? Math.max(ce.scrollWidth, ce.offsetWidth) : ce.offsetWidth) -
+ (parseInt($(ce).css("borderLeftWidth"), 10) || 0) -
+ (parseInt($(ce).css("paddingRight"), 10) || 0) -
+ this.helperProportions.width - this.margins.left,
+ co.top + (over ? Math.max(ce.scrollHeight, ce.offsetHeight) : ce.offsetHeight) -
+ (parseInt($(ce).css("borderTopWidth"), 10) || 0) -
+ (parseInt($(ce).css("paddingBottom"), 10) || 0) -
+ this.helperProportions.height - this.margins.top
+ ];
+ }
+
+ },
+
+ _convertPositionTo: function (d, pos) {
+
+ if (!pos) {
+ pos = this.position;
+ }
+ var mod = d === "absolute" ? 1 : -1,
+ scroll = this.cssPosition === "absolute" &&
+ !(this.scrollParent[0] !== this.document[0] &&
+ $.contains(this.scrollParent[0], this.offsetParent[0])) ?
+ this.offsetParent :
+ this.scrollParent,
+ scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
+
+ return {
+ top: (
+
+ // The absolute mouse position
+ pos.top +
+
+ // Only for relative positioned nodes: Relative offset from element to offset parent
+ this.offset.relative.top * mod +
+
+ // The offsetParent's offset without borders (offset + border)
+ this.offset.parent.top * mod -
+ ((this.cssPosition === "fixed" ?
+ -this.scrollParent.scrollTop() :
+ (scrollIsRootNode ? 0 : scroll.scrollTop())) * mod)
+ ),
+ left: (
+
+ // The absolute mouse position
+ pos.left +
+
+ // Only for relative positioned nodes: Relative offset from element to offset parent
+ this.offset.relative.left * mod +
+
+ // The offsetParent's offset without borders (offset + border)
+ this.offset.parent.left * mod -
+ ((this.cssPosition === "fixed" ?
+ -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 :
+ scroll.scrollLeft()) * mod)
+ )
+ };
+
+ },
+
+ _generatePosition: function (event) {
+
+ var top, left,
+ o = this.options,
+ pageX = event.pageX,
+ pageY = event.pageY,
+ scroll = this.cssPosition === "absolute" &&
+ !(this.scrollParent[0] !== this.document[0] &&
+ $.contains(this.scrollParent[0], this.offsetParent[0])) ?
+ this.offsetParent :
+ this.scrollParent,
+ scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
+
+ // This is another very weird special case that only happens for relative elements:
+ // 1. If the css position is relative
+ // 2. and the scroll parent is the document or similar to the offset parent
+ // we have to refresh the relative offset during the scroll so there are no jumps
+ if (this.cssPosition === "relative" && !(this.scrollParent[0] !== this.document[0] &&
+ this.scrollParent[0] !== this.offsetParent[0])) {
+ this.offset.relative = this._getRelativeOffset();
+ }
+
+ /*
+ * - Position constraining -
+ * Constrain the position to a mix of grid, containment.
+ */
+
+ if (this.originalPosition) { //If we are not dragging yet, we won't check for options
+
+ if (this.containment) {
+ if (event.pageX - this.offset.click.left < this.containment[0]) {
+ pageX = this.containment[0] + this.offset.click.left;
+ }
+ if (event.pageY - this.offset.click.top < this.containment[1]) {
+ pageY = this.containment[1] + this.offset.click.top;
+ }
+ if (event.pageX - this.offset.click.left > this.containment[2]) {
+ pageX = this.containment[2] + this.offset.click.left;
+ }
+ if (event.pageY - this.offset.click.top > this.containment[3]) {
+ pageY = this.containment[3] + this.offset.click.top;
+ }
+ }
+
+ if (o.grid) {
+ top = this.originalPageY + Math.round((pageY - this.originalPageY) /
+ o.grid[1]) * o.grid[1];
+ pageY = this.containment ?
+ ((top - this.offset.click.top >= this.containment[1] &&
+ top - this.offset.click.top <= this.containment[3]) ?
+ top :
+ ((top - this.offset.click.top >= this.containment[1]) ?
+ top - o.grid[1] : top + o.grid[1])) :
+ top;
+
+ left = this.originalPageX + Math.round((pageX - this.originalPageX) /
+ o.grid[0]) * o.grid[0];
+ pageX = this.containment ?
+ ((left - this.offset.click.left >= this.containment[0] &&
+ left - this.offset.click.left <= this.containment[2]) ?
+ left :
+ ((left - this.offset.click.left >= this.containment[0]) ?
+ left - o.grid[0] : left + o.grid[0])) :
+ left;
+ }
+
+ }
+
+ return {
+ top: (
+
+ // The absolute mouse position
+ pageY -
+
+ // Click offset (relative to the element)
+ this.offset.click.top -
+
+ // Only for relative positioned nodes: Relative offset from element to offset parent
+ this.offset.relative.top -
+
+ // The offsetParent's offset without borders (offset + border)
+ this.offset.parent.top +
+ ((this.cssPosition === "fixed" ?
+ -this.scrollParent.scrollTop() :
+ (scrollIsRootNode ? 0 : scroll.scrollTop())))
+ ),
+ left: (
+
+ // The absolute mouse position
+ pageX -
+
+ // Click offset (relative to the element)
+ this.offset.click.left -
+
+ // Only for relative positioned nodes: Relative offset from element to offset parent
+ this.offset.relative.left -
+
+ // The offsetParent's offset without borders (offset + border)
+ this.offset.parent.left +
+ ((this.cssPosition === "fixed" ?
+ -this.scrollParent.scrollLeft() :
+ scrollIsRootNode ? 0 : scroll.scrollLeft()))
+ )
+ };
+
+ },
+
+ _rearrange: function (event, i, a, hardRefresh) {
+
+ a ? a[0].appendChild(this.placeholder[0]) :
+ i.item[0].parentNode.insertBefore(this.placeholder[0],
+ (this.direction === "down" ? i.item[0] : i.item[0].nextSibling));
+
+ //Various things done here to improve the performance:
+ // 1. we create a setTimeout, that calls refreshPositions
+ // 2. on the instance, we have a counter variable, that get's higher after every append
+ // 3. on the local scope, we copy the counter variable, and check in the timeout,
+ // if it's still the same
+ // 4. this lets only the last addition to the timeout stack through
+ this.counter = this.counter ? ++this.counter : 1;
+ var counter = this.counter;
+
+ this._delay(function () {
+ if (counter === this.counter) {
+
+ //Precompute after each DOM insertion, NOT on mousemove
+ this.refreshPositions(!hardRefresh);
+ }
+ });
+
+ },
+
+ _clear: function (event, noPropagation) {
+
+ this.reverting = false;
+
+ // We delay all events that have to be triggered to after the point where the placeholder
+ // has been removed and everything else normalized again
+ var i,
+ delayedTriggers = [];
+
+ // We first have to update the dom position of the actual currentItem
+ // Note: don't do it if the current item is already removed (by a user), or it gets
+ // reappended (see #4088)
+ if (!this._noFinalSort && this.currentItem.parent().length) {
+ this.placeholder.before(this.currentItem);
+ }
+ this._noFinalSort = null;
+
+ if (this.helper[0] === this.currentItem[0]) {
+ for (i in this._storedCSS) {
+ if (this._storedCSS[i] === "auto" || this._storedCSS[i] === "static") {
+ this._storedCSS[i] = "";
+ }
+ }
+ this.currentItem.css(this._storedCSS);
+ this._removeClass(this.currentItem, "ui-sortable-helper");
+ } else {
+ this.currentItem.show();
+ }
+
+ if (this.fromOutside && !noPropagation) {
+ delayedTriggers.push(function (event) {
+ this._trigger("receive", event, this._uiHash(this.fromOutside));
+ });
+ }
+ if ((this.fromOutside ||
+ this.domPosition.prev !==
+ this.currentItem.prev().not(".ui-sortable-helper")[0] ||
+ this.domPosition.parent !== this.currentItem.parent()[0]) && !noPropagation) {
+
+ // Trigger update callback if the DOM position has changed
+ delayedTriggers.push(function (event) {
+ this._trigger("update", event, this._uiHash());
+ });
+ }
+
+ // Check if the items Container has Changed and trigger appropriate
+ // events.
+ if (this !== this.currentContainer) {
+ if (!noPropagation) {
+ delayedTriggers.push(function (event) {
+ this._trigger("remove", event, this._uiHash());
+ });
+ delayedTriggers.push((function (c) {
+ return function (event) {
+ c._trigger("receive", event, this._uiHash(this));
+ };
+ }).call(this, this.currentContainer));
+ delayedTriggers.push((function (c) {
+ return function (event) {
+ c._trigger("update", event, this._uiHash(this));
+ };
+ }).call(this, this.currentContainer));
+ }
+ }
+
+ //Post events to containers
+ function delayEvent(type, instance, container) {
+ return function (event) {
+ container._trigger(type, event, instance._uiHash(instance));
+ };
+ }
+ for (i = this.containers.length - 1; i >= 0; i--) {
+ if (!noPropagation) {
+ delayedTriggers.push(delayEvent("deactivate", this, this.containers[i]));
+ }
+ if (this.containers[i].containerCache.over) {
+ delayedTriggers.push(delayEvent("out", this, this.containers[i]));
+ this.containers[i].containerCache.over = 0;
+ }
+ }
+
+ //Do what was originally in plugins
+ if (this.storedCursor) {
+ this.document.find("body").css("cursor", this.storedCursor);
+ this.storedStylesheet.remove();
+ }
+ if (this._storedOpacity) {
+ this.helper.css("opacity", this._storedOpacity);
+ }
+ if (this._storedZIndex) {
+ this.helper.css("zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex);
+ }
+
+ this.dragging = false;
+
+ if (!noPropagation) {
+ this._trigger("beforeStop", event, this._uiHash());
+ }
+
+ //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately,
+ // it unbinds ALL events from the original node!
+ this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
+
+ if (!this.cancelHelperRemoval) {
+ if (this.helper[0] !== this.currentItem[0]) {
+ this.helper.remove();
+ }
+ this.helper = null;
+ }
+
+ if (!noPropagation) {
+ for (i = 0; i < delayedTriggers.length; i++) {
+
+ // Trigger all delayed events
+ delayedTriggers[i].call(this, event);
+ }
+ this._trigger("stop", event, this._uiHash());
+ }
+
+ this.fromOutside = false;
+ return !this.cancelHelperRemoval;
+
+ },
+
+ _trigger: function () {
+ if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
+ this.cancel();
+ }
+ },
+
+ _uiHash: function (_inst) {
+ var inst = _inst || this;
+ return {
+ helper: inst.helper,
+ placeholder: inst.placeholder || $([]),
+ position: inst.position,
+ originalPosition: inst.originalPosition,
+ offset: inst.positionAbs,
+ item: inst.currentItem,
+ sender: _inst ? _inst.element : null
+ };
+ }
+
+ });
+
+
+ /*!
+ * jQuery UI Spinner 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Spinner
+ //>>group: Widgets
+ //>>description: Displays buttons to easily input numbers via the keyboard or mouse.
+ //>>docs: http://api.jqueryui.com/spinner/
+ //>>demos: http://jqueryui.com/spinner/
+ //>>css.structure: ../../themes/base/core.css
+ //>>css.structure: ../../themes/base/spinner.css
+ //>>css.theme: ../../themes/base/theme.css
+
+
+
+ function spinnerModifer(fn) {
+ return function () {
+ var previous = this.element.val();
+ fn.apply(this, arguments);
+ this._refresh();
+ if (previous !== this.element.val()) {
+ this._trigger("change");
+ }
+ };
+ }
+
+ $.widget("ui.spinner", {
+ version: "1.12.1",
+ defaultElement: "<input>",
+ widgetEventPrefix: "spin",
+ options: {
+ classes: {
+ "ui-spinner": "ui-corner-all",
+ "ui-spinner-down": "ui-corner-br",
+ "ui-spinner-up": "ui-corner-tr"
+ },
+ culture: null,
+ icons: {
+ down: "ui-icon-triangle-1-s",
+ up: "ui-icon-triangle-1-n"
+ },
+ incremental: true,
+ max: null,
+ min: null,
+ numberFormat: null,
+ page: 10,
+ step: 1,
+
+ change: null,
+ spin: null,
+ start: null,
+ stop: null
+ },
+
+ _create: function () {
+
+ // handle string values that need to be parsed
+ this._setOption("max", this.options.max);
+ this._setOption("min", this.options.min);
+ this._setOption("step", this.options.step);
+
+ // Only format if there is a value, prevents the field from being marked
+ // as invalid in Firefox, see #9573.
+ if (this.value() !== "") {
+
+ // Format the value, but don't constrain.
+ this._value(this.element.val(), true);
+ }
+
+ this._draw();
+ this._on(this._events);
+ this._refresh();
+
+ // Turning off autocomplete prevents the browser from remembering the
+ // value when navigating through history, so we re-enable autocomplete
+ // if the page is unloaded before the widget is destroyed. #7790
+ this._on(this.window, {
+ beforeunload: function () {
+ this.element.removeAttr("autocomplete");
+ }
+ });
+ },
+
+ _getCreateOptions: function () {
+ var options = this._super();
+ var element = this.element;
+
+ $.each(["min", "max", "step"], function (i, option) {
+ var value = element.attr(option);
+ if (value != null && value.length) {
+ options[option] = value;
+ }
+ });
+
+ return options;
+ },
+
+ _events: {
+ keydown: function (event) {
+ if (this._start(event) && this._keydown(event)) {
+ event.preventDefault();
+ }
+ },
+ keyup: "_stop",
+ focus: function () {
+ this.previous = this.element.val();
+ },
+ blur: function (event) {
+ if (this.cancelBlur) {
+ delete this.cancelBlur;
+ return;
+ }
+
+ this._stop();
+ this._refresh();
+ if (this.previous !== this.element.val()) {
+ this._trigger("change", event);
+ }
+ },
+ mousewheel: function (event, delta) {
+ if (!delta) {
+ return;
+ }
+ if (!this.spinning && !this._start(event)) {
+ return false;
+ }
+
+ this._spin((delta > 0 ? 1 : -1) * this.options.step, event);
+ clearTimeout(this.mousewheelTimer);
+ this.mousewheelTimer = this._delay(function () {
+ if (this.spinning) {
+ this._stop(event);
+ }
+ }, 100);
+ event.preventDefault();
+ },
+ "mousedown .ui-spinner-button": function (event) {
+ var previous;
+
+ // We never want the buttons to have focus; whenever the user is
+ // interacting with the spinner, the focus should be on the input.
+ // If the input is focused then this.previous is properly set from
+ // when the input first received focus. If the input is not focused
+ // then we need to set this.previous based on the value before spinning.
+ previous = this.element[0] === $.ui.safeActiveElement(this.document[0]) ?
+ this.previous : this.element.val();
+ function checkFocus() {
+ var isActive = this.element[0] === $.ui.safeActiveElement(this.document[0]);
+ if (!isActive) {
+ this.element.trigger("focus");
+ this.previous = previous;
+
+ // support: IE
+ // IE sets focus asynchronously, so we need to check if focus
+ // moved off of the input because the user clicked on the button.
+ this._delay(function () {
+ this.previous = previous;
+ });
+ }
+ }
+
+ // Ensure focus is on (or stays on) the text field
+ event.preventDefault();
+ checkFocus.call(this);
+
+ // Support: IE
+ // IE doesn't prevent moving focus even with event.preventDefault()
+ // so we set a flag to know when we should ignore the blur event
+ // and check (again) if focus moved off of the input.
+ this.cancelBlur = true;
+ this._delay(function () {
+ delete this.cancelBlur;
+ checkFocus.call(this);
+ });
+
+ if (this._start(event) === false) {
+ return;
+ }
+
+ this._repeat(null, $(event.currentTarget)
+ .hasClass("ui-spinner-up") ? 1 : -1, event);
+ },
+ "mouseup .ui-spinner-button": "_stop",
+ "mouseenter .ui-spinner-button": function (event) {
+
+ // button will add ui-state-active if mouse was down while mouseleave and kept down
+ if (!$(event.currentTarget).hasClass("ui-state-active")) {
+ return;
+ }
+
+ if (this._start(event) === false) {
+ return false;
+ }
+ this._repeat(null, $(event.currentTarget)
+ .hasClass("ui-spinner-up") ? 1 : -1, event);
+ },
+
+ // TODO: do we really want to consider this a stop?
+ // shouldn't we just stop the repeater and wait until mouseup before
+ // we trigger the stop event?
+ "mouseleave .ui-spinner-button": "_stop"
+ },
+
+ // Support mobile enhanced option and make backcompat more sane
+ _enhance: function () {
+ this.uiSpinner = this.element
+ .attr("autocomplete", "off")
+ .wrap("<span>")
+ .parent()
+
+ // Add buttons
+ .append(
+ "<a></a><a></a>"
+ );
+ },
+
+ _draw: function () {
+ this._enhance();
+
+ this._addClass(this.uiSpinner, "ui-spinner", "ui-widget ui-widget-content");
+ this._addClass("ui-spinner-input");
+
+ this.element.attr("role", "spinbutton");
+
+ // Button bindings
+ this.buttons = this.uiSpinner.children("a")
+ .attr("tabIndex", -1)
+ .attr("aria-hidden", true)
+ .button({
+ classes: {
+ "ui-button": ""
+ }
+ });
+
+ // TODO: Right now button does not support classes this is already updated in button PR
+ this._removeClass(this.buttons, "ui-corner-all");
+
+ this._addClass(this.buttons.first(), "ui-spinner-button ui-spinner-up");
+ this._addClass(this.buttons.last(), "ui-spinner-button ui-spinner-down");
+ this.buttons.first().button({
+ "icon": this.options.icons.up,
+ "showLabel": false
+ });
+ this.buttons.last().button({
+ "icon": this.options.icons.down,
+ "showLabel": false
+ });
+
+ // IE 6 doesn't understand height: 50% for the buttons
+ // unless the wrapper has an explicit height
+ if (this.buttons.height() > Math.ceil(this.uiSpinner.height() * 0.5) &&
+ this.uiSpinner.height() > 0) {
+ this.uiSpinner.height(this.uiSpinner.height());
+ }
+ },
+
+ _keydown: function (event) {
+ var options = this.options,
+ keyCode = $.ui.keyCode;
+
+ switch (event.keyCode) {
+ case keyCode.UP:
+ this._repeat(null, 1, event);
+ return true;
+ case keyCode.DOWN:
+ this._repeat(null, -1, event);
+ return true;
+ case keyCode.PAGE_UP:
+ this._repeat(null, options.page, event);
+ return true;
+ case keyCode.PAGE_DOWN:
+ this._repeat(null, -options.page, event);
+ return true;
+ }
+
+ return false;
+ },
+
+ _start: function (event) {
+ if (!this.spinning && this._trigger("start", event) === false) {
+ return false;
+ }
+
+ if (!this.counter) {
+ this.counter = 1;
+ }
+ this.spinning = true;
+ return true;
+ },
+
+ _repeat: function (i, steps, event) {
+ i = i || 500;
+
+ clearTimeout(this.timer);
+ this.timer = this._delay(function () {
+ this._repeat(40, steps, event);
+ }, i);
+
+ this._spin(steps * this.options.step, event);
+ },
+
+ _spin: function (step, event) {
+ var value = this.value() || 0;
+
+ if (!this.counter) {
+ this.counter = 1;
+ }
+
+ value = this._adjustValue(value + step * this._increment(this.counter));
+
+ if (!this.spinning || this._trigger("spin", event, { value: value }) !== false) {
+ this._value(value);
+ this.counter++;
+ }
+ },
+
+ _increment: function (i) {
+ var incremental = this.options.incremental;
+
+ if (incremental) {
+ return $.isFunction(incremental) ?
+ incremental(i) :
+ Math.floor(i * i * i / 50000 - i * i / 500 + 17 * i / 200 + 1);
+ }
+
+ return 1;
+ },
+
+ _precision: function () {
+ var precision = this._precisionOf(this.options.step);
+ if (this.options.min !== null) {
+ precision = Math.max(precision, this._precisionOf(this.options.min));
+ }
+ return precision;
+ },
+
+ _precisionOf: function (num) {
+ var str = num.toString(),
+ decimal = str.indexOf(".");
+ return decimal === -1 ? 0 : str.length - decimal - 1;
+ },
+
+ _adjustValue: function (value) {
+ var base, aboveMin,
+ options = this.options;
+
+ // Make sure we're at a valid step
+ // - find out where we are relative to the base (min or 0)
+ base = options.min !== null ? options.min : 0;
+ aboveMin = value - base;
+
+ // - round to the nearest step
+ aboveMin = Math.round(aboveMin / options.step) * options.step;
+
+ // - rounding is based on 0, so adjust back to our base
+ value = base + aboveMin;
+
+ // Fix precision from bad JS floating point math
+ value = parseFloat(value.toFixed(this._precision()));
+
+ // Clamp the value
+ if (options.max !== null && value > options.max) {
+ return options.max;
+ }
+ if (options.min !== null && value < options.min) {
+ return options.min;
+ }
+
+ return value;
+ },
+
+ _stop: function (event) {
+ if (!this.spinning) {
+ return;
+ }
+
+ clearTimeout(this.timer);
+ clearTimeout(this.mousewheelTimer);
+ this.counter = 0;
+ this.spinning = false;
+ this._trigger("stop", event);
+ },
+
+ _setOption: function (key, value) {
+ var prevValue, first, last;
+
+ if (key === "culture" || key === "numberFormat") {
+ prevValue = this._parse(this.element.val());
+ this.options[key] = value;
+ this.element.val(this._format(prevValue));
+ return;
+ }
+
+ if (key === "max" || key === "min" || key === "step") {
+ if (typeof value === "string") {
+ value = this._parse(value);
+ }
+ }
+ if (key === "icons") {
+ first = this.buttons.first().find(".ui-icon");
+ this._removeClass(first, null, this.options.icons.up);
+ this._addClass(first, null, value.up);
+ last = this.buttons.last().find(".ui-icon");
+ this._removeClass(last, null, this.options.icons.down);
+ this._addClass(last, null, value.down);
+ }
+
+ this._super(key, value);
+ },
+
+ _setOptionDisabled: function (value) {
+ this._super(value);
+
+ this._toggleClass(this.uiSpinner, null, "ui-state-disabled", !!value);
+ this.element.prop("disabled", !!value);
+ this.buttons.button(value ? "disable" : "enable");
+ },
+
+ _setOptions: spinnerModifer(function (options) {
+ this._super(options);
+ }),
+
+ _parse: function (val) {
+ if (typeof val === "string" && val !== "") {
+ val = window.Globalize && this.options.numberFormat ?
+ Globalize.parseFloat(val, 10, this.options.culture) : +val;
+ }
+ return val === "" || isNaN(val) ? null : val;
+ },
+
+ _format: function (value) {
+ if (value === "") {
+ return "";
+ }
+ return window.Globalize && this.options.numberFormat ?
+ Globalize.format(value, this.options.numberFormat, this.options.culture) :
+ value;
+ },
+
+ _refresh: function () {
+ this.element.attr({
+ "aria-valuemin": this.options.min,
+ "aria-valuemax": this.options.max,
+
+ // TODO: what should we do with values that can't be parsed?
+ "aria-valuenow": this._parse(this.element.val())
+ });
+ },
+
+ isValid: function () {
+ var value = this.value();
+
+ // Null is invalid
+ if (value === null) {
+ return false;
+ }
+
+ // If value gets adjusted, it's invalid
+ return value === this._adjustValue(value);
+ },
+
+ // Update the value without triggering change
+ _value: function (value, allowAny) {
+ var parsed;
+ if (value !== "") {
+ parsed = this._parse(value);
+ if (parsed !== null) {
+ if (!allowAny) {
+ parsed = this._adjustValue(parsed);
+ }
+ value = this._format(parsed);
+ }
+ }
+ this.element.val(value);
+ this._refresh();
+ },
+
+ _destroy: function () {
+ this.element
+ .prop("disabled", false)
+ .removeAttr("autocomplete role aria-valuemin aria-valuemax aria-valuenow");
+
+ this.uiSpinner.replaceWith(this.element);
+ },
+
+ stepUp: spinnerModifer(function (steps) {
+ this._stepUp(steps);
+ }),
+ _stepUp: function (steps) {
+ if (this._start()) {
+ this._spin((steps || 1) * this.options.step);
+ this._stop();
+ }
+ },
+
+ stepDown: spinnerModifer(function (steps) {
+ this._stepDown(steps);
+ }),
+ _stepDown: function (steps) {
+ if (this._start()) {
+ this._spin((steps || 1) * -this.options.step);
+ this._stop();
+ }
+ },
+
+ pageUp: spinnerModifer(function (pages) {
+ this._stepUp((pages || 1) * this.options.page);
+ }),
+
+ pageDown: spinnerModifer(function (pages) {
+ this._stepDown((pages || 1) * this.options.page);
+ }),
+
+ value: function (newVal) {
+ if (!arguments.length) {
+ return this._parse(this.element.val());
+ }
+ spinnerModifer(this._value).call(this, newVal);
+ },
+
+ widget: function () {
+ return this.uiSpinner;
+ }
+ });
+
+ // DEPRECATED
+ // TODO: switch return back to widget declaration at top of file when this is removed
+ if ($.uiBackCompat !== false) {
+
+ // Backcompat for spinner html extension points
+ $.widget("ui.spinner", $.ui.spinner, {
+ _enhance: function () {
+ this.uiSpinner = this.element
+ .attr("autocomplete", "off")
+ .wrap(this._uiSpinnerHtml())
+ .parent()
+
+ // Add buttons
+ .append(this._buttonHtml());
+ },
+ _uiSpinnerHtml: function () {
+ return "<span>";
+ },
+
+ _buttonHtml: function () {
+ return "<a></a><a></a>";
+ }
+ });
+ }
+
+ var widgetsSpinner = $.ui.spinner;
+
+
+ /*!
+ * jQuery UI Tabs 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Tabs
+ //>>group: Widgets
+ //>>description: Transforms a set of container elements into a tab structure.
+ //>>docs: http://api.jqueryui.com/tabs/
+ //>>demos: http://jqueryui.com/tabs/
+ //>>css.structure: ../../themes/base/core.css
+ //>>css.structure: ../../themes/base/tabs.css
+ //>>css.theme: ../../themes/base/theme.css
+
+
+
+ $.widget("ui.tabs", {
+ version: "1.12.1",
+ delay: 300,
+ options: {
+ active: null,
+ classes: {
+ "ui-tabs": "ui-corner-all",
+ "ui-tabs-nav": "ui-corner-all",
+ "ui-tabs-panel": "ui-corner-bottom",
+ "ui-tabs-tab": "ui-corner-top"
+ },
+ collapsible: false,
+ event: "click",
+ heightStyle: "content",
+ hide: null,
+ show: null,
+
+ // Callbacks
+ activate: null,
+ beforeActivate: null,
+ beforeLoad: null,
+ load: null
+ },
+
+ _isLocal: (function () {
+ var rhash = /#.*$/;
+
+ return function (anchor) {
+ var anchorUrl, locationUrl;
+
+ anchorUrl = anchor.href.replace(rhash, "");
+ locationUrl = location.href.replace(rhash, "");
+
+ // Decoding may throw an error if the URL isn't UTF-8 (#9518)
+ try {
+ anchorUrl = decodeURIComponent(anchorUrl);
+ } catch (error) { }
+ try {
+ locationUrl = decodeURIComponent(locationUrl);
+ } catch (error) { }
+
+ return anchor.hash.length > 1 && anchorUrl === locationUrl;
+ };
+ })(),
+
+ _create: function () {
+ var that = this,
+ options = this.options;
+
+ this.running = false;
+
+ this._addClass("ui-tabs", "ui-widget ui-widget-content");
+ this._toggleClass("ui-tabs-collapsible", null, options.collapsible);
+
+ this._processTabs();
+ options.active = this._initialActive();
+
+ // Take disabling tabs via class attribute from HTML
+ // into account and update option properly.
+ if ($.isArray(options.disabled)) {
+ options.disabled = $.unique(options.disabled.concat(
+ $.map(this.tabs.filter(".ui-state-disabled"), function (li) {
+ return that.tabs.index(li);
+ })
+ )).sort();
+ }
+
+ // Check for length avoids error when initializing empty list
+ if (this.options.active !== false && this.anchors.length) {
+ this.active = this._findActive(options.active);
+ } else {
+ this.active = $();
+ }
+
+ this._refresh();
+
+ if (this.active.length) {
+ this.load(options.active);
+ }
+ },
+
+ _initialActive: function () {
+ var active = this.options.active,
+ collapsible = this.options.collapsible,
+ locationHash = location.hash.substring(1);
+
+ if (active === null) {
+
+ // check the fragment identifier in the URL
+ if (locationHash) {
+ this.tabs.each(function (i, tab) {
+ if ($(tab).attr("aria-controls") === locationHash) {
+ active = i;
+ return false;
+ }
+ });
+ }
+
+ // Check for a tab marked active via a class
+ if (active === null) {
+ active = this.tabs.index(this.tabs.filter(".ui-tabs-active"));
+ }
+
+ // No active tab, set to false
+ if (active === null || active === -1) {
+ active = this.tabs.length ? 0 : false;
+ }
+ }
+
+ // Handle numbers: negative, out of range
+ if (active !== false) {
+ active = this.tabs.index(this.tabs.eq(active));
+ if (active === -1) {
+ active = collapsible ? false : 0;
+ }
+ }
+
+ // Don't allow collapsible: false and active: false
+ if (!collapsible && active === false && this.anchors.length) {
+ active = 0;
+ }
+
+ return active;
+ },
+
+ _getCreateEventData: function () {
+ return {
+ tab: this.active,
+ panel: !this.active.length ? $() : this._getPanelForTab(this.active)
+ };
+ },
+
+ _tabKeydown: function (event) {
+ var focusedTab = $($.ui.safeActiveElement(this.document[0])).closest("li"),
+ selectedIndex = this.tabs.index(focusedTab),
+ goingForward = true;
+
+ if (this._handlePageNav(event)) {
+ return;
+ }
+
+ switch (event.keyCode) {
+ case $.ui.keyCode.RIGHT:
+ case $.ui.keyCode.DOWN:
+ selectedIndex++;
+ break;
+ case $.ui.keyCode.UP:
+ case $.ui.keyCode.LEFT:
+ goingForward = false;
+ selectedIndex--;
+ break;
+ case $.ui.keyCode.END:
+ selectedIndex = this.anchors.length - 1;
+ break;
+ case $.ui.keyCode.HOME:
+ selectedIndex = 0;
+ break;
+ case $.ui.keyCode.SPACE:
+
+ // Activate only, no collapsing
+ event.preventDefault();
+ clearTimeout(this.activating);
+ this._activate(selectedIndex);
+ return;
+ case $.ui.keyCode.ENTER:
+
+ // Toggle (cancel delayed activation, allow collapsing)
+ event.preventDefault();
+ clearTimeout(this.activating);
+
+ // Determine if we should collapse or activate
+ this._activate(selectedIndex === this.options.active ? false : selectedIndex);
+ return;
+ default:
+ return;
+ }
+
+ // Focus the appropriate tab, based on which key was pressed
+ event.preventDefault();
+ clearTimeout(this.activating);
+ selectedIndex = this._focusNextTab(selectedIndex, goingForward);
+
+ // Navigating with control/command key will prevent automatic activation
+ if (!event.ctrlKey && !event.metaKey) {
+
+ // Update aria-selected immediately so that AT think the tab is already selected.
+ // Otherwise AT may confuse the user by stating that they need to activate the tab,
+ // but the tab will already be activated by the time the announcement finishes.
+ focusedTab.attr("aria-selected", "false");
+ this.tabs.eq(selectedIndex).attr("aria-selected", "true");
+
+ this.activating = this._delay(function () {
+ this.option("active", selectedIndex);
+ }, this.delay);
+ }
+ },
+
+ _panelKeydown: function (event) {
+ if (this._handlePageNav(event)) {
+ return;
+ }
+
+ // Ctrl+up moves focus to the current tab
+ if (event.ctrlKey && event.keyCode === $.ui.keyCode.UP) {
+ event.preventDefault();
+ this.active.trigger("focus");
+ }
+ },
+
+ // Alt+page up/down moves focus to the previous/next tab (and activates)
+ _handlePageNav: function (event) {
+ if (event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP) {
+ this._activate(this._focusNextTab(this.options.active - 1, false));
+ return true;
+ }
+ if (event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN) {
+ this._activate(this._focusNextTab(this.options.active + 1, true));
+ return true;
+ }
+ },
+
+ _findNextTab: function (index, goingForward) {
+ var lastTabIndex = this.tabs.length - 1;
+
+ function constrain() {
+ if (index > lastTabIndex) {
+ index = 0;
+ }
+ if (index < 0) {
+ index = lastTabIndex;
+ }
+ return index;
+ }
+
+ while ($.inArray(constrain(), this.options.disabled) !== -1) {
+ index = goingForward ? index + 1 : index - 1;
+ }
+
+ return index;
+ },
+
+ _focusNextTab: function (index, goingForward) {
+ index = this._findNextTab(index, goingForward);
+ this.tabs.eq(index).trigger("focus");
+ return index;
+ },
+
+ _setOption: function (key, value) {
+ if (key === "active") {
+
+ // _activate() will handle invalid values and update this.options
+ this._activate(value);
+ return;
+ }
+
+ this._super(key, value);
+
+ if (key === "collapsible") {
+ this._toggleClass("ui-tabs-collapsible", null, value);
+
+ // Setting collapsible: false while collapsed; open first panel
+ if (!value && this.options.active === false) {
+ this._activate(0);
+ }
+ }
+
+ if (key === "event") {
+ this._setupEvents(value);
+ }
+
+ if (key === "heightStyle") {
+ this._setupHeightStyle(value);
+ }
+ },
+
+ _sanitizeSelector: function (hash) {
+ return hash ? hash.replace(/[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&") : "";
+ },
+
+ refresh: function () {
+ var options = this.options,
+ lis = this.tablist.children(":has(a[href])");
+
+ // Get disabled tabs from class attribute from HTML
+ // this will get converted to a boolean if needed in _refresh()
+ options.disabled = $.map(lis.filter(".ui-state-disabled"), function (tab) {
+ return lis.index(tab);
+ });
+
+ this._processTabs();
+
+ // Was collapsed or no tabs
+ if (options.active === false || !this.anchors.length) {
+ options.active = false;
+ this.active = $();
+
+ // was active, but active tab is gone
+ } else if (this.active.length && !$.contains(this.tablist[0], this.active[0])) {
+
+ // all remaining tabs are disabled
+ if (this.tabs.length === options.disabled.length) {
+ options.active = false;
+ this.active = $();
+
+ // activate previous tab
+ } else {
+ this._activate(this._findNextTab(Math.max(0, options.active - 1), false));
+ }
+
+ // was active, active tab still exists
+ } else {
+
+ // make sure active index is correct
+ options.active = this.tabs.index(this.active);
+ }
+
+ this._refresh();
+ },
+
+ _refresh: function () {
+ this._setOptionDisabled(this.options.disabled);
+ this._setupEvents(this.options.event);
+ this._setupHeightStyle(this.options.heightStyle);
+
+ this.tabs.not(this.active).attr({
+ "aria-selected": "false",
+ "aria-expanded": "false",
+ tabIndex: -1
+ });
+ this.panels.not(this._getPanelForTab(this.active))
+ .hide()
+ .attr({
+ "aria-hidden": "true"
+ });
+
+ // Make sure one tab is in the tab order
+ if (!this.active.length) {
+ this.tabs.eq(0).attr("tabIndex", 0);
+ } else {
+ this.active
+ .attr({
+ "aria-selected": "true",
+ "aria-expanded": "true",
+ tabIndex: 0
+ });
+ this._addClass(this.active, "ui-tabs-active", "ui-state-active");
+ this._getPanelForTab(this.active)
+ .show()
+ .attr({
+ "aria-hidden": "false"
+ });
+ }
+ },
+
+ _processTabs: function () {
+ var that = this,
+ prevTabs = this.tabs,
+ prevAnchors = this.anchors,
+ prevPanels = this.panels;
+
+ this.tablist = this._getList().attr("role", "tablist");
+ this._addClass(this.tablist, "ui-tabs-nav",
+ "ui-helper-reset ui-helper-clearfix ui-widget-header");
+
+ // Prevent users from focusing disabled tabs via click
+ this.tablist
+ .on("mousedown" + this.eventNamespace, "> li", function (event) {
+ if ($(this).is(".ui-state-disabled")) {
+ event.preventDefault();
+ }
+ })
+
+ // Support: IE <9
+ // Preventing the default action in mousedown doesn't prevent IE
+ // from focusing the element, so if the anchor gets focused, blur.
+ // We don't have to worry about focusing the previously focused
+ // element since clicking on a non-focusable element should focus
+ // the body anyway.
+ .on("focus" + this.eventNamespace, ".ui-tabs-anchor", function () {
+ if ($(this).closest("li").is(".ui-state-disabled")) {
+ this.blur();
+ }
+ });
+
+ this.tabs = this.tablist.find("> li:has(a[href])")
+ .attr({
+ role: "tab",
+ tabIndex: -1
+ });
+ this._addClass(this.tabs, "ui-tabs-tab", "ui-state-default");
+
+ this.anchors = this.tabs.map(function () {
+ return $("a", this)[0];
+ })
+ .attr({
+ role: "presentation",
+ tabIndex: -1
+ });
+ this._addClass(this.anchors, "ui-tabs-anchor");
+
+ this.panels = $();
+
+ this.anchors.each(function (i, anchor) {
+ var selector, panel, panelId,
+ anchorId = $(anchor).uniqueId().attr("id"),
+ tab = $(anchor).closest("li"),
+ originalAriaControls = tab.attr("aria-controls");
+
+ // Inline tab
+ if (that._isLocal(anchor)) {
+ selector = anchor.hash;
+ panelId = selector.substring(1);
+ panel = that.element.find(that._sanitizeSelector(selector));
+
+ // remote tab
+ } else {
+
+ // If the tab doesn't already have aria-controls,
+ // generate an id by using a throw-away element
+ panelId = tab.attr("aria-controls") || $({}).uniqueId()[0].id;
+ selector = "#" + panelId;
+ panel = that.element.find(selector);
+ if (!panel.length) {
+ panel = that._createPanel(panelId);
+ panel.insertAfter(that.panels[i - 1] || that.tablist);
+ }
+ panel.attr("aria-live", "polite");
+ }
+
+ if (panel.length) {
+ that.panels = that.panels.add(panel);
+ }
+ if (originalAriaControls) {
+ tab.data("ui-tabs-aria-controls", originalAriaControls);
+ }
+ tab.attr({
+ "aria-controls": panelId,
+ "aria-labelledby": anchorId
+ });
+ panel.attr("aria-labelledby", anchorId);
+ });
+
+ this.panels.attr("role", "tabpanel");
+ this._addClass(this.panels, "ui-tabs-panel", "ui-widget-content");
+
+ // Avoid memory leaks (#10056)
+ if (prevTabs) {
+ this._off(prevTabs.not(this.tabs));
+ this._off(prevAnchors.not(this.anchors));
+ this._off(prevPanels.not(this.panels));
+ }
+ },
+
+ // Allow overriding how to find the list for rare usage scenarios (#7715)
+ _getList: function () {
+ return this.tablist || this.element.find("ol, ul").eq(0);
+ },
+
+ _createPanel: function (id) {
+ return $("<div>")
+ .attr("id", id)
+ .data("ui-tabs-destroy", true);
+ },
+
+ _setOptionDisabled: function (disabled) {
+ var currentItem, li, i;
+
+ if ($.isArray(disabled)) {
+ if (!disabled.length) {
+ disabled = false;
+ } else if (disabled.length === this.anchors.length) {
+ disabled = true;
+ }
+ }
+
+ // Disable tabs
+ for (i = 0; (li = this.tabs[i]); i++) {
+ currentItem = $(li);
+ if (disabled === true || $.inArray(i, disabled) !== -1) {
+ currentItem.attr("aria-disabled", "true");
+ this._addClass(currentItem, null, "ui-state-disabled");
+ } else {
+ currentItem.removeAttr("aria-disabled");
+ this._removeClass(currentItem, null, "ui-state-disabled");
+ }
+ }
+
+ this.options.disabled = disabled;
+
+ this._toggleClass(this.widget(), this.widgetFullName + "-disabled", null,
+ disabled === true);
+ },
+
+ _setupEvents: function (event) {
+ var events = {};
+ if (event) {
+ $.each(event.split(" "), function (index, eventName) {
+ events[eventName] = "_eventHandler";
+ });
+ }
+
+ this._off(this.anchors.add(this.tabs).add(this.panels));
+
+ // Always prevent the default action, even when disabled
+ this._on(true, this.anchors, {
+ click: function (event) {
+ event.preventDefault();
+ }
+ });
+ this._on(this.anchors, events);
+ this._on(this.tabs, { keydown: "_tabKeydown" });
+ this._on(this.panels, { keydown: "_panelKeydown" });
+
+ this._focusable(this.tabs);
+ this._hoverable(this.tabs);
+ },
+
+ _setupHeightStyle: function (heightStyle) {
+ var maxHeight,
+ parent = this.element.parent();
+
+ if (heightStyle === "fill") {
+ maxHeight = parent.height();
+ maxHeight -= this.element.outerHeight() - this.element.height();
+
+ this.element.siblings(":visible").each(function () {
+ var elem = $(this),
+ position = elem.css("position");
+
+ if (position === "absolute" || position === "fixed") {
+ return;
+ }
+ maxHeight -= elem.outerHeight(true);
+ });
+
+ this.element.children().not(this.panels).each(function () {
+ maxHeight -= $(this).outerHeight(true);
+ });
+
+ this.panels.each(function () {
+ $(this).height(Math.max(0, maxHeight -
+ $(this).innerHeight() + $(this).height()));
+ })
+ .css("overflow", "auto");
+ } else if (heightStyle === "auto") {
+ maxHeight = 0;
+ this.panels.each(function () {
+ maxHeight = Math.max(maxHeight, $(this).height("").height());
+ }).height(maxHeight);
+ }
+ },
+
+ _eventHandler: function (event) {
+ var options = this.options,
+ active = this.active,
+ anchor = $(event.currentTarget),
+ tab = anchor.closest("li"),
+ clickedIsActive = tab[0] === active[0],
+ collapsing = clickedIsActive && options.collapsible,
+ toShow = collapsing ? $() : this._getPanelForTab(tab),
+ toHide = !active.length ? $() : this._getPanelForTab(active),
+ eventData = {
+ oldTab: active,
+ oldPanel: toHide,
+ newTab: collapsing ? $() : tab,
+ newPanel: toShow
+ };
+
+ event.preventDefault();
+
+ if (tab.hasClass("ui-state-disabled") ||
+
+ // tab is already loading
+ tab.hasClass("ui-tabs-loading") ||
+
+ // can't switch durning an animation
+ this.running ||
+
+ // click on active header, but not collapsible
+ (clickedIsActive && !options.collapsible) ||
+
+ // allow canceling activation
+ (this._trigger("beforeActivate", event, eventData) === false)) {
+ return;
+ }
+
+ options.active = collapsing ? false : this.tabs.index(tab);
+
+ this.active = clickedIsActive ? $() : tab;
+ if (this.xhr) {
+ this.xhr.abort();
+ }
+
+ if (!toHide.length && !toShow.length) {
+ $.error("jQuery UI Tabs: Mismatching fragment identifier.");
+ }
+
+ if (toShow.length) {
+ this.load(this.tabs.index(tab), event);
+ }
+ this._toggle(event, eventData);
+ },
+
+ // Handles show/hide for selecting tabs
+ _toggle: function (event, eventData) {
+ var that = this,
+ toShow = eventData.newPanel,
+ toHide = eventData.oldPanel;
+
+ this.running = true;
+
+ function complete() {
+ that.running = false;
+ that._trigger("activate", event, eventData);
+ }
+
+ function show() {
+ that._addClass(eventData.newTab.closest("li"), "ui-tabs-active", "ui-state-active");
+
+ if (toShow.length && that.options.show) {
+ that._show(toShow, that.options.show, complete);
+ } else {
+ toShow.show();
+ complete();
+ }
+ }
+
+ // Start out by hiding, then showing, then completing
+ if (toHide.length && this.options.hide) {
+ this._hide(toHide, this.options.hide, function () {
+ that._removeClass(eventData.oldTab.closest("li"),
+ "ui-tabs-active", "ui-state-active");
+ show();
+ });
+ } else {
+ this._removeClass(eventData.oldTab.closest("li"),
+ "ui-tabs-active", "ui-state-active");
+ toHide.hide();
+ show();
+ }
+
+ toHide.attr("aria-hidden", "true");
+ eventData.oldTab.attr({
+ "aria-selected": "false",
+ "aria-expanded": "false"
+ });
+
+ // If we're switching tabs, remove the old tab from the tab order.
+ // If we're opening from collapsed state, remove the previous tab from the tab order.
+ // If we're collapsing, then keep the collapsing tab in the tab order.
+ if (toShow.length && toHide.length) {
+ eventData.oldTab.attr("tabIndex", -1);
+ } else if (toShow.length) {
+ this.tabs.filter(function () {
+ return $(this).attr("tabIndex") === 0;
+ })
+ .attr("tabIndex", -1);
+ }
+
+ toShow.attr("aria-hidden", "false");
+ eventData.newTab.attr({
+ "aria-selected": "true",
+ "aria-expanded": "true",
+ tabIndex: 0
+ });
+ },
+
+ _activate: function (index) {
+ var anchor,
+ active = this._findActive(index);
+
+ // Trying to activate the already active panel
+ if (active[0] === this.active[0]) {
+ return;
+ }
+
+ // Trying to collapse, simulate a click on the current active header
+ if (!active.length) {
+ active = this.active;
+ }
+
+ anchor = active.find(".ui-tabs-anchor")[0];
+ this._eventHandler({
+ target: anchor,
+ currentTarget: anchor,
+ preventDefault: $.noop
+ });
+ },
+
+ _findActive: function (index) {
+ return index === false ? $() : this.tabs.eq(index);
+ },
+
+ _getIndex: function (index) {
+
+ // meta-function to give users option to provide a href string instead of a numerical index.
+ if (typeof index === "string") {
+ index = this.anchors.index(this.anchors.filter("[href$='" +
+ $.ui.escapeSelector(index) + "']"));
+ }
+
+ return index;
+ },
+
+ _destroy: function () {
+ if (this.xhr) {
+ this.xhr.abort();
+ }
+
+ this.tablist
+ .removeAttr("role")
+ .off(this.eventNamespace);
+
+ this.anchors
+ .removeAttr("role tabIndex")
+ .removeUniqueId();
+
+ this.tabs.add(this.panels).each(function () {
+ if ($.data(this, "ui-tabs-destroy")) {
+ $(this).remove();
+ } else {
+ $(this).removeAttr("role tabIndex " +
+ "aria-live aria-busy aria-selected aria-labelledby aria-hidden aria-expanded");
+ }
+ });
+
+ this.tabs.each(function () {
+ var li = $(this),
+ prev = li.data("ui-tabs-aria-controls");
+ if (prev) {
+ li
+ .attr("aria-controls", prev)
+ .removeData("ui-tabs-aria-controls");
+ } else {
+ li.removeAttr("aria-controls");
+ }
+ });
+
+ this.panels.show();
+
+ if (this.options.heightStyle !== "content") {
+ this.panels.css("height", "");
+ }
+ },
+
+ enable: function (index) {
+ var disabled = this.options.disabled;
+ if (disabled === false) {
+ return;
+ }
+
+ if (index === undefined) {
+ disabled = false;
+ } else {
+ index = this._getIndex(index);
+ if ($.isArray(disabled)) {
+ disabled = $.map(disabled, function (num) {
+ return num !== index ? num : null;
+ });
+ } else {
+ disabled = $.map(this.tabs, function (li, num) {
+ return num !== index ? num : null;
+ });
+ }
+ }
+ this._setOptionDisabled(disabled);
+ },
+
+ disable: function (index) {
+ var disabled = this.options.disabled;
+ if (disabled === true) {
+ return;
+ }
+
+ if (index === undefined) {
+ disabled = true;
+ } else {
+ index = this._getIndex(index);
+ if ($.inArray(index, disabled) !== -1) {
+ return;
+ }
+ if ($.isArray(disabled)) {
+ disabled = $.merge([index], disabled).sort();
+ } else {
+ disabled = [index];
+ }
+ }
+ this._setOptionDisabled(disabled);
+ },
+
+ load: function (index, event) {
+ index = this._getIndex(index);
+ var that = this,
+ tab = this.tabs.eq(index),
+ anchor = tab.find(".ui-tabs-anchor"),
+ panel = this._getPanelForTab(tab),
+ eventData = {
+ tab: tab,
+ panel: panel
+ },
+ complete = function (jqXHR, status) {
+ if (status === "abort") {
+ that.panels.stop(false, true);
+ }
+
+ that._removeClass(tab, "ui-tabs-loading");
+ panel.removeAttr("aria-busy");
+
+ if (jqXHR === that.xhr) {
+ delete that.xhr;
+ }
+ };
+
+ // Not remote
+ if (this._isLocal(anchor[0])) {
+ return;
+ }
+
+ this.xhr = $.ajax(this._ajaxSettings(anchor, event, eventData));
+
+ // Support: jQuery <1.8
+ // jQuery <1.8 returns false if the request is canceled in beforeSend,
+ // but as of 1.8, $.ajax() always returns a jqXHR object.
+ if (this.xhr && this.xhr.statusText !== "canceled") {
+ this._addClass(tab, "ui-tabs-loading");
+ panel.attr("aria-busy", "true");
+
+ this.xhr
+ .done(function (response, status, jqXHR) {
+
+ // support: jQuery <1.8
+ // http://bugs.jquery.com/ticket/11778
+ setTimeout(function () {
+ panel.html(response);
+ that._trigger("load", event, eventData);
+
+ complete(jqXHR, status);
+ }, 1);
+ })
+ .fail(function (jqXHR, status) {
+
+ // support: jQuery <1.8
+ // http://bugs.jquery.com/ticket/11778
+ setTimeout(function () {
+ complete(jqXHR, status);
+ }, 1);
+ });
+ }
+ },
+
+ _ajaxSettings: function (anchor, event, eventData) {
+ var that = this;
+ return {
+
+ // Support: IE <11 only
+ // Strip any hash that exists to prevent errors with the Ajax request
+ url: anchor.attr("href").replace(/#.*$/, ""),
+ beforeSend: function (jqXHR, settings) {
+ return that._trigger("beforeLoad", event,
+ $.extend({ jqXHR: jqXHR, ajaxSettings: settings }, eventData));
+ }
+ };
+ },
+
+ _getPanelForTab: function (tab) {
+ var id = $(tab).attr("aria-controls");
+ return this.element.find(this._sanitizeSelector("#" + id));
+ }
+ });
+
+ // DEPRECATED
+ // TODO: Switch return back to widget declaration at top of file when this is removed
+ if ($.uiBackCompat !== false) {
+
+ // Backcompat for ui-tab class (now ui-tabs-tab)
+ $.widget("ui.tabs", $.ui.tabs, {
+ _processTabs: function () {
+ this._superApply(arguments);
+ this._addClass(this.tabs, "ui-tab");
+ }
+ });
+ }
+
+ var widgetsTabs = $.ui.tabs;
+
+
+ /*!
+ * jQuery UI Tooltip 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Tooltip
+ //>>group: Widgets
+ //>>description: Shows additional information for any element on hover or focus.
+ //>>docs: http://api.jqueryui.com/tooltip/
+ //>>demos: http://jqueryui.com/tooltip/
+ //>>css.structure: ../../themes/base/core.css
+ //>>css.structure: ../../themes/base/tooltip.css
+ //>>css.theme: ../../themes/base/theme.css
+
+
+
+ $.widget("ui.tooltip", {
+ version: "1.12.1",
+ options: {
+ classes: {
+ "ui-tooltip": "ui-corner-all ui-widget-shadow"
+ },
+ content: function () {
+
+ // support: IE<9, Opera in jQuery <1.7
+ // .text() can't accept undefined, so coerce to a string
+ var title = $(this).attr("title") || "";
+
+ // Escape title, since we're going from an attribute to raw HTML
+ return $("<a>").text(title).html();
+ },
+ hide: true,
+
+ // Disabled elements have inconsistent behavior across browsers (#8661)
+ items: "[title]:not([disabled])",
+ position: {
+ my: "left top+15",
+ at: "left bottom",
+ collision: "flipfit flip"
+ },
+ show: true,
+ track: false,
+
+ // Callbacks
+ close: null,
+ open: null
+ },
+
+ _addDescribedBy: function (elem, id) {
+ var describedby = (elem.attr("aria-describedby") || "").split(/\s+/);
+ describedby.push(id);
+ elem
+ .data("ui-tooltip-id", id)
+ .attr("aria-describedby", $.trim(describedby.join(" ")));
+ },
+
+ _removeDescribedBy: function (elem) {
+ var id = elem.data("ui-tooltip-id"),
+ describedby = (elem.attr("aria-describedby") || "").split(/\s+/),
+ index = $.inArray(id, describedby);
+
+ if (index !== -1) {
+ describedby.splice(index, 1);
+ }
+
+ elem.removeData("ui-tooltip-id");
+ describedby = $.trim(describedby.join(" "));
+ if (describedby) {
+ elem.attr("aria-describedby", describedby);
+ } else {
+ elem.removeAttr("aria-describedby");
+ }
+ },
+
+ _create: function () {
+ this._on({
+ mouseover: "open",
+ focusin: "open"
+ });
+
+ // IDs of generated tooltips, needed for destroy
+ this.tooltips = {};
+
+ // IDs of parent tooltips where we removed the title attribute
+ this.parents = {};
+
+ // Append the aria-live region so tooltips announce correctly
+ this.liveRegion = $("<div>")
+ .attr({
+ role: "log",
+ "aria-live": "assertive",
+ "aria-relevant": "additions"
+ })
+ .appendTo(this.document[0].body);
+ this._addClass(this.liveRegion, null, "ui-helper-hidden-accessible");
+
+ this.disabledTitles = $([]);
+ },
+
+ _setOption: function (key, value) {
+ var that = this;
+
+ this._super(key, value);
+
+ if (key === "content") {
+ $.each(this.tooltips, function (id, tooltipData) {
+ that._updateContent(tooltipData.element);
+ });
+ }
+ },
+
+ _setOptionDisabled: function (value) {
+ this[value ? "_disable" : "_enable"]();
+ },
+
+ _disable: function () {
+ var that = this;
+
+ // Close open tooltips
+ $.each(this.tooltips, function (id, tooltipData) {
+ var event = $.Event("blur");
+ event.target = event.currentTarget = tooltipData.element[0];
+ that.close(event, true);
+ });
+
+ // Remove title attributes to prevent native tooltips
+ this.disabledTitles = this.disabledTitles.add(
+ this.element.find(this.options.items).addBack()
+ .filter(function () {
+ var element = $(this);
+ if (element.is("[title]")) {
+ return element
+ .data("ui-tooltip-title", element.attr("title"))
+ .removeAttr("title");
+ }
+ })
+ );
+ },
+
+ _enable: function () {
+
+ // restore title attributes
+ this.disabledTitles.each(function () {
+ var element = $(this);
+ if (element.data("ui-tooltip-title")) {
+ element.attr("title", element.data("ui-tooltip-title"));
+ }
+ });
+ this.disabledTitles = $([]);
+ },
+
+ open: function (event) {
+ var that = this,
+ target = $(event ? event.target : this.element)
+
+ // we need closest here due to mouseover bubbling,
+ // but always pointing at the same event target
+ .closest(this.options.items);
+
+ // No element to show a tooltip for or the tooltip is already open
+ if (!target.length || target.data("ui-tooltip-id")) {
+ return;
+ }
+
+ if (target.attr("title")) {
+ target.data("ui-tooltip-title", target.attr("title"));
+ }
+
+ target.data("ui-tooltip-open", true);
+
+ // Kill parent tooltips, custom or native, for hover
+ if (event && event.type === "mouseover") {
+ target.parents().each(function () {
+ var parent = $(this),
+ blurEvent;
+ if (parent.data("ui-tooltip-open")) {
+ blurEvent = $.Event("blur");
+ blurEvent.target = blurEvent.currentTarget = this;
+ that.close(blurEvent, true);
+ }
+ if (parent.attr("title")) {
+ parent.uniqueId();
+ that.parents[this.id] = {
+ element: this,
+ title: parent.attr("title")
+ };
+ parent.attr("title", "");
+ }
+ });
+ }
+
+ this._registerCloseHandlers(event, target);
+ this._updateContent(target, event);
+ },
+
+ _updateContent: function (target, event) {
+ var content,
+ contentOption = this.options.content,
+ that = this,
+ eventType = event ? event.type : null;
+
+ if (typeof contentOption === "string" || contentOption.nodeType ||
+ contentOption.jquery) {
+ return this._open(event, target, contentOption);
+ }
+
+ content = contentOption.call(target[0], function (response) {
+
+ // IE may instantly serve a cached response for ajax requests
+ // delay this call to _open so the other call to _open runs first
+ that._delay(function () {
+
+ // Ignore async response if tooltip was closed already
+ if (!target.data("ui-tooltip-open")) {
+ return;
+ }
+
+ // JQuery creates a special event for focusin when it doesn't
+ // exist natively. To improve performance, the native event
+ // object is reused and the type is changed. Therefore, we can't
+ // rely on the type being correct after the event finished
+ // bubbling, so we set it back to the previous value. (#8740)
+ if (event) {
+ event.type = eventType;
+ }
+ this._open(event, target, response);
+ });
+ });
+ if (content) {
+ this._open(event, target, content);
+ }
+ },
+
+ _open: function (event, target, content) {
+ var tooltipData, tooltip, delayedShow, a11yContent,
+ positionOption = $.extend({}, this.options.position);
+
+ if (!content) {
+ return;
+ }
+
+ // Content can be updated multiple times. If the tooltip already
+ // exists, then just update the content and bail.
+ tooltipData = this._find(target);
+ if (tooltipData) {
+ tooltipData.tooltip.find(".ui-tooltip-content").html(content);
+ return;
+ }
+
+ // If we have a title, clear it to prevent the native tooltip
+ // we have to check first to avoid defining a title if none exists
+ // (we don't want to cause an element to start matching [title])
+ //
+ // We use removeAttr only for key events, to allow IE to export the correct
+ // accessible attributes. For mouse events, set to empty string to avoid
+ // native tooltip showing up (happens only when removing inside mouseover).
+ if (target.is("[title]")) {
+ if (event && event.type === "mouseover") {
+ target.attr("title", "");
+ } else {
+ target.removeAttr("title");
+ }
+ }
+
+ tooltipData = this._tooltip(target);
+ tooltip = tooltipData.tooltip;
+ this._addDescribedBy(target, tooltip.attr("id"));
+ tooltip.find(".ui-tooltip-content").html(content);
+
+ // Support: Voiceover on OS X, JAWS on IE <= 9
+ // JAWS announces deletions even when aria-relevant="additions"
+ // Voiceover will sometimes re-read the entire log region's contents from the beginning
+ this.liveRegion.children().hide();
+ a11yContent = $("<div>").html(tooltip.find(".ui-tooltip-content").html());
+ a11yContent.removeAttr("name").find("[name]").removeAttr("name");
+ a11yContent.removeAttr("id").find("[id]").removeAttr("id");
+ a11yContent.appendTo(this.liveRegion);
+
+ function position(event) {
+ positionOption.of = event;
+ if (tooltip.is(":hidden")) {
+ return;
+ }
+ tooltip.position(positionOption);
+ }
+ if (this.options.track && event && /^mouse/.test(event.type)) {
+ this._on(this.document, {
+ mousemove: position
+ });
+
+ // trigger once to override element-relative positioning
+ position(event);
+ } else {
+ tooltip.position($.extend({
+ of: target
+ }, this.options.position));
+ }
+
+ tooltip.hide();
+
+ this._show(tooltip, this.options.show);
+
+ // Handle tracking tooltips that are shown with a delay (#8644). As soon
+ // as the tooltip is visible, position the tooltip using the most recent
+ // event.
+ // Adds the check to add the timers only when both delay and track options are set (#14682)
+ if (this.options.track && this.options.show && this.options.show.delay) {
+ delayedShow = this.delayedShow = setInterval(function () {
+ if (tooltip.is(":visible")) {
+ position(positionOption.of);
+ clearInterval(delayedShow);
+ }
+ }, $.fx.interval);
+ }
+
+ this._trigger("open", event, { tooltip: tooltip });
+ },
+
+ _registerCloseHandlers: function (event, target) {
+ var events = {
+ keyup: function (event) {
+ if (event.keyCode === $.ui.keyCode.ESCAPE) {
+ var fakeEvent = $.Event(event);
+ fakeEvent.currentTarget = target[0];
+ this.close(fakeEvent, true);
+ }
+ }
+ };
+
+ // Only bind remove handler for delegated targets. Non-delegated
+ // tooltips will handle this in destroy.
+ if (target[0] !== this.element[0]) {
+ events.remove = function () {
+ this._removeTooltip(this._find(target).tooltip);
+ };
+ }
+
+ if (!event || event.type === "mouseover") {
+ events.mouseleave = "close";
+ }
+ if (!event || event.type === "focusin") {
+ events.focusout = "close";
+ }
+ this._on(true, target, events);
+ },
+
+ close: function (event) {
+ var tooltip,
+ that = this,
+ target = $(event ? event.currentTarget : this.element),
+ tooltipData = this._find(target);
+
+ // The tooltip may already be closed
+ if (!tooltipData) {
+
+ // We set ui-tooltip-open immediately upon open (in open()), but only set the
+ // additional data once there's actually content to show (in _open()). So even if the
+ // tooltip doesn't have full data, we always remove ui-tooltip-open in case we're in
+ // the period between open() and _open().
+ target.removeData("ui-tooltip-open");
+ return;
+ }
+
+ tooltip = tooltipData.tooltip;
+
+ // Disabling closes the tooltip, so we need to track when we're closing
+ // to avoid an infinite loop in case the tooltip becomes disabled on close
+ if (tooltipData.closing) {
+ return;
+ }
+
+ // Clear the interval for delayed tracking tooltips
+ clearInterval(this.delayedShow);
+
+ // Only set title if we had one before (see comment in _open())
+ // If the title attribute has changed since open(), don't restore
+ if (target.data("ui-tooltip-title") && !target.attr("title")) {
+ target.attr("title", target.data("ui-tooltip-title"));
+ }
+
+ this._removeDescribedBy(target);
+
+ tooltipData.hiding = true;
+ tooltip.stop(true);
+ this._hide(tooltip, this.options.hide, function () {
+ that._removeTooltip($(this));
+ });
+
+ target.removeData("ui-tooltip-open");
+ this._off(target, "mouseleave focusout keyup");
+
+ // Remove 'remove' binding only on delegated targets
+ if (target[0] !== this.element[0]) {
+ this._off(target, "remove");
+ }
+ this._off(this.document, "mousemove");
+
+ if (event && event.type === "mouseleave") {
+ $.each(this.parents, function (id, parent) {
+ $(parent.element).attr("title", parent.title);
+ delete that.parents[id];
+ });
+ }
+
+ tooltipData.closing = true;
+ this._trigger("close", event, { tooltip: tooltip });
+ if (!tooltipData.hiding) {
+ tooltipData.closing = false;
+ }
+ },
+
+ _tooltip: function (element) {
+ var tooltip = $("<div>").attr("role", "tooltip"),
+ content = $("<div>").appendTo(tooltip),
+ id = tooltip.uniqueId().attr("id");
+
+ this._addClass(content, "ui-tooltip-content");
+ this._addClass(tooltip, "ui-tooltip", "ui-widget ui-widget-content");
+
+ tooltip.appendTo(this._appendTo(element));
+
+ return this.tooltips[id] = {
+ element: element,
+ tooltip: tooltip
+ };
+ },
+
+ _find: function (target) {
+ var id = target.data("ui-tooltip-id");
+ return id ? this.tooltips[id] : null;
+ },
+
+ _removeTooltip: function (tooltip) {
+ tooltip.remove();
+ delete this.tooltips[tooltip.attr("id")];
+ },
+
+ _appendTo: function (target) {
+ var element = target.closest(".ui-front, dialog");
+
+ if (!element.length) {
+ element = this.document[0].body;
+ }
+
+ return element;
+ },
+
+ _destroy: function () {
+ var that = this;
+
+ // Close open tooltips
+ $.each(this.tooltips, function (id, tooltipData) {
+
+ // Delegate to close method to handle common cleanup
+ var event = $.Event("blur"),
+ element = tooltipData.element;
+ event.target = event.currentTarget = element[0];
+ that.close(event, true);
+
+ // Remove immediately; destroying an open tooltip doesn't use the
+ // hide animation
+ $("#" + id).remove();
+
+ // Restore the title
+ if (element.data("ui-tooltip-title")) {
+
+ // If the title attribute has changed since open(), don't restore
+ if (!element.attr("title")) {
+ element.attr("title", element.data("ui-tooltip-title"));
+ }
+ element.removeData("ui-tooltip-title");
+ }
+ });
+ this.liveRegion.remove();
+ }
+ });
+
+ // DEPRECATED
+ // TODO: Switch return back to widget declaration at top of file when this is removed
+ if ($.uiBackCompat !== false) {
+
+ // Backcompat for tooltipClass option
+ $.widget("ui.tooltip", $.ui.tooltip, {
+ options: {
+ tooltipClass: null
+ },
+ _tooltip: function () {
+ var tooltipData = this._superApply(arguments);
+ if (this.options.tooltipClass) {
+ tooltipData.tooltip.addClass(this.options.tooltipClass);
+ }
+ return tooltipData;
+ }
+ });
+ }
+
+ var widgetsTooltip = $.ui.tooltip;
+
+
+
+
+}));
+/*!
+ * jQuery.scrollTo
+ * Copyright (c) 2007-2015 Ariel Flesler - aflesler<a>gmail<d>com | http://flesler.blogspot.com
+ * Licensed under MIT
+ * http://flesler.blogspot.com/2007/10/jqueryscrollto.html
+ * @projectDescription Lightweight, cross-browser and highly customizable animated scrolling with jQuery
+ * @author Ariel Flesler
+ * @version 2.1.2
+ */
+; (function (factory) {
+ 'use strict';
+ if (typeof define === 'function' && define.amd) {
+ // AMD
+ define(['jquery'], factory);
+ } else if (typeof module !== 'undefined' && module.exports) {
+ // CommonJS
+ module.exports = factory(require('jquery'));
+ } else {
+ // Global
+ factory(jQuery);
+ }
+})(function ($) {
+ 'use strict';
+
+ var $scrollTo = $.scrollTo = function (target, duration, settings) {
+ return $(window).scrollTo(target, duration, settings);
+ };
+
+ $scrollTo.defaults = {
+ axis: 'xy',
+ duration: 0,
+ limit: true
+ };
+
+ function isWin(elem) {
+ return !elem.nodeName ||
+ $.inArray(elem.nodeName.toLowerCase(), ['iframe', '#document', 'html', 'body']) !== -1;
+ }
+
+ $.fn.scrollTo = function (target, duration, settings) {
+ if (typeof duration === 'object') {
+ settings = duration;
+ duration = 0;
+ }
+ if (typeof settings === 'function') {
+ settings = { onAfter: settings };
+ }
+ if (target === 'max') {
+ target = 9e9;
+ }
+
+ settings = $.extend({}, $scrollTo.defaults, settings);
+ // Speed is still recognized for backwards compatibility
+ duration = duration || settings.duration;
+ // Make sure the settings are given right
+ var queue = settings.queue && settings.axis.length > 1;
+ if (queue) {
+ // Let's keep the overall duration
+ duration /= 2;
+ }
+ settings.offset = both(settings.offset);
+ settings.over = both(settings.over);
+
+ return this.each(function() {
+ // Null target yields nothing, just like jQuery does
+ if (target === null) return;
+
+ var win = isWin(this),
+ elem = win ? this.contentWindow || window : this,
+ $elem = $(elem),
+ targ = target,
+ attr = {},
+ toff;
+
+ switch (typeof targ) {
+ // A number will pass the regex
+ case 'number':
+ case 'string':
+ if (/^([+-]=?)?\d+(\.\d+)?(px|%)?$/.test(targ)) {
+ targ = both(targ);
+ // We are done
+ break;
+ }
+ // Relative/Absolute selector
+ targ = win ? $(targ) : $(targ, elem);
+ /* falls through */
+ case 'object':
+ if (targ.length === 0) return;
+ // DOMElement / jQuery
+ if (targ.is || targ.style) {
+ // Get the real position of the target
+ toff = (targ = $(targ)).offset();
+ }
+ }
+
+ var offset = $.isFunction(settings.offset) && settings.offset(elem, targ) || settings.offset;
+
+ $.each(settings.axis.split(''), function (i, axis) {
+ var Pos = axis === 'x' ? 'Left' : 'Top',
+ pos = Pos.toLowerCase(),
+ key = 'scroll' + Pos,
+ prev = $elem[key](),
+ max = $scrollTo.max(elem, axis);
+
+ if (toff) {// jQuery / DOMElement
+ attr[key] = toff[pos] + (win ? 0 : prev - $elem.offset()[pos]);
+
+ // If it's a dom element, reduce the margin
+ if (settings.margin) {
+ attr[key] -= parseInt(targ.css('margin' + Pos), 10) || 0;
+ attr[key] -= parseInt(targ.css('border' + Pos + 'Width'), 10) || 0;
+ }
+
+ attr[key] += offset[pos] || 0;
+
+ if (settings.over[pos]) {
+ // Scroll to a fraction of its width/height
+ attr[key] += targ[axis === 'x' ? 'width' : 'height']() * settings.over[pos];
+ }
+ } else {
+ var val = targ[pos];
+ // Handle percentage values
+ attr[key] = val.slice && val.slice(-1) === '%' ?
+ parseFloat(val) / 100 * max
+ : val;
+ }
+
+ // Number or 'number'
+ if (settings.limit && /^\d+$/.test(attr[key])) {
+ // Check the limits
+ attr[key] = attr[key] <= 0 ? 0 : Math.min(attr[key], max);
+ }
+
+ // Don't waste time animating, if there's no need.
+ if (!i && settings.axis.length > 1) {
+ if (prev === attr[key]) {
+ // No animation needed
+ attr = {};
+ } else if (queue) {
+ // Intermediate animation
+ animate(settings.onAfterFirst);
+ // Don't animate this axis again in the next iteration.
+ attr = {};
+ }
+ }
+ });
+
+ animate(settings.onAfter);
+
+ function animate(callback) {
+ var opts = $.extend({}, settings, {
+ // The queue setting conflicts with animate()
+ // Force it to always be true
+ queue: true,
+ duration: duration,
+ complete: callback && function () {
+ callback.call(elem, targ, settings);
+ }
+ });
+ $elem.animate(attr, opts);
+ }
+ });
+ };
+
+ // Max scrolling position, works on quirks mode
+ // It only fails (not too badly) on IE, quirks mode.
+ $scrollTo.max = function (elem, axis) {
+ var Dim = axis === 'x' ? 'Width' : 'Height',
+ scroll = 'scroll' + Dim;
+
+ if (!isWin(elem))
+ return elem[scroll] - $(elem)[Dim.toLowerCase()]();
+
+ var size = 'client' + Dim,
+ doc = elem.ownerDocument || elem.document,
+ html = doc.documentElement,
+ body = doc.body;
+
+ return Math.max(html[scroll], body[scroll]) - Math.min(html[size], body[size]);
+ };
+
+ function both(val) {
+ return $.isFunction(val) || $.isPlainObject(val) ? val : { top: val, left: val };
+ }
+
+ // Add special hooks so that window scroll properties can be animated
+ $.Tween.propHooks.scrollLeft =
+ $.Tween.propHooks.scrollTop = {
+ get: function (t) {
+ return $(t.elem)[t.prop]();
+ },
+ set: function (t) {
+ var curr = this.get(t);
+ // If interrupt is true and user scrolled, stop animating
+ if (t.options.interrupt && t._last && t._last !== curr) {
+ return $(t.elem).stop();
+ }
+ var next = Math.round(t.now);
+ // Don't waste CPU
+ // Browsers don't render floating point scroll
+ if (curr !== next) {
+ $(t.elem)[t.prop](next);
+ t._last = this.get(t);
+ }
+ }
+ };
+
+ // AMD requirement
+ return $scrollTo;
+});
+/*!
+ PowerTip v1.3.1 (2018-04-15)
+ https://stevenbenner.github.io/jquery-powertip/
+ Copyright (c) 2018 Steven Benner (http://stevenbenner.com/).
+ Released under MIT license.
+ https://raw.github.com/stevenbenner/jquery-powertip/master/LICENSE.txt
+*/
+(function (root, factory) {
+ // support loading the plugin via common patterns
+ if (typeof define === 'function' && define.amd) {
+ // load the plugin as an amd module
+ define(['jquery'], factory);
+ } else if (typeof module === 'object' && module.exports) {
+ // load the plugin as a commonjs module
+ module.exports = factory(require('jquery'));
+ } else {
+ // load the plugin as a global
+ factory(root.jQuery);
+ }
+}(this, function ($) {
+ // useful private variables
+ var $document = $(document),
+ $window = $(window),
+ $body = $('body');
+
+ // constants
+ var DATA_DISPLAYCONTROLLER = 'displayController',
+ DATA_HASACTIVEHOVER = 'hasActiveHover',
+ DATA_FORCEDOPEN = 'forcedOpen',
+ DATA_HASMOUSEMOVE = 'hasMouseMove',
+ DATA_MOUSEONTOTIP = 'mouseOnToPopup',
+ DATA_ORIGINALTITLE = 'originalTitle',
+ DATA_POWERTIP = 'powertip',
+ DATA_POWERTIPJQ = 'powertipjq',
+ DATA_POWERTIPTARGET = 'powertiptarget',
+ EVENT_NAMESPACE = '.powertip',
+ RAD2DEG = 180 / Math.PI,
+ MOUSE_EVENTS = [
+ 'click',
+ 'dblclick',
+ 'mousedown',
+ 'mouseup',
+ 'mousemove',
+ 'mouseover',
+ 'mouseout',
+ 'mouseenter',
+ 'mouseleave',
+ 'contextmenu'
+ ];
+
+ /**
+ * Session data
+ * Private properties global to all powerTip instances
+ */
+ var session = {
+ elements: null,
+ tooltips: null,
+ isTipOpen: false,
+ isFixedTipOpen: false,
+ isClosing: false,
+ tipOpenImminent: false,
+ activeHover: null,
+ currentX: 0,
+ currentY: 0,
+ previousX: 0,
+ previousY: 0,
+ desyncTimeout: null,
+ closeDelayTimeout: null,
+ mouseTrackingActive: false,
+ delayInProgress: false,
+ windowWidth: 0,
+ windowHeight: 0,
+ scrollTop: 0,
+ scrollLeft: 0
+ };
+
+ /**
+ * Collision enumeration
+ * @enum {number}
+ */
+ var Collision = {
+ none: 0,
+ top: 1,
+ bottom: 2,
+ left: 4,
+ right: 8
+ };
+
+ /**
+ * Display hover tooltips on the matched elements.
+ * @param {(Object|string)=} opts The options object to use for the plugin, or
+ * the name of a method to invoke on the first matched element.
+ * @param {*=} [arg] Argument for an invoked method (optional).
+ * @return {jQuery} jQuery object for the matched selectors.
+ */
+ $.fn.powerTip = function(opts, arg) {
+ var targetElements = this,
+ options,
+ tipController;
+
+ // don't do any work if there were no matched elements
+ if (!targetElements.length) {
+ return targetElements;
+ }
+
+ // handle api method calls on the plugin, e.g. powerTip('hide')
+ if ($.type(opts) === 'string' && $.powerTip[opts]) {
+ return $.powerTip[opts].call(targetElements, targetElements, arg);
+ }
+
+ // extend options
+ options = $.extend({}, $.fn.powerTip.defaults, opts);
+
+ // handle repeated powerTip calls on the same element by destroying any
+ // original instance hooked to it and replacing it with this call
+ $.powerTip.destroy(targetElements);
+
+ // instantiate the TooltipController for this instance
+ tipController = new TooltipController(options);
+
+ // hook mouse and viewport dimension tracking
+ initTracking();
+
+ // setup the elements
+ targetElements.each(function elementSetup() {
+ var $this = $(this),
+ dataPowertip = $this.data(DATA_POWERTIP),
+ dataElem = $this.data(DATA_POWERTIPJQ),
+ dataTarget = $this.data(DATA_POWERTIPTARGET),
+ title = $this.attr('title');
+
+ // attempt to use title attribute text if there is no data-powertip,
+ // data-powertipjq or data-powertiptarget. If we do use the title
+ // attribute, delete the attribute so the browser will not show it
+ if (!dataPowertip && !dataTarget && !dataElem && title) {
+ $this.data(DATA_POWERTIP, title);
+ $this.data(DATA_ORIGINALTITLE, title);
+ $this.removeAttr('title');
+ }
+
+ // create hover controllers for each element
+ $this.data(
+ DATA_DISPLAYCONTROLLER,
+ new DisplayController($this, options, tipController)
+ );
+ });
+
+ // attach events to matched elements if the manual option is not enabled
+ if (!options.manual) {
+ // attach open events
+ $.each(options.openEvents, function (idx, evt) {
+ if ($.inArray(evt, options.closeEvents) > -1) {
+ // event is in both openEvents and closeEvents, so toggle it
+ targetElements.on(evt + EVENT_NAMESPACE, function elementToggle(event) {
+ $.powerTip.toggle(this, event);
+ });
+ } else {
+ targetElements.on(evt + EVENT_NAMESPACE, function elementOpen(event) {
+ $.powerTip.show(this, event);
+ });
+ }
+ });
+
+ // attach close events
+ $.each(options.closeEvents, function (idx, evt) {
+ if ($.inArray(evt, options.openEvents) < 0) {
+ targetElements.on(evt + EVENT_NAMESPACE, function elementClose(event) {
+ // set immediate to true for any event without mouse info
+ $.powerTip.hide(this, !isMouseEvent(event));
+ });
+ }
+ });
+
+ // attach escape key close event
+ targetElements.on('keydown' + EVENT_NAMESPACE, function elementKeyDown(event) {
+ // always close tooltip when the escape key is pressed
+ if (event.keyCode === 27) {
+ $.powerTip.hide(this, true);
+ }
+ });
+ }
+
+ // remember elements that the plugin is attached to
+ session.elements = session.elements ? session.elements.add(targetElements) : targetElements;
+
+ return targetElements;
+ };
+
+ /**
+ * Default options for the powerTip plugin.
+ */
+ $.fn.powerTip.defaults = {
+ fadeInTime: 200,
+ fadeOutTime: 100,
+ followMouse: false,
+ popupId: 'powerTip',
+ popupClass: null,
+ intentSensitivity: 7,
+ intentPollInterval: 100,
+ closeDelay: 100,
+ placement: 'n',
+ smartPlacement: false,
+ offset: 10,
+ mouseOnToPopup: false,
+ manual: false,
+ openEvents: ['mouseenter', 'focus'],
+ closeEvents: ['mouseleave', 'blur']
+ };
+
+ /**
+ * Default smart placement priority lists.
+ * The first item in the array is the highest priority, the last is the lowest.
+ * The last item is also the default, which will be used if all previous options
+ * do not fit.
+ */
+ $.fn.powerTip.smartPlacementLists = {
+ n: ['n', 'ne', 'nw', 's'],
+ e: ['e', 'ne', 'se', 'w', 'nw', 'sw', 'n', 's', 'e'],
+ s: ['s', 'se', 'sw', 'n'],
+ w: ['w', 'nw', 'sw', 'e', 'ne', 'se', 'n', 's', 'w'],
+ nw: ['nw', 'w', 'sw', 'n', 's', 'se', 'nw'],
+ ne: ['ne', 'e', 'se', 'n', 's', 'sw', 'ne'],
+ sw: ['sw', 'w', 'nw', 's', 'n', 'ne', 'sw'],
+ se: ['se', 'e', 'ne', 's', 'n', 'nw', 'se'],
+ 'nw-alt': ['nw-alt', 'n', 'ne-alt', 'sw-alt', 's', 'se-alt', 'w', 'e'],
+ 'ne-alt': ['ne-alt', 'n', 'nw-alt', 'se-alt', 's', 'sw-alt', 'e', 'w'],
+ 'sw-alt': ['sw-alt', 's', 'se-alt', 'nw-alt', 'n', 'ne-alt', 'w', 'e'],
+ 'se-alt': ['se-alt', 's', 'sw-alt', 'ne-alt', 'n', 'nw-alt', 'e', 'w']
+ };
+
+ /**
+ * Public API
+ */
+ $.powerTip = {
+ /**
+ * Attempts to show the tooltip for the specified element.
+ * @param {jQuery|Element} element The element to open the tooltip for.
+ * @param {jQuery.Event=} event jQuery event for hover intent and mouse
+ * tracking (optional).
+ * @return {
+ jQuery|Element
+ } The original jQuery object or DOM Element.
+ */
+ show: function apiShowTip(element, event) {
+ // if we were given a mouse event then run the hover intent testing,
+ // otherwise, simply show the tooltip asap
+ if (isMouseEvent(event)) {
+ trackMouse(event);
+ session.previousX = event.pageX;
+ session.previousY = event.pageY;
+ $(element).data(DATA_DISPLAYCONTROLLER).show();
+ } else {
+ $(element).first().data(DATA_DISPLAYCONTROLLER).show(true, true);
+ }
+ return element;
+ },
+
+ /**
+ * Repositions the tooltip on the element.
+ * @param {jQuery|Element} element The element the tooltip is shown for.
+ * @return {jQuery|Element} The original jQuery object or DOM Element.
+ */
+ reposition: function apiResetPosition(element) {
+ $(element).first().data(DATA_DISPLAYCONTROLLER).resetPosition();
+ return element;
+ },
+
+ /**
+ * Attempts to close any open tooltips.
+ * @param {(jQuery|Element)=} element The element with the tooltip that
+ * should be closed (optional).
+ * @param {boolean=} immediate Disable close delay (optional).
+ * @return {jQuery|Element|undefined} The original jQuery object or DOM
+ * Element, if one was specified.
+ */
+ hide: function apiCloseTip(element, immediate) {
+ var displayController;
+
+ // set immediate to true when no element is specified
+ immediate = element ? immediate : true;
+
+ // find the relevant display controller
+ if (element) {
+ displayController = $(element).first().data(DATA_DISPLAYCONTROLLER);
+ } else if (session.activeHover) {
+ displayController = session.activeHover.data(DATA_DISPLAYCONTROLLER);
+ }
+
+ // if found, hide the tip
+ if (displayController) {
+ displayController.hide(immediate);
+ }
+
+ return element;
+ },
+
+ /**
+ * Toggles the tooltip for the specified element. This will open a closed
+ * tooltip, or close an open tooltip.
+ * @param {jQuery|Element} element The element with the tooltip that
+ * should be toggled.
+ * @param {jQuery.Event=} event jQuery event for hover intent and mouse
+ * tracking (optional).
+ * @return {jQuery|Element} The original jQuery object or DOM Element.
+ */
+ toggle: function apiToggle(element, event) {
+ if (session.activeHover && session.activeHover.is(element)) {
+ // tooltip for element is active, so close it
+ $.powerTip.hide(element, !isMouseEvent(event));
+ } else {
+ // tooltip for element is not active, so open it
+ $.powerTip.show(element, event);
+ }
+ return element;
+ },
+
+ /**
+ * Destroy and roll back any powerTip() instance on the specified elements.
+ * If no elements are specified then all elements that the plugin is
+ * currently attached to will be rolled back.
+ * @param {(jQuery|Element)=} element The element with the powerTip instance.
+ * @return {jQuery|Element|undefined} The original jQuery object or DOM
+ * Element, if one was specified.
+ */
+ destroy: function apiDestroy(element) {
+ var $element = element ? $(element) : session.elements;
+
+ // if the plugin is not hooked to any elements then there is no point
+ // trying to destroy anything, or dealing with the possible errors
+ if (!session.elements || session.elements.length === 0) {
+ return element;
+ }
+
+ // if a tooltip is currently open for an element we are being asked to
+ // destroy then it should be forced to close
+ if (session.isTipOpen && !session.isClosing && $element.filter(session.activeHover).length > 0) {
+ // if the tooltip is waiting to close then cancel that delay timer
+ if (session.delayInProgress) {
+ session.activeHover.data(DATA_DISPLAYCONTROLLER).cancel();
+ }
+ // hide the tooltip, immediately
+ $.powerTip.hide(session.activeHover, true);
+ }
+
+ // unhook events and destroy plugin changes to each element
+ $element.off(EVENT_NAMESPACE).each(function destroy() {
+ var $this = $(this),
+ dataAttributes = [
+ DATA_ORIGINALTITLE,
+ DATA_DISPLAYCONTROLLER,
+ DATA_HASACTIVEHOVER,
+ DATA_FORCEDOPEN
+ ];
+
+ // revert title attribute
+ if ($this.data(DATA_ORIGINALTITLE)) {
+ $this.attr('title', $this.data(DATA_ORIGINALTITLE));
+ dataAttributes.push(DATA_POWERTIP);
+ }
+
+ // remove data attributes
+ $this.removeData(dataAttributes);
+ });
+
+ // remove destroyed element from active elements collection
+ session.elements = session.elements.not($element);
+
+ // if there are no active elements left then we will unhook all of the
+ // events that we've bound code to and remove the tooltip elements
+ if (session.elements.length === 0) {
+ $window.off(EVENT_NAMESPACE);
+ $document.off(EVENT_NAMESPACE);
+ session.mouseTrackingActive = false;
+ session.tooltips.remove();
+ session.tooltips = null;
+ }
+
+ return element;
+ }
+ };
+
+ // API aliasing
+ $.powerTip.showTip = $.powerTip.show;
+ $.powerTip.closeTip = $.powerTip.hide;
+
+ /**
+ * Creates a new CSSCoordinates object.
+ * @private
+ * @constructor
+ */
+ function CSSCoordinates() {
+ var me = this;
+
+ // initialize object properties
+ me.top = 'auto';
+ me.left = 'auto';
+ me.right = 'auto';
+ me.bottom = 'auto';
+
+ /**
+ * Set a property to a value.
+ * @private
+ * @param {string} property The name of the property.
+ * @param {number} value The value of the property.
+ */
+ me.set = function(property, value) {
+ if ($.isNumeric(value)) {
+ me[property] = Math.round(value);
+ }
+ };
+ }
+
+ /**
+ * Creates a new tooltip display controller.
+ * @private
+ * @constructor
+ * @param {jQuery} element The element that this controller will handle.
+ * @param {Object} options Options object containing settings.
+ * @param {TooltipController} tipController The TooltipController object for
+ * this instance.
+ */
+ function DisplayController(element, options, tipController) {
+ var hoverTimer = null,
+ myCloseDelay = null;
+
+ /**
+ * Begins the process of showing a tooltip.
+ * @private
+ * @param {boolean=} immediate Skip intent testing (optional).
+ * @param {boolean=} forceOpen Ignore cursor position and force tooltip to
+ * open (optional).
+ */
+ function openTooltip(immediate, forceOpen) {
+ cancelTimer();
+ if (!element.data(DATA_HASACTIVEHOVER)) {
+ if (!immediate) {
+ session.tipOpenImminent = true;
+ hoverTimer = setTimeout(
+ function intentDelay() {
+ hoverTimer = null;
+ checkForIntent();
+ },
+ options.intentPollInterval
+ );
+ } else {
+ if (forceOpen) {
+ element.data(DATA_FORCEDOPEN, true);
+ }
+ closeAnyDelayed();
+ tipController.showTip(element);
+ }
+ } else {
+ // cursor left and returned to this element, cancel close
+ cancelClose();
+ }
+ }
+
+ /**
+ * Begins the process of closing a tooltip.
+ * @private
+ * @param {boolean=} disableDelay Disable close delay (optional).
+ */
+ function closeTooltip(disableDelay) {
+ // if this instance already has a close delay in progress then halt it
+ if (myCloseDelay) {
+ myCloseDelay = session.closeDelayTimeout = clearTimeout(myCloseDelay);
+ session.delayInProgress = false;
+ }
+ cancelTimer();
+ session.tipOpenImminent = false;
+ if (element.data(DATA_HASACTIVEHOVER)) {
+ element.data(DATA_FORCEDOPEN, false);
+ if (!disableDelay) {
+ session.delayInProgress = true;
+ session.closeDelayTimeout = setTimeout(
+ function closeDelay() {
+ session.closeDelayTimeout = null;
+ tipController.hideTip(element);
+ session.delayInProgress = false;
+ myCloseDelay = null;
+ },
+ options.closeDelay
+ );
+ // save internal reference close delay id so we can check if the
+ // active close delay belongs to this instance
+ myCloseDelay = session.closeDelayTimeout;
+ } else {
+ tipController.hideTip(element);
+ }
+ }
+ }
+
+ /**
+ * Checks mouse position to make sure that the user intended to hover on the
+ * specified element before showing the tooltip.
+ * @private
+ */
+ function checkForIntent() {
+ // calculate mouse position difference
+ var xDifference = Math.abs(session.previousX - session.currentX),
+ yDifference = Math.abs(session.previousY - session.currentY),
+ totalDifference = xDifference + yDifference;
+
+ // check if difference has passed the sensitivity threshold
+ if (totalDifference < options.intentSensitivity) {
+ cancelClose();
+ closeAnyDelayed();
+ tipController.showTip(element);
+ } else {
+ // try again
+ session.previousX = session.currentX;
+ session.previousY = session.currentY;
+ openTooltip();
+ }
+ }
+
+ /**
+ * Cancels active hover timer.
+ * @private
+ * @param {boolean=} stopClose Cancel any active close delay timer.
+ */
+ function cancelTimer(stopClose) {
+ hoverTimer = clearTimeout(hoverTimer);
+ // cancel the current close delay if the active close delay is for this
+ // element or the stopClose argument is true
+ if (session.closeDelayTimeout && myCloseDelay === session.closeDelayTimeout || stopClose) {
+ cancelClose();
+ }
+ }
+
+ /**
+ * Cancels any active close delay timer.
+ * @private
+ */
+ function cancelClose() {
+ session.closeDelayTimeout = clearTimeout(session.closeDelayTimeout);
+ session.delayInProgress = false;
+ }
+
+ /**
+ * Asks any tooltips waiting on their close delay to close now.
+ * @private
+ */
+ function closeAnyDelayed() {
+ // if another element is waiting for its close delay then we should ask
+ // it to close immediately so we can proceed without unexpected timeout
+ // code being run during this tooltip's lifecycle
+ if (session.delayInProgress && session.activeHover && !session.activeHover.is(element)) {
+ session.activeHover.data(DATA_DISPLAYCONTROLLER).hide(true);
+ }
+ }
+
+ /**
+ * Repositions the tooltip on this element.
+ * @private
+ */
+ function repositionTooltip() {
+ tipController.resetPosition(element);
+ }
+
+ // expose the methods
+ this.show = openTooltip;
+ this.hide = closeTooltip;
+ this.cancel = cancelTimer;
+ this.resetPosition = repositionTooltip;
+ }
+
+ /**
+ * Creates a new Placement Calculator.
+ * @private
+ * @constructor
+ */
+ function PlacementCalculator() {
+ /**
+ * Compute the CSS position to display a tooltip at the specified placement
+ * relative to the specified element.
+ * @private
+ * @param {jQuery} element The element that the tooltip should target.
+ * @param {string} placement The placement for the tooltip.
+ * @param {number} tipWidth Width of the tooltip element in pixels.
+ * @param {number} tipHeight Height of the tooltip element in pixels.
+ * @param {number} offset Distance to offset tooltips in pixels.
+ * @return {CSSCoordinates} A CSSCoordinates object with the position.
+ */
+ function computePlacementCoords(element, placement, tipWidth, tipHeight, offset) {
+ var placementBase = placement.split('-')[0], // ignore 'alt' for corners
+ coords = new CSSCoordinates(),
+ position;
+
+ if (isSvgElement(element)) {
+ position = getSvgPlacement(element, placementBase);
+ } else {
+ position = getHtmlPlacement(element, placementBase);
+ }
+
+ // calculate the appropriate x and y position in the document
+ switch (placement) {
+ case 'n':
+ coords.set('left', position.left - (tipWidth / 2));
+ coords.set('bottom', session.windowHeight - position.top + offset);
+ break;
+ case 'e':
+ coords.set('left', position.left + offset);
+ coords.set('top', position.top - (tipHeight / 2));
+ break;
+ case 's':
+ coords.set('left', position.left - (tipWidth / 2));
+ coords.set('top', position.top + offset);
+ break;
+ case 'w':
+ coords.set('top', position.top - (tipHeight / 2));
+ coords.set('right', session.windowWidth - position.left + offset);
+ break;
+ case 'nw':
+ coords.set('bottom', session.windowHeight - position.top + offset);
+ coords.set('right', session.windowWidth - position.left - 20);
+ break;
+ case 'nw-alt':
+ coords.set('left', position.left);
+ coords.set('bottom', session.windowHeight - position.top + offset);
+ break;
+ case 'ne':
+ coords.set('left', position.left - 20);
+ coords.set('bottom', session.windowHeight - position.top + offset);
+ break;
+ case 'ne-alt':
+ coords.set('bottom', session.windowHeight - position.top + offset);
+ coords.set('right', session.windowWidth - position.left);
+ break;
+ case 'sw':
+ coords.set('top', position.top + offset);
+ coords.set('right', session.windowWidth - position.left - 20);
+ break;
+ case 'sw-alt':
+ coords.set('left', position.left);
+ coords.set('top', position.top + offset);
+ break;
+ case 'se':
+ coords.set('left', position.left - 20);
+ coords.set('top', position.top + offset);
+ break;
+ case 'se-alt':
+ coords.set('top', position.top + offset);
+ coords.set('right', session.windowWidth - position.left);
+ break;
+ }
+
+ return coords;
+ }
+
+ /**
+ * Finds the tooltip attachment point in the document for a HTML DOM element
+ * for the specified placement.
+ * @private
+ * @param {jQuery} element The element that the tooltip should target.
+ * @param {string} placement The placement for the tooltip.
+ * @return {Object} An object with the top,left position values.
+ */
+ function getHtmlPlacement(element, placement) {
+ var objectOffset = element.offset(),
+ objectWidth = element.outerWidth(),
+ objectHeight = element.outerHeight(),
+ left,
+ top;
+
+ // calculate the appropriate x and y position in the document
+ switch (placement) {
+ case 'n':
+ left = objectOffset.left + objectWidth / 2;
+ top = objectOffset.top;
+ break;
+ case 'e':
+ left = objectOffset.left + objectWidth;
+ top = objectOffset.top + objectHeight / 2;
+ break;
+ case 's':
+ left = objectOffset.left + objectWidth / 2;
+ top = objectOffset.top + objectHeight;
+ break;
+ case 'w':
+ left = objectOffset.left;
+ top = objectOffset.top + objectHeight / 2;
+ break;
+ case 'nw':
+ left = objectOffset.left;
+ top = objectOffset.top;
+ break;
+ case 'ne':
+ left = objectOffset.left + objectWidth;
+ top = objectOffset.top;
+ break;
+ case 'sw':
+ left = objectOffset.left;
+ top = objectOffset.top + objectHeight;
+ break;
+ case 'se':
+ left = objectOffset.left + objectWidth;
+ top = objectOffset.top + objectHeight;
+ break;
+ }
+
+ return {
+ top: top,
+ left: left
+ };
+ }
+
+ /**
+ * Finds the tooltip attachment point in the document for a SVG element for
+ * the specified placement.
+ * @private
+ * @param {jQuery} element The element that the tooltip should target.
+ * @param {string} placement The placement for the tooltip.
+ * @return {Object} An object with the top,left position values.
+ */
+ function getSvgPlacement(element, placement) {
+ var svgElement = element.closest('svg')[0],
+ domElement = element[0],
+ point = svgElement.createSVGPoint(),
+ boundingBox = domElement.getBBox(),
+ matrix = domElement.getScreenCTM(),
+ halfWidth = boundingBox.width / 2,
+ halfHeight = boundingBox.height / 2,
+ placements = [],
+ placementKeys = ['nw', 'n', 'ne', 'e', 'se', 's', 'sw', 'w'],
+ coords,
+ rotation,
+ steps,
+ x;
+
+ /**
+ * Transform and append the current points to the placements list.
+ * @private
+ */
+ function pushPlacement() {
+ placements.push(point.matrixTransform(matrix));
+ }
+
+ // get bounding box corners and midpoints
+ point.x = boundingBox.x;
+ point.y = boundingBox.y;
+ pushPlacement();
+ point.x += halfWidth;
+ pushPlacement();
+ point.x += halfWidth;
+ pushPlacement();
+ point.y += halfHeight;
+ pushPlacement();
+ point.y += halfHeight;
+ pushPlacement();
+ point.x -= halfWidth;
+ pushPlacement();
+ point.x -= halfWidth;
+ pushPlacement();
+ point.y -= halfHeight;
+ pushPlacement();
+
+ // determine rotation
+ if (placements[0].y !== placements[1].y || placements[0].x !== placements[7].x) {
+ rotation = Math.atan2(matrix.b, matrix.a) * RAD2DEG;
+ steps = Math.ceil(((rotation % 360) - 22.5) / 45);
+ if (steps < 1) {
+ steps += 8;
+ }
+ while (steps--) {
+ placementKeys.push(placementKeys.shift());
+ }
+ }
+
+ // find placement
+ for (x = 0; x < placements.length; x++) {
+ if (placementKeys[x] === placement) {
+ coords = placements[x];
+ break;
+ }
+ }
+
+ return {
+ top: coords.y + session.scrollTop,
+ left: coords.x + session.scrollLeft
+ };
+ }
+
+ // expose methods
+ this.compute = computePlacementCoords;
+ }
+
+ /**
+ * Creates a new tooltip controller.
+ * @private
+ * @constructor
+ * @param {Object} options Options object containing settings.
+ */
+ function TooltipController(options) {
+ var placementCalculator = new PlacementCalculator(),
+ tipElement = $('#' + options.popupId);
+
+ // build and append tooltip div if it does not already exist
+ if (tipElement.length === 0) {
+ tipElement = $('<div/>', { id: options.popupId });
+ // grab body element if it was not populated when the script loaded
+ // note: this hack exists solely for jsfiddle support
+ if ($body.length === 0) {
+ $body = $('body');
+ }
+ $body.append(tipElement);
+ // remember the tooltip elements that the plugin has created
+ session.tooltips = session.tooltips ? session.tooltips.add(tipElement) : tipElement;
+ }
+
+ // hook mousemove for cursor follow tooltips
+ if (options.followMouse) {
+ // only one positionTipOnCursor hook per tooltip element, please
+ if (!tipElement.data(DATA_HASMOUSEMOVE)) {
+ $document.on('mousemove' + EVENT_NAMESPACE, positionTipOnCursor);
+ $window.on('scroll' + EVENT_NAMESPACE, positionTipOnCursor);
+ tipElement.data(DATA_HASMOUSEMOVE, true);
+ }
+ }
+
+ /**
+ * Gives the specified element the active-hover state and queues up the
+ * showTip function.
+ * @private
+ * @param {jQuery} element The element that the tooltip should target.
+ */
+ function beginShowTip(element) {
+ element.data(DATA_HASACTIVEHOVER, true);
+ // show tooltip, asap
+ tipElement.queue(function queueTipInit(next) {
+ showTip(element);
+ next();
+ });
+ }
+
+ /**
+ * Shows the tooltip, as soon as possible.
+ * @private
+ * @param {jQuery} element The element that the tooltip should target.
+ */
+ function showTip(element) {
+ var tipContent;
+
+ // it is possible, especially with keyboard navigation, to move on to
+ // another element with a tooltip during the queue to get to this point
+ // in the code. if that happens then we need to not proceed or we may
+ // have the fadeout callback for the last tooltip execute immediately
+ // after this code runs, causing bugs.
+ if (!element.data(DATA_HASACTIVEHOVER)) {
+ return;
+ }
+
+ // if the tooltip is open and we got asked to open another one then the
+ // old one is still in its fadeOut cycle, so wait and try again
+ if (session.isTipOpen) {
+ if (!session.isClosing) {
+ hideTip(session.activeHover);
+ }
+ tipElement.delay(100).queue(function queueTipAgain(next) {
+ showTip(element);
+ next();
+ });
+ return;
+ }
+
+ // trigger powerTipPreRender event
+ element.trigger('powerTipPreRender');
+
+ // set tooltip content
+ tipContent = getTooltipContent(element);
+ if (tipContent) {
+ tipElement.empty().append(tipContent);
+ } else {
+ // we have no content to display, give up
+ return;
+ }
+
+ // trigger powerTipRender event
+ element.trigger('powerTipRender');
+
+ session.activeHover = element;
+ session.isTipOpen = true;
+
+ tipElement.data(DATA_MOUSEONTOTIP, options.mouseOnToPopup);
+
+ // add custom class to tooltip element
+ tipElement.addClass(options.popupClass);
+
+ // set tooltip position
+ // revert to static placement when the "force open" flag was set because
+ // that flag means that we do not have accurate mouse position info
+ if (!options.followMouse || element.data(DATA_FORCEDOPEN)) {
+ positionTipOnElement(element);
+ session.isFixedTipOpen = true;
+ } else {
+ positionTipOnCursor();
+ }
+
+ // close tooltip when clicking anywhere on the page, with the exception
+ // of the tooltip's trigger element and any elements that are within a
+ // tooltip that has 'mouseOnToPopup' option enabled
+ // always enable this feature when the "force open" flag is set on a
+ // followMouse tooltip because we reverted to static placement above
+ if (!element.data(DATA_FORCEDOPEN) && !options.followMouse) {
+ $document.on('click' + EVENT_NAMESPACE, function documentClick(event) {
+ var target = event.target;
+ if (target !== element[0]) {
+ if (options.mouseOnToPopup) {
+ if (target !== tipElement[0] && !$.contains(tipElement[0], target)) {
+ $.powerTip.hide();
+ }
+ } else {
+ $.powerTip.hide();
+ }
+ }
+ });
+ }
+
+ // if we want to be able to mouse on to the tooltip then we need to
+ // attach hover events to the tooltip that will cancel a close request
+ // on mouseenter and start a new close request on mouseleave
+ // only hook these listeners if we're not in manual mode
+ if (options.mouseOnToPopup && !options.manual) {
+ tipElement.on('mouseenter' + EVENT_NAMESPACE, function tipMouseEnter() {
+ // check activeHover in case the mouse cursor entered the
+ // tooltip during the fadeOut and close cycle
+ if (session.activeHover) {
+ session.activeHover.data(DATA_DISPLAYCONTROLLER).cancel();
+ }
+ });
+ tipElement.on('mouseleave' + EVENT_NAMESPACE, function tipMouseLeave() {
+ // check activeHover in case the mouse cursor left the tooltip
+ // during the fadeOut and close cycle
+ if (session.activeHover) {
+ session.activeHover.data(DATA_DISPLAYCONTROLLER).hide();
+ }
+ });
+ }
+
+ // fadein
+ tipElement.fadeIn(options.fadeInTime, function fadeInCallback() {
+ // start desync polling
+ if (!session.desyncTimeout) {
+ session.desyncTimeout = setInterval(closeDesyncedTip, 500);
+ }
+
+ // trigger powerTipOpen event
+ element.trigger('powerTipOpen');
+ });
+ }
+
+ /**
+ * Hides the tooltip.
+ * @private
+ * @param {jQuery} element The element that the tooltip should target.
+ */
+ function hideTip(element) {
+ // reset session
+ session.isClosing = true;
+ session.isTipOpen = false;
+
+ // stop desync polling
+ session.desyncTimeout = clearInterval(session.desyncTimeout);
+
+ // reset element state
+ element.data(DATA_HASACTIVEHOVER, false);
+ element.data(DATA_FORCEDOPEN, false);
+
+ // remove document click handler
+ $document.off('click' + EVENT_NAMESPACE);
+
+ // unbind the mouseOnToPopup events if they were set
+ tipElement.off(EVENT_NAMESPACE);
+
+ // fade out
+ tipElement.fadeOut(options.fadeOutTime, function fadeOutCallback() {
+ var coords = new CSSCoordinates();
+
+ // reset session and tooltip element
+ session.activeHover = null;
+ session.isClosing = false;
+ session.isFixedTipOpen = false;
+ tipElement.removeClass();
+
+ // support mouse-follow and fixed position tips at the same time by
+ // moving the tooltip to the last cursor location after it is hidden
+ coords.set('top', session.currentY + options.offset);
+ coords.set('left', session.currentX + options.offset);
+ tipElement.css(coords);
+
+ // trigger powerTipClose event
+ element.trigger('powerTipClose');
+ });
+ }
+
+ /**
+ * Moves the tooltip to the users mouse cursor.
+ * @private
+ */
+ function positionTipOnCursor() {
+ var tipWidth,
+ tipHeight,
+ coords,
+ collisions,
+ collisionCount;
+
+ // to support having fixed tooltips on the same page as cursor tooltips,
+ // where both instances are referencing the same tooltip element, we
+ // need to keep track of the mouse position constantly, but we should
+ // only set the tip location if a fixed tip is not currently open, a tip
+ // open is imminent or active, and the tooltip element in question does
+ // have a mouse-follow using it.
+ if (!session.isFixedTipOpen && (session.isTipOpen || (session.tipOpenImminent && tipElement.data(DATA_HASMOUSEMOVE)))) {
+ // grab measurements
+ tipWidth = tipElement.outerWidth();
+ tipHeight = tipElement.outerHeight();
+ coords = new CSSCoordinates();
+
+ // grab collisions
+ coords.set('top', session.currentY + options.offset);
+ coords.set('left', session.currentX + options.offset);
+ collisions = getViewportCollisions(
+ coords,
+ tipWidth,
+ tipHeight
+ );
+
+ // handle tooltip view port collisions
+ if (collisions !== Collision.none) {
+ collisionCount = countFlags(collisions);
+ if (collisionCount === 1) {
+ // if there is only one collision (bottom or right) then
+ // simply constrain the tooltip to the view port
+ if (collisions === Collision.right) {
+ coords.set('left', session.scrollLeft + session.windowWidth - tipWidth);
+ } else if (collisions === Collision.bottom) {
+ coords.set('top', session.scrollTop + session.windowHeight - tipHeight);
+ }
+ } else {
+ // if the tooltip has more than one collision then it is
+ // trapped in the corner and should be flipped to get it out
+ // of the users way
+ coords.set('left', session.currentX - tipWidth - options.offset);
+ coords.set('top', session.currentY - tipHeight - options.offset);
+ }
+ }
+
+ // position the tooltip
+ tipElement.css(coords);
+ }
+ }
+
+ /**
+ * Sets the tooltip to the correct position relative to the specified target
+ * element. Based on options settings.
+ * @private
+ * @param {jQuery} element The element that the tooltip should target.
+ */
+ function positionTipOnElement(element) {
+ var priorityList,
+ finalPlacement;
+
+ // when the followMouse option is enabled and the "force open" flag is
+ // set we revert to static positioning. since the developer may not have
+ // considered this scenario we should use smart placement
+ if (options.smartPlacement || (options.followMouse && element.data(DATA_FORCEDOPEN))) {
+ priorityList = $.fn.powerTip.smartPlacementLists[options.placement];
+
+ // iterate over the priority list and use the first placement option
+ // that does not collide with the view port. if they all collide
+ // then the last placement in the list will be used.
+ $.each(priorityList, function(idx, pos) {
+ // place tooltip and find collisions
+ var collisions = getViewportCollisions(
+ placeTooltip(element, pos),
+ tipElement.outerWidth(),
+ tipElement.outerHeight()
+ );
+
+ // update the final placement variable
+ finalPlacement = pos;
+
+ // break if there were no collisions
+ return collisions !== Collision.none;
+ });
+ } else {
+ // if we're not going to use the smart placement feature then just
+ // compute the coordinates and do it
+ placeTooltip(element, options.placement);
+ finalPlacement = options.placement;
+ }
+
+ // add placement as class for CSS arrows
+ tipElement.removeClass('w nw sw e ne se n s w se-alt sw-alt ne-alt nw-alt');
+ tipElement.addClass(finalPlacement);
+ }
+
+ /**
+ * Sets the tooltip position to the appropriate values to show the tip at
+ * the specified placement. This function will iterate and test the tooltip
+ * to support elastic tooltips.
+ * @private
+ * @param {jQuery} element The element that the tooltip should target.
+ * @param {string} placement The placement for the tooltip.
+ * @return {CSSCoordinates} A CSSCoordinates object with the top, left, and
+ * right position values.
+ */
+ function placeTooltip(element, placement) {
+ var iterationCount = 0,
+ tipWidth,
+ tipHeight,
+ coords = new CSSCoordinates();
+
+ // set the tip to 0,0 to get the full expanded width
+ coords.set('top', 0);
+ coords.set('left', 0);
+ tipElement.css(coords);
+
+ // to support elastic tooltips we need to check for a change in the
+ // rendered dimensions after the tooltip has been positioned
+ do {
+ // grab the current tip dimensions
+ tipWidth = tipElement.outerWidth();
+ tipHeight = tipElement.outerHeight();
+
+ // get placement coordinates
+ coords = placementCalculator.compute(
+ element,
+ placement,
+ tipWidth,
+ tipHeight,
+ options.offset
+ );
+
+ // place the tooltip
+ tipElement.css(coords);
+ } while (
+ // sanity check: limit to 5 iterations, and...
+ ++iterationCount <= 5 &&
+ // try again if the dimensions changed after placement
+ (tipWidth !== tipElement.outerWidth() || tipHeight !== tipElement.outerHeight())
+ );
+
+ return coords;
+ }
+
+ /**
+ * Checks for a tooltip desync and closes the tooltip if one occurs.
+ * @private
+ */
+ function closeDesyncedTip() {
+ var isDesynced = false,
+ hasDesyncableCloseEvent = $.grep(
+ ['mouseleave', 'mouseout', 'blur', 'focusout'],
+ function (eventType) {
+ return $.inArray(eventType, options.closeEvents) !== -1;
+ }
+ ).length > 0;
+
+ // It is possible for the mouse cursor to leave an element without
+ // firing the mouseleave or blur event. This most commonly happens when
+ // the element is disabled under mouse cursor. If this happens it will
+ // result in a desynced tooltip because the tooltip was never asked to
+ // close. So we should periodically check for a desync situation and
+ // close the tip if such a situation arises.
+ if (session.isTipOpen && !session.isClosing && !session.delayInProgress && hasDesyncableCloseEvent) {
+ if (session.activeHover.data(DATA_HASACTIVEHOVER) === false || session.activeHover.is(':disabled')) {
+ // user moused onto another tip or active hover is disabled
+ isDesynced = true;
+ } else if (!isMouseOver(session.activeHover) && !session.activeHover.is(':focus') && !session.activeHover.data(DATA_FORCEDOPEN)) {
+ // hanging tip - have to test if mouse position is not over the
+ // active hover and not over a tooltip set to let the user
+ // interact with it.
+ // for keyboard navigation: this only counts if the element does
+ // not have focus.
+ // for tooltips opened via the api: we need to check if it has
+ // the forcedOpen flag.
+ if (tipElement.data(DATA_MOUSEONTOTIP)) {
+ if (!isMouseOver(tipElement)) {
+ isDesynced = true;
+ }
+ } else {
+ isDesynced = true;
+ }
+ }
+
+ if (isDesynced) {
+ // close the desynced tip
+ hideTip(session.activeHover);
+ }
+ }
+ }
+
+ // expose methods
+ this.showTip = beginShowTip;
+ this.hideTip = hideTip;
+ this.resetPosition = positionTipOnElement;
+ }
+
+ /**
+ * Determine whether a jQuery object is an SVG element
+ * @private
+ * @param {jQuery} element The element to check
+ * @return {boolean} Whether this is an SVG element
+ */
+ function isSvgElement(element) {
+ return Boolean(window.SVGElement && element[0] instanceof SVGElement);
+ }
+
+ /**
+ * Determines if the specified jQuery.Event object has mouse data.
+ * @private
+ * @param {jQuery.Event=} event The jQuery.Event object to test.
+ * @return {boolean} True if there is mouse data, otherwise false.
+ */
+ function isMouseEvent(event) {
+ return Boolean(event && $.inArray(event.type, MOUSE_EVENTS) > -1 &&
+ typeof event.pageX === 'number');
+ }
+
+ /**
+ * Initializes the viewport dimension cache and hooks up the mouse position
+ * tracking and viewport dimension tracking events.
+ * Prevents attaching the events more than once.
+ * @private
+ */
+ function initTracking() {
+ if (!session.mouseTrackingActive) {
+ session.mouseTrackingActive = true;
+
+ // grab the current viewport dimensions on load
+ getViewportDimensions();
+ $(getViewportDimensions);
+
+ // hook mouse move tracking
+ $document.on('mousemove' + EVENT_NAMESPACE, trackMouse);
+
+ // hook viewport dimensions tracking
+ $window.on('resize' + EVENT_NAMESPACE, trackResize);
+ $window.on('scroll' + EVENT_NAMESPACE, trackScroll);
+ }
+ }
+
+ /**
+ * Updates the viewport dimensions cache.
+ * @private
+ */
+ function getViewportDimensions() {
+ session.scrollLeft = $window.scrollLeft();
+ session.scrollTop = $window.scrollTop();
+ session.windowWidth = $window.width();
+ session.windowHeight = $window.height();
+ }
+
+ /**
+ * Updates the window size info in the viewport dimensions cache.
+ * @private
+ */
+ function trackResize() {
+ session.windowWidth = $window.width();
+ session.windowHeight = $window.height();
+ }
+
+ /**
+ * Updates the scroll offset info in the viewport dimensions cache.
+ * @private
+ */
+ function trackScroll() {
+ var x = $window.scrollLeft(),
+ y = $window.scrollTop();
+ if (x !== session.scrollLeft) {
+ session.currentX += x - session.scrollLeft;
+ session.scrollLeft = x;
+ }
+ if (y !== session.scrollTop) {
+ session.currentY += y - session.scrollTop;
+ session.scrollTop = y;
+ }
+ }
+
+ /**
+ * Saves the current mouse coordinates to the session object.
+ * @private
+ * @param {jQuery.Event} event The mousemove event for the document.
+ */
+ function trackMouse(event) {
+ session.currentX = event.pageX;
+ session.currentY = event.pageY;
+ }
+
+ /**
+ * Tests if the mouse is currently over the specified element.
+ * @private
+ * @param {jQuery} element The element to check for hover.
+ * @return {boolean} True if the mouse is over the element, otherwise false.
+ */
+ function isMouseOver(element) {
+ // use getBoundingClientRect() because jQuery's width() and height()
+ // methods do not work with SVG elements
+ // compute width/height because those properties do not exist on the object
+ // returned by getBoundingClientRect() in older versions of IE
+ var elementPosition = element.offset(),
+ elementBox = element[0].getBoundingClientRect(),
+ elementWidth = elementBox.right - elementBox.left,
+ elementHeight = elementBox.bottom - elementBox.top;
+
+ return session.currentX >= elementPosition.left &&
+ session.currentX <= elementPosition.left + elementWidth &&
+ session.currentY >= elementPosition.top &&
+ session.currentY <= elementPosition.top + elementHeight;
+ }
+
+ /**
+ * Fetches the tooltip content from the specified element's data attributes.
+ * @private
+ * @param {jQuery} element The element to get the tooltip content for.
+ * @return {(string|jQuery|undefined)} The text/HTML string, jQuery object, or
+ * undefined if there was no tooltip content for the element.
+ */
+ function getTooltipContent(element) {
+ var tipText = element.data(DATA_POWERTIP),
+ tipObject = element.data(DATA_POWERTIPJQ),
+ tipTarget = element.data(DATA_POWERTIPTARGET),
+ targetElement,
+ content;
+
+ if (tipText) {
+ if ($.isFunction(tipText)) {
+ tipText = tipText.call(element[0]);
+ }
+ content = tipText;
+ } else if (tipObject) {
+ if ($.isFunction(tipObject)) {
+ tipObject = tipObject.call(element[0]);
+ }
+ if (tipObject.length > 0) {
+ content = tipObject.clone(true, true);
+ }
+ } else if (tipTarget) {
+ targetElement = $('#' + tipTarget);
+ if (targetElement.length > 0) {
+ content = targetElement.html();
+ }
+ }
+
+ return content;
+ }
+
+ /**
+ * Finds any viewport collisions that an element (the tooltip) would have if it
+ * were absolutely positioned at the specified coordinates.
+ * @private
+ * @param {CSSCoordinates} coords Coordinates for the element.
+ * @param {number} elementWidth Width of the element in pixels.
+ * @param {number} elementHeight Height of the element in pixels.
+ * @return {number} Value with the collision flags.
+ */
+ function getViewportCollisions(coords, elementWidth, elementHeight) {
+ var viewportTop = session.scrollTop,
+ viewportLeft = session.scrollLeft,
+ viewportBottom = viewportTop + session.windowHeight,
+ viewportRight = viewportLeft + session.windowWidth,
+ collisions = Collision.none;
+
+ if (coords.top < viewportTop || Math.abs(coords.bottom - session.windowHeight) - elementHeight < viewportTop) {
+ collisions |= Collision.top;
+ }
+ if (coords.top + elementHeight > viewportBottom || Math.abs(coords.bottom - session.windowHeight) > viewportBottom) {
+ collisions |= Collision.bottom;
+ }
+ if (coords.left < viewportLeft || coords.right + elementWidth > viewportRight) {
+ collisions |= Collision.left;
+ }
+ if (coords.left + elementWidth > viewportRight || coords.right < viewportLeft) {
+ collisions |= Collision.right;
+ }
+
+ return collisions;
+ }
+
+ /**
+ * Counts the number of bits set on a flags value.
+ * @param {number} value The flags value.
+ * @return {number} The number of bits that have been set.
+ */
+ function countFlags(value) {
+ var count = 0;
+ while (value) {
+ value &= value - 1;
+ count++;
+ }
+ return count;
+ }
+
+ // return api for commonjs and amd environments
+ return $.powerTip;
+}));
+/*!
+ * jQuery UI Touch Punch 0.2.3
+ *
+ * Copyright 2011–2014, Dave Furfero
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ *
+ * Depends:
+ * jquery.ui.widget.js
+ * jquery.ui.mouse.js
+ */
+(function ($) {
+
+ // Detect touch support
+ $.support.touch = 'ontouchend' in document;
+
+ // Ignore browsers without touch support
+ if (!$.support.touch) {
+ return;
+ }
+
+ var mouseProto = $.ui.mouse.prototype,
+ _mouseInit = mouseProto._mouseInit,
+ _mouseDestroy = mouseProto._mouseDestroy,
+ touchHandled;
+
+ /**
+ * Simulate a mouse event based on a corresponding touch event
+ * @param {Object} event A touch event
+ * @param {String} simulatedType The corresponding mouse event
+ */
+ function simulateMouseEvent(event, simulatedType) {
+
+ // Ignore multi-touch events
+ if (event.originalEvent.touches.length > 1) {
+ return;
+ }
+
+ event.preventDefault();
+
+ var touch = event.originalEvent.changedTouches[0],
+ simulatedEvent = document.createEvent('MouseEvents');
+
+ // Initialize the simulated mouse event using the touch event's coordinates
+ simulatedEvent.initMouseEvent(
+ simulatedType, // type
+ true, // bubbles
+ true, // cancelable
+ window, // view
+ 1, // detail
+ touch.screenX, // screenX
+ touch.screenY, // screenY
+ touch.clientX, // clientX
+ touch.clientY, // clientY
+ false, // ctrlKey
+ false, // altKey
+ false, // shiftKey
+ false, // metaKey
+ 0, // button
+ null // relatedTarget
+ );
+
+ // Dispatch the simulated event to the target element
+ event.target.dispatchEvent(simulatedEvent);
+ }
+
+ /**
+ * Handle the jQuery UI widget's touchstart events
+ * @param {Object} event The widget element's touchstart event
+ */
+ mouseProto._touchStart = function (event) {
+
+ var self = this;
+
+ // Ignore the event if another widget is already being handled
+ if (touchHandled || !self._mouseCapture(event.originalEvent.changedTouches[0])) {
+ return;
+ }
+
+ // Set the flag to prevent other widgets from inheriting the touch event
+ touchHandled = true;
+
+ // Track movement to determine if interaction was a click
+ self._touchMoved = false;
+
+ // Simulate the mouseover event
+ simulateMouseEvent(event, 'mouseover');
+
+ // Simulate the mousemove event
+ simulateMouseEvent(event, 'mousemove');
+
+ // Simulate the mousedown event
+ simulateMouseEvent(event, 'mousedown');
+ };
+
+ /**
+ * Handle the jQuery UI widget's touchmove events
+ * @param {Object} event The document's touchmove event
+ */
+ mouseProto._touchMove = function (event) {
+
+ // Ignore event if not handled
+ if (!touchHandled) {
+ return;
+ }
+
+ // Interaction was not a click
+ this._touchMoved = true;
+
+ // Simulate the mousemove event
+ simulateMouseEvent(event, 'mousemove');
+ };
+
+ /**
+ * Handle the jQuery UI widget's touchend events
+ * @param {Object} event The document's touchend event
+ */
+ mouseProto._touchEnd = function (event) {
+
+ // Ignore event if not handled
+ if (!touchHandled) {
+ return;
+ }
+
+ // Simulate the mouseup event
+ simulateMouseEvent(event, 'mouseup');
+
+ // Simulate the mouseout event
+ simulateMouseEvent(event, 'mouseout');
+
+ // If the touch interaction did not move, it should trigger a click
+ if (!this._touchMoved) {
+
+ // Simulate the click event
+ simulateMouseEvent(event, 'click');
+ }
+
+ // Unset the flag to allow other widgets to inherit the touch event
+ touchHandled = false;
+ };
+
+ /**
+ * A duck punch of the $.ui.mouse _mouseInit method to support touch events.
+ * This method extends the widget with bound touch event handlers that
+ * translate touch events to mouse events and pass them to the widget's
+ * original mouse event handling methods.
+ */
+ mouseProto._mouseInit = function () {
+
+ var self = this;
+
+ // Delegate the touch handlers to the widget's element
+ self.element.bind({
+ touchstart: $.proxy(self, '_touchStart'),
+ touchmove: $.proxy(self, '_touchMove'),
+ touchend: $.proxy(self, '_touchEnd')
+ });
+
+ // Call the original $.ui.mouse init method
+ _mouseInit.call(self);
+ };
+
+ /**
+ * Remove the touch event handlers
+ */
+ mouseProto._mouseDestroy = function () {
+
+ var self = this;
+
+ // Delegate the touch handlers to the widget's element
+ self.element.unbind({
+ touchstart: $.proxy(self, '_touchStart'),
+ touchmove: $.proxy(self, '_touchMove'),
+ touchend: $.proxy(self, '_touchEnd')
+ });
+
+ // Call the original $.ui.mouse destroy method
+ _mouseDestroy.call(self);
+ };
+
+})(jQuery);
+/*
+ * SmartMenus jQuery v1.1.0
+ * http://www.smartmenus.org/
+ *
+ * Copyright Vasil Dinkov, Vadikom Web Ltd.
+ * http://vadikom.com/
+ *
+ * Released under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+
+(function (factory) {
+ if (typeof define === 'function' && define.amd) {
+ // AMD
+ define(['jquery'], factory);
+ } else if (typeof module === 'object' && typeof module.exports === 'object') {
+ // CommonJS
+ module.exports = factory(require('jquery'));
+ } else {
+ // Global jQuery
+ factory(jQuery);
+ }
+}(function ($) {
+
+ var menuTrees = [],
+ mouse = false, // optimize for touch by default - we will detect for mouse input
+ touchEvents = 'ontouchstart' in window, // we use this just to choose between toucn and pointer events, not for touch screen detection
+ mouseDetectionEnabled = false,
+ requestAnimationFrame = window.requestAnimationFrame || function (callback) { return setTimeout(callback, 1000 / 60); },
+ cancelAnimationFrame = window.cancelAnimationFrame || function (id) { clearTimeout(id); },
+ canAnimate = !!$.fn.animate;
+
+ // Handle detection for mouse input (i.e. desktop browsers, tablets with a mouse, etc.)
+ function initMouseDetection(disable) {
+ var eNS = '.smartmenus_mouse';
+ if (!mouseDetectionEnabled && !disable) {
+ // if we get two consecutive mousemoves within 2 pixels from each other and within 300ms, we assume a real mouse/cursor is present
+ // in practice, this seems like impossible to trick unintentianally with a real mouse and a pretty safe detection on touch devices (even with older browsers that do not support touch events)
+ var firstTime = true,
+ lastMove = null,
+ events = {
+ 'mousemove': function (e) {
+ var thisMove = { x: e.pageX, y: e.pageY, timeStamp: new Date().getTime() };
+ if (lastMove) {
+ var deltaX = Math.abs(lastMove.x - thisMove.x),
+ deltaY = Math.abs(lastMove.y - thisMove.y);
+ if ((deltaX > 0 || deltaY > 0) && deltaX <= 2 && deltaY <= 2 && thisMove.timeStamp - lastMove.timeStamp <= 300) {
+ mouse = true;
+ // if this is the first check after page load, check if we are not over some item by chance and call the mouseenter handler if yes
+ if (firstTime) {
+ var $a = $(e.target).closest('a');
+ if ($a.is('a')) {
+ $.each(menuTrees, function () {
+ if ($.contains(this.$root[0], $a[0])) {
+ this.itemEnter({ currentTarget: $a[0] });
+ return false;
+ }
+ });
+ }
+ firstTime = false;
+ }
+ }
+ }
+ lastMove = thisMove;
+ }
+ };
+ events[touchEvents ? 'touchstart' : 'pointerover pointermove pointerout MSPointerOver MSPointerMove MSPointerOut'] = function (e) {
+ if (isTouchEvent(e.originalEvent)) {
+ mouse = false;
+ }
+ };
+ $(document).on(getEventsNS(events, eNS));
+ mouseDetectionEnabled = true;
+ } else if (mouseDetectionEnabled && disable) {
+ $(document).off(eNS);
+ mouseDetectionEnabled = false;
+ }
+ }
+
+ function isTouchEvent(e) {
+ return !/^(4|mouse)$/.test(e.pointerType);
+ }
+
+ // returns a jQuery on() ready object
+ function getEventsNS(events, eNS) {
+ if (!eNS) {
+ eNS = '';
+ }
+ var eventsNS = {};
+ for (var i in events) {
+ eventsNS[i.split(' ').join(eNS + ' ') + eNS] = events[i];
+ }
+ return eventsNS;
+ }
+
+ $.SmartMenus = function (elm, options) {
+ this.$root = $(elm);
+ this.opts = options;
+ this.rootId = ''; // internal
+ this.accessIdPrefix = '';
+ this.$subArrow = null;
+ this.activatedItems = []; // stores last activated A's for each level
+ this.visibleSubMenus = []; // stores visible sub menus UL's (might be in no particular order)
+ this.showTimeout = 0;
+ this.hideTimeout = 0;
+ this.scrollTimeout = 0;
+ this.clickActivated = false;
+ this.focusActivated = false;
+ this.zIndexInc = 0;
+ this.idInc = 0;
+ this.$firstLink = null; // we'll use these for some tests
+ this.$firstSub = null; // at runtime so we'll cache them
+ this.disabled = false;
+ this.$disableOverlay = null;
+ this.$touchScrollingSub = null;
+ this.cssTransforms3d = 'perspective' in elm.style || 'webkitPerspective' in elm.style;
+ this.wasCollapsible = false;
+ this.init();
+ };
+
+ $.extend($.SmartMenus, {
+ hideAll: function () {
+ $.each(menuTrees, function () {
+ this.menuHideAll();
+ });
+ },
+ destroy: function () {
+ while (menuTrees.length) {
+ menuTrees[0].destroy();
+ }
+ initMouseDetection(true);
+ },
+ prototype: {
+ init: function (refresh) {
+ var self = this;
+
+ if (!refresh) {
+ menuTrees.push(this);
+
+ this.rootId = (new Date().getTime() + Math.random() + '').replace(/\D/g, '');
+ this.accessIdPrefix = 'sm-' + this.rootId + '-';
+
+ if (this.$root.hasClass('sm-rtl')) {
+ this.opts.rightToLeftSubMenus = true;
+ }
+
+ // init root (main menu)
+ var eNS = '.smartmenus';
+ this.$root
+ .data('smartmenus', this)
+ .attr('data-smartmenus-id', this.rootId)
+ .dataSM('level', 1)
+ .on(getEventsNS({
+ 'mouseover focusin': $.proxy(this.rootOver, this),
+ 'mouseout focusout': $.proxy(this.rootOut, this),
+ 'keydown': $.proxy(this.rootKeyDown, this)
+ }, eNS))
+ .on(getEventsNS({
+ 'mouseenter': $.proxy(this.itemEnter, this),
+ 'mouseleave': $.proxy(this.itemLeave, this),
+ 'mousedown': $.proxy(this.itemDown, this),
+ 'focus': $.proxy(this.itemFocus, this),
+ 'blur': $.proxy(this.itemBlur, this),
+ 'click': $.proxy(this.itemClick, this)
+ }, eNS), 'a');
+
+ // hide menus on tap or click outside the root UL
+ eNS += this.rootId;
+ if (this.opts.hideOnClick) {
+ $(document).on(getEventsNS({
+ 'touchstart': $.proxy(this.docTouchStart, this),
+ 'touchmove': $.proxy(this.docTouchMove, this),
+ 'touchend': $.proxy(this.docTouchEnd, this),
+ // for Opera Mobile < 11.5, webOS browser, etc. we'll check click too
+ 'click': $.proxy(this.docClick, this)
+ }, eNS));
+ }
+ // hide sub menus on resize
+ $(window).on(getEventsNS({ 'resize orientationchange': $.proxy(this.winResize, this) }, eNS));
+
+ if (this.opts.subIndicators) {
+ this.$subArrow = $('<span/>').addClass('sub-arrow');
+ if (this.opts.subIndicatorsText) {
+ this.$subArrow.html(this.opts.subIndicatorsText);
+ }
+ }
+
+ // make sure mouse detection is enabled
+ initMouseDetection();
+ }
+
+ // init sub menus
+ this.$firstSub = this.$root.find('ul').each(function () { self.menuInit($(this)); }).eq(0);
+
+ this.$firstLink = this.$root.find('a').eq(0);
+
+ // find current item
+ if (this.opts.markCurrentItem) {
+ var reDefaultDoc = /(index|default)\.[^#\?\/]*/i,
+ reHash = /#.*/,
+ locHref = window.location.href.replace(reDefaultDoc, ''),
+ locHrefNoHash = locHref.replace(reHash, '');
+ this.$root.find('a').each(function () {
+ var href = this.href.replace(reDefaultDoc, ''),
+ $this = $(this);
+ if (href == locHref || href == locHrefNoHash) {
+ $this.addClass('current');
+ if (self.opts.markCurrentTree) {
+ $this.parentsUntil('[data-smartmenus-id]', 'ul').each(function () {
+ $(this).dataSM('parent-a').addClass('current');
+ });
+ }
+ }
+ });
+ }
+
+ // save initial state
+ this.wasCollapsible = this.isCollapsible();
+ },
+ destroy: function (refresh) {
+ if (!refresh) {
+ var eNS = '.smartmenus';
+ this.$root
+ .removeData('smartmenus')
+ .removeAttr('data-smartmenus-id')
+ .removeDataSM('level')
+ .off(eNS);
+ eNS += this.rootId;
+ $(document).off(eNS);
+ $(window).off(eNS);
+ if (this.opts.subIndicators) {
+ this.$subArrow = null;
+ }
+ }
+ this.menuHideAll();
+ var self = this;
+ this.$root.find('ul').each(function () {
+ var $this = $(this);
+ if ($this.dataSM('scroll-arrows')) {
+ $this.dataSM('scroll-arrows').remove();
+ }
+ if ($this.dataSM('shown-before')) {
+ if (self.opts.subMenusMinWidth || self.opts.subMenusMaxWidth) {
+ $this.css({ width: '', minWidth: '', maxWidth: '' }).removeClass('sm-nowrap');
+ }
+ if ($this.dataSM('scroll-arrows')) {
+ $this.dataSM('scroll-arrows').remove();
+ }
+ $this.css({ zIndex: '', top: '', left: '', marginLeft: '', marginTop: '', display: '' });
+ }
+ if (($this.attr('id') || '').indexOf(self.accessIdPrefix) == 0) {
+ $this.removeAttr('id');
+ }
+ })
+ .removeDataSM('in-mega')
+ .removeDataSM('shown-before')
+ .removeDataSM('scroll-arrows')
+ .removeDataSM('parent-a')
+ .removeDataSM('level')
+ .removeDataSM('beforefirstshowfired')
+ .removeAttr('role')
+ .removeAttr('aria-hidden')
+ .removeAttr('aria-labelledby')
+ .removeAttr('aria-expanded');
+ this.$root.find('a.has-submenu').each(function () {
+ var $this = $(this);
+ if ($this.attr('id').indexOf(self.accessIdPrefix) == 0) {
+ $this.removeAttr('id');
+ }
+ })
+ .removeClass('has-submenu')
+ .removeDataSM('sub')
+ .removeAttr('aria-haspopup')
+ .removeAttr('aria-controls')
+ .removeAttr('aria-expanded')
+ .closest('li').removeDataSM('sub');
+ if (this.opts.subIndicators) {
+ this.$root.find('span.sub-arrow').remove();
+ }
+ if (this.opts.markCurrentItem) {
+ this.$root.find('a.current').removeClass('current');
+ }
+ if (!refresh) {
+ this.$root = null;
+ this.$firstLink = null;
+ this.$firstSub = null;
+ if (this.$disableOverlay) {
+ this.$disableOverlay.remove();
+ this.$disableOverlay = null;
+ }
+ menuTrees.splice($.inArray(this, menuTrees), 1);
+ }
+ },
+ disable: function (noOverlay) {
+ if (!this.disabled) {
+ this.menuHideAll();
+ // display overlay over the menu to prevent interaction
+ if (!noOverlay && !this.opts.isPopup && this.$root.is(':visible')) {
+ var pos = this.$root.offset();
+ this.$disableOverlay = $('<div class="sm-jquery-disable-overlay"/>').css({
+ position: 'absolute',
+ top: pos.top,
+ left: pos.left,
+ width: this.$root.outerWidth(),
+ height: this.$root.outerHeight(),
+ zIndex: this.getStartZIndex(true),
+ opacity: 0
+ }).appendTo(document.body);
+ }
+ this.disabled = true;
+ }
+ },
+ docClick: function (e) {
+ if (this.$touchScrollingSub) {
+ this.$touchScrollingSub = null;
+ return;
+ }
+ // hide on any click outside the menu or on a menu link
+ if (this.visibleSubMenus.length && !$.contains(this.$root[0], e.target) || $(e.target).closest('a').length) {
+ this.menuHideAll();
+ }
+ },
+ docTouchEnd: function (e) {
+ if (!this.lastTouch) {
+ return;
+ }
+ if (this.visibleSubMenus.length && (this.lastTouch.x2 === undefined || this.lastTouch.x1 == this.lastTouch.x2) && (this.lastTouch.y2 === undefined || this.lastTouch.y1 == this.lastTouch.y2) && (!this.lastTouch.target || !$.contains(this.$root[0], this.lastTouch.target))) {
+ if (this.hideTimeout) {
+ clearTimeout(this.hideTimeout);
+ this.hideTimeout = 0;
+ }
+ // hide with a delay to prevent triggering accidental unwanted click on some page element
+ var self = this;
+ this.hideTimeout = setTimeout(function () { self.menuHideAll(); }, 350);
+ }
+ this.lastTouch = null;
+ },
+ docTouchMove: function (e) {
+ if (!this.lastTouch) {
+ return;
+ }
+ var touchPoint = e.originalEvent.touches[0];
+ this.lastTouch.x2 = touchPoint.pageX;
+ this.lastTouch.y2 = touchPoint.pageY;
+ },
+ docTouchStart: function (e) {
+ var touchPoint = e.originalEvent.touches[0];
+ this.lastTouch = { x1: touchPoint.pageX, y1: touchPoint.pageY, target: touchPoint.target };
+ },
+ enable: function () {
+ if (this.disabled) {
+ if (this.$disableOverlay) {
+ this.$disableOverlay.remove();
+ this.$disableOverlay = null;
+ }
+ this.disabled = false;
+ }
+ },
+ getClosestMenu: function (elm) {
+ var $closestMenu = $(elm).closest('ul');
+ while ($closestMenu.dataSM('in-mega')) {
+ $closestMenu = $closestMenu.parent().closest('ul');
+ }
+ return $closestMenu[0] || null;
+ },
+ getHeight: function ($elm) {
+ return this.getOffset($elm, true);
+ },
+ // returns precise width/height float values
+ getOffset: function ($elm, height) {
+ var old;
+ if ($elm.css('display') == 'none') {
+ old = { position: $elm[0].style.position, visibility: $elm[0].style.visibility };
+ $elm.css({ position: 'absolute', visibility: 'hidden' }).show();
+ }
+ var box = $elm[0].getBoundingClientRect && $elm[0].getBoundingClientRect(),
+ val = box && (height ? box.height || box.bottom - box.top : box.width || box.right - box.left);
+ if (!val && val !== 0) {
+ val = height ? $elm[0].offsetHeight : $elm[0].offsetWidth;
+ }
+ if (old) {
+ $elm.hide().css(old);
+ }
+ return val;
+ },
+ getStartZIndex: function (root) {
+ var zIndex = parseInt(this[root ? '$root' : '$firstSub'].css('z-index'));
+ if (!root && isNaN(zIndex)) {
+ zIndex = parseInt(this.$root.css('z-index'));
+ }
+ return !isNaN(zIndex) ? zIndex : 1;
+ },
+ getTouchPoint: function (e) {
+ return e.touches && e.touches[0] || e.changedTouches && e.changedTouches[0] || e;
+ },
+ getViewport: function (height) {
+ var name = height ? 'Height' : 'Width',
+ val = document.documentElement['client' + name],
+ val2 = window['inner' + name];
+ if (val2) {
+ val = Math.min(val, val2);
+ }
+ return val;
+ },
+ getViewportHeight: function () {
+ return this.getViewport(true);
+ },
+ getViewportWidth: function () {
+ return this.getViewport();
+ },
+ getWidth: function ($elm) {
+ return this.getOffset($elm);
+ },
+ handleEvents: function () {
+ return !this.disabled && this.isCSSOn();
+ },
+ handleItemEvents: function ($a) {
+ return this.handleEvents() && !this.isLinkInMegaMenu($a);
+ },
+ isCollapsible: function () {
+ return this.$firstSub.css('position') == 'static';
+ },
+ isCSSOn: function () {
+ return this.$firstLink.css('display') != 'inline';
+ },
+ isFixed: function () {
+ var isFixed = this.$root.css('position') == 'fixed';
+ if (!isFixed) {
+ this.$root.parentsUntil('body').each(function () {
+ if ($(this).css('position') == 'fixed') {
+ isFixed = true;
+ return false;
+ }
+ });
+ }
+ return isFixed;
+ },
+ isLinkInMegaMenu: function ($a) {
+ return $(this.getClosestMenu($a[0])).hasClass('mega-menu');
+ },
+ isTouchMode: function () {
+ return !mouse || this.opts.noMouseOver || this.isCollapsible();
+ },
+ itemActivate: function ($a, hideDeeperSubs) {
+ var $ul = $a.closest('ul'),
+ level = $ul.dataSM('level');
+ // if for some reason the parent item is not activated (e.g. this is an API call to activate the item), activate all parent items first
+ if (level > 1 && (!this.activatedItems[level - 2] || this.activatedItems[level - 2][0] != $ul.dataSM('parent-a')[0])) {
+ var self = this;
+ $($ul.parentsUntil('[data-smartmenus-id]', 'ul').get().reverse()).add($ul).each(function () {
+ self.itemActivate($(this).dataSM('parent-a'));
+ });
+ }
+ // hide any visible deeper level sub menus
+ if (!this.isCollapsible() || hideDeeperSubs) {
+ this.menuHideSubMenus(!this.activatedItems[level - 1] || this.activatedItems[level - 1][0] != $a[0] ? level - 1 : level);
+ }
+ // save new active item for this level
+ this.activatedItems[level - 1] = $a;
+ if (this.$root.triggerHandler('activate.smapi', $a[0]) === false) {
+ return;
+ }
+ // show the sub menu if this item has one
+ var $sub = $a.dataSM('sub');
+ if ($sub && (this.isTouchMode() || (!this.opts.showOnClick || this.clickActivated))) {
+ this.menuShow($sub);
+ }
+ },
+ itemBlur: function (e) {
+ var $a = $(e.currentTarget);
+ if (!this.handleItemEvents($a)) {
+ return;
+ }
+ this.$root.triggerHandler('blur.smapi', $a[0]);
+ },
+ itemClick: function (e) {
+ var $a = $(e.currentTarget);
+ if (!this.handleItemEvents($a)) {
+ return;
+ }
+ if (this.$touchScrollingSub && this.$touchScrollingSub[0] == $a.closest('ul')[0]) {
+ this.$touchScrollingSub = null;
+ e.stopPropagation();
+ return false;
+ }
+ if (this.$root.triggerHandler('click.smapi', $a[0]) === false) {
+ return false;
+ }
+ var subArrowClicked = $(e.target).is('.sub-arrow'),
+ $sub = $a.dataSM('sub'),
+ firstLevelSub = $sub ? $sub.dataSM('level') == 2 : false,
+ collapsible = this.isCollapsible(),
+ behaviorToggle = /toggle$/.test(this.opts.collapsibleBehavior),
+ behaviorLink = /link$/.test(this.opts.collapsibleBehavior),
+ behaviorAccordion = /^accordion/.test(this.opts.collapsibleBehavior);
+ // if the sub is hidden, try to show it
+ if ($sub && !$sub.is(':visible')) {
+ if (!behaviorLink || !collapsible || subArrowClicked) {
+ if (this.opts.showOnClick && firstLevelSub) {
+ this.clickActivated = true;
+ }
+ // try to activate the item and show the sub
+ this.itemActivate($a, behaviorAccordion);
+ // if "itemActivate" showed the sub, prevent the click so that the link is not loaded
+ // if it couldn't show it, then the sub menus are disabled with an !important declaration (e.g. via mobile styles) so let the link get loaded
+ if ($sub.is(':visible')) {
+ this.focusActivated = true;
+ return false;
+ }
+ }
+ // if the sub is visible and we are in collapsible mode
+ } else if (collapsible && (behaviorToggle || subArrowClicked)) {
+ this.itemActivate($a, behaviorAccordion);
+ this.menuHide($sub);
+ if (behaviorToggle) {
+ this.focusActivated = false;
+ }
+ return false;
+ }
+ if (this.opts.showOnClick && firstLevelSub || $a.hasClass('disabled') || this.$root.triggerHandler('select.smapi', $a[0]) === false) {
+ return false;
+ }
+ },
+ itemDown: function (e) {
+ var $a = $(e.currentTarget);
+ if (!this.handleItemEvents($a)) {
+ return;
+ }
+ $a.dataSM('mousedown', true);
+ },
+ itemEnter: function (e) {
+ var $a = $(e.currentTarget);
+ if (!this.handleItemEvents($a)) {
+ return;
+ }
+ if (!this.isTouchMode()) {
+ if (this.showTimeout) {
+ clearTimeout(this.showTimeout);
+ this.showTimeout = 0;
+ }
+ var self = this;
+ this.showTimeout = setTimeout(function () { self.itemActivate($a); }, this.opts.showOnClick && $a.closest('ul').dataSM('level') == 1 ? 1 : this.opts.showTimeout);
+ }
+ this.$root.triggerHandler('mouseenter.smapi', $a[0]);
+ },
+ itemFocus: function (e) {
+ var $a = $(e.currentTarget);
+ if (!this.handleItemEvents($a)) {
+ return;
+ }
+ // fix (the mousedown check): in some browsers a tap/click produces consecutive focus + click events so we don't need to activate the item on focus
+ if (this.focusActivated && (!this.isTouchMode() || !$a.dataSM('mousedown')) && (!this.activatedItems.length || this.activatedItems[this.activatedItems.length - 1][0] != $a[0])) {
+ this.itemActivate($a, true);
+ }
+ this.$root.triggerHandler('focus.smapi', $a[0]);
+ },
+ itemLeave: function (e) {
+ var $a = $(e.currentTarget);
+ if (!this.handleItemEvents($a)) {
+ return;
+ }
+ if (!this.isTouchMode()) {
+ $a[0].blur();
+ if (this.showTimeout) {
+ clearTimeout(this.showTimeout);
+ this.showTimeout = 0;
+ }
+ }
+ $a.removeDataSM('mousedown');
+ this.$root.triggerHandler('mouseleave.smapi', $a[0]);
+ },
+ menuHide: function ($sub) {
+ if (this.$root.triggerHandler('beforehide.smapi', $sub[0]) === false) {
+ return;
+ }
+ if (canAnimate) {
+ $sub.stop(true, true);
+ }
+ if ($sub.css('display') != 'none') {
+ var complete = function () {
+ // unset z-index
+ $sub.css('z-index', '');
+ };
+ // if sub is collapsible (mobile view)
+ if (this.isCollapsible()) {
+ if (canAnimate && this.opts.collapsibleHideFunction) {
+ this.opts.collapsibleHideFunction.call(this, $sub, complete);
+ } else {
+ $sub.hide(this.opts.collapsibleHideDuration, complete);
+ }
+ } else {
+ if (canAnimate && this.opts.hideFunction) {
+ this.opts.hideFunction.call(this, $sub, complete);
+ } else {
+ $sub.hide(this.opts.hideDuration, complete);
+ }
+ }
+ // deactivate scrolling if it is activated for this sub
+ if ($sub.dataSM('scroll')) {
+ this.menuScrollStop($sub);
+ $sub.css({ 'touch-action': '', '-ms-touch-action': '', '-webkit-transform': '', transform: '' })
+ .off('.smartmenus_scroll').removeDataSM('scroll').dataSM('scroll-arrows').hide();
+ }
+ // unhighlight parent item + accessibility
+ $sub.dataSM('parent-a').removeClass('highlighted').attr('aria-expanded', 'false');
+ $sub.attr({
+ 'aria-expanded': 'false',
+ 'aria-hidden': 'true'
+ });
+ var level = $sub.dataSM('level');
+ this.activatedItems.splice(level - 1, 1);
+ this.visibleSubMenus.splice($.inArray($sub, this.visibleSubMenus), 1);
+ this.$root.triggerHandler('hide.smapi', $sub[0]);
+ }
+ },
+ menuHideAll: function () {
+ if (this.showTimeout) {
+ clearTimeout(this.showTimeout);
+ this.showTimeout = 0;
+ }
+ // hide all subs
+ // if it's a popup, this.visibleSubMenus[0] is the root UL
+ var level = this.opts.isPopup ? 1 : 0;
+ for (var i = this.visibleSubMenus.length - 1; i >= level; i--) {
+ this.menuHide(this.visibleSubMenus[i]);
+ }
+ // hide root if it's popup
+ if (this.opts.isPopup) {
+ if (canAnimate) {
+ this.$root.stop(true, true);
+ }
+ if (this.$root.is(':visible')) {
+ if (canAnimate && this.opts.hideFunction) {
+ this.opts.hideFunction.call(this, this.$root);
+ } else {
+ this.$root.hide(this.opts.hideDuration);
+ }
+ }
+ }
+ this.activatedItems = [];
+ this.visibleSubMenus = [];
+ this.clickActivated = false;
+ this.focusActivated = false;
+ // reset z-index increment
+ this.zIndexInc = 0;
+ this.$root.triggerHandler('hideAll.smapi');
+ },
+ menuHideSubMenus: function (level) {
+ for (var i = this.activatedItems.length - 1; i >= level; i--) {
+ var $sub = this.activatedItems[i].dataSM('sub');
+ if ($sub) {
+ this.menuHide($sub);
+ }
+ }
+ },
+ menuInit: function ($ul) {
+ if (!$ul.dataSM('in-mega')) {
+ // mark UL's in mega drop downs (if any) so we can neglect them
+ if ($ul.hasClass('mega-menu')) {
+ $ul.find('ul').dataSM('in-mega', true);
+ }
+ // get level (much faster than, for example, using parentsUntil)
+ var level = 2,
+ par = $ul[0];
+ while ((par = par.parentNode.parentNode) != this.$root[0]) {
+ level++;
+ }
+ // cache stuff for quick access
+ var $a = $ul.prevAll('a').eq(-1);
+ // if the link is nested (e.g. in a heading)
+ if (!$a.length) {
+ $a = $ul.prevAll().find('a').eq(-1);
+ }
+ $a.addClass('has-submenu').dataSM('sub', $ul);
+ $ul.dataSM('parent-a', $a)
+ .dataSM('level', level)
+ .parent().dataSM('sub', $ul);
+ // accessibility
+ var aId = $a.attr('id') || this.accessIdPrefix + (++this.idInc),
+ ulId = $ul.attr('id') || this.accessIdPrefix + (++this.idInc);
+ $a.attr({
+ id: aId,
+ 'aria-haspopup': 'true',
+ 'aria-controls': ulId,
+ 'aria-expanded': 'false'
+ });
+ $ul.attr({
+ id: ulId,
+ 'role': 'group',
+ 'aria-hidden': 'true',
+ 'aria-labelledby': aId,
+ 'aria-expanded': 'false'
+ });
+ // add sub indicator to parent item
+ if (this.opts.subIndicators) {
+ $a[this.opts.subIndicatorsPos](this.$subArrow.clone());
+ }
+ }
+ },
+ menuPosition: function ($sub) {
+ var $a = $sub.dataSM('parent-a'),
+ $li = $a.closest('li'),
+ $ul = $li.parent(),
+ level = $sub.dataSM('level'),
+ subW = this.getWidth($sub),
+ subH = this.getHeight($sub),
+ itemOffset = $a.offset(),
+ itemX = itemOffset.left,
+ itemY = itemOffset.top,
+ itemW = this.getWidth($a),
+ itemH = this.getHeight($a),
+ $win = $(window),
+ winX = $win.scrollLeft(),
+ winY = $win.scrollTop(),
+ winW = this.getViewportWidth(),
+ winH = this.getViewportHeight(),
+ horizontalParent = $ul.parent().is('[data-sm-horizontal-sub]') || level == 2 && !$ul.hasClass('sm-vertical'),
+ rightToLeft = this.opts.rightToLeftSubMenus && !$li.is('[data-sm-reverse]') || !this.opts.rightToLeftSubMenus && $li.is('[data-sm-reverse]'),
+ subOffsetX = level == 2 ? this.opts.mainMenuSubOffsetX : this.opts.subMenusSubOffsetX,
+ subOffsetY = level == 2 ? this.opts.mainMenuSubOffsetY : this.opts.subMenusSubOffsetY,
+ x, y;
+ if (horizontalParent) {
+ x = rightToLeft ? itemW - subW - subOffsetX : subOffsetX;
+ y = this.opts.bottomToTopSubMenus ? -subH - subOffsetY : itemH + subOffsetY;
+ } else {
+ x = rightToLeft ? subOffsetX - subW : itemW - subOffsetX;
+ y = this.opts.bottomToTopSubMenus ? itemH - subOffsetY - subH : subOffsetY;
+ }
+ if (this.opts.keepInViewport) {
+ var absX = itemX + x,
+ absY = itemY + y;
+ if (rightToLeft && absX < winX) {
+ x = horizontalParent ? winX - absX + x : itemW - subOffsetX;
+ } else if (!rightToLeft && absX + subW > winX + winW) {
+ x = horizontalParent ? winX + winW - subW - absX + x : subOffsetX - subW;
+ }
+ if (!horizontalParent) {
+ if (subH < winH && absY + subH > winY + winH) {
+ y += winY + winH - subH - absY;
+ } else if (subH >= winH || absY < winY) {
+ y += winY - absY;
+ }
+ }
+ // do we need scrolling?
+ // 0.49 used for better precision when dealing with float values
+ if (horizontalParent && (absY + subH > winY + winH + 0.49 || absY < winY) || !horizontalParent && subH > winH + 0.49) {
+ var self = this;
+ if (!$sub.dataSM('scroll-arrows')) {
+ $sub.dataSM('scroll-arrows', $([$('<span class="scroll-up"><span class="scroll-up-arrow"></span></span>')[0], $('<span class="scroll-down"><span class="scroll-down-arrow"></span></span>')[0]])
+ .on({
+ mouseenter: function () {
+ $sub.dataSM('scroll').up = $(this).hasClass('scroll-up');
+ self.menuScroll($sub);
+ },
+ mouseleave: function (e) {
+ self.menuScrollStop($sub);
+ self.menuScrollOut($sub, e);
+ },
+ 'mousewheel DOMMouseScroll': function (e) { e.preventDefault(); }
+ })
+ .insertAfter($sub)
+ );
+ }
+ // bind scroll events and save scroll data for this sub
+ var eNS = '.smartmenus_scroll';
+ $sub.dataSM('scroll', {
+ y: this.cssTransforms3d ? 0 : y - itemH,
+ step: 1,
+ // cache stuff for faster recalcs later
+ itemH: itemH,
+ subH: subH,
+ arrowDownH: this.getHeight($sub.dataSM('scroll-arrows').eq(1))
+ })
+ .on(getEventsNS({
+ 'mouseover': function (e) { self.menuScrollOver($sub, e); },
+ 'mouseout': function (e) { self.menuScrollOut($sub, e); },
+ 'mousewheel DOMMouseScroll': function (e) { self.menuScrollMousewheel($sub, e); }
+ }, eNS))
+ .dataSM('scroll-arrows').css({ top: 'auto', left: '0', marginLeft: x + (parseInt($sub.css('border-left-width')) || 0), width: subW - (parseInt($sub.css('border-left-width')) || 0) - (parseInt($sub.css('border-right-width')) || 0), zIndex: $sub.css('z-index') })
+ .eq(horizontalParent && this.opts.bottomToTopSubMenus ? 0 : 1).show();
+ // when a menu tree is fixed positioned we allow scrolling via touch too
+ // since there is no other way to access such long sub menus if no mouse is present
+ if (this.isFixed()) {
+ var events = {};
+ events[touchEvents ? 'touchstart touchmove touchend' : 'pointerdown pointermove pointerup MSPointerDown MSPointerMove MSPointerUp'] = function (e) {
+ self.menuScrollTouch($sub, e);
+ };
+ $sub.css({ 'touch-action': 'none', '-ms-touch-action': 'none' }).on(getEventsNS(events, eNS));
+ }
+ }
+ }
+ $sub.css({ top: 'auto', left: '0', marginLeft: x, marginTop: y - itemH });
+ },
+ menuScroll: function ($sub, once, step) {
+ var data = $sub.dataSM('scroll'),
+ $arrows = $sub.dataSM('scroll-arrows'),
+ end = data.up ? data.upEnd : data.downEnd,
+ diff;
+ if (!once && data.momentum) {
+ data.momentum *= 0.92;
+ diff = data.momentum;
+ if (diff < 0.5) {
+ this.menuScrollStop($sub);
+ return;
+ }
+ } else {
+ diff = step || (once || !this.opts.scrollAccelerate ? this.opts.scrollStep : Math.floor(data.step));
+ }
+ // hide any visible deeper level sub menus
+ var level = $sub.dataSM('level');
+ if (this.activatedItems[level - 1] && this.activatedItems[level - 1].dataSM('sub') && this.activatedItems[level - 1].dataSM('sub').is(':visible')) {
+ this.menuHideSubMenus(level - 1);
+ }
+ data.y = data.up && end <= data.y || !data.up && end >= data.y ? data.y : (Math.abs(end - data.y) > diff ? data.y + (data.up ? diff : -diff) : end);
+ $sub.css(this.cssTransforms3d ? { '-webkit-transform': 'translate3d(0, ' + data.y + 'px, 0)', transform: 'translate3d(0, ' + data.y + 'px, 0)' } : { marginTop: data.y });
+ // show opposite arrow if appropriate
+ if (mouse && (data.up && data.y > data.downEnd || !data.up && data.y < data.upEnd)) {
+ $arrows.eq(data.up ? 1 : 0).show();
+ }
+ // if we've reached the end
+ if (data.y == end) {
+ if (mouse) {
+ $arrows.eq(data.up ? 0 : 1).hide();
+ }
+ this.menuScrollStop($sub);
+ } else if (!once) {
+ if (this.opts.scrollAccelerate && data.step < this.opts.scrollStep) {
+ data.step += 0.2;
+ }
+ var self = this;
+ this.scrollTimeout = requestAnimationFrame(function () { self.menuScroll($sub); });
+ }
+ },
+ menuScrollMousewheel: function ($sub, e) {
+ if (this.getClosestMenu(e.target) == $sub[0]) {
+ e = e.originalEvent;
+ var up = (e.wheelDelta || -e.detail) > 0;
+ if ($sub.dataSM('scroll-arrows').eq(up ? 0 : 1).is(':visible')) {
+ $sub.dataSM('scroll').up = up;
+ this.menuScroll($sub, true);
+ }
+ }
+ e.preventDefault();
+ },
+ menuScrollOut: function ($sub, e) {
+ if (mouse) {
+ if (!/^scroll-(up|down)/.test((e.relatedTarget || '').className) && ($sub[0] != e.relatedTarget && !$.contains($sub[0], e.relatedTarget) || this.getClosestMenu(e.relatedTarget) != $sub[0])) {
+ $sub.dataSM('scroll-arrows').css('visibility', 'hidden');
+ }
+ }
+ },
+ menuScrollOver: function ($sub, e) {
+ if (mouse) {
+ if (!/^scroll-(up|down)/.test(e.target.className) && this.getClosestMenu(e.target) == $sub[0]) {
+ this.menuScrollRefreshData($sub);
+ var data = $sub.dataSM('scroll'),
+ upEnd = $(window).scrollTop() - $sub.dataSM('parent-a').offset().top - data.itemH;
+ $sub.dataSM('scroll-arrows').eq(0).css('margin-top', upEnd).end()
+ .eq(1).css('margin-top', upEnd + this.getViewportHeight() - data.arrowDownH).end()
+ .css('visibility', 'visible');
+ }
+ }
+ },
+ menuScrollRefreshData: function ($sub) {
+ var data = $sub.dataSM('scroll'),
+ upEnd = $(window).scrollTop() - $sub.dataSM('parent-a').offset().top - data.itemH;
+ if (this.cssTransforms3d) {
+ upEnd = -(parseFloat($sub.css('margin-top')) - upEnd);
+ }
+ $.extend(data, {
+ upEnd: upEnd,
+ downEnd: upEnd + this.getViewportHeight() - data.subH
+ });
+ },
+ menuScrollStop: function ($sub) {
+ if (this.scrollTimeout) {
+ cancelAnimationFrame(this.scrollTimeout);
+ this.scrollTimeout = 0;
+ $sub.dataSM('scroll').step = 1;
+ return true;
+ }
+ },
+ menuScrollTouch: function ($sub, e) {
+ e = e.originalEvent;
+ if (isTouchEvent(e)) {
+ var touchPoint = this.getTouchPoint(e);
+ // neglect event if we touched a visible deeper level sub menu
+ if (this.getClosestMenu(touchPoint.target) == $sub[0]) {
+ var data = $sub.dataSM('scroll');
+ if (/(start|down)$/i.test(e.type)) {
+ if (this.menuScrollStop($sub)) {
+ // if we were scrolling, just stop and don't activate any link on the first touch
+ e.preventDefault();
+ this.$touchScrollingSub = $sub;
+ } else {
+ this.$touchScrollingSub = null;
+ }
+ // update scroll data since the user might have zoomed, etc.
+ this.menuScrollRefreshData($sub);
+ // extend it with the touch properties
+ $.extend(data, {
+ touchStartY: touchPoint.pageY,
+ touchStartTime: e.timeStamp
+ });
+ } else if (/move$/i.test(e.type)) {
+ var prevY = data.touchY !== undefined ? data.touchY : data.touchStartY;
+ if (prevY !== undefined && prevY != touchPoint.pageY) {
+ this.$touchScrollingSub = $sub;
+ var up = prevY < touchPoint.pageY;
+ // changed direction? reset...
+ if (data.up !== undefined && data.up != up) {
+ $.extend(data, {
+ touchStartY: touchPoint.pageY,
+ touchStartTime: e.timeStamp
+ });
+ }
+ $.extend(data, {
+ up: up,
+ touchY: touchPoint.pageY
+ });
+ this.menuScroll($sub, true, Math.abs(touchPoint.pageY - prevY));
+ }
+ e.preventDefault();
+ } else { // touchend/pointerup
+ if (data.touchY !== undefined) {
+ if (data.momentum = Math.pow(Math.abs(touchPoint.pageY - data.touchStartY) / (e.timeStamp - data.touchStartTime), 2) * 15) {
+ this.menuScrollStop($sub);
+ this.menuScroll($sub);
+ e.preventDefault();
+ }
+ delete data.touchY;
+ }
+ }
+ }
+ }
+ },
+ menuShow: function ($sub) {
+ if (!$sub.dataSM('beforefirstshowfired')) {
+ $sub.dataSM('beforefirstshowfired', true);
+ if (this.$root.triggerHandler('beforefirstshow.smapi', $sub[0]) === false) {
+ return;
+ }
+ }
+ if (this.$root.triggerHandler('beforeshow.smapi', $sub[0]) === false) {
+ return;
+ }
+ $sub.dataSM('shown-before', true);
+ if (canAnimate) {
+ $sub.stop(true, true);
+ }
+ if (!$sub.is(':visible')) {
+ // highlight parent item
+ var $a = $sub.dataSM('parent-a'),
+ collapsible = this.isCollapsible();
+ if (this.opts.keepHighlighted || collapsible) {
+ $a.addClass('highlighted');
+ }
+ if (collapsible) {
+ $sub.removeClass('sm-nowrap').css({ zIndex: '', width: 'auto', minWidth: '', maxWidth: '', top: '', left: '', marginLeft: '', marginTop: '' });
+ } else {
+ // set z-index
+ $sub.css('z-index', this.zIndexInc = (this.zIndexInc || this.getStartZIndex()) + 1);
+ // min/max-width fix - no way to rely purely on CSS as all UL's are nested
+ if (this.opts.subMenusMinWidth || this.opts.subMenusMaxWidth) {
+ $sub.css({ width: 'auto', minWidth: '', maxWidth: '' }).addClass('sm-nowrap');
+ if (this.opts.subMenusMinWidth) {
+ $sub.css('min-width', this.opts.subMenusMinWidth);
+ }
+ if (this.opts.subMenusMaxWidth) {
+ var noMaxWidth = this.getWidth($sub);
+ $sub.css('max-width', this.opts.subMenusMaxWidth);
+ if (noMaxWidth > this.getWidth($sub)) {
+ $sub.removeClass('sm-nowrap').css('width', this.opts.subMenusMaxWidth);
+ }
+ }
+ }
+ this.menuPosition($sub);
+ }
+ var complete = function () {
+ // fix: "overflow: hidden;" is not reset on animation complete in jQuery < 1.9.0 in Chrome when global "box-sizing: border-box;" is used
+ $sub.css('overflow', '');
+ };
+ // if sub is collapsible (mobile view)
+ if (collapsible) {
+ if (canAnimate && this.opts.collapsibleShowFunction) {
+ this.opts.collapsibleShowFunction.call(this, $sub, complete);
+ } else {
+ $sub.show(this.opts.collapsibleShowDuration, complete);
+ }
+ } else {
+ if (canAnimate && this.opts.showFunction) {
+ this.opts.showFunction.call(this, $sub, complete);
+ } else {
+ $sub.show(this.opts.showDuration, complete);
+ }
+ }
+ // accessibility
+ $a.attr('aria-expanded', 'true');
+ $sub.attr({
+ 'aria-expanded': 'true',
+ 'aria-hidden': 'false'
+ });
+ // store sub menu in visible array
+ this.visibleSubMenus.push($sub);
+ this.$root.triggerHandler('show.smapi', $sub[0]);
+ }
+ },
+ popupHide: function (noHideTimeout) {
+ if (this.hideTimeout) {
+ clearTimeout(this.hideTimeout);
+ this.hideTimeout = 0;
+ }
+ var self = this;
+ this.hideTimeout = setTimeout(function () {
+ self.menuHideAll();
+ }, noHideTimeout ? 1 : this.opts.hideTimeout);
+ },
+ popupShow: function (left, top) {
+ if (!this.opts.isPopup) {
+ alert('SmartMenus jQuery Error:\n\nIf you want to show this menu via the "popupShow" method, set the isPopup:true option.');
+ return;
+ }
+ if (this.hideTimeout) {
+ clearTimeout(this.hideTimeout);
+ this.hideTimeout = 0;
+ }
+ this.$root.dataSM('shown-before', true);
+ if (canAnimate) {
+ this.$root.stop(true, true);
+ }
+ if (!this.$root.is(':visible')) {
+ this.$root.css({ left: left, top: top });
+ // show menu
+ var self = this,
+ complete = function () {
+ self.$root.css('overflow', '');
+ };
+ if (canAnimate && this.opts.showFunction) {
+ this.opts.showFunction.call(this, this.$root, complete);
+ } else {
+ this.$root.show(this.opts.showDuration, complete);
+ }
+ this.visibleSubMenus[0] = this.$root;
+ }
+ },
+ refresh: function () {
+ this.destroy(true);
+ this.init(true);
+ },
+ rootKeyDown: function (e) {
+ if (!this.handleEvents()) {
+ return;
+ }
+ switch (e.keyCode) {
+ case 27: // reset on Esc
+ var $activeTopItem = this.activatedItems[0];
+ if ($activeTopItem) {
+ this.menuHideAll();
+ $activeTopItem[0].focus();
+ var $sub = $activeTopItem.dataSM('sub');
+ if ($sub) {
+ this.menuHide($sub);
+ }
+ }
+ break;
+ case 32: // activate item's sub on Space
+ var $target = $(e.target);
+ if ($target.is('a') && this.handleItemEvents($target)) {
+ var $sub = $target.dataSM('sub');
+ if ($sub && !$sub.is(':visible')) {
+ this.itemClick({ currentTarget: e.target });
+ e.preventDefault();
+ }
+ }
+ break;
+ }
+ },
+ rootOut: function (e) {
+ if (!this.handleEvents() || this.isTouchMode() || e.target == this.$root[0]) {
+ return;
+ }
+ if (this.hideTimeout) {
+ clearTimeout(this.hideTimeout);
+ this.hideTimeout = 0;
+ }
+ if (!this.opts.showOnClick || !this.opts.hideOnClick) {
+ var self = this;
+ this.hideTimeout = setTimeout(function () { self.menuHideAll(); }, this.opts.hideTimeout);
+ }
+ },
+ rootOver: function (e) {
+ if (!this.handleEvents() || this.isTouchMode() || e.target == this.$root[0]) {
+ return;
+ }
+ if (this.hideTimeout) {
+ clearTimeout(this.hideTimeout);
+ this.hideTimeout = 0;
+ }
+ },
+ winResize: function (e) {
+ if (!this.handleEvents()) {
+ // we still need to resize the disable overlay if it's visible
+ if (this.$disableOverlay) {
+ var pos = this.$root.offset();
+ this.$disableOverlay.css({
+ top: pos.top,
+ left: pos.left,
+ width: this.$root.outerWidth(),
+ height: this.$root.outerHeight()
+ });
+ }
+ return;
+ }
+ // hide sub menus on resize - on mobile do it only on orientation change
+ if (!('onorientationchange' in window) || e.type == 'orientationchange') {
+ var collapsible = this.isCollapsible();
+ // if it was collapsible before resize and still is, don't do it
+ if (!(this.wasCollapsible && collapsible)) {
+ if (this.activatedItems.length) {
+ this.activatedItems[this.activatedItems.length - 1][0].blur();
+ }
+ this.menuHideAll();
+ }
+ this.wasCollapsible = collapsible;
+ }
+ }
+ }
+ });
+
+ $.fn.dataSM = function (key, val) {
+ if (val) {
+ return this.data(key + '_smartmenus', val);
+ }
+ return this.data(key + '_smartmenus');
+ };
+
+ $.fn.removeDataSM = function (key) {
+ return this.removeData(key + '_smartmenus');
+ };
+
+ $.fn.smartmenus = function (options) {
+ if (typeof options == 'string') {
+ var args = arguments,
+ method = options;
+ Array.prototype.shift.call(args);
+ return this.each(function () {
+ var smartmenus = $(this).data('smartmenus');
+ if (smartmenus && smartmenus[method]) {
+ smartmenus[method].apply(smartmenus, args);
+ }
+ });
+ }
+ return this.each(function () {
+ // [data-sm-options] attribute on the root UL
+ var dataOpts = $(this).data('sm-options') || null;
+ if (dataOpts) {
+ try {
+ dataOpts = eval('(' + dataOpts + ')');
+ } catch (e) {
+ dataOpts = null;
+ alert('ERROR\n\nSmartMenus jQuery init:\nInvalid "data-sm-options" attribute value syntax.');
+ };
+ }
+ new $.SmartMenus(this, $.extend({}, $.fn.smartmenus.defaults, options, dataOpts));
+ });
+ };
+
+ // default settings
+ $.fn.smartmenus.defaults = {
+ isPopup: false, // is this a popup menu (can be shown via the popupShow/popupHide methods) or a permanent menu bar
+ mainMenuSubOffsetX: 0, // pixels offset from default position
+ mainMenuSubOffsetY: 0, // pixels offset from default position
+ subMenusSubOffsetX: 0, // pixels offset from default position
+ subMenusSubOffsetY: 0, // pixels offset from default position
+ subMenusMinWidth: '10em', // min-width for the sub menus (any CSS unit) - if set, the fixed width set in CSS will be ignored
+ subMenusMaxWidth: '20em', // max-width for the sub menus (any CSS unit) - if set, the fixed width set in CSS will be ignored
+ subIndicators: true, // create sub menu indicators - creates a SPAN and inserts it in the A
+ subIndicatorsPos: 'append', // position of the SPAN relative to the menu item content ('append', 'prepend')
+ subIndicatorsText: '', // [optionally] add text in the SPAN (e.g. '+') (you may want to check the CSS for the sub indicators too)
+ scrollStep: 30, // pixels step when scrolling long sub menus that do not fit in the viewport height
+ scrollAccelerate: true, // accelerate scrolling or use a fixed step
+ showTimeout: 250, // timeout before showing the sub menus
+ hideTimeout: 500, // timeout before hiding the sub menus
+ showDuration: 0, // duration for show animation - set to 0 for no animation - matters only if showFunction:null
+ showFunction: null, // custom function to use when showing a sub menu (the default is the jQuery 'show')
+ // don't forget to call complete() at the end of whatever you do
+ // e.g.: function($ul, complete) { $ul.fadeIn(250, complete); }
+ hideDuration: 0, // duration for hide animation - set to 0 for no animation - matters only if hideFunction:null
+ hideFunction: function ($ul, complete) { $ul.fadeOut(200, complete); }, // custom function to use when hiding a sub menu (the default is the jQuery 'hide')
+ // don't forget to call complete() at the end of whatever you do
+ // e.g.: function($ul, complete) { $ul.fadeOut(250, complete); }
+ collapsibleShowDuration: 0, // duration for show animation for collapsible sub menus - matters only if collapsibleShowFunction:null
+ collapsibleShowFunction: function ($ul, complete) { $ul.slideDown(200, complete); }, // custom function to use when showing a collapsible sub menu
+ // (i.e. when mobile styles are used to make the sub menus collapsible)
+ collapsibleHideDuration: 0, // duration for hide animation for collapsible sub menus - matters only if collapsibleHideFunction:null
+ collapsibleHideFunction: function ($ul, complete) { $ul.slideUp(200, complete); }, // custom function to use when hiding a collapsible sub menu
+ // (i.e. when mobile styles are used to make the sub menus collapsible)
+ showOnClick: false, // show the first-level sub menus onclick instead of onmouseover (i.e. mimic desktop app menus) (matters only for mouse input)
+ hideOnClick: true, // hide the sub menus on click/tap anywhere on the page
+ noMouseOver: false, // disable sub menus activation onmouseover (i.e. behave like in touch mode - use just mouse clicks) (matters only for mouse input)
+ keepInViewport: true, // reposition the sub menus if needed to make sure they always appear inside the viewport
+ keepHighlighted: true, // keep all ancestor items of the current sub menu highlighted (adds the 'highlighted' class to the A's)
+ markCurrentItem: false, // automatically add the 'current' class to the A element of the item linking to the current URL
+ markCurrentTree: true, // add the 'current' class also to the A elements of all ancestor items of the current item
+ rightToLeftSubMenus: false, // right to left display of the sub menus (check the CSS for the sub indicators' position)
+ bottomToTopSubMenus: false, // bottom to top display of the sub menus
+ collapsibleBehavior: 'default' // parent items behavior in collapsible (mobile) view ('default', 'toggle', 'link', 'accordion', 'accordion-toggle', 'accordion-link')
+ // 'default' - first tap on parent item expands sub, second tap loads its link
+ // 'toggle' - the whole parent item acts just as a toggle button for its sub menu (expands/collapses on each tap)
+ // 'link' - the parent item acts as a regular item (first tap loads its link), the sub menu can be expanded only via the +/- button
+ // 'accordion' - like 'default' but on expand also resets any visible sub menus from deeper levels or other branches
+ // 'accordion-toggle' - like 'toggle' but on expand also resets any visible sub menus from deeper levels or other branches
+ // 'accordion-link' - like 'link' but on expand also resets any visible sub menus from deeper levels or other branches
+ };
+
+ return $;
+}));
\ No newline at end of file
projects / nats.c.git / commitdiff