--- /dev/null
--- /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 $;
++}));
projects / nats.c.git / commitdiff