33657 lines
941 KiB
JavaScript
33657 lines
941 KiB
JavaScript
/*!
|
|
* jQuery JavaScript Library v3.2.1
|
|
* https://jquery.com/
|
|
*
|
|
* Includes Sizzle.js
|
|
* https://sizzlejs.com/
|
|
*
|
|
* Copyright JS Foundation and other contributors
|
|
* Released under the MIT license
|
|
* https://jquery.org/license
|
|
*
|
|
* Date: 2017-03-20T18:59Z
|
|
*/
|
|
|
|
( 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 document = window.document;
|
|
|
|
var getProto = Object.getPrototypeOf;
|
|
|
|
var slice = arr.slice;
|
|
|
|
var concat = arr.concat;
|
|
|
|
var push = arr.push;
|
|
|
|
var indexOf = arr.indexOf;
|
|
|
|
var class2type = {};
|
|
|
|
var toString = class2type.toString;
|
|
|
|
var hasOwn = class2type.hasOwnProperty;
|
|
|
|
var fnToString = hasOwn.toString;
|
|
|
|
var ObjectFunctionString = fnToString.call( Object );
|
|
|
|
var support = {};
|
|
|
|
|
|
|
|
function DOMEval( code, doc ) {
|
|
doc = doc || document;
|
|
|
|
var script = doc.createElement( "script" );
|
|
|
|
script.text = code;
|
|
doc.head.appendChild( script ).parentNode.removeChild( script );
|
|
}
|
|
/* 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.2.1",
|
|
|
|
// 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 );
|
|
},
|
|
|
|
// Support: Android <=4.0 only
|
|
// Make sure we trim BOM and NBSP
|
|
rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
|
|
|
|
// Matches dashed string for camelizing
|
|
rmsPrefix = /^-ms-/,
|
|
rdashAlpha = /-([a-z])/g,
|
|
|
|
// Used by jQuery.camelCase as callback to replace()
|
|
fcamelCase = function( all, letter ) {
|
|
return letter.toUpperCase();
|
|
};
|
|
|
|
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 );
|
|
},
|
|
|
|
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" && !jQuery.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 ) {
|
|
src = target[ name ];
|
|
copy = options[ name ];
|
|
|
|
// Prevent never-ending loop
|
|
if ( target === copy ) {
|
|
continue;
|
|
}
|
|
|
|
// Recurse if we're merging plain objects or arrays
|
|
if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
|
|
( copyIsArray = Array.isArray( copy ) ) ) ) {
|
|
|
|
if ( copyIsArray ) {
|
|
copyIsArray = false;
|
|
clone = src && Array.isArray( src ) ? src : [];
|
|
|
|
} else {
|
|
clone = src && jQuery.isPlainObject( src ) ? src : {};
|
|
}
|
|
|
|
// 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() {},
|
|
|
|
isFunction: function( obj ) {
|
|
return jQuery.type( obj ) === "function";
|
|
},
|
|
|
|
isWindow: function( obj ) {
|
|
return obj != null && obj === obj.window;
|
|
},
|
|
|
|
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 ) );
|
|
},
|
|
|
|
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 ) {
|
|
|
|
/* eslint-disable no-unused-vars */
|
|
// See https://github.com/eslint/eslint/issues/6125
|
|
var name;
|
|
|
|
for ( name in obj ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
},
|
|
|
|
type: function( 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;
|
|
},
|
|
|
|
// Evaluates a script in a global context
|
|
globalEval: function( code ) {
|
|
DOMEval( code );
|
|
},
|
|
|
|
// Convert dashed to camelCase; used by the css and data modules
|
|
// Support: IE <=9 - 11, Edge 12 - 13
|
|
// Microsoft forgot to hump their vendor prefix (#9572)
|
|
camelCase: function( string ) {
|
|
return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
|
|
},
|
|
|
|
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;
|
|
},
|
|
|
|
// Support: Android <=4.0 only
|
|
trim: function( text ) {
|
|
return text == null ?
|
|
"" :
|
|
( text + "" ).replace( rtrim, "" );
|
|
},
|
|
|
|
// 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 concat.apply( [], ret );
|
|
},
|
|
|
|
// A global GUID counter for objects
|
|
guid: 1,
|
|
|
|
// Bind a function to a context, optionally partially applying any
|
|
// arguments.
|
|
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 ( !jQuery.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;
|
|
},
|
|
|
|
now: Date.now,
|
|
|
|
// jQuery.support is not used in Core but other projects attach their
|
|
// properties to it so it needs to exist.
|
|
support: support
|
|
} );
|
|
|
|
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 = jQuery.type( obj );
|
|
|
|
if ( type === "function" || jQuery.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.3
|
|
* https://sizzlejs.com/
|
|
*
|
|
* Copyright jQuery Foundation and other contributors
|
|
* Released under the MIT license
|
|
* http://jquery.org/license
|
|
*
|
|
* Date: 2016-08-08
|
|
*/
|
|
(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(),
|
|
sortOrder = function( a, b ) {
|
|
if ( a === b ) {
|
|
hasDuplicate = true;
|
|
}
|
|
return 0;
|
|
},
|
|
|
|
// Instance methods
|
|
hasOwn = ({}).hasOwnProperty,
|
|
arr = [],
|
|
pop = arr.pop,
|
|
push_native = 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]",
|
|
|
|
// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
|
|
identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
|
|
|
|
// 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 + "*" ),
|
|
|
|
rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
|
|
|
|
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" )
|
|
},
|
|
|
|
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-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
|
|
funescape = function( _, escaped, escapedWhitespace ) {
|
|
var high = "0x" + escaped - 0x10000;
|
|
// NaN means non-codepoint
|
|
// Support: Firefox<24
|
|
// Workaround erroneous numeric interpretation of +"0x"
|
|
return high !== high || escapedWhitespace ?
|
|
escaped :
|
|
high < 0 ?
|
|
// BMP codepoint
|
|
String.fromCharCode( high + 0x10000 ) :
|
|
// Supplemental Plane codepoint (surrogate pair)
|
|
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();
|
|
},
|
|
|
|
disabledAncestor = addCombinator(
|
|
function( elem ) {
|
|
return elem.disabled === true && ("form" in elem || "label" in elem);
|
|
},
|
|
{ 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
|
|
arr[ preferredDoc.childNodes.length ].nodeType;
|
|
} catch ( e ) {
|
|
push = { apply: arr.length ?
|
|
|
|
// Leverage slice if possible
|
|
function( target, els ) {
|
|
push_native.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 ) {
|
|
|
|
if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
|
|
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 &&
|
|
!compilerCache[ selector + " " ] &&
|
|
(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
|
|
|
|
if ( nodeType !== 1 ) {
|
|
newContext = context;
|
|
newSelector = selector;
|
|
|
|
// qSA looks outside Element context, which is not what we want
|
|
// Thanks to Andrew Dupont for this workaround technique
|
|
// Support: IE <=8
|
|
// Exclude object elements
|
|
} else if ( context.nodeName.toLowerCase() !== "object" ) {
|
|
|
|
// 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 + " " + toSelector( groups[i] );
|
|
}
|
|
newSelector = groups.join( "," );
|
|
|
|
// Expand context for sibling selectors
|
|
newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
|
|
context;
|
|
}
|
|
|
|
if ( newSelector ) {
|
|
try {
|
|
push.apply( results,
|
|
newContext.querySelectorAll( newSelector )
|
|
);
|
|
return results;
|
|
} catch ( qsaError ) {
|
|
} 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 &&
|
|
disabledAncestor( 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 ) {
|
|
// documentElement is verified for cases where it doesn't yet exist
|
|
// (such as loading iframes in IE - #4833)
|
|
var documentElement = elem && (elem.ownerDocument || elem).documentElement;
|
|
return documentElement ? documentElement.nodeName !== "HTML" : false;
|
|
};
|
|
|
|
/**
|
|
* 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
|
|
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
|
|
// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
|
|
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 );
|
|
}
|
|
}
|
|
|
|
/* 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 ) {
|
|
// 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("~=");
|
|
}
|
|
|
|
// 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(".#.+[+~]");
|
|
}
|
|
});
|
|
|
|
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" );
|
|
}
|
|
|
|
// 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
|
|
compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
|
|
a.compareDocumentPosition( b ) :
|
|
|
|
// Otherwise we know they are disconnected
|
|
1;
|
|
|
|
// Disconnected nodes
|
|
if ( compare & 1 ||
|
|
(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
|
|
|
|
// Choose the first element that is related to our preferred document
|
|
if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
|
|
return -1;
|
|
}
|
|
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 ) {
|
|
return a === document ? -1 :
|
|
b === document ? 1 :
|
|
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
|
|
ap[i] === preferredDoc ? -1 :
|
|
bp[i] === preferredDoc ? 1 :
|
|
0;
|
|
};
|
|
|
|
return document;
|
|
};
|
|
|
|
Sizzle.matches = function( expr, elements ) {
|
|
return Sizzle( expr, null, null, elements );
|
|
};
|
|
|
|
Sizzle.matchesSelector = function( elem, expr ) {
|
|
// Set document vars if needed
|
|
if ( ( elem.ownerDocument || elem ) !== document ) {
|
|
setDocument( elem );
|
|
}
|
|
|
|
// Make sure that attribute selectors are quoted
|
|
expr = expr.replace( rattributeQuotes, "='$1']" );
|
|
|
|
if ( support.matchesSelector && documentIsHTML &&
|
|
!compilerCache[ 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) {}
|
|
}
|
|
|
|
return Sizzle( expr, document, null, [ elem ] ).length > 0;
|
|
};
|
|
|
|
Sizzle.contains = function( context, elem ) {
|
|
// Set document vars if needed
|
|
if ( ( context.ownerDocument || context ) !== document ) {
|
|
setDocument( context );
|
|
}
|
|
return contains( context, elem );
|
|
};
|
|
|
|
Sizzle.attr = function( elem, name ) {
|
|
// Set document vars if needed
|
|
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 += "";
|
|
|
|
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;
|
|
};
|
|
},
|
|
|
|
"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 || elem.innerText || 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 ) {
|
|
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;
|
|
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 ) {
|
|
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;
|
|
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 );
|
|
|
|
|
|
|
|
var risSimple = /^.[^:#\[\.,]*$/;
|
|
|
|
// Implement the identical functionality for filter and not
|
|
function winnow( elements, qualifier, not ) {
|
|
if ( jQuery.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;
|
|
} );
|
|
}
|
|
|
|
// Simple selector that can be filtered directly, removing non-Elements
|
|
if ( risSimple.test( qualifier ) ) {
|
|
return jQuery.filter( qualifier, elements, not );
|
|
}
|
|
|
|
// Complex selector, compare the two sets, removing non-Elements
|
|
qualifier = jQuery.filter( qualifier, elements );
|
|
return jQuery.grep( elements, function( elem ) {
|
|
return ( indexOf.call( qualifier, elem ) > -1 ) !== not && elem.nodeType === 1;
|
|
} );
|
|
}
|
|
|
|
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 ( jQuery.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 ( jQuery.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 ( nodeName( elem, "iframe" ) ) {
|
|
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 ( jQuery.isFunction( arg ) ) {
|
|
if ( !options.unique || !self.has( arg ) ) {
|
|
list.push( arg );
|
|
}
|
|
} else if ( arg && arg.length && jQuery.type( 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 && jQuery.isFunction( ( method = value.promise ) ) ) {
|
|
method.call( value ).done( resolve ).fail( reject );
|
|
|
|
// Other thenables
|
|
} else if ( value && jQuery.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 = jQuery.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 && jQuery.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 ( jQuery.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,
|
|
jQuery.isFunction( onProgress ) ?
|
|
onProgress :
|
|
Identity,
|
|
newDefer.notifyWith
|
|
)
|
|
);
|
|
|
|
// fulfilled_handlers.add( ... )
|
|
tuples[ 1 ][ 3 ].add(
|
|
resolve(
|
|
0,
|
|
newDefer,
|
|
jQuery.isFunction( onFulfilled ) ?
|
|
onFulfilled :
|
|
Identity
|
|
)
|
|
);
|
|
|
|
// rejected_handlers.add( ... )
|
|
tuples[ 2 ][ 3 ].add(
|
|
resolve(
|
|
0,
|
|
newDefer,
|
|
jQuery.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,
|
|
|
|
// progress_callbacks.lock
|
|
tuples[ 0 ][ 2 ].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 master Deferred
|
|
master = 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 ) ) {
|
|
master.resolveWith( resolveContexts, resolveValues );
|
|
}
|
|
};
|
|
};
|
|
|
|
// Single- and empty arguments are adopted like Promise.resolve
|
|
if ( remaining <= 1 ) {
|
|
adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject,
|
|
!remaining );
|
|
|
|
// Use .then() to unwrap secondary thenables (cf. gh-3000)
|
|
if ( master.state() === "pending" ||
|
|
jQuery.isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
|
|
|
|
return master.then();
|
|
}
|
|
}
|
|
|
|
// Multiple arguments are aggregated like Promise.all array elements
|
|
while ( i-- ) {
|
|
adoptValue( resolveValues[ i ], updateFunc( i ), master.reject );
|
|
}
|
|
|
|
return master.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 ( jQuery.type( 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 ( !jQuery.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;
|
|
};
|
|
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[ jQuery.camelCase( data ) ] = value;
|
|
|
|
// Handle: [ owner, { properties } ] args
|
|
} else {
|
|
|
|
// Copy the properties one-by-one to the cache object
|
|
for ( prop in data ) {
|
|
cache[ jQuery.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 ][ jQuery.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( jQuery.camelCase );
|
|
} else {
|
|
key = jQuery.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 = jQuery.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 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.
|
|
jQuery.contains( elem.ownerDocument, elem ) &&
|
|
|
|
jQuery.css( elem, "display" ) === "none";
|
|
};
|
|
|
|
var swap = function( elem, options, callback, args ) {
|
|
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.apply( elem, args || [] );
|
|
|
|
// Revert the old values
|
|
for ( name in options ) {
|
|
elem.style[ name ] = old[ name ];
|
|
}
|
|
|
|
return ret;
|
|
};
|
|
|
|
|
|
|
|
|
|
function adjustCSS( elem, prop, valueParts, tween ) {
|
|
var adjusted,
|
|
scale = 1,
|
|
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 = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
|
|
rcssNum.exec( jQuery.css( elem, prop ) );
|
|
|
|
if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
|
|
|
|
// Trust units reported by jQuery.css
|
|
unit = unit || initialInUnit[ 3 ];
|
|
|
|
// Make sure we update the tween properties later on
|
|
valueParts = valueParts || [];
|
|
|
|
// Iteratively approximate from a nonzero starting point
|
|
initialInUnit = +initial || 1;
|
|
|
|
do {
|
|
|
|
// If previous iteration zeroed out, double until we get *something*.
|
|
// Use string for doubling so we don't accidentally see scale as unchanged below
|
|
scale = scale || ".5";
|
|
|
|
// Adjust and apply
|
|
initialInUnit = initialInUnit / scale;
|
|
jQuery.style( elem, prop, initialInUnit + unit );
|
|
|
|
// Update scale, tolerating zero or NaN from tween.cur()
|
|
// Break the loop if scale is unchanged or perfect, or if we've just had enough.
|
|
} while (
|
|
scale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations
|
|
);
|
|
}
|
|
|
|
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 = ( /^$|\/(?:java|ecma)script/i );
|
|
|
|
|
|
|
|
// We have to close these tags to support XHTML (#13200)
|
|
var wrapMap = {
|
|
|
|
// Support: IE <=9 only
|
|
option: [ 1, "<select multiple='multiple'>", "</select>" ],
|
|
|
|
// 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, "", "" ]
|
|
};
|
|
|
|
// Support: IE <=9 only
|
|
wrapMap.optgroup = wrapMap.option;
|
|
|
|
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
|
|
wrapMap.th = wrapMap.td;
|
|
|
|
|
|
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, contains, 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 ( jQuery.type( 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;
|
|
}
|
|
|
|
contains = jQuery.contains( elem.ownerDocument, elem );
|
|
|
|
// Append to fragment
|
|
tmp = getAll( fragment.appendChild( elem ), "script" );
|
|
|
|
// Preserve script evaluation history
|
|
if ( contains ) {
|
|
setGlobalEval( tmp );
|
|
}
|
|
|
|
// Capture executables
|
|
if ( scripts ) {
|
|
j = 0;
|
|
while ( ( elem = tmp[ j++ ] ) ) {
|
|
if ( rscriptType.test( elem.type || "" ) ) {
|
|
scripts.push( elem );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return fragment;
|
|
}
|
|
|
|
|
|
( 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;
|
|
} )();
|
|
var documentElement = document.documentElement;
|
|
|
|
|
|
|
|
var
|
|
rkeyEvent = /^key/,
|
|
rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
|
|
rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
|
|
|
|
function returnTrue() {
|
|
return true;
|
|
}
|
|
|
|
function returnFalse() {
|
|
return false;
|
|
}
|
|
|
|
// Support: IE <=9 only
|
|
// See #13393 for more info
|
|
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 );
|
|
|
|
// Don't attach events to noData or text/comment nodes (but allow plain objects)
|
|
if ( !elemData ) {
|
|
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 = {};
|
|
}
|
|
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 ) {
|
|
|
|
// Make a writable jQuery.Event from the native event object
|
|
var event = jQuery.event.fix( nativeEvent );
|
|
|
|
var i, j, ret, matched, handleObj, handlerQueue,
|
|
args = new Array( arguments.length ),
|
|
handlers = ( dataPriv.get( this, "events" ) || {} )[ 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() ) {
|
|
|
|
// Triggered event must either 1) have no namespace, or 2) have namespace(s)
|
|
// a subset or equal to those in the bound event (both can have no namespace).
|
|
if ( !event.rnamespace || 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: jQuery.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
|
|
},
|
|
focus: {
|
|
|
|
// Fire native event if possible so blur/focus sequence is correct
|
|
trigger: function() {
|
|
if ( this !== safeActiveElement() && this.focus ) {
|
|
this.focus();
|
|
return false;
|
|
}
|
|
},
|
|
delegateType: "focusin"
|
|
},
|
|
blur: {
|
|
trigger: function() {
|
|
if ( this === safeActiveElement() && this.blur ) {
|
|
this.blur();
|
|
return false;
|
|
}
|
|
},
|
|
delegateType: "focusout"
|
|
},
|
|
click: {
|
|
|
|
// For checkbox, fire native event so checked state will be right
|
|
trigger: function() {
|
|
if ( this.type === "checkbox" && this.click && nodeName( this, "input" ) ) {
|
|
this.click();
|
|
return false;
|
|
}
|
|
},
|
|
|
|
// For cross-browser consistency, don't fire native .click() on links
|
|
_default: function( event ) {
|
|
return nodeName( event.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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
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 || jQuery.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,
|
|
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: function( event ) {
|
|
var button = event.button;
|
|
|
|
// Add which for key events
|
|
if ( event.which == null && rkeyEvent.test( event.type ) ) {
|
|
return event.charCode != null ? event.charCode : event.keyCode;
|
|
}
|
|
|
|
// Add which for click: 1 === left; 2 === middle; 3 === right
|
|
if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {
|
|
if ( button & 1 ) {
|
|
return 1;
|
|
}
|
|
|
|
if ( button & 2 ) {
|
|
return 3;
|
|
}
|
|
|
|
if ( button & 4 ) {
|
|
return 2;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
return event.which;
|
|
}
|
|
}, jQuery.event.addProp );
|
|
|
|
// 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
|
|
|
|
/* eslint-disable max-len */
|
|
|
|
// See https://github.com/eslint/eslint/issues/3229
|
|
rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,
|
|
|
|
/* eslint-enable */
|
|
|
|
// Support: IE <=10 - 11, Edge 12 - 13
|
|
// 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,
|
|
rscriptTypeMasked = /^true\/(.*)/,
|
|
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( ">tbody", elem )[ 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 ) {
|
|
var match = rscriptTypeMasked.exec( elem.type );
|
|
|
|
if ( match ) {
|
|
elem.type = match[ 1 ];
|
|
} else {
|
|
elem.removeAttribute( "type" );
|
|
}
|
|
|
|
return elem;
|
|
}
|
|
|
|
function cloneCopyEvent( src, dest ) {
|
|
var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
|
|
|
|
if ( dest.nodeType !== 1 ) {
|
|
return;
|
|
}
|
|
|
|
// 1. Copy private data: events, handlers, etc.
|
|
if ( dataPriv.hasData( src ) ) {
|
|
pdataOld = dataPriv.access( src );
|
|
pdataCur = dataPriv.set( dest, pdataOld );
|
|
events = pdataOld.events;
|
|
|
|
if ( events ) {
|
|
delete pdataCur.handle;
|
|
pdataCur.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 = concat.apply( [], args );
|
|
|
|
var fragment, first, scripts, hasScripts, node, doc,
|
|
i = 0,
|
|
l = collection.length,
|
|
iNoClone = l - 1,
|
|
value = args[ 0 ],
|
|
isFunction = jQuery.isFunction( value );
|
|
|
|
// We can't cloneNode fragments that contain checked, in WebKit
|
|
if ( isFunction ||
|
|
( l > 1 && typeof value === "string" &&
|
|
!support.checkClone && rchecked.test( value ) ) ) {
|
|
return collection.each( function( index ) {
|
|
var self = collection.eq( index );
|
|
if ( isFunction ) {
|
|
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 ) {
|
|
|
|
// Optional AJAX dependency, but won't run scripts if not present
|
|
if ( jQuery._evalUrl ) {
|
|
jQuery._evalUrl( node.src );
|
|
}
|
|
} else {
|
|
DOMEval( node.textContent.replace( rcleanScript, "" ), 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 && jQuery.contains( node.ownerDocument, node ) ) {
|
|
setGlobalEval( getAll( node, "script" ) );
|
|
}
|
|
node.parentNode.removeChild( node );
|
|
}
|
|
}
|
|
|
|
return elem;
|
|
}
|
|
|
|
jQuery.extend( {
|
|
htmlPrefilter: function( html ) {
|
|
return html.replace( rxhtmlTag, "<$1></$2>" );
|
|
},
|
|
|
|
clone: function( elem, dataAndEvents, deepDataAndEvents ) {
|
|
var i, l, srcElements, destElements,
|
|
clone = elem.cloneNode( true ),
|
|
inPage = jQuery.contains( elem.ownerDocument, 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 rmargin = ( /^margin/ );
|
|
|
|
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 );
|
|
};
|
|
|
|
|
|
|
|
( 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;
|
|
}
|
|
|
|
div.style.cssText =
|
|
"box-sizing:border-box;" +
|
|
"position:relative;display:block;" +
|
|
"margin:auto;border:1px;padding:1px;" +
|
|
"top:1%;width:50%";
|
|
div.innerHTML = "";
|
|
documentElement.appendChild( container );
|
|
|
|
var divStyle = window.getComputedStyle( div );
|
|
pixelPositionVal = divStyle.top !== "1%";
|
|
|
|
// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
|
|
reliableMarginLeftVal = divStyle.marginLeft === "2px";
|
|
boxSizingReliableVal = divStyle.width === "4px";
|
|
|
|
// Support: Android 4.0 - 4.3 only
|
|
// Some styles come back with percentage values, even though they shouldn't
|
|
div.style.marginRight = "50%";
|
|
pixelMarginRightVal = divStyle.marginRight === "4px";
|
|
|
|
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;
|
|
}
|
|
|
|
var pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, 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";
|
|
|
|
container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" +
|
|
"padding:0;margin-top:1px;position:absolute";
|
|
container.appendChild( div );
|
|
|
|
jQuery.extend( support, {
|
|
pixelPosition: function() {
|
|
computeStyleTests();
|
|
return pixelPositionVal;
|
|
},
|
|
boxSizingReliable: function() {
|
|
computeStyleTests();
|
|
return boxSizingReliableVal;
|
|
},
|
|
pixelMarginRight: function() {
|
|
computeStyleTests();
|
|
return pixelMarginRightVal;
|
|
},
|
|
reliableMarginLeft: function() {
|
|
computeStyleTests();
|
|
return reliableMarginLeftVal;
|
|
}
|
|
} );
|
|
} )();
|
|
|
|
|
|
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 === "" && !jQuery.contains( elem.ownerDocument, 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.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.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
|
|
|
|
// 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"
|
|
},
|
|
|
|
cssPrefixes = [ "Webkit", "Moz", "ms" ],
|
|
emptyStyle = document.createElement( "div" ).style;
|
|
|
|
// Return a css property mapped to a potentially vendor prefixed property
|
|
function vendorPropName( name ) {
|
|
|
|
// Shortcut for names that are not vendor prefixed
|
|
if ( name in emptyStyle ) {
|
|
return 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 property mapped along what jQuery.cssProps suggests or to
|
|
// a vendor prefixed property.
|
|
function finalPropName( name ) {
|
|
var ret = jQuery.cssProps[ name ];
|
|
if ( !ret ) {
|
|
ret = jQuery.cssProps[ name ] = vendorPropName( name ) || name;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
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 augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
|
|
var i,
|
|
val = 0;
|
|
|
|
// If we already have the right measurement, avoid augmentation
|
|
if ( extra === ( isBorderBox ? "border" : "content" ) ) {
|
|
i = 4;
|
|
|
|
// Otherwise initialize for horizontal or vertical properties
|
|
} else {
|
|
i = name === "width" ? 1 : 0;
|
|
}
|
|
|
|
for ( ; i < 4; i += 2 ) {
|
|
|
|
// Both box models exclude margin, so add it if we want it
|
|
if ( extra === "margin" ) {
|
|
val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
|
|
}
|
|
|
|
if ( isBorderBox ) {
|
|
|
|
// border-box includes padding, so remove it if we want content
|
|
if ( extra === "content" ) {
|
|
val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
|
|
}
|
|
|
|
// At this point, extra isn't border nor margin, so remove border
|
|
if ( extra !== "margin" ) {
|
|
val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
|
|
}
|
|
} else {
|
|
|
|
// At this point, extra isn't content, so add padding
|
|
val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
|
|
|
|
// At this point, extra isn't content nor padding, so add border
|
|
if ( extra !== "padding" ) {
|
|
val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
|
|
}
|
|
}
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
function getWidthOrHeight( elem, name, extra ) {
|
|
|
|
// Start with computed style
|
|
var valueIsBorderBox,
|
|
styles = getStyles( elem ),
|
|
val = curCSS( elem, name, styles ),
|
|
isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
|
|
|
|
// Computed unit is not pixels. Stop here and return.
|
|
if ( rnumnonpx.test( val ) ) {
|
|
return val;
|
|
}
|
|
|
|
// Check for style in case a browser which returns unreliable values
|
|
// for getComputedStyle silently falls back to the reliable elem.style
|
|
valueIsBorderBox = isBorderBox &&
|
|
( support.boxSizingReliable() || val === elem.style[ name ] );
|
|
|
|
// Fall back to offsetWidth/Height when value is "auto"
|
|
// This happens for inline elements with no explicit setting (gh-3571)
|
|
if ( val === "auto" ) {
|
|
val = elem[ "offset" + name[ 0 ].toUpperCase() + name.slice( 1 ) ];
|
|
}
|
|
|
|
// Normalize "", auto, and prepare for extra
|
|
val = parseFloat( val ) || 0;
|
|
|
|
// Use the active box-sizing model to add/subtract irrelevant styles
|
|
return ( val +
|
|
augmentWidthOrHeight(
|
|
elem,
|
|
name,
|
|
extra || ( isBorderBox ? "border" : "content" ),
|
|
valueIsBorderBox,
|
|
styles
|
|
)
|
|
) + "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,
|
|
"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: {
|
|
"float": "cssFloat"
|
|
},
|
|
|
|
// 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 = jQuery.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)
|
|
if ( type === "number" ) {
|
|
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 = jQuery.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, name ) {
|
|
jQuery.cssHooks[ name ] = {
|
|
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, name, extra );
|
|
} ) :
|
|
getWidthOrHeight( elem, name, extra );
|
|
}
|
|
},
|
|
|
|
set: function( elem, value, extra ) {
|
|
var matches,
|
|
styles = extra && getStyles( elem ),
|
|
subtract = extra && augmentWidthOrHeight(
|
|
elem,
|
|
name,
|
|
extra,
|
|
jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
|
|
styles
|
|
);
|
|
|
|
// Convert to pixels if value adjustment is needed
|
|
if ( subtract && ( matches = rcssNum.exec( value ) ) &&
|
|
( matches[ 3 ] || "px" ) !== "px" ) {
|
|
|
|
elem.style[ name ] = value;
|
|
value = jQuery.css( elem, name );
|
|
}
|
|
|
|
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 ( !rmargin.test( prefix ) ) {
|
|
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 &&
|
|
( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||
|
|
jQuery.cssHooks[ tween.prop ] ) ) {
|
|
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 = jQuery.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 - 13
|
|
// Record all 3 overflow attributes because IE does not infer the shorthand
|
|
// from identically-valued overflowX and overflowY
|
|
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 = jQuery.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 ( jQuery.isFunction( result.stop ) ) {
|
|
jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
|
|
jQuery.proxy( result.stop, result );
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
jQuery.map( props, createTween, animation );
|
|
|
|
if ( jQuery.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 ( jQuery.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 ||
|
|
jQuery.isFunction( speed ) && speed,
|
|
duration: speed,
|
|
easing: fn && easing || easing && !jQuery.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 ( jQuery.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 && type !== false ) {
|
|
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 = jQuery.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://html.spec.whatwg.org/multipage/infrastructure.html#strip-and-collapse-whitespace
|
|
function stripAndCollapse( value ) {
|
|
var tokens = value.match( rnothtmlwhite ) || [];
|
|
return tokens.join( " " );
|
|
}
|
|
|
|
|
|
function getClass( elem ) {
|
|
return elem.getAttribute && elem.getAttribute( "class" ) || "";
|
|
}
|
|
|
|
jQuery.fn.extend( {
|
|
addClass: function( value ) {
|
|
var classes, elem, cur, curValue, clazz, j, finalValue,
|
|
i = 0;
|
|
|
|
if ( jQuery.isFunction( value ) ) {
|
|
return this.each( function( j ) {
|
|
jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
|
|
} );
|
|
}
|
|
|
|
if ( typeof value === "string" && value ) {
|
|
classes = value.match( rnothtmlwhite ) || [];
|
|
|
|
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 ( jQuery.isFunction( value ) ) {
|
|
return this.each( function( j ) {
|
|
jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
|
|
} );
|
|
}
|
|
|
|
if ( !arguments.length ) {
|
|
return this.attr( "class", "" );
|
|
}
|
|
|
|
if ( typeof value === "string" && value ) {
|
|
classes = value.match( rnothtmlwhite ) || [];
|
|
|
|
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;
|
|
|
|
if ( typeof stateVal === "boolean" && type === "string" ) {
|
|
return stateVal ? this.addClass( value ) : this.removeClass( value );
|
|
}
|
|
|
|
if ( jQuery.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 ( type === "string" ) {
|
|
|
|
// Toggle individual class names
|
|
i = 0;
|
|
self = jQuery( this );
|
|
classNames = value.match( rnothtmlwhite ) || [];
|
|
|
|
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, isFunction,
|
|
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;
|
|
}
|
|
|
|
isFunction = jQuery.isFunction( value );
|
|
|
|
return this.each( function( i ) {
|
|
var val;
|
|
|
|
if ( this.nodeType !== 1 ) {
|
|
return;
|
|
}
|
|
|
|
if ( isFunction ) {
|
|
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
|
|
|
|
|
|
var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
|
|
|
|
jQuery.extend( jQuery.event, {
|
|
|
|
trigger: function( event, data, elem, onlyHandlers ) {
|
|
|
|
var i, cur, tmp, bubbleType, ontype, handle, special,
|
|
eventPath = [ elem || document ],
|
|
type = hasOwn.call( event, "type" ) ? event.type : event,
|
|
namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
|
|
|
|
cur = 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 && !jQuery.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() ) {
|
|
|
|
event.type = i > 1 ?
|
|
bubbleType :
|
|
special.bindType || type;
|
|
|
|
// jQuery handler
|
|
handle = ( dataPriv.get( cur, "events" ) || {} )[ 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 && jQuery.isFunction( elem[ type ] ) && !jQuery.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;
|
|
elem[ type ]();
|
|
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 );
|
|
}
|
|
}
|
|
} );
|
|
|
|
|
|
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 );
|
|
};
|
|
} );
|
|
|
|
jQuery.fn.extend( {
|
|
hover: function( fnOver, fnOut ) {
|
|
return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
|
|
}
|
|
} );
|
|
|
|
|
|
|
|
|
|
support.focusin = "onfocusin" in window;
|
|
|
|
|
|
// 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() {
|
|
var doc = this.ownerDocument || 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,
|
|
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 = jQuery.now();
|
|
|
|
var rquery = ( /\?/ );
|
|
|
|
|
|
|
|
// Cross-browser xml parsing
|
|
jQuery.parseXML = function( data ) {
|
|
var xml;
|
|
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 ) {
|
|
xml = undefined;
|
|
}
|
|
|
|
if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {
|
|
jQuery.error( "Invalid XML: " + 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 && jQuery.type( 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 = jQuery.isFunction( valueOrFunction ) ?
|
|
valueOrFunction() :
|
|
valueOrFunction;
|
|
|
|
s[ s.length ] = encodeURIComponent( key ) + "=" +
|
|
encodeURIComponent( value == null ? "" : value );
|
|
};
|
|
|
|
// 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 ( jQuery.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() ] = match[ 2 ];
|
|
}
|
|
}
|
|
match = responseHeaders[ key.toLowerCase() ];
|
|
}
|
|
return match == null ? null : match;
|
|
},
|
|
|
|
// 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 - 13
|
|
// 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, append data to url
|
|
if ( s.data ) {
|
|
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++ ) + 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 );
|
|
}
|
|
|
|
// 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 ( jQuery.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._evalUrl = function( url ) {
|
|
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,
|
|
"throws": true
|
|
} );
|
|
};
|
|
|
|
|
|
jQuery.fn.extend( {
|
|
wrapAll: function( html ) {
|
|
var wrap;
|
|
|
|
if ( this[ 0 ] ) {
|
|
if ( jQuery.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 ( jQuery.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 isFunction = jQuery.isFunction( html );
|
|
|
|
return this.each( function( i ) {
|
|
jQuery( this ).wrapAll( isFunction ? 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.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 = 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 requests
|
|
if ( s.crossDomain ) {
|
|
var script, callback;
|
|
return {
|
|
send: function( _, complete ) {
|
|
script = jQuery( "<script>" ).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++ ) );
|
|
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 = jQuery.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 && jQuery.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 ( jQuery.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;
|
|
};
|
|
|
|
|
|
|
|
|
|
// Attach a bunch of functions for handling common AJAX events
|
|
jQuery.each( [
|
|
"ajaxStart",
|
|
"ajaxStop",
|
|
"ajaxComplete",
|
|
"ajaxError",
|
|
"ajaxSuccess",
|
|
"ajaxSend"
|
|
], function( i, type ) {
|
|
jQuery.fn[ type ] = function( fn ) {
|
|
return this.on( type, fn );
|
|
};
|
|
} );
|
|
|
|
|
|
|
|
|
|
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 ( jQuery.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: function( options ) {
|
|
|
|
// Preserve chaining for setter
|
|
if ( arguments.length ) {
|
|
return options === undefined ?
|
|
this :
|
|
this.each( function( i ) {
|
|
jQuery.offset.setOffset( this, options, i );
|
|
} );
|
|
}
|
|
|
|
var doc, docElem, 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 };
|
|
}
|
|
|
|
rect = elem.getBoundingClientRect();
|
|
|
|
doc = elem.ownerDocument;
|
|
docElem = doc.documentElement;
|
|
win = doc.defaultView;
|
|
|
|
return {
|
|
top: rect.top + win.pageYOffset - docElem.clientTop,
|
|
left: rect.left + win.pageXOffset - docElem.clientLeft
|
|
};
|
|
},
|
|
|
|
position: function() {
|
|
if ( !this[ 0 ] ) {
|
|
return;
|
|
}
|
|
|
|
var offsetParent, offset,
|
|
elem = this[ 0 ],
|
|
parentOffset = { top: 0, left: 0 };
|
|
|
|
// Fixed elements are offset from window (parentOffset = {top:0, left: 0},
|
|
// because it is its only offset parent
|
|
if ( jQuery.css( elem, "position" ) === "fixed" ) {
|
|
|
|
// Assume getBoundingClientRect is there when computed position is fixed
|
|
offset = elem.getBoundingClientRect();
|
|
|
|
} else {
|
|
|
|
// Get *real* offsetParent
|
|
offsetParent = this.offsetParent();
|
|
|
|
// Get correct offsets
|
|
offset = this.offset();
|
|
if ( !nodeName( offsetParent[ 0 ], "html" ) ) {
|
|
parentOffset = offsetParent.offset();
|
|
}
|
|
|
|
// Add offsetParent borders
|
|
parentOffset = {
|
|
top: parentOffset.top + jQuery.css( offsetParent[ 0 ], "borderTopWidth", true ),
|
|
left: parentOffset.left + jQuery.css( offsetParent[ 0 ], "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 ( jQuery.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 ( jQuery.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.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 );
|
|
}
|
|
} );
|
|
|
|
jQuery.holdReady = function( hold ) {
|
|
if ( hold ) {
|
|
jQuery.readyWait++;
|
|
} else {
|
|
jQuery.ready( true );
|
|
}
|
|
};
|
|
jQuery.isArray = Array.isArray;
|
|
jQuery.parseJSON = JSON.parse;
|
|
jQuery.nodeName = nodeName;
|
|
|
|
|
|
|
|
|
|
// 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 ( !noGlobal ) {
|
|
window.jQuery = window.$ = jQuery;
|
|
}
|
|
|
|
|
|
|
|
|
|
return jQuery;
|
|
} );
|
|
( 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 || {};
|
|
|
|
return $.ui.version = "1.12.1";
|
|
|
|
} ) );
|
|
|
|
|
|
/*!
|
|
* 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/
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [ "jquery", "./version" ], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
} ( function( $ ) {
|
|
return $.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
|
|
};
|
|
|
|
} ) );
|
|
|
|
|
|
|
|
// 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
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [
|
|
"jquery",
|
|
"../version",
|
|
"../keycode"
|
|
], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
}( function( $ ) {
|
|
|
|
$.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";
|
|
|
|
return $.datepicker;
|
|
|
|
} ) );
|
|
|
|
|
|
/*!
|
|
* 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/
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [ "jquery", "./version" ], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
}( function( $ ) {
|
|
|
|
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();
|
|
} );
|
|
}
|
|
};
|
|
} );
|
|
|
|
return $.widget;
|
|
|
|
} ) );
|
|
|
|
|
|
/*!
|
|
* 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
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [
|
|
"jquery",
|
|
"../widget"
|
|
], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
}( function( $ ) {
|
|
var controlgroupCornerRegex = /ui-corner-([a-z]){2,6}/g;
|
|
|
|
return $.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" );
|
|
}
|
|
}
|
|
} );
|
|
} ) );
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [ "jquery", "./version" ], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
} ( function( $ ) {
|
|
|
|
// Internal use only
|
|
return $.ui.escapeSelector = ( function() {
|
|
var selectorEscape = /([!"#$%&'()*+,./:;<=>?@[\]^`{|}~])/g;
|
|
return function( selector ) {
|
|
return selector.replace( selectorEscape, "\\$1" );
|
|
};
|
|
} )();
|
|
|
|
} ) );
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [ "jquery", "./version" ], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
} ( function( $ ) {
|
|
|
|
// 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.
|
|
return $.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/
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [
|
|
"jquery",
|
|
"./form",
|
|
"./version"
|
|
], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
}( function( $ ) {
|
|
|
|
return $.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 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/
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [ "jquery", "./version", "./escape-selector" ], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
} ( function( $ ) {
|
|
|
|
return $.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 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
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [
|
|
"jquery",
|
|
"../escape-selector",
|
|
"../form-reset-mixin",
|
|
"../labels",
|
|
"../widget"
|
|
], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
}( function( $ ) {
|
|
|
|
$.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 } );
|
|
}
|
|
}
|
|
|
|
} ] );
|
|
|
|
return $.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
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [
|
|
"jquery",
|
|
|
|
// These are only for backcompat
|
|
// TODO: Remove after 1.12
|
|
"./controlgroup",
|
|
"./checkboxradio",
|
|
|
|
"../keycode",
|
|
"../widget"
|
|
], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
}( function( $ ) {
|
|
|
|
$.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 );
|
|
};
|
|
}
|
|
|
|
return $.ui.button;
|
|
|
|
} ) );
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [ "jquery", "./version" ], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
} ( function( $ ) {
|
|
|
|
// This file is deprecated
|
|
return $.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/
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [
|
|
"jquery",
|
|
"../ie",
|
|
"../version",
|
|
"../widget"
|
|
], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
}( function( $ ) {
|
|
|
|
var mouseHandled = false;
|
|
$( document ).on( "mouseup", function() {
|
|
mouseHandled = false;
|
|
} );
|
|
|
|
return $.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; }
|
|
} );
|
|
|
|
} ) );
|
|
|
|
|
|
/*!
|
|
* 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/
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [ "jquery", "./version" ], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
} ( function( $ ) {
|
|
return $.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 ] );
|
|
}
|
|
} );
|
|
} ) );
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [ "jquery", "./version" ], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
} ( function( $ ) {
|
|
|
|
// $.ui.plugin is deprecated. Use $.widget() extensions instead.
|
|
return $.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 );
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
} ) );
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [ "jquery", "./version" ], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
} ( function( $ ) {
|
|
return $.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;
|
|
};
|
|
|
|
} ) );
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [ "jquery", "./version" ], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
} ( function( $ ) {
|
|
return $.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 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/
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [ "jquery", "./version" ], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
} ( function( $ ) {
|
|
|
|
return $.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 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
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [
|
|
"jquery",
|
|
"./mouse",
|
|
"../data",
|
|
"../plugin",
|
|
"../safe-active-element",
|
|
"../safe-blur",
|
|
"../scroll-parent",
|
|
"../version",
|
|
"../widget"
|
|
], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
}( function( $ ) {
|
|
|
|
$.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 );
|
|
}
|
|
}
|
|
} );
|
|
|
|
return $.ui.draggable;
|
|
|
|
} ) );
|
|
|
|
|
|
/*!
|
|
* 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
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [ "jquery", "./version" ], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
} ( function( $ ) {
|
|
|
|
return $.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 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
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [
|
|
"jquery",
|
|
"./mouse",
|
|
"../disable-selection",
|
|
"../plugin",
|
|
"../version",
|
|
"../widget"
|
|
], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
}( function( $ ) {
|
|
|
|
$.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;
|
|
}
|
|
}
|
|
}
|
|
|
|
} );
|
|
|
|
return $.ui.resizable;
|
|
|
|
} ) );
|
|
|
|
|
|
/*!
|
|
* 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/
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [ "jquery", "./version" ], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
} ( function( $ ) {
|
|
|
|
// 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 );
|
|
}
|
|
} );
|
|
|
|
return $.ui.focusable;
|
|
|
|
} ) );
|
|
|
|
|
|
/*!
|
|
* 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( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [ "jquery", "./version" ], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
}( function( $ ) {
|
|
( 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 );
|
|
}
|
|
}
|
|
};
|
|
|
|
} )();
|
|
|
|
return $.ui.position;
|
|
|
|
} ) );
|
|
|
|
|
|
|
|
/*!
|
|
* 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/
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [ "jquery", "./version", "./focusable" ], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
} ( function( $ ) {
|
|
|
|
return $.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/
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [ "jquery", "./version" ], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
} ( function( $ ) {
|
|
|
|
return $.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 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
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [
|
|
"jquery",
|
|
"./button",
|
|
"./draggable",
|
|
"./mouse",
|
|
"./resizable",
|
|
"../focusable",
|
|
"../keycode",
|
|
"../position",
|
|
"../safe-active-element",
|
|
"../safe-blur",
|
|
"../tabbable",
|
|
"../unique-id",
|
|
"../version",
|
|
"../widget"
|
|
], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
}( function( $ ) {
|
|
|
|
$.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 );
|
|
}
|
|
} );
|
|
}
|
|
|
|
return $.ui.dialog;
|
|
|
|
} ) );
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*!
|
|
* 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
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [
|
|
"jquery",
|
|
"./mouse",
|
|
"../data",
|
|
"../ie",
|
|
"../scroll-parent",
|
|
"../version",
|
|
"../widget"
|
|
], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
}( function( $ ) {
|
|
|
|
return $.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 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
|
|
|
|
( function( factory ) {
|
|
if ( typeof define === "function" && define.amd ) {
|
|
|
|
// AMD. Register as an anonymous module.
|
|
define( [
|
|
"jquery",
|
|
"../escape-selector",
|
|
"../keycode",
|
|
"../safe-active-element",
|
|
"../unique-id",
|
|
"../version",
|
|
"../widget"
|
|
], factory );
|
|
} else {
|
|
|
|
// Browser globals
|
|
factory( jQuery );
|
|
}
|
|
}( function( $ ) {
|
|
|
|
$.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" );
|
|
}
|
|
} );
|
|
}
|
|
|
|
return $.ui.tabs;
|
|
|
|
} ) );
|
|
(function($, undefined) {
|
|
|
|
/**
|
|
* Unobtrusive scripting adapter for jQuery
|
|
* https://github.com/rails/jquery-ujs
|
|
*
|
|
* Requires jQuery 1.8.0 or later.
|
|
*
|
|
* Released under the MIT license
|
|
*
|
|
*/
|
|
|
|
// Cut down on the number of issues from people inadvertently including jquery_ujs twice
|
|
// by detecting and raising an error when it happens.
|
|
'use strict';
|
|
|
|
if ( $.rails !== undefined ) {
|
|
$.error('jquery-ujs has already been loaded!');
|
|
}
|
|
|
|
// Shorthand to make it a little easier to call public rails functions from within rails.js
|
|
var rails;
|
|
var $document = $(document);
|
|
|
|
$.rails = rails = {
|
|
// Link elements bound by jquery-ujs
|
|
linkClickSelector: 'a[data-confirm], a[data-method], a[data-remote]:not([disabled]), a[data-disable-with], a[data-disable]',
|
|
|
|
// Button elements bound by jquery-ujs
|
|
buttonClickSelector: 'button[data-remote]:not([form]):not(form button), button[data-confirm]:not([form]):not(form button)',
|
|
|
|
// Select elements bound by jquery-ujs
|
|
inputChangeSelector: 'select[data-remote], input[data-remote], textarea[data-remote]',
|
|
|
|
// Form elements bound by jquery-ujs
|
|
formSubmitSelector: 'form',
|
|
|
|
// Form input elements bound by jquery-ujs
|
|
formInputClickSelector: 'form input[type=submit], form input[type=image], form button[type=submit], form button:not([type]), input[type=submit][form], input[type=image][form], button[type=submit][form], button[form]:not([type])',
|
|
|
|
// Form input elements disabled during form submission
|
|
disableSelector: 'input[data-disable-with]:enabled, button[data-disable-with]:enabled, textarea[data-disable-with]:enabled, input[data-disable]:enabled, button[data-disable]:enabled, textarea[data-disable]:enabled',
|
|
|
|
// Form input elements re-enabled after form submission
|
|
enableSelector: 'input[data-disable-with]:disabled, button[data-disable-with]:disabled, textarea[data-disable-with]:disabled, input[data-disable]:disabled, button[data-disable]:disabled, textarea[data-disable]:disabled',
|
|
|
|
// Form required input elements
|
|
requiredInputSelector: 'input[name][required]:not([disabled]), textarea[name][required]:not([disabled])',
|
|
|
|
// Form file input elements
|
|
fileInputSelector: 'input[name][type=file]:not([disabled])',
|
|
|
|
// Link onClick disable selector with possible reenable after remote submission
|
|
linkDisableSelector: 'a[data-disable-with], a[data-disable]',
|
|
|
|
// Button onClick disable selector with possible reenable after remote submission
|
|
buttonDisableSelector: 'button[data-remote][data-disable-with], button[data-remote][data-disable]',
|
|
|
|
// Up-to-date Cross-Site Request Forgery token
|
|
csrfToken: function() {
|
|
return $('meta[name=csrf-token]').attr('content');
|
|
},
|
|
|
|
// URL param that must contain the CSRF token
|
|
csrfParam: function() {
|
|
return $('meta[name=csrf-param]').attr('content');
|
|
},
|
|
|
|
// Make sure that every Ajax request sends the CSRF token
|
|
CSRFProtection: function(xhr) {
|
|
var token = rails.csrfToken();
|
|
if (token) xhr.setRequestHeader('X-CSRF-Token', token);
|
|
},
|
|
|
|
// Make sure that all forms have actual up-to-date tokens (cached forms contain old ones)
|
|
refreshCSRFTokens: function(){
|
|
$('form input[name="' + rails.csrfParam() + '"]').val(rails.csrfToken());
|
|
},
|
|
|
|
// Triggers an event on an element and returns false if the event result is false
|
|
fire: function(obj, name, data) {
|
|
var event = $.Event(name);
|
|
obj.trigger(event, data);
|
|
return event.result !== false;
|
|
},
|
|
|
|
// Default confirm dialog, may be overridden with custom confirm dialog in $.rails.confirm
|
|
confirm: function(message) {
|
|
return confirm(message);
|
|
},
|
|
|
|
// Default ajax function, may be overridden with custom function in $.rails.ajax
|
|
ajax: function(options) {
|
|
return $.ajax(options);
|
|
},
|
|
|
|
// Default way to get an element's href. May be overridden at $.rails.href.
|
|
href: function(element) {
|
|
return element[0].href;
|
|
},
|
|
|
|
// Checks "data-remote" if true to handle the request through a XHR request.
|
|
isRemote: function(element) {
|
|
return element.data('remote') !== undefined && element.data('remote') !== false;
|
|
},
|
|
|
|
// Submits "remote" forms and links with ajax
|
|
handleRemote: function(element) {
|
|
var method, url, data, withCredentials, dataType, options;
|
|
|
|
if (rails.fire(element, 'ajax:before')) {
|
|
withCredentials = element.data('with-credentials') || null;
|
|
dataType = element.data('type') || ($.ajaxSettings && $.ajaxSettings.dataType);
|
|
|
|
if (element.is('form')) {
|
|
method = element.data('ujs:submit-button-formmethod') || element.attr('method');
|
|
url = element.data('ujs:submit-button-formaction') || element.attr('action');
|
|
data = $(element[0]).serializeArray();
|
|
// memoized value from clicked submit button
|
|
var button = element.data('ujs:submit-button');
|
|
if (button) {
|
|
data.push(button);
|
|
element.data('ujs:submit-button', null);
|
|
}
|
|
element.data('ujs:submit-button-formmethod', null);
|
|
element.data('ujs:submit-button-formaction', null);
|
|
} else if (element.is(rails.inputChangeSelector)) {
|
|
method = element.data('method');
|
|
url = element.data('url');
|
|
data = element.serialize();
|
|
if (element.data('params')) data = data + '&' + element.data('params');
|
|
} else if (element.is(rails.buttonClickSelector)) {
|
|
method = element.data('method') || 'get';
|
|
url = element.data('url');
|
|
data = element.serialize();
|
|
if (element.data('params')) data = data + '&' + element.data('params');
|
|
} else {
|
|
method = element.data('method');
|
|
url = rails.href(element);
|
|
data = element.data('params') || null;
|
|
}
|
|
|
|
options = {
|
|
type: method || 'GET', data: data, dataType: dataType,
|
|
// stopping the "ajax:beforeSend" event will cancel the ajax request
|
|
beforeSend: function(xhr, settings) {
|
|
if (settings.dataType === undefined) {
|
|
xhr.setRequestHeader('accept', '*/*;q=0.5, ' + settings.accepts.script);
|
|
}
|
|
if (rails.fire(element, 'ajax:beforeSend', [xhr, settings])) {
|
|
element.trigger('ajax:send', xhr);
|
|
} else {
|
|
return false;
|
|
}
|
|
},
|
|
success: function(data, status, xhr) {
|
|
element.trigger('ajax:success', [data, status, xhr]);
|
|
},
|
|
complete: function(xhr, status) {
|
|
element.trigger('ajax:complete', [xhr, status]);
|
|
},
|
|
error: function(xhr, status, error) {
|
|
element.trigger('ajax:error', [xhr, status, error]);
|
|
},
|
|
crossDomain: rails.isCrossDomain(url)
|
|
};
|
|
|
|
// There is no withCredentials for IE6-8 when
|
|
// "Enable native XMLHTTP support" is disabled
|
|
if (withCredentials) {
|
|
options.xhrFields = {
|
|
withCredentials: withCredentials
|
|
};
|
|
}
|
|
|
|
// Only pass url to `ajax` options if not blank
|
|
if (url) { options.url = url; }
|
|
|
|
return rails.ajax(options);
|
|
} else {
|
|
return false;
|
|
}
|
|
},
|
|
|
|
// Determines if the request is a cross domain request.
|
|
isCrossDomain: function(url) {
|
|
var originAnchor = document.createElement('a');
|
|
originAnchor.href = location.href;
|
|
var urlAnchor = document.createElement('a');
|
|
|
|
try {
|
|
urlAnchor.href = url;
|
|
// This is a workaround to a IE bug.
|
|
urlAnchor.href = urlAnchor.href;
|
|
|
|
// If URL protocol is false or is a string containing a single colon
|
|
// *and* host are false, assume it is not a cross-domain request
|
|
// (should only be the case for IE7 and IE compatibility mode).
|
|
// Otherwise, evaluate protocol and host of the URL against the origin
|
|
// protocol and host.
|
|
return !(((!urlAnchor.protocol || urlAnchor.protocol === ':') && !urlAnchor.host) ||
|
|
(originAnchor.protocol + '//' + originAnchor.host ===
|
|
urlAnchor.protocol + '//' + urlAnchor.host));
|
|
} catch (e) {
|
|
// If there is an error parsing the URL, assume it is crossDomain.
|
|
return true;
|
|
}
|
|
},
|
|
|
|
// Handles "data-method" on links such as:
|
|
// <a href="/users/5" data-method="delete" rel="nofollow" data-confirm="Are you sure?">Delete</a>
|
|
handleMethod: function(link) {
|
|
var href = rails.href(link),
|
|
method = link.data('method'),
|
|
target = link.attr('target'),
|
|
csrfToken = rails.csrfToken(),
|
|
csrfParam = rails.csrfParam(),
|
|
form = $('<form method="post" action="' + href + '"></form>'),
|
|
metadataInput = '<input name="_method" value="' + method + '" type="hidden" />';
|
|
|
|
if (csrfParam !== undefined && csrfToken !== undefined && !rails.isCrossDomain(href)) {
|
|
metadataInput += '<input name="' + csrfParam + '" value="' + csrfToken + '" type="hidden" />';
|
|
}
|
|
|
|
if (target) { form.attr('target', target); }
|
|
|
|
form.hide().append(metadataInput).appendTo('body');
|
|
form.submit();
|
|
},
|
|
|
|
// Helper function that returns form elements that match the specified CSS selector
|
|
// If form is actually a "form" element this will return associated elements outside the from that have
|
|
// the html form attribute set
|
|
formElements: function(form, selector) {
|
|
return form.is('form') ? $(form[0].elements).filter(selector) : form.find(selector);
|
|
},
|
|
|
|
/* Disables form elements:
|
|
- Caches element value in 'ujs:enable-with' data store
|
|
- Replaces element text with value of 'data-disable-with' attribute
|
|
- Sets disabled property to true
|
|
*/
|
|
disableFormElements: function(form) {
|
|
rails.formElements(form, rails.disableSelector).each(function() {
|
|
rails.disableFormElement($(this));
|
|
});
|
|
},
|
|
|
|
disableFormElement: function(element) {
|
|
var method, replacement;
|
|
|
|
method = element.is('button') ? 'html' : 'val';
|
|
replacement = element.data('disable-with');
|
|
|
|
if (replacement !== undefined) {
|
|
element.data('ujs:enable-with', element[method]());
|
|
element[method](replacement);
|
|
}
|
|
|
|
element.prop('disabled', true);
|
|
element.data('ujs:disabled', true);
|
|
},
|
|
|
|
/* Re-enables disabled form elements:
|
|
- Replaces element text with cached value from 'ujs:enable-with' data store (created in `disableFormElements`)
|
|
- Sets disabled property to false
|
|
*/
|
|
enableFormElements: function(form) {
|
|
rails.formElements(form, rails.enableSelector).each(function() {
|
|
rails.enableFormElement($(this));
|
|
});
|
|
},
|
|
|
|
enableFormElement: function(element) {
|
|
var method = element.is('button') ? 'html' : 'val';
|
|
if (element.data('ujs:enable-with') !== undefined) {
|
|
element[method](element.data('ujs:enable-with'));
|
|
element.removeData('ujs:enable-with'); // clean up cache
|
|
}
|
|
element.prop('disabled', false);
|
|
element.removeData('ujs:disabled');
|
|
},
|
|
|
|
/* For 'data-confirm' attribute:
|
|
- Fires `confirm` event
|
|
- Shows the confirmation dialog
|
|
- Fires the `confirm:complete` event
|
|
|
|
Returns `true` if no function stops the chain and user chose yes; `false` otherwise.
|
|
Attaching a handler to the element's `confirm` event that returns a `falsy` value cancels the confirmation dialog.
|
|
Attaching a handler to the element's `confirm:complete` event that returns a `falsy` value makes this function
|
|
return false. The `confirm:complete` event is fired whether or not the user answered true or false to the dialog.
|
|
*/
|
|
allowAction: function(element) {
|
|
var message = element.data('confirm'),
|
|
answer = false, callback;
|
|
if (!message) { return true; }
|
|
|
|
if (rails.fire(element, 'confirm')) {
|
|
try {
|
|
answer = rails.confirm(message);
|
|
} catch (e) {
|
|
(console.error || console.log).call(console, e.stack || e);
|
|
}
|
|
callback = rails.fire(element, 'confirm:complete', [answer]);
|
|
}
|
|
return answer && callback;
|
|
},
|
|
|
|
// Helper function which checks for blank inputs in a form that match the specified CSS selector
|
|
blankInputs: function(form, specifiedSelector, nonBlank) {
|
|
var foundInputs = $(),
|
|
input,
|
|
valueToCheck,
|
|
radiosForNameWithNoneSelected,
|
|
radioName,
|
|
selector = specifiedSelector || 'input,textarea',
|
|
requiredInputs = form.find(selector),
|
|
checkedRadioButtonNames = {};
|
|
|
|
requiredInputs.each(function() {
|
|
input = $(this);
|
|
if (input.is('input[type=radio]')) {
|
|
|
|
// Don't count unchecked required radio as blank if other radio with same name is checked,
|
|
// regardless of whether same-name radio input has required attribute or not. The spec
|
|
// states https://www.w3.org/TR/html5/forms.html#the-required-attribute
|
|
radioName = input.attr('name');
|
|
|
|
// Skip if we've already seen the radio with this name.
|
|
if (!checkedRadioButtonNames[radioName]) {
|
|
|
|
// If none checked
|
|
if (form.find('input[type=radio]:checked[name="' + radioName + '"]').length === 0) {
|
|
radiosForNameWithNoneSelected = form.find(
|
|
'input[type=radio][name="' + radioName + '"]');
|
|
foundInputs = foundInputs.add(radiosForNameWithNoneSelected);
|
|
}
|
|
|
|
// We only need to check each name once.
|
|
checkedRadioButtonNames[radioName] = radioName;
|
|
}
|
|
} else {
|
|
valueToCheck = input.is('input[type=checkbox],input[type=radio]') ? input.is(':checked') : !!input.val();
|
|
if (valueToCheck === nonBlank) {
|
|
foundInputs = foundInputs.add(input);
|
|
}
|
|
}
|
|
});
|
|
return foundInputs.length ? foundInputs : false;
|
|
},
|
|
|
|
// Helper function which checks for non-blank inputs in a form that match the specified CSS selector
|
|
nonBlankInputs: function(form, specifiedSelector) {
|
|
return rails.blankInputs(form, specifiedSelector, true); // true specifies nonBlank
|
|
},
|
|
|
|
// Helper function, needed to provide consistent behavior in IE
|
|
stopEverything: function(e) {
|
|
$(e.target).trigger('ujs:everythingStopped');
|
|
e.stopImmediatePropagation();
|
|
return false;
|
|
},
|
|
|
|
// Replace element's html with the 'data-disable-with' after storing original html
|
|
// and prevent clicking on it
|
|
disableElement: function(element) {
|
|
var replacement = element.data('disable-with');
|
|
|
|
if (replacement !== undefined) {
|
|
element.data('ujs:enable-with', element.html()); // store enabled state
|
|
element.html(replacement);
|
|
}
|
|
|
|
element.bind('click.railsDisable', function(e) { // prevent further clicking
|
|
return rails.stopEverything(e);
|
|
});
|
|
element.data('ujs:disabled', true);
|
|
},
|
|
|
|
// Restore element to its original state which was disabled by 'disableElement' above
|
|
enableElement: function(element) {
|
|
if (element.data('ujs:enable-with') !== undefined) {
|
|
element.html(element.data('ujs:enable-with')); // set to old enabled state
|
|
element.removeData('ujs:enable-with'); // clean up cache
|
|
}
|
|
element.unbind('click.railsDisable'); // enable element
|
|
element.removeData('ujs:disabled');
|
|
}
|
|
};
|
|
|
|
if (rails.fire($document, 'rails:attachBindings')) {
|
|
|
|
$.ajaxPrefilter(function(options, originalOptions, xhr){ if ( !options.crossDomain ) { rails.CSRFProtection(xhr); }});
|
|
|
|
// This event works the same as the load event, except that it fires every
|
|
// time the page is loaded.
|
|
//
|
|
// See https://github.com/rails/jquery-ujs/issues/357
|
|
// See https://developer.mozilla.org/en-US/docs/Using_Firefox_1.5_caching
|
|
$(window).on('pageshow.rails', function () {
|
|
$($.rails.enableSelector).each(function () {
|
|
var element = $(this);
|
|
|
|
if (element.data('ujs:disabled')) {
|
|
$.rails.enableFormElement(element);
|
|
}
|
|
});
|
|
|
|
$($.rails.linkDisableSelector).each(function () {
|
|
var element = $(this);
|
|
|
|
if (element.data('ujs:disabled')) {
|
|
$.rails.enableElement(element);
|
|
}
|
|
});
|
|
});
|
|
|
|
$document.on('ajax:complete', rails.linkDisableSelector, function() {
|
|
rails.enableElement($(this));
|
|
});
|
|
|
|
$document.on('ajax:complete', rails.buttonDisableSelector, function() {
|
|
rails.enableFormElement($(this));
|
|
});
|
|
|
|
$document.on('click.rails', rails.linkClickSelector, function(e) {
|
|
var link = $(this), method = link.data('method'), data = link.data('params'), metaClick = e.metaKey || e.ctrlKey;
|
|
if (!rails.allowAction(link)) return rails.stopEverything(e);
|
|
|
|
if (!metaClick && link.is(rails.linkDisableSelector)) rails.disableElement(link);
|
|
|
|
if (rails.isRemote(link)) {
|
|
if (metaClick && (!method || method === 'GET') && !data) { return true; }
|
|
|
|
var handleRemote = rails.handleRemote(link);
|
|
// Response from rails.handleRemote() will either be false or a deferred object promise.
|
|
if (handleRemote === false) {
|
|
rails.enableElement(link);
|
|
} else {
|
|
handleRemote.fail( function() { rails.enableElement(link); } );
|
|
}
|
|
return false;
|
|
|
|
} else if (method) {
|
|
rails.handleMethod(link);
|
|
return false;
|
|
}
|
|
});
|
|
|
|
$document.on('click.rails', rails.buttonClickSelector, function(e) {
|
|
var button = $(this);
|
|
|
|
if (!rails.allowAction(button) || !rails.isRemote(button)) return rails.stopEverything(e);
|
|
|
|
if (button.is(rails.buttonDisableSelector)) rails.disableFormElement(button);
|
|
|
|
var handleRemote = rails.handleRemote(button);
|
|
// Response from rails.handleRemote() will either be false or a deferred object promise.
|
|
if (handleRemote === false) {
|
|
rails.enableFormElement(button);
|
|
} else {
|
|
handleRemote.fail( function() { rails.enableFormElement(button); } );
|
|
}
|
|
return false;
|
|
});
|
|
|
|
$document.on('change.rails', rails.inputChangeSelector, function(e) {
|
|
var link = $(this);
|
|
if (!rails.allowAction(link) || !rails.isRemote(link)) return rails.stopEverything(e);
|
|
|
|
rails.handleRemote(link);
|
|
return false;
|
|
});
|
|
|
|
$document.on('submit.rails', rails.formSubmitSelector, function(e) {
|
|
var form = $(this),
|
|
remote = rails.isRemote(form),
|
|
blankRequiredInputs,
|
|
nonBlankFileInputs;
|
|
|
|
if (!rails.allowAction(form)) return rails.stopEverything(e);
|
|
|
|
// Skip other logic when required values are missing or file upload is present
|
|
if (form.attr('novalidate') === undefined) {
|
|
if (form.data('ujs:formnovalidate-button') === undefined) {
|
|
blankRequiredInputs = rails.blankInputs(form, rails.requiredInputSelector, false);
|
|
if (blankRequiredInputs && rails.fire(form, 'ajax:aborted:required', [blankRequiredInputs])) {
|
|
return rails.stopEverything(e);
|
|
}
|
|
} else {
|
|
// Clear the formnovalidate in case the next button click is not on a formnovalidate button
|
|
// Not strictly necessary to do here, since it is also reset on each button click, but just to be certain
|
|
form.data('ujs:formnovalidate-button', undefined);
|
|
}
|
|
}
|
|
|
|
if (remote) {
|
|
nonBlankFileInputs = rails.nonBlankInputs(form, rails.fileInputSelector);
|
|
if (nonBlankFileInputs) {
|
|
// Slight timeout so that the submit button gets properly serialized
|
|
// (make it easy for event handler to serialize form without disabled values)
|
|
setTimeout(function(){ rails.disableFormElements(form); }, 13);
|
|
var aborted = rails.fire(form, 'ajax:aborted:file', [nonBlankFileInputs]);
|
|
|
|
// Re-enable form elements if event bindings return false (canceling normal form submission)
|
|
if (!aborted) { setTimeout(function(){ rails.enableFormElements(form); }, 13); }
|
|
|
|
return aborted;
|
|
}
|
|
|
|
rails.handleRemote(form);
|
|
return false;
|
|
|
|
} else {
|
|
// Slight timeout so that the submit button gets properly serialized
|
|
setTimeout(function(){ rails.disableFormElements(form); }, 13);
|
|
}
|
|
});
|
|
|
|
$document.on('click.rails', rails.formInputClickSelector, function(event) {
|
|
var button = $(this);
|
|
|
|
if (!rails.allowAction(button)) return rails.stopEverything(event);
|
|
|
|
// Register the pressed submit button
|
|
var name = button.attr('name'),
|
|
data = name ? {name:name, value:button.val()} : null;
|
|
|
|
var form = button.closest('form');
|
|
if (form.length === 0) {
|
|
form = $('#' + button.attr('form'));
|
|
}
|
|
form.data('ujs:submit-button', data);
|
|
|
|
// Save attributes from button
|
|
form.data('ujs:formnovalidate-button', button.attr('formnovalidate'));
|
|
form.data('ujs:submit-button-formaction', button.attr('formaction'));
|
|
form.data('ujs:submit-button-formmethod', button.attr('formmethod'));
|
|
});
|
|
|
|
$document.on('ajax:send.rails', rails.formSubmitSelector, function(event) {
|
|
if (this === event.target) rails.disableFormElements($(this));
|
|
});
|
|
|
|
$document.on('ajax:complete.rails', rails.formSubmitSelector, function(event) {
|
|
if (this === event.target) rails.enableFormElements($(this));
|
|
});
|
|
|
|
$(function(){
|
|
rails.refreshCSRFTokens();
|
|
});
|
|
}
|
|
|
|
})( jQuery );
|
|
(function() {
|
|
window.ActiveAdmin = {};
|
|
|
|
}).call(this);
|
|
(function() {
|
|
var onDOMReady;
|
|
|
|
onDOMReady = function() {
|
|
$('.batch_actions_selector li a').click(function(e) {
|
|
var message;
|
|
e.stopPropagation();
|
|
e.preventDefault();
|
|
if (message = $(this).data('confirm')) {
|
|
return ActiveAdmin.modal_dialog(message, $(this).data('inputs'), (function(_this) {
|
|
return function(inputs) {
|
|
return $(_this).trigger('confirm:complete', inputs);
|
|
};
|
|
})(this));
|
|
} else {
|
|
return $(this).trigger('confirm:complete');
|
|
}
|
|
});
|
|
$('.batch_actions_selector li a').on('confirm:complete', function(e, inputs) {
|
|
var val;
|
|
if (val = JSON.stringify(inputs)) {
|
|
$('#batch_action_inputs').removeAttr('disabled').val(val);
|
|
} else {
|
|
$('#batch_action_inputs').attr('disabled', 'disabled');
|
|
}
|
|
$('#batch_action').val($(this).data('action'));
|
|
return $('#collection_selection').submit();
|
|
});
|
|
if ($(".batch_actions_selector").length && $(":checkbox.toggle_all").length) {
|
|
if ($(".paginated_collection table.index_table").length) {
|
|
$(".paginated_collection table.index_table").tableCheckboxToggler();
|
|
} else {
|
|
$(".paginated_collection").checkboxToggler();
|
|
}
|
|
return $(document).on('change', '.paginated_collection :checkbox', function() {
|
|
if ($(".paginated_collection :checkbox:checked").length) {
|
|
return $(".batch_actions_selector").each(function() {
|
|
return $(this).aaDropdownMenu("enable");
|
|
});
|
|
} else {
|
|
return $(".batch_actions_selector").each(function() {
|
|
return $(this).aaDropdownMenu("disable");
|
|
});
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
$(document).ready(onDOMReady).on('page:load turbolinks:load', onDOMReady);
|
|
|
|
}).call(this);
|
|
(function() {
|
|
ActiveAdmin.CheckboxToggler = (function() {
|
|
function CheckboxToggler(options, container) {
|
|
var defaults;
|
|
this.options = options;
|
|
this.container = container;
|
|
defaults = {};
|
|
this.options = $.extend(defaults, this.options);
|
|
this._init();
|
|
this._bind();
|
|
}
|
|
|
|
CheckboxToggler.prototype._init = function() {
|
|
if (!this.container) {
|
|
throw new Error('Container element not found');
|
|
} else {
|
|
this.$container = $(this.container);
|
|
}
|
|
if (!this.$container.find('.toggle_all').length) {
|
|
throw new Error('"toggle all" checkbox not found');
|
|
} else {
|
|
this.toggle_all_checkbox = this.$container.find('.toggle_all');
|
|
}
|
|
return this.checkboxes = this.$container.find(':checkbox').not(this.toggle_all_checkbox);
|
|
};
|
|
|
|
CheckboxToggler.prototype._bind = function() {
|
|
this.checkboxes.change((function(_this) {
|
|
return function(e) {
|
|
return _this._didChangeCheckbox(e.target);
|
|
};
|
|
})(this));
|
|
return this.toggle_all_checkbox.change((function(_this) {
|
|
return function() {
|
|
return _this._didChangeToggleAllCheckbox();
|
|
};
|
|
})(this));
|
|
};
|
|
|
|
CheckboxToggler.prototype._didChangeCheckbox = function(checkbox) {
|
|
var allChecked, numChecked, someChecked;
|
|
numChecked = this.checkboxes.filter(':checked').length;
|
|
allChecked = numChecked === this.checkboxes.length;
|
|
someChecked = numChecked > 0 && numChecked < this.checkboxes.length;
|
|
return this.toggle_all_checkbox.prop({
|
|
checked: allChecked,
|
|
indeterminate: someChecked
|
|
});
|
|
};
|
|
|
|
CheckboxToggler.prototype._didChangeToggleAllCheckbox = function() {
|
|
var setting;
|
|
setting = this.toggle_all_checkbox.prop('checked');
|
|
this.checkboxes.prop({
|
|
checked: setting
|
|
});
|
|
return setting;
|
|
};
|
|
|
|
CheckboxToggler.prototype.option = function(key, value) {
|
|
if ($.isPlainObject(key)) {
|
|
return this.options = $.extend(true, this.options, key);
|
|
} else if (key != null) {
|
|
return this.options[key];
|
|
} else {
|
|
return this.options[key] = value;
|
|
}
|
|
};
|
|
|
|
return CheckboxToggler;
|
|
|
|
})();
|
|
|
|
$.widget.bridge('checkboxToggler', ActiveAdmin.CheckboxToggler);
|
|
|
|
}).call(this);
|
|
(function() {
|
|
var onDOMReady;
|
|
|
|
ActiveAdmin.DropdownMenu = (function() {
|
|
function DropdownMenu(options, element) {
|
|
var defaults;
|
|
this.options = options;
|
|
this.element = element;
|
|
this.$element = $(this.element);
|
|
defaults = {
|
|
fadeInDuration: 20,
|
|
fadeOutDuration: 100,
|
|
onClickActionItemCallback: null
|
|
};
|
|
this.options = $.extend(defaults, this.options);
|
|
this.isOpen = false;
|
|
this.$menuButton = this.$element.find('.dropdown_menu_button');
|
|
this.$menuList = this.$element.find('.dropdown_menu_list_wrapper');
|
|
this._buildMenuList();
|
|
this._bind();
|
|
}
|
|
|
|
DropdownMenu.prototype.open = function() {
|
|
this.isOpen = true;
|
|
this.$menuList.fadeIn(this.options.fadeInDuration);
|
|
this._position();
|
|
return this;
|
|
};
|
|
|
|
DropdownMenu.prototype.close = function() {
|
|
this.isOpen = false;
|
|
this.$menuList.fadeOut(this.options.fadeOutDuration);
|
|
return this;
|
|
};
|
|
|
|
DropdownMenu.prototype.destroy = function() {
|
|
this.$element = null;
|
|
return this;
|
|
};
|
|
|
|
DropdownMenu.prototype.isDisabled = function() {
|
|
return this.$menuButton.hasClass('disabled');
|
|
};
|
|
|
|
DropdownMenu.prototype.disable = function() {
|
|
return this.$menuButton.addClass('disabled');
|
|
};
|
|
|
|
DropdownMenu.prototype.enable = function() {
|
|
return this.$menuButton.removeClass('disabled');
|
|
};
|
|
|
|
DropdownMenu.prototype.option = function(key, value) {
|
|
if ($.isPlainObject(key)) {
|
|
return this.options = $.extend(true, this.options, key);
|
|
} else if (key != null) {
|
|
return this.options[key];
|
|
} else {
|
|
return this.options[key] = value;
|
|
}
|
|
};
|
|
|
|
DropdownMenu.prototype._buildMenuList = function() {
|
|
this.$nipple = $('<div class="dropdown_menu_nipple"></div>');
|
|
this.$menuList.prepend(this.$nipple);
|
|
return this.$menuList.hide();
|
|
};
|
|
|
|
DropdownMenu.prototype._bind = function() {
|
|
$('body').click((function(_this) {
|
|
return function() {
|
|
if (_this.isOpen) {
|
|
return _this.close();
|
|
}
|
|
};
|
|
})(this));
|
|
return this.$menuButton.click((function(_this) {
|
|
return function() {
|
|
if (!_this.isDisabled()) {
|
|
if (_this.isOpen) {
|
|
_this.close();
|
|
} else {
|
|
_this.open();
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
})(this));
|
|
};
|
|
|
|
DropdownMenu.prototype._position = function() {
|
|
var button_center, button_left, button_right, centered_menu_left, centered_menu_right, menu_center, nipple_center, window_right;
|
|
this.$menuList.css('top', this.$menuButton.position().top + this.$menuButton.outerHeight() + 10);
|
|
button_left = this.$menuButton.position().left;
|
|
button_center = this.$menuButton.outerWidth() / 2;
|
|
button_right = button_left + button_center * 2;
|
|
menu_center = this.$menuList.outerWidth() / 2;
|
|
nipple_center = this.$nipple.outerWidth() / 2;
|
|
window_right = $(window).width();
|
|
centered_menu_left = button_left + button_center - menu_center;
|
|
centered_menu_right = button_left + button_center + menu_center;
|
|
if (centered_menu_left < 0) {
|
|
this.$menuList.css('left', button_left);
|
|
return this.$nipple.css('left', button_center - nipple_center);
|
|
} else if (centered_menu_right > window_right) {
|
|
this.$menuList.css('right', window_right - button_right);
|
|
return this.$nipple.css('right', button_center - nipple_center);
|
|
} else {
|
|
this.$menuList.css('left', centered_menu_left);
|
|
return this.$nipple.css('left', menu_center - nipple_center);
|
|
}
|
|
};
|
|
|
|
return DropdownMenu;
|
|
|
|
})();
|
|
|
|
$.widget.bridge('aaDropdownMenu', ActiveAdmin.DropdownMenu);
|
|
|
|
onDOMReady = function() {
|
|
return $('.dropdown_menu').aaDropdownMenu();
|
|
};
|
|
|
|
$(document).ready(onDOMReady).on('page:load turbolinks:load', onDOMReady);
|
|
|
|
}).call(this);
|
|
(function() {
|
|
var Flash;
|
|
|
|
ActiveAdmin.flash = Flash = (function() {
|
|
Flash.error = function(message, close_after) {
|
|
return new this(message, "error", close_after);
|
|
};
|
|
|
|
Flash.notice = function(message, close_after) {
|
|
return new this(message, "notice", close_after);
|
|
};
|
|
|
|
Flash.prototype.reference = function() {
|
|
return this.reference;
|
|
};
|
|
|
|
function Flash(message1, type, close_after) {
|
|
this.message = message1;
|
|
this.type = type != null ? type : "notice";
|
|
this.reference = jQuery("<div>").addClass("flash flash_" + this.type).text(this.message);
|
|
jQuery(".flashes").append(this.reference);
|
|
if (close_after != null) {
|
|
this.close_after(close_after);
|
|
}
|
|
}
|
|
|
|
Flash.prototype.close_after = function(close_after) {
|
|
return setTimeout((function(_this) {
|
|
return function() {
|
|
return _this.close();
|
|
};
|
|
})(this), close_after * 1000);
|
|
};
|
|
|
|
Flash.prototype.close = function() {
|
|
return this.reference.remove();
|
|
};
|
|
|
|
return Flash;
|
|
|
|
})();
|
|
|
|
}).call(this);
|
|
(function() {
|
|
var init_sortable, recompute_positions;
|
|
|
|
$(function() {
|
|
$(document).on('click', 'a.button.has_many_remove', function(e) {
|
|
var parent, to_remove;
|
|
e.preventDefault();
|
|
parent = $(this).closest('.has_many_container');
|
|
to_remove = $(this).closest('fieldset');
|
|
recompute_positions(parent);
|
|
parent.trigger('has_many_remove:before', [to_remove, parent]);
|
|
to_remove.remove();
|
|
return parent.trigger('has_many_remove:after', [to_remove, parent]);
|
|
});
|
|
$(document).on('click', 'a.button.has_many_add', function(e) {
|
|
var before_add, fieldset, html, index, parent, regex;
|
|
e.preventDefault();
|
|
parent = $(this).closest('.has_many_container');
|
|
parent.trigger(before_add = $.Event('has_many_add:before'), [parent]);
|
|
if (!before_add.isDefaultPrevented()) {
|
|
index = parent.data('has_many_index') || parent.children('fieldset').length - 1;
|
|
parent.data({
|
|
has_many_index: ++index
|
|
});
|
|
regex = new RegExp($(this).data('placeholder'), 'g');
|
|
html = $(this).data('html').replace(regex, index);
|
|
fieldset = $(html).insertBefore(this);
|
|
recompute_positions(parent);
|
|
return parent.trigger('has_many_add:after', [fieldset, parent]);
|
|
}
|
|
});
|
|
$(document).on('change', '.has_many_container[data-sortable] :input[name$="[_destroy]"]', function() {
|
|
return recompute_positions($(this).closest('.has_many'));
|
|
});
|
|
init_sortable();
|
|
return $(document).on('has_many_add:after', '.has_many_container', init_sortable);
|
|
});
|
|
|
|
init_sortable = function() {
|
|
var elems;
|
|
elems = $('.has_many_container[data-sortable]:not(.ui-sortable)');
|
|
elems.sortable({
|
|
items: '> fieldset',
|
|
handle: '> ol > .handle',
|
|
stop: recompute_positions
|
|
});
|
|
return elems.each(recompute_positions);
|
|
};
|
|
|
|
recompute_positions = function(parent) {
|
|
var input_name, position;
|
|
parent = parent instanceof jQuery ? parent : $(this);
|
|
input_name = parent.data('sortable');
|
|
position = parseInt(parent.data('sortable-start') || 0, 10);
|
|
return parent.children('fieldset').each(function() {
|
|
var destroy_input, sortable_input;
|
|
destroy_input = $(this).find("> ol > .input > :input[name$='[_destroy]']");
|
|
sortable_input = $(this).find("> ol > .input > :input[name$='[" + input_name + "]']");
|
|
if (sortable_input.length) {
|
|
return sortable_input.val(destroy_input.is(':checked') ? '' : position++);
|
|
}
|
|
});
|
|
};
|
|
|
|
}).call(this);
|
|
(function() {
|
|
ActiveAdmin.modal_dialog = function(message, inputs, callback) {
|
|
var $elem, elem, form, html, klass, name, opts, ref, ref1, type, v, wrapper;
|
|
html = "<form id=\"dialog_confirm\" title=\"" + message + "\"><ul>";
|
|
for (name in inputs) {
|
|
type = inputs[name];
|
|
if (/^(datepicker|checkbox|text|number)$/.test(type)) {
|
|
wrapper = 'input';
|
|
} else if (type === 'textarea') {
|
|
wrapper = 'textarea';
|
|
} else if ($.isArray(type)) {
|
|
ref = ['select', 'option', type, ''], wrapper = ref[0], elem = ref[1], opts = ref[2], type = ref[3];
|
|
} else {
|
|
throw new Error("Unsupported input type: {" + name + ": " + type + "}");
|
|
}
|
|
klass = type === 'datepicker' ? type : '';
|
|
html += ("<li>\n<label>" + (name.charAt(0).toUpperCase() + name.slice(1)) + "</label>\n<" + wrapper + " name=\"" + name + "\" class=\"" + klass + "\" type=\"" + type + "\">") + (opts ? ((function() {
|
|
var i, len, results;
|
|
results = [];
|
|
for (i = 0, len = opts.length; i < len; i++) {
|
|
v = opts[i];
|
|
$elem = $("<" + elem + "/>");
|
|
if ($.isArray(v)) {
|
|
$elem.text(v[0]).val(v[1]);
|
|
} else {
|
|
$elem.text(v);
|
|
}
|
|
results.push($elem.wrap('<div>').parent().html());
|
|
}
|
|
return results;
|
|
})()).join('') : '') + ("</" + wrapper + ">") + "</li>";
|
|
ref1 = [], wrapper = ref1[0], elem = ref1[1], opts = ref1[2], type = ref1[3], klass = ref1[4];
|
|
}
|
|
html += "</ul></form>";
|
|
form = $(html).appendTo('body');
|
|
$('body').trigger('modal_dialog:before_open', [form]);
|
|
return form.dialog({
|
|
modal: true,
|
|
open: function(event, ui) {
|
|
return $('body').trigger('modal_dialog:after_open', [form]);
|
|
},
|
|
dialogClass: 'active_admin_dialog',
|
|
buttons: {
|
|
OK: function() {
|
|
callback($(this).serializeObject());
|
|
return $(this).dialog('close');
|
|
},
|
|
Cancel: function() {
|
|
return $(this).dialog('close').remove();
|
|
}
|
|
}
|
|
});
|
|
};
|
|
|
|
}).call(this);
|
|
(function() {
|
|
var onDOMReady;
|
|
|
|
ActiveAdmin.PerPage = (function() {
|
|
function PerPage(options, element) {
|
|
this.options = options;
|
|
this.element = element;
|
|
this.$element = $(this.element);
|
|
this._init();
|
|
this._bind();
|
|
}
|
|
|
|
PerPage.prototype._init = function() {
|
|
return this.$params = this._queryParams();
|
|
};
|
|
|
|
PerPage.prototype._bind = function() {
|
|
return this.$element.change((function(_this) {
|
|
return function() {
|
|
_this.$params['per_page'] = _this.$element.val();
|
|
delete _this.$params['page'];
|
|
if (typeof Turbolinks !== 'undefined') {
|
|
return Turbolinks.visit(window.location.href.split('?')[0] + '?' + $.param(_this.$params));
|
|
} else {
|
|
return location.search = $.param(_this.$params);
|
|
}
|
|
};
|
|
})(this));
|
|
};
|
|
|
|
PerPage.prototype._queryParams = function() {
|
|
var m, params, query, re;
|
|
query = window.location.search.substring(1);
|
|
params = {};
|
|
re = /([^&=]+)=([^&]*)/g;
|
|
while (m = re.exec(query)) {
|
|
params[this._decode(m[1])] = this._decode(m[2]);
|
|
}
|
|
return params;
|
|
};
|
|
|
|
PerPage.prototype._decode = function(value) {
|
|
return decodeURIComponent(value.replace(/\+/g, '%20'));
|
|
};
|
|
|
|
PerPage.prototype.option = function(key, value) {
|
|
if ($.isPlainObject(key)) {
|
|
return this.options = $.extend(true, this.options, key);
|
|
} else if (key != null) {
|
|
return this.options[key];
|
|
} else {
|
|
return this.options[key] = value;
|
|
}
|
|
};
|
|
|
|
return PerPage;
|
|
|
|
})();
|
|
|
|
$.widget.bridge('perPage', ActiveAdmin.PerPage);
|
|
|
|
onDOMReady = function() {
|
|
return $('.pagination_per_page select').perPage();
|
|
};
|
|
|
|
$(document).ready(onDOMReady).on('page:load turbolinks:load', onDOMReady);
|
|
|
|
}).call(this);
|
|
(function() {
|
|
var extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
|
|
hasProp = {}.hasOwnProperty;
|
|
|
|
ActiveAdmin.TableCheckboxToggler = (function(superClass) {
|
|
extend(TableCheckboxToggler, superClass);
|
|
|
|
function TableCheckboxToggler() {
|
|
return TableCheckboxToggler.__super__.constructor.apply(this, arguments);
|
|
}
|
|
|
|
TableCheckboxToggler.prototype._init = function() {
|
|
return TableCheckboxToggler.__super__._init.apply(this, arguments);
|
|
};
|
|
|
|
TableCheckboxToggler.prototype._bind = function() {
|
|
TableCheckboxToggler.__super__._bind.apply(this, arguments);
|
|
return this.$container.find('tbody td').click((function(_this) {
|
|
return function(e) {
|
|
if (e.target.type !== 'checkbox') {
|
|
return _this._didClickCell(e.target);
|
|
}
|
|
};
|
|
})(this));
|
|
};
|
|
|
|
TableCheckboxToggler.prototype._didChangeCheckbox = function(checkbox) {
|
|
TableCheckboxToggler.__super__._didChangeCheckbox.apply(this, arguments);
|
|
return $(checkbox).parents('tr').toggleClass('selected', checkbox.checked);
|
|
};
|
|
|
|
TableCheckboxToggler.prototype._didChangeToggleAllCheckbox = function() {
|
|
return this.$container.find('tbody tr').toggleClass('selected', TableCheckboxToggler.__super__._didChangeToggleAllCheckbox.apply(this, arguments));
|
|
};
|
|
|
|
TableCheckboxToggler.prototype._didClickCell = function(cell) {
|
|
return $(cell).parent('tr').find(':checkbox').click();
|
|
};
|
|
|
|
return TableCheckboxToggler;
|
|
|
|
})(ActiveAdmin.CheckboxToggler);
|
|
|
|
$.widget.bridge('tableCheckboxToggler', ActiveAdmin.TableCheckboxToggler);
|
|
|
|
}).call(this);
|
|
(function() {
|
|
$.ui.dialog.prototype._focusTabbable = function() {
|
|
return this.uiDialog.focus();
|
|
};
|
|
|
|
}).call(this);
|
|
(function() {
|
|
$.fn.serializeObject = function() {
|
|
var i, len, o, obj, ref;
|
|
obj = {};
|
|
ref = this.serializeArray();
|
|
for (i = 0, len = ref.length; i < len; i++) {
|
|
o = ref[i];
|
|
obj[o.name] = o.value;
|
|
}
|
|
return obj;
|
|
};
|
|
|
|
}).call(this);
|
|
(function() {
|
|
var onDOMReady;
|
|
|
|
onDOMReady = function() {
|
|
var batch_actions_selector;
|
|
if ((batch_actions_selector = $('.table_tools .batch_actions_selector')).length) {
|
|
return batch_actions_selector.next().css({
|
|
width: "calc(100% - 10px - " + (batch_actions_selector.outerWidth()) + "px)",
|
|
'float': 'right'
|
|
});
|
|
}
|
|
};
|
|
|
|
$(document).ready(onDOMReady).on('page:load turbolinks:load', onDOMReady);
|
|
|
|
}).call(this);
|
|
(function() {
|
|
var onDOMReady;
|
|
|
|
onDOMReady = function() {
|
|
return $(document).on('focus', 'input.datepicker:not(.hasDatepicker)', function() {
|
|
var defaults, input, options;
|
|
input = $(this);
|
|
if (input[0].type === 'date') {
|
|
return;
|
|
}
|
|
defaults = {
|
|
dateFormat: 'yy-mm-dd'
|
|
};
|
|
options = input.data('datepicker-options');
|
|
return input.datepicker($.extend(defaults, options));
|
|
});
|
|
};
|
|
|
|
$(document).ready(onDOMReady).on('page:load turbolinks:load', onDOMReady);
|
|
|
|
}).call(this);
|
|
(function() {
|
|
var onDOMReady;
|
|
|
|
onDOMReady = function() {
|
|
$('.clear_filters_btn').click(function(e) {
|
|
var param, params, regex;
|
|
params = window.location.search.slice(1).split('&');
|
|
regex = /^(q\[|q%5B|q%5b|page|commit)/;
|
|
if (typeof Turbolinks !== 'undefined') {
|
|
Turbolinks.visit(window.location.href.split('?')[0] + '?' + ((function() {
|
|
var i, len, results;
|
|
results = [];
|
|
for (i = 0, len = params.length; i < len; i++) {
|
|
param = params[i];
|
|
if (!param.match(regex)) {
|
|
results.push(param);
|
|
}
|
|
}
|
|
return results;
|
|
})()).join('&'));
|
|
return e.preventDefault();
|
|
} else {
|
|
return window.location.search = ((function() {
|
|
var i, len, results;
|
|
results = [];
|
|
for (i = 0, len = params.length; i < len; i++) {
|
|
param = params[i];
|
|
if (!param.match(regex)) {
|
|
results.push(param);
|
|
}
|
|
}
|
|
return results;
|
|
})()).join('&');
|
|
}
|
|
});
|
|
$('.filter_form').submit(function(e) {
|
|
$(this).find(':input').filter(function() {
|
|
return this.value === '';
|
|
}).prop('disabled', true);
|
|
if (typeof Turbolinks !== 'undefined') {
|
|
Turbolinks.visit(window.location.href.split('?')[0] + '?' + $(this).serialize());
|
|
return e.preventDefault();
|
|
}
|
|
});
|
|
return $('.filter_form_field.select_and_search select').change(function() {
|
|
return $(this).siblings('input').prop({
|
|
name: "q[" + this.value + "]"
|
|
});
|
|
});
|
|
};
|
|
|
|
$(document).ready(onDOMReady).on('page:load turbolinks:load', onDOMReady);
|
|
|
|
}).call(this);
|
|
(function() {
|
|
var onDOMReady;
|
|
|
|
onDOMReady = function() {
|
|
return $('#active_admin_content .tabs').tabs();
|
|
};
|
|
|
|
$(document).ready(onDOMReady).on('page:load turbolinks:load', onDOMReady);
|
|
|
|
}).call(this);
|
|
/*!
|
|
* jQuery JavaScript Library v1.12.4
|
|
* http://jquery.com/
|
|
*
|
|
* Includes Sizzle.js
|
|
* http://sizzlejs.com/
|
|
*
|
|
* Copyright jQuery Foundation and other contributors
|
|
* Released under the MIT license
|
|
* http://jquery.org/license
|
|
*
|
|
* Date: 2016-05-20T17:17Z
|
|
*/
|
|
|
|
|
|
(function( global, factory ) {
|
|
|
|
if ( typeof module === "object" && typeof module.exports === "object" ) {
|
|
// For CommonJS and CommonJS-like environments where a proper `window`
|
|
// is present, execute the factory and get jQuery.
|
|
// For environments that do not have a `window` with a `document`
|
|
// (such as Node.js), expose a factory as module.exports.
|
|
// This accentuates the need for the creation of a real `window`.
|
|
// e.g. var jQuery = require("jquery")(window);
|
|
// See ticket #14549 for more info.
|
|
module.exports = global.document ?
|
|
factory( global, true ) :
|
|
function( w ) {
|
|
if ( !w.document ) {
|
|
throw new Error( "jQuery requires a window with a document" );
|
|
}
|
|
return factory( w );
|
|
};
|
|
} else {
|
|
factory( global );
|
|
}
|
|
|
|
// Pass this if window is not defined yet
|
|
}(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
|
|
|
|
// Support: Firefox 18+
|
|
// Can't be in strict mode, several libs including ASP.NET trace
|
|
// the stack via arguments.caller.callee and Firefox dies if
|
|
// you try to trace through "use strict" call chains. (#13335)
|
|
//"use strict";
|
|
var deletedIds = [];
|
|
|
|
var document = window.document;
|
|
|
|
var slice = deletedIds.slice;
|
|
|
|
var concat = deletedIds.concat;
|
|
|
|
var push = deletedIds.push;
|
|
|
|
var indexOf = deletedIds.indexOf;
|
|
|
|
var class2type = {};
|
|
|
|
var toString = class2type.toString;
|
|
|
|
var hasOwn = class2type.hasOwnProperty;
|
|
|
|
var support = {};
|
|
|
|
|
|
|
|
var
|
|
version = "1.12.4",
|
|
|
|
// 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 );
|
|
},
|
|
|
|
// Support: Android<4.1, IE<9
|
|
// Make sure we trim BOM and NBSP
|
|
rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
|
|
|
|
// Matches dashed string for camelizing
|
|
rmsPrefix = /^-ms-/,
|
|
rdashAlpha = /-([\da-z])/gi,
|
|
|
|
// Used by jQuery.camelCase as callback to replace()
|
|
fcamelCase = function( all, letter ) {
|
|
return letter.toUpperCase();
|
|
};
|
|
|
|
jQuery.fn = jQuery.prototype = {
|
|
|
|
// The current version of jQuery being used
|
|
jquery: version,
|
|
|
|
constructor: jQuery,
|
|
|
|
// Start with an empty selector
|
|
selector: "",
|
|
|
|
// 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 num != null ?
|
|
|
|
// Return just the one element from the set
|
|
( num < 0 ? this[ num + this.length ] : this[ num ] ) :
|
|
|
|
// Return all the elements in a clean array
|
|
slice.call( this );
|
|
},
|
|
|
|
// 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;
|
|
ret.context = this.context;
|
|
|
|
// 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 );
|
|
},
|
|
|
|
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: deletedIds.sort,
|
|
splice: deletedIds.splice
|
|
};
|
|
|
|
jQuery.extend = jQuery.fn.extend = function() {
|
|
var src, copyIsArray, copy, name, options, 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" && !jQuery.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 ) {
|
|
src = target[ name ];
|
|
copy = options[ name ];
|
|
|
|
// Prevent never-ending loop
|
|
if ( target === copy ) {
|
|
continue;
|
|
}
|
|
|
|
// Recurse if we're merging plain objects or arrays
|
|
if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
|
|
( copyIsArray = jQuery.isArray( copy ) ) ) ) {
|
|
|
|
if ( copyIsArray ) {
|
|
copyIsArray = false;
|
|
clone = src && jQuery.isArray( src ) ? src : [];
|
|
|
|
} else {
|
|
clone = src && jQuery.isPlainObject( src ) ? src : {};
|
|
}
|
|
|
|
// 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() {},
|
|
|
|
// See test/unit/core.js for details concerning isFunction.
|
|
// Since version 1.3, DOM methods and functions like alert
|
|
// aren't supported. They return false on IE (#2968).
|
|
isFunction: function( obj ) {
|
|
return jQuery.type( obj ) === "function";
|
|
},
|
|
|
|
isArray: Array.isArray || function( obj ) {
|
|
return jQuery.type( obj ) === "array";
|
|
},
|
|
|
|
isWindow: function( obj ) {
|
|
/* jshint eqeqeq: false */
|
|
return obj != null && obj == obj.window;
|
|
},
|
|
|
|
isNumeric: function( obj ) {
|
|
|
|
// parseFloat NaNs numeric-cast false positives (null|true|false|"")
|
|
// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
|
|
// subtraction forces infinities to NaN
|
|
// adding 1 corrects loss of precision from parseFloat (#15100)
|
|
var realStringObj = obj && obj.toString();
|
|
return !jQuery.isArray( obj ) && ( realStringObj - parseFloat( realStringObj ) + 1 ) >= 0;
|
|
},
|
|
|
|
isEmptyObject: function( obj ) {
|
|
var name;
|
|
for ( name in obj ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
},
|
|
|
|
isPlainObject: function( obj ) {
|
|
var key;
|
|
|
|
// Must be an Object.
|
|
// Because of IE, we also have to check the presence of the constructor property.
|
|
// Make sure that DOM nodes and window objects don't pass through, as well
|
|
if ( !obj || jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
|
|
// Not own constructor property must be Object
|
|
if ( obj.constructor &&
|
|
!hasOwn.call( obj, "constructor" ) &&
|
|
!hasOwn.call( obj.constructor.prototype, "isPrototypeOf" ) ) {
|
|
return false;
|
|
}
|
|
} catch ( e ) {
|
|
|
|
// IE8,9 Will throw exceptions on certain host objects #9897
|
|
return false;
|
|
}
|
|
|
|
// Support: IE<9
|
|
// Handle iteration over inherited properties before own properties.
|
|
if ( !support.ownFirst ) {
|
|
for ( key in obj ) {
|
|
return hasOwn.call( obj, key );
|
|
}
|
|
}
|
|
|
|
// Own properties are enumerated firstly, so to speed up,
|
|
// if last one is own, then all properties are own.
|
|
for ( key in obj ) {}
|
|
|
|
return key === undefined || hasOwn.call( obj, key );
|
|
},
|
|
|
|
type: function( obj ) {
|
|
if ( obj == null ) {
|
|
return obj + "";
|
|
}
|
|
return typeof obj === "object" || typeof obj === "function" ?
|
|
class2type[ toString.call( obj ) ] || "object" :
|
|
typeof obj;
|
|
},
|
|
|
|
// Workarounds based on findings by Jim Driscoll
|
|
// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
|
|
globalEval: function( data ) {
|
|
if ( data && jQuery.trim( data ) ) {
|
|
|
|
// We use execScript on Internet Explorer
|
|
// We use an anonymous function so that context is window
|
|
// rather than jQuery in Firefox
|
|
( window.execScript || function( data ) {
|
|
window[ "eval" ].call( window, data ); // jscs:ignore requireDotNotation
|
|
} )( data );
|
|
}
|
|
},
|
|
|
|
// Convert dashed to camelCase; used by the css and data modules
|
|
// Microsoft forgot to hump their vendor prefix (#9572)
|
|
camelCase: function( string ) {
|
|
return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
|
|
},
|
|
|
|
nodeName: function( elem, name ) {
|
|
return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
|
|
},
|
|
|
|
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;
|
|
},
|
|
|
|
// Support: Android<4.1, IE<9
|
|
trim: function( text ) {
|
|
return text == null ?
|
|
"" :
|
|
( text + "" ).replace( rtrim, "" );
|
|
},
|
|
|
|
// 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 ) {
|
|
var len;
|
|
|
|
if ( arr ) {
|
|
if ( indexOf ) {
|
|
return indexOf.call( arr, elem, i );
|
|
}
|
|
|
|
len = arr.length;
|
|
i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
|
|
|
|
for ( ; i < len; i++ ) {
|
|
|
|
// Skip accessing in sparse arrays
|
|
if ( i in arr && arr[ i ] === elem ) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
},
|
|
|
|
merge: function( first, second ) {
|
|
var len = +second.length,
|
|
j = 0,
|
|
i = first.length;
|
|
|
|
while ( j < len ) {
|
|
first[ i++ ] = second[ j++ ];
|
|
}
|
|
|
|
// Support: IE<9
|
|
// Workaround casting of .length to NaN on otherwise arraylike objects (e.g., NodeLists)
|
|
if ( len !== len ) {
|
|
while ( second[ j ] !== undefined ) {
|
|
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 concat.apply( [], ret );
|
|
},
|
|
|
|
// A global GUID counter for objects
|
|
guid: 1,
|
|
|
|
// Bind a function to a context, optionally partially applying any
|
|
// arguments.
|
|
proxy: function( fn, context ) {
|
|
var args, proxy, tmp;
|
|
|
|
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 ( !jQuery.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;
|
|
},
|
|
|
|
now: function() {
|
|
return +( new Date() );
|
|
},
|
|
|
|
// jQuery.support is not used in Core but other projects attach their
|
|
// properties to it so it needs to exist.
|
|
support: support
|
|
} );
|
|
|
|
// JSHint would error on this code due to the Symbol not being defined in ES5.
|
|
// Defining this global in .jshintrc would create a danger of using the global
|
|
// unguarded in another place, it seems safer to just disable JSHint for these
|
|
// three lines.
|
|
/* jshint ignore: start */
|
|
if ( typeof Symbol === "function" ) {
|
|
jQuery.fn[ Symbol.iterator ] = deletedIds[ Symbol.iterator ];
|
|
}
|
|
/* jshint ignore: end */
|
|
|
|
// 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: iOS 8.2 (not reproducible in simulator)
|
|
// `in` check used to prevent JIT error (gh-2145)
|
|
// hasOwn isn't used here due to false negatives
|
|
// regarding Nodelist length in IE
|
|
var length = !!obj && "length" in obj && obj.length,
|
|
type = jQuery.type( obj );
|
|
|
|
if ( type === "function" || jQuery.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.2.1
|
|
* http://sizzlejs.com/
|
|
*
|
|
* Copyright jQuery Foundation and other contributors
|
|
* Released under the MIT license
|
|
* http://jquery.org/license
|
|
*
|
|
* Date: 2015-10-17
|
|
*/
|
|
(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(),
|
|
sortOrder = function( a, b ) {
|
|
if ( a === b ) {
|
|
hasDuplicate = true;
|
|
}
|
|
return 0;
|
|
},
|
|
|
|
// General-purpose constants
|
|
MAX_NEGATIVE = 1 << 31,
|
|
|
|
// Instance methods
|
|
hasOwn = ({}).hasOwnProperty,
|
|
arr = [],
|
|
pop = arr.pop,
|
|
push_native = arr.push,
|
|
push = arr.push,
|
|
slice = arr.slice,
|
|
// Use a stripped-down indexOf as it's faster than native
|
|
// http://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]",
|
|
|
|
// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
|
|
identifier = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
|
|
|
|
// 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 + "*" ),
|
|
|
|
rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
|
|
|
|
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" )
|
|
},
|
|
|
|
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 = /[+~]/,
|
|
rescape = /'|\\/g,
|
|
|
|
// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
|
|
runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
|
|
funescape = function( _, escaped, escapedWhitespace ) {
|
|
var high = "0x" + escaped - 0x10000;
|
|
// NaN means non-codepoint
|
|
// Support: Firefox<24
|
|
// Workaround erroneous numeric interpretation of +"0x"
|
|
return high !== high || escapedWhitespace ?
|
|
escaped :
|
|
high < 0 ?
|
|
// BMP codepoint
|
|
String.fromCharCode( high + 0x10000 ) :
|
|
// Supplemental Plane codepoint (surrogate pair)
|
|
String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
|
|
},
|
|
|
|
// Used for iframes
|
|
// See setDocument()
|
|
// Removing the function wrapper causes a "Permission Denied"
|
|
// error in IE
|
|
unloadHandler = function() {
|
|
setDocument();
|
|
};
|
|
|
|
// Optimize for push.apply( _, NodeList )
|
|
try {
|
|
push.apply(
|
|
(arr = slice.call( preferredDoc.childNodes )),
|
|
preferredDoc.childNodes
|
|
);
|
|
// Support: Android<4.0
|
|
// Detect silently failing push.apply
|
|
arr[ preferredDoc.childNodes.length ].nodeType;
|
|
} catch ( e ) {
|
|
push = { apply: arr.length ?
|
|
|
|
// Leverage slice if possible
|
|
function( target, els ) {
|
|
push_native.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, nidselect, 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 ) {
|
|
|
|
if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
|
|
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 &&
|
|
!compilerCache[ selector + " " ] &&
|
|
(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
|
|
|
|
if ( nodeType !== 1 ) {
|
|
newContext = context;
|
|
newSelector = selector;
|
|
|
|
// qSA looks outside Element context, which is not what we want
|
|
// Thanks to Andrew Dupont for this workaround technique
|
|
// Support: IE <=8
|
|
// Exclude object elements
|
|
} else if ( context.nodeName.toLowerCase() !== "object" ) {
|
|
|
|
// Capture the context ID, setting it first if necessary
|
|
if ( (nid = context.getAttribute( "id" )) ) {
|
|
nid = nid.replace( rescape, "\\$&" );
|
|
} else {
|
|
context.setAttribute( "id", (nid = expando) );
|
|
}
|
|
|
|
// Prefix every selector in the list
|
|
groups = tokenize( selector );
|
|
i = groups.length;
|
|
nidselect = ridentifier.test( nid ) ? "#" + nid : "[id='" + nid + "']";
|
|
while ( i-- ) {
|
|
groups[i] = nidselect + " " + toSelector( groups[i] );
|
|
}
|
|
newSelector = groups.join( "," );
|
|
|
|
// Expand context for sibling selectors
|
|
newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
|
|
context;
|
|
}
|
|
|
|
if ( newSelector ) {
|
|
try {
|
|
push.apply( results,
|
|
newContext.querySelectorAll( newSelector )
|
|
);
|
|
return results;
|
|
} catch ( qsaError ) {
|
|
} 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 div and expects a boolean result
|
|
*/
|
|
function assert( fn ) {
|
|
var div = document.createElement("div");
|
|
|
|
try {
|
|
return !!fn( div );
|
|
} catch (e) {
|
|
return false;
|
|
} finally {
|
|
// Remove from its parent by default
|
|
if ( div.parentNode ) {
|
|
div.parentNode.removeChild( div );
|
|
}
|
|
// release memory in IE
|
|
div = 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 &&
|
|
( ~b.sourceIndex || MAX_NEGATIVE ) -
|
|
( ~a.sourceIndex || MAX_NEGATIVE );
|
|
|
|
// 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 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 ) {
|
|
// documentElement is verified for cases where it doesn't yet exist
|
|
// (such as loading iframes in IE - #4833)
|
|
var documentElement = elem && (elem.ownerDocument || elem).documentElement;
|
|
return documentElement ? documentElement.nodeName !== "HTML" : false;
|
|
};
|
|
|
|
/**
|
|
* 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, parent,
|
|
doc = node ? node.ownerDocument || node : preferredDoc;
|
|
|
|
// Return early if doc is invalid or already selected
|
|
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
|
|
// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
|
|
if ( (parent = document.defaultView) && parent.top !== parent ) {
|
|
// Support: IE 11
|
|
if ( parent.addEventListener ) {
|
|
parent.addEventListener( "unload", unloadHandler, false );
|
|
|
|
// Support: IE 9 - 10 only
|
|
} else if ( parent.attachEvent ) {
|
|
parent.attachEvent( "onunload", unloadHandler );
|
|
}
|
|
}
|
|
|
|
/* Attributes
|
|
---------------------------------------------------------------------- */
|
|
|
|
// Support: IE<8
|
|
// Verify that getAttribute really returns attributes and not properties
|
|
// (excepting IE8 booleans)
|
|
support.attributes = assert(function( div ) {
|
|
div.className = "i";
|
|
return !div.getAttribute("className");
|
|
});
|
|
|
|
/* getElement(s)By*
|
|
---------------------------------------------------------------------- */
|
|
|
|
// Check if getElementsByTagName("*") returns only elements
|
|
support.getElementsByTagName = assert(function( div ) {
|
|
div.appendChild( document.createComment("") );
|
|
return !div.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 programatically-set names,
|
|
// so use a roundabout getElementsByName test
|
|
support.getById = assert(function( div ) {
|
|
docElem.appendChild( div ).id = expando;
|
|
return !document.getElementsByName || !document.getElementsByName( expando ).length;
|
|
});
|
|
|
|
// ID find and filter
|
|
if ( support.getById ) {
|
|
Expr.find["ID"] = function( id, context ) {
|
|
if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
|
|
var m = context.getElementById( id );
|
|
return m ? [ m ] : [];
|
|
}
|
|
};
|
|
Expr.filter["ID"] = function( id ) {
|
|
var attrId = id.replace( runescape, funescape );
|
|
return function( elem ) {
|
|
return elem.getAttribute("id") === attrId;
|
|
};
|
|
};
|
|
} else {
|
|
// Support: IE6/7
|
|
// getElementById is not reliable as a find shortcut
|
|
delete Expr.find["ID"];
|
|
|
|
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;
|
|
};
|
|
};
|
|
}
|
|
|
|
// 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 http://bugs.jquery.com/ticket/13378
|
|
rbuggyQSA = [];
|
|
|
|
if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
|
|
// Build QSA regex
|
|
// Regex strategy adopted from Diego Perini
|
|
assert(function( div ) {
|
|
// 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
|
|
// http://bugs.jquery.com/ticket/12359
|
|
docElem.appendChild( div ).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
|
|
// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
|
|
if ( div.querySelectorAll("[msallowcapture^='']").length ) {
|
|
rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
|
|
}
|
|
|
|
// Support: IE8
|
|
// Boolean attributes and "value" are not treated correctly
|
|
if ( !div.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 ( !div.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
|
|
rbuggyQSA.push("~=");
|
|
}
|
|
|
|
// 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 ( !div.querySelectorAll(":checked").length ) {
|
|
rbuggyQSA.push(":checked");
|
|
}
|
|
|
|
// Support: Safari 8+, iOS 8+
|
|
// https://bugs.webkit.org/show_bug.cgi?id=136851
|
|
// In-page `selector#id sibing-combinator selector` fails
|
|
if ( !div.querySelectorAll( "a#" + expando + "+*" ).length ) {
|
|
rbuggyQSA.push(".#.+[+~]");
|
|
}
|
|
});
|
|
|
|
assert(function( div ) {
|
|
// Support: Windows 8 Native Apps
|
|
// The type and name attributes are restricted during .innerHTML assignment
|
|
var input = document.createElement("input");
|
|
input.setAttribute( "type", "hidden" );
|
|
div.appendChild( input ).setAttribute( "name", "D" );
|
|
|
|
// Support: IE8
|
|
// Enforce case-sensitivity of name attribute
|
|
if ( div.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 ( !div.querySelectorAll(":enabled").length ) {
|
|
rbuggyQSA.push( ":enabled", ":disabled" );
|
|
}
|
|
|
|
// Opera 10-11 does not throw on post-comma invalid pseudos
|
|
div.querySelectorAll("*,:x");
|
|
rbuggyQSA.push(",.*:");
|
|
});
|
|
}
|
|
|
|
if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
|
|
docElem.webkitMatchesSelector ||
|
|
docElem.mozMatchesSelector ||
|
|
docElem.oMatchesSelector ||
|
|
docElem.msMatchesSelector) )) ) {
|
|
|
|
assert(function( div ) {
|
|
// Check to see if it's possible to do matchesSelector
|
|
// on a disconnected node (IE 9)
|
|
support.disconnectedMatch = matches.call( div, "div" );
|
|
|
|
// This should fail with an exception
|
|
// Gecko does not error, returns false instead
|
|
matches.call( div, "[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
|
|
compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
|
|
a.compareDocumentPosition( b ) :
|
|
|
|
// Otherwise we know they are disconnected
|
|
1;
|
|
|
|
// Disconnected nodes
|
|
if ( compare & 1 ||
|
|
(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
|
|
|
|
// Choose the first element that is related to our preferred document
|
|
if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
|
|
return -1;
|
|
}
|
|
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 ) {
|
|
return a === document ? -1 :
|
|
b === document ? 1 :
|
|
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
|
|
ap[i] === preferredDoc ? -1 :
|
|
bp[i] === preferredDoc ? 1 :
|
|
0;
|
|
};
|
|
|
|
return document;
|
|
};
|
|
|
|
Sizzle.matches = function( expr, elements ) {
|
|
return Sizzle( expr, null, null, elements );
|
|
};
|
|
|
|
Sizzle.matchesSelector = function( elem, expr ) {
|
|
// Set document vars if needed
|
|
if ( ( elem.ownerDocument || elem ) !== document ) {
|
|
setDocument( elem );
|
|
}
|
|
|
|
// Make sure that attribute selectors are quoted
|
|
expr = expr.replace( rattributeQuotes, "='$1']" );
|
|
|
|
if ( support.matchesSelector && documentIsHTML &&
|
|
!compilerCache[ 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) {}
|
|
}
|
|
|
|
return Sizzle( expr, document, null, [ elem ] ).length > 0;
|
|
};
|
|
|
|
Sizzle.contains = function( context, elem ) {
|
|
// Set document vars if needed
|
|
if ( ( context.ownerDocument || context ) !== document ) {
|
|
setDocument( context );
|
|
}
|
|
return contains( context, elem );
|
|
};
|
|
|
|
Sizzle.attr = function( elem, name ) {
|
|
// Set document vars if needed
|
|
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.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 += "";
|
|
|
|
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;
|
|
};
|
|
},
|
|
|
|
"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 || elem.innerText || 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": function( elem ) {
|
|
return elem.disabled === false;
|
|
},
|
|
|
|
"disabled": function( elem ) {
|
|
return elem.disabled === 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 ) {
|
|
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;
|
|
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,
|
|
checkNonElements = base && dir === "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 );
|
|
}
|
|
}
|
|
} :
|
|
|
|
// 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 ( (oldCache = uniqueCache[ dir ]) &&
|
|
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[ dir ] = newCache;
|
|
|
|
// A match means we're done; a fail means we have to keep checking
|
|
if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
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 ) {
|
|
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;
|
|
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" &&
|
|
support.getById && context.nodeType === 9 && documentIsHTML &&
|
|
Expr.relative[ tokens[1].type ] ) {
|
|
|
|
context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
|
|
if ( !context ) {
|
|
return results;
|
|
|
|
// Precompiled matchers will still verify ancestry, so step up a level
|
|
} else if ( compiled ) {
|
|
context = context.parentNode;
|
|
}
|
|
|
|
selector = selector.slice( tokens.shift().value.length );
|
|
}
|
|
|
|
// Fetch a seed set for right-to-left matching
|
|
i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
|
|
while ( i-- ) {
|
|
token = tokens[i];
|
|
|
|
// Abort if we hit a combinator
|
|
if ( Expr.relative[ (type = token.type) ] ) {
|
|
break;
|
|
}
|
|
if ( (find = Expr.find[ type ]) ) {
|
|
// Search, expanding context for leading sibling combinators
|
|
if ( (seed = find(
|
|
token.matches[0].replace( runescape, funescape ),
|
|
rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
|
|
)) ) {
|
|
|
|
// If seed is empty or no tokens remain, we can return early
|
|
tokens.splice( i, 1 );
|
|
selector = seed.length && toSelector( tokens );
|
|
if ( !selector ) {
|
|
push.apply( results, seed );
|
|
return results;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Compile and execute a filtering function if one is not provided
|
|
// 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( div1 ) {
|
|
// Should return 1, but returns 4 (following)
|
|
return div1.compareDocumentPosition( document.createElement("div") ) & 1;
|
|
});
|
|
|
|
// Support: IE<8
|
|
// Prevent attribute/property "interpolation"
|
|
// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
|
|
if ( !assert(function( div ) {
|
|
div.innerHTML = "<a href='#'></a>";
|
|
return div.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( div ) {
|
|
div.innerHTML = "<input/>";
|
|
div.firstChild.setAttribute( "value", "" );
|
|
return div.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( div ) {
|
|
return div.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;
|
|
jQuery.expr[ ":" ] = jQuery.expr.pseudos;
|
|
jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
|
|
jQuery.text = Sizzle.getText;
|
|
jQuery.isXMLDoc = Sizzle.isXML;
|
|
jQuery.contains = Sizzle.contains;
|
|
|
|
|
|
|
|
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;
|
|
|
|
var rsingleTag = ( /^<([\w-]+)\s*\/?>(?:<\/\1>|)$/ );
|
|
|
|
|
|
|
|
var risSimple = /^.[^:#\[\.,]*$/;
|
|
|
|
// Implement the identical functionality for filter and not
|
|
function winnow( elements, qualifier, not ) {
|
|
if ( jQuery.isFunction( qualifier ) ) {
|
|
return jQuery.grep( elements, function( elem, i ) {
|
|
/* jshint -W018 */
|
|
return !!qualifier.call( elem, i, elem ) !== not;
|
|
} );
|
|
|
|
}
|
|
|
|
if ( qualifier.nodeType ) {
|
|
return jQuery.grep( elements, function( elem ) {
|
|
return ( elem === qualifier ) !== not;
|
|
} );
|
|
|
|
}
|
|
|
|
if ( typeof qualifier === "string" ) {
|
|
if ( risSimple.test( qualifier ) ) {
|
|
return jQuery.filter( qualifier, elements, not );
|
|
}
|
|
|
|
qualifier = jQuery.filter( qualifier, elements );
|
|
}
|
|
|
|
return jQuery.grep( elements, function( elem ) {
|
|
return ( jQuery.inArray( elem, qualifier ) > -1 ) !== not;
|
|
} );
|
|
}
|
|
|
|
jQuery.filter = function( expr, elems, not ) {
|
|
var elem = elems[ 0 ];
|
|
|
|
if ( not ) {
|
|
expr = ":not(" + expr + ")";
|
|
}
|
|
|
|
return elems.length === 1 && elem.nodeType === 1 ?
|
|
jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :
|
|
jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
|
|
return elem.nodeType === 1;
|
|
} ) );
|
|
};
|
|
|
|
jQuery.fn.extend( {
|
|
find: function( selector ) {
|
|
var i,
|
|
ret = [],
|
|
self = this,
|
|
len = self.length;
|
|
|
|
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;
|
|
}
|
|
}
|
|
} ) );
|
|
}
|
|
|
|
for ( i = 0; i < len; i++ ) {
|
|
jQuery.find( selector, self[ i ], ret );
|
|
}
|
|
|
|
// Needed because $( selector, context ) becomes $( context ).find( selector )
|
|
ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );
|
|
ret.selector = this.selector ? this.selector + " " + selector : selector;
|
|
return 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 <)
|
|
rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
|
|
|
|
init = jQuery.fn.init = function( selector, context, root ) {
|
|
var match, elem;
|
|
|
|
// HANDLE: $(""), $(null), $(undefined), $(false)
|
|
if ( !selector ) {
|
|
return this;
|
|
}
|
|
|
|
// 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.charAt( 0 ) === "<" &&
|
|
selector.charAt( 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;
|
|
|
|
// 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 ( jQuery.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 ] );
|
|
|
|
// Check parentNode to catch when Blackberry 4.6 returns
|
|
// nodes that are no longer in the document #6963
|
|
if ( elem && elem.parentNode ) {
|
|
|
|
// Handle the case where IE and Opera return items
|
|
// by name instead of ID
|
|
if ( elem.id !== match[ 2 ] ) {
|
|
return rootjQuery.find( selector );
|
|
}
|
|
|
|
// Otherwise, we inject the element directly into the jQuery object
|
|
this.length = 1;
|
|
this[ 0 ] = elem;
|
|
}
|
|
|
|
this.context = document;
|
|
this.selector = selector;
|
|
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.context = this[ 0 ] = selector;
|
|
this.length = 1;
|
|
return this;
|
|
|
|
// HANDLE: $(function)
|
|
// Shortcut for document ready
|
|
} else if ( jQuery.isFunction( selector ) ) {
|
|
return typeof root.ready !== "undefined" ?
|
|
root.ready( selector ) :
|
|
|
|
// Execute immediately if ready is not present
|
|
selector( jQuery );
|
|
}
|
|
|
|
if ( selector.selector !== undefined ) {
|
|
this.selector = selector.selector;
|
|
this.context = selector.context;
|
|
}
|
|
|
|
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 i,
|
|
targets = jQuery( target, this ),
|
|
len = targets.length;
|
|
|
|
return this.filter( function() {
|
|
for ( i = 0; i < len; i++ ) {
|
|
if ( jQuery.contains( this, targets[ i ] ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
} );
|
|
},
|
|
|
|
closest: function( selectors, context ) {
|
|
var cur,
|
|
i = 0,
|
|
l = this.length,
|
|
matched = [],
|
|
pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
|
|
jQuery( selectors, context || this.context ) :
|
|
0;
|
|
|
|
for ( ; i < l; i++ ) {
|
|
for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
|
|
|
|
// Always skip document fragments
|
|
if ( cur.nodeType < 11 && ( pos ?
|
|
pos.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 matched set of elements
|
|
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 jQuery.inArray( this[ 0 ], jQuery( elem ) );
|
|
}
|
|
|
|
// Locate the position of the desired element
|
|
return jQuery.inArray(
|
|
|
|
// If it receives a jQuery object, the first element is used
|
|
elem.jquery ? elem[ 0 ] : elem, this );
|
|
},
|
|
|
|
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 ) {
|
|
do {
|
|
cur = cur[ dir ];
|
|
} while ( cur && 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 ) {
|
|
return jQuery.nodeName( elem, "iframe" ) ?
|
|
elem.contentDocument || elem.contentWindow.document :
|
|
jQuery.merge( [], elem.childNodes );
|
|
}
|
|
}, function( name, fn ) {
|
|
jQuery.fn[ name ] = function( until, selector ) {
|
|
var ret = jQuery.map( this, fn, until );
|
|
|
|
if ( name.slice( -5 ) !== "Until" ) {
|
|
selector = until;
|
|
}
|
|
|
|
if ( selector && typeof selector === "string" ) {
|
|
ret = jQuery.filter( selector, ret );
|
|
}
|
|
|
|
if ( this.length > 1 ) {
|
|
|
|
// Remove duplicates
|
|
if ( !guaranteedUnique[ name ] ) {
|
|
ret = jQuery.uniqueSort( ret );
|
|
}
|
|
|
|
// Reverse order for parents* and prev-derivatives
|
|
if ( rparentsprev.test( name ) ) {
|
|
ret = ret.reverse();
|
|
}
|
|
}
|
|
|
|
return this.pushStack( ret );
|
|
};
|
|
} );
|
|
var rnotwhite = ( /\S+/g );
|
|
|
|
|
|
|
|
// Convert String-formatted options into Object-formatted ones
|
|
function createOptions( options ) {
|
|
var object = {};
|
|
jQuery.each( options.match( rnotwhite ) || [], 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 = 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 ( jQuery.isFunction( arg ) ) {
|
|
if ( !options.unique || !self.has( arg ) ) {
|
|
list.push( arg );
|
|
}
|
|
} else if ( arg && arg.length && jQuery.type( 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 = true;
|
|
if ( !memory ) {
|
|
self.disable();
|
|
}
|
|
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;
|
|
};
|
|
|
|
|
|
jQuery.extend( {
|
|
|
|
Deferred: function( func ) {
|
|
var tuples = [
|
|
|
|
// action, add listener, listener list, final state
|
|
[ "resolve", "done", jQuery.Callbacks( "once memory" ), "resolved" ],
|
|
[ "reject", "fail", jQuery.Callbacks( "once memory" ), "rejected" ],
|
|
[ "notify", "progress", jQuery.Callbacks( "memory" ) ]
|
|
],
|
|
state = "pending",
|
|
promise = {
|
|
state: function() {
|
|
return state;
|
|
},
|
|
always: function() {
|
|
deferred.done( arguments ).fail( arguments );
|
|
return this;
|
|
},
|
|
then: function( /* fnDone, fnFail, fnProgress */ ) {
|
|
var fns = arguments;
|
|
return jQuery.Deferred( function( newDefer ) {
|
|
jQuery.each( tuples, function( i, tuple ) {
|
|
var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
|
|
|
|
// deferred[ done | fail | progress ] for forwarding actions to newDefer
|
|
deferred[ tuple[ 1 ] ]( function() {
|
|
var returned = fn && fn.apply( this, arguments );
|
|
if ( returned && jQuery.isFunction( returned.promise ) ) {
|
|
returned.promise()
|
|
.progress( newDefer.notify )
|
|
.done( newDefer.resolve )
|
|
.fail( newDefer.reject );
|
|
} else {
|
|
newDefer[ tuple[ 0 ] + "With" ](
|
|
this === promise ? newDefer.promise() : this,
|
|
fn ? [ returned ] : arguments
|
|
);
|
|
}
|
|
} );
|
|
} );
|
|
fns = null;
|
|
} ).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 = {};
|
|
|
|
// Keep pipe for back-compat
|
|
promise.pipe = promise.then;
|
|
|
|
// Add list-specific methods
|
|
jQuery.each( tuples, function( i, tuple ) {
|
|
var list = tuple[ 2 ],
|
|
stateString = tuple[ 3 ];
|
|
|
|
// promise[ done | fail | progress ] = list.add
|
|
promise[ tuple[ 1 ] ] = list.add;
|
|
|
|
// Handle state
|
|
if ( stateString ) {
|
|
list.add( function() {
|
|
|
|
// state = [ resolved | rejected ]
|
|
state = stateString;
|
|
|
|
// [ reject_list | resolve_list ].disable; progress_list.lock
|
|
}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
|
|
}
|
|
|
|
// deferred[ resolve | reject | notify ]
|
|
deferred[ tuple[ 0 ] ] = function() {
|
|
deferred[ tuple[ 0 ] + "With" ]( this === deferred ? promise : this, arguments );
|
|
return this;
|
|
};
|
|
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( subordinate /* , ..., subordinateN */ ) {
|
|
var i = 0,
|
|
resolveValues = slice.call( arguments ),
|
|
length = resolveValues.length,
|
|
|
|
// the count of uncompleted subordinates
|
|
remaining = length !== 1 ||
|
|
( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
|
|
|
|
// the master Deferred.
|
|
// If resolveValues consist of only a single Deferred, just use that.
|
|
deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
|
|
|
|
// Update function for both resolve and progress values
|
|
updateFunc = function( i, contexts, values ) {
|
|
return function( value ) {
|
|
contexts[ i ] = this;
|
|
values[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
|
|
if ( values === progressValues ) {
|
|
deferred.notifyWith( contexts, values );
|
|
|
|
} else if ( !( --remaining ) ) {
|
|
deferred.resolveWith( contexts, values );
|
|
}
|
|
};
|
|
},
|
|
|
|
progressValues, progressContexts, resolveContexts;
|
|
|
|
// add listeners to Deferred subordinates; treat others as resolved
|
|
if ( length > 1 ) {
|
|
progressValues = new Array( length );
|
|
progressContexts = new Array( length );
|
|
resolveContexts = new Array( length );
|
|
for ( ; i < length; i++ ) {
|
|
if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
|
|
resolveValues[ i ].promise()
|
|
.progress( updateFunc( i, progressContexts, progressValues ) )
|
|
.done( updateFunc( i, resolveContexts, resolveValues ) )
|
|
.fail( deferred.reject );
|
|
} else {
|
|
--remaining;
|
|
}
|
|
}
|
|
}
|
|
|
|
// if we're not waiting on anything, resolve the master
|
|
if ( !remaining ) {
|
|
deferred.resolveWith( resolveContexts, resolveValues );
|
|
}
|
|
|
|
return deferred.promise();
|
|
}
|
|
} );
|
|
|
|
|
|
// The deferred used on DOM ready
|
|
var readyList;
|
|
|
|
jQuery.fn.ready = function( fn ) {
|
|
|
|
// Add the callback
|
|
jQuery.ready.promise().done( fn );
|
|
|
|
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,
|
|
|
|
// Hold (or release) the ready event
|
|
holdReady: function( hold ) {
|
|
if ( hold ) {
|
|
jQuery.readyWait++;
|
|
} else {
|
|
jQuery.ready( true );
|
|
}
|
|
},
|
|
|
|
// 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 ] );
|
|
|
|
// Trigger any bound ready events
|
|
if ( jQuery.fn.triggerHandler ) {
|
|
jQuery( document ).triggerHandler( "ready" );
|
|
jQuery( document ).off( "ready" );
|
|
}
|
|
}
|
|
} );
|
|
|
|
/**
|
|
* Clean-up method for dom ready events
|
|
*/
|
|
function detach() {
|
|
if ( document.addEventListener ) {
|
|
document.removeEventListener( "DOMContentLoaded", completed );
|
|
window.removeEventListener( "load", completed );
|
|
|
|
} else {
|
|
document.detachEvent( "onreadystatechange", completed );
|
|
window.detachEvent( "onload", completed );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The ready event handler and self cleanup method
|
|
*/
|
|
function completed() {
|
|
|
|
// readyState === "complete" is good enough for us to call the dom ready in oldIE
|
|
if ( document.addEventListener ||
|
|
window.event.type === "load" ||
|
|
document.readyState === "complete" ) {
|
|
|
|
detach();
|
|
jQuery.ready();
|
|
}
|
|
}
|
|
|
|
jQuery.ready.promise = function( obj ) {
|
|
if ( !readyList ) {
|
|
|
|
readyList = jQuery.Deferred();
|
|
|
|
// Catch cases where $(document).ready() is called
|
|
// after the browser event has already occurred.
|
|
// Support: IE6-10
|
|
// 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 );
|
|
|
|
// Standards-based browsers support DOMContentLoaded
|
|
} else if ( document.addEventListener ) {
|
|
|
|
// Use the handy event callback
|
|
document.addEventListener( "DOMContentLoaded", completed );
|
|
|
|
// A fallback to window.onload, that will always work
|
|
window.addEventListener( "load", completed );
|
|
|
|
// If IE event model is used
|
|
} else {
|
|
|
|
// Ensure firing before onload, maybe late but safe also for iframes
|
|
document.attachEvent( "onreadystatechange", completed );
|
|
|
|
// A fallback to window.onload, that will always work
|
|
window.attachEvent( "onload", completed );
|
|
|
|
// If IE and not a frame
|
|
// continually check to see if the document is ready
|
|
var top = false;
|
|
|
|
try {
|
|
top = window.frameElement == null && document.documentElement;
|
|
} catch ( e ) {}
|
|
|
|
if ( top && top.doScroll ) {
|
|
( function doScrollCheck() {
|
|
if ( !jQuery.isReady ) {
|
|
|
|
try {
|
|
|
|
// Use the trick by Diego Perini
|
|
// http://javascript.nwbox.com/IEContentLoaded/
|
|
top.doScroll( "left" );
|
|
} catch ( e ) {
|
|
return window.setTimeout( doScrollCheck, 50 );
|
|
}
|
|
|
|
// detach all dom ready events
|
|
detach();
|
|
|
|
// and execute any waiting functions
|
|
jQuery.ready();
|
|
}
|
|
} )();
|
|
}
|
|
}
|
|
}
|
|
return readyList.promise( obj );
|
|
};
|
|
|
|
// Kick off the DOM ready check even if the user does not
|
|
jQuery.ready.promise();
|
|
|
|
|
|
|
|
|
|
// Support: IE<9
|
|
// Iteration over object's inherited properties before its own
|
|
var i;
|
|
for ( i in jQuery( support ) ) {
|
|
break;
|
|
}
|
|
support.ownFirst = i === "0";
|
|
|
|
// Note: most support tests are defined in their respective modules.
|
|
// false until the test is run
|
|
support.inlineBlockNeedsLayout = false;
|
|
|
|
// Execute ASAP in case we need to set body.style.zoom
|
|
jQuery( function() {
|
|
|
|
// Minified: var a,b,c,d
|
|
var val, div, body, container;
|
|
|
|
body = document.getElementsByTagName( "body" )[ 0 ];
|
|
if ( !body || !body.style ) {
|
|
|
|
// Return for frameset docs that don't have a body
|
|
return;
|
|
}
|
|
|
|
// Setup
|
|
div = document.createElement( "div" );
|
|
container = document.createElement( "div" );
|
|
container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px";
|
|
body.appendChild( container ).appendChild( div );
|
|
|
|
if ( typeof div.style.zoom !== "undefined" ) {
|
|
|
|
// Support: IE<8
|
|
// Check if natively block-level elements act like inline-block
|
|
// elements when setting their display to 'inline' and giving
|
|
// them layout
|
|
div.style.cssText = "display:inline;margin:0;border:0;padding:1px;width:1px;zoom:1";
|
|
|
|
support.inlineBlockNeedsLayout = val = div.offsetWidth === 3;
|
|
if ( val ) {
|
|
|
|
// Prevent IE 6 from affecting layout for positioned elements #11048
|
|
// Prevent IE from shrinking the body in IE 7 mode #12869
|
|
// Support: IE<8
|
|
body.style.zoom = 1;
|
|
}
|
|
}
|
|
|
|
body.removeChild( container );
|
|
} );
|
|
|
|
|
|
( function() {
|
|
var div = document.createElement( "div" );
|
|
|
|
// Support: IE<9
|
|
support.deleteExpando = true;
|
|
try {
|
|
delete div.test;
|
|
} catch ( e ) {
|
|
support.deleteExpando = false;
|
|
}
|
|
|
|
// Null elements to avoid leaks in IE.
|
|
div = null;
|
|
} )();
|
|
var acceptData = function( elem ) {
|
|
var noData = jQuery.noData[ ( elem.nodeName + " " ).toLowerCase() ],
|
|
nodeType = +elem.nodeType || 1;
|
|
|
|
// Do not set data on non-element DOM nodes because it will not be cleared (#8335).
|
|
return nodeType !== 1 && nodeType !== 9 ?
|
|
false :
|
|
|
|
// Nodes accept data unless otherwise specified; rejection can be conditional
|
|
!noData || noData !== true && elem.getAttribute( "classid" ) === noData;
|
|
};
|
|
|
|
|
|
|
|
|
|
var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
|
|
rmultiDash = /([A-Z])/g;
|
|
|
|
function dataAttr( elem, key, data ) {
|
|
|
|
// If nothing was found internally, try to fetch any
|
|
// data from the HTML5 data-* attribute
|
|
if ( data === undefined && elem.nodeType === 1 ) {
|
|
|
|
var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
|
|
|
|
data = elem.getAttribute( name );
|
|
|
|
if ( typeof data === "string" ) {
|
|
try {
|
|
data = data === "true" ? true :
|
|
data === "false" ? false :
|
|
data === "null" ? null :
|
|
|
|
// Only convert to a number if it doesn't change the string
|
|
+data + "" === data ? +data :
|
|
rbrace.test( data ) ? jQuery.parseJSON( data ) :
|
|
data;
|
|
} catch ( e ) {}
|
|
|
|
// Make sure we set the data so it isn't changed later
|
|
jQuery.data( elem, key, data );
|
|
|
|
} else {
|
|
data = undefined;
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
// checks a cache object for emptiness
|
|
function isEmptyDataObject( obj ) {
|
|
var name;
|
|
for ( name in obj ) {
|
|
|
|
// if the public data object is empty, the private is still empty
|
|
if ( name === "data" && jQuery.isEmptyObject( obj[ name ] ) ) {
|
|
continue;
|
|
}
|
|
if ( name !== "toJSON" ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function internalData( elem, name, data, pvt /* Internal Use Only */ ) {
|
|
if ( !acceptData( elem ) ) {
|
|
return;
|
|
}
|
|
|
|
var ret, thisCache,
|
|
internalKey = jQuery.expando,
|
|
|
|
// We have to handle DOM nodes and JS objects differently because IE6-7
|
|
// can't GC object references properly across the DOM-JS boundary
|
|
isNode = elem.nodeType,
|
|
|
|
// Only DOM nodes need the global jQuery cache; JS object data is
|
|
// attached directly to the object so GC can occur automatically
|
|
cache = isNode ? jQuery.cache : elem,
|
|
|
|
// Only defining an ID for JS objects if its cache already exists allows
|
|
// the code to shortcut on the same path as a DOM node with no cache
|
|
id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;
|
|
|
|
// Avoid doing any more work than we need to when trying to get data on an
|
|
// object that has no data at all
|
|
if ( ( !id || !cache[ id ] || ( !pvt && !cache[ id ].data ) ) &&
|
|
data === undefined && typeof name === "string" ) {
|
|
return;
|
|
}
|
|
|
|
if ( !id ) {
|
|
|
|
// Only DOM nodes need a new unique ID for each element since their data
|
|
// ends up in the global cache
|
|
if ( isNode ) {
|
|
id = elem[ internalKey ] = deletedIds.pop() || jQuery.guid++;
|
|
} else {
|
|
id = internalKey;
|
|
}
|
|
}
|
|
|
|
if ( !cache[ id ] ) {
|
|
|
|
// Avoid exposing jQuery metadata on plain JS objects when the object
|
|
// is serialized using JSON.stringify
|
|
cache[ id ] = isNode ? {} : { toJSON: jQuery.noop };
|
|
}
|
|
|
|
// An object can be passed to jQuery.data instead of a key/value pair; this gets
|
|
// shallow copied over onto the existing cache
|
|
if ( typeof name === "object" || typeof name === "function" ) {
|
|
if ( pvt ) {
|
|
cache[ id ] = jQuery.extend( cache[ id ], name );
|
|
} else {
|
|
cache[ id ].data = jQuery.extend( cache[ id ].data, name );
|
|
}
|
|
}
|
|
|
|
thisCache = cache[ id ];
|
|
|
|
// jQuery data() is stored in a separate object inside the object's internal data
|
|
// cache in order to avoid key collisions between internal data and user-defined
|
|
// data.
|
|
if ( !pvt ) {
|
|
if ( !thisCache.data ) {
|
|
thisCache.data = {};
|
|
}
|
|
|
|
thisCache = thisCache.data;
|
|
}
|
|
|
|
if ( data !== undefined ) {
|
|
thisCache[ jQuery.camelCase( name ) ] = data;
|
|
}
|
|
|
|
// Check for both converted-to-camel and non-converted data property names
|
|
// If a data property was specified
|
|
if ( typeof name === "string" ) {
|
|
|
|
// First Try to find as-is property data
|
|
ret = thisCache[ name ];
|
|
|
|
// Test for null|undefined property data
|
|
if ( ret == null ) {
|
|
|
|
// Try to find the camelCased property
|
|
ret = thisCache[ jQuery.camelCase( name ) ];
|
|
}
|
|
} else {
|
|
ret = thisCache;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
function internalRemoveData( elem, name, pvt ) {
|
|
if ( !acceptData( elem ) ) {
|
|
return;
|
|
}
|
|
|
|
var thisCache, i,
|
|
isNode = elem.nodeType,
|
|
|
|
// See jQuery.data for more information
|
|
cache = isNode ? jQuery.cache : elem,
|
|
id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
|
|
|
|
// If there is already no cache entry for this object, there is no
|
|
// purpose in continuing
|
|
if ( !cache[ id ] ) {
|
|
return;
|
|
}
|
|
|
|
if ( name ) {
|
|
|
|
thisCache = pvt ? cache[ id ] : cache[ id ].data;
|
|
|
|
if ( thisCache ) {
|
|
|
|
// Support array or space separated string names for data keys
|
|
if ( !jQuery.isArray( name ) ) {
|
|
|
|
// try the string as a key before any manipulation
|
|
if ( name in thisCache ) {
|
|
name = [ name ];
|
|
} else {
|
|
|
|
// split the camel cased version by spaces unless a key with the spaces exists
|
|
name = jQuery.camelCase( name );
|
|
if ( name in thisCache ) {
|
|
name = [ name ];
|
|
} else {
|
|
name = name.split( " " );
|
|
}
|
|
}
|
|
} else {
|
|
|
|
// If "name" is an array of keys...
|
|
// When data is initially created, via ("key", "val") signature,
|
|
// keys will be converted to camelCase.
|
|
// Since there is no way to tell _how_ a key was added, remove
|
|
// both plain key and camelCase key. #12786
|
|
// This will only penalize the array argument path.
|
|
name = name.concat( jQuery.map( name, jQuery.camelCase ) );
|
|
}
|
|
|
|
i = name.length;
|
|
while ( i-- ) {
|
|
delete thisCache[ name[ i ] ];
|
|
}
|
|
|
|
// If there is no data left in the cache, we want to continue
|
|
// and let the cache object itself get destroyed
|
|
if ( pvt ? !isEmptyDataObject( thisCache ) : !jQuery.isEmptyObject( thisCache ) ) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// See jQuery.data for more information
|
|
if ( !pvt ) {
|
|
delete cache[ id ].data;
|
|
|
|
// Don't destroy the parent cache unless the internal data object
|
|
// had been the only thing left in it
|
|
if ( !isEmptyDataObject( cache[ id ] ) ) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Destroy the cache
|
|
if ( isNode ) {
|
|
jQuery.cleanData( [ elem ], true );
|
|
|
|
// Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
|
|
/* jshint eqeqeq: false */
|
|
} else if ( support.deleteExpando || cache != cache.window ) {
|
|
/* jshint eqeqeq: true */
|
|
delete cache[ id ];
|
|
|
|
// When all else fails, undefined
|
|
} else {
|
|
cache[ id ] = undefined;
|
|
}
|
|
}
|
|
|
|
jQuery.extend( {
|
|
cache: {},
|
|
|
|
// The following elements (space-suffixed to avoid Object.prototype collisions)
|
|
// throw uncatchable exceptions if you attempt to set expando properties
|
|
noData: {
|
|
"applet ": true,
|
|
"embed ": true,
|
|
|
|
// ...but Flash objects (which have this classid) *can* handle expandos
|
|
"object ": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"
|
|
},
|
|
|
|
hasData: function( elem ) {
|
|
elem = elem.nodeType ? jQuery.cache[ elem[ jQuery.expando ] ] : elem[ jQuery.expando ];
|
|
return !!elem && !isEmptyDataObject( elem );
|
|
},
|
|
|
|
data: function( elem, name, data ) {
|
|
return internalData( elem, name, data );
|
|
},
|
|
|
|
removeData: function( elem, name ) {
|
|
return internalRemoveData( elem, name );
|
|
},
|
|
|
|
// For internal use only.
|
|
_data: function( elem, name, data ) {
|
|
return internalData( elem, name, data, true );
|
|
},
|
|
|
|
_removeData: function( elem, name ) {
|
|
return internalRemoveData( elem, name, true );
|
|
}
|
|
} );
|
|
|
|
jQuery.fn.extend( {
|
|
data: function( key, value ) {
|
|
var i, name, data,
|
|
elem = this[ 0 ],
|
|
attrs = elem && elem.attributes;
|
|
|
|
// Special expections of .data basically thwart jQuery.access,
|
|
// so implement the relevant behavior ourselves
|
|
|
|
// Gets all values
|
|
if ( key === undefined ) {
|
|
if ( this.length ) {
|
|
data = jQuery.data( elem );
|
|
|
|
if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
|
|
i = attrs.length;
|
|
while ( i-- ) {
|
|
|
|
// Support: IE11+
|
|
// The attrs elements can be null (#14894)
|
|
if ( attrs[ i ] ) {
|
|
name = attrs[ i ].name;
|
|
if ( name.indexOf( "data-" ) === 0 ) {
|
|
name = jQuery.camelCase( name.slice( 5 ) );
|
|
dataAttr( elem, name, data[ name ] );
|
|
}
|
|
}
|
|
}
|
|
jQuery._data( elem, "parsedAttrs", true );
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
// Sets multiple values
|
|
if ( typeof key === "object" ) {
|
|
return this.each( function() {
|
|
jQuery.data( this, key );
|
|
} );
|
|
}
|
|
|
|
return arguments.length > 1 ?
|
|
|
|
// Sets one value
|
|
this.each( function() {
|
|
jQuery.data( this, key, value );
|
|
} ) :
|
|
|
|
// Gets one value
|
|
// Try to fetch any internally stored data first
|
|
elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : undefined;
|
|
},
|
|
|
|
removeData: function( key ) {
|
|
return this.each( function() {
|
|
jQuery.removeData( this, key );
|
|
} );
|
|
}
|
|
} );
|
|
|
|
|
|
jQuery.extend( {
|
|
queue: function( elem, type, data ) {
|
|
var queue;
|
|
|
|
if ( elem ) {
|
|
type = ( type || "fx" ) + "queue";
|
|
queue = jQuery._data( elem, type );
|
|
|
|
// Speed up dequeue by getting out quickly if this is just a lookup
|
|
if ( data ) {
|
|
if ( !queue || jQuery.isArray( data ) ) {
|
|
queue = jQuery._data( 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 intended for public consumption - generates a queueHooks object,
|
|
// or returns the current one
|
|
_queueHooks: function( elem, type ) {
|
|
var key = type + "queueHooks";
|
|
return jQuery._data( elem, key ) || jQuery._data( elem, key, {
|
|
empty: jQuery.Callbacks( "once memory" ).add( function() {
|
|
jQuery._removeData( elem, type + "queue" );
|
|
jQuery._removeData( elem, 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 = jQuery._data( elements[ i ], type + "queueHooks" );
|
|
if ( tmp && tmp.empty ) {
|
|
count++;
|
|
tmp.empty.add( resolve );
|
|
}
|
|
}
|
|
resolve();
|
|
return defer.promise( obj );
|
|
}
|
|
} );
|
|
|
|
|
|
( function() {
|
|
var shrinkWrapBlocksVal;
|
|
|
|
support.shrinkWrapBlocks = function() {
|
|
if ( shrinkWrapBlocksVal != null ) {
|
|
return shrinkWrapBlocksVal;
|
|
}
|
|
|
|
// Will be changed later if needed.
|
|
shrinkWrapBlocksVal = false;
|
|
|
|
// Minified: var b,c,d
|
|
var div, body, container;
|
|
|
|
body = document.getElementsByTagName( "body" )[ 0 ];
|
|
if ( !body || !body.style ) {
|
|
|
|
// Test fired too early or in an unsupported environment, exit.
|
|
return;
|
|
}
|
|
|
|
// Setup
|
|
div = document.createElement( "div" );
|
|
container = document.createElement( "div" );
|
|
container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px";
|
|
body.appendChild( container ).appendChild( div );
|
|
|
|
// Support: IE6
|
|
// Check if elements with layout shrink-wrap their children
|
|
if ( typeof div.style.zoom !== "undefined" ) {
|
|
|
|
// Reset CSS: box-sizing; display; margin; border
|
|
div.style.cssText =
|
|
|
|
// Support: Firefox<29, Android 2.3
|
|
// Vendor-prefix box-sizing
|
|
"-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" +
|
|
"box-sizing:content-box;display:block;margin:0;border:0;" +
|
|
"padding:1px;width:1px;zoom:1";
|
|
div.appendChild( document.createElement( "div" ) ).style.width = "5px";
|
|
shrinkWrapBlocksVal = div.offsetWidth !== 3;
|
|
}
|
|
|
|
body.removeChild( container );
|
|
|
|
return shrinkWrapBlocksVal;
|
|
};
|
|
|
|
} )();
|
|
var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
|
|
|
|
var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
|
|
|
|
|
|
var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
|
|
|
|
var isHidden = function( elem, el ) {
|
|
|
|
// isHidden might be called from jQuery#filter function;
|
|
// in that case, element will be second argument
|
|
elem = el || elem;
|
|
return jQuery.css( elem, "display" ) === "none" ||
|
|
!jQuery.contains( elem.ownerDocument, elem );
|
|
};
|
|
|
|
|
|
|
|
function adjustCSS( elem, prop, valueParts, tween ) {
|
|
var adjusted,
|
|
scale = 1,
|
|
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 = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
|
|
rcssNum.exec( jQuery.css( elem, prop ) );
|
|
|
|
if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
|
|
|
|
// Trust units reported by jQuery.css
|
|
unit = unit || initialInUnit[ 3 ];
|
|
|
|
// Make sure we update the tween properties later on
|
|
valueParts = valueParts || [];
|
|
|
|
// Iteratively approximate from a nonzero starting point
|
|
initialInUnit = +initial || 1;
|
|
|
|
do {
|
|
|
|
// If previous iteration zeroed out, double until we get *something*.
|
|
// Use string for doubling so we don't accidentally see scale as unchanged below
|
|
scale = scale || ".5";
|
|
|
|
// Adjust and apply
|
|
initialInUnit = initialInUnit / scale;
|
|
jQuery.style( elem, prop, initialInUnit + unit );
|
|
|
|
// Update scale, tolerating zero or NaN from tween.cur()
|
|
// Break the loop if scale is unchanged or perfect, or if we've just had enough.
|
|
} while (
|
|
scale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations
|
|
);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
// 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,
|
|
length = elems.length,
|
|
bulk = key == null;
|
|
|
|
// Sets many values
|
|
if ( jQuery.type( 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 ( !jQuery.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 < length; i++ ) {
|
|
fn(
|
|
elems[ i ],
|
|
key,
|
|
raw ? value : value.call( elems[ i ], i, fn( elems[ i ], key ) )
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
return chainable ?
|
|
elems :
|
|
|
|
// Gets
|
|
bulk ?
|
|
fn.call( elems ) :
|
|
length ? fn( elems[ 0 ], key ) : emptyGet;
|
|
};
|
|
var rcheckableType = ( /^(?:checkbox|radio)$/i );
|
|
|
|
var rtagName = ( /<([\w:-]+)/ );
|
|
|
|
var rscriptType = ( /^$|\/(?:java|ecma)script/i );
|
|
|
|
var rleadingWhitespace = ( /^\s+/ );
|
|
|
|
var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|" +
|
|
"details|dialog|figcaption|figure|footer|header|hgroup|main|" +
|
|
"mark|meter|nav|output|picture|progress|section|summary|template|time|video";
|
|
|
|
|
|
|
|
function createSafeFragment( document ) {
|
|
var list = nodeNames.split( "|" ),
|
|
safeFrag = document.createDocumentFragment();
|
|
|
|
if ( safeFrag.createElement ) {
|
|
while ( list.length ) {
|
|
safeFrag.createElement(
|
|
list.pop()
|
|
);
|
|
}
|
|
}
|
|
return safeFrag;
|
|
}
|
|
|
|
|
|
( function() {
|
|
var div = document.createElement( "div" ),
|
|
fragment = document.createDocumentFragment(),
|
|
input = document.createElement( "input" );
|
|
|
|
// Setup
|
|
div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
|
|
|
|
// IE strips leading whitespace when .innerHTML is used
|
|
support.leadingWhitespace = div.firstChild.nodeType === 3;
|
|
|
|
// Make sure that tbody elements aren't automatically inserted
|
|
// IE will insert them into empty tables
|
|
support.tbody = !div.getElementsByTagName( "tbody" ).length;
|
|
|
|
// Make sure that link elements get serialized correctly by innerHTML
|
|
// This requires a wrapper element in IE
|
|
support.htmlSerialize = !!div.getElementsByTagName( "link" ).length;
|
|
|
|
// Makes sure cloning an html5 element does not cause problems
|
|
// Where outerHTML is undefined, this still works
|
|
support.html5Clone =
|
|
document.createElement( "nav" ).cloneNode( true ).outerHTML !== "<:nav></:nav>";
|
|
|
|
// Check if a disconnected checkbox will retain its checked
|
|
// value of true after appended to the DOM (IE6/7)
|
|
input.type = "checkbox";
|
|
input.checked = true;
|
|
fragment.appendChild( input );
|
|
support.appendChecked = input.checked;
|
|
|
|
// Make sure textarea (and checkbox) defaultValue is properly cloned
|
|
// Support: IE6-IE11+
|
|
div.innerHTML = "<textarea>x</textarea>";
|
|
support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
|
|
|
|
// #11217 - WebKit loses check when the name is after the checked attribute
|
|
fragment.appendChild( div );
|
|
|
|
// Support: Windows Web Apps (WWA)
|
|
// `name` and `type` must use .setAttribute for WWA (#14901)
|
|
input = document.createElement( "input" );
|
|
input.setAttribute( "type", "radio" );
|
|
input.setAttribute( "checked", "checked" );
|
|
input.setAttribute( "name", "t" );
|
|
|
|
div.appendChild( input );
|
|
|
|
// Support: Safari 5.1, iOS 5.1, Android 4.x, Android 2.3
|
|
// old WebKit doesn't clone checked state correctly in fragments
|
|
support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
|
|
|
|
// Support: IE<9
|
|
// Cloned elements keep attachEvent handlers, we use addEventListener on IE9+
|
|
support.noCloneEvent = !!div.addEventListener;
|
|
|
|
// Support: IE<9
|
|
// Since attributes and properties are the same in IE,
|
|
// cleanData must set properties to undefined rather than use removeAttribute
|
|
div[ jQuery.expando ] = 1;
|
|
support.attributes = !div.getAttribute( jQuery.expando );
|
|
} )();
|
|
|
|
|
|
// We have to close these tags to support XHTML (#13200)
|
|
var wrapMap = {
|
|
option: [ 1, "<select multiple='multiple'>", "</select>" ],
|
|
legend: [ 1, "<fieldset>", "</fieldset>" ],
|
|
area: [ 1, "<map>", "</map>" ],
|
|
|
|
// Support: IE8
|
|
param: [ 1, "<object>", "</object>" ],
|
|
thead: [ 1, "<table>", "</table>" ],
|
|
tr: [ 2, "<table><tbody>", "</tbody></table>" ],
|
|
col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
|
|
td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
|
|
|
|
// IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
|
|
// unless wrapped in a div with non-breaking characters in front of it.
|
|
_default: support.htmlSerialize ? [ 0, "", "" ] : [ 1, "X<div>", "</div>" ]
|
|
};
|
|
|
|
// Support: IE8-IE9
|
|
wrapMap.optgroup = wrapMap.option;
|
|
|
|
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
|
|
wrapMap.th = wrapMap.td;
|
|
|
|
|
|
function getAll( context, tag ) {
|
|
var elems, elem,
|
|
i = 0,
|
|
found = typeof context.getElementsByTagName !== "undefined" ?
|
|
context.getElementsByTagName( tag || "*" ) :
|
|
typeof context.querySelectorAll !== "undefined" ?
|
|
context.querySelectorAll( tag || "*" ) :
|
|
undefined;
|
|
|
|
if ( !found ) {
|
|
for ( found = [], elems = context.childNodes || context;
|
|
( elem = elems[ i ] ) != null;
|
|
i++
|
|
) {
|
|
if ( !tag || jQuery.nodeName( elem, tag ) ) {
|
|
found.push( elem );
|
|
} else {
|
|
jQuery.merge( found, getAll( elem, tag ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
|
|
jQuery.merge( [ context ], found ) :
|
|
found;
|
|
}
|
|
|
|
|
|
// Mark scripts as having already been evaluated
|
|
function setGlobalEval( elems, refElements ) {
|
|
var elem,
|
|
i = 0;
|
|
for ( ; ( elem = elems[ i ] ) != null; i++ ) {
|
|
jQuery._data(
|
|
elem,
|
|
"globalEval",
|
|
!refElements || jQuery._data( refElements[ i ], "globalEval" )
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
var rhtml = /<|&#?\w+;/,
|
|
rtbody = /<tbody/i;
|
|
|
|
function fixDefaultChecked( elem ) {
|
|
if ( rcheckableType.test( elem.type ) ) {
|
|
elem.defaultChecked = elem.checked;
|
|
}
|
|
}
|
|
|
|
function buildFragment( elems, context, scripts, selection, ignored ) {
|
|
var j, elem, contains,
|
|
tmp, tag, tbody, wrap,
|
|
l = elems.length,
|
|
|
|
// Ensure a safe fragment
|
|
safe = createSafeFragment( context ),
|
|
|
|
nodes = [],
|
|
i = 0;
|
|
|
|
for ( ; i < l; i++ ) {
|
|
elem = elems[ i ];
|
|
|
|
if ( elem || elem === 0 ) {
|
|
|
|
// Add nodes directly
|
|
if ( jQuery.type( elem ) === "object" ) {
|
|
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 || safe.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;
|
|
}
|
|
|
|
// Manually add leading whitespace removed by IE
|
|
if ( !support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
|
|
nodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[ 0 ] ) );
|
|
}
|
|
|
|
// Remove IE's autoinserted <tbody> from table fragments
|
|
if ( !support.tbody ) {
|
|
|
|
// String was a <table>, *may* have spurious <tbody>
|
|
elem = tag === "table" && !rtbody.test( elem ) ?
|
|
tmp.firstChild :
|
|
|
|
// String was a bare <thead> or <tfoot>
|
|
wrap[ 1 ] === "<table>" && !rtbody.test( elem ) ?
|
|
tmp :
|
|
0;
|
|
|
|
j = elem && elem.childNodes.length;
|
|
while ( j-- ) {
|
|
if ( jQuery.nodeName( ( tbody = elem.childNodes[ j ] ), "tbody" ) &&
|
|
!tbody.childNodes.length ) {
|
|
|
|
elem.removeChild( tbody );
|
|
}
|
|
}
|
|
}
|
|
|
|
jQuery.merge( nodes, tmp.childNodes );
|
|
|
|
// Fix #12392 for WebKit and IE > 9
|
|
tmp.textContent = "";
|
|
|
|
// Fix #12392 for oldIE
|
|
while ( tmp.firstChild ) {
|
|
tmp.removeChild( tmp.firstChild );
|
|
}
|
|
|
|
// Remember the top-level container for proper cleanup
|
|
tmp = safe.lastChild;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fix #11356: Clear elements from fragment
|
|
if ( tmp ) {
|
|
safe.removeChild( tmp );
|
|
}
|
|
|
|
// Reset defaultChecked for any radios and checkboxes
|
|
// about to be appended to the DOM in IE 6/7 (#8060)
|
|
if ( !support.appendChecked ) {
|
|
jQuery.grep( getAll( nodes, "input" ), fixDefaultChecked );
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
contains = jQuery.contains( elem.ownerDocument, elem );
|
|
|
|
// Append to fragment
|
|
tmp = getAll( safe.appendChild( elem ), "script" );
|
|
|
|
// Preserve script evaluation history
|
|
if ( contains ) {
|
|
setGlobalEval( tmp );
|
|
}
|
|
|
|
// Capture executables
|
|
if ( scripts ) {
|
|
j = 0;
|
|
while ( ( elem = tmp[ j++ ] ) ) {
|
|
if ( rscriptType.test( elem.type || "" ) ) {
|
|
scripts.push( elem );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
tmp = null;
|
|
|
|
return safe;
|
|
}
|
|
|
|
|
|
( function() {
|
|
var i, eventName,
|
|
div = document.createElement( "div" );
|
|
|
|
// Support: IE<9 (lack submit/change bubble), Firefox (lack focus(in | out) events)
|
|
for ( i in { submit: true, change: true, focusin: true } ) {
|
|
eventName = "on" + i;
|
|
|
|
if ( !( support[ i ] = eventName in window ) ) {
|
|
|
|
// Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP)
|
|
div.setAttribute( eventName, "t" );
|
|
support[ i ] = div.attributes[ eventName ].expando === false;
|
|
}
|
|
}
|
|
|
|
// Null elements to avoid leaks in IE.
|
|
div = null;
|
|
} )();
|
|
|
|
|
|
var rformElems = /^(?:input|select|textarea)$/i,
|
|
rkeyEvent = /^key/,
|
|
rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
|
|
rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
|
|
rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
|
|
|
|
function returnTrue() {
|
|
return true;
|
|
}
|
|
|
|
function returnFalse() {
|
|
return false;
|
|
}
|
|
|
|
// Support: IE9
|
|
// See #13393 for more info
|
|
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 tmp, events, t, handleObjIn,
|
|
special, eventHandle, handleObj,
|
|
handlers, type, namespaces, origType,
|
|
elemData = jQuery._data( elem );
|
|
|
|
// Don't attach events to noData or text/comment nodes (but allow plain objects)
|
|
if ( !elemData ) {
|
|
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;
|
|
}
|
|
|
|
// 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 = {};
|
|
}
|
|
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" &&
|
|
( !e || jQuery.event.triggered !== e.type ) ?
|
|
jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
|
|
undefined;
|
|
};
|
|
|
|
// Add elem as a property of the handle fn to prevent a memory leak
|
|
// with IE non-native events
|
|
eventHandle.elem = elem;
|
|
}
|
|
|
|
// Handle multiple events separated by a space
|
|
types = ( types || "" ).match( rnotwhite ) || [ "" ];
|
|
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/attachEvent if the special events handler returns false
|
|
if ( !special.setup ||
|
|
special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
|
|
|
|
// Bind the global event handler to the element
|
|
if ( elem.addEventListener ) {
|
|
elem.addEventListener( type, eventHandle, false );
|
|
|
|
} else if ( elem.attachEvent ) {
|
|
elem.attachEvent( "on" + 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;
|
|
}
|
|
|
|
// Nullify elem to prevent memory leaks in IE
|
|
elem = null;
|
|
},
|
|
|
|
// Detach an event or set of events from an element
|
|
remove: function( elem, types, handler, selector, mappedTypes ) {
|
|
var j, handleObj, tmp,
|
|
origCount, t, events,
|
|
special, handlers, type,
|
|
namespaces, origType,
|
|
elemData = jQuery.hasData( elem ) && jQuery._data( elem );
|
|
|
|
if ( !elemData || !( events = elemData.events ) ) {
|
|
return;
|
|
}
|
|
|
|
// Once for each type.namespace in types; type may be omitted
|
|
types = ( types || "" ).match( rnotwhite ) || [ "" ];
|
|
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 the expando if it's no longer used
|
|
if ( jQuery.isEmptyObject( events ) ) {
|
|
delete elemData.handle;
|
|
|
|
// removeData also checks for emptiness and clears the expando if empty
|
|
// so use it instead of delete
|
|
jQuery._removeData( elem, "events" );
|
|
}
|
|
},
|
|
|
|
trigger: function( event, data, elem, onlyHandlers ) {
|
|
var handle, ontype, cur,
|
|
bubbleType, special, tmp, i,
|
|
eventPath = [ elem || document ],
|
|
type = hasOwn.call( event, "type" ) ? event.type : event,
|
|
namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
|
|
|
|
cur = 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 && !jQuery.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() ) {
|
|
|
|
event.type = i > 1 ?
|
|
bubbleType :
|
|
special.bindType || type;
|
|
|
|
// jQuery handler
|
|
handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] &&
|
|
jQuery._data( 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 name as the event.
|
|
// Can't use an .isFunction() check here because IE6/7 fails that test.
|
|
// Don't do default actions on window, that's where global variables be (#6170)
|
|
if ( ontype && elem[ type ] && !jQuery.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;
|
|
try {
|
|
elem[ type ]();
|
|
} catch ( e ) {
|
|
|
|
// IE<9 dies on focus/blur to hidden element (#1486,#12518)
|
|
// only reproducible on winXP IE8 native, not IE9 in IE8 mode
|
|
}
|
|
jQuery.event.triggered = undefined;
|
|
|
|
if ( tmp ) {
|
|
elem[ ontype ] = tmp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return event.result;
|
|
},
|
|
|
|
dispatch: function( event ) {
|
|
|
|
// Make a writable jQuery.Event from the native event object
|
|
event = jQuery.event.fix( event );
|
|
|
|
var i, j, ret, matched, handleObj,
|
|
handlerQueue = [],
|
|
args = slice.call( arguments ),
|
|
handlers = ( jQuery._data( this, "events" ) || {} )[ event.type ] || [],
|
|
special = jQuery.event.special[ event.type ] || {};
|
|
|
|
// Use the fix-ed jQuery.Event rather than the (read-only) native event
|
|
args[ 0 ] = event;
|
|
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() ) {
|
|
|
|
// Triggered event must either 1) have no namespace, or 2) have namespace(s)
|
|
// a subset or equal to those in the bound event (both can have no namespace).
|
|
if ( !event.rnamespace || 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, matches, sel, handleObj,
|
|
handlerQueue = [],
|
|
delegateCount = handlers.delegateCount,
|
|
cur = event.target;
|
|
|
|
// Support (at least): Chrome, IE9
|
|
// Find delegate handlers
|
|
// Black-hole SVG <use> instance trees (#13180)
|
|
//
|
|
// Support: Firefox<=42+
|
|
// Avoid non-left-click in FF but don't block IE radio events (#3861, gh-2343)
|
|
if ( delegateCount && cur.nodeType &&
|
|
( event.type !== "click" || isNaN( event.button ) || event.button < 1 ) ) {
|
|
|
|
/* jshint eqeqeq: false */
|
|
for ( ; cur != this; cur = cur.parentNode || this ) {
|
|
/* jshint eqeqeq: true */
|
|
|
|
// Don't check non-elements (#13208)
|
|
// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
|
|
if ( cur.nodeType === 1 && ( cur.disabled !== true || event.type !== "click" ) ) {
|
|
matches = [];
|
|
for ( i = 0; i < delegateCount; i++ ) {
|
|
handleObj = handlers[ i ];
|
|
|
|
// Don't conflict with Object.prototype properties (#13203)
|
|
sel = handleObj.selector + " ";
|
|
|
|
if ( matches[ sel ] === undefined ) {
|
|
matches[ sel ] = handleObj.needsContext ?
|
|
jQuery( sel, this ).index( cur ) > -1 :
|
|
jQuery.find( sel, this, null, [ cur ] ).length;
|
|
}
|
|
if ( matches[ sel ] ) {
|
|
matches.push( handleObj );
|
|
}
|
|
}
|
|
if ( matches.length ) {
|
|
handlerQueue.push( { elem: cur, handlers: matches } );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add the remaining (directly-bound) handlers
|
|
if ( delegateCount < handlers.length ) {
|
|
handlerQueue.push( { elem: this, handlers: handlers.slice( delegateCount ) } );
|
|
}
|
|
|
|
return handlerQueue;
|
|
},
|
|
|
|
fix: function( event ) {
|
|
if ( event[ jQuery.expando ] ) {
|
|
return event;
|
|
}
|
|
|
|
// Create a writable copy of the event object and normalize some properties
|
|
var i, prop, copy,
|
|
type = event.type,
|
|
originalEvent = event,
|
|
fixHook = this.fixHooks[ type ];
|
|
|
|
if ( !fixHook ) {
|
|
this.fixHooks[ type ] = fixHook =
|
|
rmouseEvent.test( type ) ? this.mouseHooks :
|
|
rkeyEvent.test( type ) ? this.keyHooks :
|
|
{};
|
|
}
|
|
copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
|
|
|
|
event = new jQuery.Event( originalEvent );
|
|
|
|
i = copy.length;
|
|
while ( i-- ) {
|
|
prop = copy[ i ];
|
|
event[ prop ] = originalEvent[ prop ];
|
|
}
|
|
|
|
// Support: IE<9
|
|
// Fix target property (#1925)
|
|
if ( !event.target ) {
|
|
event.target = originalEvent.srcElement || document;
|
|
}
|
|
|
|
// Support: Safari 6-8+
|
|
// Target should not be a text node (#504, #13143)
|
|
if ( event.target.nodeType === 3 ) {
|
|
event.target = event.target.parentNode;
|
|
}
|
|
|
|
// Support: IE<9
|
|
// For mouse/key events, metaKey==false if it's undefined (#3368, #11328)
|
|
event.metaKey = !!event.metaKey;
|
|
|
|
return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
|
|
},
|
|
|
|
// Includes some event props shared by KeyEvent and MouseEvent
|
|
props: ( "altKey bubbles cancelable ctrlKey currentTarget detail eventPhase " +
|
|
"metaKey relatedTarget shiftKey target timeStamp view which" ).split( " " ),
|
|
|
|
fixHooks: {},
|
|
|
|
keyHooks: {
|
|
props: "char charCode key keyCode".split( " " ),
|
|
filter: function( event, original ) {
|
|
|
|
// Add which for key events
|
|
if ( event.which == null ) {
|
|
event.which = original.charCode != null ? original.charCode : original.keyCode;
|
|
}
|
|
|
|
return event;
|
|
}
|
|
},
|
|
|
|
mouseHooks: {
|
|
props: ( "button buttons clientX clientY fromElement offsetX offsetY " +
|
|
"pageX pageY screenX screenY toElement" ).split( " " ),
|
|
filter: function( event, original ) {
|
|
var body, eventDoc, doc,
|
|
button = original.button,
|
|
fromElement = original.fromElement;
|
|
|
|
// Calculate pageX/Y if missing and clientX/Y available
|
|
if ( event.pageX == null && original.clientX != null ) {
|
|
eventDoc = event.target.ownerDocument || document;
|
|
doc = eventDoc.documentElement;
|
|
body = eventDoc.body;
|
|
|
|
event.pageX = original.clientX +
|
|
( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) -
|
|
( doc && doc.clientLeft || body && body.clientLeft || 0 );
|
|
event.pageY = original.clientY +
|
|
( doc && doc.scrollTop || body && body.scrollTop || 0 ) -
|
|
( doc && doc.clientTop || body && body.clientTop || 0 );
|
|
}
|
|
|
|
// Add relatedTarget, if necessary
|
|
if ( !event.relatedTarget && fromElement ) {
|
|
event.relatedTarget = fromElement === event.target ?
|
|
original.toElement :
|
|
fromElement;
|
|
}
|
|
|
|
// Add which for click: 1 === left; 2 === middle; 3 === right
|
|
// Note: button is not normalized, so don't use it
|
|
if ( !event.which && button !== undefined ) {
|
|
event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
|
|
}
|
|
|
|
return event;
|
|
}
|
|
},
|
|
|
|
special: {
|
|
load: {
|
|
|
|
// Prevent triggered image.load events from bubbling to window.load
|
|
noBubble: true
|
|
},
|
|
focus: {
|
|
|
|
// Fire native event if possible so blur/focus sequence is correct
|
|
trigger: function() {
|
|
if ( this !== safeActiveElement() && this.focus ) {
|
|
try {
|
|
this.focus();
|
|
return false;
|
|
} catch ( e ) {
|
|
|
|
// Support: IE<9
|
|
// If we error on focus to hidden element (#1486, #12518),
|
|
// let .trigger() run the handlers
|
|
}
|
|
}
|
|
},
|
|
delegateType: "focusin"
|
|
},
|
|
blur: {
|
|
trigger: function() {
|
|
if ( this === safeActiveElement() && this.blur ) {
|
|
this.blur();
|
|
return false;
|
|
}
|
|
},
|
|
delegateType: "focusout"
|
|
},
|
|
click: {
|
|
|
|
// For checkbox, fire native event so checked state will be right
|
|
trigger: function() {
|
|
if ( jQuery.nodeName( this, "input" ) && this.type === "checkbox" && this.click ) {
|
|
this.click();
|
|
return false;
|
|
}
|
|
},
|
|
|
|
// For cross-browser consistency, don't fire native .click() on links
|
|
_default: function( event ) {
|
|
return jQuery.nodeName( event.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;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
// Piggyback on a donor event to simulate a different one
|
|
simulate: function( type, elem, event ) {
|
|
var e = jQuery.extend(
|
|
new jQuery.Event(),
|
|
event,
|
|
{
|
|
type: type,
|
|
isSimulated: true
|
|
|
|
// Previously, `originalEvent: {}` was set here, so stopPropagation call
|
|
// would not be triggered on donor event, since in our own
|
|
// jQuery.event.stopPropagation function we had a check for existence of
|
|
// originalEvent.stopPropagation method, so, consequently it would be a noop.
|
|
//
|
|
// Guard for simulated events was moved to jQuery.event.stopPropagation function
|
|
// since `originalEvent` should point to the original event for the
|
|
// constancy with other events and for more focused logic
|
|
}
|
|
);
|
|
|
|
jQuery.event.trigger( e, null, elem );
|
|
|
|
if ( e.isDefaultPrevented() ) {
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
};
|
|
|
|
jQuery.removeEvent = document.removeEventListener ?
|
|
function( elem, type, handle ) {
|
|
|
|
// This "if" is needed for plain objects
|
|
if ( elem.removeEventListener ) {
|
|
elem.removeEventListener( type, handle );
|
|
}
|
|
} :
|
|
function( elem, type, handle ) {
|
|
var name = "on" + type;
|
|
|
|
if ( elem.detachEvent ) {
|
|
|
|
// #8545, #7054, preventing memory leaks for custom events in IE6-8
|
|
// detachEvent needed property on element, by name of that event,
|
|
// to properly expose it to GC
|
|
if ( typeof elem[ name ] === "undefined" ) {
|
|
elem[ name ] = null;
|
|
}
|
|
|
|
elem.detachEvent( name, 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: IE < 9, Android < 4.0
|
|
src.returnValue === false ?
|
|
returnTrue :
|
|
returnFalse;
|
|
|
|
// 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 || jQuery.now();
|
|
|
|
// Mark it as fixed
|
|
this[ jQuery.expando ] = true;
|
|
};
|
|
|
|
// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
|
|
// http://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,
|
|
|
|
preventDefault: function() {
|
|
var e = this.originalEvent;
|
|
|
|
this.isDefaultPrevented = returnTrue;
|
|
if ( !e ) {
|
|
return;
|
|
}
|
|
|
|
// If preventDefault exists, run it on the original event
|
|
if ( e.preventDefault ) {
|
|
e.preventDefault();
|
|
|
|
// Support: IE
|
|
// Otherwise set the returnValue property of the original event to false
|
|
} else {
|
|
e.returnValue = false;
|
|
}
|
|
},
|
|
stopPropagation: function() {
|
|
var e = this.originalEvent;
|
|
|
|
this.isPropagationStopped = returnTrue;
|
|
|
|
if ( !e || this.isSimulated ) {
|
|
return;
|
|
}
|
|
|
|
// If stopPropagation exists, run it on the original event
|
|
if ( e.stopPropagation ) {
|
|
e.stopPropagation();
|
|
}
|
|
|
|
// Support: IE
|
|
// Set the cancelBubble property of the original event to true
|
|
e.cancelBubble = true;
|
|
},
|
|
stopImmediatePropagation: function() {
|
|
var e = this.originalEvent;
|
|
|
|
this.isImmediatePropagationStopped = returnTrue;
|
|
|
|
if ( e && e.stopImmediatePropagation ) {
|
|
e.stopImmediatePropagation();
|
|
}
|
|
|
|
this.stopPropagation();
|
|
}
|
|
};
|
|
|
|
// 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://code.google.com/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;
|
|
}
|
|
};
|
|
} );
|
|
|
|
// IE submit delegation
|
|
if ( !support.submit ) {
|
|
|
|
jQuery.event.special.submit = {
|
|
setup: function() {
|
|
|
|
// Only need this for delegated form submit events
|
|
if ( jQuery.nodeName( this, "form" ) ) {
|
|
return false;
|
|
}
|
|
|
|
// Lazy-add a submit handler when a descendant form may potentially be submitted
|
|
jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
|
|
|
|
// Node name check avoids a VML-related crash in IE (#9807)
|
|
var elem = e.target,
|
|
form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ?
|
|
|
|
// Support: IE <=8
|
|
// We use jQuery.prop instead of elem.form
|
|
// to allow fixing the IE8 delegated submit issue (gh-2332)
|
|
// by 3rd party polyfills/workarounds.
|
|
jQuery.prop( elem, "form" ) :
|
|
undefined;
|
|
|
|
if ( form && !jQuery._data( form, "submit" ) ) {
|
|
jQuery.event.add( form, "submit._submit", function( event ) {
|
|
event._submitBubble = true;
|
|
} );
|
|
jQuery._data( form, "submit", true );
|
|
}
|
|
} );
|
|
|
|
// return undefined since we don't need an event listener
|
|
},
|
|
|
|
postDispatch: function( event ) {
|
|
|
|
// If form was submitted by the user, bubble the event up the tree
|
|
if ( event._submitBubble ) {
|
|
delete event._submitBubble;
|
|
if ( this.parentNode && !event.isTrigger ) {
|
|
jQuery.event.simulate( "submit", this.parentNode, event );
|
|
}
|
|
}
|
|
},
|
|
|
|
teardown: function() {
|
|
|
|
// Only need this for delegated form submit events
|
|
if ( jQuery.nodeName( this, "form" ) ) {
|
|
return false;
|
|
}
|
|
|
|
// Remove delegated handlers; cleanData eventually reaps submit handlers attached above
|
|
jQuery.event.remove( this, "._submit" );
|
|
}
|
|
};
|
|
}
|
|
|
|
// IE change delegation and checkbox/radio fix
|
|
if ( !support.change ) {
|
|
|
|
jQuery.event.special.change = {
|
|
|
|
setup: function() {
|
|
|
|
if ( rformElems.test( this.nodeName ) ) {
|
|
|
|
// IE doesn't fire change on a check/radio until blur; trigger it on click
|
|
// after a propertychange. Eat the blur-change in special.change.handle.
|
|
// This still fires onchange a second time for check/radio after blur.
|
|
if ( this.type === "checkbox" || this.type === "radio" ) {
|
|
jQuery.event.add( this, "propertychange._change", function( event ) {
|
|
if ( event.originalEvent.propertyName === "checked" ) {
|
|
this._justChanged = true;
|
|
}
|
|
} );
|
|
jQuery.event.add( this, "click._change", function( event ) {
|
|
if ( this._justChanged && !event.isTrigger ) {
|
|
this._justChanged = false;
|
|
}
|
|
|
|
// Allow triggered, simulated change events (#11500)
|
|
jQuery.event.simulate( "change", this, event );
|
|
} );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Delegated event; lazy-add a change handler on descendant inputs
|
|
jQuery.event.add( this, "beforeactivate._change", function( e ) {
|
|
var elem = e.target;
|
|
|
|
if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "change" ) ) {
|
|
jQuery.event.add( elem, "change._change", function( event ) {
|
|
if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
|
|
jQuery.event.simulate( "change", this.parentNode, event );
|
|
}
|
|
} );
|
|
jQuery._data( elem, "change", true );
|
|
}
|
|
} );
|
|
},
|
|
|
|
handle: function( event ) {
|
|
var elem = event.target;
|
|
|
|
// Swallow native change events from checkbox/radio, we already triggered them above
|
|
if ( this !== elem || event.isSimulated || event.isTrigger ||
|
|
( elem.type !== "radio" && elem.type !== "checkbox" ) ) {
|
|
|
|
return event.handleObj.handler.apply( this, arguments );
|
|
}
|
|
},
|
|
|
|
teardown: function() {
|
|
jQuery.event.remove( this, "._change" );
|
|
|
|
return !rformElems.test( this.nodeName );
|
|
}
|
|
};
|
|
}
|
|
|
|
// Support: Firefox
|
|
// Firefox doesn't have focus(in | out) events
|
|
// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
|
|
//
|
|
// Support: Chrome, Safari
|
|
// 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://code.google.com/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() {
|
|
var doc = this.ownerDocument || this,
|
|
attaches = jQuery._data( doc, fix );
|
|
|
|
if ( !attaches ) {
|
|
doc.addEventListener( orig, handler, true );
|
|
}
|
|
jQuery._data( doc, fix, ( attaches || 0 ) + 1 );
|
|
},
|
|
teardown: function() {
|
|
var doc = this.ownerDocument || this,
|
|
attaches = jQuery._data( doc, fix ) - 1;
|
|
|
|
if ( !attaches ) {
|
|
doc.removeEventListener( orig, handler, true );
|
|
jQuery._removeData( doc, fix );
|
|
} else {
|
|
jQuery._data( doc, fix, attaches );
|
|
}
|
|
}
|
|
};
|
|
} );
|
|
}
|
|
|
|
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 );
|
|
} );
|
|
},
|
|
|
|
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 );
|
|
}
|
|
}
|
|
} );
|
|
|
|
|
|
var rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g,
|
|
rnoshimcache = new RegExp( "<(?:" + nodeNames + ")[\\s/>]", "i" ),
|
|
rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi,
|
|
|
|
// Support: IE 10-11, Edge 10240+
|
|
// 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,
|
|
rscriptTypeMasked = /^true\/(.*)/,
|
|
rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,
|
|
safeFragment = createSafeFragment( document ),
|
|
fragmentDiv = safeFragment.appendChild( document.createElement( "div" ) );
|
|
|
|
// Support: IE<8
|
|
// Manipulating tables requires a tbody
|
|
function manipulationTarget( elem, content ) {
|
|
return jQuery.nodeName( elem, "table" ) &&
|
|
jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ?
|
|
|
|
elem.getElementsByTagName( "tbody" )[ 0 ] ||
|
|
elem.appendChild( elem.ownerDocument.createElement( "tbody" ) ) :
|
|
elem;
|
|
}
|
|
|
|
// Replace/restore the type attribute of script elements for safe DOM manipulation
|
|
function disableScript( elem ) {
|
|
elem.type = ( jQuery.find.attr( elem, "type" ) !== null ) + "/" + elem.type;
|
|
return elem;
|
|
}
|
|
function restoreScript( elem ) {
|
|
var match = rscriptTypeMasked.exec( elem.type );
|
|
if ( match ) {
|
|
elem.type = match[ 1 ];
|
|
} else {
|
|
elem.removeAttribute( "type" );
|
|
}
|
|
return elem;
|
|
}
|
|
|
|
function cloneCopyEvent( src, dest ) {
|
|
if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
|
|
return;
|
|
}
|
|
|
|
var type, i, l,
|
|
oldData = jQuery._data( src ),
|
|
curData = jQuery._data( dest, oldData ),
|
|
events = oldData.events;
|
|
|
|
if ( events ) {
|
|
delete curData.handle;
|
|
curData.events = {};
|
|
|
|
for ( type in events ) {
|
|
for ( i = 0, l = events[ type ].length; i < l; i++ ) {
|
|
jQuery.event.add( dest, type, events[ type ][ i ] );
|
|
}
|
|
}
|
|
}
|
|
|
|
// make the cloned public data object a copy from the original
|
|
if ( curData.data ) {
|
|
curData.data = jQuery.extend( {}, curData.data );
|
|
}
|
|
}
|
|
|
|
function fixCloneNodeIssues( src, dest ) {
|
|
var nodeName, e, data;
|
|
|
|
// We do not need to do anything for non-Elements
|
|
if ( dest.nodeType !== 1 ) {
|
|
return;
|
|
}
|
|
|
|
nodeName = dest.nodeName.toLowerCase();
|
|
|
|
// IE6-8 copies events bound via attachEvent when using cloneNode.
|
|
if ( !support.noCloneEvent && dest[ jQuery.expando ] ) {
|
|
data = jQuery._data( dest );
|
|
|
|
for ( e in data.events ) {
|
|
jQuery.removeEvent( dest, e, data.handle );
|
|
}
|
|
|
|
// Event data gets referenced instead of copied if the expando gets copied too
|
|
dest.removeAttribute( jQuery.expando );
|
|
}
|
|
|
|
// IE blanks contents when cloning scripts, and tries to evaluate newly-set text
|
|
if ( nodeName === "script" && dest.text !== src.text ) {
|
|
disableScript( dest ).text = src.text;
|
|
restoreScript( dest );
|
|
|
|
// IE6-10 improperly clones children of object elements using classid.
|
|
// IE10 throws NoModificationAllowedError if parent is null, #12132.
|
|
} else if ( nodeName === "object" ) {
|
|
if ( dest.parentNode ) {
|
|
dest.outerHTML = src.outerHTML;
|
|
}
|
|
|
|
// This path appears unavoidable for IE9. When cloning an object
|
|
// element in IE9, the outerHTML strategy above is not sufficient.
|
|
// If the src has innerHTML and the destination does not,
|
|
// copy the src.innerHTML into the dest.innerHTML. #10324
|
|
if ( support.html5Clone && ( src.innerHTML && !jQuery.trim( dest.innerHTML ) ) ) {
|
|
dest.innerHTML = src.innerHTML;
|
|
}
|
|
|
|
} else if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
|
|
|
|
// IE6-8 fails to persist the checked state of a cloned checkbox
|
|
// or radio button. Worse, IE6-7 fail to give the cloned element
|
|
// a checked appearance if the defaultChecked value isn't also set
|
|
|
|
dest.defaultChecked = dest.checked = src.checked;
|
|
|
|
// IE6-7 get confused and end up setting the value of a cloned
|
|
// checkbox/radio button to an empty string instead of "on"
|
|
if ( dest.value !== src.value ) {
|
|
dest.value = src.value;
|
|
}
|
|
|
|
// IE6-8 fails to return the selected option to the default selected
|
|
// state when cloning options
|
|
} else if ( nodeName === "option" ) {
|
|
dest.defaultSelected = dest.selected = src.defaultSelected;
|
|
|
|
// IE6-8 fails to set the defaultValue to the correct value when
|
|
// cloning other types of input fields
|
|
} else if ( nodeName === "input" || nodeName === "textarea" ) {
|
|
dest.defaultValue = src.defaultValue;
|
|
}
|
|
}
|
|
|
|
function domManip( collection, args, callback, ignored ) {
|
|
|
|
// Flatten any nested arrays
|
|
args = concat.apply( [], args );
|
|
|
|
var first, node, hasScripts,
|
|
scripts, doc, fragment,
|
|
i = 0,
|
|
l = collection.length,
|
|
iNoClone = l - 1,
|
|
value = args[ 0 ],
|
|
isFunction = jQuery.isFunction( value );
|
|
|
|
// We can't cloneNode fragments that contain checked, in WebKit
|
|
if ( isFunction ||
|
|
( l > 1 && typeof value === "string" &&
|
|
!support.checkClone && rchecked.test( value ) ) ) {
|
|
return collection.each( function( index ) {
|
|
var self = collection.eq( index );
|
|
if ( isFunction ) {
|
|
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.1, PhantomJS<2
|
|
// 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 || "" ) &&
|
|
!jQuery._data( node, "globalEval" ) &&
|
|
jQuery.contains( doc, node ) ) {
|
|
|
|
if ( node.src ) {
|
|
|
|
// Optional AJAX dependency, but won't run scripts if not present
|
|
if ( jQuery._evalUrl ) {
|
|
jQuery._evalUrl( node.src );
|
|
}
|
|
} else {
|
|
jQuery.globalEval(
|
|
( node.text || node.textContent || node.innerHTML || "" )
|
|
.replace( rcleanScript, "" )
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fix #11809: Avoid leaking memory
|
|
fragment = first = null;
|
|
}
|
|
}
|
|
|
|
return collection;
|
|
}
|
|
|
|
function remove( elem, selector, keepData ) {
|
|
var node,
|
|
elems = selector ? jQuery.filter( selector, elem ) : elem,
|
|
i = 0;
|
|
|
|
for ( ; ( node = elems[ i ] ) != null; i++ ) {
|
|
|
|
if ( !keepData && node.nodeType === 1 ) {
|
|
jQuery.cleanData( getAll( node ) );
|
|
}
|
|
|
|
if ( node.parentNode ) {
|
|
if ( keepData && jQuery.contains( node.ownerDocument, node ) ) {
|
|
setGlobalEval( getAll( node, "script" ) );
|
|
}
|
|
node.parentNode.removeChild( node );
|
|
}
|
|
}
|
|
|
|
return elem;
|
|
}
|
|
|
|
jQuery.extend( {
|
|
htmlPrefilter: function( html ) {
|
|
return html.replace( rxhtmlTag, "<$1></$2>" );
|
|
},
|
|
|
|
clone: function( elem, dataAndEvents, deepDataAndEvents ) {
|
|
var destElements, node, clone, i, srcElements,
|
|
inPage = jQuery.contains( elem.ownerDocument, elem );
|
|
|
|
if ( support.html5Clone || jQuery.isXMLDoc( elem ) ||
|
|
!rnoshimcache.test( "<" + elem.nodeName + ">" ) ) {
|
|
|
|
clone = elem.cloneNode( true );
|
|
|
|
// IE<=8 does not properly clone detached, unknown element nodes
|
|
} else {
|
|
fragmentDiv.innerHTML = elem.outerHTML;
|
|
fragmentDiv.removeChild( clone = fragmentDiv.firstChild );
|
|
}
|
|
|
|
if ( ( !support.noCloneEvent || !support.noCloneChecked ) &&
|
|
( elem.nodeType === 1 || elem.nodeType === 11 ) && !jQuery.isXMLDoc( elem ) ) {
|
|
|
|
// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
|
|
destElements = getAll( clone );
|
|
srcElements = getAll( elem );
|
|
|
|
// Fix all IE cloning issues
|
|
for ( i = 0; ( node = srcElements[ i ] ) != null; ++i ) {
|
|
|
|
// Ensure that the destination node is not null; Fixes #9587
|
|
if ( destElements[ i ] ) {
|
|
fixCloneNodeIssues( node, 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; ( node = srcElements[ i ] ) != null; i++ ) {
|
|
cloneCopyEvent( node, destElements[ i ] );
|
|
}
|
|
} else {
|
|
cloneCopyEvent( elem, clone );
|
|
}
|
|
}
|
|
|
|
// Preserve script evaluation history
|
|
destElements = getAll( clone, "script" );
|
|
if ( destElements.length > 0 ) {
|
|
setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
|
|
}
|
|
|
|
destElements = srcElements = node = null;
|
|
|
|
// Return the cloned set
|
|
return clone;
|
|
},
|
|
|
|
cleanData: function( elems, /* internal */ forceAcceptData ) {
|
|
var elem, type, id, data,
|
|
i = 0,
|
|
internalKey = jQuery.expando,
|
|
cache = jQuery.cache,
|
|
attributes = support.attributes,
|
|
special = jQuery.event.special;
|
|
|
|
for ( ; ( elem = elems[ i ] ) != null; i++ ) {
|
|
if ( forceAcceptData || acceptData( elem ) ) {
|
|
|
|
id = elem[ internalKey ];
|
|
data = id && cache[ id ];
|
|
|
|
if ( data ) {
|
|
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 );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Remove cache only if it was not already removed by jQuery.event.remove
|
|
if ( cache[ id ] ) {
|
|
|
|
delete cache[ id ];
|
|
|
|
// Support: IE<9
|
|
// IE does not allow us to delete expando properties from nodes
|
|
// IE creates expando attributes along with the property
|
|
// IE does not have a removeAttribute function on Document nodes
|
|
if ( !attributes && typeof elem.removeAttribute !== "undefined" ) {
|
|
elem.removeAttribute( internalKey );
|
|
|
|
// Webkit & Blink performance suffers when deleting properties
|
|
// from DOM nodes, so set to undefined instead
|
|
// https://code.google.com/p/chromium/issues/detail?id=378607
|
|
} else {
|
|
elem[ internalKey ] = undefined;
|
|
}
|
|
|
|
deletedIds.push( id );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} );
|
|
|
|
jQuery.fn.extend( {
|
|
|
|
// Keep domManip exposed until 3.0 (gh-2225)
|
|
domManip: domManip,
|
|
|
|
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().append(
|
|
( this[ 0 ] && this[ 0 ].ownerDocument || document ).createTextNode( 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++ ) {
|
|
|
|
// Remove element nodes and prevent memory leaks
|
|
if ( elem.nodeType === 1 ) {
|
|
jQuery.cleanData( getAll( elem, false ) );
|
|
}
|
|
|
|
// Remove any remaining nodes
|
|
while ( elem.firstChild ) {
|
|
elem.removeChild( elem.firstChild );
|
|
}
|
|
|
|
// If this is a select, ensure that it displays empty (#12336)
|
|
// Support: IE<9
|
|
if ( elem.options && jQuery.nodeName( elem, "select" ) ) {
|
|
elem.options.length = 0;
|
|
}
|
|
}
|
|
|
|
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 ) {
|
|
return elem.nodeType === 1 ?
|
|
elem.innerHTML.replace( rinlinejQuery, "" ) :
|
|
undefined;
|
|
}
|
|
|
|
// See if we can take a shortcut and just use innerHTML
|
|
if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
|
|
( support.htmlSerialize || !rnoshimcache.test( value ) ) &&
|
|
( support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&
|
|
!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
|
|
|
|
value = jQuery.htmlPrefilter( value );
|
|
|
|
try {
|
|
for ( ; i < l; i++ ) {
|
|
|
|
// Remove element nodes and prevent memory leaks
|
|
elem = this[ i ] || {};
|
|
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,
|
|
i = 0,
|
|
ret = [],
|
|
insert = jQuery( selector ),
|
|
last = insert.length - 1;
|
|
|
|
for ( ; i <= last; i++ ) {
|
|
elems = i === last ? this : this.clone( true );
|
|
jQuery( insert[ i ] )[ original ]( elems );
|
|
|
|
// Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get()
|
|
push.apply( ret, elems.get() );
|
|
}
|
|
|
|
return this.pushStack( ret );
|
|
};
|
|
} );
|
|
|
|
|
|
var iframe,
|
|
elemdisplay = {
|
|
|
|
// Support: Firefox
|
|
// We have to pre-define these values for FF (#10227)
|
|
HTML: "block",
|
|
BODY: "block"
|
|
};
|
|
|
|
/**
|
|
* Retrieve the actual display of a element
|
|
* @param {String} name nodeName of the element
|
|
* @param {Object} doc Document object
|
|
*/
|
|
|
|
// Called only from within defaultDisplay
|
|
function actualDisplay( name, doc ) {
|
|
var elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),
|
|
|
|
display = jQuery.css( elem[ 0 ], "display" );
|
|
|
|
// We don't have any data stored on the element,
|
|
// so use "detach" method as fast way to get rid of the element
|
|
elem.detach();
|
|
|
|
return display;
|
|
}
|
|
|
|
/**
|
|
* Try to determine the default display value of an element
|
|
* @param {String} nodeName
|
|
*/
|
|
function defaultDisplay( nodeName ) {
|
|
var doc = document,
|
|
display = elemdisplay[ nodeName ];
|
|
|
|
if ( !display ) {
|
|
display = actualDisplay( nodeName, doc );
|
|
|
|
// If the simple way fails, read from inside an iframe
|
|
if ( display === "none" || !display ) {
|
|
|
|
// Use the already-created iframe if possible
|
|
iframe = ( iframe || jQuery( "<iframe frameborder='0' width='0' height='0'/>" ) )
|
|
.appendTo( doc.documentElement );
|
|
|
|
// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
|
|
doc = ( iframe[ 0 ].contentWindow || iframe[ 0 ].contentDocument ).document;
|
|
|
|
// Support: IE
|
|
doc.write();
|
|
doc.close();
|
|
|
|
display = actualDisplay( nodeName, doc );
|
|
iframe.detach();
|
|
}
|
|
|
|
// Store the correct default display
|
|
elemdisplay[ nodeName ] = display;
|
|
}
|
|
|
|
return display;
|
|
}
|
|
var rmargin = ( /^margin/ );
|
|
|
|
var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
|
|
|
|
var swap = function( elem, options, callback, args ) {
|
|
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.apply( elem, args || [] );
|
|
|
|
// Revert the old values
|
|
for ( name in options ) {
|
|
elem.style[ name ] = old[ name ];
|
|
}
|
|
|
|
return ret;
|
|
};
|
|
|
|
|
|
var documentElement = document.documentElement;
|
|
|
|
|
|
|
|
( function() {
|
|
var pixelPositionVal, pixelMarginRightVal, boxSizingReliableVal,
|
|
reliableHiddenOffsetsVal, reliableMarginRightVal, reliableMarginLeftVal,
|
|
container = document.createElement( "div" ),
|
|
div = document.createElement( "div" );
|
|
|
|
// Finish early in limited (non-browser) environments
|
|
if ( !div.style ) {
|
|
return;
|
|
}
|
|
|
|
div.style.cssText = "float:left;opacity:.5";
|
|
|
|
// Support: IE<9
|
|
// Make sure that element opacity exists (as opposed to filter)
|
|
support.opacity = div.style.opacity === "0.5";
|
|
|
|
// Verify style float existence
|
|
// (IE uses styleFloat instead of cssFloat)
|
|
support.cssFloat = !!div.style.cssFloat;
|
|
|
|
div.style.backgroundClip = "content-box";
|
|
div.cloneNode( true ).style.backgroundClip = "";
|
|
support.clearCloneStyle = div.style.backgroundClip === "content-box";
|
|
|
|
container = document.createElement( "div" );
|
|
container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" +
|
|
"padding:0;margin-top:1px;position:absolute";
|
|
div.innerHTML = "";
|
|
container.appendChild( div );
|
|
|
|
// Support: Firefox<29, Android 2.3
|
|
// Vendor-prefix box-sizing
|
|
support.boxSizing = div.style.boxSizing === "" || div.style.MozBoxSizing === "" ||
|
|
div.style.WebkitBoxSizing === "";
|
|
|
|
jQuery.extend( support, {
|
|
reliableHiddenOffsets: function() {
|
|
if ( pixelPositionVal == null ) {
|
|
computeStyleTests();
|
|
}
|
|
return reliableHiddenOffsetsVal;
|
|
},
|
|
|
|
boxSizingReliable: function() {
|
|
|
|
// We're checking for pixelPositionVal here instead of boxSizingReliableVal
|
|
// since that compresses better and they're computed together anyway.
|
|
if ( pixelPositionVal == null ) {
|
|
computeStyleTests();
|
|
}
|
|
return boxSizingReliableVal;
|
|
},
|
|
|
|
pixelMarginRight: function() {
|
|
|
|
// Support: Android 4.0-4.3
|
|
if ( pixelPositionVal == null ) {
|
|
computeStyleTests();
|
|
}
|
|
return pixelMarginRightVal;
|
|
},
|
|
|
|
pixelPosition: function() {
|
|
if ( pixelPositionVal == null ) {
|
|
computeStyleTests();
|
|
}
|
|
return pixelPositionVal;
|
|
},
|
|
|
|
reliableMarginRight: function() {
|
|
|
|
// Support: Android 2.3
|
|
if ( pixelPositionVal == null ) {
|
|
computeStyleTests();
|
|
}
|
|
return reliableMarginRightVal;
|
|
},
|
|
|
|
reliableMarginLeft: function() {
|
|
|
|
// Support: IE <=8 only, Android 4.0 - 4.3 only, Firefox <=3 - 37
|
|
if ( pixelPositionVal == null ) {
|
|
computeStyleTests();
|
|
}
|
|
return reliableMarginLeftVal;
|
|
}
|
|
} );
|
|
|
|
function computeStyleTests() {
|
|
var contents, divStyle,
|
|
documentElement = document.documentElement;
|
|
|
|
// Setup
|
|
documentElement.appendChild( container );
|
|
|
|
div.style.cssText =
|
|
|
|
// Support: Android 2.3
|
|
// Vendor-prefix box-sizing
|
|
"-webkit-box-sizing:border-box;box-sizing:border-box;" +
|
|
"position:relative;display:block;" +
|
|
"margin:auto;border:1px;padding:1px;" +
|
|
"top:1%;width:50%";
|
|
|
|
// Support: IE<9
|
|
// Assume reasonable values in the absence of getComputedStyle
|
|
pixelPositionVal = boxSizingReliableVal = reliableMarginLeftVal = false;
|
|
pixelMarginRightVal = reliableMarginRightVal = true;
|
|
|
|
// Check for getComputedStyle so that this code is not run in IE<9.
|
|
if ( window.getComputedStyle ) {
|
|
divStyle = window.getComputedStyle( div );
|
|
pixelPositionVal = ( divStyle || {} ).top !== "1%";
|
|
reliableMarginLeftVal = ( divStyle || {} ).marginLeft === "2px";
|
|
boxSizingReliableVal = ( divStyle || { width: "4px" } ).width === "4px";
|
|
|
|
// Support: Android 4.0 - 4.3 only
|
|
// Some styles come back with percentage values, even though they shouldn't
|
|
div.style.marginRight = "50%";
|
|
pixelMarginRightVal = ( divStyle || { marginRight: "4px" } ).marginRight === "4px";
|
|
|
|
// Support: Android 2.3 only
|
|
// Div with explicit width and no margin-right incorrectly
|
|
// gets computed margin-right based on width of container (#3333)
|
|
// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
|
|
contents = div.appendChild( document.createElement( "div" ) );
|
|
|
|
// Reset CSS: box-sizing; display; margin; border; padding
|
|
contents.style.cssText = div.style.cssText =
|
|
|
|
// Support: Android 2.3
|
|
// Vendor-prefix box-sizing
|
|
"-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" +
|
|
"box-sizing:content-box;display:block;margin:0;border:0;padding:0";
|
|
contents.style.marginRight = contents.style.width = "0";
|
|
div.style.width = "1px";
|
|
|
|
reliableMarginRightVal =
|
|
!parseFloat( ( window.getComputedStyle( contents ) || {} ).marginRight );
|
|
|
|
div.removeChild( contents );
|
|
}
|
|
|
|
// Support: IE6-8
|
|
// First check that getClientRects works as expected
|
|
// Check if table cells still have offsetWidth/Height when they are set
|
|
// to display:none and there are still other visible table cells in a
|
|
// table row; if so, offsetWidth/Height are not reliable for use when
|
|
// determining if an element has been hidden directly using
|
|
// display:none (it is still safe to use offsets if a parent element is
|
|
// hidden; don safety goggles and see bug #4512 for more information).
|
|
div.style.display = "none";
|
|
reliableHiddenOffsetsVal = div.getClientRects().length === 0;
|
|
if ( reliableHiddenOffsetsVal ) {
|
|
div.style.display = "";
|
|
div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
|
|
div.childNodes[ 0 ].style.borderCollapse = "separate";
|
|
contents = div.getElementsByTagName( "td" );
|
|
contents[ 0 ].style.cssText = "margin:0;border:0;padding:0;display:none";
|
|
reliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0;
|
|
if ( reliableHiddenOffsetsVal ) {
|
|
contents[ 0 ].style.display = "";
|
|
contents[ 1 ].style.display = "none";
|
|
reliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0;
|
|
}
|
|
}
|
|
|
|
// Teardown
|
|
documentElement.removeChild( container );
|
|
}
|
|
|
|
} )();
|
|
|
|
|
|
var getStyles, curCSS,
|
|
rposition = /^(top|right|bottom|left)$/;
|
|
|
|
if ( window.getComputedStyle ) {
|
|
getStyles = function( elem ) {
|
|
|
|
// Support: IE<=11+, 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 );
|
|
};
|
|
|
|
curCSS = function( elem, name, computed ) {
|
|
var width, minWidth, maxWidth, ret,
|
|
style = elem.style;
|
|
|
|
computed = computed || getStyles( elem );
|
|
|
|
// getPropertyValue is only needed for .css('filter') in IE9, see #12537
|
|
ret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined;
|
|
|
|
// Support: Opera 12.1x only
|
|
// Fall back to style even without computed
|
|
// computed is undefined for elems on document fragments
|
|
if ( ( ret === "" || ret === undefined ) && !jQuery.contains( elem.ownerDocument, elem ) ) {
|
|
ret = jQuery.style( elem, name );
|
|
}
|
|
|
|
if ( computed ) {
|
|
|
|
// A tribute to the "awesome hack by Dean Edwards"
|
|
// Chrome < 17 and Safari 5.0 uses "computed value"
|
|
// instead of "used value" for margin-right
|
|
// Safari 5.1.7 (at least) returns percentage for a larger set of values,
|
|
// but width seems to be reliably pixels
|
|
// this is against the CSSOM draft spec:
|
|
// http://dev.w3.org/csswg/cssom/#resolved-values
|
|
if ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.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;
|
|
}
|
|
}
|
|
|
|
// Support: IE
|
|
// IE returns zIndex value as an integer.
|
|
return ret === undefined ?
|
|
ret :
|
|
ret + "";
|
|
};
|
|
} else if ( documentElement.currentStyle ) {
|
|
getStyles = function( elem ) {
|
|
return elem.currentStyle;
|
|
};
|
|
|
|
curCSS = function( elem, name, computed ) {
|
|
var left, rs, rsLeft, ret,
|
|
style = elem.style;
|
|
|
|
computed = computed || getStyles( elem );
|
|
ret = computed ? computed[ name ] : undefined;
|
|
|
|
// Avoid setting ret to empty string here
|
|
// so we don't default to auto
|
|
if ( ret == null && style && style[ name ] ) {
|
|
ret = style[ name ];
|
|
}
|
|
|
|
// From the awesome hack by Dean Edwards
|
|
// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
|
|
|
|
// If we're not dealing with a regular pixel number
|
|
// but a number that has a weird ending, we need to convert it to pixels
|
|
// but not position css attributes, as those are
|
|
// proportional to the parent element instead
|
|
// and we can't measure the parent instead because it
|
|
// might trigger a "stacking dolls" problem
|
|
if ( rnumnonpx.test( ret ) && !rposition.test( name ) ) {
|
|
|
|
// Remember the original values
|
|
left = style.left;
|
|
rs = elem.runtimeStyle;
|
|
rsLeft = rs && rs.left;
|
|
|
|
// Put in the new values to get a computed value out
|
|
if ( rsLeft ) {
|
|
rs.left = elem.currentStyle.left;
|
|
}
|
|
style.left = name === "fontSize" ? "1em" : ret;
|
|
ret = style.pixelLeft + "px";
|
|
|
|
// Revert the changed values
|
|
style.left = left;
|
|
if ( rsLeft ) {
|
|
rs.left = rsLeft;
|
|
}
|
|
}
|
|
|
|
// Support: IE
|
|
// IE returns zIndex value as an integer.
|
|
return ret === undefined ?
|
|
ret :
|
|
ret + "" || "auto";
|
|
};
|
|
}
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
ralpha = /alpha\([^)]*\)/i,
|
|
ropacity = /opacity\s*=\s*([^)]*)/i,
|
|
|
|
// 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]).+)/,
|
|
rnumsplit = new RegExp( "^(" + pnum + ")(.*)$", "i" ),
|
|
|
|
cssShow = { position: "absolute", visibility: "hidden", display: "block" },
|
|
cssNormalTransform = {
|
|
letterSpacing: "0",
|
|
fontWeight: "400"
|
|
},
|
|
|
|
cssPrefixes = [ "Webkit", "O", "Moz", "ms" ],
|
|
emptyStyle = document.createElement( "div" ).style;
|
|
|
|
|
|
// return a css property mapped to a potentially vendor prefixed property
|
|
function vendorPropName( name ) {
|
|
|
|
// shortcut for names that are not vendor prefixed
|
|
if ( name in emptyStyle ) {
|
|
return name;
|
|
}
|
|
|
|
// check for vendor prefixed names
|
|
var capName = name.charAt( 0 ).toUpperCase() + name.slice( 1 ),
|
|
i = cssPrefixes.length;
|
|
|
|
while ( i-- ) {
|
|
name = cssPrefixes[ i ] + capName;
|
|
if ( name in emptyStyle ) {
|
|
return name;
|
|
}
|
|
}
|
|
}
|
|
|
|
function showHide( elements, show ) {
|
|
var display, elem, hidden,
|
|
values = [],
|
|
index = 0,
|
|
length = elements.length;
|
|
|
|
for ( ; index < length; index++ ) {
|
|
elem = elements[ index ];
|
|
if ( !elem.style ) {
|
|
continue;
|
|
}
|
|
|
|
values[ index ] = jQuery._data( elem, "olddisplay" );
|
|
display = elem.style.display;
|
|
if ( show ) {
|
|
|
|
// Reset the inline display of this element to learn if it is
|
|
// being hidden by cascaded rules or not
|
|
if ( !values[ index ] && display === "none" ) {
|
|
elem.style.display = "";
|
|
}
|
|
|
|
// Set elements which have been overridden with display: none
|
|
// in a stylesheet to whatever the default browser style is
|
|
// for such an element
|
|
if ( elem.style.display === "" && isHidden( elem ) ) {
|
|
values[ index ] =
|
|
jQuery._data( elem, "olddisplay", defaultDisplay( elem.nodeName ) );
|
|
}
|
|
} else {
|
|
hidden = isHidden( elem );
|
|
|
|
if ( display && display !== "none" || !hidden ) {
|
|
jQuery._data(
|
|
elem,
|
|
"olddisplay",
|
|
hidden ? display : jQuery.css( elem, "display" )
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set the display of most of the elements in a second loop
|
|
// to avoid the constant reflow
|
|
for ( index = 0; index < length; index++ ) {
|
|
elem = elements[ index ];
|
|
if ( !elem.style ) {
|
|
continue;
|
|
}
|
|
if ( !show || elem.style.display === "none" || elem.style.display === "" ) {
|
|
elem.style.display = show ? values[ index ] || "" : "none";
|
|
}
|
|
}
|
|
|
|
return elements;
|
|
}
|
|
|
|
function setPositiveNumber( elem, value, subtract ) {
|
|
var matches = rnumsplit.exec( value );
|
|
return matches ?
|
|
|
|
// Guard against undefined "subtract", e.g., when used as in cssHooks
|
|
Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) :
|
|
value;
|
|
}
|
|
|
|
function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
|
|
var i = extra === ( isBorderBox ? "border" : "content" ) ?
|
|
|
|
// If we already have the right measurement, avoid augmentation
|
|
4 :
|
|
|
|
// Otherwise initialize for horizontal or vertical properties
|
|
name === "width" ? 1 : 0,
|
|
|
|
val = 0;
|
|
|
|
for ( ; i < 4; i += 2 ) {
|
|
|
|
// both box models exclude margin, so add it if we want it
|
|
if ( extra === "margin" ) {
|
|
val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
|
|
}
|
|
|
|
if ( isBorderBox ) {
|
|
|
|
// border-box includes padding, so remove it if we want content
|
|
if ( extra === "content" ) {
|
|
val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
|
|
}
|
|
|
|
// at this point, extra isn't border nor margin, so remove border
|
|
if ( extra !== "margin" ) {
|
|
val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
|
|
}
|
|
} else {
|
|
|
|
// at this point, extra isn't content, so add padding
|
|
val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
|
|
|
|
// at this point, extra isn't content nor padding, so add border
|
|
if ( extra !== "padding" ) {
|
|
val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
|
|
}
|
|
}
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
function getWidthOrHeight( elem, name, extra ) {
|
|
|
|
// Start with offset property, which is equivalent to the border-box value
|
|
var valueIsBorderBox = true,
|
|
val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
|
|
styles = getStyles( elem ),
|
|
isBorderBox = support.boxSizing &&
|
|
jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
|
|
|
|
// some non-html elements return undefined for offsetWidth, so check for null/undefined
|
|
// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
|
|
// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
|
|
if ( val <= 0 || val == null ) {
|
|
|
|
// Fall back to computed then uncomputed css if necessary
|
|
val = curCSS( elem, name, styles );
|
|
if ( val < 0 || val == null ) {
|
|
val = elem.style[ name ];
|
|
}
|
|
|
|
// Computed unit is not pixels. Stop here and return.
|
|
if ( rnumnonpx.test( val ) ) {
|
|
return val;
|
|
}
|
|
|
|
// we need the check for style in case a browser which returns unreliable values
|
|
// for getComputedStyle silently falls back to the reliable elem.style
|
|
valueIsBorderBox = isBorderBox &&
|
|
( support.boxSizingReliable() || val === elem.style[ name ] );
|
|
|
|
// Normalize "", auto, and prepare for extra
|
|
val = parseFloat( val ) || 0;
|
|
}
|
|
|
|
// use the active box-sizing model to add/subtract irrelevant styles
|
|
return ( val +
|
|
augmentWidthOrHeight(
|
|
elem,
|
|
name,
|
|
extra || ( isBorderBox ? "border" : "content" ),
|
|
valueIsBorderBox,
|
|
styles
|
|
)
|
|
) + "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,
|
|
"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: {
|
|
|
|
// normalize float css property
|
|
"float": support.cssFloat ? "cssFloat" : "styleFloat"
|
|
},
|
|
|
|
// 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 = jQuery.camelCase( name ),
|
|
style = elem.style;
|
|
|
|
name = jQuery.cssProps[ origName ] ||
|
|
( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );
|
|
|
|
// gets hook for the prefixed version
|
|
// followed by the 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. See: #7116
|
|
if ( value == null || value !== value ) {
|
|
return;
|
|
}
|
|
|
|
// If a number was passed in, add the unit (except for certain CSS properties)
|
|
if ( type === "number" ) {
|
|
value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
|
|
}
|
|
|
|
// Fixes #8908, it can be done more correctly by specifing setters in cssHooks,
|
|
// but it would mean to define eight
|
|
// (for every problematic property) identical functions
|
|
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 ) {
|
|
|
|
// Support: IE
|
|
// Swallow errors from 'invalid' CSS values (#5509)
|
|
try {
|
|
style[ name ] = value;
|
|
} catch ( e ) {}
|
|
}
|
|
|
|
} 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 num, val, hooks,
|
|
origName = jQuery.camelCase( name );
|
|
|
|
// Make sure that we're working with the right name
|
|
name = jQuery.cssProps[ origName ] ||
|
|
( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );
|
|
|
|
// gets hook for the prefixed version
|
|
// followed by the unprefixed version
|
|
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 ];
|
|
}
|
|
|
|
// Return, converting to number 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, name ) {
|
|
jQuery.cssHooks[ name ] = {
|
|
get: function( elem, computed, extra ) {
|
|
if ( computed ) {
|
|
|
|
// certain elements can have dimension info if we invisibly show them
|
|
// however, it must have a current display style that would benefit from this
|
|
return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
|
|
elem.offsetWidth === 0 ?
|
|
swap( elem, cssShow, function() {
|
|
return getWidthOrHeight( elem, name, extra );
|
|
} ) :
|
|
getWidthOrHeight( elem, name, extra );
|
|
}
|
|
},
|
|
|
|
set: function( elem, value, extra ) {
|
|
var styles = extra && getStyles( elem );
|
|
return setPositiveNumber( elem, value, extra ?
|
|
augmentWidthOrHeight(
|
|
elem,
|
|
name,
|
|
extra,
|
|
support.boxSizing &&
|
|
jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
|
|
styles
|
|
) : 0
|
|
);
|
|
}
|
|
};
|
|
} );
|
|
|
|
if ( !support.opacity ) {
|
|
jQuery.cssHooks.opacity = {
|
|
get: function( elem, computed ) {
|
|
|
|
// IE uses filters for opacity
|
|
return ropacity.test( ( computed && elem.currentStyle ?
|
|
elem.currentStyle.filter :
|
|
elem.style.filter ) || "" ) ?
|
|
( 0.01 * parseFloat( RegExp.$1 ) ) + "" :
|
|
computed ? "1" : "";
|
|
},
|
|
|
|
set: function( elem, value ) {
|
|
var style = elem.style,
|
|
currentStyle = elem.currentStyle,
|
|
opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "",
|
|
filter = currentStyle && currentStyle.filter || style.filter || "";
|
|
|
|
// IE has trouble with opacity if it does not have layout
|
|
// Force it by setting the zoom level
|
|
style.zoom = 1;
|
|
|
|
// if setting opacity to 1, and no other filters exist -
|
|
// attempt to remove filter attribute #6652
|
|
// if value === "", then remove inline opacity #12685
|
|
if ( ( value >= 1 || value === "" ) &&
|
|
jQuery.trim( filter.replace( ralpha, "" ) ) === "" &&
|
|
style.removeAttribute ) {
|
|
|
|
// Setting style.filter to null, "" & " " still leave "filter:" in the cssText
|
|
// if "filter:" is present at all, clearType is disabled, we want to avoid this
|
|
// style.removeAttribute is IE Only, but so apparently is this code path...
|
|
style.removeAttribute( "filter" );
|
|
|
|
// if there is no filter style applied in a css rule
|
|
// or unset inline opacity, we are done
|
|
if ( value === "" || currentStyle && !currentStyle.filter ) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// otherwise, set new filter values
|
|
style.filter = ralpha.test( filter ) ?
|
|
filter.replace( ralpha, opacity ) :
|
|
filter + " " + opacity;
|
|
}
|
|
};
|
|
}
|
|
|
|
jQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight,
|
|
function( elem, computed ) {
|
|
if ( computed ) {
|
|
return swap( elem, { "display": "inline-block" },
|
|
curCSS, [ elem, "marginRight" ] );
|
|
}
|
|
}
|
|
);
|
|
|
|
jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
|
|
function( elem, computed ) {
|
|
if ( computed ) {
|
|
return (
|
|
parseFloat( curCSS( elem, "marginLeft" ) ) ||
|
|
|
|
// Support: IE<=11+
|
|
// Running getBoundingClientRect on a disconnected node in IE throws an error
|
|
// Support: IE8 only
|
|
// getClientRects() errors on disconnected elems
|
|
( jQuery.contains( elem.ownerDocument, elem ) ?
|
|
elem.getBoundingClientRect().left -
|
|
swap( elem, { marginLeft: 0 }, function() {
|
|
return elem.getBoundingClientRect().left;
|
|
} ) :
|
|
0
|
|
)
|
|
) + "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 ( !rmargin.test( prefix ) ) {
|
|
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 ( jQuery.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 );
|
|
},
|
|
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 ( isHidden( this ) ) {
|
|
jQuery( this ).show();
|
|
} else {
|
|
jQuery( this ).hide();
|
|
}
|
|
} );
|
|
}
|
|
} );
|
|
|
|
|
|
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
|
|
// so, 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 its
|
|
// 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 &&
|
|
( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||
|
|
jQuery.cssHooks[ tween.prop ] ) ) {
|
|
jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
|
|
} else {
|
|
tween.elem[ tween.prop ] = tween.now;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// Support: IE <=9
|
|
// 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, timerId,
|
|
rfxtypes = /^(?:toggle|show|hide)$/,
|
|
rrun = /queueHooks$/;
|
|
|
|
// Animations created synchronously will run synchronously
|
|
function createFxNow() {
|
|
window.setTimeout( function() {
|
|
fxNow = undefined;
|
|
} );
|
|
return ( fxNow = jQuery.now() );
|
|
}
|
|
|
|
// Generate parameters to create a standard animation
|
|
function genFx( type, includeWidth ) {
|
|
var which,
|
|
attrs = { height: type },
|
|
i = 0;
|
|
|
|
// if we include width, step value is 1 to do all cssExpand values,
|
|
// if we don't include width, 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 ) {
|
|
/* jshint validthis: true */
|
|
var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,
|
|
anim = this,
|
|
orig = {},
|
|
style = elem.style,
|
|
hidden = elem.nodeType && isHidden( elem ),
|
|
dataShow = jQuery._data( elem, "fxshow" );
|
|
|
|
// handle queue: false promises
|
|
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() {
|
|
|
|
// doing this makes sure that the complete handler will be called
|
|
// before this completes
|
|
anim.always( function() {
|
|
hooks.unqueued--;
|
|
if ( !jQuery.queue( elem, "fx" ).length ) {
|
|
hooks.empty.fire();
|
|
}
|
|
} );
|
|
} );
|
|
}
|
|
|
|
// height/width overflow pass
|
|
if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
|
|
|
|
// Make sure that nothing sneaks out
|
|
// Record all 3 overflow attributes because IE does not
|
|
// change the overflow attribute when overflowX and
|
|
// overflowY are set to the same value
|
|
opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
|
|
|
|
// Set display property to inline-block for height/width
|
|
// animations on inline elements that are having width/height animated
|
|
display = jQuery.css( elem, "display" );
|
|
|
|
// Test default display if display is currently "none"
|
|
checkDisplay = display === "none" ?
|
|
jQuery._data( elem, "olddisplay" ) || defaultDisplay( elem.nodeName ) : display;
|
|
|
|
if ( checkDisplay === "inline" && jQuery.css( elem, "float" ) === "none" ) {
|
|
|
|
// inline-level elements accept inline-block;
|
|
// block-level elements need to be inline with layout
|
|
if ( !support.inlineBlockNeedsLayout || defaultDisplay( elem.nodeName ) === "inline" ) {
|
|
style.display = "inline-block";
|
|
} else {
|
|
style.zoom = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( opts.overflow ) {
|
|
style.overflow = "hidden";
|
|
if ( !support.shrinkWrapBlocks() ) {
|
|
anim.always( function() {
|
|
style.overflow = opts.overflow[ 0 ];
|
|
style.overflowX = opts.overflow[ 1 ];
|
|
style.overflowY = opts.overflow[ 2 ];
|
|
} );
|
|
}
|
|
}
|
|
|
|
// show/hide pass
|
|
for ( prop in props ) {
|
|
value = props[ prop ];
|
|
if ( rfxtypes.exec( value ) ) {
|
|
delete props[ prop ];
|
|
toggle = toggle || value === "toggle";
|
|
if ( value === ( hidden ? "hide" : "show" ) ) {
|
|
|
|
// If there is dataShow left over from a stopped hide or show
|
|
// and we are going to proceed with show, we should pretend to be hidden
|
|
if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
|
|
hidden = true;
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
|
|
|
|
// Any non-fx value stops us from restoring the original display value
|
|
} else {
|
|
display = undefined;
|
|
}
|
|
}
|
|
|
|
if ( !jQuery.isEmptyObject( orig ) ) {
|
|
if ( dataShow ) {
|
|
if ( "hidden" in dataShow ) {
|
|
hidden = dataShow.hidden;
|
|
}
|
|
} else {
|
|
dataShow = jQuery._data( elem, "fxshow", {} );
|
|
}
|
|
|
|
// store state if its toggle - enables .stop().toggle() to "reverse"
|
|
if ( toggle ) {
|
|
dataShow.hidden = !hidden;
|
|
}
|
|
if ( hidden ) {
|
|
jQuery( elem ).show();
|
|
} else {
|
|
anim.done( function() {
|
|
jQuery( elem ).hide();
|
|
} );
|
|
}
|
|
anim.done( function() {
|
|
var prop;
|
|
jQuery._removeData( elem, "fxshow" );
|
|
for ( prop in orig ) {
|
|
jQuery.style( elem, prop, orig[ prop ] );
|
|
}
|
|
} );
|
|
for ( prop in orig ) {
|
|
tween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
|
|
|
|
if ( !( prop in dataShow ) ) {
|
|
dataShow[ prop ] = tween.start;
|
|
if ( hidden ) {
|
|
tween.end = tween.start;
|
|
tween.start = prop === "width" || prop === "height" ? 1 : 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If this is a noop like .hide().hide(), restore an overwritten display value
|
|
} else if ( ( display === "none" ? defaultDisplay( elem.nodeName ) : display ) === "inline" ) {
|
|
style.display = display;
|
|
}
|
|
}
|
|
|
|
function propFilter( props, specialEasing ) {
|
|
var index, name, easing, value, hooks;
|
|
|
|
// camelCase, specialEasing and expand cssHook pass
|
|
for ( index in props ) {
|
|
name = jQuery.camelCase( index );
|
|
easing = specialEasing[ name ];
|
|
value = props[ index ];
|
|
if ( jQuery.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 wont overwrite keys already present.
|
|
// also - reusing 'index' from above 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
|
|
// 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 ( percent < 1 && length ) {
|
|
return remaining;
|
|
} else {
|
|
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 ( jQuery.isFunction( result.stop ) ) {
|
|
jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
|
|
jQuery.proxy( result.stop, result );
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
jQuery.map( props, createTween, animation );
|
|
|
|
if ( jQuery.isFunction( animation.opts.start ) ) {
|
|
animation.opts.start.call( elem, animation );
|
|
}
|
|
|
|
jQuery.fx.timer(
|
|
jQuery.extend( tick, {
|
|
elem: elem,
|
|
anim: animation,
|
|
queue: animation.opts.queue
|
|
} )
|
|
);
|
|
|
|
// attach callbacks from options
|
|
return animation.progress( animation.opts.progress )
|
|
.done( animation.opts.done, animation.opts.complete )
|
|
.fail( animation.opts.fail )
|
|
.always( animation.opts.always );
|
|
}
|
|
|
|
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 ( jQuery.isFunction( props ) ) {
|
|
callback = props;
|
|
props = [ "*" ];
|
|
} else {
|
|
props = props.match( rnotwhite );
|
|
}
|
|
|
|
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 ||
|
|
jQuery.isFunction( speed ) && speed,
|
|
duration: speed,
|
|
easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
|
|
};
|
|
|
|
opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
|
|
opt.duration in jQuery.fx.speeds ?
|
|
jQuery.fx.speeds[ 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 ( jQuery.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( isHidden ).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 || jQuery._data( 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 && type !== false ) {
|
|
this.queue( type || "fx", [] );
|
|
}
|
|
|
|
return this.each( function() {
|
|
var dequeue = true,
|
|
index = type != null && type + "queueHooks",
|
|
timers = jQuery.timers,
|
|
data = jQuery._data( 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 = jQuery._data( 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,
|
|
timers = jQuery.timers,
|
|
i = 0;
|
|
|
|
fxNow = jQuery.now();
|
|
|
|
for ( ; i < timers.length; i++ ) {
|
|
timer = timers[ i ];
|
|
|
|
// Checks the timer has not already been removed
|
|
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 );
|
|
if ( timer() ) {
|
|
jQuery.fx.start();
|
|
} else {
|
|
jQuery.timers.pop();
|
|
}
|
|
};
|
|
|
|
jQuery.fx.interval = 13;
|
|
|
|
jQuery.fx.start = function() {
|
|
if ( !timerId ) {
|
|
timerId = window.setInterval( jQuery.fx.tick, jQuery.fx.interval );
|
|
}
|
|
};
|
|
|
|
jQuery.fx.stop = function() {
|
|
window.clearInterval( timerId );
|
|
timerId = null;
|
|
};
|
|
|
|
jQuery.fx.speeds = {
|
|
slow: 600,
|
|
fast: 200,
|
|
|
|
// Default speed
|
|
_default: 400
|
|
};
|
|
|
|
|
|
// Based off of the plugin by Clint Helfers, with permission.
|
|
// http://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 a,
|
|
input = document.createElement( "input" ),
|
|
div = document.createElement( "div" ),
|
|
select = document.createElement( "select" ),
|
|
opt = select.appendChild( document.createElement( "option" ) );
|
|
|
|
// Setup
|
|
div = document.createElement( "div" );
|
|
div.setAttribute( "className", "t" );
|
|
div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
|
|
a = div.getElementsByTagName( "a" )[ 0 ];
|
|
|
|
// Support: Windows Web Apps (WWA)
|
|
// `type` must use .setAttribute for WWA (#14901)
|
|
input.setAttribute( "type", "checkbox" );
|
|
div.appendChild( input );
|
|
|
|
a = div.getElementsByTagName( "a" )[ 0 ];
|
|
|
|
// First batch of tests.
|
|
a.style.cssText = "top:1px";
|
|
|
|
// Test setAttribute on camelCase class.
|
|
// If it works, we need attrFixes when doing get/setAttribute (ie6/7)
|
|
support.getSetAttribute = div.className !== "t";
|
|
|
|
// Get the style information from getAttribute
|
|
// (IE uses .cssText instead)
|
|
support.style = /top/.test( a.getAttribute( "style" ) );
|
|
|
|
// Make sure that URLs aren't manipulated
|
|
// (IE normalizes it by default)
|
|
support.hrefNormalized = a.getAttribute( "href" ) === "/a";
|
|
|
|
// Check the default checkbox/radio value ("" on WebKit; "on" elsewhere)
|
|
support.checkOn = !!input.value;
|
|
|
|
// Make sure that a selected-by-default option has a working selected property.
|
|
// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
|
|
support.optSelected = opt.selected;
|
|
|
|
// Tests for enctype support on a form (#6743)
|
|
support.enctype = !!document.createElement( "form" ).enctype;
|
|
|
|
// Make sure that the options inside disabled selects aren't marked as disabled
|
|
// (WebKit marks them as disabled)
|
|
select.disabled = true;
|
|
support.optDisabled = !opt.disabled;
|
|
|
|
// Support: IE8 only
|
|
// Check if we can trust getAttribute("value")
|
|
input = document.createElement( "input" );
|
|
input.setAttribute( "value", "" );
|
|
support.input = input.getAttribute( "value" ) === "";
|
|
|
|
// Check if an input maintains its value after becoming a radio
|
|
input.value = "t";
|
|
input.setAttribute( "type", "radio" );
|
|
support.radioValue = input.value === "t";
|
|
} )();
|
|
|
|
|
|
var rreturn = /\r/g,
|
|
rspaces = /[\x20\t\r\n\f]+/g;
|
|
|
|
jQuery.fn.extend( {
|
|
val: function( value ) {
|
|
var hooks, ret, isFunction,
|
|
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;
|
|
|
|
return typeof ret === "string" ?
|
|
|
|
// handle most common string cases
|
|
ret.replace( rreturn, "" ) :
|
|
|
|
// handle cases where value is null/undef or number
|
|
ret == null ? "" : ret;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
isFunction = jQuery.isFunction( value );
|
|
|
|
return this.each( function( i ) {
|
|
var val;
|
|
|
|
if ( this.nodeType !== 1 ) {
|
|
return;
|
|
}
|
|
|
|
if ( isFunction ) {
|
|
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 ( jQuery.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: IE10-11+
|
|
// option.text throws exceptions (#14686, #14858)
|
|
// Strip and collapse whitespace
|
|
// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
|
|
jQuery.trim( jQuery.text( elem ) ).replace( rspaces, " " );
|
|
}
|
|
},
|
|
select: {
|
|
get: function( elem ) {
|
|
var value, option,
|
|
options = elem.options,
|
|
index = elem.selectedIndex,
|
|
one = elem.type === "select-one" || index < 0,
|
|
values = one ? null : [],
|
|
max = one ? index + 1 : options.length,
|
|
i = index < 0 ?
|
|
max :
|
|
one ? index : 0;
|
|
|
|
// Loop through all the selected options
|
|
for ( ; i < max; i++ ) {
|
|
option = options[ i ];
|
|
|
|
// oldIE 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
|
|
( support.optDisabled ?
|
|
!option.disabled :
|
|
option.getAttribute( "disabled" ) === null ) &&
|
|
( !option.parentNode.disabled ||
|
|
!jQuery.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 ];
|
|
|
|
if ( jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 ) {
|
|
|
|
// Support: IE6
|
|
// When new option element is added to select box we need to
|
|
// force reflow of newly added node in order to workaround delay
|
|
// of initialization properties
|
|
try {
|
|
option.selected = optionSet = true;
|
|
|
|
} catch ( _ ) {
|
|
|
|
// Will be executed only in IE6
|
|
option.scrollHeight;
|
|
}
|
|
|
|
} else {
|
|
option.selected = false;
|
|
}
|
|
}
|
|
|
|
// Force browsers to behave consistently when non-matching value is set
|
|
if ( !optionSet ) {
|
|
elem.selectedIndex = -1;
|
|
}
|
|
|
|
return options;
|
|
}
|
|
}
|
|
}
|
|
} );
|
|
|
|
// Radios and checkboxes getter/setter
|
|
jQuery.each( [ "radio", "checkbox" ], function() {
|
|
jQuery.valHooks[ this ] = {
|
|
set: function( elem, value ) {
|
|
if ( jQuery.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;
|
|
};
|
|
}
|
|
} );
|
|
|
|
|
|
|
|
|
|
var nodeHook, boolHook,
|
|
attrHandle = jQuery.expr.attrHandle,
|
|
ruseDefault = /^(?:checked|selected)$/i,
|
|
getSetAttribute = support.getSetAttribute,
|
|
getSetInput = support.input;
|
|
|
|
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 );
|
|
}
|
|
|
|
// All attributes are lowercase
|
|
// Grab necessary hook if one is defined
|
|
if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
|
|
name = name.toLowerCase();
|
|
hooks = jQuery.attrHooks[ name ] ||
|
|
( jQuery.expr.match.bool.test( name ) ? boolHook : nodeHook );
|
|
}
|
|
|
|
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" &&
|
|
jQuery.nodeName( elem, "input" ) ) {
|
|
|
|
// Setting the type on a radio button after the value resets the value in IE8-9
|
|
// Reset value to default in case type is set after value during creation
|
|
var val = elem.value;
|
|
elem.setAttribute( "type", value );
|
|
if ( val ) {
|
|
elem.value = val;
|
|
}
|
|
return value;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
removeAttr: function( elem, value ) {
|
|
var name, propName,
|
|
i = 0,
|
|
attrNames = value && value.match( rnotwhite );
|
|
|
|
if ( attrNames && elem.nodeType === 1 ) {
|
|
while ( ( name = attrNames[ i++ ] ) ) {
|
|
propName = jQuery.propFix[ name ] || name;
|
|
|
|
// Boolean attributes get special treatment (#10870)
|
|
if ( jQuery.expr.match.bool.test( name ) ) {
|
|
|
|
// Set corresponding property to false
|
|
if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
|
|
elem[ propName ] = false;
|
|
|
|
// Support: IE<9
|
|
// Also clear defaultChecked/defaultSelected (if appropriate)
|
|
} else {
|
|
elem[ jQuery.camelCase( "default-" + name ) ] =
|
|
elem[ propName ] = false;
|
|
}
|
|
|
|
// See #9699 for explanation of this approach (setting first, then removal)
|
|
} else {
|
|
jQuery.attr( elem, name, "" );
|
|
}
|
|
|
|
elem.removeAttribute( getSetAttribute ? name : propName );
|
|
}
|
|
}
|
|
}
|
|
} );
|
|
|
|
// 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 if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
|
|
|
|
// IE<8 needs the *property* name
|
|
elem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name );
|
|
|
|
} else {
|
|
|
|
// Support: IE<9
|
|
// Use defaultChecked and defaultSelected for oldIE
|
|
elem[ jQuery.camelCase( "default-" + name ) ] = elem[ name ] = true;
|
|
}
|
|
return name;
|
|
}
|
|
};
|
|
|
|
jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
|
|
var getter = attrHandle[ name ] || jQuery.find.attr;
|
|
|
|
if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
|
|
attrHandle[ name ] = function( elem, name, isXML ) {
|
|
var ret, handle;
|
|
if ( !isXML ) {
|
|
|
|
// Avoid an infinite loop by temporarily removing this function from the getter
|
|
handle = attrHandle[ name ];
|
|
attrHandle[ name ] = ret;
|
|
ret = getter( elem, name, isXML ) != null ?
|
|
name.toLowerCase() :
|
|
null;
|
|
attrHandle[ name ] = handle;
|
|
}
|
|
return ret;
|
|
};
|
|
} else {
|
|
attrHandle[ name ] = function( elem, name, isXML ) {
|
|
if ( !isXML ) {
|
|
return elem[ jQuery.camelCase( "default-" + name ) ] ?
|
|
name.toLowerCase() :
|
|
null;
|
|
}
|
|
};
|
|
}
|
|
} );
|
|
|
|
// fix oldIE attroperties
|
|
if ( !getSetInput || !getSetAttribute ) {
|
|
jQuery.attrHooks.value = {
|
|
set: function( elem, value, name ) {
|
|
if ( jQuery.nodeName( elem, "input" ) ) {
|
|
|
|
// Does not return so that setAttribute is also used
|
|
elem.defaultValue = value;
|
|
} else {
|
|
|
|
// Use nodeHook if defined (#1954); otherwise setAttribute is fine
|
|
return nodeHook && nodeHook.set( elem, value, name );
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// IE6/7 do not support getting/setting some attributes with get/setAttribute
|
|
if ( !getSetAttribute ) {
|
|
|
|
// Use this for any attribute in IE6/7
|
|
// This fixes almost every IE6/7 issue
|
|
nodeHook = {
|
|
set: function( elem, value, name ) {
|
|
|
|
// Set the existing or create a new attribute node
|
|
var ret = elem.getAttributeNode( name );
|
|
if ( !ret ) {
|
|
elem.setAttributeNode(
|
|
( ret = elem.ownerDocument.createAttribute( name ) )
|
|
);
|
|
}
|
|
|
|
ret.value = value += "";
|
|
|
|
// Break association with cloned elements by also using setAttribute (#9646)
|
|
if ( name === "value" || value === elem.getAttribute( name ) ) {
|
|
return value;
|
|
}
|
|
}
|
|
};
|
|
|
|
// Some attributes are constructed with empty-string values when not defined
|
|
attrHandle.id = attrHandle.name = attrHandle.coords =
|
|
function( elem, name, isXML ) {
|
|
var ret;
|
|
if ( !isXML ) {
|
|
return ( ret = elem.getAttributeNode( name ) ) && ret.value !== "" ?
|
|
ret.value :
|
|
null;
|
|
}
|
|
};
|
|
|
|
// Fixing value retrieval on a button requires this module
|
|
jQuery.valHooks.button = {
|
|
get: function( elem, name ) {
|
|
var ret = elem.getAttributeNode( name );
|
|
if ( ret && ret.specified ) {
|
|
return ret.value;
|
|
}
|
|
},
|
|
set: nodeHook.set
|
|
};
|
|
|
|
// Set contenteditable to false on removals(#10429)
|
|
// Setting to empty string throws an error as an invalid value
|
|
jQuery.attrHooks.contenteditable = {
|
|
set: function( elem, value, name ) {
|
|
nodeHook.set( elem, value === "" ? false : value, name );
|
|
}
|
|
};
|
|
|
|
// Set width and height to auto instead of 0 on empty string( Bug #8150 )
|
|
// This is for removals
|
|
jQuery.each( [ "width", "height" ], function( i, name ) {
|
|
jQuery.attrHooks[ name ] = {
|
|
set: function( elem, value ) {
|
|
if ( value === "" ) {
|
|
elem.setAttribute( name, "auto" );
|
|
return value;
|
|
}
|
|
}
|
|
};
|
|
} );
|
|
}
|
|
|
|
if ( !support.style ) {
|
|
jQuery.attrHooks.style = {
|
|
get: function( elem ) {
|
|
|
|
// Return undefined in the case of empty string
|
|
// Note: IE uppercases css property names, but if we were to .toLowerCase()
|
|
// .cssText, that would destroy case sensitivity in URL's, like in "background"
|
|
return elem.style.cssText || undefined;
|
|
},
|
|
set: function( elem, value ) {
|
|
return ( elem.style.cssText = value + "" );
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
|
|
|
|
var rfocusable = /^(?:input|select|textarea|button|object)$/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 ) {
|
|
name = jQuery.propFix[ name ] || name;
|
|
return this.each( function() {
|
|
|
|
// try/catch handles cases where IE balks (such as removing a property on window)
|
|
try {
|
|
this[ name ] = undefined;
|
|
delete this[ name ];
|
|
} catch ( e ) {}
|
|
} );
|
|
}
|
|
} );
|
|
|
|
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 ) {
|
|
|
|
// elem.tabIndex doesn't always return the
|
|
// correct value when it hasn't been explicitly set
|
|
// 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" );
|
|
|
|
return tabindex ?
|
|
parseInt( tabindex, 10 ) :
|
|
rfocusable.test( elem.nodeName ) ||
|
|
rclickable.test( elem.nodeName ) && elem.href ?
|
|
0 :
|
|
-1;
|
|
}
|
|
}
|
|
},
|
|
|
|
propFix: {
|
|
"for": "htmlFor",
|
|
"class": "className"
|
|
}
|
|
} );
|
|
|
|
// Some attributes require a special call on IE
|
|
// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
|
|
if ( !support.hrefNormalized ) {
|
|
|
|
// href/src property should get the full normalized URL (#10299/#12915)
|
|
jQuery.each( [ "href", "src" ], function( i, name ) {
|
|
jQuery.propHooks[ name ] = {
|
|
get: function( elem ) {
|
|
return elem.getAttribute( name, 4 );
|
|
}
|
|
};
|
|
} );
|
|
}
|
|
|
|
// Support: Safari, IE9+
|
|
// 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
|
|
if ( !support.optSelected ) {
|
|
jQuery.propHooks.selected = {
|
|
get: function( elem ) {
|
|
var parent = elem.parentNode;
|
|
|
|
if ( parent ) {
|
|
parent.selectedIndex;
|
|
|
|
// Make sure that it also works with optgroups, see #5701
|
|
if ( parent.parentNode ) {
|
|
parent.parentNode.selectedIndex;
|
|
}
|
|
}
|
|
return null;
|
|
},
|
|
set: function( elem ) {
|
|
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;
|
|
} );
|
|
|
|
// IE6/7 call enctype encoding
|
|
if ( !support.enctype ) {
|
|
jQuery.propFix.enctype = "encoding";
|
|
}
|
|
|
|
|
|
|
|
|
|
var rclass = /[\t\r\n\f]/g;
|
|
|
|
function getClass( elem ) {
|
|
return jQuery.attr( elem, "class" ) || "";
|
|
}
|
|
|
|
jQuery.fn.extend( {
|
|
addClass: function( value ) {
|
|
var classes, elem, cur, curValue, clazz, j, finalValue,
|
|
i = 0;
|
|
|
|
if ( jQuery.isFunction( value ) ) {
|
|
return this.each( function( j ) {
|
|
jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
|
|
} );
|
|
}
|
|
|
|
if ( typeof value === "string" && value ) {
|
|
classes = value.match( rnotwhite ) || [];
|
|
|
|
while ( ( elem = this[ i++ ] ) ) {
|
|
curValue = getClass( elem );
|
|
cur = elem.nodeType === 1 &&
|
|
( " " + curValue + " " ).replace( rclass, " " );
|
|
|
|
if ( cur ) {
|
|
j = 0;
|
|
while ( ( clazz = classes[ j++ ] ) ) {
|
|
if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
|
|
cur += clazz + " ";
|
|
}
|
|
}
|
|
|
|
// only assign if different to avoid unneeded rendering.
|
|
finalValue = jQuery.trim( cur );
|
|
if ( curValue !== finalValue ) {
|
|
jQuery.attr( elem, "class", finalValue );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
removeClass: function( value ) {
|
|
var classes, elem, cur, curValue, clazz, j, finalValue,
|
|
i = 0;
|
|
|
|
if ( jQuery.isFunction( value ) ) {
|
|
return this.each( function( j ) {
|
|
jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
|
|
} );
|
|
}
|
|
|
|
if ( !arguments.length ) {
|
|
return this.attr( "class", "" );
|
|
}
|
|
|
|
if ( typeof value === "string" && value ) {
|
|
classes = value.match( rnotwhite ) || [];
|
|
|
|
while ( ( elem = this[ i++ ] ) ) {
|
|
curValue = getClass( elem );
|
|
|
|
// This expression is here for better compressibility (see addClass)
|
|
cur = elem.nodeType === 1 &&
|
|
( " " + curValue + " " ).replace( rclass, " " );
|
|
|
|
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 = jQuery.trim( cur );
|
|
if ( curValue !== finalValue ) {
|
|
jQuery.attr( elem, "class", finalValue );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
toggleClass: function( value, stateVal ) {
|
|
var type = typeof value;
|
|
|
|
if ( typeof stateVal === "boolean" && type === "string" ) {
|
|
return stateVal ? this.addClass( value ) : this.removeClass( value );
|
|
}
|
|
|
|
if ( jQuery.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 ( type === "string" ) {
|
|
|
|
// Toggle individual class names
|
|
i = 0;
|
|
self = jQuery( this );
|
|
classNames = value.match( rnotwhite ) || [];
|
|
|
|
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
|
|
jQuery._data( this, "__className__", className );
|
|
}
|
|
|
|
// If the element has a class name or if we're passed "false",
|
|
// then remove the whole classname (if there was one, the above saved it).
|
|
// Otherwise bring back whatever was previously saved (if anything),
|
|
// falling back to the empty string if nothing was stored.
|
|
jQuery.attr( this, "class",
|
|
className || value === false ?
|
|
"" :
|
|
jQuery._data( this, "__className__" ) || ""
|
|
);
|
|
}
|
|
} );
|
|
},
|
|
|
|
hasClass: function( selector ) {
|
|
var className, elem,
|
|
i = 0;
|
|
|
|
className = " " + selector + " ";
|
|
while ( ( elem = this[ i++ ] ) ) {
|
|
if ( elem.nodeType === 1 &&
|
|
( " " + getClass( elem ) + " " ).replace( rclass, " " )
|
|
.indexOf( className ) > -1
|
|
) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
} );
|
|
|
|
|
|
|
|
|
|
// Return jQuery for attributes-only inclusion
|
|
|
|
|
|
jQuery.each( ( "blur focus focusin focusout load resize scroll unload click dblclick " +
|
|
"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
|
|
"change select submit keydown keypress keyup error 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 );
|
|
};
|
|
} );
|
|
|
|
jQuery.fn.extend( {
|
|
hover: function( fnOver, fnOut ) {
|
|
return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
|
|
}
|
|
} );
|
|
|
|
|
|
var location = window.location;
|
|
|
|
var nonce = jQuery.now();
|
|
|
|
var rquery = ( /\?/ );
|
|
|
|
|
|
|
|
var rvalidtokens = /(,)|(\[|{)|(}|])|"(?:[^"\\\r\n]|\\["\\\/bfnrt]|\\u[\da-fA-F]{4})*"\s*:?|true|false|null|-?(?!0\d)\d+(?:\.\d+|)(?:[eE][+-]?\d+|)/g;
|
|
|
|
jQuery.parseJSON = function( data ) {
|
|
|
|
// Attempt to parse using the native JSON parser first
|
|
if ( window.JSON && window.JSON.parse ) {
|
|
|
|
// Support: Android 2.3
|
|
// Workaround failure to string-cast null input
|
|
return window.JSON.parse( data + "" );
|
|
}
|
|
|
|
var requireNonComma,
|
|
depth = null,
|
|
str = jQuery.trim( data + "" );
|
|
|
|
// Guard against invalid (and possibly dangerous) input by ensuring that nothing remains
|
|
// after removing valid tokens
|
|
return str && !jQuery.trim( str.replace( rvalidtokens, function( token, comma, open, close ) {
|
|
|
|
// Force termination if we see a misplaced comma
|
|
if ( requireNonComma && comma ) {
|
|
depth = 0;
|
|
}
|
|
|
|
// Perform no more replacements after returning to outermost depth
|
|
if ( depth === 0 ) {
|
|
return token;
|
|
}
|
|
|
|
// Commas must not follow "[", "{", or ","
|
|
requireNonComma = open || comma;
|
|
|
|
// Determine new depth
|
|
// array/object open ("[" or "{"): depth += true - false (increment)
|
|
// array/object close ("]" or "}"): depth += false - true (decrement)
|
|
// other cases ("," or primitive): depth += true - true (numeric cast)
|
|
depth += !close - !open;
|
|
|
|
// Remove this token
|
|
return "";
|
|
} ) ) ?
|
|
( Function( "return " + str ) )() :
|
|
jQuery.error( "Invalid JSON: " + data );
|
|
};
|
|
|
|
|
|
// Cross-browser xml parsing
|
|
jQuery.parseXML = function( data ) {
|
|
var xml, tmp;
|
|
if ( !data || typeof data !== "string" ) {
|
|
return null;
|
|
}
|
|
try {
|
|
if ( window.DOMParser ) { // Standard
|
|
tmp = new window.DOMParser();
|
|
xml = tmp.parseFromString( data, "text/xml" );
|
|
} else { // IE
|
|
xml = new window.ActiveXObject( "Microsoft.XMLDOM" );
|
|
xml.async = "false";
|
|
xml.loadXML( data );
|
|
}
|
|
} catch ( e ) {
|
|
xml = undefined;
|
|
}
|
|
if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
|
|
jQuery.error( "Invalid XML: " + data );
|
|
}
|
|
return xml;
|
|
};
|
|
|
|
|
|
var
|
|
rhash = /#.*$/,
|
|
rts = /([?&])_=[^&]*/,
|
|
|
|
// IE leaves an \r character at EOL
|
|
rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg,
|
|
|
|
// #7653, #8125, #8152: local protocol detection
|
|
rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
|
|
rnoContent = /^(?:GET|HEAD)$/,
|
|
rprotocol = /^\/\//,
|
|
rurl = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/,
|
|
|
|
/* 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( "*" ),
|
|
|
|
// Document location
|
|
ajaxLocation = location.href,
|
|
|
|
// Segment location into parts
|
|
ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
|
|
|
|
// 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( rnotwhite ) || [];
|
|
|
|
if ( jQuery.isFunction( func ) ) {
|
|
|
|
// For each dataType in the dataTypeExpression
|
|
while ( ( dataType = dataTypes[ i++ ] ) ) {
|
|
|
|
// Prepend if requested
|
|
if ( dataType.charAt( 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 deep, key,
|
|
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 firstDataType, ct, finalDataType, type,
|
|
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" ] ) { // jscs:ignore requireDotNotation
|
|
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: ajaxLocation,
|
|
type: "GET",
|
|
isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
|
|
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": jQuery.parseJSON,
|
|
|
|
// 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
|
|
|
|
// Cross-domain detection vars
|
|
parts,
|
|
|
|
// Loop variable
|
|
i,
|
|
|
|
// URL without anti-cache param
|
|
cacheURL,
|
|
|
|
// Response headers as string
|
|
responseHeadersString,
|
|
|
|
// timeout handle
|
|
timeoutTimer,
|
|
|
|
// To know if global events are to be dispatched
|
|
fireGlobals,
|
|
|
|
transport,
|
|
|
|
// Response headers
|
|
responseHeaders,
|
|
|
|
// 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 = {},
|
|
|
|
// The jqXHR state
|
|
state = 0,
|
|
|
|
// Default abort message
|
|
strAbort = "canceled",
|
|
|
|
// Fake xhr
|
|
jqXHR = {
|
|
readyState: 0,
|
|
|
|
// Builds headers hashtable if needed
|
|
getResponseHeader: function( key ) {
|
|
var match;
|
|
if ( state === 2 ) {
|
|
if ( !responseHeaders ) {
|
|
responseHeaders = {};
|
|
while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
|
|
responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
|
|
}
|
|
}
|
|
match = responseHeaders[ key.toLowerCase() ];
|
|
}
|
|
return match == null ? null : match;
|
|
},
|
|
|
|
// Raw string
|
|
getAllResponseHeaders: function() {
|
|
return state === 2 ? responseHeadersString : null;
|
|
},
|
|
|
|
// Caches the header
|
|
setRequestHeader: function( name, value ) {
|
|
var lname = name.toLowerCase();
|
|
if ( !state ) {
|
|
name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
|
|
requestHeaders[ name ] = value;
|
|
}
|
|
return this;
|
|
},
|
|
|
|
// Overrides response content-type header
|
|
overrideMimeType: function( type ) {
|
|
if ( !state ) {
|
|
s.mimeType = type;
|
|
}
|
|
return this;
|
|
},
|
|
|
|
// Status-dependent callbacks
|
|
statusCode: function( map ) {
|
|
var code;
|
|
if ( map ) {
|
|
if ( state < 2 ) {
|
|
for ( code in map ) {
|
|
|
|
// Lazy-add the new callback in a way that preserves old ones
|
|
statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
|
|
}
|
|
} else {
|
|
|
|
// Execute the appropriate callbacks
|
|
jqXHR.always( map[ jqXHR.status ] );
|
|
}
|
|
}
|
|
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 ).complete = completeDeferred.add;
|
|
jqXHR.success = jqXHR.done;
|
|
jqXHR.error = jqXHR.fail;
|
|
|
|
// Remove hash character (#7531: and string promotion)
|
|
// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
|
|
// 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 || ajaxLocation ) + "" )
|
|
.replace( rhash, "" )
|
|
.replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
|
|
|
|
// Alias method option to type as per ticket #12004
|
|
s.type = options.method || options.type || s.method || s.type;
|
|
|
|
// Extract dataTypes list
|
|
s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().match( rnotwhite ) || [ "" ];
|
|
|
|
// A cross-domain request is in order when we have a protocol:host:port mismatch
|
|
if ( s.crossDomain == null ) {
|
|
parts = rurl.exec( s.url.toLowerCase() );
|
|
s.crossDomain = !!( parts &&
|
|
( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] ||
|
|
( parts[ 3 ] || ( parts[ 1 ] === "http:" ? "80" : "443" ) ) !==
|
|
( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? "80" : "443" ) ) )
|
|
);
|
|
}
|
|
|
|
// 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 ( state === 2 ) {
|
|
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
|
|
cacheURL = s.url;
|
|
|
|
// More options handling for requests with no content
|
|
if ( !s.hasContent ) {
|
|
|
|
// If data is available, append data to url
|
|
if ( s.data ) {
|
|
cacheURL = ( s.url += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data );
|
|
|
|
// #9682: remove data so that it's not used in an eventual retry
|
|
delete s.data;
|
|
}
|
|
|
|
// Add anti-cache in url if needed
|
|
if ( s.cache === false ) {
|
|
s.url = rts.test( cacheURL ) ?
|
|
|
|
// If there is already a '_' parameter, set its value
|
|
cacheURL.replace( rts, "$1_=" + nonce++ ) :
|
|
|
|
// Otherwise add one to the end
|
|
cacheURL + ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + nonce++;
|
|
}
|
|
}
|
|
|
|
// 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 || state === 2 ) ) {
|
|
|
|
// Abort if not done already and return
|
|
return jqXHR.abort();
|
|
}
|
|
|
|
// aborting is no longer a cancellation
|
|
strAbort = "abort";
|
|
|
|
// Install callbacks on deferreds
|
|
for ( i in { success: 1, error: 1, complete: 1 } ) {
|
|
jqXHR[ i ]( s[ i ] );
|
|
}
|
|
|
|
// 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 ( state === 2 ) {
|
|
return jqXHR;
|
|
}
|
|
|
|
// Timeout
|
|
if ( s.async && s.timeout > 0 ) {
|
|
timeoutTimer = window.setTimeout( function() {
|
|
jqXHR.abort( "timeout" );
|
|
}, s.timeout );
|
|
}
|
|
|
|
try {
|
|
state = 1;
|
|
transport.send( requestHeaders, done );
|
|
} catch ( e ) {
|
|
|
|
// Propagate exception as error if not done
|
|
if ( state < 2 ) {
|
|
done( -1, e );
|
|
|
|
// Simply rethrow otherwise
|
|
} else {
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Callback for when everything is done
|
|
function done( status, nativeStatusText, responses, headers ) {
|
|
var isSuccess, success, error, response, modified,
|
|
statusText = nativeStatusText;
|
|
|
|
// Called once
|
|
if ( state === 2 ) {
|
|
return;
|
|
}
|
|
|
|
// State is "done" now
|
|
state = 2;
|
|
|
|
// 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 );
|
|
}
|
|
|
|
// 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 {
|
|
|
|
// We extract error from statusText
|
|
// then normalize statusText and status 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 ( jQuery.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._evalUrl = function( url ) {
|
|
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,
|
|
"throws": true
|
|
} );
|
|
};
|
|
|
|
|
|
jQuery.fn.extend( {
|
|
wrapAll: function( html ) {
|
|
if ( jQuery.isFunction( html ) ) {
|
|
return this.each( function( i ) {
|
|
jQuery( this ).wrapAll( html.call( this, i ) );
|
|
} );
|
|
}
|
|
|
|
if ( this[ 0 ] ) {
|
|
|
|
// The elements to wrap the target around
|
|
var 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.firstChild && elem.firstChild.nodeType === 1 ) {
|
|
elem = elem.firstChild;
|
|
}
|
|
|
|
return elem;
|
|
} ).append( this );
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
wrapInner: function( html ) {
|
|
if ( jQuery.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 isFunction = jQuery.isFunction( html );
|
|
|
|
return this.each( function( i ) {
|
|
jQuery( this ).wrapAll( isFunction ? html.call( this, i ) : html );
|
|
} );
|
|
},
|
|
|
|
unwrap: function() {
|
|
return this.parent().each( function() {
|
|
if ( !jQuery.nodeName( this, "body" ) ) {
|
|
jQuery( this ).replaceWith( this.childNodes );
|
|
}
|
|
} ).end();
|
|
}
|
|
} );
|
|
|
|
|
|
function getDisplay( elem ) {
|
|
return elem.style && elem.style.display || jQuery.css( elem, "display" );
|
|
}
|
|
|
|
function filterHidden( elem ) {
|
|
|
|
// Disconnected elements are considered hidden
|
|
if ( !jQuery.contains( elem.ownerDocument || document, elem ) ) {
|
|
return true;
|
|
}
|
|
while ( elem && elem.nodeType === 1 ) {
|
|
if ( getDisplay( elem ) === "none" || elem.type === "hidden" ) {
|
|
return true;
|
|
}
|
|
elem = elem.parentNode;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
jQuery.expr.filters.hidden = function( elem ) {
|
|
|
|
// Support: Opera <= 12.12
|
|
// Opera reports offsetWidths and offsetHeights less than zero on some elements
|
|
return support.reliableHiddenOffsets() ?
|
|
( elem.offsetWidth <= 0 && elem.offsetHeight <= 0 &&
|
|
!elem.getClientRects().length ) :
|
|
filterHidden( elem );
|
|
};
|
|
|
|
jQuery.expr.filters.visible = function( elem ) {
|
|
return !jQuery.expr.filters.hidden( elem );
|
|
};
|
|
|
|
|
|
|
|
|
|
var r20 = /%20/g,
|
|
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 ( jQuery.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 && jQuery.type( 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, value ) {
|
|
|
|
// If value is a function, invoke it and return its value
|
|
value = jQuery.isFunction( value ) ? value() : ( value == null ? "" : value );
|
|
s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
|
|
};
|
|
|
|
// Set traditional to true for jQuery <= 1.3.2 behavior.
|
|
if ( traditional === undefined ) {
|
|
traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
|
|
}
|
|
|
|
// If an array was passed in, assume that it is an array of form elements.
|
|
if ( jQuery.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( "&" ).replace( r20, "+" );
|
|
};
|
|
|
|
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();
|
|
|
|
return val == null ?
|
|
null :
|
|
jQuery.isArray( val ) ?
|
|
jQuery.map( val, function( val ) {
|
|
return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
|
|
} ) :
|
|
{ name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
|
|
} ).get();
|
|
}
|
|
} );
|
|
|
|
|
|
// Create the request object
|
|
// (This is still attached to ajaxSettings for backward compatibility)
|
|
jQuery.ajaxSettings.xhr = window.ActiveXObject !== undefined ?
|
|
|
|
// Support: IE6-IE8
|
|
function() {
|
|
|
|
// XHR cannot access local files, always use ActiveX for that case
|
|
if ( this.isLocal ) {
|
|
return createActiveXHR();
|
|
}
|
|
|
|
// Support: IE 9-11
|
|
// IE seems to error on cross-domain PATCH requests when ActiveX XHR
|
|
// is used. In IE 9+ always use the native XHR.
|
|
// Note: this condition won't catch Edge as it doesn't define
|
|
// document.documentMode but it also doesn't support ActiveX so it won't
|
|
// reach this code.
|
|
if ( document.documentMode > 8 ) {
|
|
return createStandardXHR();
|
|
}
|
|
|
|
// Support: IE<9
|
|
// oldIE XHR does not support non-RFC2616 methods (#13240)
|
|
// See http://msdn.microsoft.com/en-us/library/ie/ms536648(v=vs.85).aspx
|
|
// and http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9
|
|
// Although this check for six methods instead of eight
|
|
// since IE also does not support "trace" and "connect"
|
|
return /^(get|post|head|put|delete|options)$/i.test( this.type ) &&
|
|
createStandardXHR() || createActiveXHR();
|
|
} :
|
|
|
|
// For all other browsers, use the standard XMLHttpRequest object
|
|
createStandardXHR;
|
|
|
|
var xhrId = 0,
|
|
xhrCallbacks = {},
|
|
xhrSupported = jQuery.ajaxSettings.xhr();
|
|
|
|
// Support: IE<10
|
|
// Open requests must be manually aborted on unload (#5280)
|
|
// See https://support.microsoft.com/kb/2856746 for more info
|
|
if ( window.attachEvent ) {
|
|
window.attachEvent( "onunload", function() {
|
|
for ( var key in xhrCallbacks ) {
|
|
xhrCallbacks[ key ]( undefined, true );
|
|
}
|
|
} );
|
|
}
|
|
|
|
// Determine support properties
|
|
support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
|
|
xhrSupported = support.ajax = !!xhrSupported;
|
|
|
|
// Create transport if the browser can provide an xhr
|
|
if ( xhrSupported ) {
|
|
|
|
jQuery.ajaxTransport( function( options ) {
|
|
|
|
// Cross domain only allowed if supported through XMLHttpRequest
|
|
if ( !options.crossDomain || support.cors ) {
|
|
|
|
var callback;
|
|
|
|
return {
|
|
send: function( headers, complete ) {
|
|
var i,
|
|
xhr = options.xhr(),
|
|
id = ++xhrId;
|
|
|
|
// Open the socket
|
|
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 ) {
|
|
|
|
// Support: IE<9
|
|
// IE's ActiveXObject throws a 'Type Mismatch' exception when setting
|
|
// request header to a null-value.
|
|
//
|
|
// To keep consistent with other XHR implementations, cast the value
|
|
// to string and ignore `undefined`.
|
|
if ( headers[ i ] !== undefined ) {
|
|
xhr.setRequestHeader( i, headers[ i ] + "" );
|
|
}
|
|
}
|
|
|
|
// Do send the request
|
|
// This may raise an exception which is actually
|
|
// handled in jQuery.ajax (so no try/catch here)
|
|
xhr.send( ( options.hasContent && options.data ) || null );
|
|
|
|
// Listener
|
|
callback = function( _, isAbort ) {
|
|
var status, statusText, responses;
|
|
|
|
// Was never called and is aborted or complete
|
|
if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
|
|
|
|
// Clean up
|
|
delete xhrCallbacks[ id ];
|
|
callback = undefined;
|
|
xhr.onreadystatechange = jQuery.noop;
|
|
|
|
// Abort manually if needed
|
|
if ( isAbort ) {
|
|
if ( xhr.readyState !== 4 ) {
|
|
xhr.abort();
|
|
}
|
|
} else {
|
|
responses = {};
|
|
status = xhr.status;
|
|
|
|
// Support: IE<10
|
|
// Accessing binary-data responseText throws an exception
|
|
// (#11426)
|
|
if ( typeof xhr.responseText === "string" ) {
|
|
responses.text = xhr.responseText;
|
|
}
|
|
|
|
// Firefox throws an exception when accessing
|
|
// statusText for faulty cross-domain requests
|
|
try {
|
|
statusText = xhr.statusText;
|
|
} catch ( e ) {
|
|
|
|
// We normalize with Webkit giving an empty statusText
|
|
statusText = "";
|
|
}
|
|
|
|
// Filter status for non standard behaviors
|
|
|
|
// If the request is local and we have data: assume a success
|
|
// (success with no data won't get notified, that's the best we
|
|
// can do given current implementations)
|
|
if ( !status && options.isLocal && !options.crossDomain ) {
|
|
status = responses.text ? 200 : 404;
|
|
|
|
// IE - #1450: sometimes returns 1223 when it should be 204
|
|
} else if ( status === 1223 ) {
|
|
status = 204;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Call complete if needed
|
|
if ( responses ) {
|
|
complete( status, statusText, responses, xhr.getAllResponseHeaders() );
|
|
}
|
|
};
|
|
|
|
// Do send the request
|
|
// `xhr.send` may raise an exception, but it will be
|
|
// handled in jQuery.ajax (so no try/catch here)
|
|
if ( !options.async ) {
|
|
|
|
// If we're in sync mode we fire the callback
|
|
callback();
|
|
} else if ( xhr.readyState === 4 ) {
|
|
|
|
// (IE6 & IE7) if it's in cache and has been
|
|
// retrieved directly we need to fire the callback
|
|
window.setTimeout( callback );
|
|
} else {
|
|
|
|
// Register the callback, but delay it in case `xhr.send` throws
|
|
// Add to the list of active xhr callbacks
|
|
xhr.onreadystatechange = xhrCallbacks[ id ] = callback;
|
|
}
|
|
},
|
|
|
|
abort: function() {
|
|
if ( callback ) {
|
|
callback( undefined, true );
|
|
}
|
|
}
|
|
};
|
|
}
|
|
} );
|
|
}
|
|
|
|
// Functions to create xhrs
|
|
function createStandardXHR() {
|
|
try {
|
|
return new window.XMLHttpRequest();
|
|
} catch ( e ) {}
|
|
}
|
|
|
|
function createActiveXHR() {
|
|
try {
|
|
return new window.ActiveXObject( "Microsoft.XMLHTTP" );
|
|
} catch ( e ) {}
|
|
}
|
|
|
|
|
|
|
|
|
|
// 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 global
|
|
jQuery.ajaxPrefilter( "script", function( s ) {
|
|
if ( s.cache === undefined ) {
|
|
s.cache = false;
|
|
}
|
|
if ( s.crossDomain ) {
|
|
s.type = "GET";
|
|
s.global = false;
|
|
}
|
|
} );
|
|
|
|
// Bind script tag hack transport
|
|
jQuery.ajaxTransport( "script", function( s ) {
|
|
|
|
// This transport only deals with cross domain requests
|
|
if ( s.crossDomain ) {
|
|
|
|
var script,
|
|
head = document.head || jQuery( "head" )[ 0 ] || document.documentElement;
|
|
|
|
return {
|
|
|
|
send: function( _, callback ) {
|
|
|
|
script = document.createElement( "script" );
|
|
|
|
script.async = true;
|
|
|
|
if ( s.scriptCharset ) {
|
|
script.charset = s.scriptCharset;
|
|
}
|
|
|
|
script.src = s.url;
|
|
|
|
// Attach handlers for all browsers
|
|
script.onload = script.onreadystatechange = function( _, isAbort ) {
|
|
|
|
if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
|
|
|
|
// Handle memory leak in IE
|
|
script.onload = script.onreadystatechange = null;
|
|
|
|
// Remove the script
|
|
if ( script.parentNode ) {
|
|
script.parentNode.removeChild( script );
|
|
}
|
|
|
|
// Dereference the script
|
|
script = null;
|
|
|
|
// Callback if not abort
|
|
if ( !isAbort ) {
|
|
callback( 200, "success" );
|
|
}
|
|
}
|
|
};
|
|
|
|
// Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending
|
|
// Use native DOM manipulation to avoid our domManip AJAX trickery
|
|
head.insertBefore( script, head.firstChild );
|
|
},
|
|
|
|
abort: function() {
|
|
if ( script ) {
|
|
script.onload( undefined, true );
|
|
}
|
|
}
|
|
};
|
|
}
|
|
} );
|
|
|
|
|
|
|
|
|
|
var oldCallbacks = [],
|
|
rjsonp = /(=)\?(?=&|$)|\?\?/;
|
|
|
|
// Default jsonp settings
|
|
jQuery.ajaxSetup( {
|
|
jsonp: "callback",
|
|
jsonpCallback: function() {
|
|
var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
|
|
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 = jQuery.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 && jQuery.isFunction( overwritten ) ) {
|
|
overwritten( responseContainer[ 0 ] );
|
|
}
|
|
|
|
responseContainer = overwritten = undefined;
|
|
} );
|
|
|
|
// Delegate to script
|
|
return "script";
|
|
}
|
|
} );
|
|
|
|
|
|
|
|
|
|
// data: 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 ( !data || typeof data !== "string" ) {
|
|
return null;
|
|
}
|
|
if ( typeof context === "boolean" ) {
|
|
keepScripts = context;
|
|
context = false;
|
|
}
|
|
context = context || document;
|
|
|
|
var 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 );
|
|
};
|
|
|
|
|
|
// Keep a copy of the old load method
|
|
var _load = jQuery.fn.load;
|
|
|
|
/**
|
|
* Load a url into a page
|
|
*/
|
|
jQuery.fn.load = function( url, params, callback ) {
|
|
if ( typeof url !== "string" && _load ) {
|
|
return _load.apply( this, arguments );
|
|
}
|
|
|
|
var selector, type, response,
|
|
self = this,
|
|
off = url.indexOf( " " );
|
|
|
|
if ( off > -1 ) {
|
|
selector = jQuery.trim( url.slice( off, url.length ) );
|
|
url = url.slice( 0, off );
|
|
}
|
|
|
|
// If it's a function
|
|
if ( jQuery.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;
|
|
};
|
|
|
|
|
|
|
|
|
|
// Attach a bunch of functions for handling common AJAX events
|
|
jQuery.each( [
|
|
"ajaxStart",
|
|
"ajaxStop",
|
|
"ajaxComplete",
|
|
"ajaxError",
|
|
"ajaxSuccess",
|
|
"ajaxSend"
|
|
], function( i, type ) {
|
|
jQuery.fn[ type ] = function( fn ) {
|
|
return this.on( type, fn );
|
|
};
|
|
} );
|
|
|
|
|
|
|
|
|
|
jQuery.expr.filters.animated = function( elem ) {
|
|
return jQuery.grep( jQuery.timers, function( fn ) {
|
|
return elem === fn.elem;
|
|
} ).length;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Gets a window from an element
|
|
*/
|
|
function getWindow( elem ) {
|
|
return jQuery.isWindow( elem ) ?
|
|
elem :
|
|
elem.nodeType === 9 ?
|
|
elem.defaultView || elem.parentWindow :
|
|
false;
|
|
}
|
|
|
|
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" ) &&
|
|
jQuery.inArray( "auto", [ curCSSTop, curCSSLeft ] ) > -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 ( jQuery.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: function( options ) {
|
|
if ( arguments.length ) {
|
|
return options === undefined ?
|
|
this :
|
|
this.each( function( i ) {
|
|
jQuery.offset.setOffset( this, options, i );
|
|
} );
|
|
}
|
|
|
|
var docElem, win,
|
|
box = { top: 0, left: 0 },
|
|
elem = this[ 0 ],
|
|
doc = elem && elem.ownerDocument;
|
|
|
|
if ( !doc ) {
|
|
return;
|
|
}
|
|
|
|
docElem = doc.documentElement;
|
|
|
|
// Make sure it's not a disconnected DOM node
|
|
if ( !jQuery.contains( docElem, elem ) ) {
|
|
return box;
|
|
}
|
|
|
|
// If we don't have gBCR, just use 0,0 rather than error
|
|
// BlackBerry 5, iOS 3 (original iPhone)
|
|
if ( typeof elem.getBoundingClientRect !== "undefined" ) {
|
|
box = elem.getBoundingClientRect();
|
|
}
|
|
win = getWindow( doc );
|
|
return {
|
|
top: box.top + ( win.pageYOffset || docElem.scrollTop ) - ( docElem.clientTop || 0 ),
|
|
left: box.left + ( win.pageXOffset || docElem.scrollLeft ) - ( docElem.clientLeft || 0 )
|
|
};
|
|
},
|
|
|
|
position: function() {
|
|
if ( !this[ 0 ] ) {
|
|
return;
|
|
}
|
|
|
|
var offsetParent, offset,
|
|
parentOffset = { top: 0, left: 0 },
|
|
elem = this[ 0 ];
|
|
|
|
// Fixed elements are offset from window (parentOffset = {top:0, left: 0},
|
|
// because it is its only offset parent
|
|
if ( jQuery.css( elem, "position" ) === "fixed" ) {
|
|
|
|
// we assume that getBoundingClientRect is available when computed position is fixed
|
|
offset = elem.getBoundingClientRect();
|
|
} else {
|
|
|
|
// Get *real* offsetParent
|
|
offsetParent = this.offsetParent();
|
|
|
|
// Get correct offsets
|
|
offset = this.offset();
|
|
if ( !jQuery.nodeName( offsetParent[ 0 ], "html" ) ) {
|
|
parentOffset = offsetParent.offset();
|
|
}
|
|
|
|
// Add offsetParent borders
|
|
parentOffset.top += jQuery.css( offsetParent[ 0 ], "borderTopWidth", true );
|
|
parentOffset.left += jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true );
|
|
}
|
|
|
|
// Subtract parent offsets and element margins
|
|
// note: when an element has margin: auto the offsetLeft and marginLeft
|
|
// are the same in Safari causing offset.left to incorrectly be 0
|
|
return {
|
|
top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
|
|
left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
|
|
};
|
|
},
|
|
|
|
offsetParent: function() {
|
|
return this.map( function() {
|
|
var offsetParent = this.offsetParent;
|
|
|
|
while ( offsetParent && ( !jQuery.nodeName( offsetParent, "html" ) &&
|
|
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 = /Y/.test( prop );
|
|
|
|
jQuery.fn[ method ] = function( val ) {
|
|
return access( this, function( elem, method, val ) {
|
|
var win = getWindow( elem );
|
|
|
|
if ( val === undefined ) {
|
|
return win ? ( prop in win ) ? win[ prop ] :
|
|
win.document.documentElement[ method ] :
|
|
elem[ method ];
|
|
}
|
|
|
|
if ( win ) {
|
|
win.scrollTo(
|
|
!top ? val : jQuery( win ).scrollLeft(),
|
|
top ? val : jQuery( win ).scrollTop()
|
|
);
|
|
|
|
} else {
|
|
elem[ method ] = val;
|
|
}
|
|
}, method, val, arguments.length, null );
|
|
};
|
|
} );
|
|
|
|
// Support: Safari<7-8+, Chrome<37-44+
|
|
// Add the top/left cssHooks using jQuery.fn.position
|
|
// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
|
|
// getComputedStyle returns percent when specified for top/left/bottom/right
|
|
// rather than make the css module depend on the offset module, we 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 ( jQuery.isWindow( elem ) ) {
|
|
|
|
// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
|
|
// isn't a whole lot we can do. See pull request at this URL for discussion:
|
|
// https://github.com/jquery/jquery/pull/764
|
|
return 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
|
|
// unfortunately, this causes bug #3838 in IE6/8 only,
|
|
// but there is currently no good, small way to fix it.
|
|
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, null );
|
|
};
|
|
} );
|
|
} );
|
|
|
|
|
|
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 );
|
|
}
|
|
} );
|
|
|
|
// The number of elements contained in the matched element set
|
|
jQuery.fn.size = function() {
|
|
return this.length;
|
|
};
|
|
|
|
jQuery.fn.andSelf = jQuery.fn.addBack;
|
|
|
|
|
|
|
|
|
|
// 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 ( !noGlobal ) {
|
|
window.jQuery = window.$ = jQuery;
|
|
}
|
|
|
|
return jQuery;
|
|
}));
|
|
/*
|
|
Turbolinks 5.1.0
|
|
Copyright © 2018 Basecamp, LLC
|
|
*/
|
|
|
|
(function(){this.Turbolinks={supported:function(){return null!=window.history.pushState&&null!=window.requestAnimationFrame&&null!=window.addEventListener}(),visit:function(t,e){return Turbolinks.controller.visit(t,e)},clearCache:function(){return Turbolinks.controller.clearCache()},setProgressBarDelay:function(t){return Turbolinks.controller.setProgressBarDelay(t)}}}).call(this),function(){var t,e,r,n=[].slice;Turbolinks.copyObject=function(t){var e,r,n;r={};for(e in t)n=t[e],r[e]=n;return r},Turbolinks.closest=function(e,r){return t.call(e,r)},t=function(){var t,r;return t=document.documentElement,null!=(r=t.closest)?r:function(t){var r;for(r=this;r;){if(r.nodeType===Node.ELEMENT_NODE&&e.call(r,t))return r;r=r.parentNode}}}(),Turbolinks.defer=function(t){return setTimeout(t,1)},Turbolinks.throttle=function(t){var e;return e=null,function(){var r;return r=1<=arguments.length?n.call(arguments,0):[],null!=e?e:e=requestAnimationFrame(function(n){return function(){return e=null,t.apply(n,r)}}(this))}},Turbolinks.dispatch=function(t,e){var n,o,i,s,a,u;return a=null!=e?e:{},u=a.target,n=a.cancelable,o=a.data,i=document.createEvent("Events"),i.initEvent(t,!0,n===!0),i.data=null!=o?o:{},i.cancelable&&!r&&(s=i.preventDefault,i.preventDefault=function(){return this.defaultPrevented||Object.defineProperty(this,"defaultPrevented",{get:function(){return!0}}),s.call(this)}),(null!=u?u:document).dispatchEvent(i),i},r=function(){var t;return t=document.createEvent("Events"),t.initEvent("test",!0,!0),t.preventDefault(),t.defaultPrevented}(),Turbolinks.match=function(t,r){return e.call(t,r)},e=function(){var t,e,r,n;return t=document.documentElement,null!=(e=null!=(r=null!=(n=t.matchesSelector)?n:t.webkitMatchesSelector)?r:t.msMatchesSelector)?e:t.mozMatchesSelector}(),Turbolinks.uuid=function(){var t,e,r;for(r="",t=e=1;36>=e;t=++e)r+=9===t||14===t||19===t||24===t?"-":15===t?"4":20===t?(Math.floor(4*Math.random())+8).toString(16):Math.floor(15*Math.random()).toString(16);return r}}.call(this),function(){Turbolinks.Location=function(){function t(t){var e,r;null==t&&(t=""),r=document.createElement("a"),r.href=t.toString(),this.absoluteURL=r.href,e=r.hash.length,2>e?this.requestURL=this.absoluteURL:(this.requestURL=this.absoluteURL.slice(0,-e),this.anchor=r.hash.slice(1))}var e,r,n,o;return t.wrap=function(t){return t instanceof this?t:new this(t)},t.prototype.getOrigin=function(){return this.absoluteURL.split("/",3).join("/")},t.prototype.getPath=function(){var t,e;return null!=(t=null!=(e=this.requestURL.match(/\/\/[^\/]*(\/[^?;]*)/))?e[1]:void 0)?t:"/"},t.prototype.getPathComponents=function(){return this.getPath().split("/").slice(1)},t.prototype.getLastPathComponent=function(){return this.getPathComponents().slice(-1)[0]},t.prototype.getExtension=function(){var t,e;return null!=(t=null!=(e=this.getLastPathComponent().match(/\.[^.]*$/))?e[0]:void 0)?t:""},t.prototype.isHTML=function(){return this.getExtension().match(/^(?:|\.(?:htm|html|xhtml))$/)},t.prototype.isPrefixedBy=function(t){var e;return e=r(t),this.isEqualTo(t)||o(this.absoluteURL,e)},t.prototype.isEqualTo=function(t){return this.absoluteURL===(null!=t?t.absoluteURL:void 0)},t.prototype.toCacheKey=function(){return this.requestURL},t.prototype.toJSON=function(){return this.absoluteURL},t.prototype.toString=function(){return this.absoluteURL},t.prototype.valueOf=function(){return this.absoluteURL},r=function(t){return e(t.getOrigin()+t.getPath())},e=function(t){return n(t,"/")?t:t+"/"},o=function(t,e){return t.slice(0,e.length)===e},n=function(t,e){return t.slice(-e.length)===e},t}()}.call(this),function(){var t=function(t,e){return function(){return t.apply(e,arguments)}};Turbolinks.HttpRequest=function(){function e(e,r,n){this.delegate=e,this.requestCanceled=t(this.requestCanceled,this),this.requestTimedOut=t(this.requestTimedOut,this),this.requestFailed=t(this.requestFailed,this),this.requestLoaded=t(this.requestLoaded,this),this.requestProgressed=t(this.requestProgressed,this),this.url=Turbolinks.Location.wrap(r).requestURL,this.referrer=Turbolinks.Location.wrap(n).absoluteURL,this.createXHR()}return e.NETWORK_FAILURE=0,e.TIMEOUT_FAILURE=-1,e.timeout=60,e.prototype.send=function(){var t;return this.xhr&&!this.sent?(this.notifyApplicationBeforeRequestStart(),this.setProgress(0),this.xhr.send(),this.sent=!0,"function"==typeof(t=this.delegate).requestStarted?t.requestStarted():void 0):void 0},e.prototype.cancel=function(){return this.xhr&&this.sent?this.xhr.abort():void 0},e.prototype.requestProgressed=function(t){return t.lengthComputable?this.setProgress(t.loaded/t.total):void 0},e.prototype.requestLoaded=function(){return this.endRequest(function(t){return function(){var e;return 200<=(e=t.xhr.status)&&300>e?t.delegate.requestCompletedWithResponse(t.xhr.responseText,t.xhr.getResponseHeader("Turbolinks-Location")):(t.failed=!0,t.delegate.requestFailedWithStatusCode(t.xhr.status,t.xhr.responseText))}}(this))},e.prototype.requestFailed=function(){return this.endRequest(function(t){return function(){return t.failed=!0,t.delegate.requestFailedWithStatusCode(t.constructor.NETWORK_FAILURE)}}(this))},e.prototype.requestTimedOut=function(){return this.endRequest(function(t){return function(){return t.failed=!0,t.delegate.requestFailedWithStatusCode(t.constructor.TIMEOUT_FAILURE)}}(this))},e.prototype.requestCanceled=function(){return this.endRequest()},e.prototype.notifyApplicationBeforeRequestStart=function(){return Turbolinks.dispatch("turbolinks:request-start",{data:{url:this.url,xhr:this.xhr}})},e.prototype.notifyApplicationAfterRequestEnd=function(){return Turbolinks.dispatch("turbolinks:request-end",{data:{url:this.url,xhr:this.xhr}})},e.prototype.createXHR=function(){return this.xhr=new XMLHttpRequest,this.xhr.open("GET",this.url,!0),this.xhr.timeout=1e3*this.constructor.timeout,this.xhr.setRequestHeader("Accept","text/html, application/xhtml+xml"),this.xhr.setRequestHeader("Turbolinks-Referrer",this.referrer),this.xhr.onprogress=this.requestProgressed,this.xhr.onload=this.requestLoaded,this.xhr.onerror=this.requestFailed,this.xhr.ontimeout=this.requestTimedOut,this.xhr.onabort=this.requestCanceled},e.prototype.endRequest=function(t){return this.xhr?(this.notifyApplicationAfterRequestEnd(),null!=t&&t.call(this),this.destroy()):void 0},e.prototype.setProgress=function(t){var e;return this.progress=t,"function"==typeof(e=this.delegate).requestProgressed?e.requestProgressed(this.progress):void 0},e.prototype.destroy=function(){var t;return this.setProgress(1),"function"==typeof(t=this.delegate).requestFinished&&t.requestFinished(),this.delegate=null,this.xhr=null},e}()}.call(this),function(){var t=function(t,e){return function(){return t.apply(e,arguments)}};Turbolinks.ProgressBar=function(){function e(){this.trickle=t(this.trickle,this),this.stylesheetElement=this.createStylesheetElement(),this.progressElement=this.createProgressElement()}var r;return r=300,e.defaultCSS=".turbolinks-progress-bar {\n position: fixed;\n display: block;\n top: 0;\n left: 0;\n height: 3px;\n background: #0076ff;\n z-index: 9999;\n transition: width "+r+"ms ease-out, opacity "+r/2+"ms "+r/2+"ms ease-in;\n transform: translate3d(0, 0, 0);\n}",e.prototype.show=function(){return this.visible?void 0:(this.visible=!0,this.installStylesheetElement(),this.installProgressElement(),this.startTrickling())},e.prototype.hide=function(){return this.visible&&!this.hiding?(this.hiding=!0,this.fadeProgressElement(function(t){return function(){return t.uninstallProgressElement(),t.stopTrickling(),t.visible=!1,t.hiding=!1}}(this))):void 0},e.prototype.setValue=function(t){return this.value=t,this.refresh()},e.prototype.installStylesheetElement=function(){return document.head.insertBefore(this.stylesheetElement,document.head.firstChild)},e.prototype.installProgressElement=function(){return this.progressElement.style.width=0,this.progressElement.style.opacity=1,document.documentElement.insertBefore(this.progressElement,document.body),this.refresh()},e.prototype.fadeProgressElement=function(t){return this.progressElement.style.opacity=0,setTimeout(t,1.5*r)},e.prototype.uninstallProgressElement=function(){return this.progressElement.parentNode?document.documentElement.removeChild(this.progressElement):void 0},e.prototype.startTrickling=function(){return null!=this.trickleInterval?this.trickleInterval:this.trickleInterval=setInterval(this.trickle,r)},e.prototype.stopTrickling=function(){return clearInterval(this.trickleInterval),this.trickleInterval=null},e.prototype.trickle=function(){return this.setValue(this.value+Math.random()/100)},e.prototype.refresh=function(){return requestAnimationFrame(function(t){return function(){return t.progressElement.style.width=10+90*t.value+"%"}}(this))},e.prototype.createStylesheetElement=function(){var t;return t=document.createElement("style"),t.type="text/css",t.textContent=this.constructor.defaultCSS,t},e.prototype.createProgressElement=function(){var t;return t=document.createElement("div"),t.className="turbolinks-progress-bar",t},e}()}.call(this),function(){var t=function(t,e){return function(){return t.apply(e,arguments)}};Turbolinks.BrowserAdapter=function(){function e(e){this.controller=e,this.showProgressBar=t(this.showProgressBar,this),this.progressBar=new Turbolinks.ProgressBar}var r,n,o;return o=Turbolinks.HttpRequest,r=o.NETWORK_FAILURE,n=o.TIMEOUT_FAILURE,e.prototype.visitProposedToLocationWithAction=function(t,e){return this.controller.startVisitToLocationWithAction(t,e)},e.prototype.visitStarted=function(t){return t.issueRequest(),t.changeHistory(),t.loadCachedSnapshot()},e.prototype.visitRequestStarted=function(t){return this.progressBar.setValue(0),t.hasCachedSnapshot()||"restore"!==t.action?this.showProgressBarAfterDelay():this.showProgressBar()},e.prototype.visitRequestProgressed=function(t){return this.progressBar.setValue(t.progress)},e.prototype.visitRequestCompleted=function(t){return t.loadResponse()},e.prototype.visitRequestFailedWithStatusCode=function(t,e){switch(e){case r:case n:return this.reload();default:return t.loadResponse()}},e.prototype.visitRequestFinished=function(t){return this.hideProgressBar()},e.prototype.visitCompleted=function(t){return t.followRedirect()},e.prototype.pageInvalidated=function(){return this.reload()},e.prototype.showProgressBarAfterDelay=function(){return this.progressBarTimeout=setTimeout(this.showProgressBar,this.controller.progressBarDelay)},e.prototype.showProgressBar=function(){return this.progressBar.show()},e.prototype.hideProgressBar=function(){return this.progressBar.hide(),clearTimeout(this.progressBarTimeout)},e.prototype.reload=function(){return window.location.reload()},e}()}.call(this),function(){var t=function(t,e){return function(){return t.apply(e,arguments)}};Turbolinks.History=function(){function e(e){this.delegate=e,this.onPageLoad=t(this.onPageLoad,this),this.onPopState=t(this.onPopState,this)}return e.prototype.start=function(){return this.started?void 0:(addEventListener("popstate",this.onPopState,!1),addEventListener("load",this.onPageLoad,!1),this.started=!0)},e.prototype.stop=function(){return this.started?(removeEventListener("popstate",this.onPopState,!1),removeEventListener("load",this.onPageLoad,!1),this.started=!1):void 0},e.prototype.push=function(t,e){return t=Turbolinks.Location.wrap(t),this.update("push",t,e)},e.prototype.replace=function(t,e){return t=Turbolinks.Location.wrap(t),this.update("replace",t,e)},e.prototype.onPopState=function(t){var e,r,n,o;return this.shouldHandlePopState()&&(o=null!=(r=t.state)?r.turbolinks:void 0)?(e=Turbolinks.Location.wrap(window.location),n=o.restorationIdentifier,this.delegate.historyPoppedToLocationWithRestorationIdentifier(e,n)):void 0},e.prototype.onPageLoad=function(t){return Turbolinks.defer(function(t){return function(){return t.pageLoaded=!0}}(this))},e.prototype.shouldHandlePopState=function(){return this.pageIsLoaded()},e.prototype.pageIsLoaded=function(){return this.pageLoaded||"complete"===document.readyState},e.prototype.update=function(t,e,r){var n;return n={turbolinks:{restorationIdentifier:r}},history[t+"State"](n,null,e)},e}()}.call(this),function(){Turbolinks.Snapshot=function(){function t(t){var e,r;r=t.head,e=t.body,this.head=null!=r?r:document.createElement("head"),this.body=null!=e?e:document.createElement("body")}return t.wrap=function(t){return t instanceof this?t:this.fromHTML(t)},t.fromHTML=function(t){var e;return e=document.createElement("html"),e.innerHTML=t,this.fromElement(e)},t.fromElement=function(t){return new this({head:t.querySelector("head"),body:t.querySelector("body")})},t.prototype.clone=function(){return new t({head:this.head.cloneNode(!0),body:this.body.cloneNode(!0)})},t.prototype.getRootLocation=function(){var t,e;return e=null!=(t=this.getSetting("root"))?t:"/",new Turbolinks.Location(e)},t.prototype.getCacheControlValue=function(){return this.getSetting("cache-control")},t.prototype.getElementForAnchor=function(t){try{return this.body.querySelector("[id='"+t+"'], a[name='"+t+"']")}catch(e){}},t.prototype.hasAnchor=function(t){return null!=this.getElementForAnchor(t)},t.prototype.isPreviewable=function(){return"no-preview"!==this.getCacheControlValue()},t.prototype.isCacheable=function(){return"no-cache"!==this.getCacheControlValue()},t.prototype.isVisitable=function(){return"reload"!==this.getSetting("visit-control")},t.prototype.getSetting=function(t){var e,r;return r=this.head.querySelectorAll("meta[name='turbolinks-"+t+"']"),e=r[r.length-1],null!=e?e.getAttribute("content"):void 0},t}()}.call(this),function(){var t=[].slice;Turbolinks.Renderer=function(){function e(){}var r;return e.render=function(){var e,r,n,o;return n=arguments[0],r=arguments[1],e=3<=arguments.length?t.call(arguments,2):[],o=function(t,e,r){r.prototype=t.prototype;var n=new r,o=t.apply(n,e);return Object(o)===o?o:n}(this,e,function(){}),o.delegate=n,o.render(r),o},e.prototype.renderView=function(t){return this.delegate.viewWillRender(this.newBody),t(),this.delegate.viewRendered(this.newBody)},e.prototype.invalidateView=function(){return this.delegate.viewInvalidated()},e.prototype.createScriptElement=function(t){var e;return"false"===t.getAttribute("data-turbolinks-eval")?t:(e=document.createElement("script"),e.textContent=t.textContent,e.async=!1,r(e,t),e)},r=function(t,e){var r,n,o,i,s,a,u;for(i=e.attributes,a=[],r=0,n=i.length;n>r;r++)s=i[r],o=s.name,u=s.value,a.push(t.setAttribute(o,u));return a},e}()}.call(this),function(){Turbolinks.HeadDetails=function(){function t(t){var e,r,i,s,a,u,l;for(this.element=t,this.elements={},l=this.element.childNodes,s=0,u=l.length;u>s;s++)i=l[s],i.nodeType===Node.ELEMENT_NODE&&(a=i.outerHTML,r=null!=(e=this.elements)[a]?e[a]:e[a]={type:o(i),tracked:n(i),elements:[]},r.elements.push(i))}var e,r,n,o;return t.prototype.hasElementWithKey=function(t){return t in this.elements},t.prototype.getTrackedElementSignature=function(){var t,e;return function(){var r,n;r=this.elements,n=[];for(t in r)e=r[t].tracked,e&&n.push(t);return n}.call(this).join("")},t.prototype.getScriptElementsNotInDetails=function(t){return this.getElementsMatchingTypeNotInDetails("script",t)},t.prototype.getStylesheetElementsNotInDetails=function(t){return this.getElementsMatchingTypeNotInDetails("stylesheet",t)},t.prototype.getElementsMatchingTypeNotInDetails=function(t,e){var r,n,o,i,s,a;o=this.elements,s=[];for(n in o)i=o[n],a=i.type,r=i.elements,a!==t||e.hasElementWithKey(n)||s.push(r[0]);return s},t.prototype.getProvisionalElements=function(){var t,e,r,n,o,i,s;r=[],n=this.elements;for(e in n)o=n[e],s=o.type,i=o.tracked,t=o.elements,null!=s||i?t.length>1&&r.push.apply(r,t.slice(1)):r.push.apply(r,t);return r},o=function(t){return e(t)?"script":r(t)?"stylesheet":void 0},n=function(t){return"reload"===t.getAttribute("data-turbolinks-track")},e=function(t){var e;return e=t.tagName.toLowerCase(),"script"===e},r=function(t){var e;return e=t.tagName.toLowerCase(),"style"===e||"link"===e&&"stylesheet"===t.getAttribute("rel")},t}()}.call(this),function(){var t=function(t,r){function n(){this.constructor=t}for(var o in r)e.call(r,o)&&(t[o]=r[o]);return n.prototype=r.prototype,t.prototype=new n,t.__super__=r.prototype,t},e={}.hasOwnProperty;Turbolinks.SnapshotRenderer=function(e){function r(t,e,r){this.currentSnapshot=t,this.newSnapshot=e,this.isPreview=r,this.currentHeadDetails=new Turbolinks.HeadDetails(this.currentSnapshot.head),this.newHeadDetails=new Turbolinks.HeadDetails(this.newSnapshot.head),this.newBody=this.newSnapshot.body}return t(r,e),r.prototype.render=function(t){return this.shouldRender()?(this.mergeHead(),this.renderView(function(e){return function(){return e.replaceBody(),e.isPreview||e.focusFirstAutofocusableElement(),t()}}(this))):this.invalidateView()},r.prototype.mergeHead=function(){return this.copyNewHeadStylesheetElements(),this.copyNewHeadScriptElements(),this.removeCurrentHeadProvisionalElements(),this.copyNewHeadProvisionalElements()},r.prototype.replaceBody=function(){return this.activateBodyScriptElements(),this.importBodyPermanentElements(),this.assignNewBody()},r.prototype.shouldRender=function(){return this.newSnapshot.isVisitable()&&this.trackedElementsAreIdentical()},r.prototype.trackedElementsAreIdentical=function(){return this.currentHeadDetails.getTrackedElementSignature()===this.newHeadDetails.getTrackedElementSignature()},r.prototype.copyNewHeadStylesheetElements=function(){var t,e,r,n,o;for(n=this.getNewHeadStylesheetElements(),o=[],e=0,r=n.length;r>e;e++)t=n[e],o.push(document.head.appendChild(t));return o},r.prototype.copyNewHeadScriptElements=function(){var t,e,r,n,o;for(n=this.getNewHeadScriptElements(),o=[],e=0,r=n.length;r>e;e++)t=n[e],o.push(document.head.appendChild(this.createScriptElement(t)));return o},r.prototype.removeCurrentHeadProvisionalElements=function(){var t,e,r,n,o;for(n=this.getCurrentHeadProvisionalElements(),o=[],e=0,r=n.length;r>e;e++)t=n[e],o.push(document.head.removeChild(t));return o},r.prototype.copyNewHeadProvisionalElements=function(){var t,e,r,n,o;for(n=this.getNewHeadProvisionalElements(),o=[],e=0,r=n.length;r>e;e++)t=n[e],o.push(document.head.appendChild(t));return o},r.prototype.importBodyPermanentElements=function(){var t,e,r,n,o,i;for(n=this.getNewBodyPermanentElements(),i=[],e=0,r=n.length;r>e;e++)o=n[e],(t=this.findCurrentBodyPermanentElement(o))?i.push(o.parentNode.replaceChild(t,o)):i.push(void 0);return i},r.prototype.activateBodyScriptElements=function(){var t,e,r,n,o,i;for(n=this.getNewBodyScriptElements(),i=[],e=0,r=n.length;r>e;e++)o=n[e],t=this.createScriptElement(o),i.push(o.parentNode.replaceChild(t,o));return i},r.prototype.assignNewBody=function(){return document.body=this.newBody},r.prototype.focusFirstAutofocusableElement=function(){var t;return null!=(t=this.findFirstAutofocusableElement())?t.focus():void 0},r.prototype.getNewHeadStylesheetElements=function(){return this.newHeadDetails.getStylesheetElementsNotInDetails(this.currentHeadDetails)},r.prototype.getNewHeadScriptElements=function(){return this.newHeadDetails.getScriptElementsNotInDetails(this.currentHeadDetails)},r.prototype.getCurrentHeadProvisionalElements=function(){return this.currentHeadDetails.getProvisionalElements()},r.prototype.getNewHeadProvisionalElements=function(){return this.newHeadDetails.getProvisionalElements()},r.prototype.getNewBodyPermanentElements=function(){return this.newBody.querySelectorAll("[id][data-turbolinks-permanent]")},r.prototype.findCurrentBodyPermanentElement=function(t){return document.body.querySelector("#"+t.id+"[data-turbolinks-permanent]")},r.prototype.getNewBodyScriptElements=function(){return this.newBody.querySelectorAll("script")},r.prototype.findFirstAutofocusableElement=function(){return document.body.querySelector("[autofocus]")},r}(Turbolinks.Renderer)}.call(this),function(){var t=function(t,r){function n(){this.constructor=t}for(var o in r)e.call(r,o)&&(t[o]=r[o]);return n.prototype=r.prototype,t.prototype=new n,t.__super__=r.prototype,t},e={}.hasOwnProperty;Turbolinks.ErrorRenderer=function(e){function r(t){this.html=t}return t(r,e),r.prototype.render=function(t){return this.renderView(function(e){return function(){return e.replaceDocumentHTML(),e.activateBodyScriptElements(),t()}}(this))},r.prototype.replaceDocumentHTML=function(){return document.documentElement.innerHTML=this.html},r.prototype.activateBodyScriptElements=function(){var t,e,r,n,o,i;for(n=this.getScriptElements(),i=[],e=0,r=n.length;r>e;e++)o=n[e],t=this.createScriptElement(o),i.push(o.parentNode.replaceChild(t,o));return i},r.prototype.getScriptElements=function(){return document.documentElement.querySelectorAll("script")},r}(Turbolinks.Renderer)}.call(this),function(){Turbolinks.View=function(){function t(t){this.delegate=t,this.element=document.documentElement}return t.prototype.getRootLocation=function(){return this.getSnapshot().getRootLocation()},t.prototype.getElementForAnchor=function(t){return this.getSnapshot().getElementForAnchor(t)},t.prototype.getSnapshot=function(){return Turbolinks.Snapshot.fromElement(this.element)},t.prototype.render=function(t,e){var r,n,o;return o=t.snapshot,r=t.error,n=t.isPreview,this.markAsPreview(n),null!=o?this.renderSnapshot(o,n,e):this.renderError(r,e)},t.prototype.markAsPreview=function(t){return t?this.element.setAttribute("data-turbolinks-preview",""):this.element.removeAttribute("data-turbolinks-preview")},t.prototype.renderSnapshot=function(t,e,r){return Turbolinks.SnapshotRenderer.render(this.delegate,r,this.getSnapshot(),Turbolinks.Snapshot.wrap(t),e)},t.prototype.renderError=function(t,e){return Turbolinks.ErrorRenderer.render(this.delegate,e,t)},t}()}.call(this),function(){var t=function(t,e){return function(){return t.apply(e,arguments)}};Turbolinks.ScrollManager=function(){function e(e){this.delegate=e,this.onScroll=t(this.onScroll,this),this.onScroll=Turbolinks.throttle(this.onScroll)}return e.prototype.start=function(){return this.started?void 0:(addEventListener("scroll",this.onScroll,!1),this.onScroll(),this.started=!0)},e.prototype.stop=function(){return this.started?(removeEventListener("scroll",this.onScroll,!1),this.started=!1):void 0},e.prototype.scrollToElement=function(t){return t.scrollIntoView()},e.prototype.scrollToPosition=function(t){var e,r;return e=t.x,r=t.y,window.scrollTo(e,r)},e.prototype.onScroll=function(t){return this.updatePosition({x:window.pageXOffset,y:window.pageYOffset})},e.prototype.updatePosition=function(t){var e;return this.position=t,null!=(e=this.delegate)?e.scrollPositionChanged(this.position):void 0},e}()}.call(this),function(){Turbolinks.SnapshotCache=function(){function t(t){this.size=t,this.keys=[],this.snapshots={}}var e;return t.prototype.has=function(t){var r;return r=e(t),r in this.snapshots},t.prototype.get=function(t){var e;if(this.has(t))return e=this.read(t),this.touch(t),e},t.prototype.put=function(t,e){return this.write(t,e),this.touch(t),e},t.prototype.read=function(t){var r;return r=e(t),this.snapshots[r]},t.prototype.write=function(t,r){var n;return n=e(t),this.snapshots[n]=r},t.prototype.touch=function(t){var r,n;return n=e(t),r=this.keys.indexOf(n),r>-1&&this.keys.splice(r,1),this.keys.unshift(n),this.trim()},t.prototype.trim=function(){var t,e,r,n,o;for(n=this.keys.splice(this.size),o=[],t=0,r=n.length;r>t;t++)e=n[t],o.push(delete this.snapshots[e]);return o},e=function(t){return Turbolinks.Location.wrap(t).toCacheKey()},t}()}.call(this),function(){var t=function(t,e){return function(){return t.apply(e,arguments)}};Turbolinks.Visit=function(){function e(e,r,n){this.controller=e,this.action=n,this.performScroll=t(this.performScroll,this),this.identifier=Turbolinks.uuid(),this.location=Turbolinks.Location.wrap(r),this.adapter=this.controller.adapter,this.state="initialized",this.timingMetrics={}}var r;return e.prototype.start=function(){return"initialized"===this.state?(this.recordTimingMetric("visitStart"),this.state="started",this.adapter.visitStarted(this)):void 0},e.prototype.cancel=function(){var t;return"started"===this.state?(null!=(t=this.request)&&t.cancel(),this.cancelRender(),this.state="canceled"):void 0},e.prototype.complete=function(){var t;return"started"===this.state?(this.recordTimingMetric("visitEnd"),this.state="completed","function"==typeof(t=this.adapter).visitCompleted&&t.visitCompleted(this),this.controller.visitCompleted(this)):void 0},e.prototype.fail=function(){var t;return"started"===this.state?(this.state="failed","function"==typeof(t=this.adapter).visitFailed?t.visitFailed(this):void 0):void 0},e.prototype.changeHistory=function(){var t,e;return this.historyChanged?void 0:(t=this.location.isEqualTo(this.referrer)?"replace":this.action,e=r(t),this.controller[e](this.location,this.restorationIdentifier),this.historyChanged=!0)},e.prototype.issueRequest=function(){return this.shouldIssueRequest()&&null==this.request?(this.progress=0,this.request=new Turbolinks.HttpRequest(this,this.location,this.referrer),this.request.send()):void 0},e.prototype.getCachedSnapshot=function(){var t;return!(t=this.controller.getCachedSnapshotForLocation(this.location))||null!=this.location.anchor&&!t.hasAnchor(this.location.anchor)||"restore"!==this.action&&!t.isPreviewable()?void 0:t},e.prototype.hasCachedSnapshot=function(){return null!=this.getCachedSnapshot()},e.prototype.loadCachedSnapshot=function(){var t,e;return(e=this.getCachedSnapshot())?(t=this.shouldIssueRequest(),this.render(function(){var r;return this.cacheSnapshot(),this.controller.render({snapshot:e,isPreview:t},this.performScroll),"function"==typeof(r=this.adapter).visitRendered&&r.visitRendered(this),t?void 0:this.complete()})):void 0},e.prototype.loadResponse=function(){return null!=this.response?this.render(function(){var t,e;return this.cacheSnapshot(),this.request.failed?(this.controller.render({error:this.response},this.performScroll),"function"==typeof(t=this.adapter).visitRendered&&t.visitRendered(this),this.fail()):(this.controller.render({snapshot:this.response},this.performScroll),"function"==typeof(e=this.adapter).visitRendered&&e.visitRendered(this),this.complete())}):void 0},e.prototype.followRedirect=function(){return this.redirectedToLocation&&!this.followedRedirect?(this.location=this.redirectedToLocation,this.controller.replaceHistoryWithLocationAndRestorationIdentifier(this.redirectedToLocation,this.restorationIdentifier),this.followedRedirect=!0):void 0},e.prototype.requestStarted=function(){var t;return this.recordTimingMetric("requestStart"),"function"==typeof(t=this.adapter).visitRequestStarted?t.visitRequestStarted(this):void 0},e.prototype.requestProgressed=function(t){var e;return this.progress=t,"function"==typeof(e=this.adapter).visitRequestProgressed?e.visitRequestProgressed(this):void 0},e.prototype.requestCompletedWithResponse=function(t,e){return this.response=t,null!=e&&(this.redirectedToLocation=Turbolinks.Location.wrap(e)),this.adapter.visitRequestCompleted(this)},e.prototype.requestFailedWithStatusCode=function(t,e){return this.response=e,this.adapter.visitRequestFailedWithStatusCode(this,t)},e.prototype.requestFinished=function(){var t;return this.recordTimingMetric("requestEnd"),"function"==typeof(t=this.adapter).visitRequestFinished?t.visitRequestFinished(this):void 0},e.prototype.performScroll=function(){return this.scrolled?void 0:("restore"===this.action?this.scrollToRestoredPosition()||this.scrollToTop():this.scrollToAnchor()||this.scrollToTop(),this.scrolled=!0)},e.prototype.scrollToRestoredPosition=function(){var t,e;return t=null!=(e=this.restorationData)?e.scrollPosition:void 0,null!=t?(this.controller.scrollToPosition(t),!0):void 0},e.prototype.scrollToAnchor=function(){return null!=this.location.anchor?(this.controller.scrollToAnchor(this.location.anchor),!0):void 0},e.prototype.scrollToTop=function(){return this.controller.scrollToPosition({x:0,y:0})},e.prototype.recordTimingMetric=function(t){var e;return null!=(e=this.timingMetrics)[t]?e[t]:e[t]=(new Date).getTime()},e.prototype.getTimingMetrics=function(){return Turbolinks.copyObject(this.timingMetrics)},r=function(t){switch(t){case"replace":return"replaceHistoryWithLocationAndRestorationIdentifier";case"advance":case"restore":return"pushHistoryWithLocationAndRestorationIdentifier"}},e.prototype.shouldIssueRequest=function(){return"restore"===this.action?!this.hasCachedSnapshot():!0},e.prototype.cacheSnapshot=function(){return this.snapshotCached?void 0:(this.controller.cacheSnapshot(),this.snapshotCached=!0)},e.prototype.render=function(t){return this.cancelRender(),this.frame=requestAnimationFrame(function(e){return function(){return e.frame=null,t.call(e)}}(this))},e.prototype.cancelRender=function(){return this.frame?cancelAnimationFrame(this.frame):void 0},e}()}.call(this),function(){var t=function(t,e){return function(){return t.apply(e,arguments)}};Turbolinks.Controller=function(){function e(){this.clickBubbled=t(this.clickBubbled,this),this.clickCaptured=t(this.clickCaptured,this),this.pageLoaded=t(this.pageLoaded,this),this.history=new Turbolinks.History(this),this.view=new Turbolinks.View(this),this.scrollManager=new Turbolinks.ScrollManager(this),this.restorationData={},this.clearCache(),this.setProgressBarDelay(500)}return e.prototype.start=function(){return Turbolinks.supported&&!this.started?(addEventListener("click",this.clickCaptured,!0),addEventListener("DOMContentLoaded",this.pageLoaded,!1),this.scrollManager.start(),this.startHistory(),this.started=!0,this.enabled=!0):void 0},e.prototype.disable=function(){return this.enabled=!1},e.prototype.stop=function(){return this.started?(removeEventListener("click",this.clickCaptured,!0),removeEventListener("DOMContentLoaded",this.pageLoaded,!1),this.scrollManager.stop(),this.stopHistory(),this.started=!1):void 0},e.prototype.clearCache=function(){return this.cache=new Turbolinks.SnapshotCache(10)},e.prototype.visit=function(t,e){var r,n;return null==e&&(e={}),t=Turbolinks.Location.wrap(t),this.applicationAllowsVisitingLocation(t)?this.locationIsVisitable(t)?(r=null!=(n=e.action)?n:"advance",this.adapter.visitProposedToLocationWithAction(t,r)):window.location=t:void 0},e.prototype.startVisitToLocationWithAction=function(t,e,r){var n;return Turbolinks.supported?(n=this.getRestorationDataForIdentifier(r),this.startVisit(t,e,{restorationData:n})):window.location=t},e.prototype.setProgressBarDelay=function(t){return this.progressBarDelay=t},e.prototype.startHistory=function(){return this.location=Turbolinks.Location.wrap(window.location),this.restorationIdentifier=Turbolinks.uuid(),this.history.start(),this.history.replace(this.location,this.restorationIdentifier)},e.prototype.stopHistory=function(){return this.history.stop()},e.prototype.pushHistoryWithLocationAndRestorationIdentifier=function(t,e){return this.restorationIdentifier=e,this.location=Turbolinks.Location.wrap(t),this.history.push(this.location,this.restorationIdentifier)},e.prototype.replaceHistoryWithLocationAndRestorationIdentifier=function(t,e){return this.restorationIdentifier=e,this.location=Turbolinks.Location.wrap(t),this.history.replace(this.location,this.restorationIdentifier)},e.prototype.historyPoppedToLocationWithRestorationIdentifier=function(t,e){var r;return this.restorationIdentifier=e,this.enabled?(r=this.getRestorationDataForIdentifier(this.restorationIdentifier),this.startVisit(t,"restore",{restorationIdentifier:this.restorationIdentifier,restorationData:r,historyChanged:!0}),this.location=Turbolinks.Location.wrap(t)):this.adapter.pageInvalidated()},e.prototype.getCachedSnapshotForLocation=function(t){var e;return e=this.cache.get(t),e?e.clone():void 0},e.prototype.shouldCacheSnapshot=function(){return this.view.getSnapshot().isCacheable()},e.prototype.cacheSnapshot=function(){var t;return this.shouldCacheSnapshot()?(this.notifyApplicationBeforeCachingSnapshot(),t=this.view.getSnapshot(),this.cache.put(this.lastRenderedLocation,t.clone())):void 0},e.prototype.scrollToAnchor=function(t){var e;return(e=this.view.getElementForAnchor(t))?this.scrollToElement(e):this.scrollToPosition({x:0,y:0})},e.prototype.scrollToElement=function(t){return this.scrollManager.scrollToElement(t)},e.prototype.scrollToPosition=function(t){return this.scrollManager.scrollToPosition(t)},e.prototype.scrollPositionChanged=function(t){var e;return e=this.getCurrentRestorationData(),e.scrollPosition=t},e.prototype.render=function(t,e){return this.view.render(t,e)},e.prototype.viewInvalidated=function(){return this.adapter.pageInvalidated()},e.prototype.viewWillRender=function(t){return this.notifyApplicationBeforeRender(t)},e.prototype.viewRendered=function(){return this.lastRenderedLocation=this.currentVisit.location,this.notifyApplicationAfterRender()},e.prototype.pageLoaded=function(){
|
|
return this.lastRenderedLocation=this.location,this.notifyApplicationAfterPageLoad()},e.prototype.clickCaptured=function(){return removeEventListener("click",this.clickBubbled,!1),addEventListener("click",this.clickBubbled,!1)},e.prototype.clickBubbled=function(t){var e,r,n;return this.enabled&&this.clickEventIsSignificant(t)&&(r=this.getVisitableLinkForNode(t.target))&&(n=this.getVisitableLocationForLink(r))&&this.applicationAllowsFollowingLinkToLocation(r,n)?(t.preventDefault(),e=this.getActionForLink(r),this.visit(n,{action:e})):void 0},e.prototype.applicationAllowsFollowingLinkToLocation=function(t,e){var r;return r=this.notifyApplicationAfterClickingLinkToLocation(t,e),!r.defaultPrevented},e.prototype.applicationAllowsVisitingLocation=function(t){var e;return e=this.notifyApplicationBeforeVisitingLocation(t),!e.defaultPrevented},e.prototype.notifyApplicationAfterClickingLinkToLocation=function(t,e){return Turbolinks.dispatch("turbolinks:click",{target:t,data:{url:e.absoluteURL},cancelable:!0})},e.prototype.notifyApplicationBeforeVisitingLocation=function(t){return Turbolinks.dispatch("turbolinks:before-visit",{data:{url:t.absoluteURL},cancelable:!0})},e.prototype.notifyApplicationAfterVisitingLocation=function(t){return Turbolinks.dispatch("turbolinks:visit",{data:{url:t.absoluteURL}})},e.prototype.notifyApplicationBeforeCachingSnapshot=function(){return Turbolinks.dispatch("turbolinks:before-cache")},e.prototype.notifyApplicationBeforeRender=function(t){return Turbolinks.dispatch("turbolinks:before-render",{data:{newBody:t}})},e.prototype.notifyApplicationAfterRender=function(){return Turbolinks.dispatch("turbolinks:render")},e.prototype.notifyApplicationAfterPageLoad=function(t){return null==t&&(t={}),Turbolinks.dispatch("turbolinks:load",{data:{url:this.location.absoluteURL,timing:t}})},e.prototype.startVisit=function(t,e,r){var n;return null!=(n=this.currentVisit)&&n.cancel(),this.currentVisit=this.createVisit(t,e,r),this.currentVisit.start(),this.notifyApplicationAfterVisitingLocation(t)},e.prototype.createVisit=function(t,e,r){var n,o,i,s,a;return o=null!=r?r:{},s=o.restorationIdentifier,i=o.restorationData,n=o.historyChanged,a=new Turbolinks.Visit(this,t,e),a.restorationIdentifier=null!=s?s:Turbolinks.uuid(),a.restorationData=Turbolinks.copyObject(i),a.historyChanged=n,a.referrer=this.location,a},e.prototype.visitCompleted=function(t){return this.notifyApplicationAfterPageLoad(t.getTimingMetrics())},e.prototype.clickEventIsSignificant=function(t){return!(t.defaultPrevented||t.target.isContentEditable||t.which>1||t.altKey||t.ctrlKey||t.metaKey||t.shiftKey)},e.prototype.getVisitableLinkForNode=function(t){return this.nodeIsVisitable(t)?Turbolinks.closest(t,"a[href]:not([target]):not([download])"):void 0},e.prototype.getVisitableLocationForLink=function(t){var e;return e=new Turbolinks.Location(t.getAttribute("href")),this.locationIsVisitable(e)?e:void 0},e.prototype.getActionForLink=function(t){var e;return null!=(e=t.getAttribute("data-turbolinks-action"))?e:"advance"},e.prototype.nodeIsVisitable=function(t){var e;return(e=Turbolinks.closest(t,"[data-turbolinks]"))?"false"!==e.getAttribute("data-turbolinks"):!0},e.prototype.locationIsVisitable=function(t){return t.isPrefixedBy(this.view.getRootLocation())&&t.isHTML()},e.prototype.getCurrentRestorationData=function(){return this.getRestorationDataForIdentifier(this.restorationIdentifier)},e.prototype.getRestorationDataForIdentifier=function(t){var e;return null!=(e=this.restorationData)[t]?e[t]:e[t]={}},e}()}.call(this),function(){!function(){var t,e;if((t=e=document.currentScript)&&!e.hasAttribute("data-turbolinks-suppress-warning"))for(;t=t.parentNode;)if(t===document.body)return console.warn("You are loading Turbolinks from a <script> element inside the <body> element. This is probably not what you meant to do!\n\nLoad your application\u2019s JavaScript bundle inside the <head> element instead. <script> elements in <body> are evaluated with each page change.\n\nFor more information, see: https://github.com/turbolinks/turbolinks#working-with-script-elements\n\n\u2014\u2014\nSuppress this warning by adding a `data-turbolinks-suppress-warning` attribute to: %s",e.outerHTML)}()}.call(this),function(){var t,e,r;Turbolinks.start=function(){return e()?(null==Turbolinks.controller&&(Turbolinks.controller=t()),Turbolinks.controller.start()):void 0},e=function(){return null==window.Turbolinks&&(window.Turbolinks=Turbolinks),r()},t=function(){var t;return t=new Turbolinks.Controller,t.adapter=new Turbolinks.BrowserAdapter(t),t},r=function(){return window.Turbolinks===Turbolinks},r()&&Turbolinks.start()}.call(this);
|
|
(function() {
|
|
$(document).on('turbolinks:load', function() {});
|
|
|
|
}).call(this);
|
|
(function() {
|
|
|
|
|
|
}).call(this);
|