105051 lines
No EOL
3.6 MiB
105051 lines
No EOL
3.6 MiB
/*!
|
||
* 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;
|
||
} );
|
||
|
||
/**!
|
||
* @fileOverview Kickass library to create and place poppers near their reference elements.
|
||
* @version 1.12.9
|
||
* @license
|
||
* Copyright (c) 2016 Federico Zivolo and contributors
|
||
*
|
||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||
* of this software and associated documentation files (the "Software"), to deal
|
||
* in the Software without restriction, including without limitation the rights
|
||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||
* copies of the Software, and to permit persons to whom the Software is
|
||
* furnished to do so, subject to the following conditions:
|
||
*
|
||
* The above copyright notice and this permission notice shall be included in all
|
||
* copies or substantial portions of the Software.
|
||
*
|
||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||
* SOFTWARE.
|
||
*/
|
||
(function (global, factory) {
|
||
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
|
||
typeof define === 'function' && define.amd ? define(factory) :
|
||
(global.Popper = factory());
|
||
}(this, (function () { 'use strict';
|
||
|
||
var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
|
||
var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];
|
||
var timeoutDuration = 0;
|
||
for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {
|
||
if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {
|
||
timeoutDuration = 1;
|
||
break;
|
||
}
|
||
}
|
||
|
||
function microtaskDebounce(fn) {
|
||
var called = false;
|
||
return function () {
|
||
if (called) {
|
||
return;
|
||
}
|
||
called = true;
|
||
window.Promise.resolve().then(function () {
|
||
called = false;
|
||
fn();
|
||
});
|
||
};
|
||
}
|
||
|
||
function taskDebounce(fn) {
|
||
var scheduled = false;
|
||
return function () {
|
||
if (!scheduled) {
|
||
scheduled = true;
|
||
setTimeout(function () {
|
||
scheduled = false;
|
||
fn();
|
||
}, timeoutDuration);
|
||
}
|
||
};
|
||
}
|
||
|
||
var supportsMicroTasks = isBrowser && window.Promise;
|
||
|
||
/**
|
||
* Create a debounced version of a method, that's asynchronously deferred
|
||
* but called in the minimum time possible.
|
||
*
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {Function} fn
|
||
* @returns {Function}
|
||
*/
|
||
var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;
|
||
|
||
/**
|
||
* Check if the given variable is a function
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {Any} functionToCheck - variable to check
|
||
* @returns {Boolean} answer to: is a function?
|
||
*/
|
||
function isFunction(functionToCheck) {
|
||
var getType = {};
|
||
return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
|
||
}
|
||
|
||
/**
|
||
* Get CSS computed property of the given element
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {Eement} element
|
||
* @argument {String} property
|
||
*/
|
||
function getStyleComputedProperty(element, property) {
|
||
if (element.nodeType !== 1) {
|
||
return [];
|
||
}
|
||
// NOTE: 1 DOM access here
|
||
var css = getComputedStyle(element, null);
|
||
return property ? css[property] : css;
|
||
}
|
||
|
||
/**
|
||
* Returns the parentNode or the host of the element
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {Element} element
|
||
* @returns {Element} parent
|
||
*/
|
||
function getParentNode(element) {
|
||
if (element.nodeName === 'HTML') {
|
||
return element;
|
||
}
|
||
return element.parentNode || element.host;
|
||
}
|
||
|
||
/**
|
||
* Returns the scrolling parent of the given element
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {Element} element
|
||
* @returns {Element} scroll parent
|
||
*/
|
||
function getScrollParent(element) {
|
||
// Return body, `getScroll` will take care to get the correct `scrollTop` from it
|
||
if (!element) {
|
||
return document.body;
|
||
}
|
||
|
||
switch (element.nodeName) {
|
||
case 'HTML':
|
||
case 'BODY':
|
||
return element.ownerDocument.body;
|
||
case '#document':
|
||
return element.body;
|
||
}
|
||
|
||
// Firefox want us to check `-x` and `-y` variations as well
|
||
|
||
var _getStyleComputedProp = getStyleComputedProperty(element),
|
||
overflow = _getStyleComputedProp.overflow,
|
||
overflowX = _getStyleComputedProp.overflowX,
|
||
overflowY = _getStyleComputedProp.overflowY;
|
||
|
||
if (/(auto|scroll)/.test(overflow + overflowY + overflowX)) {
|
||
return element;
|
||
}
|
||
|
||
return getScrollParent(getParentNode(element));
|
||
}
|
||
|
||
/**
|
||
* Returns the offset parent of the given element
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {Element} element
|
||
* @returns {Element} offset parent
|
||
*/
|
||
function getOffsetParent(element) {
|
||
// NOTE: 1 DOM access here
|
||
var offsetParent = element && element.offsetParent;
|
||
var nodeName = offsetParent && offsetParent.nodeName;
|
||
|
||
if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {
|
||
if (element) {
|
||
return element.ownerDocument.documentElement;
|
||
}
|
||
|
||
return document.documentElement;
|
||
}
|
||
|
||
// .offsetParent will return the closest TD or TABLE in case
|
||
// no offsetParent is present, I hate this job...
|
||
if (['TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {
|
||
return getOffsetParent(offsetParent);
|
||
}
|
||
|
||
return offsetParent;
|
||
}
|
||
|
||
function isOffsetContainer(element) {
|
||
var nodeName = element.nodeName;
|
||
|
||
if (nodeName === 'BODY') {
|
||
return false;
|
||
}
|
||
return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;
|
||
}
|
||
|
||
/**
|
||
* Finds the root node (document, shadowDOM root) of the given element
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {Element} node
|
||
* @returns {Element} root node
|
||
*/
|
||
function getRoot(node) {
|
||
if (node.parentNode !== null) {
|
||
return getRoot(node.parentNode);
|
||
}
|
||
|
||
return node;
|
||
}
|
||
|
||
/**
|
||
* Finds the offset parent common to the two provided nodes
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {Element} element1
|
||
* @argument {Element} element2
|
||
* @returns {Element} common offset parent
|
||
*/
|
||
function findCommonOffsetParent(element1, element2) {
|
||
// This check is needed to avoid errors in case one of the elements isn't defined for any reason
|
||
if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {
|
||
return document.documentElement;
|
||
}
|
||
|
||
// Here we make sure to give as "start" the element that comes first in the DOM
|
||
var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
|
||
var start = order ? element1 : element2;
|
||
var end = order ? element2 : element1;
|
||
|
||
// Get common ancestor container
|
||
var range = document.createRange();
|
||
range.setStart(start, 0);
|
||
range.setEnd(end, 0);
|
||
var commonAncestorContainer = range.commonAncestorContainer;
|
||
|
||
// Both nodes are inside #document
|
||
|
||
if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {
|
||
if (isOffsetContainer(commonAncestorContainer)) {
|
||
return commonAncestorContainer;
|
||
}
|
||
|
||
return getOffsetParent(commonAncestorContainer);
|
||
}
|
||
|
||
// one of the nodes is inside shadowDOM, find which one
|
||
var element1root = getRoot(element1);
|
||
if (element1root.host) {
|
||
return findCommonOffsetParent(element1root.host, element2);
|
||
} else {
|
||
return findCommonOffsetParent(element1, getRoot(element2).host);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Gets the scroll value of the given element in the given side (top and left)
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {Element} element
|
||
* @argument {String} side `top` or `left`
|
||
* @returns {number} amount of scrolled pixels
|
||
*/
|
||
function getScroll(element) {
|
||
var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';
|
||
|
||
var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';
|
||
var nodeName = element.nodeName;
|
||
|
||
if (nodeName === 'BODY' || nodeName === 'HTML') {
|
||
var html = element.ownerDocument.documentElement;
|
||
var scrollingElement = element.ownerDocument.scrollingElement || html;
|
||
return scrollingElement[upperSide];
|
||
}
|
||
|
||
return element[upperSide];
|
||
}
|
||
|
||
/*
|
||
* Sum or subtract the element scroll values (left and top) from a given rect object
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @param {Object} rect - Rect object you want to change
|
||
* @param {HTMLElement} element - The element from the function reads the scroll values
|
||
* @param {Boolean} subtract - set to true if you want to subtract the scroll values
|
||
* @return {Object} rect - The modifier rect object
|
||
*/
|
||
function includeScroll(rect, element) {
|
||
var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
|
||
|
||
var scrollTop = getScroll(element, 'top');
|
||
var scrollLeft = getScroll(element, 'left');
|
||
var modifier = subtract ? -1 : 1;
|
||
rect.top += scrollTop * modifier;
|
||
rect.bottom += scrollTop * modifier;
|
||
rect.left += scrollLeft * modifier;
|
||
rect.right += scrollLeft * modifier;
|
||
return rect;
|
||
}
|
||
|
||
/*
|
||
* Helper to detect borders of a given element
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @param {CSSStyleDeclaration} styles
|
||
* Result of `getStyleComputedProperty` on the given element
|
||
* @param {String} axis - `x` or `y`
|
||
* @return {number} borders - The borders size of the given axis
|
||
*/
|
||
|
||
function getBordersSize(styles, axis) {
|
||
var sideA = axis === 'x' ? 'Left' : 'Top';
|
||
var sideB = sideA === 'Left' ? 'Right' : 'Bottom';
|
||
|
||
return parseFloat(styles['border' + sideA + 'Width'], 10) + parseFloat(styles['border' + sideB + 'Width'], 10);
|
||
}
|
||
|
||
/**
|
||
* Tells if you are running Internet Explorer 10
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @returns {Boolean} isIE10
|
||
*/
|
||
var isIE10 = undefined;
|
||
|
||
var isIE10$1 = function () {
|
||
if (isIE10 === undefined) {
|
||
isIE10 = navigator.appVersion.indexOf('MSIE 10') !== -1;
|
||
}
|
||
return isIE10;
|
||
};
|
||
|
||
function getSize(axis, body, html, computedStyle) {
|
||
return Math.max(body['offset' + axis], body['scroll' + axis], html['client' + axis], html['offset' + axis], html['scroll' + axis], isIE10$1() ? html['offset' + axis] + computedStyle['margin' + (axis === 'Height' ? 'Top' : 'Left')] + computedStyle['margin' + (axis === 'Height' ? 'Bottom' : 'Right')] : 0);
|
||
}
|
||
|
||
function getWindowSizes() {
|
||
var body = document.body;
|
||
var html = document.documentElement;
|
||
var computedStyle = isIE10$1() && getComputedStyle(html);
|
||
|
||
return {
|
||
height: getSize('Height', body, html, computedStyle),
|
||
width: getSize('Width', body, html, computedStyle)
|
||
};
|
||
}
|
||
|
||
var classCallCheck = function (instance, Constructor) {
|
||
if (!(instance instanceof Constructor)) {
|
||
throw new TypeError("Cannot call a class as a function");
|
||
}
|
||
};
|
||
|
||
var createClass = function () {
|
||
function defineProperties(target, props) {
|
||
for (var i = 0; i < props.length; i++) {
|
||
var descriptor = props[i];
|
||
descriptor.enumerable = descriptor.enumerable || false;
|
||
descriptor.configurable = true;
|
||
if ("value" in descriptor) descriptor.writable = true;
|
||
Object.defineProperty(target, descriptor.key, descriptor);
|
||
}
|
||
}
|
||
|
||
return function (Constructor, protoProps, staticProps) {
|
||
if (protoProps) defineProperties(Constructor.prototype, protoProps);
|
||
if (staticProps) defineProperties(Constructor, staticProps);
|
||
return Constructor;
|
||
};
|
||
}();
|
||
|
||
|
||
|
||
|
||
|
||
var defineProperty = function (obj, key, value) {
|
||
if (key in obj) {
|
||
Object.defineProperty(obj, key, {
|
||
value: value,
|
||
enumerable: true,
|
||
configurable: true,
|
||
writable: true
|
||
});
|
||
} else {
|
||
obj[key] = value;
|
||
}
|
||
|
||
return obj;
|
||
};
|
||
|
||
var _extends = Object.assign || function (target) {
|
||
for (var i = 1; i < arguments.length; i++) {
|
||
var source = arguments[i];
|
||
|
||
for (var key in source) {
|
||
if (Object.prototype.hasOwnProperty.call(source, key)) {
|
||
target[key] = source[key];
|
||
}
|
||
}
|
||
}
|
||
|
||
return target;
|
||
};
|
||
|
||
/**
|
||
* Given element offsets, generate an output similar to getBoundingClientRect
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {Object} offsets
|
||
* @returns {Object} ClientRect like output
|
||
*/
|
||
function getClientRect(offsets) {
|
||
return _extends({}, offsets, {
|
||
right: offsets.left + offsets.width,
|
||
bottom: offsets.top + offsets.height
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Get bounding client rect of given element
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @param {HTMLElement} element
|
||
* @return {Object} client rect
|
||
*/
|
||
function getBoundingClientRect(element) {
|
||
var rect = {};
|
||
|
||
// IE10 10 FIX: Please, don't ask, the element isn't
|
||
// considered in DOM in some circumstances...
|
||
// This isn't reproducible in IE10 compatibility mode of IE11
|
||
if (isIE10$1()) {
|
||
try {
|
||
rect = element.getBoundingClientRect();
|
||
var scrollTop = getScroll(element, 'top');
|
||
var scrollLeft = getScroll(element, 'left');
|
||
rect.top += scrollTop;
|
||
rect.left += scrollLeft;
|
||
rect.bottom += scrollTop;
|
||
rect.right += scrollLeft;
|
||
} catch (err) {}
|
||
} else {
|
||
rect = element.getBoundingClientRect();
|
||
}
|
||
|
||
var result = {
|
||
left: rect.left,
|
||
top: rect.top,
|
||
width: rect.right - rect.left,
|
||
height: rect.bottom - rect.top
|
||
};
|
||
|
||
// subtract scrollbar size from sizes
|
||
var sizes = element.nodeName === 'HTML' ? getWindowSizes() : {};
|
||
var width = sizes.width || element.clientWidth || result.right - result.left;
|
||
var height = sizes.height || element.clientHeight || result.bottom - result.top;
|
||
|
||
var horizScrollbar = element.offsetWidth - width;
|
||
var vertScrollbar = element.offsetHeight - height;
|
||
|
||
// if an hypothetical scrollbar is detected, we must be sure it's not a `border`
|
||
// we make this check conditional for performance reasons
|
||
if (horizScrollbar || vertScrollbar) {
|
||
var styles = getStyleComputedProperty(element);
|
||
horizScrollbar -= getBordersSize(styles, 'x');
|
||
vertScrollbar -= getBordersSize(styles, 'y');
|
||
|
||
result.width -= horizScrollbar;
|
||
result.height -= vertScrollbar;
|
||
}
|
||
|
||
return getClientRect(result);
|
||
}
|
||
|
||
function getOffsetRectRelativeToArbitraryNode(children, parent) {
|
||
var isIE10 = isIE10$1();
|
||
var isHTML = parent.nodeName === 'HTML';
|
||
var childrenRect = getBoundingClientRect(children);
|
||
var parentRect = getBoundingClientRect(parent);
|
||
var scrollParent = getScrollParent(children);
|
||
|
||
var styles = getStyleComputedProperty(parent);
|
||
var borderTopWidth = parseFloat(styles.borderTopWidth, 10);
|
||
var borderLeftWidth = parseFloat(styles.borderLeftWidth, 10);
|
||
|
||
var offsets = getClientRect({
|
||
top: childrenRect.top - parentRect.top - borderTopWidth,
|
||
left: childrenRect.left - parentRect.left - borderLeftWidth,
|
||
width: childrenRect.width,
|
||
height: childrenRect.height
|
||
});
|
||
offsets.marginTop = 0;
|
||
offsets.marginLeft = 0;
|
||
|
||
// Subtract margins of documentElement in case it's being used as parent
|
||
// we do this only on HTML because it's the only element that behaves
|
||
// differently when margins are applied to it. The margins are included in
|
||
// the box of the documentElement, in the other cases not.
|
||
if (!isIE10 && isHTML) {
|
||
var marginTop = parseFloat(styles.marginTop, 10);
|
||
var marginLeft = parseFloat(styles.marginLeft, 10);
|
||
|
||
offsets.top -= borderTopWidth - marginTop;
|
||
offsets.bottom -= borderTopWidth - marginTop;
|
||
offsets.left -= borderLeftWidth - marginLeft;
|
||
offsets.right -= borderLeftWidth - marginLeft;
|
||
|
||
// Attach marginTop and marginLeft because in some circumstances we may need them
|
||
offsets.marginTop = marginTop;
|
||
offsets.marginLeft = marginLeft;
|
||
}
|
||
|
||
if (isIE10 ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {
|
||
offsets = includeScroll(offsets, parent);
|
||
}
|
||
|
||
return offsets;
|
||
}
|
||
|
||
function getViewportOffsetRectRelativeToArtbitraryNode(element) {
|
||
var html = element.ownerDocument.documentElement;
|
||
var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);
|
||
var width = Math.max(html.clientWidth, window.innerWidth || 0);
|
||
var height = Math.max(html.clientHeight, window.innerHeight || 0);
|
||
|
||
var scrollTop = getScroll(html);
|
||
var scrollLeft = getScroll(html, 'left');
|
||
|
||
var offset = {
|
||
top: scrollTop - relativeOffset.top + relativeOffset.marginTop,
|
||
left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,
|
||
width: width,
|
||
height: height
|
||
};
|
||
|
||
return getClientRect(offset);
|
||
}
|
||
|
||
/**
|
||
* Check if the given element is fixed or is inside a fixed parent
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {Element} element
|
||
* @argument {Element} customContainer
|
||
* @returns {Boolean} answer to "isFixed?"
|
||
*/
|
||
function isFixed(element) {
|
||
var nodeName = element.nodeName;
|
||
if (nodeName === 'BODY' || nodeName === 'HTML') {
|
||
return false;
|
||
}
|
||
if (getStyleComputedProperty(element, 'position') === 'fixed') {
|
||
return true;
|
||
}
|
||
return isFixed(getParentNode(element));
|
||
}
|
||
|
||
/**
|
||
* Computed the boundaries limits and return them
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @param {HTMLElement} popper
|
||
* @param {HTMLElement} reference
|
||
* @param {number} padding
|
||
* @param {HTMLElement} boundariesElement - Element used to define the boundaries
|
||
* @returns {Object} Coordinates of the boundaries
|
||
*/
|
||
function getBoundaries(popper, reference, padding, boundariesElement) {
|
||
// NOTE: 1 DOM access here
|
||
var boundaries = { top: 0, left: 0 };
|
||
var offsetParent = findCommonOffsetParent(popper, reference);
|
||
|
||
// Handle viewport case
|
||
if (boundariesElement === 'viewport') {
|
||
boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent);
|
||
} else {
|
||
// Handle other cases based on DOM element used as boundaries
|
||
var boundariesNode = void 0;
|
||
if (boundariesElement === 'scrollParent') {
|
||
boundariesNode = getScrollParent(getParentNode(reference));
|
||
if (boundariesNode.nodeName === 'BODY') {
|
||
boundariesNode = popper.ownerDocument.documentElement;
|
||
}
|
||
} else if (boundariesElement === 'window') {
|
||
boundariesNode = popper.ownerDocument.documentElement;
|
||
} else {
|
||
boundariesNode = boundariesElement;
|
||
}
|
||
|
||
var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent);
|
||
|
||
// In case of HTML, we need a different computation
|
||
if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {
|
||
var _getWindowSizes = getWindowSizes(),
|
||
height = _getWindowSizes.height,
|
||
width = _getWindowSizes.width;
|
||
|
||
boundaries.top += offsets.top - offsets.marginTop;
|
||
boundaries.bottom = height + offsets.top;
|
||
boundaries.left += offsets.left - offsets.marginLeft;
|
||
boundaries.right = width + offsets.left;
|
||
} else {
|
||
// for all the other DOM elements, this one is good
|
||
boundaries = offsets;
|
||
}
|
||
}
|
||
|
||
// Add paddings
|
||
boundaries.left += padding;
|
||
boundaries.top += padding;
|
||
boundaries.right -= padding;
|
||
boundaries.bottom -= padding;
|
||
|
||
return boundaries;
|
||
}
|
||
|
||
function getArea(_ref) {
|
||
var width = _ref.width,
|
||
height = _ref.height;
|
||
|
||
return width * height;
|
||
}
|
||
|
||
/**
|
||
* Utility used to transform the `auto` placement to the placement with more
|
||
* available space.
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {Object} data - The data object generated by update method
|
||
* @argument {Object} options - Modifiers configuration and options
|
||
* @returns {Object} The data object, properly modified
|
||
*/
|
||
function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {
|
||
var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
|
||
|
||
if (placement.indexOf('auto') === -1) {
|
||
return placement;
|
||
}
|
||
|
||
var boundaries = getBoundaries(popper, reference, padding, boundariesElement);
|
||
|
||
var rects = {
|
||
top: {
|
||
width: boundaries.width,
|
||
height: refRect.top - boundaries.top
|
||
},
|
||
right: {
|
||
width: boundaries.right - refRect.right,
|
||
height: boundaries.height
|
||
},
|
||
bottom: {
|
||
width: boundaries.width,
|
||
height: boundaries.bottom - refRect.bottom
|
||
},
|
||
left: {
|
||
width: refRect.left - boundaries.left,
|
||
height: boundaries.height
|
||
}
|
||
};
|
||
|
||
var sortedAreas = Object.keys(rects).map(function (key) {
|
||
return _extends({
|
||
key: key
|
||
}, rects[key], {
|
||
area: getArea(rects[key])
|
||
});
|
||
}).sort(function (a, b) {
|
||
return b.area - a.area;
|
||
});
|
||
|
||
var filteredAreas = sortedAreas.filter(function (_ref2) {
|
||
var width = _ref2.width,
|
||
height = _ref2.height;
|
||
return width >= popper.clientWidth && height >= popper.clientHeight;
|
||
});
|
||
|
||
var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;
|
||
|
||
var variation = placement.split('-')[1];
|
||
|
||
return computedPlacement + (variation ? '-' + variation : '');
|
||
}
|
||
|
||
/**
|
||
* Get offsets to the reference element
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @param {Object} state
|
||
* @param {Element} popper - the popper element
|
||
* @param {Element} reference - the reference element (the popper will be relative to this)
|
||
* @returns {Object} An object containing the offsets which will be applied to the popper
|
||
*/
|
||
function getReferenceOffsets(state, popper, reference) {
|
||
var commonOffsetParent = findCommonOffsetParent(popper, reference);
|
||
return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent);
|
||
}
|
||
|
||
/**
|
||
* Get the outer sizes of the given element (offset size + margins)
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {Element} element
|
||
* @returns {Object} object containing width and height properties
|
||
*/
|
||
function getOuterSizes(element) {
|
||
var styles = getComputedStyle(element);
|
||
var x = parseFloat(styles.marginTop) + parseFloat(styles.marginBottom);
|
||
var y = parseFloat(styles.marginLeft) + parseFloat(styles.marginRight);
|
||
var result = {
|
||
width: element.offsetWidth + y,
|
||
height: element.offsetHeight + x
|
||
};
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* Get the opposite placement of the given one
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {String} placement
|
||
* @returns {String} flipped placement
|
||
*/
|
||
function getOppositePlacement(placement) {
|
||
var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };
|
||
return placement.replace(/left|right|bottom|top/g, function (matched) {
|
||
return hash[matched];
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Get offsets to the popper
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @param {Object} position - CSS position the Popper will get applied
|
||
* @param {HTMLElement} popper - the popper element
|
||
* @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)
|
||
* @param {String} placement - one of the valid placement options
|
||
* @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper
|
||
*/
|
||
function getPopperOffsets(popper, referenceOffsets, placement) {
|
||
placement = placement.split('-')[0];
|
||
|
||
// Get popper node sizes
|
||
var popperRect = getOuterSizes(popper);
|
||
|
||
// Add position, width and height to our offsets object
|
||
var popperOffsets = {
|
||
width: popperRect.width,
|
||
height: popperRect.height
|
||
};
|
||
|
||
// depending by the popper placement we have to compute its offsets slightly differently
|
||
var isHoriz = ['right', 'left'].indexOf(placement) !== -1;
|
||
var mainSide = isHoriz ? 'top' : 'left';
|
||
var secondarySide = isHoriz ? 'left' : 'top';
|
||
var measurement = isHoriz ? 'height' : 'width';
|
||
var secondaryMeasurement = !isHoriz ? 'height' : 'width';
|
||
|
||
popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;
|
||
if (placement === secondarySide) {
|
||
popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];
|
||
} else {
|
||
popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];
|
||
}
|
||
|
||
return popperOffsets;
|
||
}
|
||
|
||
/**
|
||
* Mimics the `find` method of Array
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {Array} arr
|
||
* @argument prop
|
||
* @argument value
|
||
* @returns index or -1
|
||
*/
|
||
function find(arr, check) {
|
||
// use native find if supported
|
||
if (Array.prototype.find) {
|
||
return arr.find(check);
|
||
}
|
||
|
||
// use `filter` to obtain the same behavior of `find`
|
||
return arr.filter(check)[0];
|
||
}
|
||
|
||
/**
|
||
* Return the index of the matching object
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {Array} arr
|
||
* @argument prop
|
||
* @argument value
|
||
* @returns index or -1
|
||
*/
|
||
function findIndex(arr, prop, value) {
|
||
// use native findIndex if supported
|
||
if (Array.prototype.findIndex) {
|
||
return arr.findIndex(function (cur) {
|
||
return cur[prop] === value;
|
||
});
|
||
}
|
||
|
||
// use `find` + `indexOf` if `findIndex` isn't supported
|
||
var match = find(arr, function (obj) {
|
||
return obj[prop] === value;
|
||
});
|
||
return arr.indexOf(match);
|
||
}
|
||
|
||
/**
|
||
* Loop trough the list of modifiers and run them in order,
|
||
* each of them will then edit the data object.
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @param {dataObject} data
|
||
* @param {Array} modifiers
|
||
* @param {String} ends - Optional modifier name used as stopper
|
||
* @returns {dataObject}
|
||
*/
|
||
function runModifiers(modifiers, data, ends) {
|
||
var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));
|
||
|
||
modifiersToRun.forEach(function (modifier) {
|
||
if (modifier['function']) {
|
||
// eslint-disable-line dot-notation
|
||
console.warn('`modifier.function` is deprecated, use `modifier.fn`!');
|
||
}
|
||
var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation
|
||
if (modifier.enabled && isFunction(fn)) {
|
||
// Add properties to offsets to make them a complete clientRect object
|
||
// we do this before each modifier to make sure the previous one doesn't
|
||
// mess with these values
|
||
data.offsets.popper = getClientRect(data.offsets.popper);
|
||
data.offsets.reference = getClientRect(data.offsets.reference);
|
||
|
||
data = fn(data, modifier);
|
||
}
|
||
});
|
||
|
||
return data;
|
||
}
|
||
|
||
/**
|
||
* Updates the position of the popper, computing the new offsets and applying
|
||
* the new style.<br />
|
||
* Prefer `scheduleUpdate` over `update` because of performance reasons.
|
||
* @method
|
||
* @memberof Popper
|
||
*/
|
||
function update() {
|
||
// if popper is destroyed, don't perform any further update
|
||
if (this.state.isDestroyed) {
|
||
return;
|
||
}
|
||
|
||
var data = {
|
||
instance: this,
|
||
styles: {},
|
||
arrowStyles: {},
|
||
attributes: {},
|
||
flipped: false,
|
||
offsets: {}
|
||
};
|
||
|
||
// compute reference element offsets
|
||
data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference);
|
||
|
||
// compute auto placement, store placement inside the data object,
|
||
// modifiers will be able to edit `placement` if needed
|
||
// and refer to originalPlacement to know the original value
|
||
data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);
|
||
|
||
// store the computed placement inside `originalPlacement`
|
||
data.originalPlacement = data.placement;
|
||
|
||
// compute the popper offsets
|
||
data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);
|
||
data.offsets.popper.position = 'absolute';
|
||
|
||
// run the modifiers
|
||
data = runModifiers(this.modifiers, data);
|
||
|
||
// the first `update` will call `onCreate` callback
|
||
// the other ones will call `onUpdate` callback
|
||
if (!this.state.isCreated) {
|
||
this.state.isCreated = true;
|
||
this.options.onCreate(data);
|
||
} else {
|
||
this.options.onUpdate(data);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Helper used to know if the given modifier is enabled.
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @returns {Boolean}
|
||
*/
|
||
function isModifierEnabled(modifiers, modifierName) {
|
||
return modifiers.some(function (_ref) {
|
||
var name = _ref.name,
|
||
enabled = _ref.enabled;
|
||
return enabled && name === modifierName;
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Get the prefixed supported property name
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {String} property (camelCase)
|
||
* @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)
|
||
*/
|
||
function getSupportedPropertyName(property) {
|
||
var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];
|
||
var upperProp = property.charAt(0).toUpperCase() + property.slice(1);
|
||
|
||
for (var i = 0; i < prefixes.length - 1; i++) {
|
||
var prefix = prefixes[i];
|
||
var toCheck = prefix ? '' + prefix + upperProp : property;
|
||
if (typeof document.body.style[toCheck] !== 'undefined') {
|
||
return toCheck;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* Destroy the popper
|
||
* @method
|
||
* @memberof Popper
|
||
*/
|
||
function destroy() {
|
||
this.state.isDestroyed = true;
|
||
|
||
// touch DOM only if `applyStyle` modifier is enabled
|
||
if (isModifierEnabled(this.modifiers, 'applyStyle')) {
|
||
this.popper.removeAttribute('x-placement');
|
||
this.popper.style.left = '';
|
||
this.popper.style.position = '';
|
||
this.popper.style.top = '';
|
||
this.popper.style[getSupportedPropertyName('transform')] = '';
|
||
}
|
||
|
||
this.disableEventListeners();
|
||
|
||
// remove the popper if user explicity asked for the deletion on destroy
|
||
// do not use `remove` because IE11 doesn't support it
|
||
if (this.options.removeOnDestroy) {
|
||
this.popper.parentNode.removeChild(this.popper);
|
||
}
|
||
return this;
|
||
}
|
||
|
||
/**
|
||
* Get the window associated with the element
|
||
* @argument {Element} element
|
||
* @returns {Window}
|
||
*/
|
||
function getWindow(element) {
|
||
var ownerDocument = element.ownerDocument;
|
||
return ownerDocument ? ownerDocument.defaultView : window;
|
||
}
|
||
|
||
function attachToScrollParents(scrollParent, event, callback, scrollParents) {
|
||
var isBody = scrollParent.nodeName === 'BODY';
|
||
var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;
|
||
target.addEventListener(event, callback, { passive: true });
|
||
|
||
if (!isBody) {
|
||
attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);
|
||
}
|
||
scrollParents.push(target);
|
||
}
|
||
|
||
/**
|
||
* Setup needed event listeners used to update the popper position
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @private
|
||
*/
|
||
function setupEventListeners(reference, options, state, updateBound) {
|
||
// Resize event listener on window
|
||
state.updateBound = updateBound;
|
||
getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });
|
||
|
||
// Scroll event listener on scroll parents
|
||
var scrollElement = getScrollParent(reference);
|
||
attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);
|
||
state.scrollElement = scrollElement;
|
||
state.eventsEnabled = true;
|
||
|
||
return state;
|
||
}
|
||
|
||
/**
|
||
* It will add resize/scroll events and start recalculating
|
||
* position of the popper element when they are triggered.
|
||
* @method
|
||
* @memberof Popper
|
||
*/
|
||
function enableEventListeners() {
|
||
if (!this.state.eventsEnabled) {
|
||
this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Remove event listeners used to update the popper position
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @private
|
||
*/
|
||
function removeEventListeners(reference, state) {
|
||
// Remove resize event listener on window
|
||
getWindow(reference).removeEventListener('resize', state.updateBound);
|
||
|
||
// Remove scroll event listener on scroll parents
|
||
state.scrollParents.forEach(function (target) {
|
||
target.removeEventListener('scroll', state.updateBound);
|
||
});
|
||
|
||
// Reset state
|
||
state.updateBound = null;
|
||
state.scrollParents = [];
|
||
state.scrollElement = null;
|
||
state.eventsEnabled = false;
|
||
return state;
|
||
}
|
||
|
||
/**
|
||
* It will remove resize/scroll events and won't recalculate popper position
|
||
* when they are triggered. It also won't trigger onUpdate callback anymore,
|
||
* unless you call `update` method manually.
|
||
* @method
|
||
* @memberof Popper
|
||
*/
|
||
function disableEventListeners() {
|
||
if (this.state.eventsEnabled) {
|
||
cancelAnimationFrame(this.scheduleUpdate);
|
||
this.state = removeEventListeners(this.reference, this.state);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Tells if a given input is a number
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @param {*} input to check
|
||
* @return {Boolean}
|
||
*/
|
||
function isNumeric(n) {
|
||
return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);
|
||
}
|
||
|
||
/**
|
||
* Set the style to the given popper
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {Element} element - Element to apply the style to
|
||
* @argument {Object} styles
|
||
* Object with a list of properties and values which will be applied to the element
|
||
*/
|
||
function setStyles(element, styles) {
|
||
Object.keys(styles).forEach(function (prop) {
|
||
var unit = '';
|
||
// add unit if the value is numeric and is one of the following
|
||
if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {
|
||
unit = 'px';
|
||
}
|
||
element.style[prop] = styles[prop] + unit;
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Set the attributes to the given popper
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {Element} element - Element to apply the attributes to
|
||
* @argument {Object} styles
|
||
* Object with a list of properties and values which will be applied to the element
|
||
*/
|
||
function setAttributes(element, attributes) {
|
||
Object.keys(attributes).forEach(function (prop) {
|
||
var value = attributes[prop];
|
||
if (value !== false) {
|
||
element.setAttribute(prop, attributes[prop]);
|
||
} else {
|
||
element.removeAttribute(prop);
|
||
}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* @function
|
||
* @memberof Modifiers
|
||
* @argument {Object} data - The data object generated by `update` method
|
||
* @argument {Object} data.styles - List of style properties - values to apply to popper element
|
||
* @argument {Object} data.attributes - List of attribute properties - values to apply to popper element
|
||
* @argument {Object} options - Modifiers configuration and options
|
||
* @returns {Object} The same data object
|
||
*/
|
||
function applyStyle(data) {
|
||
// any property present in `data.styles` will be applied to the popper,
|
||
// in this way we can make the 3rd party modifiers add custom styles to it
|
||
// Be aware, modifiers could override the properties defined in the previous
|
||
// lines of this modifier!
|
||
setStyles(data.instance.popper, data.styles);
|
||
|
||
// any property present in `data.attributes` will be applied to the popper,
|
||
// they will be set as HTML attributes of the element
|
||
setAttributes(data.instance.popper, data.attributes);
|
||
|
||
// if arrowElement is defined and arrowStyles has some properties
|
||
if (data.arrowElement && Object.keys(data.arrowStyles).length) {
|
||
setStyles(data.arrowElement, data.arrowStyles);
|
||
}
|
||
|
||
return data;
|
||
}
|
||
|
||
/**
|
||
* Set the x-placement attribute before everything else because it could be used
|
||
* to add margins to the popper margins needs to be calculated to get the
|
||
* correct popper offsets.
|
||
* @method
|
||
* @memberof Popper.modifiers
|
||
* @param {HTMLElement} reference - The reference element used to position the popper
|
||
* @param {HTMLElement} popper - The HTML element used as popper.
|
||
* @param {Object} options - Popper.js options
|
||
*/
|
||
function applyStyleOnLoad(reference, popper, options, modifierOptions, state) {
|
||
// compute reference element offsets
|
||
var referenceOffsets = getReferenceOffsets(state, popper, reference);
|
||
|
||
// compute auto placement, store placement inside the data object,
|
||
// modifiers will be able to edit `placement` if needed
|
||
// and refer to originalPlacement to know the original value
|
||
var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);
|
||
|
||
popper.setAttribute('x-placement', placement);
|
||
|
||
// Apply `position` to popper before anything else because
|
||
// without the position applied we can't guarantee correct computations
|
||
setStyles(popper, { position: 'absolute' });
|
||
|
||
return options;
|
||
}
|
||
|
||
/**
|
||
* @function
|
||
* @memberof Modifiers
|
||
* @argument {Object} data - The data object generated by `update` method
|
||
* @argument {Object} options - Modifiers configuration and options
|
||
* @returns {Object} The data object, properly modified
|
||
*/
|
||
function computeStyle(data, options) {
|
||
var x = options.x,
|
||
y = options.y;
|
||
var popper = data.offsets.popper;
|
||
|
||
// Remove this legacy support in Popper.js v2
|
||
|
||
var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) {
|
||
return modifier.name === 'applyStyle';
|
||
}).gpuAcceleration;
|
||
if (legacyGpuAccelerationOption !== undefined) {
|
||
console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');
|
||
}
|
||
var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration;
|
||
|
||
var offsetParent = getOffsetParent(data.instance.popper);
|
||
var offsetParentRect = getBoundingClientRect(offsetParent);
|
||
|
||
// Styles
|
||
var styles = {
|
||
position: popper.position
|
||
};
|
||
|
||
// floor sides to avoid blurry text
|
||
var offsets = {
|
||
left: Math.floor(popper.left),
|
||
top: Math.floor(popper.top),
|
||
bottom: Math.floor(popper.bottom),
|
||
right: Math.floor(popper.right)
|
||
};
|
||
|
||
var sideA = x === 'bottom' ? 'top' : 'bottom';
|
||
var sideB = y === 'right' ? 'left' : 'right';
|
||
|
||
// if gpuAcceleration is set to `true` and transform is supported,
|
||
// we use `translate3d` to apply the position to the popper we
|
||
// automatically use the supported prefixed version if needed
|
||
var prefixedProperty = getSupportedPropertyName('transform');
|
||
|
||
// now, let's make a step back and look at this code closely (wtf?)
|
||
// If the content of the popper grows once it's been positioned, it
|
||
// may happen that the popper gets misplaced because of the new content
|
||
// overflowing its reference element
|
||
// To avoid this problem, we provide two options (x and y), which allow
|
||
// the consumer to define the offset origin.
|
||
// If we position a popper on top of a reference element, we can set
|
||
// `x` to `top` to make the popper grow towards its top instead of
|
||
// its bottom.
|
||
var left = void 0,
|
||
top = void 0;
|
||
if (sideA === 'bottom') {
|
||
top = -offsetParentRect.height + offsets.bottom;
|
||
} else {
|
||
top = offsets.top;
|
||
}
|
||
if (sideB === 'right') {
|
||
left = -offsetParentRect.width + offsets.right;
|
||
} else {
|
||
left = offsets.left;
|
||
}
|
||
if (gpuAcceleration && prefixedProperty) {
|
||
styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)';
|
||
styles[sideA] = 0;
|
||
styles[sideB] = 0;
|
||
styles.willChange = 'transform';
|
||
} else {
|
||
// othwerise, we use the standard `top`, `left`, `bottom` and `right` properties
|
||
var invertTop = sideA === 'bottom' ? -1 : 1;
|
||
var invertLeft = sideB === 'right' ? -1 : 1;
|
||
styles[sideA] = top * invertTop;
|
||
styles[sideB] = left * invertLeft;
|
||
styles.willChange = sideA + ', ' + sideB;
|
||
}
|
||
|
||
// Attributes
|
||
var attributes = {
|
||
'x-placement': data.placement
|
||
};
|
||
|
||
// Update `data` attributes, styles and arrowStyles
|
||
data.attributes = _extends({}, attributes, data.attributes);
|
||
data.styles = _extends({}, styles, data.styles);
|
||
data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles);
|
||
|
||
return data;
|
||
}
|
||
|
||
/**
|
||
* Helper used to know if the given modifier depends from another one.<br />
|
||
* It checks if the needed modifier is listed and enabled.
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @param {Array} modifiers - list of modifiers
|
||
* @param {String} requestingName - name of requesting modifier
|
||
* @param {String} requestedName - name of requested modifier
|
||
* @returns {Boolean}
|
||
*/
|
||
function isModifierRequired(modifiers, requestingName, requestedName) {
|
||
var requesting = find(modifiers, function (_ref) {
|
||
var name = _ref.name;
|
||
return name === requestingName;
|
||
});
|
||
|
||
var isRequired = !!requesting && modifiers.some(function (modifier) {
|
||
return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;
|
||
});
|
||
|
||
if (!isRequired) {
|
||
var _requesting = '`' + requestingName + '`';
|
||
var requested = '`' + requestedName + '`';
|
||
console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!');
|
||
}
|
||
return isRequired;
|
||
}
|
||
|
||
/**
|
||
* @function
|
||
* @memberof Modifiers
|
||
* @argument {Object} data - The data object generated by update method
|
||
* @argument {Object} options - Modifiers configuration and options
|
||
* @returns {Object} The data object, properly modified
|
||
*/
|
||
function arrow(data, options) {
|
||
var _data$offsets$arrow;
|
||
|
||
// arrow depends on keepTogether in order to work
|
||
if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {
|
||
return data;
|
||
}
|
||
|
||
var arrowElement = options.element;
|
||
|
||
// if arrowElement is a string, suppose it's a CSS selector
|
||
if (typeof arrowElement === 'string') {
|
||
arrowElement = data.instance.popper.querySelector(arrowElement);
|
||
|
||
// if arrowElement is not found, don't run the modifier
|
||
if (!arrowElement) {
|
||
return data;
|
||
}
|
||
} else {
|
||
// if the arrowElement isn't a query selector we must check that the
|
||
// provided DOM node is child of its popper node
|
||
if (!data.instance.popper.contains(arrowElement)) {
|
||
console.warn('WARNING: `arrow.element` must be child of its popper element!');
|
||
return data;
|
||
}
|
||
}
|
||
|
||
var placement = data.placement.split('-')[0];
|
||
var _data$offsets = data.offsets,
|
||
popper = _data$offsets.popper,
|
||
reference = _data$offsets.reference;
|
||
|
||
var isVertical = ['left', 'right'].indexOf(placement) !== -1;
|
||
|
||
var len = isVertical ? 'height' : 'width';
|
||
var sideCapitalized = isVertical ? 'Top' : 'Left';
|
||
var side = sideCapitalized.toLowerCase();
|
||
var altSide = isVertical ? 'left' : 'top';
|
||
var opSide = isVertical ? 'bottom' : 'right';
|
||
var arrowElementSize = getOuterSizes(arrowElement)[len];
|
||
|
||
//
|
||
// extends keepTogether behavior making sure the popper and its
|
||
// reference have enough pixels in conjuction
|
||
//
|
||
|
||
// top/left side
|
||
if (reference[opSide] - arrowElementSize < popper[side]) {
|
||
data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize);
|
||
}
|
||
// bottom/right side
|
||
if (reference[side] + arrowElementSize > popper[opSide]) {
|
||
data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide];
|
||
}
|
||
data.offsets.popper = getClientRect(data.offsets.popper);
|
||
|
||
// compute center of the popper
|
||
var center = reference[side] + reference[len] / 2 - arrowElementSize / 2;
|
||
|
||
// Compute the sideValue using the updated popper offsets
|
||
// take popper margin in account because we don't have this info available
|
||
var css = getStyleComputedProperty(data.instance.popper);
|
||
var popperMarginSide = parseFloat(css['margin' + sideCapitalized], 10);
|
||
var popperBorderSide = parseFloat(css['border' + sideCapitalized + 'Width'], 10);
|
||
var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide;
|
||
|
||
// prevent arrowElement from being placed not contiguously to its popper
|
||
sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0);
|
||
|
||
data.arrowElement = arrowElement;
|
||
data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ''), _data$offsets$arrow);
|
||
|
||
return data;
|
||
}
|
||
|
||
/**
|
||
* Get the opposite placement variation of the given one
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {String} placement variation
|
||
* @returns {String} flipped placement variation
|
||
*/
|
||
function getOppositeVariation(variation) {
|
||
if (variation === 'end') {
|
||
return 'start';
|
||
} else if (variation === 'start') {
|
||
return 'end';
|
||
}
|
||
return variation;
|
||
}
|
||
|
||
/**
|
||
* List of accepted placements to use as values of the `placement` option.<br />
|
||
* Valid placements are:
|
||
* - `auto`
|
||
* - `top`
|
||
* - `right`
|
||
* - `bottom`
|
||
* - `left`
|
||
*
|
||
* Each placement can have a variation from this list:
|
||
* - `-start`
|
||
* - `-end`
|
||
*
|
||
* Variations are interpreted easily if you think of them as the left to right
|
||
* written languages. Horizontally (`top` and `bottom`), `start` is left and `end`
|
||
* is right.<br />
|
||
* Vertically (`left` and `right`), `start` is top and `end` is bottom.
|
||
*
|
||
* Some valid examples are:
|
||
* - `top-end` (on top of reference, right aligned)
|
||
* - `right-start` (on right of reference, top aligned)
|
||
* - `bottom` (on bottom, centered)
|
||
* - `auto-right` (on the side with more space available, alignment depends by placement)
|
||
*
|
||
* @static
|
||
* @type {Array}
|
||
* @enum {String}
|
||
* @readonly
|
||
* @method placements
|
||
* @memberof Popper
|
||
*/
|
||
var placements = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start'];
|
||
|
||
// Get rid of `auto` `auto-start` and `auto-end`
|
||
var validPlacements = placements.slice(3);
|
||
|
||
/**
|
||
* Given an initial placement, returns all the subsequent placements
|
||
* clockwise (or counter-clockwise).
|
||
*
|
||
* @method
|
||
* @memberof Popper.Utils
|
||
* @argument {String} placement - A valid placement (it accepts variations)
|
||
* @argument {Boolean} counter - Set to true to walk the placements counterclockwise
|
||
* @returns {Array} placements including their variations
|
||
*/
|
||
function clockwise(placement) {
|
||
var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
||
|
||
var index = validPlacements.indexOf(placement);
|
||
var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index));
|
||
return counter ? arr.reverse() : arr;
|
||
}
|
||
|
||
var BEHAVIORS = {
|
||
FLIP: 'flip',
|
||
CLOCKWISE: 'clockwise',
|
||
COUNTERCLOCKWISE: 'counterclockwise'
|
||
};
|
||
|
||
/**
|
||
* @function
|
||
* @memberof Modifiers
|
||
* @argument {Object} data - The data object generated by update method
|
||
* @argument {Object} options - Modifiers configuration and options
|
||
* @returns {Object} The data object, properly modified
|
||
*/
|
||
function flip(data, options) {
|
||
// if `inner` modifier is enabled, we can't use the `flip` modifier
|
||
if (isModifierEnabled(data.instance.modifiers, 'inner')) {
|
||
return data;
|
||
}
|
||
|
||
if (data.flipped && data.placement === data.originalPlacement) {
|
||
// seems like flip is trying to loop, probably there's not enough space on any of the flippable sides
|
||
return data;
|
||
}
|
||
|
||
var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement);
|
||
|
||
var placement = data.placement.split('-')[0];
|
||
var placementOpposite = getOppositePlacement(placement);
|
||
var variation = data.placement.split('-')[1] || '';
|
||
|
||
var flipOrder = [];
|
||
|
||
switch (options.behavior) {
|
||
case BEHAVIORS.FLIP:
|
||
flipOrder = [placement, placementOpposite];
|
||
break;
|
||
case BEHAVIORS.CLOCKWISE:
|
||
flipOrder = clockwise(placement);
|
||
break;
|
||
case BEHAVIORS.COUNTERCLOCKWISE:
|
||
flipOrder = clockwise(placement, true);
|
||
break;
|
||
default:
|
||
flipOrder = options.behavior;
|
||
}
|
||
|
||
flipOrder.forEach(function (step, index) {
|
||
if (placement !== step || flipOrder.length === index + 1) {
|
||
return data;
|
||
}
|
||
|
||
placement = data.placement.split('-')[0];
|
||
placementOpposite = getOppositePlacement(placement);
|
||
|
||
var popperOffsets = data.offsets.popper;
|
||
var refOffsets = data.offsets.reference;
|
||
|
||
// using floor because the reference offsets may contain decimals we are not going to consider here
|
||
var floor = Math.floor;
|
||
var overlapsRef = placement === 'left' && floor(popperOffsets.right) > floor(refOffsets.left) || placement === 'right' && floor(popperOffsets.left) < floor(refOffsets.right) || placement === 'top' && floor(popperOffsets.bottom) > floor(refOffsets.top) || placement === 'bottom' && floor(popperOffsets.top) < floor(refOffsets.bottom);
|
||
|
||
var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);
|
||
var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);
|
||
var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);
|
||
var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom);
|
||
|
||
var overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom;
|
||
|
||
// flip the variation if required
|
||
var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
|
||
var flippedVariation = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom);
|
||
|
||
if (overlapsRef || overflowsBoundaries || flippedVariation) {
|
||
// this boolean to detect any flip loop
|
||
data.flipped = true;
|
||
|
||
if (overlapsRef || overflowsBoundaries) {
|
||
placement = flipOrder[index + 1];
|
||
}
|
||
|
||
if (flippedVariation) {
|
||
variation = getOppositeVariation(variation);
|
||
}
|
||
|
||
data.placement = placement + (variation ? '-' + variation : '');
|
||
|
||
// this object contains `position`, we want to preserve it along with
|
||
// any additional property we may add in the future
|
||
data.offsets.popper = _extends({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement));
|
||
|
||
data = runModifiers(data.instance.modifiers, data, 'flip');
|
||
}
|
||
});
|
||
return data;
|
||
}
|
||
|
||
/**
|
||
* @function
|
||
* @memberof Modifiers
|
||
* @argument {Object} data - The data object generated by update method
|
||
* @argument {Object} options - Modifiers configuration and options
|
||
* @returns {Object} The data object, properly modified
|
||
*/
|
||
function keepTogether(data) {
|
||
var _data$offsets = data.offsets,
|
||
popper = _data$offsets.popper,
|
||
reference = _data$offsets.reference;
|
||
|
||
var placement = data.placement.split('-')[0];
|
||
var floor = Math.floor;
|
||
var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
|
||
var side = isVertical ? 'right' : 'bottom';
|
||
var opSide = isVertical ? 'left' : 'top';
|
||
var measurement = isVertical ? 'width' : 'height';
|
||
|
||
if (popper[side] < floor(reference[opSide])) {
|
||
data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement];
|
||
}
|
||
if (popper[opSide] > floor(reference[side])) {
|
||
data.offsets.popper[opSide] = floor(reference[side]);
|
||
}
|
||
|
||
return data;
|
||
}
|
||
|
||
/**
|
||
* Converts a string containing value + unit into a px value number
|
||
* @function
|
||
* @memberof {modifiers~offset}
|
||
* @private
|
||
* @argument {String} str - Value + unit string
|
||
* @argument {String} measurement - `height` or `width`
|
||
* @argument {Object} popperOffsets
|
||
* @argument {Object} referenceOffsets
|
||
* @returns {Number|String}
|
||
* Value in pixels, or original string if no values were extracted
|
||
*/
|
||
function toValue(str, measurement, popperOffsets, referenceOffsets) {
|
||
// separate value from unit
|
||
var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/);
|
||
var value = +split[1];
|
||
var unit = split[2];
|
||
|
||
// If it's not a number it's an operator, I guess
|
||
if (!value) {
|
||
return str;
|
||
}
|
||
|
||
if (unit.indexOf('%') === 0) {
|
||
var element = void 0;
|
||
switch (unit) {
|
||
case '%p':
|
||
element = popperOffsets;
|
||
break;
|
||
case '%':
|
||
case '%r':
|
||
default:
|
||
element = referenceOffsets;
|
||
}
|
||
|
||
var rect = getClientRect(element);
|
||
return rect[measurement] / 100 * value;
|
||
} else if (unit === 'vh' || unit === 'vw') {
|
||
// if is a vh or vw, we calculate the size based on the viewport
|
||
var size = void 0;
|
||
if (unit === 'vh') {
|
||
size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
|
||
} else {
|
||
size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
|
||
}
|
||
return size / 100 * value;
|
||
} else {
|
||
// if is an explicit pixel unit, we get rid of the unit and keep the value
|
||
// if is an implicit unit, it's px, and we return just the value
|
||
return value;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Parse an `offset` string to extrapolate `x` and `y` numeric offsets.
|
||
* @function
|
||
* @memberof {modifiers~offset}
|
||
* @private
|
||
* @argument {String} offset
|
||
* @argument {Object} popperOffsets
|
||
* @argument {Object} referenceOffsets
|
||
* @argument {String} basePlacement
|
||
* @returns {Array} a two cells array with x and y offsets in numbers
|
||
*/
|
||
function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {
|
||
var offsets = [0, 0];
|
||
|
||
// Use height if placement is left or right and index is 0 otherwise use width
|
||
// in this way the first offset will use an axis and the second one
|
||
// will use the other one
|
||
var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1;
|
||
|
||
// Split the offset string to obtain a list of values and operands
|
||
// The regex addresses values with the plus or minus sign in front (+10, -20, etc)
|
||
var fragments = offset.split(/(\+|\-)/).map(function (frag) {
|
||
return frag.trim();
|
||
});
|
||
|
||
// Detect if the offset string contains a pair of values or a single one
|
||
// they could be separated by comma or space
|
||
var divider = fragments.indexOf(find(fragments, function (frag) {
|
||
return frag.search(/,|\s/) !== -1;
|
||
}));
|
||
|
||
if (fragments[divider] && fragments[divider].indexOf(',') === -1) {
|
||
console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.');
|
||
}
|
||
|
||
// If divider is found, we divide the list of values and operands to divide
|
||
// them by ofset X and Y.
|
||
var splitRegex = /\s*,\s*|\s+/;
|
||
var ops = divider !== -1 ? [fragments.slice(0, divider).concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat(fragments.slice(divider + 1))] : [fragments];
|
||
|
||
// Convert the values with units to absolute pixels to allow our computations
|
||
ops = ops.map(function (op, index) {
|
||
// Most of the units rely on the orientation of the popper
|
||
var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width';
|
||
var mergeWithPrevious = false;
|
||
return op
|
||
// This aggregates any `+` or `-` sign that aren't considered operators
|
||
// e.g.: 10 + +5 => [10, +, +5]
|
||
.reduce(function (a, b) {
|
||
if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) {
|
||
a[a.length - 1] = b;
|
||
mergeWithPrevious = true;
|
||
return a;
|
||
} else if (mergeWithPrevious) {
|
||
a[a.length - 1] += b;
|
||
mergeWithPrevious = false;
|
||
return a;
|
||
} else {
|
||
return a.concat(b);
|
||
}
|
||
}, [])
|
||
// Here we convert the string values into number values (in px)
|
||
.map(function (str) {
|
||
return toValue(str, measurement, popperOffsets, referenceOffsets);
|
||
});
|
||
});
|
||
|
||
// Loop trough the offsets arrays and execute the operations
|
||
ops.forEach(function (op, index) {
|
||
op.forEach(function (frag, index2) {
|
||
if (isNumeric(frag)) {
|
||
offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1);
|
||
}
|
||
});
|
||
});
|
||
return offsets;
|
||
}
|
||
|
||
/**
|
||
* @function
|
||
* @memberof Modifiers
|
||
* @argument {Object} data - The data object generated by update method
|
||
* @argument {Object} options - Modifiers configuration and options
|
||
* @argument {Number|String} options.offset=0
|
||
* The offset value as described in the modifier description
|
||
* @returns {Object} The data object, properly modified
|
||
*/
|
||
function offset(data, _ref) {
|
||
var offset = _ref.offset;
|
||
var placement = data.placement,
|
||
_data$offsets = data.offsets,
|
||
popper = _data$offsets.popper,
|
||
reference = _data$offsets.reference;
|
||
|
||
var basePlacement = placement.split('-')[0];
|
||
|
||
var offsets = void 0;
|
||
if (isNumeric(+offset)) {
|
||
offsets = [+offset, 0];
|
||
} else {
|
||
offsets = parseOffset(offset, popper, reference, basePlacement);
|
||
}
|
||
|
||
if (basePlacement === 'left') {
|
||
popper.top += offsets[0];
|
||
popper.left -= offsets[1];
|
||
} else if (basePlacement === 'right') {
|
||
popper.top += offsets[0];
|
||
popper.left += offsets[1];
|
||
} else if (basePlacement === 'top') {
|
||
popper.left += offsets[0];
|
||
popper.top -= offsets[1];
|
||
} else if (basePlacement === 'bottom') {
|
||
popper.left += offsets[0];
|
||
popper.top += offsets[1];
|
||
}
|
||
|
||
data.popper = popper;
|
||
return data;
|
||
}
|
||
|
||
/**
|
||
* @function
|
||
* @memberof Modifiers
|
||
* @argument {Object} data - The data object generated by `update` method
|
||
* @argument {Object} options - Modifiers configuration and options
|
||
* @returns {Object} The data object, properly modified
|
||
*/
|
||
function preventOverflow(data, options) {
|
||
var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);
|
||
|
||
// If offsetParent is the reference element, we really want to
|
||
// go one step up and use the next offsetParent as reference to
|
||
// avoid to make this modifier completely useless and look like broken
|
||
if (data.instance.reference === boundariesElement) {
|
||
boundariesElement = getOffsetParent(boundariesElement);
|
||
}
|
||
|
||
var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement);
|
||
options.boundaries = boundaries;
|
||
|
||
var order = options.priority;
|
||
var popper = data.offsets.popper;
|
||
|
||
var check = {
|
||
primary: function primary(placement) {
|
||
var value = popper[placement];
|
||
if (popper[placement] < boundaries[placement] && !options.escapeWithReference) {
|
||
value = Math.max(popper[placement], boundaries[placement]);
|
||
}
|
||
return defineProperty({}, placement, value);
|
||
},
|
||
secondary: function secondary(placement) {
|
||
var mainSide = placement === 'right' ? 'left' : 'top';
|
||
var value = popper[mainSide];
|
||
if (popper[placement] > boundaries[placement] && !options.escapeWithReference) {
|
||
value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height));
|
||
}
|
||
return defineProperty({}, mainSide, value);
|
||
}
|
||
};
|
||
|
||
order.forEach(function (placement) {
|
||
var side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary';
|
||
popper = _extends({}, popper, check[side](placement));
|
||
});
|
||
|
||
data.offsets.popper = popper;
|
||
|
||
return data;
|
||
}
|
||
|
||
/**
|
||
* @function
|
||
* @memberof Modifiers
|
||
* @argument {Object} data - The data object generated by `update` method
|
||
* @argument {Object} options - Modifiers configuration and options
|
||
* @returns {Object} The data object, properly modified
|
||
*/
|
||
function shift(data) {
|
||
var placement = data.placement;
|
||
var basePlacement = placement.split('-')[0];
|
||
var shiftvariation = placement.split('-')[1];
|
||
|
||
// if shift shiftvariation is specified, run the modifier
|
||
if (shiftvariation) {
|
||
var _data$offsets = data.offsets,
|
||
reference = _data$offsets.reference,
|
||
popper = _data$offsets.popper;
|
||
|
||
var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;
|
||
var side = isVertical ? 'left' : 'top';
|
||
var measurement = isVertical ? 'width' : 'height';
|
||
|
||
var shiftOffsets = {
|
||
start: defineProperty({}, side, reference[side]),
|
||
end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement])
|
||
};
|
||
|
||
data.offsets.popper = _extends({}, popper, shiftOffsets[shiftvariation]);
|
||
}
|
||
|
||
return data;
|
||
}
|
||
|
||
/**
|
||
* @function
|
||
* @memberof Modifiers
|
||
* @argument {Object} data - The data object generated by update method
|
||
* @argument {Object} options - Modifiers configuration and options
|
||
* @returns {Object} The data object, properly modified
|
||
*/
|
||
function hide(data) {
|
||
if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {
|
||
return data;
|
||
}
|
||
|
||
var refRect = data.offsets.reference;
|
||
var bound = find(data.instance.modifiers, function (modifier) {
|
||
return modifier.name === 'preventOverflow';
|
||
}).boundaries;
|
||
|
||
if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) {
|
||
// Avoid unnecessary DOM access if visibility hasn't changed
|
||
if (data.hide === true) {
|
||
return data;
|
||
}
|
||
|
||
data.hide = true;
|
||
data.attributes['x-out-of-boundaries'] = '';
|
||
} else {
|
||
// Avoid unnecessary DOM access if visibility hasn't changed
|
||
if (data.hide === false) {
|
||
return data;
|
||
}
|
||
|
||
data.hide = false;
|
||
data.attributes['x-out-of-boundaries'] = false;
|
||
}
|
||
|
||
return data;
|
||
}
|
||
|
||
/**
|
||
* @function
|
||
* @memberof Modifiers
|
||
* @argument {Object} data - The data object generated by `update` method
|
||
* @argument {Object} options - Modifiers configuration and options
|
||
* @returns {Object} The data object, properly modified
|
||
*/
|
||
function inner(data) {
|
||
var placement = data.placement;
|
||
var basePlacement = placement.split('-')[0];
|
||
var _data$offsets = data.offsets,
|
||
popper = _data$offsets.popper,
|
||
reference = _data$offsets.reference;
|
||
|
||
var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;
|
||
|
||
var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;
|
||
|
||
popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);
|
||
|
||
data.placement = getOppositePlacement(placement);
|
||
data.offsets.popper = getClientRect(popper);
|
||
|
||
return data;
|
||
}
|
||
|
||
/**
|
||
* Modifier function, each modifier can have a function of this type assigned
|
||
* to its `fn` property.<br />
|
||
* These functions will be called on each update, this means that you must
|
||
* make sure they are performant enough to avoid performance bottlenecks.
|
||
*
|
||
* @function ModifierFn
|
||
* @argument {dataObject} data - The data object generated by `update` method
|
||
* @argument {Object} options - Modifiers configuration and options
|
||
* @returns {dataObject} The data object, properly modified
|
||
*/
|
||
|
||
/**
|
||
* Modifiers are plugins used to alter the behavior of your poppers.<br />
|
||
* Popper.js uses a set of 9 modifiers to provide all the basic functionalities
|
||
* needed by the library.
|
||
*
|
||
* Usually you don't want to override the `order`, `fn` and `onLoad` props.
|
||
* All the other properties are configurations that could be tweaked.
|
||
* @namespace modifiers
|
||
*/
|
||
var modifiers = {
|
||
/**
|
||
* Modifier used to shift the popper on the start or end of its reference
|
||
* element.<br />
|
||
* It will read the variation of the `placement` property.<br />
|
||
* It can be one either `-end` or `-start`.
|
||
* @memberof modifiers
|
||
* @inner
|
||
*/
|
||
shift: {
|
||
/** @prop {number} order=100 - Index used to define the order of execution */
|
||
order: 100,
|
||
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
||
enabled: true,
|
||
/** @prop {ModifierFn} */
|
||
fn: shift
|
||
},
|
||
|
||
/**
|
||
* The `offset` modifier can shift your popper on both its axis.
|
||
*
|
||
* It accepts the following units:
|
||
* - `px` or unitless, interpreted as pixels
|
||
* - `%` or `%r`, percentage relative to the length of the reference element
|
||
* - `%p`, percentage relative to the length of the popper element
|
||
* - `vw`, CSS viewport width unit
|
||
* - `vh`, CSS viewport height unit
|
||
*
|
||
* For length is intended the main axis relative to the placement of the popper.<br />
|
||
* This means that if the placement is `top` or `bottom`, the length will be the
|
||
* `width`. In case of `left` or `right`, it will be the height.
|
||
*
|
||
* You can provide a single value (as `Number` or `String`), or a pair of values
|
||
* as `String` divided by a comma or one (or more) white spaces.<br />
|
||
* The latter is a deprecated method because it leads to confusion and will be
|
||
* removed in v2.<br />
|
||
* Additionally, it accepts additions and subtractions between different units.
|
||
* Note that multiplications and divisions aren't supported.
|
||
*
|
||
* Valid examples are:
|
||
* ```
|
||
* 10
|
||
* '10%'
|
||
* '10, 10'
|
||
* '10%, 10'
|
||
* '10 + 10%'
|
||
* '10 - 5vh + 3%'
|
||
* '-10px + 5vh, 5px - 6%'
|
||
* ```
|
||
* > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap
|
||
* > with their reference element, unfortunately, you will have to disable the `flip` modifier.
|
||
* > More on this [reading this issue](https://github.com/FezVrasta/popper.js/issues/373)
|
||
*
|
||
* @memberof modifiers
|
||
* @inner
|
||
*/
|
||
offset: {
|
||
/** @prop {number} order=200 - Index used to define the order of execution */
|
||
order: 200,
|
||
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
||
enabled: true,
|
||
/** @prop {ModifierFn} */
|
||
fn: offset,
|
||
/** @prop {Number|String} offset=0
|
||
* The offset value as described in the modifier description
|
||
*/
|
||
offset: 0
|
||
},
|
||
|
||
/**
|
||
* Modifier used to prevent the popper from being positioned outside the boundary.
|
||
*
|
||
* An scenario exists where the reference itself is not within the boundaries.<br />
|
||
* We can say it has "escaped the boundaries" — or just "escaped".<br />
|
||
* In this case we need to decide whether the popper should either:
|
||
*
|
||
* - detach from the reference and remain "trapped" in the boundaries, or
|
||
* - if it should ignore the boundary and "escape with its reference"
|
||
*
|
||
* When `escapeWithReference` is set to`true` and reference is completely
|
||
* outside its boundaries, the popper will overflow (or completely leave)
|
||
* the boundaries in order to remain attached to the edge of the reference.
|
||
*
|
||
* @memberof modifiers
|
||
* @inner
|
||
*/
|
||
preventOverflow: {
|
||
/** @prop {number} order=300 - Index used to define the order of execution */
|
||
order: 300,
|
||
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
||
enabled: true,
|
||
/** @prop {ModifierFn} */
|
||
fn: preventOverflow,
|
||
/**
|
||
* @prop {Array} [priority=['left','right','top','bottom']]
|
||
* Popper will try to prevent overflow following these priorities by default,
|
||
* then, it could overflow on the left and on top of the `boundariesElement`
|
||
*/
|
||
priority: ['left', 'right', 'top', 'bottom'],
|
||
/**
|
||
* @prop {number} padding=5
|
||
* Amount of pixel used to define a minimum distance between the boundaries
|
||
* and the popper this makes sure the popper has always a little padding
|
||
* between the edges of its container
|
||
*/
|
||
padding: 5,
|
||
/**
|
||
* @prop {String|HTMLElement} boundariesElement='scrollParent'
|
||
* Boundaries used by the modifier, can be `scrollParent`, `window`,
|
||
* `viewport` or any DOM element.
|
||
*/
|
||
boundariesElement: 'scrollParent'
|
||
},
|
||
|
||
/**
|
||
* Modifier used to make sure the reference and its popper stay near eachothers
|
||
* without leaving any gap between the two. Expecially useful when the arrow is
|
||
* enabled and you want to assure it to point to its reference element.
|
||
* It cares only about the first axis, you can still have poppers with margin
|
||
* between the popper and its reference element.
|
||
* @memberof modifiers
|
||
* @inner
|
||
*/
|
||
keepTogether: {
|
||
/** @prop {number} order=400 - Index used to define the order of execution */
|
||
order: 400,
|
||
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
||
enabled: true,
|
||
/** @prop {ModifierFn} */
|
||
fn: keepTogether
|
||
},
|
||
|
||
/**
|
||
* This modifier is used to move the `arrowElement` of the popper to make
|
||
* sure it is positioned between the reference element and its popper element.
|
||
* It will read the outer size of the `arrowElement` node to detect how many
|
||
* pixels of conjuction are needed.
|
||
*
|
||
* It has no effect if no `arrowElement` is provided.
|
||
* @memberof modifiers
|
||
* @inner
|
||
*/
|
||
arrow: {
|
||
/** @prop {number} order=500 - Index used to define the order of execution */
|
||
order: 500,
|
||
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
||
enabled: true,
|
||
/** @prop {ModifierFn} */
|
||
fn: arrow,
|
||
/** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */
|
||
element: '[x-arrow]'
|
||
},
|
||
|
||
/**
|
||
* Modifier used to flip the popper's placement when it starts to overlap its
|
||
* reference element.
|
||
*
|
||
* Requires the `preventOverflow` modifier before it in order to work.
|
||
*
|
||
* **NOTE:** this modifier will interrupt the current update cycle and will
|
||
* restart it if it detects the need to flip the placement.
|
||
* @memberof modifiers
|
||
* @inner
|
||
*/
|
||
flip: {
|
||
/** @prop {number} order=600 - Index used to define the order of execution */
|
||
order: 600,
|
||
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
||
enabled: true,
|
||
/** @prop {ModifierFn} */
|
||
fn: flip,
|
||
/**
|
||
* @prop {String|Array} behavior='flip'
|
||
* The behavior used to change the popper's placement. It can be one of
|
||
* `flip`, `clockwise`, `counterclockwise` or an array with a list of valid
|
||
* placements (with optional variations).
|
||
*/
|
||
behavior: 'flip',
|
||
/**
|
||
* @prop {number} padding=5
|
||
* The popper will flip if it hits the edges of the `boundariesElement`
|
||
*/
|
||
padding: 5,
|
||
/**
|
||
* @prop {String|HTMLElement} boundariesElement='viewport'
|
||
* The element which will define the boundaries of the popper position,
|
||
* the popper will never be placed outside of the defined boundaries
|
||
* (except if keepTogether is enabled)
|
||
*/
|
||
boundariesElement: 'viewport'
|
||
},
|
||
|
||
/**
|
||
* Modifier used to make the popper flow toward the inner of the reference element.
|
||
* By default, when this modifier is disabled, the popper will be placed outside
|
||
* the reference element.
|
||
* @memberof modifiers
|
||
* @inner
|
||
*/
|
||
inner: {
|
||
/** @prop {number} order=700 - Index used to define the order of execution */
|
||
order: 700,
|
||
/** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */
|
||
enabled: false,
|
||
/** @prop {ModifierFn} */
|
||
fn: inner
|
||
},
|
||
|
||
/**
|
||
* Modifier used to hide the popper when its reference element is outside of the
|
||
* popper boundaries. It will set a `x-out-of-boundaries` attribute which can
|
||
* be used to hide with a CSS selector the popper when its reference is
|
||
* out of boundaries.
|
||
*
|
||
* Requires the `preventOverflow` modifier before it in order to work.
|
||
* @memberof modifiers
|
||
* @inner
|
||
*/
|
||
hide: {
|
||
/** @prop {number} order=800 - Index used to define the order of execution */
|
||
order: 800,
|
||
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
||
enabled: true,
|
||
/** @prop {ModifierFn} */
|
||
fn: hide
|
||
},
|
||
|
||
/**
|
||
* Computes the style that will be applied to the popper element to gets
|
||
* properly positioned.
|
||
*
|
||
* Note that this modifier will not touch the DOM, it just prepares the styles
|
||
* so that `applyStyle` modifier can apply it. This separation is useful
|
||
* in case you need to replace `applyStyle` with a custom implementation.
|
||
*
|
||
* This modifier has `850` as `order` value to maintain backward compatibility
|
||
* with previous versions of Popper.js. Expect the modifiers ordering method
|
||
* to change in future major versions of the library.
|
||
*
|
||
* @memberof modifiers
|
||
* @inner
|
||
*/
|
||
computeStyle: {
|
||
/** @prop {number} order=850 - Index used to define the order of execution */
|
||
order: 850,
|
||
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
||
enabled: true,
|
||
/** @prop {ModifierFn} */
|
||
fn: computeStyle,
|
||
/**
|
||
* @prop {Boolean} gpuAcceleration=true
|
||
* If true, it uses the CSS 3d transformation to position the popper.
|
||
* Otherwise, it will use the `top` and `left` properties.
|
||
*/
|
||
gpuAcceleration: true,
|
||
/**
|
||
* @prop {string} [x='bottom']
|
||
* Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.
|
||
* Change this if your popper should grow in a direction different from `bottom`
|
||
*/
|
||
x: 'bottom',
|
||
/**
|
||
* @prop {string} [x='left']
|
||
* Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.
|
||
* Change this if your popper should grow in a direction different from `right`
|
||
*/
|
||
y: 'right'
|
||
},
|
||
|
||
/**
|
||
* Applies the computed styles to the popper element.
|
||
*
|
||
* All the DOM manipulations are limited to this modifier. This is useful in case
|
||
* you want to integrate Popper.js inside a framework or view library and you
|
||
* want to delegate all the DOM manipulations to it.
|
||
*
|
||
* Note that if you disable this modifier, you must make sure the popper element
|
||
* has its position set to `absolute` before Popper.js can do its work!
|
||
*
|
||
* Just disable this modifier and define you own to achieve the desired effect.
|
||
*
|
||
* @memberof modifiers
|
||
* @inner
|
||
*/
|
||
applyStyle: {
|
||
/** @prop {number} order=900 - Index used to define the order of execution */
|
||
order: 900,
|
||
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
||
enabled: true,
|
||
/** @prop {ModifierFn} */
|
||
fn: applyStyle,
|
||
/** @prop {Function} */
|
||
onLoad: applyStyleOnLoad,
|
||
/**
|
||
* @deprecated since version 1.10.0, the property moved to `computeStyle` modifier
|
||
* @prop {Boolean} gpuAcceleration=true
|
||
* If true, it uses the CSS 3d transformation to position the popper.
|
||
* Otherwise, it will use the `top` and `left` properties.
|
||
*/
|
||
gpuAcceleration: undefined
|
||
}
|
||
};
|
||
|
||
/**
|
||
* The `dataObject` is an object containing all the informations used by Popper.js
|
||
* this object get passed to modifiers and to the `onCreate` and `onUpdate` callbacks.
|
||
* @name dataObject
|
||
* @property {Object} data.instance The Popper.js instance
|
||
* @property {String} data.placement Placement applied to popper
|
||
* @property {String} data.originalPlacement Placement originally defined on init
|
||
* @property {Boolean} data.flipped True if popper has been flipped by flip modifier
|
||
* @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper.
|
||
* @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier
|
||
* @property {Object} data.styles Any CSS property defined here will be applied to the popper, it expects the JavaScript nomenclature (eg. `marginBottom`)
|
||
* @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow, it expects the JavaScript nomenclature (eg. `marginBottom`)
|
||
* @property {Object} data.boundaries Offsets of the popper boundaries
|
||
* @property {Object} data.offsets The measurements of popper, reference and arrow elements.
|
||
* @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values
|
||
* @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values
|
||
* @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0
|
||
*/
|
||
|
||
/**
|
||
* Default options provided to Popper.js constructor.<br />
|
||
* These can be overriden using the `options` argument of Popper.js.<br />
|
||
* To override an option, simply pass as 3rd argument an object with the same
|
||
* structure of this object, example:
|
||
* ```
|
||
* new Popper(ref, pop, {
|
||
* modifiers: {
|
||
* preventOverflow: { enabled: false }
|
||
* }
|
||
* })
|
||
* ```
|
||
* @type {Object}
|
||
* @static
|
||
* @memberof Popper
|
||
*/
|
||
var Defaults = {
|
||
/**
|
||
* Popper's placement
|
||
* @prop {Popper.placements} placement='bottom'
|
||
*/
|
||
placement: 'bottom',
|
||
|
||
/**
|
||
* Whether events (resize, scroll) are initially enabled
|
||
* @prop {Boolean} eventsEnabled=true
|
||
*/
|
||
eventsEnabled: true,
|
||
|
||
/**
|
||
* Set to true if you want to automatically remove the popper when
|
||
* you call the `destroy` method.
|
||
* @prop {Boolean} removeOnDestroy=false
|
||
*/
|
||
removeOnDestroy: false,
|
||
|
||
/**
|
||
* Callback called when the popper is created.<br />
|
||
* By default, is set to no-op.<br />
|
||
* Access Popper.js instance with `data.instance`.
|
||
* @prop {onCreate}
|
||
*/
|
||
onCreate: function onCreate() {},
|
||
|
||
/**
|
||
* Callback called when the popper is updated, this callback is not called
|
||
* on the initialization/creation of the popper, but only on subsequent
|
||
* updates.<br />
|
||
* By default, is set to no-op.<br />
|
||
* Access Popper.js instance with `data.instance`.
|
||
* @prop {onUpdate}
|
||
*/
|
||
onUpdate: function onUpdate() {},
|
||
|
||
/**
|
||
* List of modifiers used to modify the offsets before they are applied to the popper.
|
||
* They provide most of the functionalities of Popper.js
|
||
* @prop {modifiers}
|
||
*/
|
||
modifiers: modifiers
|
||
};
|
||
|
||
/**
|
||
* @callback onCreate
|
||
* @param {dataObject} data
|
||
*/
|
||
|
||
/**
|
||
* @callback onUpdate
|
||
* @param {dataObject} data
|
||
*/
|
||
|
||
// Utils
|
||
// Methods
|
||
var Popper = function () {
|
||
/**
|
||
* Create a new Popper.js instance
|
||
* @class Popper
|
||
* @param {HTMLElement|referenceObject} reference - The reference element used to position the popper
|
||
* @param {HTMLElement} popper - The HTML element used as popper.
|
||
* @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)
|
||
* @return {Object} instance - The generated Popper.js instance
|
||
*/
|
||
function Popper(reference, popper) {
|
||
var _this = this;
|
||
|
||
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
||
classCallCheck(this, Popper);
|
||
|
||
this.scheduleUpdate = function () {
|
||
return requestAnimationFrame(_this.update);
|
||
};
|
||
|
||
// make update() debounced, so that it only runs at most once-per-tick
|
||
this.update = debounce(this.update.bind(this));
|
||
|
||
// with {} we create a new object with the options inside it
|
||
this.options = _extends({}, Popper.Defaults, options);
|
||
|
||
// init state
|
||
this.state = {
|
||
isDestroyed: false,
|
||
isCreated: false,
|
||
scrollParents: []
|
||
};
|
||
|
||
// get reference and popper elements (allow jQuery wrappers)
|
||
this.reference = reference && reference.jquery ? reference[0] : reference;
|
||
this.popper = popper && popper.jquery ? popper[0] : popper;
|
||
|
||
// Deep merge modifiers options
|
||
this.options.modifiers = {};
|
||
Object.keys(_extends({}, Popper.Defaults.modifiers, options.modifiers)).forEach(function (name) {
|
||
_this.options.modifiers[name] = _extends({}, Popper.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {});
|
||
});
|
||
|
||
// Refactoring modifiers' list (Object => Array)
|
||
this.modifiers = Object.keys(this.options.modifiers).map(function (name) {
|
||
return _extends({
|
||
name: name
|
||
}, _this.options.modifiers[name]);
|
||
})
|
||
// sort the modifiers by order
|
||
.sort(function (a, b) {
|
||
return a.order - b.order;
|
||
});
|
||
|
||
// modifiers have the ability to execute arbitrary code when Popper.js get inited
|
||
// such code is executed in the same order of its modifier
|
||
// they could add new properties to their options configuration
|
||
// BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`!
|
||
this.modifiers.forEach(function (modifierOptions) {
|
||
if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {
|
||
modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state);
|
||
}
|
||
});
|
||
|
||
// fire the first update to position the popper in the right place
|
||
this.update();
|
||
|
||
var eventsEnabled = this.options.eventsEnabled;
|
||
if (eventsEnabled) {
|
||
// setup event listeners, they will take care of update the position in specific situations
|
||
this.enableEventListeners();
|
||
}
|
||
|
||
this.state.eventsEnabled = eventsEnabled;
|
||
}
|
||
|
||
// We can't use class properties because they don't get listed in the
|
||
// class prototype and break stuff like Sinon stubs
|
||
|
||
|
||
createClass(Popper, [{
|
||
key: 'update',
|
||
value: function update$$1() {
|
||
return update.call(this);
|
||
}
|
||
}, {
|
||
key: 'destroy',
|
||
value: function destroy$$1() {
|
||
return destroy.call(this);
|
||
}
|
||
}, {
|
||
key: 'enableEventListeners',
|
||
value: function enableEventListeners$$1() {
|
||
return enableEventListeners.call(this);
|
||
}
|
||
}, {
|
||
key: 'disableEventListeners',
|
||
value: function disableEventListeners$$1() {
|
||
return disableEventListeners.call(this);
|
||
}
|
||
|
||
/**
|
||
* Schedule an update, it will run on the next UI update available
|
||
* @method scheduleUpdate
|
||
* @memberof Popper
|
||
*/
|
||
|
||
|
||
/**
|
||
* Collection of utilities useful when writing custom modifiers.
|
||
* Starting from version 1.7, this method is available only if you
|
||
* include `popper-utils.js` before `popper.js`.
|
||
*
|
||
* **DEPRECATION**: This way to access PopperUtils is deprecated
|
||
* and will be removed in v2! Use the PopperUtils module directly instead.
|
||
* Due to the high instability of the methods contained in Utils, we can't
|
||
* guarantee them to follow semver. Use them at your own risk!
|
||
* @static
|
||
* @private
|
||
* @type {Object}
|
||
* @deprecated since version 1.8
|
||
* @member Utils
|
||
* @memberof Popper
|
||
*/
|
||
|
||
}]);
|
||
return Popper;
|
||
}();
|
||
|
||
/**
|
||
* The `referenceObject` is an object that provides an interface compatible with Popper.js
|
||
* and lets you use it as replacement of a real DOM node.<br />
|
||
* You can use this method to position a popper relatively to a set of coordinates
|
||
* in case you don't have a DOM node to use as reference.
|
||
*
|
||
* ```
|
||
* new Popper(referenceObject, popperNode);
|
||
* ```
|
||
*
|
||
* NB: This feature isn't supported in Internet Explorer 10
|
||
* @name referenceObject
|
||
* @property {Function} data.getBoundingClientRect
|
||
* A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method.
|
||
* @property {number} data.clientWidth
|
||
* An ES6 getter that will return the width of the virtual reference element.
|
||
* @property {number} data.clientHeight
|
||
* An ES6 getter that will return the height of the virtual reference element.
|
||
*/
|
||
|
||
|
||
Popper.Utils = (typeof window !== 'undefined' ? window : global).PopperUtils;
|
||
Popper.placements = placements;
|
||
Popper.Defaults = Defaults;
|
||
|
||
return Popper;
|
||
|
||
})));
|
||
//# sourceMappingURL=popper.js.map
|
||
|
||
/*!
|
||
* Bootstrap v4.0.0-beta.2 (https://getbootstrap.com)
|
||
* Copyright 2011-2017 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
|
||
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
|
||
*/
|
||
var bootstrap=function(t,e,n){"use strict";function i(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}e=e&&e.hasOwnProperty("default")?e.default:e,n=n&&n.hasOwnProperty("default")?n.default:n;var s=function(){function t(t){return{}.toString.call(t).match(/\s([a-zA-Z]+)/)[1].toLowerCase()}function n(){return{bindType:r.end,delegateType:r.end,handle:function(t){if(e(t.target).is(this))return t.handleObj.handler.apply(this,arguments)}}}function i(){if(window.QUnit)return!1;var t=document.createElement("bootstrap");for(var e in o)if("undefined"!=typeof t.style[e])return{end:o[e]};return!1}function s(t){var n=this,i=!1;return e(this).one(a.TRANSITION_END,function(){i=!0}),setTimeout(function(){i||a.triggerTransitionEnd(n)},t),this}var r=!1,o={WebkitTransition:"webkitTransitionEnd",MozTransition:"transitionend",OTransition:"oTransitionEnd otransitionend",transition:"transitionend"},a={TRANSITION_END:"bsTransitionEnd",getUID:function(t){do{t+=~~(1e6*Math.random())}while(document.getElementById(t));return t},getSelectorFromElement:function(t){var n=t.getAttribute("data-target");n&&"#"!==n||(n=t.getAttribute("href")||"");try{return e(document).find(n).length>0?n:null}catch(t){return null}},reflow:function(t){return t.offsetHeight},triggerTransitionEnd:function(t){e(t).trigger(r.end)},supportsTransitionEnd:function(){return Boolean(r)},isElement:function(t){return(t[0]||t).nodeType},typeCheckConfig:function(e,n,i){for(var s in i)if(Object.prototype.hasOwnProperty.call(i,s)){var r=i[s],o=n[s],l=o&&a.isElement(o)?"element":t(o);if(!new RegExp(r).test(l))throw new Error(e.toUpperCase()+': Option "'+s+'" provided type "'+l+'" but expected type "'+r+'".')}}};return r=i(),e.fn.emulateTransitionEnd=s,a.supportsTransitionEnd()&&(e.event.special[a.TRANSITION_END]=n()),a}(),r=function(t,e,n){return e&&i(t.prototype,e),n&&i(t,n),t},o=function(t,e){t.prototype=Object.create(e.prototype),t.prototype.constructor=t,t.__proto__=e},a=function(){var t="alert",n=e.fn[t],i={CLOSE:"close.bs.alert",CLOSED:"closed.bs.alert",CLICK_DATA_API:"click.bs.alert.data-api"},o={ALERT:"alert",FADE:"fade",SHOW:"show"},a=function(){function t(t){this._element=t}var n=t.prototype;return n.close=function(t){t=t||this._element;var e=this._getRootElement(t);this._triggerCloseEvent(e).isDefaultPrevented()||this._removeElement(e)},n.dispose=function(){e.removeData(this._element,"bs.alert"),this._element=null},n._getRootElement=function(t){var n=s.getSelectorFromElement(t),i=!1;return n&&(i=e(n)[0]),i||(i=e(t).closest("."+o.ALERT)[0]),i},n._triggerCloseEvent=function(t){var n=e.Event(i.CLOSE);return e(t).trigger(n),n},n._removeElement=function(t){var n=this;e(t).removeClass(o.SHOW),s.supportsTransitionEnd()&&e(t).hasClass(o.FADE)?e(t).one(s.TRANSITION_END,function(e){return n._destroyElement(t,e)}).emulateTransitionEnd(150):this._destroyElement(t)},n._destroyElement=function(t){e(t).detach().trigger(i.CLOSED).remove()},t._jQueryInterface=function(n){return this.each(function(){var i=e(this),s=i.data("bs.alert");s||(s=new t(this),i.data("bs.alert",s)),"close"===n&&s[n](this)})},t._handleDismiss=function(t){return function(e){e&&e.preventDefault(),t.close(this)}},r(t,null,[{key:"VERSION",get:function(){return"4.0.0-beta.2"}}]),t}();return e(document).on(i.CLICK_DATA_API,{DISMISS:'[data-dismiss="alert"]'}.DISMISS,a._handleDismiss(new a)),e.fn[t]=a._jQueryInterface,e.fn[t].Constructor=a,e.fn[t].noConflict=function(){return e.fn[t]=n,a._jQueryInterface},a}(),l=function(){var t="button",n=e.fn[t],i={ACTIVE:"active",BUTTON:"btn",FOCUS:"focus"},s={DATA_TOGGLE_CARROT:'[data-toggle^="button"]',DATA_TOGGLE:'[data-toggle="buttons"]',INPUT:"input",ACTIVE:".active",BUTTON:".btn"},o={CLICK_DATA_API:"click.bs.button.data-api",FOCUS_BLUR_DATA_API:"focus.bs.button.data-api blur.bs.button.data-api"},a=function(){function t(t){this._element=t}var n=t.prototype;return n.toggle=function(){var t=!0,n=!0,r=e(this._element).closest(s.DATA_TOGGLE)[0];if(r){var o=e(this._element).find(s.INPUT)[0];if(o){if("radio"===o.type)if(o.checked&&e(this._element).hasClass(i.ACTIVE))t=!1;else{var a=e(r).find(s.ACTIVE)[0];a&&e(a).removeClass(i.ACTIVE)}if(t){if(o.hasAttribute("disabled")||r.hasAttribute("disabled")||o.classList.contains("disabled")||r.classList.contains("disabled"))return;o.checked=!e(this._element).hasClass(i.ACTIVE),e(o).trigger("change")}o.focus(),n=!1}}n&&this._element.setAttribute("aria-pressed",!e(this._element).hasClass(i.ACTIVE)),t&&e(this._element).toggleClass(i.ACTIVE)},n.dispose=function(){e.removeData(this._element,"bs.button"),this._element=null},t._jQueryInterface=function(n){return this.each(function(){var i=e(this).data("bs.button");i||(i=new t(this),e(this).data("bs.button",i)),"toggle"===n&&i[n]()})},r(t,null,[{key:"VERSION",get:function(){return"4.0.0-beta.2"}}]),t}();return e(document).on(o.CLICK_DATA_API,s.DATA_TOGGLE_CARROT,function(t){t.preventDefault();var n=t.target;e(n).hasClass(i.BUTTON)||(n=e(n).closest(s.BUTTON)),a._jQueryInterface.call(e(n),"toggle")}).on(o.FOCUS_BLUR_DATA_API,s.DATA_TOGGLE_CARROT,function(t){var n=e(t.target).closest(s.BUTTON)[0];e(n).toggleClass(i.FOCUS,/^focus(in)?$/.test(t.type))}),e.fn[t]=a._jQueryInterface,e.fn[t].Constructor=a,e.fn[t].noConflict=function(){return e.fn[t]=n,a._jQueryInterface},a}(),h=function(){var t="carousel",n="bs.carousel",i="."+n,o=e.fn[t],a={interval:5e3,keyboard:!0,slide:!1,pause:"hover",wrap:!0},l={interval:"(number|boolean)",keyboard:"boolean",slide:"(boolean|string)",pause:"(string|boolean)",wrap:"boolean"},h={NEXT:"next",PREV:"prev",LEFT:"left",RIGHT:"right"},c={SLIDE:"slide"+i,SLID:"slid"+i,KEYDOWN:"keydown"+i,MOUSEENTER:"mouseenter"+i,MOUSELEAVE:"mouseleave"+i,TOUCHEND:"touchend"+i,LOAD_DATA_API:"load.bs.carousel.data-api",CLICK_DATA_API:"click.bs.carousel.data-api"},u={CAROUSEL:"carousel",ACTIVE:"active",SLIDE:"slide",RIGHT:"carousel-item-right",LEFT:"carousel-item-left",NEXT:"carousel-item-next",PREV:"carousel-item-prev",ITEM:"carousel-item"},d={ACTIVE:".active",ACTIVE_ITEM:".active.carousel-item",ITEM:".carousel-item",NEXT_PREV:".carousel-item-next, .carousel-item-prev",INDICATORS:".carousel-indicators",DATA_SLIDE:"[data-slide], [data-slide-to]",DATA_RIDE:'[data-ride="carousel"]'},f=function(){function o(t,n){this._items=null,this._interval=null,this._activeElement=null,this._isPaused=!1,this._isSliding=!1,this.touchTimeout=null,this._config=this._getConfig(n),this._element=e(t)[0],this._indicatorsElement=e(this._element).find(d.INDICATORS)[0],this._addEventListeners()}var f=o.prototype;return f.next=function(){this._isSliding||this._slide(h.NEXT)},f.nextWhenVisible=function(){!document.hidden&&e(this._element).is(":visible")&&"hidden"!==e(this._element).css("visibility")&&this.next()},f.prev=function(){this._isSliding||this._slide(h.PREV)},f.pause=function(t){t||(this._isPaused=!0),e(this._element).find(d.NEXT_PREV)[0]&&s.supportsTransitionEnd()&&(s.triggerTransitionEnd(this._element),this.cycle(!0)),clearInterval(this._interval),this._interval=null},f.cycle=function(t){t||(this._isPaused=!1),this._interval&&(clearInterval(this._interval),this._interval=null),this._config.interval&&!this._isPaused&&(this._interval=setInterval((document.visibilityState?this.nextWhenVisible:this.next).bind(this),this._config.interval))},f.to=function(t){var n=this;this._activeElement=e(this._element).find(d.ACTIVE_ITEM)[0];var i=this._getItemIndex(this._activeElement);if(!(t>this._items.length-1||t<0))if(this._isSliding)e(this._element).one(c.SLID,function(){return n.to(t)});else{if(i===t)return this.pause(),void this.cycle();var s=t>i?h.NEXT:h.PREV;this._slide(s,this._items[t])}},f.dispose=function(){e(this._element).off(i),e.removeData(this._element,n),this._items=null,this._config=null,this._element=null,this._interval=null,this._isPaused=null,this._isSliding=null,this._activeElement=null,this._indicatorsElement=null},f._getConfig=function(n){return n=e.extend({},a,n),s.typeCheckConfig(t,n,l),n},f._addEventListeners=function(){var t=this;this._config.keyboard&&e(this._element).on(c.KEYDOWN,function(e){return t._keydown(e)}),"hover"===this._config.pause&&(e(this._element).on(c.MOUSEENTER,function(e){return t.pause(e)}).on(c.MOUSELEAVE,function(e){return t.cycle(e)}),"ontouchstart"in document.documentElement&&e(this._element).on(c.TOUCHEND,function(){t.pause(),t.touchTimeout&&clearTimeout(t.touchTimeout),t.touchTimeout=setTimeout(function(e){return t.cycle(e)},500+t._config.interval)}))},f._keydown=function(t){if(!/input|textarea/i.test(t.target.tagName))switch(t.which){case 37:t.preventDefault(),this.prev();break;case 39:t.preventDefault(),this.next();break;default:return}},f._getItemIndex=function(t){return this._items=e.makeArray(e(t).parent().find(d.ITEM)),this._items.indexOf(t)},f._getItemByDirection=function(t,e){var n=t===h.NEXT,i=t===h.PREV,s=this._getItemIndex(e),r=this._items.length-1;if((i&&0===s||n&&s===r)&&!this._config.wrap)return e;var o=(s+(t===h.PREV?-1:1))%this._items.length;return-1===o?this._items[this._items.length-1]:this._items[o]},f._triggerSlideEvent=function(t,n){var i=this._getItemIndex(t),s=this._getItemIndex(e(this._element).find(d.ACTIVE_ITEM)[0]),r=e.Event(c.SLIDE,{relatedTarget:t,direction:n,from:s,to:i});return e(this._element).trigger(r),r},f._setActiveIndicatorElement=function(t){if(this._indicatorsElement){e(this._indicatorsElement).find(d.ACTIVE).removeClass(u.ACTIVE);var n=this._indicatorsElement.children[this._getItemIndex(t)];n&&e(n).addClass(u.ACTIVE)}},f._slide=function(t,n){var i,r,o,a=this,l=e(this._element).find(d.ACTIVE_ITEM)[0],f=this._getItemIndex(l),_=n||l&&this._getItemByDirection(t,l),g=this._getItemIndex(_),m=Boolean(this._interval);if(t===h.NEXT?(i=u.LEFT,r=u.NEXT,o=h.LEFT):(i=u.RIGHT,r=u.PREV,o=h.RIGHT),_&&e(_).hasClass(u.ACTIVE))this._isSliding=!1;else if(!this._triggerSlideEvent(_,o).isDefaultPrevented()&&l&&_){this._isSliding=!0,m&&this.pause(),this._setActiveIndicatorElement(_);var p=e.Event(c.SLID,{relatedTarget:_,direction:o,from:f,to:g});s.supportsTransitionEnd()&&e(this._element).hasClass(u.SLIDE)?(e(_).addClass(r),s.reflow(_),e(l).addClass(i),e(_).addClass(i),e(l).one(s.TRANSITION_END,function(){e(_).removeClass(i+" "+r).addClass(u.ACTIVE),e(l).removeClass(u.ACTIVE+" "+r+" "+i),a._isSliding=!1,setTimeout(function(){return e(a._element).trigger(p)},0)}).emulateTransitionEnd(600)):(e(l).removeClass(u.ACTIVE),e(_).addClass(u.ACTIVE),this._isSliding=!1,e(this._element).trigger(p)),m&&this.cycle()}},o._jQueryInterface=function(t){return this.each(function(){var i=e(this).data(n),s=e.extend({},a,e(this).data());"object"==typeof t&&e.extend(s,t);var r="string"==typeof t?t:s.slide;if(i||(i=new o(this,s),e(this).data(n,i)),"number"==typeof t)i.to(t);else if("string"==typeof r){if("undefined"==typeof i[r])throw new Error('No method named "'+r+'"');i[r]()}else s.interval&&(i.pause(),i.cycle())})},o._dataApiClickHandler=function(t){var i=s.getSelectorFromElement(this);if(i){var r=e(i)[0];if(r&&e(r).hasClass(u.CAROUSEL)){var a=e.extend({},e(r).data(),e(this).data()),l=this.getAttribute("data-slide-to");l&&(a.interval=!1),o._jQueryInterface.call(e(r),a),l&&e(r).data(n).to(l),t.preventDefault()}}},r(o,null,[{key:"VERSION",get:function(){return"4.0.0-beta.2"}},{key:"Default",get:function(){return a}}]),o}();return e(document).on(c.CLICK_DATA_API,d.DATA_SLIDE,f._dataApiClickHandler),e(window).on(c.LOAD_DATA_API,function(){e(d.DATA_RIDE).each(function(){var t=e(this);f._jQueryInterface.call(t,t.data())})}),e.fn[t]=f._jQueryInterface,e.fn[t].Constructor=f,e.fn[t].noConflict=function(){return e.fn[t]=o,f._jQueryInterface},f}(),c=function(){var t="collapse",n="bs.collapse",i=e.fn[t],o={toggle:!0,parent:""},a={toggle:"boolean",parent:"(string|element)"},l={SHOW:"show.bs.collapse",SHOWN:"shown.bs.collapse",HIDE:"hide.bs.collapse",HIDDEN:"hidden.bs.collapse",CLICK_DATA_API:"click.bs.collapse.data-api"},h={SHOW:"show",COLLAPSE:"collapse",COLLAPSING:"collapsing",COLLAPSED:"collapsed"},c={WIDTH:"width",HEIGHT:"height"},u={ACTIVES:".show, .collapsing",DATA_TOGGLE:'[data-toggle="collapse"]'},d=function(){function i(t,n){this._isTransitioning=!1,this._element=t,this._config=this._getConfig(n),this._triggerArray=e.makeArray(e('[data-toggle="collapse"][href="#'+t.id+'"],[data-toggle="collapse"][data-target="#'+t.id+'"]'));for(var i=e(u.DATA_TOGGLE),r=0;r<i.length;r++){var o=i[r],a=s.getSelectorFromElement(o);null!==a&&e(a).filter(t).length>0&&this._triggerArray.push(o)}this._parent=this._config.parent?this._getParent():null,this._config.parent||this._addAriaAndCollapsedClass(this._element,this._triggerArray),this._config.toggle&&this.toggle()}var d=i.prototype;return d.toggle=function(){e(this._element).hasClass(h.SHOW)?this.hide():this.show()},d.show=function(){var t=this;if(!this._isTransitioning&&!e(this._element).hasClass(h.SHOW)){var r,o;if(this._parent&&((r=e.makeArray(e(this._parent).children().children(u.ACTIVES))).length||(r=null)),!(r&&(o=e(r).data(n))&&o._isTransitioning)){var a=e.Event(l.SHOW);if(e(this._element).trigger(a),!a.isDefaultPrevented()){r&&(i._jQueryInterface.call(e(r),"hide"),o||e(r).data(n,null));var c=this._getDimension();e(this._element).removeClass(h.COLLAPSE).addClass(h.COLLAPSING),this._element.style[c]=0,this._triggerArray.length&&e(this._triggerArray).removeClass(h.COLLAPSED).attr("aria-expanded",!0),this.setTransitioning(!0);var d=function(){e(t._element).removeClass(h.COLLAPSING).addClass(h.COLLAPSE).addClass(h.SHOW),t._element.style[c]="",t.setTransitioning(!1),e(t._element).trigger(l.SHOWN)};if(s.supportsTransitionEnd()){var f="scroll"+(c[0].toUpperCase()+c.slice(1));e(this._element).one(s.TRANSITION_END,d).emulateTransitionEnd(600),this._element.style[c]=this._element[f]+"px"}else d()}}}},d.hide=function(){var t=this;if(!this._isTransitioning&&e(this._element).hasClass(h.SHOW)){var n=e.Event(l.HIDE);if(e(this._element).trigger(n),!n.isDefaultPrevented()){var i=this._getDimension();if(this._element.style[i]=this._element.getBoundingClientRect()[i]+"px",s.reflow(this._element),e(this._element).addClass(h.COLLAPSING).removeClass(h.COLLAPSE).removeClass(h.SHOW),this._triggerArray.length)for(var r=0;r<this._triggerArray.length;r++){var o=this._triggerArray[r],a=s.getSelectorFromElement(o);null!==a&&(e(a).hasClass(h.SHOW)||e(o).addClass(h.COLLAPSED).attr("aria-expanded",!1))}this.setTransitioning(!0);var c=function(){t.setTransitioning(!1),e(t._element).removeClass(h.COLLAPSING).addClass(h.COLLAPSE).trigger(l.HIDDEN)};this._element.style[i]="",s.supportsTransitionEnd()?e(this._element).one(s.TRANSITION_END,c).emulateTransitionEnd(600):c()}}},d.setTransitioning=function(t){this._isTransitioning=t},d.dispose=function(){e.removeData(this._element,n),this._config=null,this._parent=null,this._element=null,this._triggerArray=null,this._isTransitioning=null},d._getConfig=function(n){return n=e.extend({},o,n),n.toggle=Boolean(n.toggle),s.typeCheckConfig(t,n,a),n},d._getDimension=function(){return e(this._element).hasClass(c.WIDTH)?c.WIDTH:c.HEIGHT},d._getParent=function(){var t=this,n=null;s.isElement(this._config.parent)?(n=this._config.parent,"undefined"!=typeof this._config.parent.jquery&&(n=this._config.parent[0])):n=e(this._config.parent)[0];var r='[data-toggle="collapse"][data-parent="'+this._config.parent+'"]';return e(n).find(r).each(function(e,n){t._addAriaAndCollapsedClass(i._getTargetFromElement(n),[n])}),n},d._addAriaAndCollapsedClass=function(t,n){if(t){var i=e(t).hasClass(h.SHOW);n.length&&e(n).toggleClass(h.COLLAPSED,!i).attr("aria-expanded",i)}},i._getTargetFromElement=function(t){var n=s.getSelectorFromElement(t);return n?e(n)[0]:null},i._jQueryInterface=function(t){return this.each(function(){var s=e(this),r=s.data(n),a=e.extend({},o,s.data(),"object"==typeof t&&t);if(!r&&a.toggle&&/show|hide/.test(t)&&(a.toggle=!1),r||(r=new i(this,a),s.data(n,r)),"string"==typeof t){if("undefined"==typeof r[t])throw new Error('No method named "'+t+'"');r[t]()}})},r(i,null,[{key:"VERSION",get:function(){return"4.0.0-beta.2"}},{key:"Default",get:function(){return o}}]),i}();return e(document).on(l.CLICK_DATA_API,u.DATA_TOGGLE,function(t){"A"===t.currentTarget.tagName&&t.preventDefault();var i=e(this),r=s.getSelectorFromElement(this);e(r).each(function(){var t=e(this),s=t.data(n)?"toggle":i.data();d._jQueryInterface.call(t,s)})}),e.fn[t]=d._jQueryInterface,e.fn[t].Constructor=d,e.fn[t].noConflict=function(){return e.fn[t]=i,d._jQueryInterface},d}(),u=function(){if("undefined"==typeof n)throw new Error("Bootstrap dropdown require Popper.js (https://popper.js.org)");var t="dropdown",i="bs.dropdown",o="."+i,a=e.fn[t],l=new RegExp("38|40|27"),h={HIDE:"hide"+o,HIDDEN:"hidden"+o,SHOW:"show"+o,SHOWN:"shown"+o,CLICK:"click"+o,CLICK_DATA_API:"click.bs.dropdown.data-api",KEYDOWN_DATA_API:"keydown.bs.dropdown.data-api",KEYUP_DATA_API:"keyup.bs.dropdown.data-api"},c={DISABLED:"disabled",SHOW:"show",DROPUP:"dropup",MENURIGHT:"dropdown-menu-right",MENULEFT:"dropdown-menu-left"},u={DATA_TOGGLE:'[data-toggle="dropdown"]',FORM_CHILD:".dropdown form",MENU:".dropdown-menu",NAVBAR_NAV:".navbar-nav",VISIBLE_ITEMS:".dropdown-menu .dropdown-item:not(.disabled)"},d={TOP:"top-start",TOPEND:"top-end",BOTTOM:"bottom-start",BOTTOMEND:"bottom-end"},f={offset:0,flip:!0},_={offset:"(number|string|function)",flip:"boolean"},g=function(){function a(t,e){this._element=t,this._popper=null,this._config=this._getConfig(e),this._menu=this._getMenuElement(),this._inNavbar=this._detectNavbar(),this._addEventListeners()}var g=a.prototype;return g.toggle=function(){if(!this._element.disabled&&!e(this._element).hasClass(c.DISABLED)){var t=a._getParentFromElement(this._element),i=e(this._menu).hasClass(c.SHOW);if(a._clearMenus(),!i){var s={relatedTarget:this._element},r=e.Event(h.SHOW,s);if(e(t).trigger(r),!r.isDefaultPrevented()){var o=this._element;e(t).hasClass(c.DROPUP)&&(e(this._menu).hasClass(c.MENULEFT)||e(this._menu).hasClass(c.MENURIGHT))&&(o=t),this._popper=new n(o,this._menu,this._getPopperConfig()),"ontouchstart"in document.documentElement&&!e(t).closest(u.NAVBAR_NAV).length&&e("body").children().on("mouseover",null,e.noop),this._element.focus(),this._element.setAttribute("aria-expanded",!0),e(this._menu).toggleClass(c.SHOW),e(t).toggleClass(c.SHOW).trigger(e.Event(h.SHOWN,s))}}}},g.dispose=function(){e.removeData(this._element,i),e(this._element).off(o),this._element=null,this._menu=null,null!==this._popper&&this._popper.destroy(),this._popper=null},g.update=function(){this._inNavbar=this._detectNavbar(),null!==this._popper&&this._popper.scheduleUpdate()},g._addEventListeners=function(){var t=this;e(this._element).on(h.CLICK,function(e){e.preventDefault(),e.stopPropagation(),t.toggle()})},g._getConfig=function(n){return n=e.extend({},this.constructor.Default,e(this._element).data(),n),s.typeCheckConfig(t,n,this.constructor.DefaultType),n},g._getMenuElement=function(){if(!this._menu){var t=a._getParentFromElement(this._element);this._menu=e(t).find(u.MENU)[0]}return this._menu},g._getPlacement=function(){var t=e(this._element).parent(),n=d.BOTTOM;return t.hasClass(c.DROPUP)?(n=d.TOP,e(this._menu).hasClass(c.MENURIGHT)&&(n=d.TOPEND)):e(this._menu).hasClass(c.MENURIGHT)&&(n=d.BOTTOMEND),n},g._detectNavbar=function(){return e(this._element).closest(".navbar").length>0},g._getPopperConfig=function(){var t=this,n={};"function"==typeof this._config.offset?n.fn=function(n){return n.offsets=e.extend({},n.offsets,t._config.offset(n.offsets)||{}),n}:n.offset=this._config.offset;var i={placement:this._getPlacement(),modifiers:{offset:n,flip:{enabled:this._config.flip}}};return this._inNavbar&&(i.modifiers.applyStyle={enabled:!this._inNavbar}),i},a._jQueryInterface=function(t){return this.each(function(){var n=e(this).data(i),s="object"==typeof t?t:null;if(n||(n=new a(this,s),e(this).data(i,n)),"string"==typeof t){if("undefined"==typeof n[t])throw new Error('No method named "'+t+'"');n[t]()}})},a._clearMenus=function(t){if(!t||3!==t.which&&("keyup"!==t.type||9===t.which))for(var n=e.makeArray(e(u.DATA_TOGGLE)),s=0;s<n.length;s++){var r=a._getParentFromElement(n[s]),o=e(n[s]).data(i),l={relatedTarget:n[s]};if(o){var d=o._menu;if(e(r).hasClass(c.SHOW)&&!(t&&("click"===t.type&&/input|textarea/i.test(t.target.tagName)||"keyup"===t.type&&9===t.which)&&e.contains(r,t.target))){var f=e.Event(h.HIDE,l);e(r).trigger(f),f.isDefaultPrevented()||("ontouchstart"in document.documentElement&&e("body").children().off("mouseover",null,e.noop),n[s].setAttribute("aria-expanded","false"),e(d).removeClass(c.SHOW),e(r).removeClass(c.SHOW).trigger(e.Event(h.HIDDEN,l)))}}}},a._getParentFromElement=function(t){var n,i=s.getSelectorFromElement(t);return i&&(n=e(i)[0]),n||t.parentNode},a._dataApiKeydownHandler=function(t){if(!(!l.test(t.which)||/button/i.test(t.target.tagName)&&32===t.which||/input|textarea/i.test(t.target.tagName)||(t.preventDefault(),t.stopPropagation(),this.disabled||e(this).hasClass(c.DISABLED)))){var n=a._getParentFromElement(this),i=e(n).hasClass(c.SHOW);if((i||27===t.which&&32===t.which)&&(!i||27!==t.which&&32!==t.which)){var s=e(n).find(u.VISIBLE_ITEMS).get();if(s.length){var r=s.indexOf(t.target);38===t.which&&r>0&&r--,40===t.which&&r<s.length-1&&r++,r<0&&(r=0),s[r].focus()}}else{if(27===t.which){var o=e(n).find(u.DATA_TOGGLE)[0];e(o).trigger("focus")}e(this).trigger("click")}}},r(a,null,[{key:"VERSION",get:function(){return"4.0.0-beta.2"}},{key:"Default",get:function(){return f}},{key:"DefaultType",get:function(){return _}}]),a}();return e(document).on(h.KEYDOWN_DATA_API,u.DATA_TOGGLE,g._dataApiKeydownHandler).on(h.KEYDOWN_DATA_API,u.MENU,g._dataApiKeydownHandler).on(h.CLICK_DATA_API+" "+h.KEYUP_DATA_API,g._clearMenus).on(h.CLICK_DATA_API,u.DATA_TOGGLE,function(t){t.preventDefault(),t.stopPropagation(),g._jQueryInterface.call(e(this),"toggle")}).on(h.CLICK_DATA_API,u.FORM_CHILD,function(t){t.stopPropagation()}),e.fn[t]=g._jQueryInterface,e.fn[t].Constructor=g,e.fn[t].noConflict=function(){return e.fn[t]=a,g._jQueryInterface},g}(),d=function(){var t="modal",n=".bs.modal",i=e.fn[t],o={backdrop:!0,keyboard:!0,focus:!0,show:!0},a={backdrop:"(boolean|string)",keyboard:"boolean",focus:"boolean",show:"boolean"},l={HIDE:"hide.bs.modal",HIDDEN:"hidden.bs.modal",SHOW:"show.bs.modal",SHOWN:"shown.bs.modal",FOCUSIN:"focusin.bs.modal",RESIZE:"resize.bs.modal",CLICK_DISMISS:"click.dismiss.bs.modal",KEYDOWN_DISMISS:"keydown.dismiss.bs.modal",MOUSEUP_DISMISS:"mouseup.dismiss.bs.modal",MOUSEDOWN_DISMISS:"mousedown.dismiss.bs.modal",CLICK_DATA_API:"click.bs.modal.data-api"},h={SCROLLBAR_MEASURER:"modal-scrollbar-measure",BACKDROP:"modal-backdrop",OPEN:"modal-open",FADE:"fade",SHOW:"show"},c={DIALOG:".modal-dialog",DATA_TOGGLE:'[data-toggle="modal"]',DATA_DISMISS:'[data-dismiss="modal"]',FIXED_CONTENT:".fixed-top, .fixed-bottom, .is-fixed, .sticky-top",STICKY_CONTENT:".sticky-top",NAVBAR_TOGGLER:".navbar-toggler"},u=function(){function i(t,n){this._config=this._getConfig(n),this._element=t,this._dialog=e(t).find(c.DIALOG)[0],this._backdrop=null,this._isShown=!1,this._isBodyOverflowing=!1,this._ignoreBackdropClick=!1,this._originalBodyPadding=0,this._scrollbarWidth=0}var u=i.prototype;return u.toggle=function(t){return this._isShown?this.hide():this.show(t)},u.show=function(t){var n=this;if(!this._isTransitioning&&!this._isShown){s.supportsTransitionEnd()&&e(this._element).hasClass(h.FADE)&&(this._isTransitioning=!0);var i=e.Event(l.SHOW,{relatedTarget:t});e(this._element).trigger(i),this._isShown||i.isDefaultPrevented()||(this._isShown=!0,this._checkScrollbar(),this._setScrollbar(),this._adjustDialog(),e(document.body).addClass(h.OPEN),this._setEscapeEvent(),this._setResizeEvent(),e(this._element).on(l.CLICK_DISMISS,c.DATA_DISMISS,function(t){return n.hide(t)}),e(this._dialog).on(l.MOUSEDOWN_DISMISS,function(){e(n._element).one(l.MOUSEUP_DISMISS,function(t){e(t.target).is(n._element)&&(n._ignoreBackdropClick=!0)})}),this._showBackdrop(function(){return n._showElement(t)}))}},u.hide=function(t){var n=this;if(t&&t.preventDefault(),!this._isTransitioning&&this._isShown){var i=e.Event(l.HIDE);if(e(this._element).trigger(i),this._isShown&&!i.isDefaultPrevented()){this._isShown=!1;var r=s.supportsTransitionEnd()&&e(this._element).hasClass(h.FADE);r&&(this._isTransitioning=!0),this._setEscapeEvent(),this._setResizeEvent(),e(document).off(l.FOCUSIN),e(this._element).removeClass(h.SHOW),e(this._element).off(l.CLICK_DISMISS),e(this._dialog).off(l.MOUSEDOWN_DISMISS),r?e(this._element).one(s.TRANSITION_END,function(t){return n._hideModal(t)}).emulateTransitionEnd(300):this._hideModal()}}},u.dispose=function(){e.removeData(this._element,"bs.modal"),e(window,document,this._element,this._backdrop).off(n),this._config=null,this._element=null,this._dialog=null,this._backdrop=null,this._isShown=null,this._isBodyOverflowing=null,this._ignoreBackdropClick=null,this._scrollbarWidth=null},u.handleUpdate=function(){this._adjustDialog()},u._getConfig=function(n){return n=e.extend({},o,n),s.typeCheckConfig(t,n,a),n},u._showElement=function(t){var n=this,i=s.supportsTransitionEnd()&&e(this._element).hasClass(h.FADE);this._element.parentNode&&this._element.parentNode.nodeType===Node.ELEMENT_NODE||document.body.appendChild(this._element),this._element.style.display="block",this._element.removeAttribute("aria-hidden"),this._element.scrollTop=0,i&&s.reflow(this._element),e(this._element).addClass(h.SHOW),this._config.focus&&this._enforceFocus();var r=e.Event(l.SHOWN,{relatedTarget:t}),o=function(){n._config.focus&&n._element.focus(),n._isTransitioning=!1,e(n._element).trigger(r)};i?e(this._dialog).one(s.TRANSITION_END,o).emulateTransitionEnd(300):o()},u._enforceFocus=function(){var t=this;e(document).off(l.FOCUSIN).on(l.FOCUSIN,function(n){document===n.target||t._element===n.target||e(t._element).has(n.target).length||t._element.focus()})},u._setEscapeEvent=function(){var t=this;this._isShown&&this._config.keyboard?e(this._element).on(l.KEYDOWN_DISMISS,function(e){27===e.which&&(e.preventDefault(),t.hide())}):this._isShown||e(this._element).off(l.KEYDOWN_DISMISS)},u._setResizeEvent=function(){var t=this;this._isShown?e(window).on(l.RESIZE,function(e){return t.handleUpdate(e)}):e(window).off(l.RESIZE)},u._hideModal=function(){var t=this;this._element.style.display="none",this._element.setAttribute("aria-hidden",!0),this._isTransitioning=!1,this._showBackdrop(function(){e(document.body).removeClass(h.OPEN),t._resetAdjustments(),t._resetScrollbar(),e(t._element).trigger(l.HIDDEN)})},u._removeBackdrop=function(){this._backdrop&&(e(this._backdrop).remove(),this._backdrop=null)},u._showBackdrop=function(t){var n=this,i=e(this._element).hasClass(h.FADE)?h.FADE:"";if(this._isShown&&this._config.backdrop){var r=s.supportsTransitionEnd()&&i;if(this._backdrop=document.createElement("div"),this._backdrop.className=h.BACKDROP,i&&e(this._backdrop).addClass(i),e(this._backdrop).appendTo(document.body),e(this._element).on(l.CLICK_DISMISS,function(t){n._ignoreBackdropClick?n._ignoreBackdropClick=!1:t.target===t.currentTarget&&("static"===n._config.backdrop?n._element.focus():n.hide())}),r&&s.reflow(this._backdrop),e(this._backdrop).addClass(h.SHOW),!t)return;if(!r)return void t();e(this._backdrop).one(s.TRANSITION_END,t).emulateTransitionEnd(150)}else if(!this._isShown&&this._backdrop){e(this._backdrop).removeClass(h.SHOW);var o=function(){n._removeBackdrop(),t&&t()};s.supportsTransitionEnd()&&e(this._element).hasClass(h.FADE)?e(this._backdrop).one(s.TRANSITION_END,o).emulateTransitionEnd(150):o()}else t&&t()},u._adjustDialog=function(){var t=this._element.scrollHeight>document.documentElement.clientHeight;!this._isBodyOverflowing&&t&&(this._element.style.paddingLeft=this._scrollbarWidth+"px"),this._isBodyOverflowing&&!t&&(this._element.style.paddingRight=this._scrollbarWidth+"px")},u._resetAdjustments=function(){this._element.style.paddingLeft="",this._element.style.paddingRight=""},u._checkScrollbar=function(){var t=document.body.getBoundingClientRect();this._isBodyOverflowing=t.left+t.right<window.innerWidth,this._scrollbarWidth=this._getScrollbarWidth()},u._setScrollbar=function(){var t=this;if(this._isBodyOverflowing){e(c.FIXED_CONTENT).each(function(n,i){var s=e(i)[0].style.paddingRight,r=e(i).css("padding-right");e(i).data("padding-right",s).css("padding-right",parseFloat(r)+t._scrollbarWidth+"px")}),e(c.STICKY_CONTENT).each(function(n,i){var s=e(i)[0].style.marginRight,r=e(i).css("margin-right");e(i).data("margin-right",s).css("margin-right",parseFloat(r)-t._scrollbarWidth+"px")}),e(c.NAVBAR_TOGGLER).each(function(n,i){var s=e(i)[0].style.marginRight,r=e(i).css("margin-right");e(i).data("margin-right",s).css("margin-right",parseFloat(r)+t._scrollbarWidth+"px")});var n=document.body.style.paddingRight,i=e("body").css("padding-right");e("body").data("padding-right",n).css("padding-right",parseFloat(i)+this._scrollbarWidth+"px")}},u._resetScrollbar=function(){e(c.FIXED_CONTENT).each(function(t,n){var i=e(n).data("padding-right");"undefined"!=typeof i&&e(n).css("padding-right",i).removeData("padding-right")}),e(c.STICKY_CONTENT+", "+c.NAVBAR_TOGGLER).each(function(t,n){var i=e(n).data("margin-right");"undefined"!=typeof i&&e(n).css("margin-right",i).removeData("margin-right")});var t=e("body").data("padding-right");"undefined"!=typeof t&&e("body").css("padding-right",t).removeData("padding-right")},u._getScrollbarWidth=function(){var t=document.createElement("div");t.className=h.SCROLLBAR_MEASURER,document.body.appendChild(t);var e=t.getBoundingClientRect().width-t.clientWidth;return document.body.removeChild(t),e},i._jQueryInterface=function(t,n){return this.each(function(){var s=e(this).data("bs.modal"),r=e.extend({},i.Default,e(this).data(),"object"==typeof t&&t);if(s||(s=new i(this,r),e(this).data("bs.modal",s)),"string"==typeof t){if("undefined"==typeof s[t])throw new Error('No method named "'+t+'"');s[t](n)}else r.show&&s.show(n)})},r(i,null,[{key:"VERSION",get:function(){return"4.0.0-beta.2"}},{key:"Default",get:function(){return o}}]),i}();return e(document).on(l.CLICK_DATA_API,c.DATA_TOGGLE,function(t){var n,i=this,r=s.getSelectorFromElement(this);r&&(n=e(r)[0]);var o=e(n).data("bs.modal")?"toggle":e.extend({},e(n).data(),e(this).data());"A"!==this.tagName&&"AREA"!==this.tagName||t.preventDefault();var a=e(n).one(l.SHOW,function(t){t.isDefaultPrevented()||a.one(l.HIDDEN,function(){e(i).is(":visible")&&i.focus()})});u._jQueryInterface.call(e(n),o,this)}),e.fn[t]=u._jQueryInterface,e.fn[t].Constructor=u,e.fn[t].noConflict=function(){return e.fn[t]=i,u._jQueryInterface},u}(),f=function(){if("undefined"==typeof n)throw new Error("Bootstrap tooltips require Popper.js (https://popper.js.org)");var t="tooltip",i=".bs.tooltip",o=e.fn[t],a=new RegExp("(^|\\s)bs-tooltip\\S+","g"),l={animation:"boolean",template:"string",title:"(string|element|function)",trigger:"string",delay:"(number|object)",html:"boolean",selector:"(string|boolean)",placement:"(string|function)",offset:"(number|string)",container:"(string|element|boolean)",fallbackPlacement:"(string|array)"},h={AUTO:"auto",TOP:"top",RIGHT:"right",BOTTOM:"bottom",LEFT:"left"},c={animation:!0,template:'<div class="tooltip" role="tooltip"><div class="arrow"></div><div class="tooltip-inner"></div></div>',trigger:"hover focus",title:"",delay:0,html:!1,selector:!1,placement:"top",offset:0,container:!1,fallbackPlacement:"flip"},u={SHOW:"show",OUT:"out"},d={HIDE:"hide"+i,HIDDEN:"hidden"+i,SHOW:"show"+i,SHOWN:"shown"+i,INSERTED:"inserted"+i,CLICK:"click"+i,FOCUSIN:"focusin"+i,FOCUSOUT:"focusout"+i,MOUSEENTER:"mouseenter"+i,MOUSELEAVE:"mouseleave"+i},f={FADE:"fade",SHOW:"show"},_={TOOLTIP:".tooltip",TOOLTIP_INNER:".tooltip-inner",ARROW:".arrow"},g={HOVER:"hover",FOCUS:"focus",CLICK:"click",MANUAL:"manual"},m=function(){function o(t,e){this._isEnabled=!0,this._timeout=0,this._hoverState="",this._activeTrigger={},this._popper=null,this.element=t,this.config=this._getConfig(e),this.tip=null,this._setListeners()}var m=o.prototype;return m.enable=function(){this._isEnabled=!0},m.disable=function(){this._isEnabled=!1},m.toggleEnabled=function(){this._isEnabled=!this._isEnabled},m.toggle=function(t){if(this._isEnabled)if(t){var n=this.constructor.DATA_KEY,i=e(t.currentTarget).data(n);i||(i=new this.constructor(t.currentTarget,this._getDelegateConfig()),e(t.currentTarget).data(n,i)),i._activeTrigger.click=!i._activeTrigger.click,i._isWithActiveTrigger()?i._enter(null,i):i._leave(null,i)}else{if(e(this.getTipElement()).hasClass(f.SHOW))return void this._leave(null,this);this._enter(null,this)}},m.dispose=function(){clearTimeout(this._timeout),e.removeData(this.element,this.constructor.DATA_KEY),e(this.element).off(this.constructor.EVENT_KEY),e(this.element).closest(".modal").off("hide.bs.modal"),this.tip&&e(this.tip).remove(),this._isEnabled=null,this._timeout=null,this._hoverState=null,this._activeTrigger=null,null!==this._popper&&this._popper.destroy(),this._popper=null,this.element=null,this.config=null,this.tip=null},m.show=function(){var t=this;if("none"===e(this.element).css("display"))throw new Error("Please use show on visible elements");var i=e.Event(this.constructor.Event.SHOW);if(this.isWithContent()&&this._isEnabled){e(this.element).trigger(i);var r=e.contains(this.element.ownerDocument.documentElement,this.element);if(i.isDefaultPrevented()||!r)return;var a=this.getTipElement(),l=s.getUID(this.constructor.NAME);a.setAttribute("id",l),this.element.setAttribute("aria-describedby",l),this.setContent(),this.config.animation&&e(a).addClass(f.FADE);var h="function"==typeof this.config.placement?this.config.placement.call(this,a,this.element):this.config.placement,c=this._getAttachment(h);this.addAttachmentClass(c);var d=!1===this.config.container?document.body:e(this.config.container);e(a).data(this.constructor.DATA_KEY,this),e.contains(this.element.ownerDocument.documentElement,this.tip)||e(a).appendTo(d),e(this.element).trigger(this.constructor.Event.INSERTED),this._popper=new n(this.element,a,{placement:c,modifiers:{offset:{offset:this.config.offset},flip:{behavior:this.config.fallbackPlacement},arrow:{element:_.ARROW}},onCreate:function(e){e.originalPlacement!==e.placement&&t._handlePopperPlacementChange(e)},onUpdate:function(e){t._handlePopperPlacementChange(e)}}),e(a).addClass(f.SHOW),"ontouchstart"in document.documentElement&&e("body").children().on("mouseover",null,e.noop);var g=function(){t.config.animation&&t._fixTransition();var n=t._hoverState;t._hoverState=null,e(t.element).trigger(t.constructor.Event.SHOWN),n===u.OUT&&t._leave(null,t)};s.supportsTransitionEnd()&&e(this.tip).hasClass(f.FADE)?e(this.tip).one(s.TRANSITION_END,g).emulateTransitionEnd(o._TRANSITION_DURATION):g()}},m.hide=function(t){var n=this,i=this.getTipElement(),r=e.Event(this.constructor.Event.HIDE),o=function(){n._hoverState!==u.SHOW&&i.parentNode&&i.parentNode.removeChild(i),n._cleanTipClass(),n.element.removeAttribute("aria-describedby"),e(n.element).trigger(n.constructor.Event.HIDDEN),null!==n._popper&&n._popper.destroy(),t&&t()};e(this.element).trigger(r),r.isDefaultPrevented()||(e(i).removeClass(f.SHOW),"ontouchstart"in document.documentElement&&e("body").children().off("mouseover",null,e.noop),this._activeTrigger[g.CLICK]=!1,this._activeTrigger[g.FOCUS]=!1,this._activeTrigger[g.HOVER]=!1,s.supportsTransitionEnd()&&e(this.tip).hasClass(f.FADE)?e(i).one(s.TRANSITION_END,o).emulateTransitionEnd(150):o(),this._hoverState="")},m.update=function(){null!==this._popper&&this._popper.scheduleUpdate()},m.isWithContent=function(){return Boolean(this.getTitle())},m.addAttachmentClass=function(t){e(this.getTipElement()).addClass("bs-tooltip-"+t)},m.getTipElement=function(){return this.tip=this.tip||e(this.config.template)[0],this.tip},m.setContent=function(){var t=e(this.getTipElement());this.setElementContent(t.find(_.TOOLTIP_INNER),this.getTitle()),t.removeClass(f.FADE+" "+f.SHOW)},m.setElementContent=function(t,n){var i=this.config.html;"object"==typeof n&&(n.nodeType||n.jquery)?i?e(n).parent().is(t)||t.empty().append(n):t.text(e(n).text()):t[i?"html":"text"](n)},m.getTitle=function(){var t=this.element.getAttribute("data-original-title");return t||(t="function"==typeof this.config.title?this.config.title.call(this.element):this.config.title),t},m._getAttachment=function(t){return h[t.toUpperCase()]},m._setListeners=function(){var t=this;this.config.trigger.split(" ").forEach(function(n){if("click"===n)e(t.element).on(t.constructor.Event.CLICK,t.config.selector,function(e){return t.toggle(e)});else if(n!==g.MANUAL){var i=n===g.HOVER?t.constructor.Event.MOUSEENTER:t.constructor.Event.FOCUSIN,s=n===g.HOVER?t.constructor.Event.MOUSELEAVE:t.constructor.Event.FOCUSOUT;e(t.element).on(i,t.config.selector,function(e){return t._enter(e)}).on(s,t.config.selector,function(e){return t._leave(e)})}e(t.element).closest(".modal").on("hide.bs.modal",function(){return t.hide()})}),this.config.selector?this.config=e.extend({},this.config,{trigger:"manual",selector:""}):this._fixTitle()},m._fixTitle=function(){var t=typeof this.element.getAttribute("data-original-title");(this.element.getAttribute("title")||"string"!==t)&&(this.element.setAttribute("data-original-title",this.element.getAttribute("title")||""),this.element.setAttribute("title",""))},m._enter=function(t,n){var i=this.constructor.DATA_KEY;(n=n||e(t.currentTarget).data(i))||(n=new this.constructor(t.currentTarget,this._getDelegateConfig()),e(t.currentTarget).data(i,n)),t&&(n._activeTrigger["focusin"===t.type?g.FOCUS:g.HOVER]=!0),e(n.getTipElement()).hasClass(f.SHOW)||n._hoverState===u.SHOW?n._hoverState=u.SHOW:(clearTimeout(n._timeout),n._hoverState=u.SHOW,n.config.delay&&n.config.delay.show?n._timeout=setTimeout(function(){n._hoverState===u.SHOW&&n.show()},n.config.delay.show):n.show())},m._leave=function(t,n){var i=this.constructor.DATA_KEY;(n=n||e(t.currentTarget).data(i))||(n=new this.constructor(t.currentTarget,this._getDelegateConfig()),e(t.currentTarget).data(i,n)),t&&(n._activeTrigger["focusout"===t.type?g.FOCUS:g.HOVER]=!1),n._isWithActiveTrigger()||(clearTimeout(n._timeout),n._hoverState=u.OUT,n.config.delay&&n.config.delay.hide?n._timeout=setTimeout(function(){n._hoverState===u.OUT&&n.hide()},n.config.delay.hide):n.hide())},m._isWithActiveTrigger=function(){for(var t in this._activeTrigger)if(this._activeTrigger[t])return!0;return!1},m._getConfig=function(n){return"number"==typeof(n=e.extend({},this.constructor.Default,e(this.element).data(),n)).delay&&(n.delay={show:n.delay,hide:n.delay}),"number"==typeof n.title&&(n.title=n.title.toString()),"number"==typeof n.content&&(n.content=n.content.toString()),s.typeCheckConfig(t,n,this.constructor.DefaultType),n},m._getDelegateConfig=function(){var t={};if(this.config)for(var e in this.config)this.constructor.Default[e]!==this.config[e]&&(t[e]=this.config[e]);return t},m._cleanTipClass=function(){var t=e(this.getTipElement()),n=t.attr("class").match(a);null!==n&&n.length>0&&t.removeClass(n.join(""))},m._handlePopperPlacementChange=function(t){this._cleanTipClass(),this.addAttachmentClass(this._getAttachment(t.placement))},m._fixTransition=function(){var t=this.getTipElement(),n=this.config.animation;null===t.getAttribute("x-placement")&&(e(t).removeClass(f.FADE),this.config.animation=!1,this.hide(),this.show(),this.config.animation=n)},o._jQueryInterface=function(t){return this.each(function(){var n=e(this).data("bs.tooltip"),i="object"==typeof t&&t;if((n||!/dispose|hide/.test(t))&&(n||(n=new o(this,i),e(this).data("bs.tooltip",n)),"string"==typeof t)){if("undefined"==typeof n[t])throw new Error('No method named "'+t+'"');n[t]()}})},r(o,null,[{key:"VERSION",get:function(){return"4.0.0-beta.2"}},{key:"Default",get:function(){return c}},{key:"NAME",get:function(){return t}},{key:"DATA_KEY",get:function(){return"bs.tooltip"}},{key:"Event",get:function(){return d}},{key:"EVENT_KEY",get:function(){return i}},{key:"DefaultType",get:function(){return l}}]),o}();return e.fn[t]=m._jQueryInterface,e.fn[t].Constructor=m,e.fn[t].noConflict=function(){return e.fn[t]=o,m._jQueryInterface},m}(),_=function(){var t="popover",n=".bs.popover",i=e.fn[t],s=new RegExp("(^|\\s)bs-popover\\S+","g"),a=e.extend({},f.Default,{placement:"right",trigger:"click",content:"",template:'<div class="popover" role="tooltip"><div class="arrow"></div><h3 class="popover-header"></h3><div class="popover-body"></div></div>'}),l=e.extend({},f.DefaultType,{content:"(string|element|function)"}),h={FADE:"fade",SHOW:"show"},c={TITLE:".popover-header",CONTENT:".popover-body"},u={HIDE:"hide"+n,HIDDEN:"hidden"+n,SHOW:"show"+n,SHOWN:"shown"+n,INSERTED:"inserted"+n,CLICK:"click"+n,FOCUSIN:"focusin"+n,FOCUSOUT:"focusout"+n,MOUSEENTER:"mouseenter"+n,MOUSELEAVE:"mouseleave"+n},d=function(i){function d(){return i.apply(this,arguments)||this}o(d,i);var f=d.prototype;return f.isWithContent=function(){return this.getTitle()||this._getContent()},f.addAttachmentClass=function(t){e(this.getTipElement()).addClass("bs-popover-"+t)},f.getTipElement=function(){return this.tip=this.tip||e(this.config.template)[0],this.tip},f.setContent=function(){var t=e(this.getTipElement());this.setElementContent(t.find(c.TITLE),this.getTitle()),this.setElementContent(t.find(c.CONTENT),this._getContent()),t.removeClass(h.FADE+" "+h.SHOW)},f._getContent=function(){return this.element.getAttribute("data-content")||("function"==typeof this.config.content?this.config.content.call(this.element):this.config.content)},f._cleanTipClass=function(){var t=e(this.getTipElement()),n=t.attr("class").match(s);null!==n&&n.length>0&&t.removeClass(n.join(""))},d._jQueryInterface=function(t){return this.each(function(){var n=e(this).data("bs.popover"),i="object"==typeof t?t:null;if((n||!/destroy|hide/.test(t))&&(n||(n=new d(this,i),e(this).data("bs.popover",n)),"string"==typeof t)){if("undefined"==typeof n[t])throw new Error('No method named "'+t+'"');n[t]()}})},r(d,null,[{key:"VERSION",get:function(){return"4.0.0-beta.2"}},{key:"Default",get:function(){return a}},{key:"NAME",get:function(){return t}},{key:"DATA_KEY",get:function(){return"bs.popover"}},{key:"Event",get:function(){return u}},{key:"EVENT_KEY",get:function(){return n}},{key:"DefaultType",get:function(){return l}}]),d}(f);return e.fn[t]=d._jQueryInterface,e.fn[t].Constructor=d,e.fn[t].noConflict=function(){return e.fn[t]=i,d._jQueryInterface},d}(),g=function(){var t="scrollspy",n=e.fn[t],i={offset:10,method:"auto",target:""},o={offset:"number",method:"string",target:"(string|element)"},a={ACTIVATE:"activate.bs.scrollspy",SCROLL:"scroll.bs.scrollspy",LOAD_DATA_API:"load.bs.scrollspy.data-api"},l={DROPDOWN_ITEM:"dropdown-item",DROPDOWN_MENU:"dropdown-menu",ACTIVE:"active"},h={DATA_SPY:'[data-spy="scroll"]',ACTIVE:".active",NAV_LIST_GROUP:".nav, .list-group",NAV_LINKS:".nav-link",NAV_ITEMS:".nav-item",LIST_ITEMS:".list-group-item",DROPDOWN:".dropdown",DROPDOWN_ITEMS:".dropdown-item",DROPDOWN_TOGGLE:".dropdown-toggle"},c={OFFSET:"offset",POSITION:"position"},u=function(){function n(t,n){var i=this;this._element=t,this._scrollElement="BODY"===t.tagName?window:t,this._config=this._getConfig(n),this._selector=this._config.target+" "+h.NAV_LINKS+","+this._config.target+" "+h.LIST_ITEMS+","+this._config.target+" "+h.DROPDOWN_ITEMS,this._offsets=[],this._targets=[],this._activeTarget=null,this._scrollHeight=0,e(this._scrollElement).on(a.SCROLL,function(t){return i._process(t)}),this.refresh(),this._process()}var u=n.prototype;return u.refresh=function(){var t=this,n=this._scrollElement!==this._scrollElement.window?c.POSITION:c.OFFSET,i="auto"===this._config.method?n:this._config.method,r=i===c.POSITION?this._getScrollTop():0;this._offsets=[],this._targets=[],this._scrollHeight=this._getScrollHeight(),e.makeArray(e(this._selector)).map(function(t){var n,o=s.getSelectorFromElement(t);if(o&&(n=e(o)[0]),n){var a=n.getBoundingClientRect();if(a.width||a.height)return[e(n)[i]().top+r,o]}return null}).filter(function(t){return t}).sort(function(t,e){return t[0]-e[0]}).forEach(function(e){t._offsets.push(e[0]),t._targets.push(e[1])})},u.dispose=function(){e.removeData(this._element,"bs.scrollspy"),e(this._scrollElement).off(".bs.scrollspy"),this._element=null,this._scrollElement=null,this._config=null,this._selector=null,this._offsets=null,this._targets=null,this._activeTarget=null,this._scrollHeight=null},u._getConfig=function(n){if("string"!=typeof(n=e.extend({},i,n)).target){var r=e(n.target).attr("id");r||(r=s.getUID(t),e(n.target).attr("id",r)),n.target="#"+r}return s.typeCheckConfig(t,n,o),n},u._getScrollTop=function(){return this._scrollElement===window?this._scrollElement.pageYOffset:this._scrollElement.scrollTop},u._getScrollHeight=function(){return this._scrollElement.scrollHeight||Math.max(document.body.scrollHeight,document.documentElement.scrollHeight)},u._getOffsetHeight=function(){return this._scrollElement===window?window.innerHeight:this._scrollElement.getBoundingClientRect().height},u._process=function(){var t=this._getScrollTop()+this._config.offset,e=this._getScrollHeight(),n=this._config.offset+e-this._getOffsetHeight();if(this._scrollHeight!==e&&this.refresh(),t>=n){var i=this._targets[this._targets.length-1];this._activeTarget!==i&&this._activate(i)}else{if(this._activeTarget&&t<this._offsets[0]&&this._offsets[0]>0)return this._activeTarget=null,void this._clear();for(var s=this._offsets.length;s--;)this._activeTarget!==this._targets[s]&&t>=this._offsets[s]&&("undefined"==typeof this._offsets[s+1]||t<this._offsets[s+1])&&this._activate(this._targets[s])}},u._activate=function(t){this._activeTarget=t,this._clear();var n=this._selector.split(",");n=n.map(function(e){return e+'[data-target="'+t+'"],'+e+'[href="'+t+'"]'});var i=e(n.join(","));i.hasClass(l.DROPDOWN_ITEM)?(i.closest(h.DROPDOWN).find(h.DROPDOWN_TOGGLE).addClass(l.ACTIVE),i.addClass(l.ACTIVE)):(i.addClass(l.ACTIVE),i.parents(h.NAV_LIST_GROUP).prev(h.NAV_LINKS+", "+h.LIST_ITEMS).addClass(l.ACTIVE),i.parents(h.NAV_LIST_GROUP).prev(h.NAV_ITEMS).children(h.NAV_LINKS).addClass(l.ACTIVE)),e(this._scrollElement).trigger(a.ACTIVATE,{relatedTarget:t})},u._clear=function(){e(this._selector).filter(h.ACTIVE).removeClass(l.ACTIVE)},n._jQueryInterface=function(t){return this.each(function(){var i=e(this).data("bs.scrollspy"),s="object"==typeof t&&t;if(i||(i=new n(this,s),e(this).data("bs.scrollspy",i)),"string"==typeof t){if("undefined"==typeof i[t])throw new Error('No method named "'+t+'"');i[t]()}})},r(n,null,[{key:"VERSION",get:function(){return"4.0.0-beta.2"}},{key:"Default",get:function(){return i}}]),n}();return e(window).on(a.LOAD_DATA_API,function(){for(var t=e.makeArray(e(h.DATA_SPY)),n=t.length;n--;){var i=e(t[n]);u._jQueryInterface.call(i,i.data())}}),e.fn[t]=u._jQueryInterface,e.fn[t].Constructor=u,e.fn[t].noConflict=function(){return e.fn[t]=n,u._jQueryInterface},u}(),m=function(){var t=e.fn.tab,n={HIDE:"hide.bs.tab",HIDDEN:"hidden.bs.tab",SHOW:"show.bs.tab",SHOWN:"shown.bs.tab",CLICK_DATA_API:"click.bs.tab.data-api"},i={DROPDOWN_MENU:"dropdown-menu",ACTIVE:"active",DISABLED:"disabled",FADE:"fade",SHOW:"show"},o={DROPDOWN:".dropdown",NAV_LIST_GROUP:".nav, .list-group",ACTIVE:".active",ACTIVE_UL:"> li > .active",DATA_TOGGLE:'[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]',DROPDOWN_TOGGLE:".dropdown-toggle",DROPDOWN_ACTIVE_CHILD:"> .dropdown-menu .active"},a=function(){function t(t){this._element=t}var a=t.prototype;return a.show=function(){var t=this;if(!(this._element.parentNode&&this._element.parentNode.nodeType===Node.ELEMENT_NODE&&e(this._element).hasClass(i.ACTIVE)||e(this._element).hasClass(i.DISABLED))){var r,a,l=e(this._element).closest(o.NAV_LIST_GROUP)[0],h=s.getSelectorFromElement(this._element);if(l){var c="UL"===l.nodeName?o.ACTIVE_UL:o.ACTIVE;a=e.makeArray(e(l).find(c)),a=a[a.length-1]}var u=e.Event(n.HIDE,{relatedTarget:this._element}),d=e.Event(n.SHOW,{relatedTarget:a});if(a&&e(a).trigger(u),e(this._element).trigger(d),!d.isDefaultPrevented()&&!u.isDefaultPrevented()){h&&(r=e(h)[0]),this._activate(this._element,l);var f=function(){var i=e.Event(n.HIDDEN,{relatedTarget:t._element}),s=e.Event(n.SHOWN,{relatedTarget:a});e(a).trigger(i),e(t._element).trigger(s)};r?this._activate(r,r.parentNode,f):f()}}},a.dispose=function(){e.removeData(this._element,"bs.tab"),this._element=null},a._activate=function(t,n,r){var a,l=this,h=(a="UL"===n.nodeName?e(n).find(o.ACTIVE_UL):e(n).children(o.ACTIVE))[0],c=r&&s.supportsTransitionEnd()&&h&&e(h).hasClass(i.FADE),u=function(){return l._transitionComplete(t,h,c,r)};h&&c?e(h).one(s.TRANSITION_END,u).emulateTransitionEnd(150):u(),h&&e(h).removeClass(i.SHOW)},a._transitionComplete=function(t,n,r,a){if(n){e(n).removeClass(i.ACTIVE);var l=e(n.parentNode).find(o.DROPDOWN_ACTIVE_CHILD)[0];l&&e(l).removeClass(i.ACTIVE),"tab"===n.getAttribute("role")&&n.setAttribute("aria-selected",!1)}if(e(t).addClass(i.ACTIVE),"tab"===t.getAttribute("role")&&t.setAttribute("aria-selected",!0),r?(s.reflow(t),e(t).addClass(i.SHOW)):e(t).removeClass(i.FADE),t.parentNode&&e(t.parentNode).hasClass(i.DROPDOWN_MENU)){var h=e(t).closest(o.DROPDOWN)[0];h&&e(h).find(o.DROPDOWN_TOGGLE).addClass(i.ACTIVE),t.setAttribute("aria-expanded",!0)}a&&a()},t._jQueryInterface=function(n){return this.each(function(){var i=e(this),s=i.data("bs.tab");if(s||(s=new t(this),i.data("bs.tab",s)),"string"==typeof n){if("undefined"==typeof s[n])throw new Error('No method named "'+n+'"');s[n]()}})},r(t,null,[{key:"VERSION",get:function(){return"4.0.0-beta.2"}}]),t}();return e(document).on(n.CLICK_DATA_API,o.DATA_TOGGLE,function(t){t.preventDefault(),a._jQueryInterface.call(e(this),"show")}),e.fn.tab=a._jQueryInterface,e.fn.tab.Constructor=a,e.fn.tab.noConflict=function(){return e.fn.tab=t,a._jQueryInterface},a}();return function(){if("undefined"==typeof e)throw new Error("Bootstrap's JavaScript requires jQuery. jQuery must be included before Bootstrap's JavaScript.");var t=e.fn.jquery.split(" ")[0].split(".");if(t[0]<2&&t[1]<9||1===t[0]&&9===t[1]&&t[2]<1||t[0]>=4)throw new Error("Bootstrap's JavaScript requires at least jQuery v1.9.1 but less than v4.0.0")}(),t.Util=s,t.Alert=a,t.Button=l,t.Carousel=h,t.Collapse=c,t.Dropdown=u,t.Modal=d,t.Popover=_,t.Scrollspy=g,t.Tab=m,t.Tooltip=f,t}({},$,Popper);
|
||
//# sourceMappingURL=bootstrap.min.js.map
|
||
/*!
|
||
* JavaScript Cookie v2.2.0
|
||
* https://github.com/js-cookie/js-cookie
|
||
*
|
||
* Copyright 2006, 2015 Klaus Hartl & Fagner Brack
|
||
* Released under the MIT license
|
||
*/
|
||
;(function (factory) {
|
||
var registeredInModuleLoader = false;
|
||
if (typeof define === 'function' && define.amd) {
|
||
define(factory);
|
||
registeredInModuleLoader = true;
|
||
}
|
||
if (typeof exports === 'object') {
|
||
module.exports = factory();
|
||
registeredInModuleLoader = true;
|
||
}
|
||
if (!registeredInModuleLoader) {
|
||
var OldCookies = window.Cookies;
|
||
var api = window.Cookies = factory();
|
||
api.noConflict = function () {
|
||
window.Cookies = OldCookies;
|
||
return api;
|
||
};
|
||
}
|
||
}(function () {
|
||
function extend () {
|
||
var i = 0;
|
||
var result = {};
|
||
for (; i < arguments.length; i++) {
|
||
var attributes = arguments[ i ];
|
||
for (var key in attributes) {
|
||
result[key] = attributes[key];
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
function init (converter) {
|
||
function api (key, value, attributes) {
|
||
var result;
|
||
if (typeof document === 'undefined') {
|
||
return;
|
||
}
|
||
|
||
// Write
|
||
|
||
if (arguments.length > 1) {
|
||
attributes = extend({
|
||
path: '/'
|
||
}, api.defaults, attributes);
|
||
|
||
if (typeof attributes.expires === 'number') {
|
||
var expires = new Date();
|
||
expires.setMilliseconds(expires.getMilliseconds() + attributes.expires * 864e+5);
|
||
attributes.expires = expires;
|
||
}
|
||
|
||
// We're using "expires" because "max-age" is not supported by IE
|
||
attributes.expires = attributes.expires ? attributes.expires.toUTCString() : '';
|
||
|
||
try {
|
||
result = JSON.stringify(value);
|
||
if (/^[\{\[]/.test(result)) {
|
||
value = result;
|
||
}
|
||
} catch (e) {}
|
||
|
||
if (!converter.write) {
|
||
value = encodeURIComponent(String(value))
|
||
.replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent);
|
||
} else {
|
||
value = converter.write(value, key);
|
||
}
|
||
|
||
key = encodeURIComponent(String(key));
|
||
key = key.replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent);
|
||
key = key.replace(/[\(\)]/g, escape);
|
||
|
||
var stringifiedAttributes = '';
|
||
|
||
for (var attributeName in attributes) {
|
||
if (!attributes[attributeName]) {
|
||
continue;
|
||
}
|
||
stringifiedAttributes += '; ' + attributeName;
|
||
if (attributes[attributeName] === true) {
|
||
continue;
|
||
}
|
||
stringifiedAttributes += '=' + attributes[attributeName];
|
||
}
|
||
return (document.cookie = key + '=' + value + stringifiedAttributes);
|
||
}
|
||
|
||
// Read
|
||
|
||
if (!key) {
|
||
result = {};
|
||
}
|
||
|
||
// To prevent the for loop in the first place assign an empty array
|
||
// in case there are no cookies at all. Also prevents odd result when
|
||
// calling "get()"
|
||
var cookies = document.cookie ? document.cookie.split('; ') : [];
|
||
var rdecode = /(%[0-9A-Z]{2})+/g;
|
||
var i = 0;
|
||
|
||
for (; i < cookies.length; i++) {
|
||
var parts = cookies[i].split('=');
|
||
var cookie = parts.slice(1).join('=');
|
||
|
||
if (!this.json && cookie.charAt(0) === '"') {
|
||
cookie = cookie.slice(1, -1);
|
||
}
|
||
|
||
try {
|
||
var name = parts[0].replace(rdecode, decodeURIComponent);
|
||
cookie = converter.read ?
|
||
converter.read(cookie, name) : converter(cookie, name) ||
|
||
cookie.replace(rdecode, decodeURIComponent);
|
||
|
||
if (this.json) {
|
||
try {
|
||
cookie = JSON.parse(cookie);
|
||
} catch (e) {}
|
||
}
|
||
|
||
if (key === name) {
|
||
result = cookie;
|
||
break;
|
||
}
|
||
|
||
if (!key) {
|
||
result[name] = cookie;
|
||
}
|
||
} catch (e) {}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
api.set = api;
|
||
api.get = function (key) {
|
||
return api.call(api, key);
|
||
};
|
||
api.getJSON = function () {
|
||
return api.apply({
|
||
json: true
|
||
}, [].slice.call(arguments));
|
||
};
|
||
api.defaults = {};
|
||
|
||
api.remove = function (key, attributes) {
|
||
api(key, '', extend(attributes, {
|
||
expires: -1
|
||
}));
|
||
};
|
||
|
||
api.withConverter = init;
|
||
|
||
return api;
|
||
}
|
||
|
||
return init(function () {});
|
||
}));
|
||
|
||
!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):e.moment=t()}(this,function(){"use strict";function e(){return Qe.apply(null,arguments)}function t(e){return e instanceof Array||"[object Array]"===Object.prototype.toString.call(e)}function n(e){return null!=e&&"[object Object]"===Object.prototype.toString.call(e)}function s(e){return void 0===e}function i(e){return"number"==typeof e||"[object Number]"===Object.prototype.toString.call(e)}function r(e){return e instanceof Date||"[object Date]"===Object.prototype.toString.call(e)}function a(e,t){var n,s=[];for(n=0;n<e.length;++n)s.push(t(e[n],n));return s}function o(e,t){return Object.prototype.hasOwnProperty.call(e,t)}function u(e,t){for(var n in t)o(t,n)&&(e[n]=t[n]);return o(t,"toString")&&(e.toString=t.toString),o(t,"valueOf")&&(e.valueOf=t.valueOf),e}function l(e,t,n,s){return ge(e,t,n,s,!0).utc()}function d(e){return null==e._pf&&(e._pf={empty:!1,unusedTokens:[],unusedInput:[],overflow:-2,charsLeftOver:0,nullInput:!1,invalidMonth:null,invalidFormat:!1,userInvalidated:!1,iso:!1,parsedDateParts:[],meridiem:null,rfc2822:!1,weekdayMismatch:!1}),e._pf}function h(e){if(null==e._isValid){var t=d(e),n=Xe.call(t.parsedDateParts,function(e){return null!=e}),s=!isNaN(e._d.getTime())&&t.overflow<0&&!t.empty&&!t.invalidMonth&&!t.invalidWeekday&&!t.weekdayMismatch&&!t.nullInput&&!t.invalidFormat&&!t.userInvalidated&&(!t.meridiem||t.meridiem&&n);if(e._strict&&(s=s&&0===t.charsLeftOver&&0===t.unusedTokens.length&&void 0===t.bigHour),null!=Object.isFrozen&&Object.isFrozen(e))return s;e._isValid=s}return e._isValid}function c(e){var t=l(NaN);return null!=e?u(d(t),e):d(t).userInvalidated=!0,t}function f(e,t){var n,i,r;if(s(t._isAMomentObject)||(e._isAMomentObject=t._isAMomentObject),s(t._i)||(e._i=t._i),s(t._f)||(e._f=t._f),s(t._l)||(e._l=t._l),s(t._strict)||(e._strict=t._strict),s(t._tzm)||(e._tzm=t._tzm),s(t._isUTC)||(e._isUTC=t._isUTC),s(t._offset)||(e._offset=t._offset),s(t._pf)||(e._pf=d(t)),s(t._locale)||(e._locale=t._locale),Ke.length>0)for(n=0;n<Ke.length;n++)s(r=t[i=Ke[n]])||(e[i]=r);return e}function m(t){f(this,t),this._d=new Date(null!=t._d?t._d.getTime():NaN),this.isValid()||(this._d=new Date(NaN)),!1===et&&(et=!0,e.updateOffset(this),et=!1)}function _(e){return e instanceof m||null!=e&&null!=e._isAMomentObject}function y(e){return e<0?Math.ceil(e)||0:Math.floor(e)}function g(e){var t=+e,n=0;return 0!==t&&isFinite(t)&&(n=y(t)),n}function p(e,t,n){var s,i=Math.min(e.length,t.length),r=Math.abs(e.length-t.length),a=0;for(s=0;s<i;s++)(n&&e[s]!==t[s]||!n&&g(e[s])!==g(t[s]))&&a++;return a+r}function w(t){!1===e.suppressDeprecationWarnings&&"undefined"!=typeof console&&console.warn&&console.warn("Deprecation warning: "+t)}function v(t,n){var s=!0;return u(function(){if(null!=e.deprecationHandler&&e.deprecationHandler(null,t),s){for(var i,r=[],a=0;a<arguments.length;a++){if(i="","object"==typeof arguments[a]){i+="\n["+a+"] ";for(var o in arguments[0])i+=o+": "+arguments[0][o]+", ";i=i.slice(0,-2)}else i=arguments[a];r.push(i)}w(t+"\nArguments: "+Array.prototype.slice.call(r).join("")+"\n"+(new Error).stack),s=!1}return n.apply(this,arguments)},n)}function M(t,n){null!=e.deprecationHandler&&e.deprecationHandler(t,n),tt[t]||(w(n),tt[t]=!0)}function k(e){return e instanceof Function||"[object Function]"===Object.prototype.toString.call(e)}function S(e,t){var s,i=u({},e);for(s in t)o(t,s)&&(n(e[s])&&n(t[s])?(i[s]={},u(i[s],e[s]),u(i[s],t[s])):null!=t[s]?i[s]=t[s]:delete i[s]);for(s in e)o(e,s)&&!o(t,s)&&n(e[s])&&(i[s]=u({},i[s]));return i}function D(e){null!=e&&this.set(e)}function Y(e,t){var n=e.toLowerCase();st[n]=st[n+"s"]=st[t]=e}function O(e){return"string"==typeof e?st[e]||st[e.toLowerCase()]:void 0}function x(e){var t,n,s={};for(n in e)o(e,n)&&(t=O(n))&&(s[t]=e[n]);return s}function T(e,t){it[e]=t}function b(e,t,n){var s=""+Math.abs(e),i=t-s.length;return(e>=0?n?"+":"":"-")+Math.pow(10,Math.max(0,i)).toString().substr(1)+s}function P(e,t,n,s){var i=s;"string"==typeof s&&(i=function(){return this[s]()}),e&&(ut[e]=i),t&&(ut[t[0]]=function(){return b(i.apply(this,arguments),t[1],t[2])}),n&&(ut[n]=function(){return this.localeData().ordinal(i.apply(this,arguments),e)})}function W(e){return e.match(/\[[\s\S]/)?e.replace(/^\[|\]$/g,""):e.replace(/\\/g,"")}function R(e,t){return e.isValid()?(t=C(t,e.localeData()),ot[t]=ot[t]||function(e){var t,n,s=e.match(rt);for(t=0,n=s.length;t<n;t++)ut[s[t]]?s[t]=ut[s[t]]:s[t]=W(s[t]);return function(t){var i,r="";for(i=0;i<n;i++)r+=k(s[i])?s[i].call(t,e):s[i];return r}}(t),ot[t](e)):e.localeData().invalidDate()}function C(e,t){function n(e){return t.longDateFormat(e)||e}var s=5;for(at.lastIndex=0;s>=0&&at.test(e);)e=e.replace(at,n),at.lastIndex=0,s-=1;return e}function F(e,t,n){Yt[e]=k(t)?t:function(e,s){return e&&n?n:t}}function U(e,t){return o(Yt,e)?Yt[e](t._strict,t._locale):new RegExp(function(e){return N(e.replace("\\","").replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,function(e,t,n,s,i){return t||n||s||i}))}(e))}function N(e){return e.replace(/[-\/\\^$*+?.()|[\]{}]/g,"\\$&")}function H(e,t){var n,s=t;for("string"==typeof e&&(e=[e]),i(t)&&(s=function(e,n){n[t]=g(e)}),n=0;n<e.length;n++)Ot[e[n]]=s}function L(e,t){H(e,function(e,n,s,i){s._w=s._w||{},t(e,s._w,s,i)})}function G(e,t,n){null!=t&&o(Ot,e)&&Ot[e](t,n._a,n,e)}function V(e){return j(e)?366:365}function j(e){return e%4==0&&e%100!=0||e%400==0}function I(t,n){return function(s){return null!=s?(A(this,t,s),e.updateOffset(this,n),this):E(this,t)}}function E(e,t){return e.isValid()?e._d["get"+(e._isUTC?"UTC":"")+t]():NaN}function A(e,t,n){e.isValid()&&!isNaN(n)&&("FullYear"===t&&j(e.year())&&1===e.month()&&29===e.date()?e._d["set"+(e._isUTC?"UTC":"")+t](n,e.month(),z(n,e.month())):e._d["set"+(e._isUTC?"UTC":"")+t](n))}function z(e,t){if(isNaN(e)||isNaN(t))return NaN;var n=function(e,t){return(e%t+t)%t}(t,12);return e+=(t-n)/12,1===n?j(e)?29:28:31-n%7%2}function Z(e,t){var n;if(!e.isValid())return e;if("string"==typeof t)if(/^\d+$/.test(t))t=g(t);else if(t=e.localeData().monthsParse(t),!i(t))return e;return n=Math.min(e.date(),z(e.year(),t)),e._d["set"+(e._isUTC?"UTC":"")+"Month"](t,n),e}function $(t){return null!=t?(Z(this,t),e.updateOffset(this,!0),this):E(this,"Month")}function q(){function e(e,t){return t.length-e.length}var t,n,s=[],i=[],r=[];for(t=0;t<12;t++)n=l([2e3,t]),s.push(this.monthsShort(n,"")),i.push(this.months(n,"")),r.push(this.months(n,"")),r.push(this.monthsShort(n,""));for(s.sort(e),i.sort(e),r.sort(e),t=0;t<12;t++)s[t]=N(s[t]),i[t]=N(i[t]);for(t=0;t<24;t++)r[t]=N(r[t]);this._monthsRegex=new RegExp("^("+r.join("|")+")","i"),this._monthsShortRegex=this._monthsRegex,this._monthsStrictRegex=new RegExp("^("+i.join("|")+")","i"),this._monthsShortStrictRegex=new RegExp("^("+s.join("|")+")","i")}function J(e){var t=new Date(Date.UTC.apply(null,arguments));return e<100&&e>=0&&isFinite(t.getUTCFullYear())&&t.setUTCFullYear(e),t}function B(e,t,n){var s=7+t-n;return-((7+J(e,0,s).getUTCDay()-t)%7)+s-1}function Q(e,t,n,s,i){var r,a,o=1+7*(t-1)+(7+n-s)%7+B(e,s,i);return o<=0?a=V(r=e-1)+o:o>V(e)?(r=e+1,a=o-V(e)):(r=e,a=o),{year:r,dayOfYear:a}}function X(e,t,n){var s,i,r=B(e.year(),t,n),a=Math.floor((e.dayOfYear()-r-1)/7)+1;return a<1?s=a+K(i=e.year()-1,t,n):a>K(e.year(),t,n)?(s=a-K(e.year(),t,n),i=e.year()+1):(i=e.year(),s=a),{week:s,year:i}}function K(e,t,n){var s=B(e,t,n),i=B(e+1,t,n);return(V(e)-s+i)/7}function ee(){function e(e,t){return t.length-e.length}var t,n,s,i,r,a=[],o=[],u=[],d=[];for(t=0;t<7;t++)n=l([2e3,1]).day(t),s=this.weekdaysMin(n,""),i=this.weekdaysShort(n,""),r=this.weekdays(n,""),a.push(s),o.push(i),u.push(r),d.push(s),d.push(i),d.push(r);for(a.sort(e),o.sort(e),u.sort(e),d.sort(e),t=0;t<7;t++)o[t]=N(o[t]),u[t]=N(u[t]),d[t]=N(d[t]);this._weekdaysRegex=new RegExp("^("+d.join("|")+")","i"),this._weekdaysShortRegex=this._weekdaysRegex,this._weekdaysMinRegex=this._weekdaysRegex,this._weekdaysStrictRegex=new RegExp("^("+u.join("|")+")","i"),this._weekdaysShortStrictRegex=new RegExp("^("+o.join("|")+")","i"),this._weekdaysMinStrictRegex=new RegExp("^("+a.join("|")+")","i")}function te(){return this.hours()%12||12}function ne(e,t){P(e,0,0,function(){return this.localeData().meridiem(this.hours(),this.minutes(),t)})}function se(e,t){return t._meridiemParse}function ie(e){return e?e.toLowerCase().replace("_","-"):e}function re(e){var t=null;if(!Xt[e]&&"undefined"!=typeof module&&module&&module.exports)try{t=Jt._abbr;require("./locale/"+e),ae(t)}catch(e){}return Xt[e]}function ae(e,t){var n;return e&&(n=s(t)?ue(e):oe(e,t))&&(Jt=n),Jt._abbr}function oe(e,t){if(null!==t){var n=Qt;if(t.abbr=e,null!=Xt[e])M("defineLocaleOverride","use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale See http://momentjs.com/guides/#/warnings/define-locale/ for more info."),n=Xt[e]._config;else if(null!=t.parentLocale){if(null==Xt[t.parentLocale])return Kt[t.parentLocale]||(Kt[t.parentLocale]=[]),Kt[t.parentLocale].push({name:e,config:t}),null;n=Xt[t.parentLocale]._config}return Xt[e]=new D(S(n,t)),Kt[e]&&Kt[e].forEach(function(e){oe(e.name,e.config)}),ae(e),Xt[e]}return delete Xt[e],null}function ue(e){var n;if(e&&e._locale&&e._locale._abbr&&(e=e._locale._abbr),!e)return Jt;if(!t(e)){if(n=re(e))return n;e=[e]}return function(e){for(var t,n,s,i,r=0;r<e.length;){for(t=(i=ie(e[r]).split("-")).length,n=(n=ie(e[r+1]))?n.split("-"):null;t>0;){if(s=re(i.slice(0,t).join("-")))return s;if(n&&n.length>=t&&p(i,n,!0)>=t-1)break;t--}r++}return null}(e)}function le(e){var t,n=e._a;return n&&-2===d(e).overflow&&(t=n[Tt]<0||n[Tt]>11?Tt:n[bt]<1||n[bt]>z(n[xt],n[Tt])?bt:n[Pt]<0||n[Pt]>24||24===n[Pt]&&(0!==n[Wt]||0!==n[Rt]||0!==n[Ct])?Pt:n[Wt]<0||n[Wt]>59?Wt:n[Rt]<0||n[Rt]>59?Rt:n[Ct]<0||n[Ct]>999?Ct:-1,d(e)._overflowDayOfYear&&(t<xt||t>bt)&&(t=bt),d(e)._overflowWeeks&&-1===t&&(t=Ft),d(e)._overflowWeekday&&-1===t&&(t=Ut),d(e).overflow=t),e}function de(e,t,n){return null!=e?e:null!=t?t:n}function he(t){var n,s,i,r,a,o=[];if(!t._d){for(i=function(t){var n=new Date(e.now());return t._useUTC?[n.getUTCFullYear(),n.getUTCMonth(),n.getUTCDate()]:[n.getFullYear(),n.getMonth(),n.getDate()]}(t),t._w&&null==t._a[bt]&&null==t._a[Tt]&&function(e){var t,n,s,i,r,a,o,u;if(null!=(t=e._w).GG||null!=t.W||null!=t.E)r=1,a=4,n=de(t.GG,e._a[xt],X(pe(),1,4).year),s=de(t.W,1),((i=de(t.E,1))<1||i>7)&&(u=!0);else{r=e._locale._week.dow,a=e._locale._week.doy;var l=X(pe(),r,a);n=de(t.gg,e._a[xt],l.year),s=de(t.w,l.week),null!=t.d?((i=t.d)<0||i>6)&&(u=!0):null!=t.e?(i=t.e+r,(t.e<0||t.e>6)&&(u=!0)):i=r}s<1||s>K(n,r,a)?d(e)._overflowWeeks=!0:null!=u?d(e)._overflowWeekday=!0:(o=Q(n,s,i,r,a),e._a[xt]=o.year,e._dayOfYear=o.dayOfYear)}(t),null!=t._dayOfYear&&(a=de(t._a[xt],i[xt]),(t._dayOfYear>V(a)||0===t._dayOfYear)&&(d(t)._overflowDayOfYear=!0),s=J(a,0,t._dayOfYear),t._a[Tt]=s.getUTCMonth(),t._a[bt]=s.getUTCDate()),n=0;n<3&&null==t._a[n];++n)t._a[n]=o[n]=i[n];for(;n<7;n++)t._a[n]=o[n]=null==t._a[n]?2===n?1:0:t._a[n];24===t._a[Pt]&&0===t._a[Wt]&&0===t._a[Rt]&&0===t._a[Ct]&&(t._nextDay=!0,t._a[Pt]=0),t._d=(t._useUTC?J:function(e,t,n,s,i,r,a){var o=new Date(e,t,n,s,i,r,a);return e<100&&e>=0&&isFinite(o.getFullYear())&&o.setFullYear(e),o}).apply(null,o),r=t._useUTC?t._d.getUTCDay():t._d.getDay(),null!=t._tzm&&t._d.setUTCMinutes(t._d.getUTCMinutes()-t._tzm),t._nextDay&&(t._a[Pt]=24),t._w&&void 0!==t._w.d&&t._w.d!==r&&(d(t).weekdayMismatch=!0)}}function ce(e){var t,n,s,i,r,a,o=e._i,u=en.exec(o)||tn.exec(o);if(u){for(d(e).iso=!0,t=0,n=sn.length;t<n;t++)if(sn[t][1].exec(u[1])){i=sn[t][0],s=!1!==sn[t][2];break}if(null==i)return void(e._isValid=!1);if(u[3]){for(t=0,n=rn.length;t<n;t++)if(rn[t][1].exec(u[3])){r=(u[2]||" ")+rn[t][0];break}if(null==r)return void(e._isValid=!1)}if(!s&&null!=r)return void(e._isValid=!1);if(u[4]){if(!nn.exec(u[4]))return void(e._isValid=!1);a="Z"}e._f=i+(r||"")+(a||""),_e(e)}else e._isValid=!1}function fe(e,t,n,s,i,r){var a=[function(e){var t=parseInt(e,10);{if(t<=49)return 2e3+t;if(t<=999)return 1900+t}return t}(e),Vt.indexOf(t),parseInt(n,10),parseInt(s,10),parseInt(i,10)];return r&&a.push(parseInt(r,10)),a}function me(e){var t=on.exec(function(e){return e.replace(/\([^)]*\)|[\n\t]/g," ").replace(/(\s\s+)/g," ").trim()}(e._i));if(t){var n=fe(t[4],t[3],t[2],t[5],t[6],t[7]);if(!function(e,t,n){if(e&&At.indexOf(e)!==new Date(t[0],t[1],t[2]).getDay())return d(n).weekdayMismatch=!0,n._isValid=!1,!1;return!0}(t[1],n,e))return;e._a=n,e._tzm=function(e,t,n){if(e)return un[e];if(t)return 0;var s=parseInt(n,10),i=s%100;return(s-i)/100*60+i}(t[8],t[9],t[10]),e._d=J.apply(null,e._a),e._d.setUTCMinutes(e._d.getUTCMinutes()-e._tzm),d(e).rfc2822=!0}else e._isValid=!1}function _e(t){if(t._f!==e.ISO_8601)if(t._f!==e.RFC_2822){t._a=[],d(t).empty=!0;var n,s,i,r,a,o=""+t._i,u=o.length,l=0;for(i=C(t._f,t._locale).match(rt)||[],n=0;n<i.length;n++)r=i[n],(s=(o.match(U(r,t))||[])[0])&&((a=o.substr(0,o.indexOf(s))).length>0&&d(t).unusedInput.push(a),o=o.slice(o.indexOf(s)+s.length),l+=s.length),ut[r]?(s?d(t).empty=!1:d(t).unusedTokens.push(r),G(r,s,t)):t._strict&&!s&&d(t).unusedTokens.push(r);d(t).charsLeftOver=u-l,o.length>0&&d(t).unusedInput.push(o),t._a[Pt]<=12&&!0===d(t).bigHour&&t._a[Pt]>0&&(d(t).bigHour=void 0),d(t).parsedDateParts=t._a.slice(0),d(t).meridiem=t._meridiem,t._a[Pt]=function(e,t,n){var s;if(null==n)return t;return null!=e.meridiemHour?e.meridiemHour(t,n):null!=e.isPM?((s=e.isPM(n))&&t<12&&(t+=12),s||12!==t||(t=0),t):t}(t._locale,t._a[Pt],t._meridiem),he(t),le(t)}else me(t);else ce(t)}function ye(o){var l=o._i,y=o._f;return o._locale=o._locale||ue(o._l),null===l||void 0===y&&""===l?c({nullInput:!0}):("string"==typeof l&&(o._i=l=o._locale.preparse(l)),_(l)?new m(le(l)):(r(l)?o._d=l:t(y)?function(e){var t,n,s,i,r;if(0===e._f.length)return d(e).invalidFormat=!0,void(e._d=new Date(NaN));for(i=0;i<e._f.length;i++)r=0,t=f({},e),null!=e._useUTC&&(t._useUTC=e._useUTC),t._f=e._f[i],_e(t),h(t)&&(r+=d(t).charsLeftOver,r+=10*d(t).unusedTokens.length,d(t).score=r,(null==s||r<s)&&(s=r,n=t));u(e,n||t)}(o):y?_e(o):function(o){var u=o._i;s(u)?o._d=new Date(e.now()):r(u)?o._d=new Date(u.valueOf()):"string"==typeof u?function(t){var n=an.exec(t._i);null===n?(ce(t),!1===t._isValid&&(delete t._isValid,me(t),!1===t._isValid&&(delete t._isValid,e.createFromInputFallback(t)))):t._d=new Date(+n[1])}(o):t(u)?(o._a=a(u.slice(0),function(e){return parseInt(e,10)}),he(o)):n(u)?function(e){if(!e._d){var t=x(e._i);e._a=a([t.year,t.month,t.day||t.date,t.hour,t.minute,t.second,t.millisecond],function(e){return e&&parseInt(e,10)}),he(e)}}(o):i(u)?o._d=new Date(u):e.createFromInputFallback(o)}(o),h(o)||(o._d=null),o))}function ge(e,s,i,r,a){var o={};return!0!==i&&!1!==i||(r=i,i=void 0),(n(e)&&function(e){if(Object.getOwnPropertyNames)return 0===Object.getOwnPropertyNames(e).length;var t;for(t in e)if(e.hasOwnProperty(t))return!1;return!0}(e)||t(e)&&0===e.length)&&(e=void 0),o._isAMomentObject=!0,o._useUTC=o._isUTC=a,o._l=i,o._i=e,o._f=s,o._strict=r,function(e){var t=new m(le(ye(e)));return t._nextDay&&(t.add(1,"d"),t._nextDay=void 0),t}(o)}function pe(e,t,n,s){return ge(e,t,n,s,!1)}function we(e,n){var s,i;if(1===n.length&&t(n[0])&&(n=n[0]),!n.length)return pe();for(s=n[0],i=1;i<n.length;++i)n[i].isValid()&&!n[i][e](s)||(s=n[i]);return s}function ve(e){var t=x(e),n=t.year||0,s=t.quarter||0,i=t.month||0,r=t.week||0,a=t.day||0,o=t.hour||0,u=t.minute||0,l=t.second||0,d=t.millisecond||0;this._isValid=function(e){for(var t in e)if(-1===Nt.call(hn,t)||null!=e[t]&&isNaN(e[t]))return!1;for(var n=!1,s=0;s<hn.length;++s)if(e[hn[s]]){if(n)return!1;parseFloat(e[hn[s]])!==g(e[hn[s]])&&(n=!0)}return!0}(t),this._milliseconds=+d+1e3*l+6e4*u+1e3*o*60*60,this._days=+a+7*r,this._months=+i+3*s+12*n,this._data={},this._locale=ue(),this._bubble()}function Me(e){return e instanceof ve}function ke(e){return e<0?-1*Math.round(-1*e):Math.round(e)}function Se(e,t){P(e,0,0,function(){var e=this.utcOffset(),n="+";return e<0&&(e=-e,n="-"),n+b(~~(e/60),2)+t+b(~~e%60,2)})}function De(e,t){var n=(t||"").match(e);if(null===n)return null;var s=((n[n.length-1]||[])+"").match(cn)||["-",0,0],i=60*s[1]+g(s[2]);return 0===i?0:"+"===s[0]?i:-i}function Ye(t,n){var s,i;return n._isUTC?(s=n.clone(),i=(_(t)||r(t)?t.valueOf():pe(t).valueOf())-s.valueOf(),s._d.setTime(s._d.valueOf()+i),e.updateOffset(s,!1),s):pe(t).local()}function Oe(e){return 15*-Math.round(e._d.getTimezoneOffset()/15)}function xe(){return!!this.isValid()&&(this._isUTC&&0===this._offset)}function Te(e,t){var n,s,r,a=e,u=null;return Me(e)?a={ms:e._milliseconds,d:e._days,M:e._months}:i(e)?(a={},t?a[t]=e:a.milliseconds=e):(u=fn.exec(e))?(n="-"===u[1]?-1:1,a={y:0,d:g(u[bt])*n,h:g(u[Pt])*n,m:g(u[Wt])*n,s:g(u[Rt])*n,ms:g(ke(1e3*u[Ct]))*n}):(u=mn.exec(e))?(n="-"===u[1]?-1:(u[1],1),a={y:be(u[2],n),M:be(u[3],n),w:be(u[4],n),d:be(u[5],n),h:be(u[6],n),m:be(u[7],n),s:be(u[8],n)}):null==a?a={}:"object"==typeof a&&("from"in a||"to"in a)&&(r=function(e,t){var n;if(!e.isValid()||!t.isValid())return{milliseconds:0,months:0};t=Ye(t,e),e.isBefore(t)?n=Pe(e,t):((n=Pe(t,e)).milliseconds=-n.milliseconds,n.months=-n.months);return n}(pe(a.from),pe(a.to)),(a={}).ms=r.milliseconds,a.M=r.months),s=new ve(a),Me(e)&&o(e,"_locale")&&(s._locale=e._locale),s}function be(e,t){var n=e&&parseFloat(e.replace(",","."));return(isNaN(n)?0:n)*t}function Pe(e,t){var n={milliseconds:0,months:0};return n.months=t.month()-e.month()+12*(t.year()-e.year()),e.clone().add(n.months,"M").isAfter(t)&&--n.months,n.milliseconds=+t-+e.clone().add(n.months,"M"),n}function We(e,t){return function(n,s){var i,r;return null===s||isNaN(+s)||(M(t,"moment()."+t+"(period, number) is deprecated. Please use moment()."+t+"(number, period). See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info."),r=n,n=s,s=r),n="string"==typeof n?+n:n,i=Te(n,s),Re(this,i,e),this}}function Re(t,n,s,i){var r=n._milliseconds,a=ke(n._days),o=ke(n._months);t.isValid()&&(i=null==i||i,o&&Z(t,E(t,"Month")+o*s),a&&A(t,"Date",E(t,"Date")+a*s),r&&t._d.setTime(t._d.valueOf()+r*s),i&&e.updateOffset(t,a||o))}function Ce(e,t){var n,s=12*(t.year()-e.year())+(t.month()-e.month()),i=e.clone().add(s,"months");return n=t-i<0?(t-i)/(i-e.clone().add(s-1,"months")):(t-i)/(e.clone().add(s+1,"months")-i),-(s+n)||0}function Fe(e){var t;return void 0===e?this._locale._abbr:(null!=(t=ue(e))&&(this._locale=t),this)}function Ue(){return this._locale}function Ne(e,t){P(0,[e,e.length],0,t)}function He(e,t,n,s,i){var r;return null==e?X(this,s,i).year:(r=K(e,s,i),t>r&&(t=r),function(e,t,n,s,i){var r=Q(e,t,n,s,i),a=J(r.year,0,r.dayOfYear);return this.year(a.getUTCFullYear()),this.month(a.getUTCMonth()),this.date(a.getUTCDate()),this}.call(this,e,t,n,s,i))}function Le(e,t){t[Ct]=g(1e3*("0."+e))}function Ge(e){return e}function Ve(e,t,n,s){var i=ue(),r=l().set(s,t);return i[n](r,e)}function je(e,t,n){if(i(e)&&(t=e,e=void 0),e=e||"",null!=t)return Ve(e,t,n,"month");var s,r=[];for(s=0;s<12;s++)r[s]=Ve(e,s,n,"month");return r}function Ie(e,t,n,s){"boolean"==typeof e?(i(t)&&(n=t,t=void 0),t=t||""):(n=t=e,e=!1,i(t)&&(n=t,t=void 0),t=t||"");var r=ue(),a=e?r._week.dow:0;if(null!=n)return Ve(t,(n+a)%7,s,"day");var o,u=[];for(o=0;o<7;o++)u[o]=Ve(t,(o+a)%7,s,"day");return u}function Ee(e,t,n,s){var i=Te(t,n);return e._milliseconds+=s*i._milliseconds,e._days+=s*i._days,e._months+=s*i._months,e._bubble()}function Ae(e){return e<0?Math.floor(e):Math.ceil(e)}function ze(e){return 4800*e/146097}function Ze(e){return 146097*e/4800}function $e(e){return function(){return this.as(e)}}function qe(e){return function(){return this.isValid()?this._data[e]:NaN}}function Je(e){return(e>0)-(e<0)||+e}function Be(){if(!this.isValid())return this.localeData().invalidDate();var e,t,n=En(this._milliseconds)/1e3,s=En(this._days),i=En(this._months);t=y((e=y(n/60))/60),n%=60,e%=60;var r=y(i/12),a=i%=12,o=s,u=t,l=e,d=n?n.toFixed(3).replace(/\.?0+$/,""):"",h=this.asSeconds();if(!h)return"P0D";var c=h<0?"-":"",f=Je(this._months)!==Je(h)?"-":"",m=Je(this._days)!==Je(h)?"-":"",_=Je(this._milliseconds)!==Je(h)?"-":"";return c+"P"+(r?f+r+"Y":"")+(a?f+a+"M":"")+(o?m+o+"D":"")+(u||l||d?"T":"")+(u?_+u+"H":"")+(l?_+l+"M":"")+(d?_+d+"S":"")}var Qe,Xe;Xe=Array.prototype.some?Array.prototype.some:function(e){for(var t=Object(this),n=t.length>>>0,s=0;s<n;s++)if(s in t&&e.call(this,t[s],s,t))return!0;return!1};var Ke=e.momentProperties=[],et=!1,tt={};e.suppressDeprecationWarnings=!1,e.deprecationHandler=null;var nt;nt=Object.keys?Object.keys:function(e){var t,n=[];for(t in e)o(e,t)&&n.push(t);return n};var st={},it={},rt=/(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,at=/(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,ot={},ut={},lt=/\d/,dt=/\d\d/,ht=/\d{3}/,ct=/\d{4}/,ft=/[+-]?\d{6}/,mt=/\d\d?/,_t=/\d\d\d\d?/,yt=/\d\d\d\d\d\d?/,gt=/\d{1,3}/,pt=/\d{1,4}/,wt=/[+-]?\d{1,6}/,vt=/\d+/,Mt=/[+-]?\d+/,kt=/Z|[+-]\d\d:?\d\d/gi,St=/Z|[+-]\d\d(?::?\d\d)?/gi,Dt=/[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i,Yt={},Ot={},xt=0,Tt=1,bt=2,Pt=3,Wt=4,Rt=5,Ct=6,Ft=7,Ut=8;P("Y",0,0,function(){var e=this.year();return e<=9999?""+e:"+"+e}),P(0,["YY",2],0,function(){return this.year()%100}),P(0,["YYYY",4],0,"year"),P(0,["YYYYY",5],0,"year"),P(0,["YYYYYY",6,!0],0,"year"),Y("year","y"),T("year",1),F("Y",Mt),F("YY",mt,dt),F("YYYY",pt,ct),F("YYYYY",wt,ft),F("YYYYYY",wt,ft),H(["YYYYY","YYYYYY"],xt),H("YYYY",function(t,n){n[xt]=2===t.length?e.parseTwoDigitYear(t):g(t)}),H("YY",function(t,n){n[xt]=e.parseTwoDigitYear(t)}),H("Y",function(e,t){t[xt]=parseInt(e,10)}),e.parseTwoDigitYear=function(e){return g(e)+(g(e)>68?1900:2e3)};var Nt,Ht=I("FullYear",!0);Nt=Array.prototype.indexOf?Array.prototype.indexOf:function(e){var t;for(t=0;t<this.length;++t)if(this[t]===e)return t;return-1},P("M",["MM",2],"Mo",function(){return this.month()+1}),P("MMM",0,0,function(e){return this.localeData().monthsShort(this,e)}),P("MMMM",0,0,function(e){return this.localeData().months(this,e)}),Y("month","M"),T("month",8),F("M",mt),F("MM",mt,dt),F("MMM",function(e,t){return t.monthsShortRegex(e)}),F("MMMM",function(e,t){return t.monthsRegex(e)}),H(["M","MM"],function(e,t){t[Tt]=g(e)-1}),H(["MMM","MMMM"],function(e,t,n,s){var i=n._locale.monthsParse(e,s,n._strict);null!=i?t[Tt]=i:d(n).invalidMonth=e});var Lt=/D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,Gt="January_February_March_April_May_June_July_August_September_October_November_December".split("_"),Vt="Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),jt=Dt,It=Dt;P("w",["ww",2],"wo","week"),P("W",["WW",2],"Wo","isoWeek"),Y("week","w"),Y("isoWeek","W"),T("week",5),T("isoWeek",5),F("w",mt),F("ww",mt,dt),F("W",mt),F("WW",mt,dt),L(["w","ww","W","WW"],function(e,t,n,s){t[s.substr(0,1)]=g(e)});P("d",0,"do","day"),P("dd",0,0,function(e){return this.localeData().weekdaysMin(this,e)}),P("ddd",0,0,function(e){return this.localeData().weekdaysShort(this,e)}),P("dddd",0,0,function(e){return this.localeData().weekdays(this,e)}),P("e",0,0,"weekday"),P("E",0,0,"isoWeekday"),Y("day","d"),Y("weekday","e"),Y("isoWeekday","E"),T("day",11),T("weekday",11),T("isoWeekday",11),F("d",mt),F("e",mt),F("E",mt),F("dd",function(e,t){return t.weekdaysMinRegex(e)}),F("ddd",function(e,t){return t.weekdaysShortRegex(e)}),F("dddd",function(e,t){return t.weekdaysRegex(e)}),L(["dd","ddd","dddd"],function(e,t,n,s){var i=n._locale.weekdaysParse(e,s,n._strict);null!=i?t.d=i:d(n).invalidWeekday=e}),L(["d","e","E"],function(e,t,n,s){t[s]=g(e)});var Et="Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),At="Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),zt="Su_Mo_Tu_We_Th_Fr_Sa".split("_"),Zt=Dt,$t=Dt,qt=Dt;P("H",["HH",2],0,"hour"),P("h",["hh",2],0,te),P("k",["kk",2],0,function(){return this.hours()||24}),P("hmm",0,0,function(){return""+te.apply(this)+b(this.minutes(),2)}),P("hmmss",0,0,function(){return""+te.apply(this)+b(this.minutes(),2)+b(this.seconds(),2)}),P("Hmm",0,0,function(){return""+this.hours()+b(this.minutes(),2)}),P("Hmmss",0,0,function(){return""+this.hours()+b(this.minutes(),2)+b(this.seconds(),2)}),ne("a",!0),ne("A",!1),Y("hour","h"),T("hour",13),F("a",se),F("A",se),F("H",mt),F("h",mt),F("k",mt),F("HH",mt,dt),F("hh",mt,dt),F("kk",mt,dt),F("hmm",_t),F("hmmss",yt),F("Hmm",_t),F("Hmmss",yt),H(["H","HH"],Pt),H(["k","kk"],function(e,t,n){var s=g(e);t[Pt]=24===s?0:s}),H(["a","A"],function(e,t,n){n._isPm=n._locale.isPM(e),n._meridiem=e}),H(["h","hh"],function(e,t,n){t[Pt]=g(e),d(n).bigHour=!0}),H("hmm",function(e,t,n){var s=e.length-2;t[Pt]=g(e.substr(0,s)),t[Wt]=g(e.substr(s)),d(n).bigHour=!0}),H("hmmss",function(e,t,n){var s=e.length-4,i=e.length-2;t[Pt]=g(e.substr(0,s)),t[Wt]=g(e.substr(s,2)),t[Rt]=g(e.substr(i)),d(n).bigHour=!0}),H("Hmm",function(e,t,n){var s=e.length-2;t[Pt]=g(e.substr(0,s)),t[Wt]=g(e.substr(s))}),H("Hmmss",function(e,t,n){var s=e.length-4,i=e.length-2;t[Pt]=g(e.substr(0,s)),t[Wt]=g(e.substr(s,2)),t[Rt]=g(e.substr(i))});var Jt,Bt=I("Hours",!0),Qt={calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},longDateFormat:{LTS:"h:mm:ss A",LT:"h:mm A",L:"MM/DD/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"},invalidDate:"Invalid date",ordinal:"%d",dayOfMonthOrdinalParse:/\d{1,2}/,relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},months:Gt,monthsShort:Vt,week:{dow:0,doy:6},weekdays:Et,weekdaysMin:zt,weekdaysShort:At,meridiemParse:/[ap]\.?m?\.?/i},Xt={},Kt={},en=/^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/,tn=/^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/,nn=/Z|[+-]\d\d(?::?\d\d)?/,sn=[["YYYYYY-MM-DD",/[+-]\d{6}-\d\d-\d\d/],["YYYY-MM-DD",/\d{4}-\d\d-\d\d/],["GGGG-[W]WW-E",/\d{4}-W\d\d-\d/],["GGGG-[W]WW",/\d{4}-W\d\d/,!1],["YYYY-DDD",/\d{4}-\d{3}/],["YYYY-MM",/\d{4}-\d\d/,!1],["YYYYYYMMDD",/[+-]\d{10}/],["YYYYMMDD",/\d{8}/],["GGGG[W]WWE",/\d{4}W\d{3}/],["GGGG[W]WW",/\d{4}W\d{2}/,!1],["YYYYDDD",/\d{7}/]],rn=[["HH:mm:ss.SSSS",/\d\d:\d\d:\d\d\.\d+/],["HH:mm:ss,SSSS",/\d\d:\d\d:\d\d,\d+/],["HH:mm:ss",/\d\d:\d\d:\d\d/],["HH:mm",/\d\d:\d\d/],["HHmmss.SSSS",/\d\d\d\d\d\d\.\d+/],["HHmmss,SSSS",/\d\d\d\d\d\d,\d+/],["HHmmss",/\d\d\d\d\d\d/],["HHmm",/\d\d\d\d/],["HH",/\d\d/]],an=/^\/?Date\((\-?\d+)/i,on=/^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/,un={UT:0,GMT:0,EDT:-240,EST:-300,CDT:-300,CST:-360,MDT:-360,MST:-420,PDT:-420,PST:-480};e.createFromInputFallback=v("value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are discouraged and will be removed in an upcoming major release. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.",function(e){e._d=new Date(e._i+(e._useUTC?" UTC":""))}),e.ISO_8601=function(){},e.RFC_2822=function(){};var ln=v("moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/",function(){var e=pe.apply(null,arguments);return this.isValid()&&e.isValid()?e<this?this:e:c()}),dn=v("moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/",function(){var e=pe.apply(null,arguments);return this.isValid()&&e.isValid()?e>this?this:e:c()}),hn=["year","quarter","month","week","day","hour","minute","second","millisecond"];Se("Z",":"),Se("ZZ",""),F("Z",St),F("ZZ",St),H(["Z","ZZ"],function(e,t,n){n._useUTC=!0,n._tzm=De(St,e)});var cn=/([\+\-]|\d\d)/gi;e.updateOffset=function(){};var fn=/^(\-|\+)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/,mn=/^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;Te.fn=ve.prototype,Te.invalid=function(){return Te(NaN)};var _n=We(1,"add"),yn=We(-1,"subtract");e.defaultFormat="YYYY-MM-DDTHH:mm:ssZ",e.defaultFormatUtc="YYYY-MM-DDTHH:mm:ss[Z]";var gn=v("moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.",function(e){return void 0===e?this.localeData():this.locale(e)});P(0,["gg",2],0,function(){return this.weekYear()%100}),P(0,["GG",2],0,function(){return this.isoWeekYear()%100}),Ne("gggg","weekYear"),Ne("ggggg","weekYear"),Ne("GGGG","isoWeekYear"),Ne("GGGGG","isoWeekYear"),Y("weekYear","gg"),Y("isoWeekYear","GG"),T("weekYear",1),T("isoWeekYear",1),F("G",Mt),F("g",Mt),F("GG",mt,dt),F("gg",mt,dt),F("GGGG",pt,ct),F("gggg",pt,ct),F("GGGGG",wt,ft),F("ggggg",wt,ft),L(["gggg","ggggg","GGGG","GGGGG"],function(e,t,n,s){t[s.substr(0,2)]=g(e)}),L(["gg","GG"],function(t,n,s,i){n[i]=e.parseTwoDigitYear(t)}),P("Q",0,"Qo","quarter"),Y("quarter","Q"),T("quarter",7),F("Q",lt),H("Q",function(e,t){t[Tt]=3*(g(e)-1)}),P("D",["DD",2],"Do","date"),Y("date","D"),T("date",9),F("D",mt),F("DD",mt,dt),F("Do",function(e,t){return e?t._dayOfMonthOrdinalParse||t._ordinalParse:t._dayOfMonthOrdinalParseLenient}),H(["D","DD"],bt),H("Do",function(e,t){t[bt]=g(e.match(mt)[0])});var pn=I("Date",!0);P("DDD",["DDDD",3],"DDDo","dayOfYear"),Y("dayOfYear","DDD"),T("dayOfYear",4),F("DDD",gt),F("DDDD",ht),H(["DDD","DDDD"],function(e,t,n){n._dayOfYear=g(e)}),P("m",["mm",2],0,"minute"),Y("minute","m"),T("minute",14),F("m",mt),F("mm",mt,dt),H(["m","mm"],Wt);var wn=I("Minutes",!1);P("s",["ss",2],0,"second"),Y("second","s"),T("second",15),F("s",mt),F("ss",mt,dt),H(["s","ss"],Rt);var vn=I("Seconds",!1);P("S",0,0,function(){return~~(this.millisecond()/100)}),P(0,["SS",2],0,function(){return~~(this.millisecond()/10)}),P(0,["SSS",3],0,"millisecond"),P(0,["SSSS",4],0,function(){return 10*this.millisecond()}),P(0,["SSSSS",5],0,function(){return 100*this.millisecond()}),P(0,["SSSSSS",6],0,function(){return 1e3*this.millisecond()}),P(0,["SSSSSSS",7],0,function(){return 1e4*this.millisecond()}),P(0,["SSSSSSSS",8],0,function(){return 1e5*this.millisecond()}),P(0,["SSSSSSSSS",9],0,function(){return 1e6*this.millisecond()}),Y("millisecond","ms"),T("millisecond",16),F("S",gt,lt),F("SS",gt,dt),F("SSS",gt,ht);var Mn;for(Mn="SSSS";Mn.length<=9;Mn+="S")F(Mn,vt);for(Mn="S";Mn.length<=9;Mn+="S")H(Mn,Le);var kn=I("Milliseconds",!1);P("z",0,0,"zoneAbbr"),P("zz",0,0,"zoneName");var Sn=m.prototype;Sn.add=_n,Sn.calendar=function(t,n){var s=t||pe(),i=Ye(s,this).startOf("day"),r=e.calendarFormat(this,i)||"sameElse",a=n&&(k(n[r])?n[r].call(this,s):n[r]);return this.format(a||this.localeData().calendar(r,this,pe(s)))},Sn.clone=function(){return new m(this)},Sn.diff=function(e,t,n){var s,i,r;if(!this.isValid())return NaN;if(!(s=Ye(e,this)).isValid())return NaN;switch(i=6e4*(s.utcOffset()-this.utcOffset()),t=O(t)){case"year":r=Ce(this,s)/12;break;case"month":r=Ce(this,s);break;case"quarter":r=Ce(this,s)/3;break;case"second":r=(this-s)/1e3;break;case"minute":r=(this-s)/6e4;break;case"hour":r=(this-s)/36e5;break;case"day":r=(this-s-i)/864e5;break;case"week":r=(this-s-i)/6048e5;break;default:r=this-s}return n?r:y(r)},Sn.endOf=function(e){return void 0===(e=O(e))||"millisecond"===e?this:("date"===e&&(e="day"),this.startOf(e).add(1,"isoWeek"===e?"week":e).subtract(1,"ms"))},Sn.format=function(t){t||(t=this.isUtc()?e.defaultFormatUtc:e.defaultFormat);var n=R(this,t);return this.localeData().postformat(n)},Sn.from=function(e,t){return this.isValid()&&(_(e)&&e.isValid()||pe(e).isValid())?Te({to:this,from:e}).locale(this.locale()).humanize(!t):this.localeData().invalidDate()},Sn.fromNow=function(e){return this.from(pe(),e)},Sn.to=function(e,t){return this.isValid()&&(_(e)&&e.isValid()||pe(e).isValid())?Te({from:this,to:e}).locale(this.locale()).humanize(!t):this.localeData().invalidDate()},Sn.toNow=function(e){return this.to(pe(),e)},Sn.get=function(e){return e=O(e),k(this[e])?this[e]():this},Sn.invalidAt=function(){return d(this).overflow},Sn.isAfter=function(e,t){var n=_(e)?e:pe(e);return!(!this.isValid()||!n.isValid())&&("millisecond"===(t=O(s(t)?"millisecond":t))?this.valueOf()>n.valueOf():n.valueOf()<this.clone().startOf(t).valueOf())},Sn.isBefore=function(e,t){var n=_(e)?e:pe(e);return!(!this.isValid()||!n.isValid())&&("millisecond"===(t=O(s(t)?"millisecond":t))?this.valueOf()<n.valueOf():this.clone().endOf(t).valueOf()<n.valueOf())},Sn.isBetween=function(e,t,n,s){return("("===(s=s||"()")[0]?this.isAfter(e,n):!this.isBefore(e,n))&&(")"===s[1]?this.isBefore(t,n):!this.isAfter(t,n))},Sn.isSame=function(e,t){var n,s=_(e)?e:pe(e);return!(!this.isValid()||!s.isValid())&&("millisecond"===(t=O(t||"millisecond"))?this.valueOf()===s.valueOf():(n=s.valueOf(),this.clone().startOf(t).valueOf()<=n&&n<=this.clone().endOf(t).valueOf()))},Sn.isSameOrAfter=function(e,t){return this.isSame(e,t)||this.isAfter(e,t)},Sn.isSameOrBefore=function(e,t){return this.isSame(e,t)||this.isBefore(e,t)},Sn.isValid=function(){return h(this)},Sn.lang=gn,Sn.locale=Fe,Sn.localeData=Ue,Sn.max=dn,Sn.min=ln,Sn.parsingFlags=function(){return u({},d(this))},Sn.set=function(e,t){if("object"==typeof e)for(var n=function(e){var t=[];for(var n in e)t.push({unit:n,priority:it[n]});return t.sort(function(e,t){return e.priority-t.priority}),t}(e=x(e)),s=0;s<n.length;s++)this[n[s].unit](e[n[s].unit]);else if(e=O(e),k(this[e]))return this[e](t);return this},Sn.startOf=function(e){switch(e=O(e)){case"year":this.month(0);case"quarter":case"month":this.date(1);case"week":case"isoWeek":case"day":case"date":this.hours(0);case"hour":this.minutes(0);case"minute":this.seconds(0);case"second":this.milliseconds(0)}return"week"===e&&this.weekday(0),"isoWeek"===e&&this.isoWeekday(1),"quarter"===e&&this.month(3*Math.floor(this.month()/3)),this},Sn.subtract=yn,Sn.toArray=function(){return[this.year(),this.month(),this.date(),this.hour(),this.minute(),this.second(),this.millisecond()]},Sn.toObject=function(){return{years:this.year(),months:this.month(),date:this.date(),hours:this.hours(),minutes:this.minutes(),seconds:this.seconds(),milliseconds:this.milliseconds()}},Sn.toDate=function(){return new Date(this.valueOf())},Sn.toISOString=function(){if(!this.isValid())return null;var e=this.clone().utc();return e.year()<0||e.year()>9999?R(e,"YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]"):k(Date.prototype.toISOString)?this.toDate().toISOString():R(e,"YYYY-MM-DD[T]HH:mm:ss.SSS[Z]")},Sn.inspect=function(){if(!this.isValid())return"moment.invalid(/* "+this._i+" */)";var e="moment",t="";this.isLocal()||(e=0===this.utcOffset()?"moment.utc":"moment.parseZone",t="Z");var n="["+e+'("]',s=0<=this.year()&&this.year()<=9999?"YYYY":"YYYYYY",i=t+'[")]';return this.format(n+s+"-MM-DD[T]HH:mm:ss.SSS"+i)},Sn.toJSON=function(){return this.isValid()?this.toISOString():null},Sn.toString=function(){return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ")},Sn.unix=function(){return Math.floor(this.valueOf()/1e3)},Sn.valueOf=function(){return this._d.valueOf()-6e4*(this._offset||0)},Sn.creationData=function(){return{input:this._i,format:this._f,locale:this._locale,isUTC:this._isUTC,strict:this._strict}},Sn.year=Ht,Sn.isLeapYear=function(){return j(this.year())},Sn.weekYear=function(e){return He.call(this,e,this.week(),this.weekday(),this.localeData()._week.dow,this.localeData()._week.doy)},Sn.isoWeekYear=function(e){return He.call(this,e,this.isoWeek(),this.isoWeekday(),1,4)},Sn.quarter=Sn.quarters=function(e){return null==e?Math.ceil((this.month()+1)/3):this.month(3*(e-1)+this.month()%3)},Sn.month=$,Sn.daysInMonth=function(){return z(this.year(),this.month())},Sn.week=Sn.weeks=function(e){var t=this.localeData().week(this);return null==e?t:this.add(7*(e-t),"d")},Sn.isoWeek=Sn.isoWeeks=function(e){var t=X(this,1,4).week;return null==e?t:this.add(7*(e-t),"d")},Sn.weeksInYear=function(){var e=this.localeData()._week;return K(this.year(),e.dow,e.doy)},Sn.isoWeeksInYear=function(){return K(this.year(),1,4)},Sn.date=pn,Sn.day=Sn.days=function(e){if(!this.isValid())return null!=e?this:NaN;var t=this._isUTC?this._d.getUTCDay():this._d.getDay();return null!=e?(e=function(e,t){return"string"!=typeof e?e:isNaN(e)?"number"==typeof(e=t.weekdaysParse(e))?e:null:parseInt(e,10)}(e,this.localeData()),this.add(e-t,"d")):t},Sn.weekday=function(e){if(!this.isValid())return null!=e?this:NaN;var t=(this.day()+7-this.localeData()._week.dow)%7;return null==e?t:this.add(e-t,"d")},Sn.isoWeekday=function(e){if(!this.isValid())return null!=e?this:NaN;if(null!=e){var t=function(e,t){return"string"==typeof e?t.weekdaysParse(e)%7||7:isNaN(e)?null:e}(e,this.localeData());return this.day(this.day()%7?t:t-7)}return this.day()||7},Sn.dayOfYear=function(e){var t=Math.round((this.clone().startOf("day")-this.clone().startOf("year"))/864e5)+1;return null==e?t:this.add(e-t,"d")},Sn.hour=Sn.hours=Bt,Sn.minute=Sn.minutes=wn,Sn.second=Sn.seconds=vn,Sn.millisecond=Sn.milliseconds=kn,Sn.utcOffset=function(t,n,s){var i,r=this._offset||0;if(!this.isValid())return null!=t?this:NaN;if(null!=t){if("string"==typeof t){if(null===(t=De(St,t)))return this}else Math.abs(t)<16&&!s&&(t*=60);return!this._isUTC&&n&&(i=Oe(this)),this._offset=t,this._isUTC=!0,null!=i&&this.add(i,"m"),r!==t&&(!n||this._changeInProgress?Re(this,Te(t-r,"m"),1,!1):this._changeInProgress||(this._changeInProgress=!0,e.updateOffset(this,!0),this._changeInProgress=null)),this}return this._isUTC?r:Oe(this)},Sn.utc=function(e){return this.utcOffset(0,e)},Sn.local=function(e){return this._isUTC&&(this.utcOffset(0,e),this._isUTC=!1,e&&this.subtract(Oe(this),"m")),this},Sn.parseZone=function(){if(null!=this._tzm)this.utcOffset(this._tzm,!1,!0);else if("string"==typeof this._i){var e=De(kt,this._i);null!=e?this.utcOffset(e):this.utcOffset(0,!0)}return this},Sn.hasAlignedHourOffset=function(e){return!!this.isValid()&&(e=e?pe(e).utcOffset():0,(this.utcOffset()-e)%60==0)},Sn.isDST=function(){return this.utcOffset()>this.clone().month(0).utcOffset()||this.utcOffset()>this.clone().month(5).utcOffset()},Sn.isLocal=function(){return!!this.isValid()&&!this._isUTC},Sn.isUtcOffset=function(){return!!this.isValid()&&this._isUTC},Sn.isUtc=xe,Sn.isUTC=xe,Sn.zoneAbbr=function(){return this._isUTC?"UTC":""},Sn.zoneName=function(){return this._isUTC?"Coordinated Universal Time":""},Sn.dates=v("dates accessor is deprecated. Use date instead.",pn),Sn.months=v("months accessor is deprecated. Use month instead",$),Sn.years=v("years accessor is deprecated. Use year instead",Ht),Sn.zone=v("moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/",function(e,t){return null!=e?("string"!=typeof e&&(e=-e),this.utcOffset(e,t),this):-this.utcOffset()}),Sn.isDSTShifted=v("isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information",function(){if(!s(this._isDSTShifted))return this._isDSTShifted;var e={};if(f(e,this),(e=ye(e))._a){var t=e._isUTC?l(e._a):pe(e._a);this._isDSTShifted=this.isValid()&&p(e._a,t.toArray())>0}else this._isDSTShifted=!1;return this._isDSTShifted});var Dn=D.prototype;Dn.calendar=function(e,t,n){var s=this._calendar[e]||this._calendar.sameElse;return k(s)?s.call(t,n):s},Dn.longDateFormat=function(e){var t=this._longDateFormat[e],n=this._longDateFormat[e.toUpperCase()];return t||!n?t:(this._longDateFormat[e]=n.replace(/MMMM|MM|DD|dddd/g,function(e){return e.slice(1)}),this._longDateFormat[e])},Dn.invalidDate=function(){return this._invalidDate},Dn.ordinal=function(e){return this._ordinal.replace("%d",e)},Dn.preparse=Ge,Dn.postformat=Ge,Dn.relativeTime=function(e,t,n,s){var i=this._relativeTime[n];return k(i)?i(e,t,n,s):i.replace(/%d/i,e)},Dn.pastFuture=function(e,t){var n=this._relativeTime[e>0?"future":"past"];return k(n)?n(t):n.replace(/%s/i,t)},Dn.set=function(e){var t,n;for(n in e)k(t=e[n])?this[n]=t:this["_"+n]=t;this._config=e,this._dayOfMonthOrdinalParseLenient=new RegExp((this._dayOfMonthOrdinalParse.source||this._ordinalParse.source)+"|"+/\d{1,2}/.source)},Dn.months=function(e,n){return e?t(this._months)?this._months[e.month()]:this._months[(this._months.isFormat||Lt).test(n)?"format":"standalone"][e.month()]:t(this._months)?this._months:this._months.standalone},Dn.monthsShort=function(e,n){return e?t(this._monthsShort)?this._monthsShort[e.month()]:this._monthsShort[Lt.test(n)?"format":"standalone"][e.month()]:t(this._monthsShort)?this._monthsShort:this._monthsShort.standalone},Dn.monthsParse=function(e,t,n){var s,i,r;if(this._monthsParseExact)return function(e,t,n){var s,i,r,a=e.toLocaleLowerCase();if(!this._monthsParse)for(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[],s=0;s<12;++s)r=l([2e3,s]),this._shortMonthsParse[s]=this.monthsShort(r,"").toLocaleLowerCase(),this._longMonthsParse[s]=this.months(r,"").toLocaleLowerCase();return n?"MMM"===t?-1!==(i=Nt.call(this._shortMonthsParse,a))?i:null:-1!==(i=Nt.call(this._longMonthsParse,a))?i:null:"MMM"===t?-1!==(i=Nt.call(this._shortMonthsParse,a))?i:-1!==(i=Nt.call(this._longMonthsParse,a))?i:null:-1!==(i=Nt.call(this._longMonthsParse,a))?i:-1!==(i=Nt.call(this._shortMonthsParse,a))?i:null}.call(this,e,t,n);for(this._monthsParse||(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[]),s=0;s<12;s++){if(i=l([2e3,s]),n&&!this._longMonthsParse[s]&&(this._longMonthsParse[s]=new RegExp("^"+this.months(i,"").replace(".","")+"$","i"),this._shortMonthsParse[s]=new RegExp("^"+this.monthsShort(i,"").replace(".","")+"$","i")),n||this._monthsParse[s]||(r="^"+this.months(i,"")+"|^"+this.monthsShort(i,""),this._monthsParse[s]=new RegExp(r.replace(".",""),"i")),n&&"MMMM"===t&&this._longMonthsParse[s].test(e))return s;if(n&&"MMM"===t&&this._shortMonthsParse[s].test(e))return s;if(!n&&this._monthsParse[s].test(e))return s}},Dn.monthsRegex=function(e){return this._monthsParseExact?(o(this,"_monthsRegex")||q.call(this),e?this._monthsStrictRegex:this._monthsRegex):(o(this,"_monthsRegex")||(this._monthsRegex=It),this._monthsStrictRegex&&e?this._monthsStrictRegex:this._monthsRegex)},Dn.monthsShortRegex=function(e){return this._monthsParseExact?(o(this,"_monthsRegex")||q.call(this),e?this._monthsShortStrictRegex:this._monthsShortRegex):(o(this,"_monthsShortRegex")||(this._monthsShortRegex=jt),this._monthsShortStrictRegex&&e?this._monthsShortStrictRegex:this._monthsShortRegex)},Dn.week=function(e){return X(e,this._week.dow,this._week.doy).week},Dn.firstDayOfYear=function(){return this._week.doy},Dn.firstDayOfWeek=function(){return this._week.dow},Dn.weekdays=function(e,n){return e?t(this._weekdays)?this._weekdays[e.day()]:this._weekdays[this._weekdays.isFormat.test(n)?"format":"standalone"][e.day()]:t(this._weekdays)?this._weekdays:this._weekdays.standalone},Dn.weekdaysMin=function(e){return e?this._weekdaysMin[e.day()]:this._weekdaysMin},Dn.weekdaysShort=function(e){return e?this._weekdaysShort[e.day()]:this._weekdaysShort},Dn.weekdaysParse=function(e,t,n){var s,i,r;if(this._weekdaysParseExact)return function(e,t,n){var s,i,r,a=e.toLocaleLowerCase();if(!this._weekdaysParse)for(this._weekdaysParse=[],this._shortWeekdaysParse=[],this._minWeekdaysParse=[],s=0;s<7;++s)r=l([2e3,1]).day(s),this._minWeekdaysParse[s]=this.weekdaysMin(r,"").toLocaleLowerCase(),this._shortWeekdaysParse[s]=this.weekdaysShort(r,"").toLocaleLowerCase(),this._weekdaysParse[s]=this.weekdays(r,"").toLocaleLowerCase();return n?"dddd"===t?-1!==(i=Nt.call(this._weekdaysParse,a))?i:null:"ddd"===t?-1!==(i=Nt.call(this._shortWeekdaysParse,a))?i:null:-1!==(i=Nt.call(this._minWeekdaysParse,a))?i:null:"dddd"===t?-1!==(i=Nt.call(this._weekdaysParse,a))?i:-1!==(i=Nt.call(this._shortWeekdaysParse,a))?i:-1!==(i=Nt.call(this._minWeekdaysParse,a))?i:null:"ddd"===t?-1!==(i=Nt.call(this._shortWeekdaysParse,a))?i:-1!==(i=Nt.call(this._weekdaysParse,a))?i:-1!==(i=Nt.call(this._minWeekdaysParse,a))?i:null:-1!==(i=Nt.call(this._minWeekdaysParse,a))?i:-1!==(i=Nt.call(this._weekdaysParse,a))?i:-1!==(i=Nt.call(this._shortWeekdaysParse,a))?i:null}.call(this,e,t,n);for(this._weekdaysParse||(this._weekdaysParse=[],this._minWeekdaysParse=[],this._shortWeekdaysParse=[],this._fullWeekdaysParse=[]),s=0;s<7;s++){if(i=l([2e3,1]).day(s),n&&!this._fullWeekdaysParse[s]&&(this._fullWeekdaysParse[s]=new RegExp("^"+this.weekdays(i,"").replace(".",".?")+"$","i"),this._shortWeekdaysParse[s]=new RegExp("^"+this.weekdaysShort(i,"").replace(".",".?")+"$","i"),this._minWeekdaysParse[s]=new RegExp("^"+this.weekdaysMin(i,"").replace(".",".?")+"$","i")),this._weekdaysParse[s]||(r="^"+this.weekdays(i,"")+"|^"+this.weekdaysShort(i,"")+"|^"+this.weekdaysMin(i,""),this._weekdaysParse[s]=new RegExp(r.replace(".",""),"i")),n&&"dddd"===t&&this._fullWeekdaysParse[s].test(e))return s;if(n&&"ddd"===t&&this._shortWeekdaysParse[s].test(e))return s;if(n&&"dd"===t&&this._minWeekdaysParse[s].test(e))return s;if(!n&&this._weekdaysParse[s].test(e))return s}},Dn.weekdaysRegex=function(e){return this._weekdaysParseExact?(o(this,"_weekdaysRegex")||ee.call(this),e?this._weekdaysStrictRegex:this._weekdaysRegex):(o(this,"_weekdaysRegex")||(this._weekdaysRegex=Zt),this._weekdaysStrictRegex&&e?this._weekdaysStrictRegex:this._weekdaysRegex)},Dn.weekdaysShortRegex=function(e){return this._weekdaysParseExact?(o(this,"_weekdaysRegex")||ee.call(this),e?this._weekdaysShortStrictRegex:this._weekdaysShortRegex):(o(this,"_weekdaysShortRegex")||(this._weekdaysShortRegex=$t),this._weekdaysShortStrictRegex&&e?this._weekdaysShortStrictRegex:this._weekdaysShortRegex)},Dn.weekdaysMinRegex=function(e){return this._weekdaysParseExact?(o(this,"_weekdaysRegex")||ee.call(this),e?this._weekdaysMinStrictRegex:this._weekdaysMinRegex):(o(this,"_weekdaysMinRegex")||(this._weekdaysMinRegex=qt),this._weekdaysMinStrictRegex&&e?this._weekdaysMinStrictRegex:this._weekdaysMinRegex)},Dn.isPM=function(e){return"p"===(e+"").toLowerCase().charAt(0)},Dn.meridiem=function(e,t,n){return e>11?n?"pm":"PM":n?"am":"AM"},ae("en",{dayOfMonthOrdinalParse:/\d{1,2}(th|st|nd|rd)/,ordinal:function(e){var t=e%10;return e+(1===g(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")}}),e.lang=v("moment.lang is deprecated. Use moment.locale instead.",ae),e.langData=v("moment.langData is deprecated. Use moment.localeData instead.",ue);var Yn=Math.abs,On=$e("ms"),xn=$e("s"),Tn=$e("m"),bn=$e("h"),Pn=$e("d"),Wn=$e("w"),Rn=$e("M"),Cn=$e("y"),Fn=qe("milliseconds"),Un=qe("seconds"),Nn=qe("minutes"),Hn=qe("hours"),Ln=qe("days"),Gn=qe("months"),Vn=qe("years"),jn=Math.round,In={ss:44,s:45,m:45,h:22,d:26,M:11},En=Math.abs,An=ve.prototype;return An.isValid=function(){return this._isValid},An.abs=function(){var e=this._data;return this._milliseconds=Yn(this._milliseconds),this._days=Yn(this._days),this._months=Yn(this._months),e.milliseconds=Yn(e.milliseconds),e.seconds=Yn(e.seconds),e.minutes=Yn(e.minutes),e.hours=Yn(e.hours),e.months=Yn(e.months),e.years=Yn(e.years),this},An.add=function(e,t){return Ee(this,e,t,1)},An.subtract=function(e,t){return Ee(this,e,t,-1)},An.as=function(e){if(!this.isValid())return NaN;var t,n,s=this._milliseconds;if("month"===(e=O(e))||"year"===e)return t=this._days+s/864e5,n=this._months+ze(t),"month"===e?n:n/12;switch(t=this._days+Math.round(Ze(this._months)),e){case"week":return t/7+s/6048e5;case"day":return t+s/864e5;case"hour":return 24*t+s/36e5;case"minute":return 1440*t+s/6e4;case"second":return 86400*t+s/1e3;case"millisecond":return Math.floor(864e5*t)+s;default:throw new Error("Unknown unit "+e)}},An.asMilliseconds=On,An.asSeconds=xn,An.asMinutes=Tn,An.asHours=bn,An.asDays=Pn,An.asWeeks=Wn,An.asMonths=Rn,An.asYears=Cn,An.valueOf=function(){return this.isValid()?this._milliseconds+864e5*this._days+this._months%12*2592e6+31536e6*g(this._months/12):NaN},An._bubble=function(){var e,t,n,s,i,r=this._milliseconds,a=this._days,o=this._months,u=this._data;return r>=0&&a>=0&&o>=0||r<=0&&a<=0&&o<=0||(r+=864e5*Ae(Ze(o)+a),a=0,o=0),u.milliseconds=r%1e3,e=y(r/1e3),u.seconds=e%60,t=y(e/60),u.minutes=t%60,n=y(t/60),u.hours=n%24,a+=y(n/24),i=y(ze(a)),o+=i,a-=Ae(Ze(i)),s=y(o/12),o%=12,u.days=a,u.months=o,u.years=s,this},An.clone=function(){return Te(this)},An.get=function(e){return e=O(e),this.isValid()?this[e+"s"]():NaN},An.milliseconds=Fn,An.seconds=Un,An.minutes=Nn,An.hours=Hn,An.days=Ln,An.weeks=function(){return y(this.days()/7)},An.months=Gn,An.years=Vn,An.humanize=function(e){if(!this.isValid())return this.localeData().invalidDate();var t=this.localeData(),n=function(e,t,n){var s=Te(e).abs(),i=jn(s.as("s")),r=jn(s.as("m")),a=jn(s.as("h")),o=jn(s.as("d")),u=jn(s.as("M")),l=jn(s.as("y")),d=i<=In.ss&&["s",i]||i<In.s&&["ss",i]||r<=1&&["m"]||r<In.m&&["mm",r]||a<=1&&["h"]||a<In.h&&["hh",a]||o<=1&&["d"]||o<In.d&&["dd",o]||u<=1&&["M"]||u<In.M&&["MM",u]||l<=1&&["y"]||["yy",l];return d[2]=t,d[3]=+e>0,d[4]=n,function(e,t,n,s,i){return i.relativeTime(t||1,!!n,e,s)}.apply(null,d)}(this,!e,t);return e&&(n=t.pastFuture(+this,n)),t.postformat(n)},An.toISOString=Be,An.toString=Be,An.toJSON=Be,An.locale=Fe,An.localeData=Ue,An.toIsoString=v("toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)",Be),An.lang=gn,P("X",0,0,"unix"),P("x",0,0,"valueOf"),F("x",Mt),F("X",/[+-]?\d+(\.\d{1,3})?/),H("X",function(e,t,n){n._d=new Date(1e3*parseFloat(e,10))}),H("x",function(e,t,n){n._d=new Date(g(e))}),e.version="2.19.4",function(e){Qe=e}(pe),e.fn=Sn,e.min=function(){return we("isBefore",[].slice.call(arguments,0))},e.max=function(){return we("isAfter",[].slice.call(arguments,0))},e.now=function(){return Date.now?Date.now():+new Date},e.utc=l,e.unix=function(e){return pe(1e3*e)},e.months=function(e,t){return je(e,t,"months")},e.isDate=r,e.locale=ae,e.invalid=c,e.duration=Te,e.isMoment=_,e.weekdays=function(e,t,n){return Ie(e,t,n,"weekdays")},e.parseZone=function(){return pe.apply(null,arguments).parseZone()},e.localeData=ue,e.isDuration=Me,e.monthsShort=function(e,t){return je(e,t,"monthsShort")},e.weekdaysMin=function(e,t,n){return Ie(e,t,n,"weekdaysMin")},e.defineLocale=oe,e.updateLocale=function(e,t){if(null!=t){var n,s,i=Qt;null!=(s=re(e))&&(i=s._config),(n=new D(t=S(i,t))).parentLocale=Xt[e],Xt[e]=n,ae(e)}else null!=Xt[e]&&(null!=Xt[e].parentLocale?Xt[e]=Xt[e].parentLocale:null!=Xt[e]&&delete Xt[e]);return Xt[e]},e.locales=function(){return nt(Xt)},e.weekdaysShort=function(e,t,n){return Ie(e,t,n,"weekdaysShort")},e.normalizeUnits=O,e.relativeTimeRounding=function(e){return void 0===e?jn:"function"==typeof e&&(jn=e,!0)},e.relativeTimeThreshold=function(e,t){return void 0!==In[e]&&(void 0===t?In[e]:(In[e]=t,"s"===e&&(In.ss=t-1),!0))},e.calendarFormat=function(e,t){var n=e.diff(t,"days",!0);return n<-6?"sameElse":n<-1?"lastWeek":n<0?"lastDay":n<1?"sameDay":n<2?"nextDay":n<7?"nextWeek":"sameElse"},e.prototype=Sn,e});
|
||
(function (factory) {
|
||
|
||
if ( typeof define === 'function' && define.amd ) {
|
||
|
||
// AMD. Register as an anonymous module.
|
||
define([], factory);
|
||
|
||
} else if ( typeof exports === 'object' ) {
|
||
|
||
// Node/CommonJS
|
||
module.exports = factory();
|
||
|
||
} else {
|
||
|
||
// Browser globals
|
||
window.wNumb = factory();
|
||
}
|
||
|
||
}(function(){
|
||
|
||
'use strict';
|
||
|
||
var FormatOptions = [
|
||
'decimals',
|
||
'thousand',
|
||
'mark',
|
||
'prefix',
|
||
'suffix',
|
||
'encoder',
|
||
'decoder',
|
||
'negativeBefore',
|
||
'negative',
|
||
'edit',
|
||
'undo'
|
||
];
|
||
|
||
// General
|
||
|
||
// Reverse a string
|
||
function strReverse ( a ) {
|
||
return a.split('').reverse().join('');
|
||
}
|
||
|
||
// Check if a string starts with a specified prefix.
|
||
function strStartsWith ( input, match ) {
|
||
return input.substring(0, match.length) === match;
|
||
}
|
||
|
||
// Check is a string ends in a specified suffix.
|
||
function strEndsWith ( input, match ) {
|
||
return input.slice(-1 * match.length) === match;
|
||
}
|
||
|
||
// Throw an error if formatting options are incompatible.
|
||
function throwEqualError( F, a, b ) {
|
||
if ( (F[a] || F[b]) && (F[a] === F[b]) ) {
|
||
throw new Error(a);
|
||
}
|
||
}
|
||
|
||
// Check if a number is finite and not NaN
|
||
function isValidNumber ( input ) {
|
||
return typeof input === 'number' && isFinite( input );
|
||
}
|
||
|
||
// Provide rounding-accurate toFixed method.
|
||
// Borrowed: http://stackoverflow.com/a/21323330/775265
|
||
function toFixed ( value, exp ) {
|
||
value = value.toString().split('e');
|
||
value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)));
|
||
value = value.toString().split('e');
|
||
return (+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp))).toFixed(exp);
|
||
}
|
||
|
||
|
||
// Formatting
|
||
|
||
// Accept a number as input, output formatted string.
|
||
function formatTo ( decimals, thousand, mark, prefix, suffix, encoder, decoder, negativeBefore, negative, edit, undo, input ) {
|
||
|
||
var originalInput = input, inputIsNegative, inputPieces, inputBase, inputDecimals = '', output = '';
|
||
|
||
// Apply user encoder to the input.
|
||
// Expected outcome: number.
|
||
if ( encoder ) {
|
||
input = encoder(input);
|
||
}
|
||
|
||
// Stop if no valid number was provided, the number is infinite or NaN.
|
||
if ( !isValidNumber(input) ) {
|
||
return false;
|
||
}
|
||
|
||
// Rounding away decimals might cause a value of -0
|
||
// when using very small ranges. Remove those cases.
|
||
if ( decimals !== false && parseFloat(input.toFixed(decimals)) === 0 ) {
|
||
input = 0;
|
||
}
|
||
|
||
// Formatting is done on absolute numbers,
|
||
// decorated by an optional negative symbol.
|
||
if ( input < 0 ) {
|
||
inputIsNegative = true;
|
||
input = Math.abs(input);
|
||
}
|
||
|
||
// Reduce the number of decimals to the specified option.
|
||
if ( decimals !== false ) {
|
||
input = toFixed( input, decimals );
|
||
}
|
||
|
||
// Transform the number into a string, so it can be split.
|
||
input = input.toString();
|
||
|
||
// Break the number on the decimal separator.
|
||
if ( input.indexOf('.') !== -1 ) {
|
||
inputPieces = input.split('.');
|
||
|
||
inputBase = inputPieces[0];
|
||
|
||
if ( mark ) {
|
||
inputDecimals = mark + inputPieces[1];
|
||
}
|
||
|
||
} else {
|
||
|
||
// If it isn't split, the entire number will do.
|
||
inputBase = input;
|
||
}
|
||
|
||
// Group numbers in sets of three.
|
||
if ( thousand ) {
|
||
inputBase = strReverse(inputBase).match(/.{1,3}/g);
|
||
inputBase = strReverse(inputBase.join( strReverse( thousand ) ));
|
||
}
|
||
|
||
// If the number is negative, prefix with negation symbol.
|
||
if ( inputIsNegative && negativeBefore ) {
|
||
output += negativeBefore;
|
||
}
|
||
|
||
// Prefix the number
|
||
if ( prefix ) {
|
||
output += prefix;
|
||
}
|
||
|
||
// Normal negative option comes after the prefix. Defaults to '-'.
|
||
if ( inputIsNegative && negative ) {
|
||
output += negative;
|
||
}
|
||
|
||
// Append the actual number.
|
||
output += inputBase;
|
||
output += inputDecimals;
|
||
|
||
// Apply the suffix.
|
||
if ( suffix ) {
|
||
output += suffix;
|
||
}
|
||
|
||
// Run the output through a user-specified post-formatter.
|
||
if ( edit ) {
|
||
output = edit ( output, originalInput );
|
||
}
|
||
|
||
// All done.
|
||
return output;
|
||
}
|
||
|
||
// Accept a sting as input, output decoded number.
|
||
function formatFrom ( decimals, thousand, mark, prefix, suffix, encoder, decoder, negativeBefore, negative, edit, undo, input ) {
|
||
|
||
var originalInput = input, inputIsNegative, output = '';
|
||
|
||
// User defined pre-decoder. Result must be a non empty string.
|
||
if ( undo ) {
|
||
input = undo(input);
|
||
}
|
||
|
||
// Test the input. Can't be empty.
|
||
if ( !input || typeof input !== 'string' ) {
|
||
return false;
|
||
}
|
||
|
||
// If the string starts with the negativeBefore value: remove it.
|
||
// Remember is was there, the number is negative.
|
||
if ( negativeBefore && strStartsWith(input, negativeBefore) ) {
|
||
input = input.replace(negativeBefore, '');
|
||
inputIsNegative = true;
|
||
}
|
||
|
||
// Repeat the same procedure for the prefix.
|
||
if ( prefix && strStartsWith(input, prefix) ) {
|
||
input = input.replace(prefix, '');
|
||
}
|
||
|
||
// And again for negative.
|
||
if ( negative && strStartsWith(input, negative) ) {
|
||
input = input.replace(negative, '');
|
||
inputIsNegative = true;
|
||
}
|
||
|
||
// Remove the suffix.
|
||
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice
|
||
if ( suffix && strEndsWith(input, suffix) ) {
|
||
input = input.slice(0, -1 * suffix.length);
|
||
}
|
||
|
||
// Remove the thousand grouping.
|
||
if ( thousand ) {
|
||
input = input.split(thousand).join('');
|
||
}
|
||
|
||
// Set the decimal separator back to period.
|
||
if ( mark ) {
|
||
input = input.replace(mark, '.');
|
||
}
|
||
|
||
// Prepend the negative symbol.
|
||
if ( inputIsNegative ) {
|
||
output += '-';
|
||
}
|
||
|
||
// Add the number
|
||
output += input;
|
||
|
||
// Trim all non-numeric characters (allow '.' and '-');
|
||
output = output.replace(/[^0-9\.\-.]/g, '');
|
||
|
||
// The value contains no parse-able number.
|
||
if ( output === '' ) {
|
||
return false;
|
||
}
|
||
|
||
// Covert to number.
|
||
output = Number(output);
|
||
|
||
// Run the user-specified post-decoder.
|
||
if ( decoder ) {
|
||
output = decoder(output);
|
||
}
|
||
|
||
// Check is the output is valid, otherwise: return false.
|
||
if ( !isValidNumber(output) ) {
|
||
return false;
|
||
}
|
||
|
||
return output;
|
||
}
|
||
|
||
|
||
// Framework
|
||
|
||
// Validate formatting options
|
||
function validate ( inputOptions ) {
|
||
|
||
var i, optionName, optionValue,
|
||
filteredOptions = {};
|
||
|
||
if ( inputOptions['suffix'] === undefined ) {
|
||
inputOptions['suffix'] = inputOptions['postfix'];
|
||
}
|
||
|
||
for ( i = 0; i < FormatOptions.length; i+=1 ) {
|
||
|
||
optionName = FormatOptions[i];
|
||
optionValue = inputOptions[optionName];
|
||
|
||
if ( optionValue === undefined ) {
|
||
|
||
// Only default if negativeBefore isn't set.
|
||
if ( optionName === 'negative' && !filteredOptions.negativeBefore ) {
|
||
filteredOptions[optionName] = '-';
|
||
// Don't set a default for mark when 'thousand' is set.
|
||
} else if ( optionName === 'mark' && filteredOptions.thousand !== '.' ) {
|
||
filteredOptions[optionName] = '.';
|
||
} else {
|
||
filteredOptions[optionName] = false;
|
||
}
|
||
|
||
// Floating points in JS are stable up to 7 decimals.
|
||
} else if ( optionName === 'decimals' ) {
|
||
if ( optionValue >= 0 && optionValue < 8 ) {
|
||
filteredOptions[optionName] = optionValue;
|
||
} else {
|
||
throw new Error(optionName);
|
||
}
|
||
|
||
// These options, when provided, must be functions.
|
||
} else if ( optionName === 'encoder' || optionName === 'decoder' || optionName === 'edit' || optionName === 'undo' ) {
|
||
if ( typeof optionValue === 'function' ) {
|
||
filteredOptions[optionName] = optionValue;
|
||
} else {
|
||
throw new Error(optionName);
|
||
}
|
||
|
||
// Other options are strings.
|
||
} else {
|
||
|
||
if ( typeof optionValue === 'string' ) {
|
||
filteredOptions[optionName] = optionValue;
|
||
} else {
|
||
throw new Error(optionName);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Some values can't be extracted from a
|
||
// string if certain combinations are present.
|
||
throwEqualError(filteredOptions, 'mark', 'thousand');
|
||
throwEqualError(filteredOptions, 'prefix', 'negative');
|
||
throwEqualError(filteredOptions, 'prefix', 'negativeBefore');
|
||
|
||
return filteredOptions;
|
||
}
|
||
|
||
// Pass all options as function arguments
|
||
function passAll ( options, method, input ) {
|
||
var i, args = [];
|
||
|
||
// Add all options in order of FormatOptions
|
||
for ( i = 0; i < FormatOptions.length; i+=1 ) {
|
||
args.push(options[FormatOptions[i]]);
|
||
}
|
||
|
||
// Append the input, then call the method, presenting all
|
||
// options as arguments.
|
||
args.push(input);
|
||
return method.apply('', args);
|
||
}
|
||
|
||
function wNumb ( options ) {
|
||
|
||
if ( !(this instanceof wNumb) ) {
|
||
return new wNumb ( options );
|
||
}
|
||
|
||
if ( typeof options !== "object" ) {
|
||
return;
|
||
}
|
||
|
||
options = validate(options);
|
||
|
||
// Call 'formatTo' with proper arguments.
|
||
this.to = function ( input ) {
|
||
return passAll(options, formatTo, input);
|
||
};
|
||
|
||
// Call 'formatFrom' with proper arguments.
|
||
this.from = function ( input ) {
|
||
return passAll(options, formatFrom, input);
|
||
};
|
||
}
|
||
|
||
return wNumb;
|
||
|
||
}));
|
||
|
||
(function ($) {
|
||
'use strict';
|
||
|
||
var identity = function (x) {
|
||
return x;
|
||
};
|
||
|
||
var isArray = function (value) {
|
||
return $.isArray(value);
|
||
};
|
||
|
||
var isObject = function (value) {
|
||
return !isArray(value) && (value instanceof Object);
|
||
};
|
||
|
||
var isNumber = function (value) {
|
||
return value instanceof Number;
|
||
};
|
||
|
||
var isFunction = function (value) {
|
||
return value instanceof Function;
|
||
};
|
||
|
||
var indexOf = function (object, value) {
|
||
return $.inArray(value, object);
|
||
};
|
||
|
||
var inArray = function (array, value) {
|
||
return indexOf(array, value) !== -1;
|
||
};
|
||
|
||
var foreach = function (collection, callback) {
|
||
for(var i in collection) {
|
||
if(collection.hasOwnProperty(i)) {
|
||
callback(collection[i], i, collection);
|
||
}
|
||
}
|
||
};
|
||
|
||
|
||
var last = function (array) {
|
||
return array[array.length - 1];
|
||
};
|
||
|
||
var argumentsToArray = function (args) {
|
||
return Array.prototype.slice.call(args);
|
||
};
|
||
|
||
var extend = function () {
|
||
var extended = {};
|
||
foreach(argumentsToArray(arguments), function (o) {
|
||
foreach(o, function (val, key) {
|
||
extended[key] = val;
|
||
});
|
||
});
|
||
return extended;
|
||
};
|
||
|
||
var mapToArray = function (collection, callback) {
|
||
var mapped = [];
|
||
foreach(collection, function (value, key, coll) {
|
||
mapped.push(callback(value, key, coll));
|
||
});
|
||
return mapped;
|
||
};
|
||
|
||
var mapToObject = function (collection, callback, keyCallback) {
|
||
var mapped = {};
|
||
foreach(collection, function (value, key, coll) {
|
||
key = keyCallback ? keyCallback(key, value) : key;
|
||
mapped[key] = callback(value, key, coll);
|
||
});
|
||
return mapped;
|
||
};
|
||
|
||
var map = function (collection, callback, keyCallback) {
|
||
return isArray(collection) ?
|
||
mapToArray(collection, callback) :
|
||
mapToObject(collection, callback, keyCallback);
|
||
};
|
||
|
||
var pluck = function (arrayOfObjects, key) {
|
||
return map(arrayOfObjects, function (val) {
|
||
return val[key];
|
||
});
|
||
};
|
||
|
||
var filter = function (collection, callback) {
|
||
var filtered;
|
||
|
||
if(isArray(collection)) {
|
||
filtered = [];
|
||
foreach(collection, function (val, key, coll) {
|
||
if(callback(val, key, coll)) {
|
||
filtered.push(val);
|
||
}
|
||
});
|
||
}
|
||
else {
|
||
filtered = {};
|
||
foreach(collection, function (val, key, coll) {
|
||
if(callback(val, key, coll)) {
|
||
filtered[key] = val;
|
||
}
|
||
});
|
||
}
|
||
|
||
return filtered;
|
||
};
|
||
|
||
var call = function (collection, functionName, args) {
|
||
return map(collection, function (object, name) {
|
||
return object[functionName].apply(object, args || []);
|
||
});
|
||
};
|
||
|
||
//execute callback immediately and at most one time on the minimumInterval,
|
||
//ignore block attempts
|
||
var throttle = function (minimumInterval, callback) {
|
||
var timeout = null;
|
||
return function () {
|
||
var that = this, args = arguments;
|
||
if(timeout === null) {
|
||
timeout = setTimeout(function () {
|
||
timeout = null;
|
||
}, minimumInterval);
|
||
callback.apply(that, args);
|
||
}
|
||
};
|
||
};
|
||
|
||
|
||
var mixinPubSub = function (object) {
|
||
object = object || {};
|
||
var topics = {};
|
||
|
||
object.publish = function (topic, data) {
|
||
foreach(topics[topic], function (callback) {
|
||
callback(data);
|
||
});
|
||
};
|
||
|
||
object.subscribe = function (topic, callback) {
|
||
topics[topic] = topics[topic] || [];
|
||
topics[topic].push(callback);
|
||
};
|
||
|
||
object.unsubscribe = function (callback) {
|
||
foreach(topics, function (subscribers) {
|
||
var index = indexOf(subscribers, callback);
|
||
if(index !== -1) {
|
||
subscribers.splice(index, 1);
|
||
}
|
||
});
|
||
};
|
||
|
||
return object;
|
||
};
|
||
|
||
// jquery.input version 0.0.0
|
||
// https://github.com/DubFriend/jquery.input
|
||
// (MIT) 09-04-2014
|
||
// Brian Detering <BDeterin@gmail.com> (http://www.briandetering.net/)
|
||
(function ($) {
|
||
'use strict';
|
||
|
||
var createBaseInput = function (fig, my) {
|
||
var self = mixinPubSub(),
|
||
$self = fig.$;
|
||
|
||
self.getType = function () {
|
||
throw 'implement me (return type. "text", "radio", etc.)';
|
||
};
|
||
|
||
self.$ = function (selector) {
|
||
return selector ? $self.find(selector) : $self;
|
||
};
|
||
|
||
self.disable = function () {
|
||
self.$().prop('disabled', true);
|
||
self.publish('isEnabled', false);
|
||
};
|
||
|
||
self.enable = function () {
|
||
self.$().prop('disabled', false);
|
||
self.publish('isEnabled', true);
|
||
};
|
||
|
||
my.equalTo = function (a, b) {
|
||
return a === b;
|
||
};
|
||
|
||
my.publishChange = (function () {
|
||
var oldValue;
|
||
return function (e, domElement) {
|
||
var newValue = self.get();
|
||
if(!my.equalTo(newValue, oldValue)) {
|
||
self.publish('change', { e: e, domElement: domElement });
|
||
}
|
||
oldValue = newValue;
|
||
};
|
||
}());
|
||
|
||
return self;
|
||
};
|
||
|
||
|
||
var createInput = function (fig, my) {
|
||
var self = createBaseInput(fig, my);
|
||
|
||
self.get = function () {
|
||
return self.$().val();
|
||
};
|
||
|
||
self.set = function (newValue) {
|
||
self.$().val(newValue);
|
||
};
|
||
|
||
self.clear = function () {
|
||
self.set('');
|
||
};
|
||
|
||
my.buildSetter = function (callback) {
|
||
return function (newValue) {
|
||
callback.call(self, newValue);
|
||
};
|
||
};
|
||
|
||
return self;
|
||
};
|
||
|
||
var inputEqualToArray = function (a, b) {
|
||
a = isArray(a) ? a : [a];
|
||
b = isArray(b) ? b : [b];
|
||
|
||
var isEqual = true;
|
||
if(a.length !== b.length) {
|
||
isEqual = false;
|
||
}
|
||
else {
|
||
foreach(a, function (value) {
|
||
if(!inArray(b, value)) {
|
||
isEqual = false;
|
||
}
|
||
});
|
||
}
|
||
|
||
return isEqual;
|
||
};
|
||
|
||
var createInputButton = function (fig) {
|
||
var my = {},
|
||
self = createInput(fig, my);
|
||
|
||
self.getType = function () {
|
||
return 'button';
|
||
};
|
||
|
||
self.$().on('change', function (e) {
|
||
my.publishChange(e, this);
|
||
});
|
||
|
||
return self;
|
||
};
|
||
|
||
var createInputCheckbox = function (fig) {
|
||
var my = {},
|
||
self = createInput(fig, my);
|
||
|
||
self.getType = function () {
|
||
return 'checkbox';
|
||
};
|
||
|
||
self.get = function () {
|
||
var values = [];
|
||
self.$().filter(':checked').each(function () {
|
||
values.push($(this).val());
|
||
});
|
||
return values;
|
||
};
|
||
|
||
self.set = function (newValues) {
|
||
newValues = isArray(newValues) ? newValues : [newValues];
|
||
|
||
self.$().each(function () {
|
||
$(this).prop('checked', false);
|
||
});
|
||
|
||
foreach(newValues, function (value) {
|
||
self.$().filter('[value="' + value + '"]')
|
||
.prop('checked', true);
|
||
});
|
||
};
|
||
|
||
my.equalTo = inputEqualToArray;
|
||
|
||
self.$().change(function (e) {
|
||
my.publishChange(e, this);
|
||
});
|
||
|
||
return self;
|
||
};
|
||
|
||
var createInputEmail = function (fig) {
|
||
var my = {},
|
||
self = createInputText(fig, my);
|
||
|
||
self.getType = function () {
|
||
return 'email';
|
||
};
|
||
|
||
return self;
|
||
};
|
||
|
||
var createInputFile = function (fig) {
|
||
var my = {},
|
||
self = createBaseInput(fig, my);
|
||
|
||
self.getType = function () {
|
||
return 'file';
|
||
};
|
||
|
||
self.get = function () {
|
||
return last(self.$().val().split('\\'));
|
||
};
|
||
|
||
self.clear = function () {
|
||
// http://stackoverflow.com/questions/1043957/clearing-input-type-file-using-jquery
|
||
this.$().each(function () {
|
||
$(this).wrap('<form>').closest('form').get(0).reset();
|
||
$(this).unwrap();
|
||
});
|
||
};
|
||
|
||
self.$().change(function (e) {
|
||
my.publishChange(e, this);
|
||
// self.publish('change', self);
|
||
});
|
||
|
||
return self;
|
||
};
|
||
|
||
var createInputHidden = function (fig) {
|
||
var my = {},
|
||
self = createInput(fig, my);
|
||
|
||
self.getType = function () {
|
||
return 'hidden';
|
||
};
|
||
|
||
self.$().change(function (e) {
|
||
my.publishChange(e, this);
|
||
});
|
||
|
||
return self;
|
||
};
|
||
var createInputMultipleFile = function (fig) {
|
||
var my = {},
|
||
self = createBaseInput(fig, my);
|
||
|
||
self.getType = function () {
|
||
return 'file[multiple]';
|
||
};
|
||
|
||
self.get = function () {
|
||
// http://stackoverflow.com/questions/14035530/how-to-get-value-of-html-5-multiple-file-upload-variable-using-jquery
|
||
var fileListObject = self.$().get(0).files || [],
|
||
names = [], i;
|
||
|
||
for(i = 0; i < (fileListObject.length || 0); i += 1) {
|
||
names.push(fileListObject[i].name);
|
||
}
|
||
|
||
return names;
|
||
};
|
||
|
||
self.clear = function () {
|
||
// http://stackoverflow.com/questions/1043957/clearing-input-type-file-using-jquery
|
||
this.$().each(function () {
|
||
$(this).wrap('<form>').closest('form').get(0).reset();
|
||
$(this).unwrap();
|
||
});
|
||
};
|
||
|
||
self.$().change(function (e) {
|
||
my.publishChange(e, this);
|
||
});
|
||
|
||
return self;
|
||
};
|
||
|
||
var createInputMultipleSelect = function (fig) {
|
||
var my = {},
|
||
self = createInput(fig, my);
|
||
|
||
self.getType = function () {
|
||
return 'select[multiple]';
|
||
};
|
||
|
||
self.get = function () {
|
||
return self.$().val() || [];
|
||
};
|
||
|
||
self.set = function (newValues) {
|
||
self.$().val(
|
||
newValues === '' ? [] : isArray(newValues) ? newValues : [newValues]
|
||
);
|
||
};
|
||
|
||
my.equalTo = inputEqualToArray;
|
||
|
||
self.$().change(function (e) {
|
||
my.publishChange(e, this);
|
||
});
|
||
|
||
return self;
|
||
};
|
||
|
||
var createInputPassword = function (fig) {
|
||
var my = {},
|
||
self = createInputText(fig, my);
|
||
|
||
self.getType = function () {
|
||
return 'password';
|
||
};
|
||
|
||
return self;
|
||
};
|
||
|
||
var createInputRadio = function (fig) {
|
||
var my = {},
|
||
self = createInput(fig, my);
|
||
|
||
self.getType = function () {
|
||
return 'radio';
|
||
};
|
||
|
||
self.get = function () {
|
||
return self.$().filter(':checked').val() || null;
|
||
};
|
||
|
||
self.set = function (newValue) {
|
||
if(!newValue) {
|
||
self.$().each(function () {
|
||
$(this).prop('checked', false);
|
||
});
|
||
}
|
||
else {
|
||
self.$().filter('[value="' + newValue + '"]').prop('checked', true);
|
||
}
|
||
};
|
||
|
||
self.$().change(function (e) {
|
||
my.publishChange(e, this);
|
||
});
|
||
|
||
return self;
|
||
};
|
||
|
||
var createInputRange = function (fig) {
|
||
var my = {},
|
||
self = createInput(fig, my);
|
||
|
||
self.getType = function () {
|
||
return 'range';
|
||
};
|
||
|
||
self.$().change(function (e) {
|
||
my.publishChange(e, this);
|
||
});
|
||
|
||
return self;
|
||
};
|
||
|
||
var createInputSelect = function (fig) {
|
||
var my = {},
|
||
self = createInput(fig, my);
|
||
|
||
self.getType = function () {
|
||
return 'select';
|
||
};
|
||
|
||
self.$().change(function (e) {
|
||
my.publishChange(e, this);
|
||
});
|
||
|
||
return self;
|
||
};
|
||
|
||
var createInputText = function (fig) {
|
||
var my = {},
|
||
self = createInput(fig, my);
|
||
|
||
self.getType = function () {
|
||
return 'text';
|
||
};
|
||
|
||
self.$().on('change keyup keydown', function (e) {
|
||
my.publishChange(e, this);
|
||
});
|
||
|
||
return self;
|
||
};
|
||
|
||
var createInputTextarea = function (fig) {
|
||
var my = {},
|
||
self = createInput(fig, my);
|
||
|
||
self.getType = function () {
|
||
return 'textarea';
|
||
};
|
||
|
||
self.$().on('change keyup keydown', function (e) {
|
||
my.publishChange(e, this);
|
||
});
|
||
|
||
return self;
|
||
};
|
||
|
||
var createInputURL = function (fig) {
|
||
var my = {},
|
||
self = createInputText(fig, my);
|
||
|
||
self.getType = function () {
|
||
return 'url';
|
||
};
|
||
|
||
return self;
|
||
};
|
||
|
||
var buildFormInputs = function (fig) {
|
||
var inputs = {},
|
||
$self = fig.$;
|
||
|
||
var constructor = fig.constructorOverride || {
|
||
button: createInputButton,
|
||
text: createInputText,
|
||
url: createInputURL,
|
||
email: createInputEmail,
|
||
password: createInputPassword,
|
||
range: createInputRange,
|
||
textarea: createInputTextarea,
|
||
select: createInputSelect,
|
||
'select[multiple]': createInputMultipleSelect,
|
||
radio: createInputRadio,
|
||
checkbox: createInputCheckbox,
|
||
file: createInputFile,
|
||
'file[multiple]': createInputMultipleFile,
|
||
hidden: createInputHidden
|
||
};
|
||
|
||
var addInputsBasic = function (type, selector) {
|
||
var $input = isObject(selector) ? selector : $self.find(selector);
|
||
|
||
$input.each(function () {
|
||
var name = $(this).attr('name');
|
||
inputs[name] = constructor[type]({
|
||
$: $(this)
|
||
});
|
||
});
|
||
};
|
||
|
||
var addInputsGroup = function (type, selector) {
|
||
var names = [],
|
||
$input = isObject(selector) ? selector : $self.find(selector);
|
||
|
||
if(isObject(selector)) {
|
||
inputs[$input.attr('name')] = constructor[type]({
|
||
$: $input
|
||
});
|
||
}
|
||
else {
|
||
// group by name attribute
|
||
$input.each(function () {
|
||
if(indexOf(names, $(this).attr('name')) === -1) {
|
||
names.push($(this).attr('name'));
|
||
}
|
||
});
|
||
|
||
foreach(names, function (name) {
|
||
inputs[name] = constructor[type]({
|
||
$: $self.find('input[name="' + name + '"]')
|
||
});
|
||
});
|
||
}
|
||
};
|
||
|
||
|
||
if($self.is('input, select, textarea')) {
|
||
if($self.is('input[type="button"], button, input[type="submit"]')) {
|
||
addInputsBasic('button', $self);
|
||
}
|
||
else if($self.is('textarea')) {
|
||
addInputsBasic('textarea', $self);
|
||
}
|
||
else if(
|
||
$self.is('input[type="text"]') ||
|
||
$self.is('input') && !$self.attr('type')
|
||
) {
|
||
addInputsBasic('text', $self);
|
||
}
|
||
else if($self.is('input[type="password"]')) {
|
||
addInputsBasic('password', $self);
|
||
}
|
||
else if($self.is('input[type="email"]')) {
|
||
addInputsBasic('email', $self);
|
||
}
|
||
else if($self.is('input[type="url"]')) {
|
||
addInputsBasic('url', $self);
|
||
}
|
||
else if($self.is('input[type="range"]')) {
|
||
addInputsBasic('range', $self);
|
||
}
|
||
else if($self.is('select')) {
|
||
if($self.is('[multiple]')) {
|
||
addInputsBasic('select[multiple]', $self);
|
||
}
|
||
else {
|
||
addInputsBasic('select', $self);
|
||
}
|
||
}
|
||
else if($self.is('input[type="file"]')) {
|
||
if($self.is('[multiple]')) {
|
||
addInputsBasic('file[multiple]', $self);
|
||
}
|
||
else {
|
||
addInputsBasic('file', $self);
|
||
}
|
||
}
|
||
else if($self.is('input[type="hidden"]')) {
|
||
addInputsBasic('hidden', $self);
|
||
}
|
||
else if($self.is('input[type="radio"]')) {
|
||
addInputsGroup('radio', $self);
|
||
}
|
||
else if($self.is('input[type="checkbox"]')) {
|
||
addInputsGroup('checkbox', $self);
|
||
}
|
||
else {
|
||
//in all other cases default to a "text" input interface.
|
||
addInputsBasic('text', $self);
|
||
}
|
||
}
|
||
else {
|
||
addInputsBasic('button', 'input[type="button"], button, input[type="submit"]');
|
||
addInputsBasic('text', 'input[type="text"]');
|
||
addInputsBasic('password', 'input[type="password"]');
|
||
addInputsBasic('email', 'input[type="email"]');
|
||
addInputsBasic('url', 'input[type="url"]');
|
||
addInputsBasic('range', 'input[type="range"]');
|
||
addInputsBasic('textarea', 'textarea');
|
||
addInputsBasic('select', 'select:not([multiple])');
|
||
addInputsBasic('select[multiple]', 'select[multiple]');
|
||
addInputsBasic('file', 'input[type="file"]:not([multiple])');
|
||
addInputsBasic('file[multiple]', 'input[type="file"][multiple]');
|
||
addInputsBasic('hidden', 'input[type="hidden"]');
|
||
addInputsGroup('radio', 'input[type="radio"]');
|
||
addInputsGroup('checkbox', 'input[type="checkbox"]');
|
||
}
|
||
|
||
return inputs;
|
||
};
|
||
|
||
$.fn.inputVal = function (newValue) {
|
||
var $self = $(this);
|
||
|
||
var inputs = buildFormInputs({ $: $self });
|
||
|
||
if($self.is('input, textarea, select')) {
|
||
if(typeof newValue === 'undefined') {
|
||
return inputs[$self.attr('name')].get();
|
||
}
|
||
else {
|
||
inputs[$self.attr('name')].set(newValue);
|
||
return $self;
|
||
}
|
||
}
|
||
else {
|
||
if(typeof newValue === 'undefined') {
|
||
return call(inputs, 'get');
|
||
}
|
||
else {
|
||
foreach(newValue, function (value, inputName) {
|
||
inputs[inputName].set(value);
|
||
});
|
||
return $self;
|
||
}
|
||
}
|
||
};
|
||
|
||
$.fn.inputOnChange = function (callback) {
|
||
var $self = $(this);
|
||
var inputs = buildFormInputs({ $: $self });
|
||
foreach(inputs, function (input) {
|
||
input.subscribe('change', function (data) {
|
||
callback.call(data.domElement, data.e);
|
||
});
|
||
});
|
||
return $self;
|
||
};
|
||
|
||
$.fn.inputDisable = function () {
|
||
var $self = $(this);
|
||
call(buildFormInputs({ $: $self }), 'disable');
|
||
return $self;
|
||
};
|
||
|
||
$.fn.inputEnable = function () {
|
||
var $self = $(this);
|
||
call(buildFormInputs({ $: $self }), 'enable');
|
||
return $self;
|
||
};
|
||
|
||
$.fn.inputClear = function () {
|
||
var $self = $(this);
|
||
call(buildFormInputs({ $: $self }), 'clear');
|
||
return $self;
|
||
};
|
||
|
||
}(jQuery));
|
||
|
||
$.fn.repeaterVal = function () {
|
||
var parse = function (raw) {
|
||
var parsed = [];
|
||
|
||
foreach(raw, function (val, key) {
|
||
var parsedKey = [];
|
||
if(key !== "undefined") {
|
||
parsedKey.push(key.match(/^[^\[]*/)[0]);
|
||
parsedKey = parsedKey.concat(map(
|
||
key.match(/\[[^\]]*\]/g),
|
||
function (bracketed) {
|
||
return bracketed.replace(/[\[\]]/g, '');
|
||
}
|
||
));
|
||
|
||
parsed.push({
|
||
val: val,
|
||
key: parsedKey
|
||
});
|
||
}
|
||
});
|
||
|
||
return parsed;
|
||
};
|
||
|
||
var build = function (parsed) {
|
||
if(
|
||
parsed.length === 1 &&
|
||
(parsed[0].key.length === 0 || parsed[0].key.length === 1 && !parsed[0].key[0])
|
||
) {
|
||
return parsed[0].val;
|
||
}
|
||
|
||
foreach(parsed, function (p) {
|
||
p.head = p.key.shift();
|
||
});
|
||
|
||
var grouped = (function () {
|
||
var grouped = {};
|
||
|
||
foreach(parsed, function (p) {
|
||
if(!grouped[p.head]) {
|
||
grouped[p.head] = [];
|
||
}
|
||
grouped[p.head].push(p);
|
||
});
|
||
|
||
return grouped;
|
||
}());
|
||
|
||
var built;
|
||
|
||
if(/^[0-9]+$/.test(parsed[0].head)) {
|
||
built = [];
|
||
foreach(grouped, function (group) {
|
||
built.push(build(group));
|
||
});
|
||
}
|
||
else {
|
||
built = {};
|
||
foreach(grouped, function (group, key) {
|
||
built[key] = build(group);
|
||
});
|
||
}
|
||
|
||
return built;
|
||
};
|
||
|
||
return build(parse($(this).inputVal()));
|
||
};
|
||
|
||
$.fn.repeater = function (fig) {
|
||
fig = fig || {};
|
||
|
||
var setList;
|
||
|
||
$(this).each(function () {
|
||
|
||
var $self = $(this);
|
||
|
||
var show = fig.show || function () {
|
||
$(this).show();
|
||
};
|
||
|
||
var hide = fig.hide || function (removeElement) {
|
||
removeElement();
|
||
};
|
||
|
||
var $list = $self.find('[data-repeater-list]').first();
|
||
|
||
var $filterNested = function ($items, repeaters) {
|
||
return $items.filter(function () {
|
||
return repeaters ?
|
||
$(this).closest(
|
||
pluck(repeaters, 'selector').join(',')
|
||
).length === 0 : true;
|
||
});
|
||
};
|
||
|
||
var $items = function () {
|
||
return $filterNested($list.find('[data-repeater-item]'), fig.repeaters);
|
||
};
|
||
|
||
var $itemTemplate = $list.find('[data-repeater-item]')
|
||
.first().clone().hide();
|
||
|
||
var $firstDeleteButton = $filterNested(
|
||
$filterNested($(this).find('[data-repeater-item]'), fig.repeaters)
|
||
.first().find('[data-repeater-delete]'),
|
||
fig.repeaters
|
||
);
|
||
|
||
if(fig.isFirstItemUndeletable && $firstDeleteButton) {
|
||
$firstDeleteButton.remove();
|
||
}
|
||
|
||
var getGroupName = function () {
|
||
var groupName = $list.data('repeater-list');
|
||
return fig.$parent ?
|
||
fig.$parent.data('item-name') + '[' + groupName + ']' :
|
||
groupName;
|
||
};
|
||
|
||
var initNested = function ($listItems) {
|
||
if(fig.repeaters) {
|
||
$listItems.each(function () {
|
||
var $item = $(this);
|
||
foreach(fig.repeaters, function (nestedFig) {
|
||
$item.find(nestedFig.selector).repeater(extend(
|
||
nestedFig, { $parent: $item }
|
||
));
|
||
});
|
||
});
|
||
}
|
||
};
|
||
|
||
var $foreachRepeaterInItem = function (repeaters, $item, cb) {
|
||
if(repeaters) {
|
||
foreach(repeaters, function (nestedFig) {
|
||
cb.call($item.find(nestedFig.selector)[0], nestedFig);
|
||
});
|
||
}
|
||
};
|
||
|
||
var setIndexes = function ($items, groupName, repeaters) {
|
||
$items.each(function (index) {
|
||
var $item = $(this);
|
||
$item.data('item-name', groupName + '[' + index + ']');
|
||
$filterNested($item.find('[name]'), repeaters)
|
||
.each(function () {
|
||
var $input = $(this);
|
||
// match non empty brackets (ex: "[foo]")
|
||
var matches = $input.attr('name').match(/\[[^\]]+\]/g);
|
||
|
||
var name = matches ?
|
||
// strip "[" and "]" characters
|
||
last(matches).replace(/\[|\]/g, '') :
|
||
$input.attr('name');
|
||
|
||
|
||
var newName = groupName + '[' + index + '][' + name + ']' +
|
||
($input.is(':checkbox') || $input.attr('multiple') ? '[]' : '');
|
||
|
||
$input.attr('name', newName);
|
||
|
||
$foreachRepeaterInItem(repeaters, $item, function (nestedFig) {
|
||
var $repeater = $(this);
|
||
setIndexes(
|
||
$filterNested($repeater.find('[data-repeater-item]'), nestedFig.repeaters || []),
|
||
groupName + '[' + index + ']' +
|
||
'[' + $repeater.find('[data-repeater-list]').first().data('repeater-list') + ']',
|
||
nestedFig.repeaters
|
||
);
|
||
});
|
||
});
|
||
});
|
||
|
||
$list.find('input[name][checked]')
|
||
.removeAttr('checked')
|
||
.prop('checked', true);
|
||
};
|
||
|
||
setIndexes($items(), getGroupName(), fig.repeaters);
|
||
initNested($items());
|
||
if(fig.initEmpty) {
|
||
$items().remove();
|
||
}
|
||
|
||
if(fig.ready) {
|
||
fig.ready(function () {
|
||
setIndexes($items(), getGroupName(), fig.repeaters);
|
||
});
|
||
}
|
||
|
||
var appendItem = (function () {
|
||
var setItemsValues = function ($item, data, repeaters) {
|
||
if(data || fig.defaultValues) {
|
||
var inputNames = {};
|
||
$filterNested($item.find('[name]'), repeaters).each(function () {
|
||
var key = $(this).attr('name').match(/\[([^\]]*)(\]|\]\[\])$/)[1];
|
||
inputNames[key] = $(this).attr('name');
|
||
});
|
||
|
||
$item.inputVal(map(
|
||
filter(data || fig.defaultValues, function (val, name) {
|
||
return inputNames[name];
|
||
}),
|
||
identity,
|
||
function (name) {
|
||
return inputNames[name];
|
||
}
|
||
));
|
||
}
|
||
|
||
|
||
$foreachRepeaterInItem(repeaters, $item, function (nestedFig) {
|
||
var $repeater = $(this);
|
||
$filterNested(
|
||
$repeater.find('[data-repeater-item]'),
|
||
nestedFig.repeaters
|
||
)
|
||
.each(function () {
|
||
var fieldName = $repeater.find('[data-repeater-list]').data('repeater-list');
|
||
if(data && data[fieldName]) {
|
||
var $template = $(this).clone();
|
||
$repeater.find('[data-repeater-item]').remove();
|
||
foreach(data[fieldName], function (data) {
|
||
var $item = $template.clone();
|
||
setItemsValues(
|
||
$item,
|
||
data,
|
||
nestedFig.repeaters || []
|
||
);
|
||
$repeater.find('[data-repeater-list]').append($item);
|
||
});
|
||
}
|
||
else {
|
||
setItemsValues(
|
||
$(this),
|
||
nestedFig.defaultValues,
|
||
nestedFig.repeaters || []
|
||
);
|
||
}
|
||
});
|
||
});
|
||
|
||
};
|
||
|
||
return function ($item, data) {
|
||
$list.append($item);
|
||
setIndexes($items(), getGroupName(), fig.repeaters);
|
||
$item.find('[name]').each(function () {
|
||
$(this).inputClear();
|
||
});
|
||
setItemsValues($item, data || fig.defaultValues, fig.repeaters);
|
||
};
|
||
}());
|
||
|
||
var addItem = function (data) {
|
||
var $item = $itemTemplate.clone();
|
||
appendItem($item, data);
|
||
if(fig.repeaters) {
|
||
initNested($item);
|
||
}
|
||
show.call($item.get(0));
|
||
};
|
||
|
||
setList = function (rows) {
|
||
$items().remove();
|
||
foreach(rows, addItem);
|
||
};
|
||
|
||
$filterNested($self.find('[data-repeater-create]'), fig.repeaters).click(function () {
|
||
addItem();
|
||
});
|
||
|
||
$list.on('click', '[data-repeater-delete]', function () {
|
||
var self = $(this).closest('[data-repeater-item]').get(0);
|
||
hide.call(self, function () {
|
||
$(self).remove();
|
||
setIndexes($items(), getGroupName(), fig.repeaters);
|
||
});
|
||
});
|
||
});
|
||
|
||
this.setList = setList;
|
||
|
||
return this;
|
||
};
|
||
|
||
}(jQuery));
|
||
/*!
|
||
* jQuery Form Plugin
|
||
* version: 4.2.2
|
||
* Requires jQuery v1.7.2 or later
|
||
* Project repository: https://github.com/jquery-form/form
|
||
|
||
* Copyright 2017 Kevin Morris
|
||
* Copyright 2006 M. Alsup
|
||
|
||
* Dual licensed under the LGPL-2.1+ or MIT licenses
|
||
* https://github.com/jquery-form/form#license
|
||
|
||
* This library is free software; you can redistribute it and/or
|
||
* modify it under the terms of the GNU Lesser General Public
|
||
* License as published by the Free Software Foundation; either
|
||
* version 2.1 of the License, or (at your option) any later version.
|
||
* This library is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
* Lesser General Public License for more details.
|
||
*/
|
||
!function(e){"function"==typeof define&&define.amd?define(["jquery"],e):"object"==typeof module&&module.exports?module.exports=function(t,r){return void 0===r&&(r="undefined"!=typeof window?require("jquery"):require("jquery")(t)),e(r),r}:e(jQuery)}(function(e){"use strict";function t(t){var r=t.data;t.isDefaultPrevented()||(t.preventDefault(),e(t.target).closest("form").ajaxSubmit(r))}function r(t){var r=t.target,a=e(r);if(!a.is("[type=submit],[type=image]")){var n=a.closest("[type=submit]");if(0===n.length)return;r=n[0]}var i=r.form;if(i.clk=r,"image"===r.type)if(void 0!==t.offsetX)i.clk_x=t.offsetX,i.clk_y=t.offsetY;else if("function"==typeof e.fn.offset){var o=a.offset();i.clk_x=t.pageX-o.left,i.clk_y=t.pageY-o.top}else i.clk_x=t.pageX-r.offsetLeft,i.clk_y=t.pageY-r.offsetTop;setTimeout(function(){i.clk=i.clk_x=i.clk_y=null},100)}function a(){if(e.fn.ajaxSubmit.debug){var t="[jquery.form] "+Array.prototype.join.call(arguments,"");window.console&&window.console.log?window.console.log(t):window.opera&&window.opera.postError&&window.opera.postError(t)}}var n=/\r?\n/g,i={};i.fileapi=void 0!==e('<input type="file">').get(0).files,i.formdata=void 0!==window.FormData;var o=!!e.fn.prop;e.fn.attr2=function(){if(!o)return this.attr.apply(this,arguments);var e=this.prop.apply(this,arguments);return e&&e.jquery||"string"==typeof e?e:this.attr.apply(this,arguments)},e.fn.ajaxSubmit=function(t,r,n,s){function u(r){var a,n,i=e.param(r,t.traditional).split("&"),o=i.length,s=[];for(a=0;a<o;a++)i[a]=i[a].replace(/\+/g," "),n=i[a].split("="),s.push([decodeURIComponent(n[0]),decodeURIComponent(n[1])]);return s}function c(r){function n(e){var t=null;try{e.contentWindow&&(t=e.contentWindow.document)}catch(e){a("cannot get iframe.contentWindow document: "+e)}if(t)return t;try{t=e.contentDocument?e.contentDocument:e.document}catch(r){a("cannot get iframe.contentDocument: "+r),t=e.document}return t}function i(){function t(){try{var e=n(v).readyState;a("state = "+e),e&&"uninitialized"===e.toLowerCase()&&setTimeout(t,50)}catch(e){a("Server abort: ",e," (",e.name,")"),s(L),j&&clearTimeout(j),j=void 0}}var r=p.attr2("target"),i=p.attr2("action"),o=p.attr("enctype")||p.attr("encoding")||"multipart/form-data";w.setAttribute("target",m),l&&!/post/i.test(l)||w.setAttribute("method","POST"),i!==f.url&&w.setAttribute("action",f.url),f.skipEncodingOverride||l&&!/post/i.test(l)||p.attr({encoding:"multipart/form-data",enctype:"multipart/form-data"}),f.timeout&&(j=setTimeout(function(){T=!0,s(A)},f.timeout));var u=[];try{if(f.extraData)for(var c in f.extraData)f.extraData.hasOwnProperty(c)&&(e.isPlainObject(f.extraData[c])&&f.extraData[c].hasOwnProperty("name")&&f.extraData[c].hasOwnProperty("value")?u.push(e('<input type="hidden" name="'+f.extraData[c].name+'">',k).val(f.extraData[c].value).appendTo(w)[0]):u.push(e('<input type="hidden" name="'+c+'">',k).val(f.extraData[c]).appendTo(w)[0]));f.iframeTarget||h.appendTo(D),v.attachEvent?v.attachEvent("onload",s):v.addEventListener("load",s,!1),setTimeout(t,15);try{w.submit()}catch(e){document.createElement("form").submit.apply(w)}}finally{w.setAttribute("action",i),w.setAttribute("enctype",o),r?w.setAttribute("target",r):p.removeAttr("target"),e(u).remove()}}function s(t){if(!x.aborted&&!X){if((O=n(v))||(a("cannot access response document"),t=L),t===A&&x)return x.abort("timeout"),void S.reject(x,"timeout");if(t===L&&x)return x.abort("server abort"),void S.reject(x,"error","server abort");if(O&&O.location.href!==f.iframeSrc||T){v.detachEvent?v.detachEvent("onload",s):v.removeEventListener("load",s,!1);var r,i="success";try{if(T)throw"timeout";var o="xml"===f.dataType||O.XMLDocument||e.isXMLDoc(O);if(a("isXml="+o),!o&&window.opera&&(null===O.body||!O.body.innerHTML)&&--C)return a("requeing onLoad callback, DOM not available"),void setTimeout(s,250);var u=O.body?O.body:O.documentElement;x.responseText=u?u.innerHTML:null,x.responseXML=O.XMLDocument?O.XMLDocument:O,o&&(f.dataType="xml"),x.getResponseHeader=function(e){return{"content-type":f.dataType}[e.toLowerCase()]},u&&(x.status=Number(u.getAttribute("status"))||x.status,x.statusText=u.getAttribute("statusText")||x.statusText);var c=(f.dataType||"").toLowerCase(),l=/(json|script|text)/.test(c);if(l||f.textarea){var p=O.getElementsByTagName("textarea")[0];if(p)x.responseText=p.value,x.status=Number(p.getAttribute("status"))||x.status,x.statusText=p.getAttribute("statusText")||x.statusText;else if(l){var m=O.getElementsByTagName("pre")[0],g=O.getElementsByTagName("body")[0];m?x.responseText=m.textContent?m.textContent:m.innerText:g&&(x.responseText=g.textContent?g.textContent:g.innerText)}}else"xml"===c&&!x.responseXML&&x.responseText&&(x.responseXML=q(x.responseText));try{M=N(x,c,f)}catch(e){i="parsererror",x.error=r=e||i}}catch(e){a("error caught: ",e),i="error",x.error=r=e||i}x.aborted&&(a("upload aborted"),i=null),x.status&&(i=x.status>=200&&x.status<300||304===x.status?"success":"error"),"success"===i?(f.success&&f.success.call(f.context,M,"success",x),S.resolve(x.responseText,"success",x),d&&e.event.trigger("ajaxSuccess",[x,f])):i&&(void 0===r&&(r=x.statusText),f.error&&f.error.call(f.context,x,i,r),S.reject(x,"error",r),d&&e.event.trigger("ajaxError",[x,f,r])),d&&e.event.trigger("ajaxComplete",[x,f]),d&&!--e.active&&e.event.trigger("ajaxStop"),f.complete&&f.complete.call(f.context,x,i),X=!0,f.timeout&&clearTimeout(j),setTimeout(function(){f.iframeTarget?h.attr("src",f.iframeSrc):h.remove(),x.responseXML=null},100)}}}var u,c,f,d,m,h,v,x,y,b,T,j,w=p[0],S=e.Deferred();if(S.abort=function(e){x.abort(e)},r)for(c=0;c<g.length;c++)u=e(g[c]),o?u.prop("disabled",!1):u.removeAttr("disabled");(f=e.extend(!0,{},e.ajaxSettings,t)).context=f.context||f,m="jqFormIO"+(new Date).getTime();var k=w.ownerDocument,D=p.closest("body");if(f.iframeTarget?(b=(h=e(f.iframeTarget,k)).attr2("name"))?m=b:h.attr2("name",m):(h=e('<iframe name="'+m+'" src="'+f.iframeSrc+'" />',k)).css({position:"absolute",top:"-1000px",left:"-1000px"}),v=h[0],x={aborted:0,responseText:null,responseXML:null,status:0,statusText:"n/a",getAllResponseHeaders:function(){},getResponseHeader:function(){},setRequestHeader:function(){},abort:function(t){var r="timeout"===t?"timeout":"aborted";a("aborting upload... "+r),this.aborted=1;try{v.contentWindow.document.execCommand&&v.contentWindow.document.execCommand("Stop")}catch(e){}h.attr("src",f.iframeSrc),x.error=r,f.error&&f.error.call(f.context,x,r,t),d&&e.event.trigger("ajaxError",[x,f,r]),f.complete&&f.complete.call(f.context,x,r)}},(d=f.global)&&0==e.active++&&e.event.trigger("ajaxStart"),d&&e.event.trigger("ajaxSend",[x,f]),f.beforeSend&&!1===f.beforeSend.call(f.context,x,f))return f.global&&e.active--,S.reject(),S;if(x.aborted)return S.reject(),S;(y=w.clk)&&(b=y.name)&&!y.disabled&&(f.extraData=f.extraData||{},f.extraData[b]=y.value,"image"===y.type&&(f.extraData[b+".x"]=w.clk_x,f.extraData[b+".y"]=w.clk_y));var A=1,L=2,F=e("meta[name=csrf-token]").attr("content"),E=e("meta[name=csrf-param]").attr("content");E&&F&&(f.extraData=f.extraData||{},f.extraData[E]=F),f.forceSync?i():setTimeout(i,10);var M,O,X,C=50,q=e.parseXML||function(e,t){return window.ActiveXObject?((t=new ActiveXObject("Microsoft.XMLDOM")).async="false",t.loadXML(e)):t=(new DOMParser).parseFromString(e,"text/xml"),t&&t.documentElement&&"parsererror"!==t.documentElement.nodeName?t:null},_=e.parseJSON||function(e){return window.eval("("+e+")")},N=function(t,r,a){var n=t.getResponseHeader("content-type")||"",i=("xml"===r||!r)&&n.indexOf("xml")>=0,o=i?t.responseXML:t.responseText;return i&&"parsererror"===o.documentElement.nodeName&&e.error&&e.error("parsererror"),a&&a.dataFilter&&(o=a.dataFilter(o,r)),"string"==typeof o&&(("json"===r||!r)&&n.indexOf("json")>=0?o=_(o):("script"===r||!r)&&n.indexOf("javascript")>=0&&e.globalEval(o)),o};return S}if(!this.length)return a("ajaxSubmit: skipping submit process - no element selected"),this;var l,f,d,p=this;"function"==typeof t?t={success:t}:"string"==typeof t||!1===t&&arguments.length>0?(t={url:t,data:r,dataType:n},"function"==typeof s&&(t.success=s)):void 0===t&&(t={}),l=t.method||t.type||this.attr2("method"),(d=(d="string"==typeof(f=t.url||this.attr2("action"))?e.trim(f):"")||window.location.href||"")&&(d=(d.match(/^([^#]+)/)||[])[1]),t=e.extend(!0,{url:d,success:e.ajaxSettings.success,type:l||e.ajaxSettings.type,iframeSrc:/^https/i.test(window.location.href||"")?"javascript:false":"about:blank"},t);var m={};if(this.trigger("form-pre-serialize",[this,t,m]),m.veto)return a("ajaxSubmit: submit vetoed via form-pre-serialize trigger"),this;if(t.beforeSerialize&&!1===t.beforeSerialize(this,t))return a("ajaxSubmit: submit aborted via beforeSerialize callback"),this;var h=t.traditional;void 0===h&&(h=e.ajaxSettings.traditional);var v,g=[],x=this.formToArray(t.semantic,g,t.filtering);if(t.data){var y=e.isFunction(t.data)?t.data(x):t.data;t.extraData=y,v=e.param(y,h)}if(t.beforeSubmit&&!1===t.beforeSubmit(x,this,t))return a("ajaxSubmit: submit aborted via beforeSubmit callback"),this;if(this.trigger("form-submit-validate",[x,this,t,m]),m.veto)return a("ajaxSubmit: submit vetoed via form-submit-validate trigger"),this;var b=e.param(x,h);v&&(b=b?b+"&"+v:v),"GET"===t.type.toUpperCase()?(t.url+=(t.url.indexOf("?")>=0?"&":"?")+b,t.data=null):t.data=b;var T=[];if(t.resetForm&&T.push(function(){p.resetForm()}),t.clearForm&&T.push(function(){p.clearForm(t.includeHidden)}),!t.dataType&&t.target){var j=t.success||function(){};T.push(function(r,a,n){var i=arguments,o=t.replaceTarget?"replaceWith":"html";e(t.target)[o](r).each(function(){j.apply(this,i)})})}else t.success&&(e.isArray(t.success)?e.merge(T,t.success):T.push(t.success));if(t.success=function(e,r,a){for(var n=t.context||this,i=0,o=T.length;i<o;i++)T[i].apply(n,[e,r,a||p,p])},t.error){var w=t.error;t.error=function(e,r,a){var n=t.context||this;w.apply(n,[e,r,a,p])}}if(t.complete){var S=t.complete;t.complete=function(e,r){var a=t.context||this;S.apply(a,[e,r,p])}}var k=e("input[type=file]:enabled",this).filter(function(){return""!==e(this).val()}).length>0,D="multipart/form-data",A=p.attr("enctype")===D||p.attr("encoding")===D,L=i.fileapi&&i.formdata;a("fileAPI :"+L);var F,E=(k||A)&&!L;!1!==t.iframe&&(t.iframe||E)?t.closeKeepAlive?e.get(t.closeKeepAlive,function(){F=c(x)}):F=c(x):F=(k||A)&&L?function(r){for(var a=new FormData,n=0;n<r.length;n++)a.append(r[n].name,r[n].value);if(t.extraData){var i=u(t.extraData);for(n=0;n<i.length;n++)i[n]&&a.append(i[n][0],i[n][1])}t.data=null;var o=e.extend(!0,{},e.ajaxSettings,t,{contentType:!1,processData:!1,cache:!1,type:l||"POST"});t.uploadProgress&&(o.xhr=function(){var r=e.ajaxSettings.xhr();return r.upload&&r.upload.addEventListener("progress",function(e){var r=0,a=e.loaded||e.position,n=e.total;e.lengthComputable&&(r=Math.ceil(a/n*100)),t.uploadProgress(e,a,n,r)},!1),r}),o.data=null;var s=o.beforeSend;return o.beforeSend=function(e,r){t.formData?r.data=t.formData:r.data=a,s&&s.call(this,e,r)},e.ajax(o)}(x):e.ajax(t),p.removeData("jqxhr").data("jqxhr",F);for(var M=0;M<g.length;M++)g[M]=null;return this.trigger("form-submit-notify",[this,t]),this},e.fn.ajaxForm=function(n,i,o,s){if(("string"==typeof n||!1===n&&arguments.length>0)&&(n={url:n,data:i,dataType:o},"function"==typeof s&&(n.success=s)),n=n||{},n.delegation=n.delegation&&e.isFunction(e.fn.on),!n.delegation&&0===this.length){var u={s:this.selector,c:this.context};return!e.isReady&&u.s?(a("DOM not ready, queuing ajaxForm"),e(function(){e(u.s,u.c).ajaxForm(n)}),this):(a("terminating; zero elements found by selector"+(e.isReady?"":" (DOM not ready)")),this)}return n.delegation?(e(document).off("submit.form-plugin",this.selector,t).off("click.form-plugin",this.selector,r).on("submit.form-plugin",this.selector,n,t).on("click.form-plugin",this.selector,n,r),this):this.ajaxFormUnbind().on("submit.form-plugin",n,t).on("click.form-plugin",n,r)},e.fn.ajaxFormUnbind=function(){return this.off("submit.form-plugin click.form-plugin")},e.fn.formToArray=function(t,r,a){var n=[];if(0===this.length)return n;var o,s=this[0],u=this.attr("id"),c=t||void 0===s.elements?s.getElementsByTagName("*"):s.elements;if(c&&(c=e.makeArray(c)),u&&(t||/(Edge|Trident)\//.test(navigator.userAgent))&&(o=e(':input[form="'+u+'"]').get()).length&&(c=(c||[]).concat(o)),!c||!c.length)return n;e.isFunction(a)&&(c=e.map(c,a));var l,f,d,p,m,h,v;for(l=0,h=c.length;l<h;l++)if(m=c[l],(d=m.name)&&!m.disabled)if(t&&s.clk&&"image"===m.type)s.clk===m&&(n.push({name:d,value:e(m).val(),type:m.type}),n.push({name:d+".x",value:s.clk_x},{name:d+".y",value:s.clk_y}));else if((p=e.fieldValue(m,!0))&&p.constructor===Array)for(r&&r.push(m),f=0,v=p.length;f<v;f++)n.push({name:d,value:p[f]});else if(i.fileapi&&"file"===m.type){r&&r.push(m);var g=m.files;if(g.length)for(f=0;f<g.length;f++)n.push({name:d,value:g[f],type:m.type});else n.push({name:d,value:"",type:m.type})}else null!==p&&void 0!==p&&(r&&r.push(m),n.push({name:d,value:p,type:m.type,required:m.required}));if(!t&&s.clk){var x=e(s.clk),y=x[0];(d=y.name)&&!y.disabled&&"image"===y.type&&(n.push({name:d,value:x.val()}),n.push({name:d+".x",value:s.clk_x},{name:d+".y",value:s.clk_y}))}return n},e.fn.formSerialize=function(t){return e.param(this.formToArray(t))},e.fn.fieldSerialize=function(t){var r=[];return this.each(function(){var a=this.name;if(a){var n=e.fieldValue(this,t);if(n&&n.constructor===Array)for(var i=0,o=n.length;i<o;i++)r.push({name:a,value:n[i]});else null!==n&&void 0!==n&&r.push({name:this.name,value:n})}}),e.param(r)},e.fn.fieldValue=function(t){for(var r=[],a=0,n=this.length;a<n;a++){var i=this[a],o=e.fieldValue(i,t);null===o||void 0===o||o.constructor===Array&&!o.length||(o.constructor===Array?e.merge(r,o):r.push(o))}return r},e.fieldValue=function(t,r){var a=t.name,i=t.type,o=t.tagName.toLowerCase();if(void 0===r&&(r=!0),r&&(!a||t.disabled||"reset"===i||"button"===i||("checkbox"===i||"radio"===i)&&!t.checked||("submit"===i||"image"===i)&&t.form&&t.form.clk!==t||"select"===o&&-1===t.selectedIndex))return null;if("select"===o){var s=t.selectedIndex;if(s<0)return null;for(var u=[],c=t.options,l="select-one"===i,f=l?s+1:c.length,d=l?s:0;d<f;d++){var p=c[d];if(p.selected&&!p.disabled){var m=p.value;if(m||(m=p.attributes&&p.attributes.value&&!p.attributes.value.specified?p.text:p.value),l)return m;u.push(m)}}return u}return e(t).val().replace(n,"\r\n")},e.fn.clearForm=function(t){return this.each(function(){e("input,select,textarea",this).clearFields(t)})},e.fn.clearFields=e.fn.clearInputs=function(t){var r=/^(?:color|date|datetime|email|month|number|password|range|search|tel|text|time|url|week)$/i;return this.each(function(){var a=this.type,n=this.tagName.toLowerCase();r.test(a)||"textarea"===n?this.value="":"checkbox"===a||"radio"===a?this.checked=!1:"select"===n?this.selectedIndex=-1:"file"===a?/MSIE/.test(navigator.userAgent)?e(this).replaceWith(e(this).clone(!0)):e(this).val(""):t&&(!0===t&&/hidden/.test(a)||"string"==typeof t&&e(this).is(t))&&(this.value="")})},e.fn.resetForm=function(){return this.each(function(){var t=e(this),r=this.tagName.toLowerCase();switch(r){case"input":this.checked=this.defaultChecked;case"textarea":return this.value=this.defaultValue,!0;case"option":case"optgroup":var a=t.parents("select");return a.length&&a[0].multiple?"option"===r?this.selected=this.defaultSelected:t.find("option").resetForm():a.resetForm(),!0;case"select":return t.find("option").each(function(e){if(this.selected=this.defaultSelected,this.defaultSelected&&!t[0].multiple)return t[0].selectedIndex=e,!1}),!0;case"label":var n=e(t.attr("for")),i=t.find("input,select,textarea");return n[0]&&i.unshift(n[0]),i.resetForm(),!0;case"form":return("function"==typeof this.reset||"object"==typeof this.reset&&!this.reset.nodeType)&&this.reset(),!0;default:return t.find("form,input,label,select,textarea").resetForm(),!0}})},e.fn.enable=function(e){return void 0===e&&(e=!0),this.each(function(){this.disabled=!e})},e.fn.selected=function(t){return void 0===t&&(t=!0),this.each(function(){var r=this.type;if("checkbox"===r||"radio"===r)this.checked=t;else if("option"===this.tagName.toLowerCase()){var a=e(this).parent("select");t&&a[0]&&"select-one"===a[0].type&&a.find("option").selected(!1),this.selected=t}})},e.fn.ajaxSubmit.debug=!1});
|
||
//# sourceMappingURL=jquery.form.min.js.map
|
||
|
||
/*
|
||
== malihu jquery custom scrollbar plugin ==
|
||
Version: 3.1.5
|
||
Plugin URI: http://manos.malihu.gr/jquery-custom-content-scroller
|
||
Author: malihu
|
||
Author URI: http://manos.malihu.gr
|
||
License: MIT License (MIT)
|
||
*/
|
||
|
||
/*
|
||
Copyright Manos Malihutsakis (email: manos@malihu.gr)
|
||
|
||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||
of this software and associated documentation files (the "Software"), to deal
|
||
in the Software without restriction, including without limitation the rights
|
||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||
copies of the Software, and to permit persons to whom the Software is
|
||
furnished to do so, subject to the following conditions:
|
||
|
||
The above copyright notice and this permission notice shall be included in
|
||
all copies or substantial portions of the Software.
|
||
|
||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||
THE SOFTWARE.
|
||
*/
|
||
|
||
/*
|
||
The code below is fairly long, fully commented and should be normally used in development.
|
||
For production, use either the minified jquery.mCustomScrollbar.min.js script or
|
||
the production-ready jquery.mCustomScrollbar.concat.min.js which contains the plugin
|
||
and dependencies (minified).
|
||
*/
|
||
|
||
(function(factory){
|
||
if(typeof define==="function" && define.amd){
|
||
define(["jquery"],factory);
|
||
}else if(typeof module!=="undefined" && module.exports){
|
||
module.exports=factory;
|
||
}else{
|
||
factory(jQuery,window,document);
|
||
}
|
||
}(function($){
|
||
(function(init){
|
||
var _rjs=typeof define==="function" && define.amd, /* RequireJS */
|
||
_njs=typeof module !== "undefined" && module.exports, /* NodeJS */
|
||
_dlp=("https:"==document.location.protocol) ? "https:" : "http:", /* location protocol */
|
||
_url="cdnjs.cloudflare.com/ajax/libs/jquery-mousewheel/3.1.13/jquery.mousewheel.min.js";
|
||
if(!_rjs){
|
||
if(_njs){
|
||
require("jquery-mousewheel")($);
|
||
}else{
|
||
/* load jquery-mousewheel plugin (via CDN) if it's not present or not loaded via RequireJS
|
||
(works when mCustomScrollbar fn is called on window load) */
|
||
$.event.special.mousewheel || $("head").append(decodeURI("%3Cscript src="+_dlp+"//"+_url+"%3E%3C/script%3E"));
|
||
}
|
||
}
|
||
init();
|
||
}(function(){
|
||
|
||
/*
|
||
----------------------------------------
|
||
PLUGIN NAMESPACE, PREFIX, DEFAULT SELECTOR(S)
|
||
----------------------------------------
|
||
*/
|
||
|
||
var pluginNS="mCustomScrollbar",
|
||
pluginPfx="mCS",
|
||
defaultSelector=".mCustomScrollbar",
|
||
|
||
|
||
|
||
|
||
|
||
/*
|
||
----------------------------------------
|
||
DEFAULT OPTIONS
|
||
----------------------------------------
|
||
*/
|
||
|
||
defaults={
|
||
/*
|
||
set element/content width/height programmatically
|
||
values: boolean, pixels, percentage
|
||
option default
|
||
-------------------------------------
|
||
setWidth false
|
||
setHeight false
|
||
*/
|
||
/*
|
||
set the initial css top property of content
|
||
values: string (e.g. "-100px", "10%" etc.)
|
||
*/
|
||
setTop:0,
|
||
/*
|
||
set the initial css left property of content
|
||
values: string (e.g. "-100px", "10%" etc.)
|
||
*/
|
||
setLeft:0,
|
||
/*
|
||
scrollbar axis (vertical and/or horizontal scrollbars)
|
||
values (string): "y", "x", "yx"
|
||
*/
|
||
axis:"y",
|
||
/*
|
||
position of scrollbar relative to content
|
||
values (string): "inside", "outside" ("outside" requires elements with position:relative)
|
||
*/
|
||
scrollbarPosition:"inside",
|
||
/*
|
||
scrolling inertia
|
||
values: integer (milliseconds)
|
||
*/
|
||
scrollInertia:950,
|
||
/*
|
||
auto-adjust scrollbar dragger length
|
||
values: boolean
|
||
*/
|
||
autoDraggerLength:true,
|
||
/*
|
||
auto-hide scrollbar when idle
|
||
values: boolean
|
||
option default
|
||
-------------------------------------
|
||
autoHideScrollbar false
|
||
*/
|
||
/*
|
||
auto-expands scrollbar on mouse-over and dragging
|
||
values: boolean
|
||
option default
|
||
-------------------------------------
|
||
autoExpandScrollbar false
|
||
*/
|
||
/*
|
||
always show scrollbar, even when there's nothing to scroll
|
||
values: integer (0=disable, 1=always show dragger rail and buttons, 2=always show dragger rail, dragger and buttons), boolean
|
||
*/
|
||
alwaysShowScrollbar:0,
|
||
/*
|
||
scrolling always snaps to a multiple of this number in pixels
|
||
values: integer, array ([y,x])
|
||
option default
|
||
-------------------------------------
|
||
snapAmount null
|
||
*/
|
||
/*
|
||
when snapping, snap with this number in pixels as an offset
|
||
values: integer
|
||
*/
|
||
snapOffset:0,
|
||
/*
|
||
mouse-wheel scrolling
|
||
*/
|
||
mouseWheel:{
|
||
/*
|
||
enable mouse-wheel scrolling
|
||
values: boolean
|
||
*/
|
||
enable:true,
|
||
/*
|
||
scrolling amount in pixels
|
||
values: "auto", integer
|
||
*/
|
||
scrollAmount:"auto",
|
||
/*
|
||
mouse-wheel scrolling axis
|
||
the default scrolling direction when both vertical and horizontal scrollbars are present
|
||
values (string): "y", "x"
|
||
*/
|
||
axis:"y",
|
||
/*
|
||
prevent the default behaviour which automatically scrolls the parent element(s) when end of scrolling is reached
|
||
values: boolean
|
||
option default
|
||
-------------------------------------
|
||
preventDefault null
|
||
*/
|
||
/*
|
||
the reported mouse-wheel delta value. The number of lines (translated to pixels) one wheel notch scrolls.
|
||
values: "auto", integer
|
||
"auto" uses the default OS/browser value
|
||
*/
|
||
deltaFactor:"auto",
|
||
/*
|
||
normalize mouse-wheel delta to -1 or 1 (disables mouse-wheel acceleration)
|
||
values: boolean
|
||
option default
|
||
-------------------------------------
|
||
normalizeDelta null
|
||
*/
|
||
/*
|
||
invert mouse-wheel scrolling direction
|
||
values: boolean
|
||
option default
|
||
-------------------------------------
|
||
invert null
|
||
*/
|
||
/*
|
||
the tags that disable mouse-wheel when cursor is over them
|
||
*/
|
||
disableOver:["select","option","keygen","datalist","textarea"]
|
||
},
|
||
/*
|
||
scrollbar buttons
|
||
*/
|
||
scrollButtons:{
|
||
/*
|
||
enable scrollbar buttons
|
||
values: boolean
|
||
option default
|
||
-------------------------------------
|
||
enable null
|
||
*/
|
||
/*
|
||
scrollbar buttons scrolling type
|
||
values (string): "stepless", "stepped"
|
||
*/
|
||
scrollType:"stepless",
|
||
/*
|
||
scrolling amount in pixels
|
||
values: "auto", integer
|
||
*/
|
||
scrollAmount:"auto"
|
||
/*
|
||
tabindex of the scrollbar buttons
|
||
values: false, integer
|
||
option default
|
||
-------------------------------------
|
||
tabindex null
|
||
*/
|
||
},
|
||
/*
|
||
keyboard scrolling
|
||
*/
|
||
keyboard:{
|
||
/*
|
||
enable scrolling via keyboard
|
||
values: boolean
|
||
*/
|
||
enable:true,
|
||
/*
|
||
keyboard scrolling type
|
||
values (string): "stepless", "stepped"
|
||
*/
|
||
scrollType:"stepless",
|
||
/*
|
||
scrolling amount in pixels
|
||
values: "auto", integer
|
||
*/
|
||
scrollAmount:"auto"
|
||
},
|
||
/*
|
||
enable content touch-swipe scrolling
|
||
values: boolean, integer, string (number)
|
||
integer values define the axis-specific minimum amount required for scrolling momentum
|
||
*/
|
||
contentTouchScroll:25,
|
||
/*
|
||
enable/disable document (default) touch-swipe scrolling
|
||
*/
|
||
documentTouchScroll:true,
|
||
/*
|
||
advanced option parameters
|
||
*/
|
||
advanced:{
|
||
/*
|
||
auto-expand content horizontally (for "x" or "yx" axis)
|
||
values: boolean, integer (the value 2 forces the non scrollHeight/scrollWidth method, the value 3 forces the scrollHeight/scrollWidth method)
|
||
option default
|
||
-------------------------------------
|
||
autoExpandHorizontalScroll null
|
||
*/
|
||
/*
|
||
auto-scroll to elements with focus
|
||
*/
|
||
autoScrollOnFocus:"input,textarea,select,button,datalist,keygen,a[tabindex],area,object,[contenteditable='true']",
|
||
/*
|
||
auto-update scrollbars on content, element or viewport resize
|
||
should be true for fluid layouts/elements, adding/removing content dynamically, hiding/showing elements, content with images etc.
|
||
values: boolean
|
||
*/
|
||
updateOnContentResize:true,
|
||
/*
|
||
auto-update scrollbars each time each image inside the element is fully loaded
|
||
values: "auto", boolean
|
||
*/
|
||
updateOnImageLoad:"auto",
|
||
/*
|
||
auto-update scrollbars based on the amount and size changes of specific selectors
|
||
useful when you need to update the scrollbar(s) automatically, each time a type of element is added, removed or changes its size
|
||
values: boolean, string (e.g. "ul li" will auto-update scrollbars each time list-items inside the element are changed)
|
||
a value of true (boolean) will auto-update scrollbars each time any element is changed
|
||
option default
|
||
-------------------------------------
|
||
updateOnSelectorChange null
|
||
*/
|
||
/*
|
||
extra selectors that'll allow scrollbar dragging upon mousemove/up, pointermove/up, touchend etc. (e.g. "selector-1, selector-2")
|
||
option default
|
||
-------------------------------------
|
||
extraDraggableSelectors null
|
||
*/
|
||
/*
|
||
extra selectors that'll release scrollbar dragging upon mouseup, pointerup, touchend etc. (e.g. "selector-1, selector-2")
|
||
option default
|
||
-------------------------------------
|
||
releaseDraggableSelectors null
|
||
*/
|
||
/*
|
||
auto-update timeout
|
||
values: integer (milliseconds)
|
||
*/
|
||
autoUpdateTimeout:60
|
||
},
|
||
/*
|
||
scrollbar theme
|
||
values: string (see CSS/plugin URI for a list of ready-to-use themes)
|
||
*/
|
||
theme:"light",
|
||
/*
|
||
user defined callback functions
|
||
*/
|
||
callbacks:{
|
||
/*
|
||
Available callbacks:
|
||
callback default
|
||
-------------------------------------
|
||
onCreate null
|
||
onInit null
|
||
onScrollStart null
|
||
onScroll null
|
||
onTotalScroll null
|
||
onTotalScrollBack null
|
||
whileScrolling null
|
||
onOverflowY null
|
||
onOverflowX null
|
||
onOverflowYNone null
|
||
onOverflowXNone null
|
||
onImageLoad null
|
||
onSelectorChange null
|
||
onBeforeUpdate null
|
||
onUpdate null
|
||
*/
|
||
onTotalScrollOffset:0,
|
||
onTotalScrollBackOffset:0,
|
||
alwaysTriggerOffsets:true
|
||
}
|
||
/*
|
||
add scrollbar(s) on all elements matching the current selector, now and in the future
|
||
values: boolean, string
|
||
string values: "on" (enable), "once" (disable after first invocation), "off" (disable)
|
||
liveSelector values: string (selector)
|
||
option default
|
||
-------------------------------------
|
||
live false
|
||
liveSelector null
|
||
*/
|
||
},
|
||
|
||
|
||
|
||
|
||
|
||
/*
|
||
----------------------------------------
|
||
VARS, CONSTANTS
|
||
----------------------------------------
|
||
*/
|
||
|
||
totalInstances=0, /* plugin instances amount */
|
||
liveTimers={}, /* live option timers */
|
||
oldIE=(window.attachEvent && !window.addEventListener) ? 1 : 0, /* detect IE < 9 */
|
||
touchActive=false,touchable, /* global touch vars (for touch and pointer events) */
|
||
/* general plugin classes */
|
||
classes=[
|
||
"mCSB_dragger_onDrag","mCSB_scrollTools_onDrag","mCS_img_loaded","mCS_disabled","mCS_destroyed","mCS_no_scrollbar",
|
||
"mCS-autoHide","mCS-dir-rtl","mCS_no_scrollbar_y","mCS_no_scrollbar_x","mCS_y_hidden","mCS_x_hidden","mCSB_draggerContainer",
|
||
"mCSB_buttonUp","mCSB_buttonDown","mCSB_buttonLeft","mCSB_buttonRight"
|
||
],
|
||
|
||
|
||
|
||
|
||
|
||
/*
|
||
----------------------------------------
|
||
METHODS
|
||
----------------------------------------
|
||
*/
|
||
|
||
methods={
|
||
|
||
/*
|
||
plugin initialization method
|
||
creates the scrollbar(s), plugin data object and options
|
||
----------------------------------------
|
||
*/
|
||
|
||
init:function(options){
|
||
|
||
var options=$.extend(true,{},defaults,options),
|
||
selector=_selector.call(this); /* validate selector */
|
||
|
||
/*
|
||
if live option is enabled, monitor for elements matching the current selector and
|
||
apply scrollbar(s) when found (now and in the future)
|
||
*/
|
||
if(options.live){
|
||
var liveSelector=options.liveSelector || this.selector || defaultSelector, /* live selector(s) */
|
||
$liveSelector=$(liveSelector); /* live selector(s) as jquery object */
|
||
if(options.live==="off"){
|
||
/*
|
||
disable live if requested
|
||
usage: $(selector).mCustomScrollbar({live:"off"});
|
||
*/
|
||
removeLiveTimers(liveSelector);
|
||
return;
|
||
}
|
||
liveTimers[liveSelector]=setTimeout(function(){
|
||
/* call mCustomScrollbar fn on live selector(s) every half-second */
|
||
$liveSelector.mCustomScrollbar(options);
|
||
if(options.live==="once" && $liveSelector.length){
|
||
/* disable live after first invocation */
|
||
removeLiveTimers(liveSelector);
|
||
}
|
||
},500);
|
||
}else{
|
||
removeLiveTimers(liveSelector);
|
||
}
|
||
|
||
/* options backward compatibility (for versions < 3.0.0) and normalization */
|
||
options.setWidth=(options.set_width) ? options.set_width : options.setWidth;
|
||
options.setHeight=(options.set_height) ? options.set_height : options.setHeight;
|
||
options.axis=(options.horizontalScroll) ? "x" : _findAxis(options.axis);
|
||
options.scrollInertia=options.scrollInertia>0 && options.scrollInertia<17 ? 17 : options.scrollInertia;
|
||
if(typeof options.mouseWheel!=="object" && options.mouseWheel==true){ /* old school mouseWheel option (non-object) */
|
||
options.mouseWheel={enable:true,scrollAmount:"auto",axis:"y",preventDefault:false,deltaFactor:"auto",normalizeDelta:false,invert:false}
|
||
}
|
||
options.mouseWheel.scrollAmount=!options.mouseWheelPixels ? options.mouseWheel.scrollAmount : options.mouseWheelPixels;
|
||
options.mouseWheel.normalizeDelta=!options.advanced.normalizeMouseWheelDelta ? options.mouseWheel.normalizeDelta : options.advanced.normalizeMouseWheelDelta;
|
||
options.scrollButtons.scrollType=_findScrollButtonsType(options.scrollButtons.scrollType);
|
||
|
||
_theme(options); /* theme-specific options */
|
||
|
||
/* plugin constructor */
|
||
return $(selector).each(function(){
|
||
|
||
var $this=$(this);
|
||
|
||
if(!$this.data(pluginPfx)){ /* prevent multiple instantiations */
|
||
|
||
/* store options and create objects in jquery data */
|
||
$this.data(pluginPfx,{
|
||
idx:++totalInstances, /* instance index */
|
||
opt:options, /* options */
|
||
scrollRatio:{y:null,x:null}, /* scrollbar to content ratio */
|
||
overflowed:null, /* overflowed axis */
|
||
contentReset:{y:null,x:null}, /* object to check when content resets */
|
||
bindEvents:false, /* object to check if events are bound */
|
||
tweenRunning:false, /* object to check if tween is running */
|
||
sequential:{}, /* sequential scrolling object */
|
||
langDir:$this.css("direction"), /* detect/store direction (ltr or rtl) */
|
||
cbOffsets:null, /* object to check whether callback offsets always trigger */
|
||
/*
|
||
object to check how scrolling events where last triggered
|
||
"internal" (default - triggered by this script), "external" (triggered by other scripts, e.g. via scrollTo method)
|
||
usage: object.data("mCS").trigger
|
||
*/
|
||
trigger:null,
|
||
/*
|
||
object to check for changes in elements in order to call the update method automatically
|
||
*/
|
||
poll:{size:{o:0,n:0},img:{o:0,n:0},change:{o:0,n:0}}
|
||
});
|
||
|
||
var d=$this.data(pluginPfx),o=d.opt,
|
||
/* HTML data attributes */
|
||
htmlDataAxis=$this.data("mcs-axis"),htmlDataSbPos=$this.data("mcs-scrollbar-position"),htmlDataTheme=$this.data("mcs-theme");
|
||
|
||
if(htmlDataAxis){o.axis=htmlDataAxis;} /* usage example: data-mcs-axis="y" */
|
||
if(htmlDataSbPos){o.scrollbarPosition=htmlDataSbPos;} /* usage example: data-mcs-scrollbar-position="outside" */
|
||
if(htmlDataTheme){ /* usage example: data-mcs-theme="minimal" */
|
||
o.theme=htmlDataTheme;
|
||
_theme(o); /* theme-specific options */
|
||
}
|
||
|
||
_pluginMarkup.call(this); /* add plugin markup */
|
||
|
||
if(d && o.callbacks.onCreate && typeof o.callbacks.onCreate==="function"){o.callbacks.onCreate.call(this);} /* callbacks: onCreate */
|
||
|
||
$("#mCSB_"+d.idx+"_container img:not(."+classes[2]+")").addClass(classes[2]); /* flag loaded images */
|
||
|
||
methods.update.call(null,$this); /* call the update method */
|
||
|
||
}
|
||
|
||
});
|
||
|
||
},
|
||
/* ---------------------------------------- */
|
||
|
||
|
||
|
||
/*
|
||
plugin update method
|
||
updates content and scrollbar(s) values, events and status
|
||
----------------------------------------
|
||
usage: $(selector).mCustomScrollbar("update");
|
||
*/
|
||
|
||
update:function(el,cb){
|
||
|
||
var selector=el || _selector.call(this); /* validate selector */
|
||
|
||
return $(selector).each(function(){
|
||
|
||
var $this=$(this);
|
||
|
||
if($this.data(pluginPfx)){ /* check if plugin has initialized */
|
||
|
||
var d=$this.data(pluginPfx),o=d.opt,
|
||
mCSB_container=$("#mCSB_"+d.idx+"_container"),
|
||
mCustomScrollBox=$("#mCSB_"+d.idx),
|
||
mCSB_dragger=[$("#mCSB_"+d.idx+"_dragger_vertical"),$("#mCSB_"+d.idx+"_dragger_horizontal")];
|
||
|
||
if(!mCSB_container.length){return;}
|
||
|
||
if(d.tweenRunning){_stop($this);} /* stop any running tweens while updating */
|
||
|
||
if(cb && d && o.callbacks.onBeforeUpdate && typeof o.callbacks.onBeforeUpdate==="function"){o.callbacks.onBeforeUpdate.call(this);} /* callbacks: onBeforeUpdate */
|
||
|
||
/* if element was disabled or destroyed, remove class(es) */
|
||
if($this.hasClass(classes[3])){$this.removeClass(classes[3]);}
|
||
if($this.hasClass(classes[4])){$this.removeClass(classes[4]);}
|
||
|
||
/* css flexbox fix, detect/set max-height */
|
||
mCustomScrollBox.css("max-height","none");
|
||
if(mCustomScrollBox.height()!==$this.height()){mCustomScrollBox.css("max-height",$this.height());}
|
||
|
||
_expandContentHorizontally.call(this); /* expand content horizontally */
|
||
|
||
if(o.axis!=="y" && !o.advanced.autoExpandHorizontalScroll){
|
||
mCSB_container.css("width",_contentWidth(mCSB_container));
|
||
}
|
||
|
||
d.overflowed=_overflowed.call(this); /* determine if scrolling is required */
|
||
|
||
_scrollbarVisibility.call(this); /* show/hide scrollbar(s) */
|
||
|
||
/* auto-adjust scrollbar dragger length analogous to content */
|
||
if(o.autoDraggerLength){_setDraggerLength.call(this);}
|
||
|
||
_scrollRatio.call(this); /* calculate and store scrollbar to content ratio */
|
||
|
||
_bindEvents.call(this); /* bind scrollbar events */
|
||
|
||
/* reset scrolling position and/or events */
|
||
var to=[Math.abs(mCSB_container[0].offsetTop),Math.abs(mCSB_container[0].offsetLeft)];
|
||
if(o.axis!=="x"){ /* y/yx axis */
|
||
if(!d.overflowed[0]){ /* y scrolling is not required */
|
||
_resetContentPosition.call(this); /* reset content position */
|
||
if(o.axis==="y"){
|
||
_unbindEvents.call(this);
|
||
}else if(o.axis==="yx" && d.overflowed[1]){
|
||
_scrollTo($this,to[1].toString(),{dir:"x",dur:0,overwrite:"none"});
|
||
}
|
||
}else if(mCSB_dragger[0].height()>mCSB_dragger[0].parent().height()){
|
||
_resetContentPosition.call(this); /* reset content position */
|
||
}else{ /* y scrolling is required */
|
||
_scrollTo($this,to[0].toString(),{dir:"y",dur:0,overwrite:"none"});
|
||
d.contentReset.y=null;
|
||
}
|
||
}
|
||
if(o.axis!=="y"){ /* x/yx axis */
|
||
if(!d.overflowed[1]){ /* x scrolling is not required */
|
||
_resetContentPosition.call(this); /* reset content position */
|
||
if(o.axis==="x"){
|
||
_unbindEvents.call(this);
|
||
}else if(o.axis==="yx" && d.overflowed[0]){
|
||
_scrollTo($this,to[0].toString(),{dir:"y",dur:0,overwrite:"none"});
|
||
}
|
||
}else if(mCSB_dragger[1].width()>mCSB_dragger[1].parent().width()){
|
||
_resetContentPosition.call(this); /* reset content position */
|
||
}else{ /* x scrolling is required */
|
||
_scrollTo($this,to[1].toString(),{dir:"x",dur:0,overwrite:"none"});
|
||
d.contentReset.x=null;
|
||
}
|
||
}
|
||
|
||
/* callbacks: onImageLoad, onSelectorChange, onUpdate */
|
||
if(cb && d){
|
||
if(cb===2 && o.callbacks.onImageLoad && typeof o.callbacks.onImageLoad==="function"){
|
||
o.callbacks.onImageLoad.call(this);
|
||
}else if(cb===3 && o.callbacks.onSelectorChange && typeof o.callbacks.onSelectorChange==="function"){
|
||
o.callbacks.onSelectorChange.call(this);
|
||
}else if(o.callbacks.onUpdate && typeof o.callbacks.onUpdate==="function"){
|
||
o.callbacks.onUpdate.call(this);
|
||
}
|
||
}
|
||
|
||
_autoUpdate.call(this); /* initialize automatic updating (for dynamic content, fluid layouts etc.) */
|
||
|
||
}
|
||
|
||
});
|
||
|
||
},
|
||
/* ---------------------------------------- */
|
||
|
||
|
||
|
||
/*
|
||
plugin scrollTo method
|
||
triggers a scrolling event to a specific value
|
||
----------------------------------------
|
||
usage: $(selector).mCustomScrollbar("scrollTo",value,options);
|
||
*/
|
||
|
||
scrollTo:function(val,options){
|
||
|
||
/* prevent silly things like $(selector).mCustomScrollbar("scrollTo",undefined); */
|
||
if(typeof val=="undefined" || val==null){return;}
|
||
|
||
var selector=_selector.call(this); /* validate selector */
|
||
|
||
return $(selector).each(function(){
|
||
|
||
var $this=$(this);
|
||
|
||
if($this.data(pluginPfx)){ /* check if plugin has initialized */
|
||
|
||
var d=$this.data(pluginPfx),o=d.opt,
|
||
/* method default options */
|
||
methodDefaults={
|
||
trigger:"external", /* method is by default triggered externally (e.g. from other scripts) */
|
||
scrollInertia:o.scrollInertia, /* scrolling inertia (animation duration) */
|
||
scrollEasing:"mcsEaseInOut", /* animation easing */
|
||
moveDragger:false, /* move dragger instead of content */
|
||
timeout:60, /* scroll-to delay */
|
||
callbacks:true, /* enable/disable callbacks */
|
||
onStart:true,
|
||
onUpdate:true,
|
||
onComplete:true
|
||
},
|
||
methodOptions=$.extend(true,{},methodDefaults,options),
|
||
to=_arr.call(this,val),dur=methodOptions.scrollInertia>0 && methodOptions.scrollInertia<17 ? 17 : methodOptions.scrollInertia;
|
||
|
||
/* translate yx values to actual scroll-to positions */
|
||
to[0]=_to.call(this,to[0],"y");
|
||
to[1]=_to.call(this,to[1],"x");
|
||
|
||
/*
|
||
check if scroll-to value moves the dragger instead of content.
|
||
Only pixel values apply on dragger (e.g. 100, "100px", "-=100" etc.)
|
||
*/
|
||
if(methodOptions.moveDragger){
|
||
to[0]*=d.scrollRatio.y;
|
||
to[1]*=d.scrollRatio.x;
|
||
}
|
||
|
||
methodOptions.dur=_isTabHidden() ? 0 : dur; //skip animations if browser tab is hidden
|
||
|
||
setTimeout(function(){
|
||
/* do the scrolling */
|
||
if(to[0]!==null && typeof to[0]!=="undefined" && o.axis!=="x" && d.overflowed[0]){ /* scroll y */
|
||
methodOptions.dir="y";
|
||
methodOptions.overwrite="all";
|
||
_scrollTo($this,to[0].toString(),methodOptions);
|
||
}
|
||
if(to[1]!==null && typeof to[1]!=="undefined" && o.axis!=="y" && d.overflowed[1]){ /* scroll x */
|
||
methodOptions.dir="x";
|
||
methodOptions.overwrite="none";
|
||
_scrollTo($this,to[1].toString(),methodOptions);
|
||
}
|
||
},methodOptions.timeout);
|
||
|
||
}
|
||
|
||
});
|
||
|
||
},
|
||
/* ---------------------------------------- */
|
||
|
||
|
||
|
||
/*
|
||
plugin stop method
|
||
stops scrolling animation
|
||
----------------------------------------
|
||
usage: $(selector).mCustomScrollbar("stop");
|
||
*/
|
||
stop:function(){
|
||
|
||
var selector=_selector.call(this); /* validate selector */
|
||
|
||
return $(selector).each(function(){
|
||
|
||
var $this=$(this);
|
||
|
||
if($this.data(pluginPfx)){ /* check if plugin has initialized */
|
||
|
||
_stop($this);
|
||
|
||
}
|
||
|
||
});
|
||
|
||
},
|
||
/* ---------------------------------------- */
|
||
|
||
|
||
|
||
/*
|
||
plugin disable method
|
||
temporarily disables the scrollbar(s)
|
||
----------------------------------------
|
||
usage: $(selector).mCustomScrollbar("disable",reset);
|
||
reset (boolean): resets content position to 0
|
||
*/
|
||
disable:function(r){
|
||
|
||
var selector=_selector.call(this); /* validate selector */
|
||
|
||
return $(selector).each(function(){
|
||
|
||
var $this=$(this);
|
||
|
||
if($this.data(pluginPfx)){ /* check if plugin has initialized */
|
||
|
||
var d=$this.data(pluginPfx);
|
||
|
||
_autoUpdate.call(this,"remove"); /* remove automatic updating */
|
||
|
||
_unbindEvents.call(this); /* unbind events */
|
||
|
||
if(r){_resetContentPosition.call(this);} /* reset content position */
|
||
|
||
_scrollbarVisibility.call(this,true); /* show/hide scrollbar(s) */
|
||
|
||
$this.addClass(classes[3]); /* add disable class */
|
||
|
||
}
|
||
|
||
});
|
||
|
||
},
|
||
/* ---------------------------------------- */
|
||
|
||
|
||
|
||
/*
|
||
plugin destroy method
|
||
completely removes the scrollbar(s) and returns the element to its original state
|
||
----------------------------------------
|
||
usage: $(selector).mCustomScrollbar("destroy");
|
||
*/
|
||
destroy:function(){
|
||
|
||
var selector=_selector.call(this); /* validate selector */
|
||
|
||
return $(selector).each(function(){
|
||
|
||
var $this=$(this);
|
||
|
||
if($this.data(pluginPfx)){ /* check if plugin has initialized */
|
||
|
||
var d=$this.data(pluginPfx),o=d.opt,
|
||
mCustomScrollBox=$("#mCSB_"+d.idx),
|
||
mCSB_container=$("#mCSB_"+d.idx+"_container"),
|
||
scrollbar=$(".mCSB_"+d.idx+"_scrollbar");
|
||
|
||
if(o.live){removeLiveTimers(o.liveSelector || $(selector).selector);} /* remove live timers */
|
||
|
||
_autoUpdate.call(this,"remove"); /* remove automatic updating */
|
||
|
||
_unbindEvents.call(this); /* unbind events */
|
||
|
||
_resetContentPosition.call(this); /* reset content position */
|
||
|
||
$this.removeData(pluginPfx); /* remove plugin data object */
|
||
|
||
_delete(this,"mcs"); /* delete callbacks object */
|
||
|
||
/* remove plugin markup */
|
||
scrollbar.remove(); /* remove scrollbar(s) first (those can be either inside or outside plugin's inner wrapper) */
|
||
mCSB_container.find("img."+classes[2]).removeClass(classes[2]); /* remove loaded images flag */
|
||
mCustomScrollBox.replaceWith(mCSB_container.contents()); /* replace plugin's inner wrapper with the original content */
|
||
/* remove plugin classes from the element and add destroy class */
|
||
$this.removeClass(pluginNS+" _"+pluginPfx+"_"+d.idx+" "+classes[6]+" "+classes[7]+" "+classes[5]+" "+classes[3]).addClass(classes[4]);
|
||
|
||
}
|
||
|
||
});
|
||
|
||
}
|
||
/* ---------------------------------------- */
|
||
|
||
},
|
||
|
||
|
||
|
||
|
||
|
||
/*
|
||
----------------------------------------
|
||
FUNCTIONS
|
||
----------------------------------------
|
||
*/
|
||
|
||
/* validates selector (if selector is invalid or undefined uses the default one) */
|
||
_selector=function(){
|
||
return (typeof $(this)!=="object" || $(this).length<1) ? defaultSelector : this;
|
||
},
|
||
/* -------------------- */
|
||
|
||
|
||
/* changes options according to theme */
|
||
_theme=function(obj){
|
||
var fixedSizeScrollbarThemes=["rounded","rounded-dark","rounded-dots","rounded-dots-dark"],
|
||
nonExpandedScrollbarThemes=["rounded-dots","rounded-dots-dark","3d","3d-dark","3d-thick","3d-thick-dark","inset","inset-dark","inset-2","inset-2-dark","inset-3","inset-3-dark"],
|
||
disabledScrollButtonsThemes=["minimal","minimal-dark"],
|
||
enabledAutoHideScrollbarThemes=["minimal","minimal-dark"],
|
||
scrollbarPositionOutsideThemes=["minimal","minimal-dark"];
|
||
obj.autoDraggerLength=$.inArray(obj.theme,fixedSizeScrollbarThemes) > -1 ? false : obj.autoDraggerLength;
|
||
obj.autoExpandScrollbar=$.inArray(obj.theme,nonExpandedScrollbarThemes) > -1 ? false : obj.autoExpandScrollbar;
|
||
obj.scrollButtons.enable=$.inArray(obj.theme,disabledScrollButtonsThemes) > -1 ? false : obj.scrollButtons.enable;
|
||
obj.autoHideScrollbar=$.inArray(obj.theme,enabledAutoHideScrollbarThemes) > -1 ? true : obj.autoHideScrollbar;
|
||
obj.scrollbarPosition=$.inArray(obj.theme,scrollbarPositionOutsideThemes) > -1 ? "outside" : obj.scrollbarPosition;
|
||
},
|
||
/* -------------------- */
|
||
|
||
|
||
/* live option timers removal */
|
||
removeLiveTimers=function(selector){
|
||
if(liveTimers[selector]){
|
||
clearTimeout(liveTimers[selector]);
|
||
_delete(liveTimers,selector);
|
||
}
|
||
},
|
||
/* -------------------- */
|
||
|
||
|
||
/* normalizes axis option to valid values: "y", "x", "yx" */
|
||
_findAxis=function(val){
|
||
return (val==="yx" || val==="xy" || val==="auto") ? "yx" : (val==="x" || val==="horizontal") ? "x" : "y";
|
||
},
|
||
/* -------------------- */
|
||
|
||
|
||
/* normalizes scrollButtons.scrollType option to valid values: "stepless", "stepped" */
|
||
_findScrollButtonsType=function(val){
|
||
return (val==="stepped" || val==="pixels" || val==="step" || val==="click") ? "stepped" : "stepless";
|
||
},
|
||
/* -------------------- */
|
||
|
||
|
||
/* generates plugin markup */
|
||
_pluginMarkup=function(){
|
||
var $this=$(this),d=$this.data(pluginPfx),o=d.opt,
|
||
expandClass=o.autoExpandScrollbar ? " "+classes[1]+"_expand" : "",
|
||
scrollbar=["<div id='mCSB_"+d.idx+"_scrollbar_vertical' class='mCSB_scrollTools mCSB_"+d.idx+"_scrollbar mCS-"+o.theme+" mCSB_scrollTools_vertical"+expandClass+"'><div class='"+classes[12]+"'><div id='mCSB_"+d.idx+"_dragger_vertical' class='mCSB_dragger' style='position:absolute;'><div class='mCSB_dragger_bar' /></div><div class='mCSB_draggerRail' /></div></div>","<div id='mCSB_"+d.idx+"_scrollbar_horizontal' class='mCSB_scrollTools mCSB_"+d.idx+"_scrollbar mCS-"+o.theme+" mCSB_scrollTools_horizontal"+expandClass+"'><div class='"+classes[12]+"'><div id='mCSB_"+d.idx+"_dragger_horizontal' class='mCSB_dragger' style='position:absolute;'><div class='mCSB_dragger_bar' /></div><div class='mCSB_draggerRail' /></div></div>"],
|
||
wrapperClass=o.axis==="yx" ? "mCSB_vertical_horizontal" : o.axis==="x" ? "mCSB_horizontal" : "mCSB_vertical",
|
||
scrollbars=o.axis==="yx" ? scrollbar[0]+scrollbar[1] : o.axis==="x" ? scrollbar[1] : scrollbar[0],
|
||
contentWrapper=o.axis==="yx" ? "<div id='mCSB_"+d.idx+"_container_wrapper' class='mCSB_container_wrapper' />" : "",
|
||
autoHideClass=o.autoHideScrollbar ? " "+classes[6] : "",
|
||
scrollbarDirClass=(o.axis!=="x" && d.langDir==="rtl") ? " "+classes[7] : "";
|
||
if(o.setWidth){$this.css("width",o.setWidth);} /* set element width */
|
||
if(o.setHeight){$this.css("height",o.setHeight);} /* set element height */
|
||
o.setLeft=(o.axis!=="y" && d.langDir==="rtl") ? "989999px" : o.setLeft; /* adjust left position for rtl direction */
|
||
$this.addClass(pluginNS+" _"+pluginPfx+"_"+d.idx+autoHideClass+scrollbarDirClass).wrapInner("<div id='mCSB_"+d.idx+"' class='mCustomScrollBox mCS-"+o.theme+" "+wrapperClass+"'><div id='mCSB_"+d.idx+"_container' class='mCSB_container' style='position:relative; top:"+o.setTop+"; left:"+o.setLeft+";' dir='"+d.langDir+"' /></div>");
|
||
var mCustomScrollBox=$("#mCSB_"+d.idx),
|
||
mCSB_container=$("#mCSB_"+d.idx+"_container");
|
||
if(o.axis!=="y" && !o.advanced.autoExpandHorizontalScroll){
|
||
mCSB_container.css("width",_contentWidth(mCSB_container));
|
||
}
|
||
if(o.scrollbarPosition==="outside"){
|
||
if($this.css("position")==="static"){ /* requires elements with non-static position */
|
||
$this.css("position","relative");
|
||
}
|
||
$this.css("overflow","visible");
|
||
mCustomScrollBox.addClass("mCSB_outside").after(scrollbars);
|
||
}else{
|
||
mCustomScrollBox.addClass("mCSB_inside").append(scrollbars);
|
||
mCSB_container.wrap(contentWrapper);
|
||
}
|
||
_scrollButtons.call(this); /* add scrollbar buttons */
|
||
/* minimum dragger length */
|
||
var mCSB_dragger=[$("#mCSB_"+d.idx+"_dragger_vertical"),$("#mCSB_"+d.idx+"_dragger_horizontal")];
|
||
mCSB_dragger[0].css("min-height",mCSB_dragger[0].height());
|
||
mCSB_dragger[1].css("min-width",mCSB_dragger[1].width());
|
||
},
|
||
/* -------------------- */
|
||
|
||
|
||
/* calculates content width */
|
||
_contentWidth=function(el){
|
||
var val=[el[0].scrollWidth,Math.max.apply(Math,el.children().map(function(){return $(this).outerWidth(true);}).get())],w=el.parent().width();
|
||
return val[0]>w ? val[0] : val[1]>w ? val[1] : "100%";
|
||
},
|
||
/* -------------------- */
|
||
|
||
|
||
/* expands content horizontally */
|
||
_expandContentHorizontally=function(){
|
||
var $this=$(this),d=$this.data(pluginPfx),o=d.opt,
|
||
mCSB_container=$("#mCSB_"+d.idx+"_container");
|
||
if(o.advanced.autoExpandHorizontalScroll && o.axis!=="y"){
|
||
/* calculate scrollWidth */
|
||
mCSB_container.css({"width":"auto","min-width":0,"overflow-x":"scroll"});
|
||
var w=Math.ceil(mCSB_container[0].scrollWidth);
|
||
if(o.advanced.autoExpandHorizontalScroll===3 || (o.advanced.autoExpandHorizontalScroll!==2 && w>mCSB_container.parent().width())){
|
||
mCSB_container.css({"width":w,"min-width":"100%","overflow-x":"inherit"});
|
||
}else{
|
||
/*
|
||
wrap content with an infinite width div and set its position to absolute and width to auto.
|
||
Setting width to auto before calculating the actual width is important!
|
||
We must let the browser set the width as browser zoom values are impossible to calculate.
|
||
*/
|
||
mCSB_container.css({"overflow-x":"inherit","position":"absolute"})
|
||
.wrap("<div class='mCSB_h_wrapper' style='position:relative; left:0; width:999999px;' />")
|
||
.css({ /* set actual width, original position and un-wrap */
|
||
/*
|
||
get the exact width (with decimals) and then round-up.
|
||
Using jquery outerWidth() will round the width value which will mess up with inner elements that have non-integer width
|
||
*/
|
||
"width":(Math.ceil(mCSB_container[0].getBoundingClientRect().right+0.4)-Math.floor(mCSB_container[0].getBoundingClientRect().left)),
|
||
"min-width":"100%",
|
||
"position":"relative"
|
||
}).unwrap();
|
||
}
|
||
}
|
||
},
|
||
/* -------------------- */
|
||
|
||
|
||
/* adds scrollbar buttons */
|
||
_scrollButtons=function(){
|
||
var $this=$(this),d=$this.data(pluginPfx),o=d.opt,
|
||
mCSB_scrollTools=$(".mCSB_"+d.idx+"_scrollbar:first"),
|
||
tabindex=!_isNumeric(o.scrollButtons.tabindex) ? "" : "tabindex='"+o.scrollButtons.tabindex+"'",
|
||
btnHTML=[
|
||
"<a href='#' class='"+classes[13]+"' "+tabindex+" />",
|
||
"<a href='#' class='"+classes[14]+"' "+tabindex+" />",
|
||
"<a href='#' class='"+classes[15]+"' "+tabindex+" />",
|
||
"<a href='#' class='"+classes[16]+"' "+tabindex+" />"
|
||
],
|
||
btn=[(o.axis==="x" ? btnHTML[2] : btnHTML[0]),(o.axis==="x" ? btnHTML[3] : btnHTML[1]),btnHTML[2],btnHTML[3]];
|
||
if(o.scrollButtons.enable){
|
||
mCSB_scrollTools.prepend(btn[0]).append(btn[1]).next(".mCSB_scrollTools").prepend(btn[2]).append(btn[3]);
|
||
}
|
||
},
|
||
/* -------------------- */
|
||
|
||
|
||
/* auto-adjusts scrollbar dragger length */
|
||
_setDraggerLength=function(){
|
||
var $this=$(this),d=$this.data(pluginPfx),
|
||
mCustomScrollBox=$("#mCSB_"+d.idx),
|
||
mCSB_container=$("#mCSB_"+d.idx+"_container"),
|
||
mCSB_dragger=[$("#mCSB_"+d.idx+"_dragger_vertical"),$("#mCSB_"+d.idx+"_dragger_horizontal")],
|
||
ratio=[mCustomScrollBox.height()/mCSB_container.outerHeight(false),mCustomScrollBox.width()/mCSB_container.outerWidth(false)],
|
||
l=[
|
||
parseInt(mCS |