mirror of
https://git.coop/cotech/website.git
synced 2024-11-22 22:53:06 +00:00
19704 lines
703 KiB
JavaScript
19704 lines
703 KiB
JavaScript
/*!
|
|
* jQuery JavaScript Library v3.2.1
|
|
* https://jquery.com/
|
|
*
|
|
* Includes Sizzle.js
|
|
* https://sizzlejs.com/
|
|
*
|
|
* Copyright JS Foundation and other contributors
|
|
* Released under the MIT license
|
|
* https://jquery.org/license
|
|
*
|
|
* Date: 2017-03-20T18:59Z
|
|
*/
|
|
( function( global, factory ) {
|
|
|
|
"use strict";
|
|
|
|
if ( typeof module === "object" && typeof module.exports === "object" ) {
|
|
|
|
// For CommonJS and CommonJS-like environments where a proper `window`
|
|
// is present, execute the factory and get jQuery.
|
|
// For environments that do not have a `window` with a `document`
|
|
// (such as Node.js), expose a factory as module.exports.
|
|
// This accentuates the need for the creation of a real `window`.
|
|
// e.g. var jQuery = require("jquery")(window);
|
|
// See ticket #14549 for more info.
|
|
module.exports = global.document ?
|
|
factory( global, true ) :
|
|
function( w ) {
|
|
if ( !w.document ) {
|
|
throw new Error( "jQuery requires a window with a document" );
|
|
}
|
|
return factory( w );
|
|
};
|
|
} else {
|
|
factory( global );
|
|
}
|
|
|
|
// Pass this if window is not defined yet
|
|
} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
|
|
|
|
// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
|
|
// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
|
|
// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
|
|
// enough that all such attempts are guarded in a try block.
|
|
"use strict";
|
|
|
|
var arr = [];
|
|
|
|
var document = window.document;
|
|
|
|
var getProto = Object.getPrototypeOf;
|
|
|
|
var slice = arr.slice;
|
|
|
|
var concat = arr.concat;
|
|
|
|
var push = arr.push;
|
|
|
|
var indexOf = arr.indexOf;
|
|
|
|
var class2type = {};
|
|
|
|
var toString = class2type.toString;
|
|
|
|
var hasOwn = class2type.hasOwnProperty;
|
|
|
|
var fnToString = hasOwn.toString;
|
|
|
|
var ObjectFunctionString = fnToString.call( Object );
|
|
|
|
var support = {};
|
|
|
|
|
|
|
|
function DOMEval( code, doc ) {
|
|
doc = doc || document;
|
|
|
|
var script = doc.createElement( "script" );
|
|
|
|
script.text = code;
|
|
doc.head.appendChild( script ).parentNode.removeChild( script );
|
|
}
|
|
/* global Symbol */
|
|
// Defining this global in .eslintrc.json would create a danger of using the global
|
|
// unguarded in another place, it seems safer to define global only for this module
|
|
|
|
|
|
|
|
var
|
|
version = "3.2.1",
|
|
|
|
// Define a local copy of jQuery
|
|
jQuery = function( selector, context ) {
|
|
|
|
// The jQuery object is actually just the init constructor 'enhanced'
|
|
// Need init if jQuery is called (just allow error to be thrown if not included)
|
|
return new jQuery.fn.init( selector, context );
|
|
},
|
|
|
|
// Support: Android <=4.0 only
|
|
// Make sure we trim BOM and NBSP
|
|
rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
|
|
|
|
// Matches dashed string for camelizing
|
|
rmsPrefix = /^-ms-/,
|
|
rdashAlpha = /-([a-z])/g,
|
|
|
|
// Used by jQuery.camelCase as callback to replace()
|
|
fcamelCase = function( all, letter ) {
|
|
return letter.toUpperCase();
|
|
};
|
|
|
|
jQuery.fn = jQuery.prototype = {
|
|
|
|
// The current version of jQuery being used
|
|
jquery: version,
|
|
|
|
constructor: jQuery,
|
|
|
|
// The default length of a jQuery object is 0
|
|
length: 0,
|
|
|
|
toArray: function() {
|
|
return slice.call( this );
|
|
},
|
|
|
|
// Get the Nth element in the matched element set OR
|
|
// Get the whole matched element set as a clean array
|
|
get: function( num ) {
|
|
|
|
// Return all the elements in a clean array
|
|
if ( num == null ) {
|
|
return slice.call( this );
|
|
}
|
|
|
|
// Return just the one element from the set
|
|
return num < 0 ? this[ num + this.length ] : this[ num ];
|
|
},
|
|
|
|
// Take an array of elements and push it onto the stack
|
|
// (returning the new matched element set)
|
|
pushStack: function( elems ) {
|
|
|
|
// Build a new jQuery matched element set
|
|
var ret = jQuery.merge( this.constructor(), elems );
|
|
|
|
// Add the old object onto the stack (as a reference)
|
|
ret.prevObject = this;
|
|
|
|
// Return the newly-formed element set
|
|
return ret;
|
|
},
|
|
|
|
// Execute a callback for every element in the matched set.
|
|
each: function( callback ) {
|
|
return jQuery.each( this, callback );
|
|
},
|
|
|
|
map: function( callback ) {
|
|
return this.pushStack( jQuery.map( this, function( elem, i ) {
|
|
return callback.call( elem, i, elem );
|
|
} ) );
|
|
},
|
|
|
|
slice: function() {
|
|
return this.pushStack( slice.apply( this, arguments ) );
|
|
},
|
|
|
|
first: function() {
|
|
return this.eq( 0 );
|
|
},
|
|
|
|
last: function() {
|
|
return this.eq( -1 );
|
|
},
|
|
|
|
eq: function( i ) {
|
|
var len = this.length,
|
|
j = +i + ( i < 0 ? len : 0 );
|
|
return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
|
|
},
|
|
|
|
end: function() {
|
|
return this.prevObject || this.constructor();
|
|
},
|
|
|
|
// For internal use only.
|
|
// Behaves like an Array's method, not like a jQuery method.
|
|
push: push,
|
|
sort: arr.sort,
|
|
splice: arr.splice
|
|
};
|
|
|
|
jQuery.extend = jQuery.fn.extend = function() {
|
|
var options, name, src, copy, copyIsArray, clone,
|
|
target = arguments[ 0 ] || {},
|
|
i = 1,
|
|
length = arguments.length,
|
|
deep = false;
|
|
|
|
// Handle a deep copy situation
|
|
if ( typeof target === "boolean" ) {
|
|
deep = target;
|
|
|
|
// Skip the boolean and the target
|
|
target = arguments[ i ] || {};
|
|
i++;
|
|
}
|
|
|
|
// Handle case when target is a string or something (possible in deep copy)
|
|
if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
|
|
target = {};
|
|
}
|
|
|
|
// Extend jQuery itself if only one argument is passed
|
|
if ( i === length ) {
|
|
target = this;
|
|
i--;
|
|
}
|
|
|
|
for ( ; i < length; i++ ) {
|
|
|
|
// Only deal with non-null/undefined values
|
|
if ( ( options = arguments[ i ] ) != null ) {
|
|
|
|
// Extend the base object
|
|
for ( name in options ) {
|
|
src = target[ name ];
|
|
copy = options[ name ];
|
|
|
|
// Prevent never-ending loop
|
|
if ( target === copy ) {
|
|
continue;
|
|
}
|
|
|
|
// Recurse if we're merging plain objects or arrays
|
|
if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
|
|
( copyIsArray = Array.isArray( copy ) ) ) ) {
|
|
|
|
if ( copyIsArray ) {
|
|
copyIsArray = false;
|
|
clone = src && Array.isArray( src ) ? src : [];
|
|
|
|
} else {
|
|
clone = src && jQuery.isPlainObject( src ) ? src : {};
|
|
}
|
|
|
|
// Never move original objects, clone them
|
|
target[ name ] = jQuery.extend( deep, clone, copy );
|
|
|
|
// Don't bring in undefined values
|
|
} else if ( copy !== undefined ) {
|
|
target[ name ] = copy;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Return the modified object
|
|
return target;
|
|
};
|
|
|
|
jQuery.extend( {
|
|
|
|
// Unique for each copy of jQuery on the page
|
|
expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
|
|
|
|
// Assume jQuery is ready without the ready module
|
|
isReady: true,
|
|
|
|
error: function( msg ) {
|
|
throw new Error( msg );
|
|
},
|
|
|
|
noop: function() {},
|
|
|
|
isFunction: function( obj ) {
|
|
return jQuery.type( obj ) === "function";
|
|
},
|
|
|
|
isWindow: function( obj ) {
|
|
return obj != null && obj === obj.window;
|
|
},
|
|
|
|
isNumeric: function( obj ) {
|
|
|
|
// As of jQuery 3.0, isNumeric is limited to
|
|
// strings and numbers (primitives or objects)
|
|
// that can be coerced to finite numbers (gh-2662)
|
|
var type = jQuery.type( obj );
|
|
return ( type === "number" || type === "string" ) &&
|
|
|
|
// parseFloat NaNs numeric-cast false positives ("")
|
|
// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
|
|
// subtraction forces infinities to NaN
|
|
!isNaN( obj - parseFloat( obj ) );
|
|
},
|
|
|
|
isPlainObject: function( obj ) {
|
|
var proto, Ctor;
|
|
|
|
// Detect obvious negatives
|
|
// Use toString instead of jQuery.type to catch host objects
|
|
if ( !obj || toString.call( obj ) !== "[object Object]" ) {
|
|
return false;
|
|
}
|
|
|
|
proto = getProto( obj );
|
|
|
|
// Objects with no prototype (e.g., `Object.create( null )`) are plain
|
|
if ( !proto ) {
|
|
return true;
|
|
}
|
|
|
|
// Objects with prototype are plain iff they were constructed by a global Object function
|
|
Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
|
|
return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
|
|
},
|
|
|
|
isEmptyObject: function( obj ) {
|
|
|
|
/* eslint-disable no-unused-vars */
|
|
// See https://github.com/eslint/eslint/issues/6125
|
|
var name;
|
|
|
|
for ( name in obj ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
},
|
|
|
|
type: function( obj ) {
|
|
if ( obj == null ) {
|
|
return obj + "";
|
|
}
|
|
|
|
// Support: Android <=2.3 only (functionish RegExp)
|
|
return typeof obj === "object" || typeof obj === "function" ?
|
|
class2type[ toString.call( obj ) ] || "object" :
|
|
typeof obj;
|
|
},
|
|
|
|
// Evaluates a script in a global context
|
|
globalEval: function( code ) {
|
|
DOMEval( code );
|
|
},
|
|
|
|
// Convert dashed to camelCase; used by the css and data modules
|
|
// Support: IE <=9 - 11, Edge 12 - 13
|
|
// Microsoft forgot to hump their vendor prefix (#9572)
|
|
camelCase: function( string ) {
|
|
return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
|
|
},
|
|
|
|
each: function( obj, callback ) {
|
|
var length, i = 0;
|
|
|
|
if ( isArrayLike( obj ) ) {
|
|
length = obj.length;
|
|
for ( ; i < length; i++ ) {
|
|
if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
for ( i in obj ) {
|
|
if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
},
|
|
|
|
// Support: Android <=4.0 only
|
|
trim: function( text ) {
|
|
return text == null ?
|
|
"" :
|
|
( text + "" ).replace( rtrim, "" );
|
|
},
|
|
|
|
// results is for internal usage only
|
|
makeArray: function( arr, results ) {
|
|
var ret = results || [];
|
|
|
|
if ( arr != null ) {
|
|
if ( isArrayLike( Object( arr ) ) ) {
|
|
jQuery.merge( ret,
|
|
typeof arr === "string" ?
|
|
[ arr ] : arr
|
|
);
|
|
} else {
|
|
push.call( ret, arr );
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
},
|
|
|
|
inArray: function( elem, arr, i ) {
|
|
return arr == null ? -1 : indexOf.call( arr, elem, i );
|
|
},
|
|
|
|
// Support: Android <=4.0 only, PhantomJS 1 only
|
|
// push.apply(_, arraylike) throws on ancient WebKit
|
|
merge: function( first, second ) {
|
|
var len = +second.length,
|
|
j = 0,
|
|
i = first.length;
|
|
|
|
for ( ; j < len; j++ ) {
|
|
first[ i++ ] = second[ j ];
|
|
}
|
|
|
|
first.length = i;
|
|
|
|
return first;
|
|
},
|
|
|
|
grep: function( elems, callback, invert ) {
|
|
var callbackInverse,
|
|
matches = [],
|
|
i = 0,
|
|
length = elems.length,
|
|
callbackExpect = !invert;
|
|
|
|
// Go through the array, only saving the items
|
|
// that pass the validator function
|
|
for ( ; i < length; i++ ) {
|
|
callbackInverse = !callback( elems[ i ], i );
|
|
if ( callbackInverse !== callbackExpect ) {
|
|
matches.push( elems[ i ] );
|
|
}
|
|
}
|
|
|
|
return matches;
|
|
},
|
|
|
|
// arg is for internal usage only
|
|
map: function( elems, callback, arg ) {
|
|
var length, value,
|
|
i = 0,
|
|
ret = [];
|
|
|
|
// Go through the array, translating each of the items to their new values
|
|
if ( isArrayLike( elems ) ) {
|
|
length = elems.length;
|
|
for ( ; i < length; i++ ) {
|
|
value = callback( elems[ i ], i, arg );
|
|
|
|
if ( value != null ) {
|
|
ret.push( value );
|
|
}
|
|
}
|
|
|
|
// Go through every key on the object,
|
|
} else {
|
|
for ( i in elems ) {
|
|
value = callback( elems[ i ], i, arg );
|
|
|
|
if ( value != null ) {
|
|
ret.push( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Flatten any nested arrays
|
|
return concat.apply( [], ret );
|
|
},
|
|
|
|
// A global GUID counter for objects
|
|
guid: 1,
|
|
|
|
// Bind a function to a context, optionally partially applying any
|
|
// arguments.
|
|
proxy: function( fn, context ) {
|
|
var tmp, args, proxy;
|
|
|
|
if ( typeof context === "string" ) {
|
|
tmp = fn[ context ];
|
|
context = fn;
|
|
fn = tmp;
|
|
}
|
|
|
|
// Quick check to determine if target is callable, in the spec
|
|
// this throws a TypeError, but we will just return undefined.
|
|
if ( !jQuery.isFunction( fn ) ) {
|
|
return undefined;
|
|
}
|
|
|
|
// Simulated bind
|
|
args = slice.call( arguments, 2 );
|
|
proxy = function() {
|
|
return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
|
|
};
|
|
|
|
// Set the guid of unique handler to the same of original handler, so it can be removed
|
|
proxy.guid = fn.guid = fn.guid || jQuery.guid++;
|
|
|
|
return proxy;
|
|
},
|
|
|
|
now: Date.now,
|
|
|
|
// jQuery.support is not used in Core but other projects attach their
|
|
// properties to it so it needs to exist.
|
|
support: support
|
|
} );
|
|
|
|
if ( typeof Symbol === "function" ) {
|
|
jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
|
|
}
|
|
|
|
// Populate the class2type map
|
|
jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
|
|
function( i, name ) {
|
|
class2type[ "[object " + name + "]" ] = name.toLowerCase();
|
|
} );
|
|
|
|
function isArrayLike( obj ) {
|
|
|
|
// Support: real iOS 8.2 only (not reproducible in simulator)
|
|
// `in` check used to prevent JIT error (gh-2145)
|
|
// hasOwn isn't used here due to false negatives
|
|
// regarding Nodelist length in IE
|
|
var length = !!obj && "length" in obj && obj.length,
|
|
type = jQuery.type( obj );
|
|
|
|
if ( type === "function" || jQuery.isWindow( obj ) ) {
|
|
return false;
|
|
}
|
|
|
|
return type === "array" || length === 0 ||
|
|
typeof length === "number" && length > 0 && ( length - 1 ) in obj;
|
|
}
|
|
var Sizzle =
|
|
/*!
|
|
* Sizzle CSS Selector Engine v2.3.3
|
|
* https://sizzlejs.com/
|
|
*
|
|
* Copyright jQuery Foundation and other contributors
|
|
* Released under the MIT license
|
|
* http://jquery.org/license
|
|
*
|
|
* Date: 2016-08-08
|
|
*/
|
|
(function( window ) {
|
|
|
|
var i,
|
|
support,
|
|
Expr,
|
|
getText,
|
|
isXML,
|
|
tokenize,
|
|
compile,
|
|
select,
|
|
outermostContext,
|
|
sortInput,
|
|
hasDuplicate,
|
|
|
|
// Local document vars
|
|
setDocument,
|
|
document,
|
|
docElem,
|
|
documentIsHTML,
|
|
rbuggyQSA,
|
|
rbuggyMatches,
|
|
matches,
|
|
contains,
|
|
|
|
// Instance-specific data
|
|
expando = "sizzle" + 1 * new Date(),
|
|
preferredDoc = window.document,
|
|
dirruns = 0,
|
|
done = 0,
|
|
classCache = createCache(),
|
|
tokenCache = createCache(),
|
|
compilerCache = createCache(),
|
|
sortOrder = function( a, b ) {
|
|
if ( a === b ) {
|
|
hasDuplicate = true;
|
|
}
|
|
return 0;
|
|
},
|
|
|
|
// Instance methods
|
|
hasOwn = ({}).hasOwnProperty,
|
|
arr = [],
|
|
pop = arr.pop,
|
|
push_native = arr.push,
|
|
push = arr.push,
|
|
slice = arr.slice,
|
|
// Use a stripped-down indexOf as it's faster than native
|
|
// https://jsperf.com/thor-indexof-vs-for/5
|
|
indexOf = function( list, elem ) {
|
|
var i = 0,
|
|
len = list.length;
|
|
for ( ; i < len; i++ ) {
|
|
if ( list[i] === elem ) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
},
|
|
|
|
booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
|
|
|
|
// Regular expressions
|
|
|
|
// http://www.w3.org/TR/css3-selectors/#whitespace
|
|
whitespace = "[\\x20\\t\\r\\n\\f]",
|
|
|
|
// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
|
|
identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
|
|
|
|
// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
|
|
attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
|
|
// Operator (capture 2)
|
|
"*([*^$|!~]?=)" + whitespace +
|
|
// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
|
|
"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
|
|
"*\\]",
|
|
|
|
pseudos = ":(" + identifier + ")(?:\\((" +
|
|
// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
|
|
// 1. quoted (capture 3; capture 4 or capture 5)
|
|
"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
|
|
// 2. simple (capture 6)
|
|
"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
|
|
// 3. anything else (capture 2)
|
|
".*" +
|
|
")\\)|)",
|
|
|
|
// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
|
|
rwhitespace = new RegExp( whitespace + "+", "g" ),
|
|
rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
|
|
|
|
rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
|
|
rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
|
|
|
|
rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
|
|
|
|
rpseudo = new RegExp( pseudos ),
|
|
ridentifier = new RegExp( "^" + identifier + "$" ),
|
|
|
|
matchExpr = {
|
|
"ID": new RegExp( "^#(" + identifier + ")" ),
|
|
"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
|
|
"TAG": new RegExp( "^(" + identifier + "|[*])" ),
|
|
"ATTR": new RegExp( "^" + attributes ),
|
|
"PSEUDO": new RegExp( "^" + pseudos ),
|
|
"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
|
|
"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
|
|
"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
|
|
"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
|
|
// For use in libraries implementing .is()
|
|
// We use this for POS matching in `select`
|
|
"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
|
|
whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
|
|
},
|
|
|
|
rinputs = /^(?:input|select|textarea|button)$/i,
|
|
rheader = /^h\d$/i,
|
|
|
|
rnative = /^[^{]+\{\s*\[native \w/,
|
|
|
|
// Easily-parseable/retrievable ID or TAG or CLASS selectors
|
|
rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
|
|
|
|
rsibling = /[+~]/,
|
|
|
|
// CSS escapes
|
|
// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
|
|
runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
|
|
funescape = function( _, escaped, escapedWhitespace ) {
|
|
var high = "0x" + escaped - 0x10000;
|
|
// NaN means non-codepoint
|
|
// Support: Firefox<24
|
|
// Workaround erroneous numeric interpretation of +"0x"
|
|
return high !== high || escapedWhitespace ?
|
|
escaped :
|
|
high < 0 ?
|
|
// BMP codepoint
|
|
String.fromCharCode( high + 0x10000 ) :
|
|
// Supplemental Plane codepoint (surrogate pair)
|
|
String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
|
|
},
|
|
|
|
// CSS string/identifier serialization
|
|
// https://drafts.csswg.org/cssom/#common-serializing-idioms
|
|
rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
|
|
fcssescape = function( ch, asCodePoint ) {
|
|
if ( asCodePoint ) {
|
|
|
|
// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
|
|
if ( ch === "\0" ) {
|
|
return "\uFFFD";
|
|
}
|
|
|
|
// Control characters and (dependent upon position) numbers get escaped as code points
|
|
return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
|
|
}
|
|
|
|
// Other potentially-special ASCII characters get backslash-escaped
|
|
return "\\" + ch;
|
|
},
|
|
|
|
// Used for iframes
|
|
// See setDocument()
|
|
// Removing the function wrapper causes a "Permission Denied"
|
|
// error in IE
|
|
unloadHandler = function() {
|
|
setDocument();
|
|
},
|
|
|
|
disabledAncestor = addCombinator(
|
|
function( elem ) {
|
|
return elem.disabled === true && ("form" in elem || "label" in elem);
|
|
},
|
|
{ dir: "parentNode", next: "legend" }
|
|
);
|
|
|
|
// Optimize for push.apply( _, NodeList )
|
|
try {
|
|
push.apply(
|
|
(arr = slice.call( preferredDoc.childNodes )),
|
|
preferredDoc.childNodes
|
|
);
|
|
// Support: Android<4.0
|
|
// Detect silently failing push.apply
|
|
arr[ preferredDoc.childNodes.length ].nodeType;
|
|
} catch ( e ) {
|
|
push = { apply: arr.length ?
|
|
|
|
// Leverage slice if possible
|
|
function( target, els ) {
|
|
push_native.apply( target, slice.call(els) );
|
|
} :
|
|
|
|
// Support: IE<9
|
|
// Otherwise append directly
|
|
function( target, els ) {
|
|
var j = target.length,
|
|
i = 0;
|
|
// Can't trust NodeList.length
|
|
while ( (target[j++] = els[i++]) ) {}
|
|
target.length = j - 1;
|
|
}
|
|
};
|
|
}
|
|
|
|
function Sizzle( selector, context, results, seed ) {
|
|
var m, i, elem, nid, match, groups, newSelector,
|
|
newContext = context && context.ownerDocument,
|
|
|
|
// nodeType defaults to 9, since context defaults to document
|
|
nodeType = context ? context.nodeType : 9;
|
|
|
|
results = results || [];
|
|
|
|
// Return early from calls with invalid selector or context
|
|
if ( typeof selector !== "string" || !selector ||
|
|
nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
|
|
|
|
return results;
|
|
}
|
|
|
|
// Try to shortcut find operations (as opposed to filters) in HTML documents
|
|
if ( !seed ) {
|
|
|
|
if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
|
|
setDocument( context );
|
|
}
|
|
context = context || document;
|
|
|
|
if ( documentIsHTML ) {
|
|
|
|
// If the selector is sufficiently simple, try using a "get*By*" DOM method
|
|
// (excepting DocumentFragment context, where the methods don't exist)
|
|
if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
|
|
|
|
// ID selector
|
|
if ( (m = match[1]) ) {
|
|
|
|
// Document context
|
|
if ( nodeType === 9 ) {
|
|
if ( (elem = context.getElementById( m )) ) {
|
|
|
|
// Support: IE, Opera, Webkit
|
|
// TODO: identify versions
|
|
// getElementById can match elements by name instead of ID
|
|
if ( elem.id === m ) {
|
|
results.push( elem );
|
|
return results;
|
|
}
|
|
} else {
|
|
return results;
|
|
}
|
|
|
|
// Element context
|
|
} else {
|
|
|
|
// Support: IE, Opera, Webkit
|
|
// TODO: identify versions
|
|
// getElementById can match elements by name instead of ID
|
|
if ( newContext && (elem = newContext.getElementById( m )) &&
|
|
contains( context, elem ) &&
|
|
elem.id === m ) {
|
|
|
|
results.push( elem );
|
|
return results;
|
|
}
|
|
}
|
|
|
|
// Type selector
|
|
} else if ( match[2] ) {
|
|
push.apply( results, context.getElementsByTagName( selector ) );
|
|
return results;
|
|
|
|
// Class selector
|
|
} else if ( (m = match[3]) && support.getElementsByClassName &&
|
|
context.getElementsByClassName ) {
|
|
|
|
push.apply( results, context.getElementsByClassName( m ) );
|
|
return results;
|
|
}
|
|
}
|
|
|
|
// Take advantage of querySelectorAll
|
|
if ( support.qsa &&
|
|
!compilerCache[ selector + " " ] &&
|
|
(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
|
|
|
|
if ( nodeType !== 1 ) {
|
|
newContext = context;
|
|
newSelector = selector;
|
|
|
|
// qSA looks outside Element context, which is not what we want
|
|
// Thanks to Andrew Dupont for this workaround technique
|
|
// Support: IE <=8
|
|
// Exclude object elements
|
|
} else if ( context.nodeName.toLowerCase() !== "object" ) {
|
|
|
|
// Capture the context ID, setting it first if necessary
|
|
if ( (nid = context.getAttribute( "id" )) ) {
|
|
nid = nid.replace( rcssescape, fcssescape );
|
|
} else {
|
|
context.setAttribute( "id", (nid = expando) );
|
|
}
|
|
|
|
// Prefix every selector in the list
|
|
groups = tokenize( selector );
|
|
i = groups.length;
|
|
while ( i-- ) {
|
|
groups[i] = "#" + nid + " " + toSelector( groups[i] );
|
|
}
|
|
newSelector = groups.join( "," );
|
|
|
|
// Expand context for sibling selectors
|
|
newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
|
|
context;
|
|
}
|
|
|
|
if ( newSelector ) {
|
|
try {
|
|
push.apply( results,
|
|
newContext.querySelectorAll( newSelector )
|
|
);
|
|
return results;
|
|
} catch ( qsaError ) {
|
|
} finally {
|
|
if ( nid === expando ) {
|
|
context.removeAttribute( "id" );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// All others
|
|
return select( selector.replace( rtrim, "$1" ), context, results, seed );
|
|
}
|
|
|
|
/**
|
|
* Create key-value caches of limited size
|
|
* @returns {function(string, object)} Returns the Object data after storing it on itself with
|
|
* property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
|
|
* deleting the oldest entry
|
|
*/
|
|
function createCache() {
|
|
var keys = [];
|
|
|
|
function cache( key, value ) {
|
|
// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
|
|
if ( keys.push( key + " " ) > Expr.cacheLength ) {
|
|
// Only keep the most recent entries
|
|
delete cache[ keys.shift() ];
|
|
}
|
|
return (cache[ key + " " ] = value);
|
|
}
|
|
return cache;
|
|
}
|
|
|
|
/**
|
|
* Mark a function for special use by Sizzle
|
|
* @param {Function} fn The function to mark
|
|
*/
|
|
function markFunction( fn ) {
|
|
fn[ expando ] = true;
|
|
return fn;
|
|
}
|
|
|
|
/**
|
|
* Support testing using an element
|
|
* @param {Function} fn Passed the created element and returns a boolean result
|
|
*/
|
|
function assert( fn ) {
|
|
var el = document.createElement("fieldset");
|
|
|
|
try {
|
|
return !!fn( el );
|
|
} catch (e) {
|
|
return false;
|
|
} finally {
|
|
// Remove from its parent by default
|
|
if ( el.parentNode ) {
|
|
el.parentNode.removeChild( el );
|
|
}
|
|
// release memory in IE
|
|
el = null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the same handler for all of the specified attrs
|
|
* @param {String} attrs Pipe-separated list of attributes
|
|
* @param {Function} handler The method that will be applied
|
|
*/
|
|
function addHandle( attrs, handler ) {
|
|
var arr = attrs.split("|"),
|
|
i = arr.length;
|
|
|
|
while ( i-- ) {
|
|
Expr.attrHandle[ arr[i] ] = handler;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks document order of two siblings
|
|
* @param {Element} a
|
|
* @param {Element} b
|
|
* @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
|
|
*/
|
|
function siblingCheck( a, b ) {
|
|
var cur = b && a,
|
|
diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
|
|
a.sourceIndex - b.sourceIndex;
|
|
|
|
// Use IE sourceIndex if available on both nodes
|
|
if ( diff ) {
|
|
return diff;
|
|
}
|
|
|
|
// Check if b follows a
|
|
if ( cur ) {
|
|
while ( (cur = cur.nextSibling) ) {
|
|
if ( cur === b ) {
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return a ? 1 : -1;
|
|
}
|
|
|
|
/**
|
|
* Returns a function to use in pseudos for input types
|
|
* @param {String} type
|
|
*/
|
|
function createInputPseudo( type ) {
|
|
return function( elem ) {
|
|
var name = elem.nodeName.toLowerCase();
|
|
return name === "input" && elem.type === type;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Returns a function to use in pseudos for buttons
|
|
* @param {String} type
|
|
*/
|
|
function createButtonPseudo( type ) {
|
|
return function( elem ) {
|
|
var name = elem.nodeName.toLowerCase();
|
|
return (name === "input" || name === "button") && elem.type === type;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Returns a function to use in pseudos for :enabled/:disabled
|
|
* @param {Boolean} disabled true for :disabled; false for :enabled
|
|
*/
|
|
function createDisabledPseudo( disabled ) {
|
|
|
|
// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
|
|
return function( elem ) {
|
|
|
|
// Only certain elements can match :enabled or :disabled
|
|
// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
|
|
// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
|
|
if ( "form" in elem ) {
|
|
|
|
// Check for inherited disabledness on relevant non-disabled elements:
|
|
// * listed form-associated elements in a disabled fieldset
|
|
// https://html.spec.whatwg.org/multipage/forms.html#category-listed
|
|
// https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
|
|
// * option elements in a disabled optgroup
|
|
// https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
|
|
// All such elements have a "form" property.
|
|
if ( elem.parentNode && elem.disabled === false ) {
|
|
|
|
// Option elements defer to a parent optgroup if present
|
|
if ( "label" in elem ) {
|
|
if ( "label" in elem.parentNode ) {
|
|
return elem.parentNode.disabled === disabled;
|
|
} else {
|
|
return elem.disabled === disabled;
|
|
}
|
|
}
|
|
|
|
// Support: IE 6 - 11
|
|
// Use the isDisabled shortcut property to check for disabled fieldset ancestors
|
|
return elem.isDisabled === disabled ||
|
|
|
|
// Where there is no isDisabled, check manually
|
|
/* jshint -W018 */
|
|
elem.isDisabled !== !disabled &&
|
|
disabledAncestor( elem ) === disabled;
|
|
}
|
|
|
|
return elem.disabled === disabled;
|
|
|
|
// Try to winnow out elements that can't be disabled before trusting the disabled property.
|
|
// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
|
|
// even exist on them, let alone have a boolean value.
|
|
} else if ( "label" in elem ) {
|
|
return elem.disabled === disabled;
|
|
}
|
|
|
|
// Remaining elements are neither :enabled nor :disabled
|
|
return false;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Returns a function to use in pseudos for positionals
|
|
* @param {Function} fn
|
|
*/
|
|
function createPositionalPseudo( fn ) {
|
|
return markFunction(function( argument ) {
|
|
argument = +argument;
|
|
return markFunction(function( seed, matches ) {
|
|
var j,
|
|
matchIndexes = fn( [], seed.length, argument ),
|
|
i = matchIndexes.length;
|
|
|
|
// Match elements found at the specified indexes
|
|
while ( i-- ) {
|
|
if ( seed[ (j = matchIndexes[i]) ] ) {
|
|
seed[j] = !(matches[j] = seed[j]);
|
|
}
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Checks a node for validity as a Sizzle context
|
|
* @param {Element|Object=} context
|
|
* @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
|
|
*/
|
|
function testContext( context ) {
|
|
return context && typeof context.getElementsByTagName !== "undefined" && context;
|
|
}
|
|
|
|
// Expose support vars for convenience
|
|
support = Sizzle.support = {};
|
|
|
|
/**
|
|
* Detects XML nodes
|
|
* @param {Element|Object} elem An element or a document
|
|
* @returns {Boolean} True iff elem is a non-HTML XML node
|
|
*/
|
|
isXML = Sizzle.isXML = function( elem ) {
|
|
// documentElement is verified for cases where it doesn't yet exist
|
|
// (such as loading iframes in IE - #4833)
|
|
var documentElement = elem && (elem.ownerDocument || elem).documentElement;
|
|
return documentElement ? documentElement.nodeName !== "HTML" : false;
|
|
};
|
|
|
|
/**
|
|
* Sets document-related variables once based on the current document
|
|
* @param {Element|Object} [doc] An element or document object to use to set the document
|
|
* @returns {Object} Returns the current document
|
|
*/
|
|
setDocument = Sizzle.setDocument = function( node ) {
|
|
var hasCompare, subWindow,
|
|
doc = node ? node.ownerDocument || node : preferredDoc;
|
|
|
|
// Return early if doc is invalid or already selected
|
|
if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
|
|
return document;
|
|
}
|
|
|
|
// Update global variables
|
|
document = doc;
|
|
docElem = document.documentElement;
|
|
documentIsHTML = !isXML( document );
|
|
|
|
// Support: IE 9-11, Edge
|
|
// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
|
|
if ( preferredDoc !== document &&
|
|
(subWindow = document.defaultView) && subWindow.top !== subWindow ) {
|
|
|
|
// Support: IE 11, Edge
|
|
if ( subWindow.addEventListener ) {
|
|
subWindow.addEventListener( "unload", unloadHandler, false );
|
|
|
|
// Support: IE 9 - 10 only
|
|
} else if ( subWindow.attachEvent ) {
|
|
subWindow.attachEvent( "onunload", unloadHandler );
|
|
}
|
|
}
|
|
|
|
/* Attributes
|
|
---------------------------------------------------------------------- */
|
|
|
|
// Support: IE<8
|
|
// Verify that getAttribute really returns attributes and not properties
|
|
// (excepting IE8 booleans)
|
|
support.attributes = assert(function( el ) {
|
|
el.className = "i";
|
|
return !el.getAttribute("className");
|
|
});
|
|
|
|
/* getElement(s)By*
|
|
---------------------------------------------------------------------- */
|
|
|
|
// Check if getElementsByTagName("*") returns only elements
|
|
support.getElementsByTagName = assert(function( el ) {
|
|
el.appendChild( document.createComment("") );
|
|
return !el.getElementsByTagName("*").length;
|
|
});
|
|
|
|
// Support: IE<9
|
|
support.getElementsByClassName = rnative.test( document.getElementsByClassName );
|
|
|
|
// Support: IE<10
|
|
// Check if getElementById returns elements by name
|
|
// The broken getElementById methods don't pick up programmatically-set names,
|
|
// so use a roundabout getElementsByName test
|
|
support.getById = assert(function( el ) {
|
|
docElem.appendChild( el ).id = expando;
|
|
return !document.getElementsByName || !document.getElementsByName( expando ).length;
|
|
});
|
|
|
|
// ID filter and find
|
|
if ( support.getById ) {
|
|
Expr.filter["ID"] = function( id ) {
|
|
var attrId = id.replace( runescape, funescape );
|
|
return function( elem ) {
|
|
return elem.getAttribute("id") === attrId;
|
|
};
|
|
};
|
|
Expr.find["ID"] = function( id, context ) {
|
|
if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
|
|
var elem = context.getElementById( id );
|
|
return elem ? [ elem ] : [];
|
|
}
|
|
};
|
|
} else {
|
|
Expr.filter["ID"] = function( id ) {
|
|
var attrId = id.replace( runescape, funescape );
|
|
return function( elem ) {
|
|
var node = typeof elem.getAttributeNode !== "undefined" &&
|
|
elem.getAttributeNode("id");
|
|
return node && node.value === attrId;
|
|
};
|
|
};
|
|
|
|
// Support: IE 6 - 7 only
|
|
// getElementById is not reliable as a find shortcut
|
|
Expr.find["ID"] = function( id, context ) {
|
|
if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
|
|
var node, i, elems,
|
|
elem = context.getElementById( id );
|
|
|
|
if ( elem ) {
|
|
|
|
// Verify the id attribute
|
|
node = elem.getAttributeNode("id");
|
|
if ( node && node.value === id ) {
|
|
return [ elem ];
|
|
}
|
|
|
|
// Fall back on getElementsByName
|
|
elems = context.getElementsByName( id );
|
|
i = 0;
|
|
while ( (elem = elems[i++]) ) {
|
|
node = elem.getAttributeNode("id");
|
|
if ( node && node.value === id ) {
|
|
return [ elem ];
|
|
}
|
|
}
|
|
}
|
|
|
|
return [];
|
|
}
|
|
};
|
|
}
|
|
|
|
// Tag
|
|
Expr.find["TAG"] = support.getElementsByTagName ?
|
|
function( tag, context ) {
|
|
if ( typeof context.getElementsByTagName !== "undefined" ) {
|
|
return context.getElementsByTagName( tag );
|
|
|
|
// DocumentFragment nodes don't have gEBTN
|
|
} else if ( support.qsa ) {
|
|
return context.querySelectorAll( tag );
|
|
}
|
|
} :
|
|
|
|
function( tag, context ) {
|
|
var elem,
|
|
tmp = [],
|
|
i = 0,
|
|
// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
|
|
results = context.getElementsByTagName( tag );
|
|
|
|
// Filter out possible comments
|
|
if ( tag === "*" ) {
|
|
while ( (elem = results[i++]) ) {
|
|
if ( elem.nodeType === 1 ) {
|
|
tmp.push( elem );
|
|
}
|
|
}
|
|
|
|
return tmp;
|
|
}
|
|
return results;
|
|
};
|
|
|
|
// Class
|
|
Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
|
|
if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
|
|
return context.getElementsByClassName( className );
|
|
}
|
|
};
|
|
|
|
/* QSA/matchesSelector
|
|
---------------------------------------------------------------------- */
|
|
|
|
// QSA and matchesSelector support
|
|
|
|
// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
|
|
rbuggyMatches = [];
|
|
|
|
// qSa(:focus) reports false when true (Chrome 21)
|
|
// We allow this because of a bug in IE8/9 that throws an error
|
|
// whenever `document.activeElement` is accessed on an iframe
|
|
// So, we allow :focus to pass through QSA all the time to avoid the IE error
|
|
// See https://bugs.jquery.com/ticket/13378
|
|
rbuggyQSA = [];
|
|
|
|
if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
|
|
// Build QSA regex
|
|
// Regex strategy adopted from Diego Perini
|
|
assert(function( el ) {
|
|
// Select is set to empty string on purpose
|
|
// This is to test IE's treatment of not explicitly
|
|
// setting a boolean content attribute,
|
|
// since its presence should be enough
|
|
// https://bugs.jquery.com/ticket/12359
|
|
docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
|
|
"<select id='" + expando + "-\r\\' msallowcapture=''>" +
|
|
"<option selected=''></option></select>";
|
|
|
|
// Support: IE8, Opera 11-12.16
|
|
// Nothing should be selected when empty strings follow ^= or $= or *=
|
|
// The test attribute must be unknown in Opera but "safe" for WinRT
|
|
// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
|
|
if ( el.querySelectorAll("[msallowcapture^='']").length ) {
|
|
rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
|
|
}
|
|
|
|
// Support: IE8
|
|
// Boolean attributes and "value" are not treated correctly
|
|
if ( !el.querySelectorAll("[selected]").length ) {
|
|
rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
|
|
}
|
|
|
|
// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
|
|
if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
|
|
rbuggyQSA.push("~=");
|
|
}
|
|
|
|
// Webkit/Opera - :checked should return selected option elements
|
|
// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
|
|
// IE8 throws error here and will not see later tests
|
|
if ( !el.querySelectorAll(":checked").length ) {
|
|
rbuggyQSA.push(":checked");
|
|
}
|
|
|
|
// Support: Safari 8+, iOS 8+
|
|
// https://bugs.webkit.org/show_bug.cgi?id=136851
|
|
// In-page `selector#id sibling-combinator selector` fails
|
|
if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
|
|
rbuggyQSA.push(".#.+[+~]");
|
|
}
|
|
});
|
|
|
|
assert(function( el ) {
|
|
el.innerHTML = "<a href='' disabled='disabled'></a>" +
|
|
"<select disabled='disabled'><option/></select>";
|
|
|
|
// Support: Windows 8 Native Apps
|
|
// The type and name attributes are restricted during .innerHTML assignment
|
|
var input = document.createElement("input");
|
|
input.setAttribute( "type", "hidden" );
|
|
el.appendChild( input ).setAttribute( "name", "D" );
|
|
|
|
// Support: IE8
|
|
// Enforce case-sensitivity of name attribute
|
|
if ( el.querySelectorAll("[name=d]").length ) {
|
|
rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
|
|
}
|
|
|
|
// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
|
|
// IE8 throws error here and will not see later tests
|
|
if ( el.querySelectorAll(":enabled").length !== 2 ) {
|
|
rbuggyQSA.push( ":enabled", ":disabled" );
|
|
}
|
|
|
|
// Support: IE9-11+
|
|
// IE's :disabled selector does not pick up the children of disabled fieldsets
|
|
docElem.appendChild( el ).disabled = true;
|
|
if ( el.querySelectorAll(":disabled").length !== 2 ) {
|
|
rbuggyQSA.push( ":enabled", ":disabled" );
|
|
}
|
|
|
|
// Opera 10-11 does not throw on post-comma invalid pseudos
|
|
el.querySelectorAll("*,:x");
|
|
rbuggyQSA.push(",.*:");
|
|
});
|
|
}
|
|
|
|
if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
|
|
docElem.webkitMatchesSelector ||
|
|
docElem.mozMatchesSelector ||
|
|
docElem.oMatchesSelector ||
|
|
docElem.msMatchesSelector) )) ) {
|
|
|
|
assert(function( el ) {
|
|
// Check to see if it's possible to do matchesSelector
|
|
// on a disconnected node (IE 9)
|
|
support.disconnectedMatch = matches.call( el, "*" );
|
|
|
|
// This should fail with an exception
|
|
// Gecko does not error, returns false instead
|
|
matches.call( el, "[s!='']:x" );
|
|
rbuggyMatches.push( "!=", pseudos );
|
|
});
|
|
}
|
|
|
|
rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
|
|
rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
|
|
|
|
/* Contains
|
|
---------------------------------------------------------------------- */
|
|
hasCompare = rnative.test( docElem.compareDocumentPosition );
|
|
|
|
// Element contains another
|
|
// Purposefully self-exclusive
|
|
// As in, an element does not contain itself
|
|
contains = hasCompare || rnative.test( docElem.contains ) ?
|
|
function( a, b ) {
|
|
var adown = a.nodeType === 9 ? a.documentElement : a,
|
|
bup = b && b.parentNode;
|
|
return a === bup || !!( bup && bup.nodeType === 1 && (
|
|
adown.contains ?
|
|
adown.contains( bup ) :
|
|
a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
|
|
));
|
|
} :
|
|
function( a, b ) {
|
|
if ( b ) {
|
|
while ( (b = b.parentNode) ) {
|
|
if ( b === a ) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
/* Sorting
|
|
---------------------------------------------------------------------- */
|
|
|
|
// Document order sorting
|
|
sortOrder = hasCompare ?
|
|
function( a, b ) {
|
|
|
|
// Flag for duplicate removal
|
|
if ( a === b ) {
|
|
hasDuplicate = true;
|
|
return 0;
|
|
}
|
|
|
|
// Sort on method existence if only one input has compareDocumentPosition
|
|
var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
|
|
if ( compare ) {
|
|
return compare;
|
|
}
|
|
|
|
// Calculate position if both inputs belong to the same document
|
|
compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
|
|
a.compareDocumentPosition( b ) :
|
|
|
|
// Otherwise we know they are disconnected
|
|
1;
|
|
|
|
// Disconnected nodes
|
|
if ( compare & 1 ||
|
|
(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
|
|
|
|
// Choose the first element that is related to our preferred document
|
|
if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
|
|
return -1;
|
|
}
|
|
if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
|
|
return 1;
|
|
}
|
|
|
|
// Maintain original order
|
|
return sortInput ?
|
|
( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
|
|
0;
|
|
}
|
|
|
|
return compare & 4 ? -1 : 1;
|
|
} :
|
|
function( a, b ) {
|
|
// Exit early if the nodes are identical
|
|
if ( a === b ) {
|
|
hasDuplicate = true;
|
|
return 0;
|
|
}
|
|
|
|
var cur,
|
|
i = 0,
|
|
aup = a.parentNode,
|
|
bup = b.parentNode,
|
|
ap = [ a ],
|
|
bp = [ b ];
|
|
|
|
// Parentless nodes are either documents or disconnected
|
|
if ( !aup || !bup ) {
|
|
return a === document ? -1 :
|
|
b === document ? 1 :
|
|
aup ? -1 :
|
|
bup ? 1 :
|
|
sortInput ?
|
|
( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
|
|
0;
|
|
|
|
// If the nodes are siblings, we can do a quick check
|
|
} else if ( aup === bup ) {
|
|
return siblingCheck( a, b );
|
|
}
|
|
|
|
// Otherwise we need full lists of their ancestors for comparison
|
|
cur = a;
|
|
while ( (cur = cur.parentNode) ) {
|
|
ap.unshift( cur );
|
|
}
|
|
cur = b;
|
|
while ( (cur = cur.parentNode) ) {
|
|
bp.unshift( cur );
|
|
}
|
|
|
|
// Walk down the tree looking for a discrepancy
|
|
while ( ap[i] === bp[i] ) {
|
|
i++;
|
|
}
|
|
|
|
return i ?
|
|
// Do a sibling check if the nodes have a common ancestor
|
|
siblingCheck( ap[i], bp[i] ) :
|
|
|
|
// Otherwise nodes in our document sort first
|
|
ap[i] === preferredDoc ? -1 :
|
|
bp[i] === preferredDoc ? 1 :
|
|
0;
|
|
};
|
|
|
|
return document;
|
|
};
|
|
|
|
Sizzle.matches = function( expr, elements ) {
|
|
return Sizzle( expr, null, null, elements );
|
|
};
|
|
|
|
Sizzle.matchesSelector = function( elem, expr ) {
|
|
// Set document vars if needed
|
|
if ( ( elem.ownerDocument || elem ) !== document ) {
|
|
setDocument( elem );
|
|
}
|
|
|
|
// Make sure that attribute selectors are quoted
|
|
expr = expr.replace( rattributeQuotes, "='$1']" );
|
|
|
|
if ( support.matchesSelector && documentIsHTML &&
|
|
!compilerCache[ expr + " " ] &&
|
|
( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
|
|
( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {
|
|
|
|
try {
|
|
var ret = matches.call( elem, expr );
|
|
|
|
// IE 9's matchesSelector returns false on disconnected nodes
|
|
if ( ret || support.disconnectedMatch ||
|
|
// As well, disconnected nodes are said to be in a document
|
|
// fragment in IE 9
|
|
elem.document && elem.document.nodeType !== 11 ) {
|
|
return ret;
|
|
}
|
|
} catch (e) {}
|
|
}
|
|
|
|
return Sizzle( expr, document, null, [ elem ] ).length > 0;
|
|
};
|
|
|
|
Sizzle.contains = function( context, elem ) {
|
|
// Set document vars if needed
|
|
if ( ( context.ownerDocument || context ) !== document ) {
|
|
setDocument( context );
|
|
}
|
|
return contains( context, elem );
|
|
};
|
|
|
|
Sizzle.attr = function( elem, name ) {
|
|
// Set document vars if needed
|
|
if ( ( elem.ownerDocument || elem ) !== document ) {
|
|
setDocument( elem );
|
|
}
|
|
|
|
var fn = Expr.attrHandle[ name.toLowerCase() ],
|
|
// Don't get fooled by Object.prototype properties (jQuery #13807)
|
|
val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
|
|
fn( elem, name, !documentIsHTML ) :
|
|
undefined;
|
|
|
|
return val !== undefined ?
|
|
val :
|
|
support.attributes || !documentIsHTML ?
|
|
elem.getAttribute( name ) :
|
|
(val = elem.getAttributeNode(name)) && val.specified ?
|
|
val.value :
|
|
null;
|
|
};
|
|
|
|
Sizzle.escape = function( sel ) {
|
|
return (sel + "").replace( rcssescape, fcssescape );
|
|
};
|
|
|
|
Sizzle.error = function( msg ) {
|
|
throw new Error( "Syntax error, unrecognized expression: " + msg );
|
|
};
|
|
|
|
/**
|
|
* Document sorting and removing duplicates
|
|
* @param {ArrayLike} results
|
|
*/
|
|
Sizzle.uniqueSort = function( results ) {
|
|
var elem,
|
|
duplicates = [],
|
|
j = 0,
|
|
i = 0;
|
|
|
|
// Unless we *know* we can detect duplicates, assume their presence
|
|
hasDuplicate = !support.detectDuplicates;
|
|
sortInput = !support.sortStable && results.slice( 0 );
|
|
results.sort( sortOrder );
|
|
|
|
if ( hasDuplicate ) {
|
|
while ( (elem = results[i++]) ) {
|
|
if ( elem === results[ i ] ) {
|
|
j = duplicates.push( i );
|
|
}
|
|
}
|
|
while ( j-- ) {
|
|
results.splice( duplicates[ j ], 1 );
|
|
}
|
|
}
|
|
|
|
// Clear input after sorting to release objects
|
|
// See https://github.com/jquery/sizzle/pull/225
|
|
sortInput = null;
|
|
|
|
return results;
|
|
};
|
|
|
|
/**
|
|
* Utility function for retrieving the text value of an array of DOM nodes
|
|
* @param {Array|Element} elem
|
|
*/
|
|
getText = Sizzle.getText = function( elem ) {
|
|
var node,
|
|
ret = "",
|
|
i = 0,
|
|
nodeType = elem.nodeType;
|
|
|
|
if ( !nodeType ) {
|
|
// If no nodeType, this is expected to be an array
|
|
while ( (node = elem[i++]) ) {
|
|
// Do not traverse comment nodes
|
|
ret += getText( node );
|
|
}
|
|
} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
|
|
// Use textContent for elements
|
|
// innerText usage removed for consistency of new lines (jQuery #11153)
|
|
if ( typeof elem.textContent === "string" ) {
|
|
return elem.textContent;
|
|
} else {
|
|
// Traverse its children
|
|
for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
|
|
ret += getText( elem );
|
|
}
|
|
}
|
|
} else if ( nodeType === 3 || nodeType === 4 ) {
|
|
return elem.nodeValue;
|
|
}
|
|
// Do not include comment or processing instruction nodes
|
|
|
|
return ret;
|
|
};
|
|
|
|
Expr = Sizzle.selectors = {
|
|
|
|
// Can be adjusted by the user
|
|
cacheLength: 50,
|
|
|
|
createPseudo: markFunction,
|
|
|
|
match: matchExpr,
|
|
|
|
attrHandle: {},
|
|
|
|
find: {},
|
|
|
|
relative: {
|
|
">": { dir: "parentNode", first: true },
|
|
" ": { dir: "parentNode" },
|
|
"+": { dir: "previousSibling", first: true },
|
|
"~": { dir: "previousSibling" }
|
|
},
|
|
|
|
preFilter: {
|
|
"ATTR": function( match ) {
|
|
match[1] = match[1].replace( runescape, funescape );
|
|
|
|
// Move the given value to match[3] whether quoted or unquoted
|
|
match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
|
|
|
|
if ( match[2] === "~=" ) {
|
|
match[3] = " " + match[3] + " ";
|
|
}
|
|
|
|
return match.slice( 0, 4 );
|
|
},
|
|
|
|
"CHILD": function( match ) {
|
|
/* matches from matchExpr["CHILD"]
|
|
1 type (only|nth|...)
|
|
2 what (child|of-type)
|
|
3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
|
|
4 xn-component of xn+y argument ([+-]?\d*n|)
|
|
5 sign of xn-component
|
|
6 x of xn-component
|
|
7 sign of y-component
|
|
8 y of y-component
|
|
*/
|
|
match[1] = match[1].toLowerCase();
|
|
|
|
if ( match[1].slice( 0, 3 ) === "nth" ) {
|
|
// nth-* requires argument
|
|
if ( !match[3] ) {
|
|
Sizzle.error( match[0] );
|
|
}
|
|
|
|
// numeric x and y parameters for Expr.filter.CHILD
|
|
// remember that false/true cast respectively to 0/1
|
|
match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
|
|
match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
|
|
|
|
// other types prohibit arguments
|
|
} else if ( match[3] ) {
|
|
Sizzle.error( match[0] );
|
|
}
|
|
|
|
return match;
|
|
},
|
|
|
|
"PSEUDO": function( match ) {
|
|
var excess,
|
|
unquoted = !match[6] && match[2];
|
|
|
|
if ( matchExpr["CHILD"].test( match[0] ) ) {
|
|
return null;
|
|
}
|
|
|
|
// Accept quoted arguments as-is
|
|
if ( match[3] ) {
|
|
match[2] = match[4] || match[5] || "";
|
|
|
|
// Strip excess characters from unquoted arguments
|
|
} else if ( unquoted && rpseudo.test( unquoted ) &&
|
|
// Get excess from tokenize (recursively)
|
|
(excess = tokenize( unquoted, true )) &&
|
|
// advance to the next closing parenthesis
|
|
(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
|
|
|
|
// excess is a negative index
|
|
match[0] = match[0].slice( 0, excess );
|
|
match[2] = unquoted.slice( 0, excess );
|
|
}
|
|
|
|
// Return only captures needed by the pseudo filter method (type and argument)
|
|
return match.slice( 0, 3 );
|
|
}
|
|
},
|
|
|
|
filter: {
|
|
|
|
"TAG": function( nodeNameSelector ) {
|
|
var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
|
|
return nodeNameSelector === "*" ?
|
|
function() { return true; } :
|
|
function( elem ) {
|
|
return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
|
|
};
|
|
},
|
|
|
|
"CLASS": function( className ) {
|
|
var pattern = classCache[ className + " " ];
|
|
|
|
return pattern ||
|
|
(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
|
|
classCache( className, function( elem ) {
|
|
return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
|
|
});
|
|
},
|
|
|
|
"ATTR": function( name, operator, check ) {
|
|
return function( elem ) {
|
|
var result = Sizzle.attr( elem, name );
|
|
|
|
if ( result == null ) {
|
|
return operator === "!=";
|
|
}
|
|
if ( !operator ) {
|
|
return true;
|
|
}
|
|
|
|
result += "";
|
|
|
|
return operator === "=" ? result === check :
|
|
operator === "!=" ? result !== check :
|
|
operator === "^=" ? check && result.indexOf( check ) === 0 :
|
|
operator === "*=" ? check && result.indexOf( check ) > -1 :
|
|
operator === "$=" ? check && result.slice( -check.length ) === check :
|
|
operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
|
|
operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
|
|
false;
|
|
};
|
|
},
|
|
|
|
"CHILD": function( type, what, argument, first, last ) {
|
|
var simple = type.slice( 0, 3 ) !== "nth",
|
|
forward = type.slice( -4 ) !== "last",
|
|
ofType = what === "of-type";
|
|
|
|
return first === 1 && last === 0 ?
|
|
|
|
// Shortcut for :nth-*(n)
|
|
function( elem ) {
|
|
return !!elem.parentNode;
|
|
} :
|
|
|
|
function( elem, context, xml ) {
|
|
var cache, uniqueCache, outerCache, node, nodeIndex, start,
|
|
dir = simple !== forward ? "nextSibling" : "previousSibling",
|
|
parent = elem.parentNode,
|
|
name = ofType && elem.nodeName.toLowerCase(),
|
|
useCache = !xml && !ofType,
|
|
diff = false;
|
|
|
|
if ( parent ) {
|
|
|
|
// :(first|last|only)-(child|of-type)
|
|
if ( simple ) {
|
|
while ( dir ) {
|
|
node = elem;
|
|
while ( (node = node[ dir ]) ) {
|
|
if ( ofType ?
|
|
node.nodeName.toLowerCase() === name :
|
|
node.nodeType === 1 ) {
|
|
|
|
return false;
|
|
}
|
|
}
|
|
// Reverse direction for :only-* (if we haven't yet done so)
|
|
start = dir = type === "only" && !start && "nextSibling";
|
|
}
|
|
return true;
|
|
}
|
|
|
|
start = [ forward ? parent.firstChild : parent.lastChild ];
|
|
|
|
// non-xml :nth-child(...) stores cache data on `parent`
|
|
if ( forward && useCache ) {
|
|
|
|
// Seek `elem` from a previously-cached index
|
|
|
|
// ...in a gzip-friendly way
|
|
node = parent;
|
|
outerCache = node[ expando ] || (node[ expando ] = {});
|
|
|
|
// Support: IE <9 only
|
|
// Defend against cloned attroperties (jQuery gh-1709)
|
|
uniqueCache = outerCache[ node.uniqueID ] ||
|
|
(outerCache[ node.uniqueID ] = {});
|
|
|
|
cache = uniqueCache[ type ] || [];
|
|
nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
|
|
diff = nodeIndex && cache[ 2 ];
|
|
node = nodeIndex && parent.childNodes[ nodeIndex ];
|
|
|
|
while ( (node = ++nodeIndex && node && node[ dir ] ||
|
|
|
|
// Fallback to seeking `elem` from the start
|
|
(diff = nodeIndex = 0) || start.pop()) ) {
|
|
|
|
// When found, cache indexes on `parent` and break
|
|
if ( node.nodeType === 1 && ++diff && node === elem ) {
|
|
uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
|
|
break;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
// Use previously-cached element index if available
|
|
if ( useCache ) {
|
|
// ...in a gzip-friendly way
|
|
node = elem;
|
|
outerCache = node[ expando ] || (node[ expando ] = {});
|
|
|
|
// Support: IE <9 only
|
|
// Defend against cloned attroperties (jQuery gh-1709)
|
|
uniqueCache = outerCache[ node.uniqueID ] ||
|
|
(outerCache[ node.uniqueID ] = {});
|
|
|
|
cache = uniqueCache[ type ] || [];
|
|
nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
|
|
diff = nodeIndex;
|
|
}
|
|
|
|
// xml :nth-child(...)
|
|
// or :nth-last-child(...) or :nth(-last)?-of-type(...)
|
|
if ( diff === false ) {
|
|
// Use the same loop as above to seek `elem` from the start
|
|
while ( (node = ++nodeIndex && node && node[ dir ] ||
|
|
(diff = nodeIndex = 0) || start.pop()) ) {
|
|
|
|
if ( ( ofType ?
|
|
node.nodeName.toLowerCase() === name :
|
|
node.nodeType === 1 ) &&
|
|
++diff ) {
|
|
|
|
// Cache the index of each encountered element
|
|
if ( useCache ) {
|
|
outerCache = node[ expando ] || (node[ expando ] = {});
|
|
|
|
// Support: IE <9 only
|
|
// Defend against cloned attroperties (jQuery gh-1709)
|
|
uniqueCache = outerCache[ node.uniqueID ] ||
|
|
(outerCache[ node.uniqueID ] = {});
|
|
|
|
uniqueCache[ type ] = [ dirruns, diff ];
|
|
}
|
|
|
|
if ( node === elem ) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Incorporate the offset, then check against cycle size
|
|
diff -= last;
|
|
return diff === first || ( diff % first === 0 && diff / first >= 0 );
|
|
}
|
|
};
|
|
},
|
|
|
|
"PSEUDO": function( pseudo, argument ) {
|
|
// pseudo-class names are case-insensitive
|
|
// http://www.w3.org/TR/selectors/#pseudo-classes
|
|
// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
|
|
// Remember that setFilters inherits from pseudos
|
|
var args,
|
|
fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
|
|
Sizzle.error( "unsupported pseudo: " + pseudo );
|
|
|
|
// The user may use createPseudo to indicate that
|
|
// arguments are needed to create the filter function
|
|
// just as Sizzle does
|
|
if ( fn[ expando ] ) {
|
|
return fn( argument );
|
|
}
|
|
|
|
// But maintain support for old signatures
|
|
if ( fn.length > 1 ) {
|
|
args = [ pseudo, pseudo, "", argument ];
|
|
return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
|
|
markFunction(function( seed, matches ) {
|
|
var idx,
|
|
matched = fn( seed, argument ),
|
|
i = matched.length;
|
|
while ( i-- ) {
|
|
idx = indexOf( seed, matched[i] );
|
|
seed[ idx ] = !( matches[ idx ] = matched[i] );
|
|
}
|
|
}) :
|
|
function( elem ) {
|
|
return fn( elem, 0, args );
|
|
};
|
|
}
|
|
|
|
return fn;
|
|
}
|
|
},
|
|
|
|
pseudos: {
|
|
// Potentially complex pseudos
|
|
"not": markFunction(function( selector ) {
|
|
// Trim the selector passed to compile
|
|
// to avoid treating leading and trailing
|
|
// spaces as combinators
|
|
var input = [],
|
|
results = [],
|
|
matcher = compile( selector.replace( rtrim, "$1" ) );
|
|
|
|
return matcher[ expando ] ?
|
|
markFunction(function( seed, matches, context, xml ) {
|
|
var elem,
|
|
unmatched = matcher( seed, null, xml, [] ),
|
|
i = seed.length;
|
|
|
|
// Match elements unmatched by `matcher`
|
|
while ( i-- ) {
|
|
if ( (elem = unmatched[i]) ) {
|
|
seed[i] = !(matches[i] = elem);
|
|
}
|
|
}
|
|
}) :
|
|
function( elem, context, xml ) {
|
|
input[0] = elem;
|
|
matcher( input, null, xml, results );
|
|
// Don't keep the element (issue #299)
|
|
input[0] = null;
|
|
return !results.pop();
|
|
};
|
|
}),
|
|
|
|
"has": markFunction(function( selector ) {
|
|
return function( elem ) {
|
|
return Sizzle( selector, elem ).length > 0;
|
|
};
|
|
}),
|
|
|
|
"contains": markFunction(function( text ) {
|
|
text = text.replace( runescape, funescape );
|
|
return function( elem ) {
|
|
return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
|
|
};
|
|
}),
|
|
|
|
// "Whether an element is represented by a :lang() selector
|
|
// is based solely on the element's language value
|
|
// being equal to the identifier C,
|
|
// or beginning with the identifier C immediately followed by "-".
|
|
// The matching of C against the element's language value is performed case-insensitively.
|
|
// The identifier C does not have to be a valid language name."
|
|
// http://www.w3.org/TR/selectors/#lang-pseudo
|
|
"lang": markFunction( function( lang ) {
|
|
// lang value must be a valid identifier
|
|
if ( !ridentifier.test(lang || "") ) {
|
|
Sizzle.error( "unsupported lang: " + lang );
|
|
}
|
|
lang = lang.replace( runescape, funescape ).toLowerCase();
|
|
return function( elem ) {
|
|
var elemLang;
|
|
do {
|
|
if ( (elemLang = documentIsHTML ?
|
|
elem.lang :
|
|
elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
|
|
|
|
elemLang = elemLang.toLowerCase();
|
|
return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
|
|
}
|
|
} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
|
|
return false;
|
|
};
|
|
}),
|
|
|
|
// Miscellaneous
|
|
"target": function( elem ) {
|
|
var hash = window.location && window.location.hash;
|
|
return hash && hash.slice( 1 ) === elem.id;
|
|
},
|
|
|
|
"root": function( elem ) {
|
|
return elem === docElem;
|
|
},
|
|
|
|
"focus": function( elem ) {
|
|
return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
|
|
},
|
|
|
|
// Boolean properties
|
|
"enabled": createDisabledPseudo( false ),
|
|
"disabled": createDisabledPseudo( true ),
|
|
|
|
"checked": function( elem ) {
|
|
// In CSS3, :checked should return both checked and selected elements
|
|
// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
|
|
var nodeName = elem.nodeName.toLowerCase();
|
|
return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
|
|
},
|
|
|
|
"selected": function( elem ) {
|
|
// Accessing this property makes selected-by-default
|
|
// options in Safari work properly
|
|
if ( elem.parentNode ) {
|
|
elem.parentNode.selectedIndex;
|
|
}
|
|
|
|
return elem.selected === true;
|
|
},
|
|
|
|
// Contents
|
|
"empty": function( elem ) {
|
|
// http://www.w3.org/TR/selectors/#empty-pseudo
|
|
// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
|
|
// but not by others (comment: 8; processing instruction: 7; etc.)
|
|
// nodeType < 6 works because attributes (2) do not appear as children
|
|
for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
|
|
if ( elem.nodeType < 6 ) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
},
|
|
|
|
"parent": function( elem ) {
|
|
return !Expr.pseudos["empty"]( elem );
|
|
},
|
|
|
|
// Element/input types
|
|
"header": function( elem ) {
|
|
return rheader.test( elem.nodeName );
|
|
},
|
|
|
|
"input": function( elem ) {
|
|
return rinputs.test( elem.nodeName );
|
|
},
|
|
|
|
"button": function( elem ) {
|
|
var name = elem.nodeName.toLowerCase();
|
|
return name === "input" && elem.type === "button" || name === "button";
|
|
},
|
|
|
|
"text": function( elem ) {
|
|
var attr;
|
|
return elem.nodeName.toLowerCase() === "input" &&
|
|
elem.type === "text" &&
|
|
|
|
// Support: IE<8
|
|
// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
|
|
( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
|
|
},
|
|
|
|
// Position-in-collection
|
|
"first": createPositionalPseudo(function() {
|
|
return [ 0 ];
|
|
}),
|
|
|
|
"last": createPositionalPseudo(function( matchIndexes, length ) {
|
|
return [ length - 1 ];
|
|
}),
|
|
|
|
"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
|
|
return [ argument < 0 ? argument + length : argument ];
|
|
}),
|
|
|
|
"even": createPositionalPseudo(function( matchIndexes, length ) {
|
|
var i = 0;
|
|
for ( ; i < length; i += 2 ) {
|
|
matchIndexes.push( i );
|
|
}
|
|
return matchIndexes;
|
|
}),
|
|
|
|
"odd": createPositionalPseudo(function( matchIndexes, length ) {
|
|
var i = 1;
|
|
for ( ; i < length; i += 2 ) {
|
|
matchIndexes.push( i );
|
|
}
|
|
return matchIndexes;
|
|
}),
|
|
|
|
"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
|
|
var i = argument < 0 ? argument + length : argument;
|
|
for ( ; --i >= 0; ) {
|
|
matchIndexes.push( i );
|
|
}
|
|
return matchIndexes;
|
|
}),
|
|
|
|
"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
|
|
var i = argument < 0 ? argument + length : argument;
|
|
for ( ; ++i < length; ) {
|
|
matchIndexes.push( i );
|
|
}
|
|
return matchIndexes;
|
|
})
|
|
}
|
|
};
|
|
|
|
Expr.pseudos["nth"] = Expr.pseudos["eq"];
|
|
|
|
// Add button/input type pseudos
|
|
for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
|
|
Expr.pseudos[ i ] = createInputPseudo( i );
|
|
}
|
|
for ( i in { submit: true, reset: true } ) {
|
|
Expr.pseudos[ i ] = createButtonPseudo( i );
|
|
}
|
|
|
|
// Easy API for creating new setFilters
|
|
function setFilters() {}
|
|
setFilters.prototype = Expr.filters = Expr.pseudos;
|
|
Expr.setFilters = new setFilters();
|
|
|
|
tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
|
|
var matched, match, tokens, type,
|
|
soFar, groups, preFilters,
|
|
cached = tokenCache[ selector + " " ];
|
|
|
|
if ( cached ) {
|
|
return parseOnly ? 0 : cached.slice( 0 );
|
|
}
|
|
|
|
soFar = selector;
|
|
groups = [];
|
|
preFilters = Expr.preFilter;
|
|
|
|
while ( soFar ) {
|
|
|
|
// Comma and first run
|
|
if ( !matched || (match = rcomma.exec( soFar )) ) {
|
|
if ( match ) {
|
|
// Don't consume trailing commas as valid
|
|
soFar = soFar.slice( match[0].length ) || soFar;
|
|
}
|
|
groups.push( (tokens = []) );
|
|
}
|
|
|
|
matched = false;
|
|
|
|
// Combinators
|
|
if ( (match = rcombinators.exec( soFar )) ) {
|
|
matched = match.shift();
|
|
tokens.push({
|
|
value: matched,
|
|
// Cast descendant combinators to space
|
|
type: match[0].replace( rtrim, " " )
|
|
});
|
|
soFar = soFar.slice( matched.length );
|
|
}
|
|
|
|
// Filters
|
|
for ( type in Expr.filter ) {
|
|
if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
|
|
(match = preFilters[ type ]( match ))) ) {
|
|
matched = match.shift();
|
|
tokens.push({
|
|
value: matched,
|
|
type: type,
|
|
matches: match
|
|
});
|
|
soFar = soFar.slice( matched.length );
|
|
}
|
|
}
|
|
|
|
if ( !matched ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Return the length of the invalid excess
|
|
// if we're just parsing
|
|
// Otherwise, throw an error or return tokens
|
|
return parseOnly ?
|
|
soFar.length :
|
|
soFar ?
|
|
Sizzle.error( selector ) :
|
|
// Cache the tokens
|
|
tokenCache( selector, groups ).slice( 0 );
|
|
};
|
|
|
|
function toSelector( tokens ) {
|
|
var i = 0,
|
|
len = tokens.length,
|
|
selector = "";
|
|
for ( ; i < len; i++ ) {
|
|
selector += tokens[i].value;
|
|
}
|
|
return selector;
|
|
}
|
|
|
|
function addCombinator( matcher, combinator, base ) {
|
|
var dir = combinator.dir,
|
|
skip = combinator.next,
|
|
key = skip || dir,
|
|
checkNonElements = base && key === "parentNode",
|
|
doneName = done++;
|
|
|
|
return combinator.first ?
|
|
// Check against closest ancestor/preceding element
|
|
function( elem, context, xml ) {
|
|
while ( (elem = elem[ dir ]) ) {
|
|
if ( elem.nodeType === 1 || checkNonElements ) {
|
|
return matcher( elem, context, xml );
|
|
}
|
|
}
|
|
return false;
|
|
} :
|
|
|
|
// Check against all ancestor/preceding elements
|
|
function( elem, context, xml ) {
|
|
var oldCache, uniqueCache, outerCache,
|
|
newCache = [ dirruns, doneName ];
|
|
|
|
// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
|
|
if ( xml ) {
|
|
while ( (elem = elem[ dir ]) ) {
|
|
if ( elem.nodeType === 1 || checkNonElements ) {
|
|
if ( matcher( elem, context, xml ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
while ( (elem = elem[ dir ]) ) {
|
|
if ( elem.nodeType === 1 || checkNonElements ) {
|
|
outerCache = elem[ expando ] || (elem[ expando ] = {});
|
|
|
|
// Support: IE <9 only
|
|
// Defend against cloned attroperties (jQuery gh-1709)
|
|
uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});
|
|
|
|
if ( skip && skip === elem.nodeName.toLowerCase() ) {
|
|
elem = elem[ dir ] || elem;
|
|
} else if ( (oldCache = uniqueCache[ key ]) &&
|
|
oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
|
|
|
|
// Assign to newCache so results back-propagate to previous elements
|
|
return (newCache[ 2 ] = oldCache[ 2 ]);
|
|
} else {
|
|
// Reuse newcache so results back-propagate to previous elements
|
|
uniqueCache[ key ] = newCache;
|
|
|
|
// A match means we're done; a fail means we have to keep checking
|
|
if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
}
|
|
|
|
function elementMatcher( matchers ) {
|
|
return matchers.length > 1 ?
|
|
function( elem, context, xml ) {
|
|
var i = matchers.length;
|
|
while ( i-- ) {
|
|
if ( !matchers[i]( elem, context, xml ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
} :
|
|
matchers[0];
|
|
}
|
|
|
|
function multipleContexts( selector, contexts, results ) {
|
|
var i = 0,
|
|
len = contexts.length;
|
|
for ( ; i < len; i++ ) {
|
|
Sizzle( selector, contexts[i], results );
|
|
}
|
|
return results;
|
|
}
|
|
|
|
function condense( unmatched, map, filter, context, xml ) {
|
|
var elem,
|
|
newUnmatched = [],
|
|
i = 0,
|
|
len = unmatched.length,
|
|
mapped = map != null;
|
|
|
|
for ( ; i < len; i++ ) {
|
|
if ( (elem = unmatched[i]) ) {
|
|
if ( !filter || filter( elem, context, xml ) ) {
|
|
newUnmatched.push( elem );
|
|
if ( mapped ) {
|
|
map.push( i );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return newUnmatched;
|
|
}
|
|
|
|
function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
|
|
if ( postFilter && !postFilter[ expando ] ) {
|
|
postFilter = setMatcher( postFilter );
|
|
}
|
|
if ( postFinder && !postFinder[ expando ] ) {
|
|
postFinder = setMatcher( postFinder, postSelector );
|
|
}
|
|
return markFunction(function( seed, results, context, xml ) {
|
|
var temp, i, elem,
|
|
preMap = [],
|
|
postMap = [],
|
|
preexisting = results.length,
|
|
|
|
// Get initial elements from seed or context
|
|
elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
|
|
|
|
// Prefilter to get matcher input, preserving a map for seed-results synchronization
|
|
matcherIn = preFilter && ( seed || !selector ) ?
|
|
condense( elems, preMap, preFilter, context, xml ) :
|
|
elems,
|
|
|
|
matcherOut = matcher ?
|
|
// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
|
|
postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
|
|
|
|
// ...intermediate processing is necessary
|
|
[] :
|
|
|
|
// ...otherwise use results directly
|
|
results :
|
|
matcherIn;
|
|
|
|
// Find primary matches
|
|
if ( matcher ) {
|
|
matcher( matcherIn, matcherOut, context, xml );
|
|
}
|
|
|
|
// Apply postFilter
|
|
if ( postFilter ) {
|
|
temp = condense( matcherOut, postMap );
|
|
postFilter( temp, [], context, xml );
|
|
|
|
// Un-match failing elements by moving them back to matcherIn
|
|
i = temp.length;
|
|
while ( i-- ) {
|
|
if ( (elem = temp[i]) ) {
|
|
matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( seed ) {
|
|
if ( postFinder || preFilter ) {
|
|
if ( postFinder ) {
|
|
// Get the final matcherOut by condensing this intermediate into postFinder contexts
|
|
temp = [];
|
|
i = matcherOut.length;
|
|
while ( i-- ) {
|
|
if ( (elem = matcherOut[i]) ) {
|
|
// Restore matcherIn since elem is not yet a final match
|
|
temp.push( (matcherIn[i] = elem) );
|
|
}
|
|
}
|
|
postFinder( null, (matcherOut = []), temp, xml );
|
|
}
|
|
|
|
// Move matched elements from seed to results to keep them synchronized
|
|
i = matcherOut.length;
|
|
while ( i-- ) {
|
|
if ( (elem = matcherOut[i]) &&
|
|
(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
|
|
|
|
seed[temp] = !(results[temp] = elem);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add elements to results, through postFinder if defined
|
|
} else {
|
|
matcherOut = condense(
|
|
matcherOut === results ?
|
|
matcherOut.splice( preexisting, matcherOut.length ) :
|
|
matcherOut
|
|
);
|
|
if ( postFinder ) {
|
|
postFinder( null, results, matcherOut, xml );
|
|
} else {
|
|
push.apply( results, matcherOut );
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
function matcherFromTokens( tokens ) {
|
|
var checkContext, matcher, j,
|
|
len = tokens.length,
|
|
leadingRelative = Expr.relative[ tokens[0].type ],
|
|
implicitRelative = leadingRelative || Expr.relative[" "],
|
|
i = leadingRelative ? 1 : 0,
|
|
|
|
// The foundational matcher ensures that elements are reachable from top-level context(s)
|
|
matchContext = addCombinator( function( elem ) {
|
|
return elem === checkContext;
|
|
}, implicitRelative, true ),
|
|
matchAnyContext = addCombinator( function( elem ) {
|
|
return indexOf( checkContext, elem ) > -1;
|
|
}, implicitRelative, true ),
|
|
matchers = [ function( elem, context, xml ) {
|
|
var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
|
|
(checkContext = context).nodeType ?
|
|
matchContext( elem, context, xml ) :
|
|
matchAnyContext( elem, context, xml ) );
|
|
// Avoid hanging onto element (issue #299)
|
|
checkContext = null;
|
|
return ret;
|
|
} ];
|
|
|
|
for ( ; i < len; i++ ) {
|
|
if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
|
|
matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
|
|
} else {
|
|
matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
|
|
|
|
// Return special upon seeing a positional matcher
|
|
if ( matcher[ expando ] ) {
|
|
// Find the next relative operator (if any) for proper handling
|
|
j = ++i;
|
|
for ( ; j < len; j++ ) {
|
|
if ( Expr.relative[ tokens[j].type ] ) {
|
|
break;
|
|
}
|
|
}
|
|
return setMatcher(
|
|
i > 1 && elementMatcher( matchers ),
|
|
i > 1 && toSelector(
|
|
// If the preceding token was a descendant combinator, insert an implicit any-element `*`
|
|
tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
|
|
).replace( rtrim, "$1" ),
|
|
matcher,
|
|
i < j && matcherFromTokens( tokens.slice( i, j ) ),
|
|
j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
|
|
j < len && toSelector( tokens )
|
|
);
|
|
}
|
|
matchers.push( matcher );
|
|
}
|
|
}
|
|
|
|
return elementMatcher( matchers );
|
|
}
|
|
|
|
function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
|
|
var bySet = setMatchers.length > 0,
|
|
byElement = elementMatchers.length > 0,
|
|
superMatcher = function( seed, context, xml, results, outermost ) {
|
|
var elem, j, matcher,
|
|
matchedCount = 0,
|
|
i = "0",
|
|
unmatched = seed && [],
|
|
setMatched = [],
|
|
contextBackup = outermostContext,
|
|
// We must always have either seed elements or outermost context
|
|
elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
|
|
// Use integer dirruns iff this is the outermost matcher
|
|
dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
|
|
len = elems.length;
|
|
|
|
if ( outermost ) {
|
|
outermostContext = context === document || context || outermost;
|
|
}
|
|
|
|
// Add elements passing elementMatchers directly to results
|
|
// Support: IE<9, Safari
|
|
// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
|
|
for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
|
|
if ( byElement && elem ) {
|
|
j = 0;
|
|
if ( !context && elem.ownerDocument !== document ) {
|
|
setDocument( elem );
|
|
xml = !documentIsHTML;
|
|
}
|
|
while ( (matcher = elementMatchers[j++]) ) {
|
|
if ( matcher( elem, context || document, xml) ) {
|
|
results.push( elem );
|
|
break;
|
|
}
|
|
}
|
|
if ( outermost ) {
|
|
dirruns = dirrunsUnique;
|
|
}
|
|
}
|
|
|
|
// Track unmatched elements for set filters
|
|
if ( bySet ) {
|
|
// They will have gone through all possible matchers
|
|
if ( (elem = !matcher && elem) ) {
|
|
matchedCount--;
|
|
}
|
|
|
|
// Lengthen the array for every element, matched or not
|
|
if ( seed ) {
|
|
unmatched.push( elem );
|
|
}
|
|
}
|
|
}
|
|
|
|
// `i` is now the count of elements visited above, and adding it to `matchedCount`
|
|
// makes the latter nonnegative.
|
|
matchedCount += i;
|
|
|
|
// Apply set filters to unmatched elements
|
|
// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
|
|
// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
|
|
// no element matchers and no seed.
|
|
// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
|
|
// case, which will result in a "00" `matchedCount` that differs from `i` but is also
|
|
// numerically zero.
|
|
if ( bySet && i !== matchedCount ) {
|
|
j = 0;
|
|
while ( (matcher = setMatchers[j++]) ) {
|
|
matcher( unmatched, setMatched, context, xml );
|
|
}
|
|
|
|
if ( seed ) {
|
|
// Reintegrate element matches to eliminate the need for sorting
|
|
if ( matchedCount > 0 ) {
|
|
while ( i-- ) {
|
|
if ( !(unmatched[i] || setMatched[i]) ) {
|
|
setMatched[i] = pop.call( results );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Discard index placeholder values to get only actual matches
|
|
setMatched = condense( setMatched );
|
|
}
|
|
|
|
// Add matches to results
|
|
push.apply( results, setMatched );
|
|
|
|
// Seedless set matches succeeding multiple successful matchers stipulate sorting
|
|
if ( outermost && !seed && setMatched.length > 0 &&
|
|
( matchedCount + setMatchers.length ) > 1 ) {
|
|
|
|
Sizzle.uniqueSort( results );
|
|
}
|
|
}
|
|
|
|
// Override manipulation of globals by nested matchers
|
|
if ( outermost ) {
|
|
dirruns = dirrunsUnique;
|
|
outermostContext = contextBackup;
|
|
}
|
|
|
|
return unmatched;
|
|
};
|
|
|
|
return bySet ?
|
|
markFunction( superMatcher ) :
|
|
superMatcher;
|
|
}
|
|
|
|
compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
|
|
var i,
|
|
setMatchers = [],
|
|
elementMatchers = [],
|
|
cached = compilerCache[ selector + " " ];
|
|
|
|
if ( !cached ) {
|
|
// Generate a function of recursive functions that can be used to check each element
|
|
if ( !match ) {
|
|
match = tokenize( selector );
|
|
}
|
|
i = match.length;
|
|
while ( i-- ) {
|
|
cached = matcherFromTokens( match[i] );
|
|
if ( cached[ expando ] ) {
|
|
setMatchers.push( cached );
|
|
} else {
|
|
elementMatchers.push( cached );
|
|
}
|
|
}
|
|
|
|
// Cache the compiled function
|
|
cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
|
|
|
|
// Save selector and tokenization
|
|
cached.selector = selector;
|
|
}
|
|
return cached;
|
|
};
|
|
|
|
/**
|
|
* A low-level selection function that works with Sizzle's compiled
|
|
* selector functions
|
|
* @param {String|Function} selector A selector or a pre-compiled
|
|
* selector function built with Sizzle.compile
|
|
* @param {Element} context
|
|
* @param {Array} [results]
|
|
* @param {Array} [seed] A set of elements to match against
|
|
*/
|
|
select = Sizzle.select = function( selector, context, results, seed ) {
|
|
var i, tokens, token, type, find,
|
|
compiled = typeof selector === "function" && selector,
|
|
match = !seed && tokenize( (selector = compiled.selector || selector) );
|
|
|
|
results = results || [];
|
|
|
|
// Try to minimize operations if there is only one selector in the list and no seed
|
|
// (the latter of which guarantees us context)
|
|
if ( match.length === 1 ) {
|
|
|
|
// Reduce context if the leading compound selector is an ID
|
|
tokens = match[0] = match[0].slice( 0 );
|
|
if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
|
|
context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {
|
|
|
|
context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
|
|
if ( !context ) {
|
|
return results;
|
|
|
|
// Precompiled matchers will still verify ancestry, so step up a level
|
|
} else if ( compiled ) {
|
|
context = context.parentNode;
|
|
}
|
|
|
|
selector = selector.slice( tokens.shift().value.length );
|
|
}
|
|
|
|
// Fetch a seed set for right-to-left matching
|
|
i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
|
|
while ( i-- ) {
|
|
token = tokens[i];
|
|
|
|
// Abort if we hit a combinator
|
|
if ( Expr.relative[ (type = token.type) ] ) {
|
|
break;
|
|
}
|
|
if ( (find = Expr.find[ type ]) ) {
|
|
// Search, expanding context for leading sibling combinators
|
|
if ( (seed = find(
|
|
token.matches[0].replace( runescape, funescape ),
|
|
rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
|
|
)) ) {
|
|
|
|
// If seed is empty or no tokens remain, we can return early
|
|
tokens.splice( i, 1 );
|
|
selector = seed.length && toSelector( tokens );
|
|
if ( !selector ) {
|
|
push.apply( results, seed );
|
|
return results;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Compile and execute a filtering function if one is not provided
|
|
// Provide `match` to avoid retokenization if we modified the selector above
|
|
( compiled || compile( selector, match ) )(
|
|
seed,
|
|
context,
|
|
!documentIsHTML,
|
|
results,
|
|
!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
|
|
);
|
|
return results;
|
|
};
|
|
|
|
// One-time assignments
|
|
|
|
// Sort stability
|
|
support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
|
|
|
|
// Support: Chrome 14-35+
|
|
// Always assume duplicates if they aren't passed to the comparison function
|
|
support.detectDuplicates = !!hasDuplicate;
|
|
|
|
// Initialize against the default document
|
|
setDocument();
|
|
|
|
// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
|
|
// Detached nodes confoundingly follow *each other*
|
|
support.sortDetached = assert(function( el ) {
|
|
// Should return 1, but returns 4 (following)
|
|
return el.compareDocumentPosition( document.createElement("fieldset") ) & 1;
|
|
});
|
|
|
|
// Support: IE<8
|
|
// Prevent attribute/property "interpolation"
|
|
// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
|
|
if ( !assert(function( el ) {
|
|
el.innerHTML = "<a href='#'></a>";
|
|
return el.firstChild.getAttribute("href") === "#" ;
|
|
}) ) {
|
|
addHandle( "type|href|height|width", function( elem, name, isXML ) {
|
|
if ( !isXML ) {
|
|
return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
|
|
}
|
|
});
|
|
}
|
|
|
|
// Support: IE<9
|
|
// Use defaultValue in place of getAttribute("value")
|
|
if ( !support.attributes || !assert(function( el ) {
|
|
el.innerHTML = "<input/>";
|
|
el.firstChild.setAttribute( "value", "" );
|
|
return el.firstChild.getAttribute( "value" ) === "";
|
|
}) ) {
|
|
addHandle( "value", function( elem, name, isXML ) {
|
|
if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
|
|
return elem.defaultValue;
|
|
}
|
|
});
|
|
}
|
|
|
|
// Support: IE<9
|
|
// Use getAttributeNode to fetch booleans when getAttribute lies
|
|
if ( !assert(function( el ) {
|
|
return el.getAttribute("disabled") == null;
|
|
}) ) {
|
|
addHandle( booleans, function( elem, name, isXML ) {
|
|
var val;
|
|
if ( !isXML ) {
|
|
return elem[ name ] === true ? name.toLowerCase() :
|
|
(val = elem.getAttributeNode( name )) && val.specified ?
|
|
val.value :
|
|
null;
|
|
}
|
|
});
|
|
}
|
|
|
|
return Sizzle;
|
|
|
|
})( window );
|
|
|
|
|
|
|
|
jQuery.find = Sizzle;
|
|
jQuery.expr = Sizzle.selectors;
|
|
|
|
// Deprecated
|
|
jQuery.expr[ ":" ] = jQuery.expr.pseudos;
|
|
jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
|
|
jQuery.text = Sizzle.getText;
|
|
jQuery.isXMLDoc = Sizzle.isXML;
|
|
jQuery.contains = Sizzle.contains;
|
|
jQuery.escapeSelector = Sizzle.escape;
|
|
|
|
|
|
|
|
|
|
var dir = function( elem, dir, until ) {
|
|
var matched = [],
|
|
truncate = until !== undefined;
|
|
|
|
while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
|
|
if ( elem.nodeType === 1 ) {
|
|
if ( truncate && jQuery( elem ).is( until ) ) {
|
|
break;
|
|
}
|
|
matched.push( elem );
|
|
}
|
|
}
|
|
return matched;
|
|
};
|
|
|
|
|
|
var siblings = function( n, elem ) {
|
|
var matched = [];
|
|
|
|
for ( ; n; n = n.nextSibling ) {
|
|
if ( n.nodeType === 1 && n !== elem ) {
|
|
matched.push( n );
|
|
}
|
|
}
|
|
|
|
return matched;
|
|
};
|
|
|
|
|
|
var rneedsContext = jQuery.expr.match.needsContext;
|
|
|
|
|
|
|
|
function nodeName( elem, name ) {
|
|
|
|
return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
|
|
|
|
};
|
|
var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
|
|
|
|
|
|
|
|
var risSimple = /^.[^:#\[\.,]*$/;
|
|
|
|
// Implement the identical functionality for filter and not
|
|
function winnow( elements, qualifier, not ) {
|
|
if ( jQuery.isFunction( qualifier ) ) {
|
|
return jQuery.grep( elements, function( elem, i ) {
|
|
return !!qualifier.call( elem, i, elem ) !== not;
|
|
} );
|
|
}
|
|
|
|
// Single element
|
|
if ( qualifier.nodeType ) {
|
|
return jQuery.grep( elements, function( elem ) {
|
|
return ( elem === qualifier ) !== not;
|
|
} );
|
|
}
|
|
|
|
// Arraylike of elements (jQuery, arguments, Array)
|
|
if ( typeof qualifier !== "string" ) {
|
|
return jQuery.grep( elements, function( elem ) {
|
|
return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
|
|
} );
|
|
}
|
|
|
|
// Simple selector that can be filtered directly, removing non-Elements
|
|
if ( risSimple.test( qualifier ) ) {
|
|
return jQuery.filter( qualifier, elements, not );
|
|
}
|
|
|
|
// Complex selector, compare the two sets, removing non-Elements
|
|
qualifier = jQuery.filter( qualifier, elements );
|
|
return jQuery.grep( elements, function( elem ) {
|
|
return ( indexOf.call( qualifier, elem ) > -1 ) !== not && elem.nodeType === 1;
|
|
} );
|
|
}
|
|
|
|
jQuery.filter = function( expr, elems, not ) {
|
|
var elem = elems[ 0 ];
|
|
|
|
if ( not ) {
|
|
expr = ":not(" + expr + ")";
|
|
}
|
|
|
|
if ( elems.length === 1 && elem.nodeType === 1 ) {
|
|
return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
|
|
}
|
|
|
|
return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
|
|
return elem.nodeType === 1;
|
|
} ) );
|
|
};
|
|
|
|
jQuery.fn.extend( {
|
|
find: function( selector ) {
|
|
var i, ret,
|
|
len = this.length,
|
|
self = this;
|
|
|
|
if ( typeof selector !== "string" ) {
|
|
return this.pushStack( jQuery( selector ).filter( function() {
|
|
for ( i = 0; i < len; i++ ) {
|
|
if ( jQuery.contains( self[ i ], this ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
} ) );
|
|
}
|
|
|
|
ret = this.pushStack( [] );
|
|
|
|
for ( i = 0; i < len; i++ ) {
|
|
jQuery.find( selector, self[ i ], ret );
|
|
}
|
|
|
|
return len > 1 ? jQuery.uniqueSort( ret ) : ret;
|
|
},
|
|
filter: function( selector ) {
|
|
return this.pushStack( winnow( this, selector || [], false ) );
|
|
},
|
|
not: function( selector ) {
|
|
return this.pushStack( winnow( this, selector || [], true ) );
|
|
},
|
|
is: function( selector ) {
|
|
return !!winnow(
|
|
this,
|
|
|
|
// If this is a positional/relative selector, check membership in the returned set
|
|
// so $("p:first").is("p:last") won't return true for a doc with two "p".
|
|
typeof selector === "string" && rneedsContext.test( selector ) ?
|
|
jQuery( selector ) :
|
|
selector || [],
|
|
false
|
|
).length;
|
|
}
|
|
} );
|
|
|
|
|
|
// Initialize a jQuery object
|
|
|
|
|
|
// A central reference to the root jQuery(document)
|
|
var rootjQuery,
|
|
|
|
// A simple way to check for HTML strings
|
|
// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
|
|
// Strict HTML recognition (#11290: must start with <)
|
|
// Shortcut simple #id case for speed
|
|
rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
|
|
|
|
init = jQuery.fn.init = function( selector, context, root ) {
|
|
var match, elem;
|
|
|
|
// HANDLE: $(""), $(null), $(undefined), $(false)
|
|
if ( !selector ) {
|
|
return this;
|
|
}
|
|
|
|
// Method init() accepts an alternate rootjQuery
|
|
// so migrate can support jQuery.sub (gh-2101)
|
|
root = root || rootjQuery;
|
|
|
|
// Handle HTML strings
|
|
if ( typeof selector === "string" ) {
|
|
if ( selector[ 0 ] === "<" &&
|
|
selector[ selector.length - 1 ] === ">" &&
|
|
selector.length >= 3 ) {
|
|
|
|
// Assume that strings that start and end with <> are HTML and skip the regex check
|
|
match = [ null, selector, null ];
|
|
|
|
} else {
|
|
match = rquickExpr.exec( selector );
|
|
}
|
|
|
|
// Match html or make sure no context is specified for #id
|
|
if ( match && ( match[ 1 ] || !context ) ) {
|
|
|
|
// HANDLE: $(html) -> $(array)
|
|
if ( match[ 1 ] ) {
|
|
context = context instanceof jQuery ? context[ 0 ] : context;
|
|
|
|
// Option to run scripts is true for back-compat
|
|
// Intentionally let the error be thrown if parseHTML is not present
|
|
jQuery.merge( this, jQuery.parseHTML(
|
|
match[ 1 ],
|
|
context && context.nodeType ? context.ownerDocument || context : document,
|
|
true
|
|
) );
|
|
|
|
// HANDLE: $(html, props)
|
|
if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
|
|
for ( match in context ) {
|
|
|
|
// Properties of context are called as methods if possible
|
|
if ( jQuery.isFunction( this[ match ] ) ) {
|
|
this[ match ]( context[ match ] );
|
|
|
|
// ...and otherwise set as attributes
|
|
} else {
|
|
this.attr( match, context[ match ] );
|
|
}
|
|
}
|
|
}
|
|
|
|
return this;
|
|
|
|
// HANDLE: $(#id)
|
|
} else {
|
|
elem = document.getElementById( match[ 2 ] );
|
|
|
|
if ( elem ) {
|
|
|
|
// Inject the element directly into the jQuery object
|
|
this[ 0 ] = elem;
|
|
this.length = 1;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
// HANDLE: $(expr, $(...))
|
|
} else if ( !context || context.jquery ) {
|
|
return ( context || root ).find( selector );
|
|
|
|
// HANDLE: $(expr, context)
|
|
// (which is just equivalent to: $(context).find(expr)
|
|
} else {
|
|
return this.constructor( context ).find( selector );
|
|
}
|
|
|
|
// HANDLE: $(DOMElement)
|
|
} else if ( selector.nodeType ) {
|
|
this[ 0 ] = selector;
|
|
this.length = 1;
|
|
return this;
|
|
|
|
// HANDLE: $(function)
|
|
// Shortcut for document ready
|
|
} else if ( jQuery.isFunction( selector ) ) {
|
|
return root.ready !== undefined ?
|
|
root.ready( selector ) :
|
|
|
|
// Execute immediately if ready is not present
|
|
selector( jQuery );
|
|
}
|
|
|
|
return jQuery.makeArray( selector, this );
|
|
};
|
|
|
|
// Give the init function the jQuery prototype for later instantiation
|
|
init.prototype = jQuery.fn;
|
|
|
|
// Initialize central reference
|
|
rootjQuery = jQuery( document );
|
|
|
|
|
|
var rparentsprev = /^(?:parents|prev(?:Until|All))/,
|
|
|
|
// Methods guaranteed to produce a unique set when starting from a unique set
|
|
guaranteedUnique = {
|
|
children: true,
|
|
contents: true,
|
|
next: true,
|
|
prev: true
|
|
};
|
|
|
|
jQuery.fn.extend( {
|
|
has: function( target ) {
|
|
var targets = jQuery( target, this ),
|
|
l = targets.length;
|
|
|
|
return this.filter( function() {
|
|
var i = 0;
|
|
for ( ; i < l; i++ ) {
|
|
if ( jQuery.contains( this, targets[ i ] ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
} );
|
|
},
|
|
|
|
closest: function( selectors, context ) {
|
|
var cur,
|
|
i = 0,
|
|
l = this.length,
|
|
matched = [],
|
|
targets = typeof selectors !== "string" && jQuery( selectors );
|
|
|
|
// Positional selectors never match, since there's no _selection_ context
|
|
if ( !rneedsContext.test( selectors ) ) {
|
|
for ( ; i < l; i++ ) {
|
|
for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
|
|
|
|
// Always skip document fragments
|
|
if ( cur.nodeType < 11 && ( targets ?
|
|
targets.index( cur ) > -1 :
|
|
|
|
// Don't pass non-elements to Sizzle
|
|
cur.nodeType === 1 &&
|
|
jQuery.find.matchesSelector( cur, selectors ) ) ) {
|
|
|
|
matched.push( cur );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
|
|
},
|
|
|
|
// Determine the position of an element within the set
|
|
index: function( elem ) {
|
|
|
|
// No argument, return index in parent
|
|
if ( !elem ) {
|
|
return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
|
|
}
|
|
|
|
// Index in selector
|
|
if ( typeof elem === "string" ) {
|
|
return indexOf.call( jQuery( elem ), this[ 0 ] );
|
|
}
|
|
|
|
// Locate the position of the desired element
|
|
return indexOf.call( this,
|
|
|
|
// If it receives a jQuery object, the first element is used
|
|
elem.jquery ? elem[ 0 ] : elem
|
|
);
|
|
},
|
|
|
|
add: function( selector, context ) {
|
|
return this.pushStack(
|
|
jQuery.uniqueSort(
|
|
jQuery.merge( this.get(), jQuery( selector, context ) )
|
|
)
|
|
);
|
|
},
|
|
|
|
addBack: function( selector ) {
|
|
return this.add( selector == null ?
|
|
this.prevObject : this.prevObject.filter( selector )
|
|
);
|
|
}
|
|
} );
|
|
|
|
function sibling( cur, dir ) {
|
|
while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
|
|
return cur;
|
|
}
|
|
|
|
jQuery.each( {
|
|
parent: function( elem ) {
|
|
var parent = elem.parentNode;
|
|
return parent && parent.nodeType !== 11 ? parent : null;
|
|
},
|
|
parents: function( elem ) {
|
|
return dir( elem, "parentNode" );
|
|
},
|
|
parentsUntil: function( elem, i, until ) {
|
|
return dir( elem, "parentNode", until );
|
|
},
|
|
next: function( elem ) {
|
|
return sibling( elem, "nextSibling" );
|
|
},
|
|
prev: function( elem ) {
|
|
return sibling( elem, "previousSibling" );
|
|
},
|
|
nextAll: function( elem ) {
|
|
return dir( elem, "nextSibling" );
|
|
},
|
|
prevAll: function( elem ) {
|
|
return dir( elem, "previousSibling" );
|
|
},
|
|
nextUntil: function( elem, i, until ) {
|
|
return dir( elem, "nextSibling", until );
|
|
},
|
|
prevUntil: function( elem, i, until ) {
|
|
return dir( elem, "previousSibling", until );
|
|
},
|
|
siblings: function( elem ) {
|
|
return siblings( ( elem.parentNode || {} ).firstChild, elem );
|
|
},
|
|
children: function( elem ) {
|
|
return siblings( elem.firstChild );
|
|
},
|
|
contents: function( elem ) {
|
|
if ( nodeName( elem, "iframe" ) ) {
|
|
return elem.contentDocument;
|
|
}
|
|
|
|
// Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
|
|
// Treat the template element as a regular one in browsers that
|
|
// don't support it.
|
|
if ( nodeName( elem, "template" ) ) {
|
|
elem = elem.content || elem;
|
|
}
|
|
|
|
return jQuery.merge( [], elem.childNodes );
|
|
}
|
|
}, function( name, fn ) {
|
|
jQuery.fn[ name ] = function( until, selector ) {
|
|
var matched = jQuery.map( this, fn, until );
|
|
|
|
if ( name.slice( -5 ) !== "Until" ) {
|
|
selector = until;
|
|
}
|
|
|
|
if ( selector && typeof selector === "string" ) {
|
|
matched = jQuery.filter( selector, matched );
|
|
}
|
|
|
|
if ( this.length > 1 ) {
|
|
|
|
// Remove duplicates
|
|
if ( !guaranteedUnique[ name ] ) {
|
|
jQuery.uniqueSort( matched );
|
|
}
|
|
|
|
// Reverse order for parents* and prev-derivatives
|
|
if ( rparentsprev.test( name ) ) {
|
|
matched.reverse();
|
|
}
|
|
}
|
|
|
|
return this.pushStack( matched );
|
|
};
|
|
} );
|
|
var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
|
|
|
|
|
|
|
|
// Convert String-formatted options into Object-formatted ones
|
|
function createOptions( options ) {
|
|
var object = {};
|
|
jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
|
|
object[ flag ] = true;
|
|
} );
|
|
return object;
|
|
}
|
|
|
|
/*
|
|
* Create a callback list using the following parameters:
|
|
*
|
|
* options: an optional list of space-separated options that will change how
|
|
* the callback list behaves or a more traditional option object
|
|
*
|
|
* By default a callback list will act like an event callback list and can be
|
|
* "fired" multiple times.
|
|
*
|
|
* Possible options:
|
|
*
|
|
* once: will ensure the callback list can only be fired once (like a Deferred)
|
|
*
|
|
* memory: will keep track of previous values and will call any callback added
|
|
* after the list has been fired right away with the latest "memorized"
|
|
* values (like a Deferred)
|
|
*
|
|
* unique: will ensure a callback can only be added once (no duplicate in the list)
|
|
*
|
|
* stopOnFalse: interrupt callings when a callback returns false
|
|
*
|
|
*/
|
|
jQuery.Callbacks = function( options ) {
|
|
|
|
// Convert options from String-formatted to Object-formatted if needed
|
|
// (we check in cache first)
|
|
options = typeof options === "string" ?
|
|
createOptions( options ) :
|
|
jQuery.extend( {}, options );
|
|
|
|
var // Flag to know if list is currently firing
|
|
firing,
|
|
|
|
// Last fire value for non-forgettable lists
|
|
memory,
|
|
|
|
// Flag to know if list was already fired
|
|
fired,
|
|
|
|
// Flag to prevent firing
|
|
locked,
|
|
|
|
// Actual callback list
|
|
list = [],
|
|
|
|
// Queue of execution data for repeatable lists
|
|
queue = [],
|
|
|
|
// Index of currently firing callback (modified by add/remove as needed)
|
|
firingIndex = -1,
|
|
|
|
// Fire callbacks
|
|
fire = function() {
|
|
|
|
// Enforce single-firing
|
|
locked = locked || options.once;
|
|
|
|
// Execute callbacks for all pending executions,
|
|
// respecting firingIndex overrides and runtime changes
|
|
fired = firing = true;
|
|
for ( ; queue.length; firingIndex = -1 ) {
|
|
memory = queue.shift();
|
|
while ( ++firingIndex < list.length ) {
|
|
|
|
// Run callback and check for early termination
|
|
if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
|
|
options.stopOnFalse ) {
|
|
|
|
// Jump to end and forget the data so .add doesn't re-fire
|
|
firingIndex = list.length;
|
|
memory = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Forget the data if we're done with it
|
|
if ( !options.memory ) {
|
|
memory = false;
|
|
}
|
|
|
|
firing = false;
|
|
|
|
// Clean up if we're done firing for good
|
|
if ( locked ) {
|
|
|
|
// Keep an empty list if we have data for future add calls
|
|
if ( memory ) {
|
|
list = [];
|
|
|
|
// Otherwise, this object is spent
|
|
} else {
|
|
list = "";
|
|
}
|
|
}
|
|
},
|
|
|
|
// Actual Callbacks object
|
|
self = {
|
|
|
|
// Add a callback or a collection of callbacks to the list
|
|
add: function() {
|
|
if ( list ) {
|
|
|
|
// If we have memory from a past run, we should fire after adding
|
|
if ( memory && !firing ) {
|
|
firingIndex = list.length - 1;
|
|
queue.push( memory );
|
|
}
|
|
|
|
( function add( args ) {
|
|
jQuery.each( args, function( _, arg ) {
|
|
if ( jQuery.isFunction( arg ) ) {
|
|
if ( !options.unique || !self.has( arg ) ) {
|
|
list.push( arg );
|
|
}
|
|
} else if ( arg && arg.length && jQuery.type( arg ) !== "string" ) {
|
|
|
|
// Inspect recursively
|
|
add( arg );
|
|
}
|
|
} );
|
|
} )( arguments );
|
|
|
|
if ( memory && !firing ) {
|
|
fire();
|
|
}
|
|
}
|
|
return this;
|
|
},
|
|
|
|
// Remove a callback from the list
|
|
remove: function() {
|
|
jQuery.each( arguments, function( _, arg ) {
|
|
var index;
|
|
while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
|
|
list.splice( index, 1 );
|
|
|
|
// Handle firing indexes
|
|
if ( index <= firingIndex ) {
|
|
firingIndex--;
|
|
}
|
|
}
|
|
} );
|
|
return this;
|
|
},
|
|
|
|
// Check if a given callback is in the list.
|
|
// If no argument is given, return whether or not list has callbacks attached.
|
|
has: function( fn ) {
|
|
return fn ?
|
|
jQuery.inArray( fn, list ) > -1 :
|
|
list.length > 0;
|
|
},
|
|
|
|
// Remove all callbacks from the list
|
|
empty: function() {
|
|
if ( list ) {
|
|
list = [];
|
|
}
|
|
return this;
|
|
},
|
|
|
|
// Disable .fire and .add
|
|
// Abort any current/pending executions
|
|
// Clear all callbacks and values
|
|
disable: function() {
|
|
locked = queue = [];
|
|
list = memory = "";
|
|
return this;
|
|
},
|
|
disabled: function() {
|
|
return !list;
|
|
},
|
|
|
|
// Disable .fire
|
|
// Also disable .add unless we have memory (since it would have no effect)
|
|
// Abort any pending executions
|
|
lock: function() {
|
|
locked = queue = [];
|
|
if ( !memory && !firing ) {
|
|
list = memory = "";
|
|
}
|
|
return this;
|
|
},
|
|
locked: function() {
|
|
return !!locked;
|
|
},
|
|
|
|
// Call all callbacks with the given context and arguments
|
|
fireWith: function( context, args ) {
|
|
if ( !locked ) {
|
|
args = args || [];
|
|
args = [ context, args.slice ? args.slice() : args ];
|
|
queue.push( args );
|
|
if ( !firing ) {
|
|
fire();
|
|
}
|
|
}
|
|
return this;
|
|
},
|
|
|
|
// Call all the callbacks with the given arguments
|
|
fire: function() {
|
|
self.fireWith( this, arguments );
|
|
return this;
|
|
},
|
|
|
|
// To know if the callbacks have already been called at least once
|
|
fired: function() {
|
|
return !!fired;
|
|
}
|
|
};
|
|
|
|
return self;
|
|
};
|
|
|
|
|
|
function Identity( v ) {
|
|
return v;
|
|
}
|
|
function Thrower( ex ) {
|
|
throw ex;
|
|
}
|
|
|
|
function adoptValue( value, resolve, reject, noValue ) {
|
|
var method;
|
|
|
|
try {
|
|
|
|
// Check for promise aspect first to privilege synchronous behavior
|
|
if ( value && jQuery.isFunction( ( method = value.promise ) ) ) {
|
|
method.call( value ).done( resolve ).fail( reject );
|
|
|
|
// Other thenables
|
|
} else if ( value && jQuery.isFunction( ( method = value.then ) ) ) {
|
|
method.call( value, resolve, reject );
|
|
|
|
// Other non-thenables
|
|
} else {
|
|
|
|
// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
|
|
// * false: [ value ].slice( 0 ) => resolve( value )
|
|
// * true: [ value ].slice( 1 ) => resolve()
|
|
resolve.apply( undefined, [ value ].slice( noValue ) );
|
|
}
|
|
|
|
// For Promises/A+, convert exceptions into rejections
|
|
// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
|
|
// Deferred#then to conditionally suppress rejection.
|
|
} catch ( value ) {
|
|
|
|
// Support: Android 4.0 only
|
|
// Strict mode functions invoked without .call/.apply get global-object context
|
|
reject.apply( undefined, [ value ] );
|
|
}
|
|
}
|
|
|
|
jQuery.extend( {
|
|
|
|
Deferred: function( func ) {
|
|
var tuples = [
|
|
|
|
// action, add listener, callbacks,
|
|
// ... .then handlers, argument index, [final state]
|
|
[ "notify", "progress", jQuery.Callbacks( "memory" ),
|
|
jQuery.Callbacks( "memory" ), 2 ],
|
|
[ "resolve", "done", jQuery.Callbacks( "once memory" ),
|
|
jQuery.Callbacks( "once memory" ), 0, "resolved" ],
|
|
[ "reject", "fail", jQuery.Callbacks( "once memory" ),
|
|
jQuery.Callbacks( "once memory" ), 1, "rejected" ]
|
|
],
|
|
state = "pending",
|
|
promise = {
|
|
state: function() {
|
|
return state;
|
|
},
|
|
always: function() {
|
|
deferred.done( arguments ).fail( arguments );
|
|
return this;
|
|
},
|
|
"catch": function( fn ) {
|
|
return promise.then( null, fn );
|
|
},
|
|
|
|
// Keep pipe for back-compat
|
|
pipe: function( /* fnDone, fnFail, fnProgress */ ) {
|
|
var fns = arguments;
|
|
|
|
return jQuery.Deferred( function( newDefer ) {
|
|
jQuery.each( tuples, function( i, tuple ) {
|
|
|
|
// Map tuples (progress, done, fail) to arguments (done, fail, progress)
|
|
var fn = jQuery.isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
|
|
|
|
// deferred.progress(function() { bind to newDefer or newDefer.notify })
|
|
// deferred.done(function() { bind to newDefer or newDefer.resolve })
|
|
// deferred.fail(function() { bind to newDefer or newDefer.reject })
|
|
deferred[ tuple[ 1 ] ]( function() {
|
|
var returned = fn && fn.apply( this, arguments );
|
|
if ( returned && jQuery.isFunction( returned.promise ) ) {
|
|
returned.promise()
|
|
.progress( newDefer.notify )
|
|
.done( newDefer.resolve )
|
|
.fail( newDefer.reject );
|
|
} else {
|
|
newDefer[ tuple[ 0 ] + "With" ](
|
|
this,
|
|
fn ? [ returned ] : arguments
|
|
);
|
|
}
|
|
} );
|
|
} );
|
|
fns = null;
|
|
} ).promise();
|
|
},
|
|
then: function( onFulfilled, onRejected, onProgress ) {
|
|
var maxDepth = 0;
|
|
function resolve( depth, deferred, handler, special ) {
|
|
return function() {
|
|
var that = this,
|
|
args = arguments,
|
|
mightThrow = function() {
|
|
var returned, then;
|
|
|
|
// Support: Promises/A+ section 2.3.3.3.3
|
|
// https://promisesaplus.com/#point-59
|
|
// Ignore double-resolution attempts
|
|
if ( depth < maxDepth ) {
|
|
return;
|
|
}
|
|
|
|
returned = handler.apply( that, args );
|
|
|
|
// Support: Promises/A+ section 2.3.1
|
|
// https://promisesaplus.com/#point-48
|
|
if ( returned === deferred.promise() ) {
|
|
throw new TypeError( "Thenable self-resolution" );
|
|
}
|
|
|
|
// Support: Promises/A+ sections 2.3.3.1, 3.5
|
|
// https://promisesaplus.com/#point-54
|
|
// https://promisesaplus.com/#point-75
|
|
// Retrieve `then` only once
|
|
then = returned &&
|
|
|
|
// Support: Promises/A+ section 2.3.4
|
|
// https://promisesaplus.com/#point-64
|
|
// Only check objects and functions for thenability
|
|
( typeof returned === "object" ||
|
|
typeof returned === "function" ) &&
|
|
returned.then;
|
|
|
|
// Handle a returned thenable
|
|
if ( jQuery.isFunction( then ) ) {
|
|
|
|
// Special processors (notify) just wait for resolution
|
|
if ( special ) {
|
|
then.call(
|
|
returned,
|
|
resolve( maxDepth, deferred, Identity, special ),
|
|
resolve( maxDepth, deferred, Thrower, special )
|
|
);
|
|
|
|
// Normal processors (resolve) also hook into progress
|
|
} else {
|
|
|
|
// ...and disregard older resolution values
|
|
maxDepth++;
|
|
|
|
then.call(
|
|
returned,
|
|
resolve( maxDepth, deferred, Identity, special ),
|
|
resolve( maxDepth, deferred, Thrower, special ),
|
|
resolve( maxDepth, deferred, Identity,
|
|
deferred.notifyWith )
|
|
);
|
|
}
|
|
|
|
// Handle all other returned values
|
|
} else {
|
|
|
|
// Only substitute handlers pass on context
|
|
// and multiple values (non-spec behavior)
|
|
if ( handler !== Identity ) {
|
|
that = undefined;
|
|
args = [ returned ];
|
|
}
|
|
|
|
// Process the value(s)
|
|
// Default process is resolve
|
|
( special || deferred.resolveWith )( that, args );
|
|
}
|
|
},
|
|
|
|
// Only normal processors (resolve) catch and reject exceptions
|
|
process = special ?
|
|
mightThrow :
|
|
function() {
|
|
try {
|
|
mightThrow();
|
|
} catch ( e ) {
|
|
|
|
if ( jQuery.Deferred.exceptionHook ) {
|
|
jQuery.Deferred.exceptionHook( e,
|
|
process.stackTrace );
|
|
}
|
|
|
|
// Support: Promises/A+ section 2.3.3.3.4.1
|
|
// https://promisesaplus.com/#point-61
|
|
// Ignore post-resolution exceptions
|
|
if ( depth + 1 >= maxDepth ) {
|
|
|
|
// Only substitute handlers pass on context
|
|
// and multiple values (non-spec behavior)
|
|
if ( handler !== Thrower ) {
|
|
that = undefined;
|
|
args = [ e ];
|
|
}
|
|
|
|
deferred.rejectWith( that, args );
|
|
}
|
|
}
|
|
};
|
|
|
|
// Support: Promises/A+ section 2.3.3.3.1
|
|
// https://promisesaplus.com/#point-57
|
|
// Re-resolve promises immediately to dodge false rejection from
|
|
// subsequent errors
|
|
if ( depth ) {
|
|
process();
|
|
} else {
|
|
|
|
// Call an optional hook to record the stack, in case of exception
|
|
// since it's otherwise lost when execution goes async
|
|
if ( jQuery.Deferred.getStackHook ) {
|
|
process.stackTrace = jQuery.Deferred.getStackHook();
|
|
}
|
|
window.setTimeout( process );
|
|
}
|
|
};
|
|
}
|
|
|
|
return jQuery.Deferred( function( newDefer ) {
|
|
|
|
// progress_handlers.add( ... )
|
|
tuples[ 0 ][ 3 ].add(
|
|
resolve(
|
|
0,
|
|
newDefer,
|
|
jQuery.isFunction( onProgress ) ?
|
|
onProgress :
|
|
Identity,
|
|
newDefer.notifyWith
|
|
)
|
|
);
|
|
|
|
// fulfilled_handlers.add( ... )
|
|
tuples[ 1 ][ 3 ].add(
|
|
resolve(
|
|
0,
|
|
newDefer,
|
|
jQuery.isFunction( onFulfilled ) ?
|
|
onFulfilled :
|
|
Identity
|
|
)
|
|
);
|
|
|
|
// rejected_handlers.add( ... )
|
|
tuples[ 2 ][ 3 ].add(
|
|
resolve(
|
|
0,
|
|
newDefer,
|
|
jQuery.isFunction( onRejected ) ?
|
|
onRejected :
|
|
Thrower
|
|
)
|
|
);
|
|
} ).promise();
|
|
},
|
|
|
|
// Get a promise for this deferred
|
|
// If obj is provided, the promise aspect is added to the object
|
|
promise: function( obj ) {
|
|
return obj != null ? jQuery.extend( obj, promise ) : promise;
|
|
}
|
|
},
|
|
deferred = {};
|
|
|
|
// Add list-specific methods
|
|
jQuery.each( tuples, function( i, tuple ) {
|
|
var list = tuple[ 2 ],
|
|
stateString = tuple[ 5 ];
|
|
|
|
// promise.progress = list.add
|
|
// promise.done = list.add
|
|
// promise.fail = list.add
|
|
promise[ tuple[ 1 ] ] = list.add;
|
|
|
|
// Handle state
|
|
if ( stateString ) {
|
|
list.add(
|
|
function() {
|
|
|
|
// state = "resolved" (i.e., fulfilled)
|
|
// state = "rejected"
|
|
state = stateString;
|
|
},
|
|
|
|
// rejected_callbacks.disable
|
|
// fulfilled_callbacks.disable
|
|
tuples[ 3 - i ][ 2 ].disable,
|
|
|
|
// progress_callbacks.lock
|
|
tuples[ 0 ][ 2 ].lock
|
|
);
|
|
}
|
|
|
|
// progress_handlers.fire
|
|
// fulfilled_handlers.fire
|
|
// rejected_handlers.fire
|
|
list.add( tuple[ 3 ].fire );
|
|
|
|
// deferred.notify = function() { deferred.notifyWith(...) }
|
|
// deferred.resolve = function() { deferred.resolveWith(...) }
|
|
// deferred.reject = function() { deferred.rejectWith(...) }
|
|
deferred[ tuple[ 0 ] ] = function() {
|
|
deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
|
|
return this;
|
|
};
|
|
|
|
// deferred.notifyWith = list.fireWith
|
|
// deferred.resolveWith = list.fireWith
|
|
// deferred.rejectWith = list.fireWith
|
|
deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
|
|
} );
|
|
|
|
// Make the deferred a promise
|
|
promise.promise( deferred );
|
|
|
|
// Call given func if any
|
|
if ( func ) {
|
|
func.call( deferred, deferred );
|
|
}
|
|
|
|
// All done!
|
|
return deferred;
|
|
},
|
|
|
|
// Deferred helper
|
|
when: function( singleValue ) {
|
|
var
|
|
|
|
// count of uncompleted subordinates
|
|
remaining = arguments.length,
|
|
|
|
// count of unprocessed arguments
|
|
i = remaining,
|
|
|
|
// subordinate fulfillment data
|
|
resolveContexts = Array( i ),
|
|
resolveValues = slice.call( arguments ),
|
|
|
|
// the master Deferred
|
|
master = jQuery.Deferred(),
|
|
|
|
// subordinate callback factory
|
|
updateFunc = function( i ) {
|
|
return function( value ) {
|
|
resolveContexts[ i ] = this;
|
|
resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
|
|
if ( !( --remaining ) ) {
|
|
master.resolveWith( resolveContexts, resolveValues );
|
|
}
|
|
};
|
|
};
|
|
|
|
// Single- and empty arguments are adopted like Promise.resolve
|
|
if ( remaining <= 1 ) {
|
|
adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject,
|
|
!remaining );
|
|
|
|
// Use .then() to unwrap secondary thenables (cf. gh-3000)
|
|
if ( master.state() === "pending" ||
|
|
jQuery.isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
|
|
|
|
return master.then();
|
|
}
|
|
}
|
|
|
|
// Multiple arguments are aggregated like Promise.all array elements
|
|
while ( i-- ) {
|
|
adoptValue( resolveValues[ i ], updateFunc( i ), master.reject );
|
|
}
|
|
|
|
return master.promise();
|
|
}
|
|
} );
|
|
|
|
|
|
// These usually indicate a programmer mistake during development,
|
|
// warn about them ASAP rather than swallowing them by default.
|
|
var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
|
|
|
|
jQuery.Deferred.exceptionHook = function( error, stack ) {
|
|
|
|
// Support: IE 8 - 9 only
|
|
// Console exists when dev tools are open, which can happen at any time
|
|
if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
|
|
window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
jQuery.readyException = function( error ) {
|
|
window.setTimeout( function() {
|
|
throw error;
|
|
} );
|
|
};
|
|
|
|
|
|
|
|
|
|
// The deferred used on DOM ready
|
|
var readyList = jQuery.Deferred();
|
|
|
|
jQuery.fn.ready = function( fn ) {
|
|
|
|
readyList
|
|
.then( fn )
|
|
|
|
// Wrap jQuery.readyException in a function so that the lookup
|
|
// happens at the time of error handling instead of callback
|
|
// registration.
|
|
.catch( function( error ) {
|
|
jQuery.readyException( error );
|
|
} );
|
|
|
|
return this;
|
|
};
|
|
|
|
jQuery.extend( {
|
|
|
|
// Is the DOM ready to be used? Set to true once it occurs.
|
|
isReady: false,
|
|
|
|
// A counter to track how many items to wait for before
|
|
// the ready event fires. See #6781
|
|
readyWait: 1,
|
|
|
|
// Handle when the DOM is ready
|
|
ready: function( wait ) {
|
|
|
|
// Abort if there are pending holds or we're already ready
|
|
if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
|
|
return;
|
|
}
|
|
|
|
// Remember that the DOM is ready
|
|
jQuery.isReady = true;
|
|
|
|
// If a normal DOM Ready event fired, decrement, and wait if need be
|
|
if ( wait !== true && --jQuery.readyWait > 0 ) {
|
|
return;
|
|
}
|
|
|
|
// If there are functions bound, to execute
|
|
readyList.resolveWith( document, [ jQuery ] );
|
|
}
|
|
} );
|
|
|
|
jQuery.ready.then = readyList.then;
|
|
|
|
// The ready event handler and self cleanup method
|
|
function completed() {
|
|
document.removeEventListener( "DOMContentLoaded", completed );
|
|
window.removeEventListener( "load", completed );
|
|
jQuery.ready();
|
|
}
|
|
|
|
// Catch cases where $(document).ready() is called
|
|
// after the browser event has already occurred.
|
|
// Support: IE <=9 - 10 only
|
|
// Older IE sometimes signals "interactive" too soon
|
|
if ( document.readyState === "complete" ||
|
|
( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
|
|
|
|
// Handle it asynchronously to allow scripts the opportunity to delay ready
|
|
window.setTimeout( jQuery.ready );
|
|
|
|
} else {
|
|
|
|
// Use the handy event callback
|
|
document.addEventListener( "DOMContentLoaded", completed );
|
|
|
|
// A fallback to window.onload, that will always work
|
|
window.addEventListener( "load", completed );
|
|
}
|
|
|
|
|
|
|
|
|
|
// Multifunctional method to get and set values of a collection
|
|
// The value/s can optionally be executed if it's a function
|
|
var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
|
|
var i = 0,
|
|
len = elems.length,
|
|
bulk = key == null;
|
|
|
|
// Sets many values
|
|
if ( jQuery.type( key ) === "object" ) {
|
|
chainable = true;
|
|
for ( i in key ) {
|
|
access( elems, fn, i, key[ i ], true, emptyGet, raw );
|
|
}
|
|
|
|
// Sets one value
|
|
} else if ( value !== undefined ) {
|
|
chainable = true;
|
|
|
|
if ( !jQuery.isFunction( value ) ) {
|
|
raw = true;
|
|
}
|
|
|
|
if ( bulk ) {
|
|
|
|
// Bulk operations run against the entire set
|
|
if ( raw ) {
|
|
fn.call( elems, value );
|
|
fn = null;
|
|
|
|
// ...except when executing function values
|
|
} else {
|
|
bulk = fn;
|
|
fn = function( elem, key, value ) {
|
|
return bulk.call( jQuery( elem ), value );
|
|
};
|
|
}
|
|
}
|
|
|
|
if ( fn ) {
|
|
for ( ; i < len; i++ ) {
|
|
fn(
|
|
elems[ i ], key, raw ?
|
|
value :
|
|
value.call( elems[ i ], i, fn( elems[ i ], key ) )
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( chainable ) {
|
|
return elems;
|
|
}
|
|
|
|
// Gets
|
|
if ( bulk ) {
|
|
return fn.call( elems );
|
|
}
|
|
|
|
return len ? fn( elems[ 0 ], key ) : emptyGet;
|
|
};
|
|
var acceptData = function( owner ) {
|
|
|
|
// Accepts only:
|
|
// - Node
|
|
// - Node.ELEMENT_NODE
|
|
// - Node.DOCUMENT_NODE
|
|
// - Object
|
|
// - Any
|
|
return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
|
|
};
|
|
|
|
|
|
|
|
|
|
function Data() {
|
|
this.expando = jQuery.expando + Data.uid++;
|
|
}
|
|
|
|
Data.uid = 1;
|
|
|
|
Data.prototype = {
|
|
|
|
cache: function( owner ) {
|
|
|
|
// Check if the owner object already has a cache
|
|
var value = owner[ this.expando ];
|
|
|
|
// If not, create one
|
|
if ( !value ) {
|
|
value = {};
|
|
|
|
// We can accept data for non-element nodes in modern browsers,
|
|
// but we should not, see #8335.
|
|
// Always return an empty object.
|
|
if ( acceptData( owner ) ) {
|
|
|
|
// If it is a node unlikely to be stringify-ed or looped over
|
|
// use plain assignment
|
|
if ( owner.nodeType ) {
|
|
owner[ this.expando ] = value;
|
|
|
|
// Otherwise secure it in a non-enumerable property
|
|
// configurable must be true to allow the property to be
|
|
// deleted when data is removed
|
|
} else {
|
|
Object.defineProperty( owner, this.expando, {
|
|
value: value,
|
|
configurable: true
|
|
} );
|
|
}
|
|
}
|
|
}
|
|
|
|
return value;
|
|
},
|
|
set: function( owner, data, value ) {
|
|
var prop,
|
|
cache = this.cache( owner );
|
|
|
|
// Handle: [ owner, key, value ] args
|
|
// Always use camelCase key (gh-2257)
|
|
if ( typeof data === "string" ) {
|
|
cache[ jQuery.camelCase( data ) ] = value;
|
|
|
|
// Handle: [ owner, { properties } ] args
|
|
} else {
|
|
|
|
// Copy the properties one-by-one to the cache object
|
|
for ( prop in data ) {
|
|
cache[ jQuery.camelCase( prop ) ] = data[ prop ];
|
|
}
|
|
}
|
|
return cache;
|
|
},
|
|
get: function( owner, key ) {
|
|
return key === undefined ?
|
|
this.cache( owner ) :
|
|
|
|
// Always use camelCase key (gh-2257)
|
|
owner[ this.expando ] && owner[ this.expando ][ jQuery.camelCase( key ) ];
|
|
},
|
|
access: function( owner, key, value ) {
|
|
|
|
// In cases where either:
|
|
//
|
|
// 1. No key was specified
|
|
// 2. A string key was specified, but no value provided
|
|
//
|
|
// Take the "read" path and allow the get method to determine
|
|
// which value to return, respectively either:
|
|
//
|
|
// 1. The entire cache object
|
|
// 2. The data stored at the key
|
|
//
|
|
if ( key === undefined ||
|
|
( ( key && typeof key === "string" ) && value === undefined ) ) {
|
|
|
|
return this.get( owner, key );
|
|
}
|
|
|
|
// When the key is not a string, or both a key and value
|
|
// are specified, set or extend (existing objects) with either:
|
|
//
|
|
// 1. An object of properties
|
|
// 2. A key and value
|
|
//
|
|
this.set( owner, key, value );
|
|
|
|
// Since the "set" path can have two possible entry points
|
|
// return the expected data based on which path was taken[*]
|
|
return value !== undefined ? value : key;
|
|
},
|
|
remove: function( owner, key ) {
|
|
var i,
|
|
cache = owner[ this.expando ];
|
|
|
|
if ( cache === undefined ) {
|
|
return;
|
|
}
|
|
|
|
if ( key !== undefined ) {
|
|
|
|
// Support array or space separated string of keys
|
|
if ( Array.isArray( key ) ) {
|
|
|
|
// If key is an array of keys...
|
|
// We always set camelCase keys, so remove that.
|
|
key = key.map( jQuery.camelCase );
|
|
} else {
|
|
key = jQuery.camelCase( key );
|
|
|
|
// If a key with the spaces exists, use it.
|
|
// Otherwise, create an array by matching non-whitespace
|
|
key = key in cache ?
|
|
[ key ] :
|
|
( key.match( rnothtmlwhite ) || [] );
|
|
}
|
|
|
|
i = key.length;
|
|
|
|
while ( i-- ) {
|
|
delete cache[ key[ i ] ];
|
|
}
|
|
}
|
|
|
|
// Remove the expando if there's no more data
|
|
if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
|
|
|
|
// Support: Chrome <=35 - 45
|
|
// Webkit & Blink performance suffers when deleting properties
|
|
// from DOM nodes, so set to undefined instead
|
|
// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
|
|
if ( owner.nodeType ) {
|
|
owner[ this.expando ] = undefined;
|
|
} else {
|
|
delete owner[ this.expando ];
|
|
}
|
|
}
|
|
},
|
|
hasData: function( owner ) {
|
|
var cache = owner[ this.expando ];
|
|
return cache !== undefined && !jQuery.isEmptyObject( cache );
|
|
}
|
|
};
|
|
var dataPriv = new Data();
|
|
|
|
var dataUser = new Data();
|
|
|
|
|
|
|
|
// Implementation Summary
|
|
//
|
|
// 1. Enforce API surface and semantic compatibility with 1.9.x branch
|
|
// 2. Improve the module's maintainability by reducing the storage
|
|
// paths to a single mechanism.
|
|
// 3. Use the same single mechanism to support "private" and "user" data.
|
|
// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
|
|
// 5. Avoid exposing implementation details on user objects (eg. expando properties)
|
|
// 6. Provide a clear path for implementation upgrade to WeakMap in 2014
|
|
|
|
var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
|
|
rmultiDash = /[A-Z]/g;
|
|
|
|
function getData( data ) {
|
|
if ( data === "true" ) {
|
|
return true;
|
|
}
|
|
|
|
if ( data === "false" ) {
|
|
return false;
|
|
}
|
|
|
|
if ( data === "null" ) {
|
|
return null;
|
|
}
|
|
|
|
// Only convert to a number if it doesn't change the string
|
|
if ( data === +data + "" ) {
|
|
return +data;
|
|
}
|
|
|
|
if ( rbrace.test( data ) ) {
|
|
return JSON.parse( data );
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
function dataAttr( elem, key, data ) {
|
|
var name;
|
|
|
|
// If nothing was found internally, try to fetch any
|
|
// data from the HTML5 data-* attribute
|
|
if ( data === undefined && elem.nodeType === 1 ) {
|
|
name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
|
|
data = elem.getAttribute( name );
|
|
|
|
if ( typeof data === "string" ) {
|
|
try {
|
|
data = getData( data );
|
|
} catch ( e ) {}
|
|
|
|
// Make sure we set the data so it isn't changed later
|
|
dataUser.set( elem, key, data );
|
|
} else {
|
|
data = undefined;
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
|
|
jQuery.extend( {
|
|
hasData: function( elem ) {
|
|
return dataUser.hasData( elem ) || dataPriv.hasData( elem );
|
|
},
|
|
|
|
data: function( elem, name, data ) {
|
|
return dataUser.access( elem, name, data );
|
|
},
|
|
|
|
removeData: function( elem, name ) {
|
|
dataUser.remove( elem, name );
|
|
},
|
|
|
|
// TODO: Now that all calls to _data and _removeData have been replaced
|
|
// with direct calls to dataPriv methods, these can be deprecated.
|
|
_data: function( elem, name, data ) {
|
|
return dataPriv.access( elem, name, data );
|
|
},
|
|
|
|
_removeData: function( elem, name ) {
|
|
dataPriv.remove( elem, name );
|
|
}
|
|
} );
|
|
|
|
jQuery.fn.extend( {
|
|
data: function( key, value ) {
|
|
var i, name, data,
|
|
elem = this[ 0 ],
|
|
attrs = elem && elem.attributes;
|
|
|
|
// Gets all values
|
|
if ( key === undefined ) {
|
|
if ( this.length ) {
|
|
data = dataUser.get( elem );
|
|
|
|
if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
|
|
i = attrs.length;
|
|
while ( i-- ) {
|
|
|
|
// Support: IE 11 only
|
|
// The attrs elements can be null (#14894)
|
|
if ( attrs[ i ] ) {
|
|
name = attrs[ i ].name;
|
|
if ( name.indexOf( "data-" ) === 0 ) {
|
|
name = jQuery.camelCase( name.slice( 5 ) );
|
|
dataAttr( elem, name, data[ name ] );
|
|
}
|
|
}
|
|
}
|
|
dataPriv.set( elem, "hasDataAttrs", true );
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
// Sets multiple values
|
|
if ( typeof key === "object" ) {
|
|
return this.each( function() {
|
|
dataUser.set( this, key );
|
|
} );
|
|
}
|
|
|
|
return access( this, function( value ) {
|
|
var data;
|
|
|
|
// The calling jQuery object (element matches) is not empty
|
|
// (and therefore has an element appears at this[ 0 ]) and the
|
|
// `value` parameter was not undefined. An empty jQuery object
|
|
// will result in `undefined` for elem = this[ 0 ] which will
|
|
// throw an exception if an attempt to read a data cache is made.
|
|
if ( elem && value === undefined ) {
|
|
|
|
// Attempt to get data from the cache
|
|
// The key will always be camelCased in Data
|
|
data = dataUser.get( elem, key );
|
|
if ( data !== undefined ) {
|
|
return data;
|
|
}
|
|
|
|
// Attempt to "discover" the data in
|
|
// HTML5 custom data-* attrs
|
|
data = dataAttr( elem, key );
|
|
if ( data !== undefined ) {
|
|
return data;
|
|
}
|
|
|
|
// We tried really hard, but the data doesn't exist.
|
|
return;
|
|
}
|
|
|
|
// Set the data...
|
|
this.each( function() {
|
|
|
|
// We always store the camelCased key
|
|
dataUser.set( this, key, value );
|
|
} );
|
|
}, null, value, arguments.length > 1, null, true );
|
|
},
|
|
|
|
removeData: function( key ) {
|
|
return this.each( function() {
|
|
dataUser.remove( this, key );
|
|
} );
|
|
}
|
|
} );
|
|
|
|
|
|
jQuery.extend( {
|
|
queue: function( elem, type, data ) {
|
|
var queue;
|
|
|
|
if ( elem ) {
|
|
type = ( type || "fx" ) + "queue";
|
|
queue = dataPriv.get( elem, type );
|
|
|
|
// Speed up dequeue by getting out quickly if this is just a lookup
|
|
if ( data ) {
|
|
if ( !queue || Array.isArray( data ) ) {
|
|
queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
|
|
} else {
|
|
queue.push( data );
|
|
}
|
|
}
|
|
return queue || [];
|
|
}
|
|
},
|
|
|
|
dequeue: function( elem, type ) {
|
|
type = type || "fx";
|
|
|
|
var queue = jQuery.queue( elem, type ),
|
|
startLength = queue.length,
|
|
fn = queue.shift(),
|
|
hooks = jQuery._queueHooks( elem, type ),
|
|
next = function() {
|
|
jQuery.dequeue( elem, type );
|
|
};
|
|
|
|
// If the fx queue is dequeued, always remove the progress sentinel
|
|
if ( fn === "inprogress" ) {
|
|
fn = queue.shift();
|
|
startLength--;
|
|
}
|
|
|
|
if ( fn ) {
|
|
|
|
// Add a progress sentinel to prevent the fx queue from being
|
|
// automatically dequeued
|
|
if ( type === "fx" ) {
|
|
queue.unshift( "inprogress" );
|
|
}
|
|
|
|
// Clear up the last queue stop function
|
|
delete hooks.stop;
|
|
fn.call( elem, next, hooks );
|
|
}
|
|
|
|
if ( !startLength && hooks ) {
|
|
hooks.empty.fire();
|
|
}
|
|
},
|
|
|
|
// Not public - generate a queueHooks object, or return the current one
|
|
_queueHooks: function( elem, type ) {
|
|
var key = type + "queueHooks";
|
|
return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
|
|
empty: jQuery.Callbacks( "once memory" ).add( function() {
|
|
dataPriv.remove( elem, [ type + "queue", key ] );
|
|
} )
|
|
} );
|
|
}
|
|
} );
|
|
|
|
jQuery.fn.extend( {
|
|
queue: function( type, data ) {
|
|
var setter = 2;
|
|
|
|
if ( typeof type !== "string" ) {
|
|
data = type;
|
|
type = "fx";
|
|
setter--;
|
|
}
|
|
|
|
if ( arguments.length < setter ) {
|
|
return jQuery.queue( this[ 0 ], type );
|
|
}
|
|
|
|
return data === undefined ?
|
|
this :
|
|
this.each( function() {
|
|
var queue = jQuery.queue( this, type, data );
|
|
|
|
// Ensure a hooks for this queue
|
|
jQuery._queueHooks( this, type );
|
|
|
|
if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
|
|
jQuery.dequeue( this, type );
|
|
}
|
|
} );
|
|
},
|
|
dequeue: function( type ) {
|
|
return this.each( function() {
|
|
jQuery.dequeue( this, type );
|
|
} );
|
|
},
|
|
clearQueue: function( type ) {
|
|
return this.queue( type || "fx", [] );
|
|
},
|
|
|
|
// Get a promise resolved when queues of a certain type
|
|
// are emptied (fx is the type by default)
|
|
promise: function( type, obj ) {
|
|
var tmp,
|
|
count = 1,
|
|
defer = jQuery.Deferred(),
|
|
elements = this,
|
|
i = this.length,
|
|
resolve = function() {
|
|
if ( !( --count ) ) {
|
|
defer.resolveWith( elements, [ elements ] );
|
|
}
|
|
};
|
|
|
|
if ( typeof type !== "string" ) {
|
|
obj = type;
|
|
type = undefined;
|
|
}
|
|
type = type || "fx";
|
|
|
|
while ( i-- ) {
|
|
tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
|
|
if ( tmp && tmp.empty ) {
|
|
count++;
|
|
tmp.empty.add( resolve );
|
|
}
|
|
}
|
|
resolve();
|
|
return defer.promise( obj );
|
|
}
|
|
} );
|
|
var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
|
|
|
|
var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
|
|
|
|
|
|
var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
|
|
|
|
var isHiddenWithinTree = function( elem, el ) {
|
|
|
|
// isHiddenWithinTree might be called from jQuery#filter function;
|
|
// in that case, element will be second argument
|
|
elem = el || elem;
|
|
|
|
// Inline style trumps all
|
|
return elem.style.display === "none" ||
|
|
elem.style.display === "" &&
|
|
|
|
// Otherwise, check computed style
|
|
// Support: Firefox <=43 - 45
|
|
// Disconnected elements can have computed display: none, so first confirm that elem is
|
|
// in the document.
|
|
jQuery.contains( elem.ownerDocument, elem ) &&
|
|
|
|
jQuery.css( elem, "display" ) === "none";
|
|
};
|
|
|
|
var swap = function( elem, options, callback, args ) {
|
|
var ret, name,
|
|
old = {};
|
|
|
|
// Remember the old values, and insert the new ones
|
|
for ( name in options ) {
|
|
old[ name ] = elem.style[ name ];
|
|
elem.style[ name ] = options[ name ];
|
|
}
|
|
|
|
ret = callback.apply( elem, args || [] );
|
|
|
|
// Revert the old values
|
|
for ( name in options ) {
|
|
elem.style[ name ] = old[ name ];
|
|
}
|
|
|
|
return ret;
|
|
};
|
|
|
|
|
|
|
|
|
|
function adjustCSS( elem, prop, valueParts, tween ) {
|
|
var adjusted,
|
|
scale = 1,
|
|
maxIterations = 20,
|
|
currentValue = tween ?
|
|
function() {
|
|
return tween.cur();
|
|
} :
|
|
function() {
|
|
return jQuery.css( elem, prop, "" );
|
|
},
|
|
initial = currentValue(),
|
|
unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
|
|
|
|
// Starting value computation is required for potential unit mismatches
|
|
initialInUnit = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
|
|
rcssNum.exec( jQuery.css( elem, prop ) );
|
|
|
|
if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
|
|
|
|
// Trust units reported by jQuery.css
|
|
unit = unit || initialInUnit[ 3 ];
|
|
|
|
// Make sure we update the tween properties later on
|
|
valueParts = valueParts || [];
|
|
|
|
// Iteratively approximate from a nonzero starting point
|
|
initialInUnit = +initial || 1;
|
|
|
|
do {
|
|
|
|
// If previous iteration zeroed out, double until we get *something*.
|
|
// Use string for doubling so we don't accidentally see scale as unchanged below
|
|
scale = scale || ".5";
|
|
|
|
// Adjust and apply
|
|
initialInUnit = initialInUnit / scale;
|
|
jQuery.style( elem, prop, initialInUnit + unit );
|
|
|
|
// Update scale, tolerating zero or NaN from tween.cur()
|
|
// Break the loop if scale is unchanged or perfect, or if we've just had enough.
|
|
} while (
|
|
scale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations
|
|
);
|
|
}
|
|
|
|
if ( valueParts ) {
|
|
initialInUnit = +initialInUnit || +initial || 0;
|
|
|
|
// Apply relative offset (+=/-=) if specified
|
|
adjusted = valueParts[ 1 ] ?
|
|
initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
|
|
+valueParts[ 2 ];
|
|
if ( tween ) {
|
|
tween.unit = unit;
|
|
tween.start = initialInUnit;
|
|
tween.end = adjusted;
|
|
}
|
|
}
|
|
return adjusted;
|
|
}
|
|
|
|
|
|
var defaultDisplayMap = {};
|
|
|
|
function getDefaultDisplay( elem ) {
|
|
var temp,
|
|
doc = elem.ownerDocument,
|
|
nodeName = elem.nodeName,
|
|
display = defaultDisplayMap[ nodeName ];
|
|
|
|
if ( display ) {
|
|
return display;
|
|
}
|
|
|
|
temp = doc.body.appendChild( doc.createElement( nodeName ) );
|
|
display = jQuery.css( temp, "display" );
|
|
|
|
temp.parentNode.removeChild( temp );
|
|
|
|
if ( display === "none" ) {
|
|
display = "block";
|
|
}
|
|
defaultDisplayMap[ nodeName ] = display;
|
|
|
|
return display;
|
|
}
|
|
|
|
function showHide( elements, show ) {
|
|
var display, elem,
|
|
values = [],
|
|
index = 0,
|
|
length = elements.length;
|
|
|
|
// Determine new display value for elements that need to change
|
|
for ( ; index < length; index++ ) {
|
|
elem = elements[ index ];
|
|
if ( !elem.style ) {
|
|
continue;
|
|
}
|
|
|
|
display = elem.style.display;
|
|
if ( show ) {
|
|
|
|
// Since we force visibility upon cascade-hidden elements, an immediate (and slow)
|
|
// check is required in this first loop unless we have a nonempty display value (either
|
|
// inline or about-to-be-restored)
|
|
if ( display === "none" ) {
|
|
values[ index ] = dataPriv.get( elem, "display" ) || null;
|
|
if ( !values[ index ] ) {
|
|
elem.style.display = "";
|
|
}
|
|
}
|
|
if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
|
|
values[ index ] = getDefaultDisplay( elem );
|
|
}
|
|
} else {
|
|
if ( display !== "none" ) {
|
|
values[ index ] = "none";
|
|
|
|
// Remember what we're overwriting
|
|
dataPriv.set( elem, "display", display );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set the display of the elements in a second loop to avoid constant reflow
|
|
for ( index = 0; index < length; index++ ) {
|
|
if ( values[ index ] != null ) {
|
|
elements[ index ].style.display = values[ index ];
|
|
}
|
|
}
|
|
|
|
return elements;
|
|
}
|
|
|
|
jQuery.fn.extend( {
|
|
show: function() {
|
|
return showHide( this, true );
|
|
},
|
|
hide: function() {
|
|
return showHide( this );
|
|
},
|
|
toggle: function( state ) {
|
|
if ( typeof state === "boolean" ) {
|
|
return state ? this.show() : this.hide();
|
|
}
|
|
|
|
return this.each( function() {
|
|
if ( isHiddenWithinTree( this ) ) {
|
|
jQuery( this ).show();
|
|
} else {
|
|
jQuery( this ).hide();
|
|
}
|
|
} );
|
|
}
|
|
} );
|
|
var rcheckableType = ( /^(?:checkbox|radio)$/i );
|
|
|
|
var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]+)/i );
|
|
|
|
var rscriptType = ( /^$|\/(?:java|ecma)script/i );
|
|
|
|
|
|
|
|
// We have to close these tags to support XHTML (#13200)
|
|
var wrapMap = {
|
|
|
|
// Support: IE <=9 only
|
|
option: [ 1, "<select multiple='multiple'>", "</select>" ],
|
|
|
|
// XHTML parsers do not magically insert elements in the
|
|
// same way that tag soup parsers do. So we cannot shorten
|
|
// this by omitting <tbody> or other required elements.
|
|
thead: [ 1, "<table>", "</table>" ],
|
|
col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
|
|
tr: [ 2, "<table><tbody>", "</tbody></table>" ],
|
|
td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
|
|
|
|
_default: [ 0, "", "" ]
|
|
};
|
|
|
|
// Support: IE <=9 only
|
|
wrapMap.optgroup = wrapMap.option;
|
|
|
|
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
|
|
wrapMap.th = wrapMap.td;
|
|
|
|
|
|
function getAll( context, tag ) {
|
|
|
|
// Support: IE <=9 - 11 only
|
|
// Use typeof to avoid zero-argument method invocation on host objects (#15151)
|
|
var ret;
|
|
|
|
if ( typeof context.getElementsByTagName !== "undefined" ) {
|
|
ret = context.getElementsByTagName( tag || "*" );
|
|
|
|
} else if ( typeof context.querySelectorAll !== "undefined" ) {
|
|
ret = context.querySelectorAll( tag || "*" );
|
|
|
|
} else {
|
|
ret = [];
|
|
}
|
|
|
|
if ( tag === undefined || tag && nodeName( context, tag ) ) {
|
|
return jQuery.merge( [ context ], ret );
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
// Mark scripts as having already been evaluated
|
|
function setGlobalEval( elems, refElements ) {
|
|
var i = 0,
|
|
l = elems.length;
|
|
|
|
for ( ; i < l; i++ ) {
|
|
dataPriv.set(
|
|
elems[ i ],
|
|
"globalEval",
|
|
!refElements || dataPriv.get( refElements[ i ], "globalEval" )
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
var rhtml = /<|&#?\w+;/;
|
|
|
|
function buildFragment( elems, context, scripts, selection, ignored ) {
|
|
var elem, tmp, tag, wrap, contains, j,
|
|
fragment = context.createDocumentFragment(),
|
|
nodes = [],
|
|
i = 0,
|
|
l = elems.length;
|
|
|
|
for ( ; i < l; i++ ) {
|
|
elem = elems[ i ];
|
|
|
|
if ( elem || elem === 0 ) {
|
|
|
|
// Add nodes directly
|
|
if ( jQuery.type( elem ) === "object" ) {
|
|
|
|
// Support: Android <=4.0 only, PhantomJS 1 only
|
|
// push.apply(_, arraylike) throws on ancient WebKit
|
|
jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
|
|
|
|
// Convert non-html into a text node
|
|
} else if ( !rhtml.test( elem ) ) {
|
|
nodes.push( context.createTextNode( elem ) );
|
|
|
|
// Convert html into DOM nodes
|
|
} else {
|
|
tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
|
|
|
|
// Deserialize a standard representation
|
|
tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
|
|
wrap = wrapMap[ tag ] || wrapMap._default;
|
|
tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
|
|
|
|
// Descend through wrappers to the right content
|
|
j = wrap[ 0 ];
|
|
while ( j-- ) {
|
|
tmp = tmp.lastChild;
|
|
}
|
|
|
|
// Support: Android <=4.0 only, PhantomJS 1 only
|
|
// push.apply(_, arraylike) throws on ancient WebKit
|
|
jQuery.merge( nodes, tmp.childNodes );
|
|
|
|
// Remember the top-level container
|
|
tmp = fragment.firstChild;
|
|
|
|
// Ensure the created nodes are orphaned (#12392)
|
|
tmp.textContent = "";
|
|
}
|
|
}
|
|
}
|
|
|
|
// Remove wrapper from fragment
|
|
fragment.textContent = "";
|
|
|
|
i = 0;
|
|
while ( ( elem = nodes[ i++ ] ) ) {
|
|
|
|
// Skip elements already in the context collection (trac-4087)
|
|
if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
|
|
if ( ignored ) {
|
|
ignored.push( elem );
|
|
}
|
|
continue;
|
|
}
|
|
|
|
contains = jQuery.contains( elem.ownerDocument, elem );
|
|
|
|
// Append to fragment
|
|
tmp = getAll( fragment.appendChild( elem ), "script" );
|
|
|
|
// Preserve script evaluation history
|
|
if ( contains ) {
|
|
setGlobalEval( tmp );
|
|
}
|
|
|
|
// Capture executables
|
|
if ( scripts ) {
|
|
j = 0;
|
|
while ( ( elem = tmp[ j++ ] ) ) {
|
|
if ( rscriptType.test( elem.type || "" ) ) {
|
|
scripts.push( elem );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return fragment;
|
|
}
|
|
|
|
|
|
( function() {
|
|
var fragment = document.createDocumentFragment(),
|
|
div = fragment.appendChild( document.createElement( "div" ) ),
|
|
input = document.createElement( "input" );
|
|
|
|
// Support: Android 4.0 - 4.3 only
|
|
// Check state lost if the name is set (#11217)
|
|
// Support: Windows Web Apps (WWA)
|
|
// `name` and `type` must use .setAttribute for WWA (#14901)
|
|
input.setAttribute( "type", "radio" );
|
|
input.setAttribute( "checked", "checked" );
|
|
input.setAttribute( "name", "t" );
|
|
|
|
div.appendChild( input );
|
|
|
|
// Support: Android <=4.1 only
|
|
// Older WebKit doesn't clone checked state correctly in fragments
|
|
support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
|
|
|
|
// Support: IE <=11 only
|
|
// Make sure textarea (and checkbox) defaultValue is properly cloned
|
|
div.innerHTML = "<textarea>x</textarea>";
|
|
support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
|
|
} )();
|
|
var documentElement = document.documentElement;
|
|
|
|
|
|
|
|
var
|
|
rkeyEvent = /^key/,
|
|
rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
|
|
rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
|
|
|
|
function returnTrue() {
|
|
return true;
|
|
}
|
|
|
|
function returnFalse() {
|
|
return false;
|
|
}
|
|
|
|
// Support: IE <=9 only
|
|
// See #13393 for more info
|
|
function safeActiveElement() {
|
|
try {
|
|
return document.activeElement;
|
|
} catch ( err ) { }
|
|
}
|
|
|
|
function on( elem, types, selector, data, fn, one ) {
|
|
var origFn, type;
|
|
|
|
// Types can be a map of types/handlers
|
|
if ( typeof types === "object" ) {
|
|
|
|
// ( types-Object, selector, data )
|
|
if ( typeof selector !== "string" ) {
|
|
|
|
// ( types-Object, data )
|
|
data = data || selector;
|
|
selector = undefined;
|
|
}
|
|
for ( type in types ) {
|
|
on( elem, type, selector, data, types[ type ], one );
|
|
}
|
|
return elem;
|
|
}
|
|
|
|
if ( data == null && fn == null ) {
|
|
|
|
// ( types, fn )
|
|
fn = selector;
|
|
data = selector = undefined;
|
|
} else if ( fn == null ) {
|
|
if ( typeof selector === "string" ) {
|
|
|
|
// ( types, selector, fn )
|
|
fn = data;
|
|
data = undefined;
|
|
} else {
|
|
|
|
// ( types, data, fn )
|
|
fn = data;
|
|
data = selector;
|
|
selector = undefined;
|
|
}
|
|
}
|
|
if ( fn === false ) {
|
|
fn = returnFalse;
|
|
} else if ( !fn ) {
|
|
return elem;
|
|
}
|
|
|
|
if ( one === 1 ) {
|
|
origFn = fn;
|
|
fn = function( event ) {
|
|
|
|
// Can use an empty set, since event contains the info
|
|
jQuery().off( event );
|
|
return origFn.apply( this, arguments );
|
|
};
|
|
|
|
// Use same guid so caller can remove using origFn
|
|
fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
|
|
}
|
|
return elem.each( function() {
|
|
jQuery.event.add( this, types, fn, data, selector );
|
|
} );
|
|
}
|
|
|
|
/*
|
|
* Helper functions for managing events -- not part of the public interface.
|
|
* Props to Dean Edwards' addEvent library for many of the ideas.
|
|
*/
|
|
jQuery.event = {
|
|
|
|
global: {},
|
|
|
|
add: function( elem, types, handler, data, selector ) {
|
|
|
|
var handleObjIn, eventHandle, tmp,
|
|
events, t, handleObj,
|
|
special, handlers, type, namespaces, origType,
|
|
elemData = dataPriv.get( elem );
|
|
|
|
// Don't attach events to noData or text/comment nodes (but allow plain objects)
|
|
if ( !elemData ) {
|
|
return;
|
|
}
|
|
|
|
// Caller can pass in an object of custom data in lieu of the handler
|
|
if ( handler.handler ) {
|
|
handleObjIn = handler;
|
|
handler = handleObjIn.handler;
|
|
selector = handleObjIn.selector;
|
|
}
|
|
|
|
// Ensure that invalid selectors throw exceptions at attach time
|
|
// Evaluate against documentElement in case elem is a non-element node (e.g., document)
|
|
if ( selector ) {
|
|
jQuery.find.matchesSelector( documentElement, selector );
|
|
}
|
|
|
|
// Make sure that the handler has a unique ID, used to find/remove it later
|
|
if ( !handler.guid ) {
|
|
handler.guid = jQuery.guid++;
|
|
}
|
|
|
|
// Init the element's event structure and main handler, if this is the first
|
|
if ( !( events = elemData.events ) ) {
|
|
events = elemData.events = {};
|
|
}
|
|
if ( !( eventHandle = elemData.handle ) ) {
|
|
eventHandle = elemData.handle = function( e ) {
|
|
|
|
// Discard the second event of a jQuery.event.trigger() and
|
|
// when an event is called after a page has unloaded
|
|
return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
|
|
jQuery.event.dispatch.apply( elem, arguments ) : undefined;
|
|
};
|
|
}
|
|
|
|
// Handle multiple events separated by a space
|
|
types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
|
|
t = types.length;
|
|
while ( t-- ) {
|
|
tmp = rtypenamespace.exec( types[ t ] ) || [];
|
|
type = origType = tmp[ 1 ];
|
|
namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
|
|
|
|
// There *must* be a type, no attaching namespace-only handlers
|
|
if ( !type ) {
|
|
continue;
|
|
}
|
|
|
|
// If event changes its type, use the special event handlers for the changed type
|
|
special = jQuery.event.special[ type ] || {};
|
|
|
|
// If selector defined, determine special event api type, otherwise given type
|
|
type = ( selector ? special.delegateType : special.bindType ) || type;
|
|
|
|
// Update special based on newly reset type
|
|
special = jQuery.event.special[ type ] || {};
|
|
|
|
// handleObj is passed to all event handlers
|
|
handleObj = jQuery.extend( {
|
|
type: type,
|
|
origType: origType,
|
|
data: data,
|
|
handler: handler,
|
|
guid: handler.guid,
|
|
selector: selector,
|
|
needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
|
|
namespace: namespaces.join( "." )
|
|
}, handleObjIn );
|
|
|
|
// Init the event handler queue if we're the first
|
|
if ( !( handlers = events[ type ] ) ) {
|
|
handlers = events[ type ] = [];
|
|
handlers.delegateCount = 0;
|
|
|
|
// Only use addEventListener if the special events handler returns false
|
|
if ( !special.setup ||
|
|
special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
|
|
|
|
if ( elem.addEventListener ) {
|
|
elem.addEventListener( type, eventHandle );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( special.add ) {
|
|
special.add.call( elem, handleObj );
|
|
|
|
if ( !handleObj.handler.guid ) {
|
|
handleObj.handler.guid = handler.guid;
|
|
}
|
|
}
|
|
|
|
// Add to the element's handler list, delegates in front
|
|
if ( selector ) {
|
|
handlers.splice( handlers.delegateCount++, 0, handleObj );
|
|
} else {
|
|
handlers.push( handleObj );
|
|
}
|
|
|
|
// Keep track of which events have ever been used, for event optimization
|
|
jQuery.event.global[ type ] = true;
|
|
}
|
|
|
|
},
|
|
|
|
// Detach an event or set of events from an element
|
|
remove: function( elem, types, handler, selector, mappedTypes ) {
|
|
|
|
var j, origCount, tmp,
|
|
events, t, handleObj,
|
|
special, handlers, type, namespaces, origType,
|
|
elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
|
|
|
|
if ( !elemData || !( events = elemData.events ) ) {
|
|
return;
|
|
}
|
|
|
|
// Once for each type.namespace in types; type may be omitted
|
|
types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
|
|
t = types.length;
|
|
while ( t-- ) {
|
|
tmp = rtypenamespace.exec( types[ t ] ) || [];
|
|
type = origType = tmp[ 1 ];
|
|
namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
|
|
|
|
// Unbind all events (on this namespace, if provided) for the element
|
|
if ( !type ) {
|
|
for ( type in events ) {
|
|
jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
|
|
}
|
|
continue;
|
|
}
|
|
|
|
special = jQuery.event.special[ type ] || {};
|
|
type = ( selector ? special.delegateType : special.bindType ) || type;
|
|
handlers = events[ type ] || [];
|
|
tmp = tmp[ 2 ] &&
|
|
new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
|
|
|
|
// Remove matching events
|
|
origCount = j = handlers.length;
|
|
while ( j-- ) {
|
|
handleObj = handlers[ j ];
|
|
|
|
if ( ( mappedTypes || origType === handleObj.origType ) &&
|
|
( !handler || handler.guid === handleObj.guid ) &&
|
|
( !tmp || tmp.test( handleObj.namespace ) ) &&
|
|
( !selector || selector === handleObj.selector ||
|
|
selector === "**" && handleObj.selector ) ) {
|
|
handlers.splice( j, 1 );
|
|
|
|
if ( handleObj.selector ) {
|
|
handlers.delegateCount--;
|
|
}
|
|
if ( special.remove ) {
|
|
special.remove.call( elem, handleObj );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Remove generic event handler if we removed something and no more handlers exist
|
|
// (avoids potential for endless recursion during removal of special event handlers)
|
|
if ( origCount && !handlers.length ) {
|
|
if ( !special.teardown ||
|
|
special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
|
|
|
|
jQuery.removeEvent( elem, type, elemData.handle );
|
|
}
|
|
|
|
delete events[ type ];
|
|
}
|
|
}
|
|
|
|
// Remove data and the expando if it's no longer used
|
|
if ( jQuery.isEmptyObject( events ) ) {
|
|
dataPriv.remove( elem, "handle events" );
|
|
}
|
|
},
|
|
|
|
dispatch: function( nativeEvent ) {
|
|
|
|
// Make a writable jQuery.Event from the native event object
|
|
var event = jQuery.event.fix( nativeEvent );
|
|
|
|
var i, j, ret, matched, handleObj, handlerQueue,
|
|
args = new Array( arguments.length ),
|
|
handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [],
|
|
special = jQuery.event.special[ event.type ] || {};
|
|
|
|
// Use the fix-ed jQuery.Event rather than the (read-only) native event
|
|
args[ 0 ] = event;
|
|
|
|
for ( i = 1; i < arguments.length; i++ ) {
|
|
args[ i ] = arguments[ i ];
|
|
}
|
|
|
|
event.delegateTarget = this;
|
|
|
|
// Call the preDispatch hook for the mapped type, and let it bail if desired
|
|
if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
|
|
return;
|
|
}
|
|
|
|
// Determine handlers
|
|
handlerQueue = jQuery.event.handlers.call( this, event, handlers );
|
|
|
|
// Run delegates first; they may want to stop propagation beneath us
|
|
i = 0;
|
|
while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
|
|
event.currentTarget = matched.elem;
|
|
|
|
j = 0;
|
|
while ( ( handleObj = matched.handlers[ j++ ] ) &&
|
|
!event.isImmediatePropagationStopped() ) {
|
|
|
|
// Triggered event must either 1) have no namespace, or 2) have namespace(s)
|
|
// a subset or equal to those in the bound event (both can have no namespace).
|
|
if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {
|
|
|
|
event.handleObj = handleObj;
|
|
event.data = handleObj.data;
|
|
|
|
ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
|
|
handleObj.handler ).apply( matched.elem, args );
|
|
|
|
if ( ret !== undefined ) {
|
|
if ( ( event.result = ret ) === false ) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Call the postDispatch hook for the mapped type
|
|
if ( special.postDispatch ) {
|
|
special.postDispatch.call( this, event );
|
|
}
|
|
|
|
return event.result;
|
|
},
|
|
|
|
handlers: function( event, handlers ) {
|
|
var i, handleObj, sel, matchedHandlers, matchedSelectors,
|
|
handlerQueue = [],
|
|
delegateCount = handlers.delegateCount,
|
|
cur = event.target;
|
|
|
|
// Find delegate handlers
|
|
if ( delegateCount &&
|
|
|
|
// Support: IE <=9
|
|
// Black-hole SVG <use> instance trees (trac-13180)
|
|
cur.nodeType &&
|
|
|
|
// Support: Firefox <=42
|
|
// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
|
|
// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
|
|
// Support: IE 11 only
|
|
// ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
|
|
!( event.type === "click" && event.button >= 1 ) ) {
|
|
|
|
for ( ; cur !== this; cur = cur.parentNode || this ) {
|
|
|
|
// Don't check non-elements (#13208)
|
|
// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
|
|
if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
|
|
matchedHandlers = [];
|
|
matchedSelectors = {};
|
|
for ( i = 0; i < delegateCount; i++ ) {
|
|
handleObj = handlers[ i ];
|
|
|
|
// Don't conflict with Object.prototype properties (#13203)
|
|
sel = handleObj.selector + " ";
|
|
|
|
if ( matchedSelectors[ sel ] === undefined ) {
|
|
matchedSelectors[ sel ] = handleObj.needsContext ?
|
|
jQuery( sel, this ).index( cur ) > -1 :
|
|
jQuery.find( sel, this, null, [ cur ] ).length;
|
|
}
|
|
if ( matchedSelectors[ sel ] ) {
|
|
matchedHandlers.push( handleObj );
|
|
}
|
|
}
|
|
if ( matchedHandlers.length ) {
|
|
handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add the remaining (directly-bound) handlers
|
|
cur = this;
|
|
if ( delegateCount < handlers.length ) {
|
|
handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
|
|
}
|
|
|
|
return handlerQueue;
|
|
},
|
|
|
|
addProp: function( name, hook ) {
|
|
Object.defineProperty( jQuery.Event.prototype, name, {
|
|
enumerable: true,
|
|
configurable: true,
|
|
|
|
get: jQuery.isFunction( hook ) ?
|
|
function() {
|
|
if ( this.originalEvent ) {
|
|
return hook( this.originalEvent );
|
|
}
|
|
} :
|
|
function() {
|
|
if ( this.originalEvent ) {
|
|
return this.originalEvent[ name ];
|
|
}
|
|
},
|
|
|
|
set: function( value ) {
|
|
Object.defineProperty( this, name, {
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true,
|
|
value: value
|
|
} );
|
|
}
|
|
} );
|
|
},
|
|
|
|
fix: function( originalEvent ) {
|
|
return originalEvent[ jQuery.expando ] ?
|
|
originalEvent :
|
|
new jQuery.Event( originalEvent );
|
|
},
|
|
|
|
special: {
|
|
load: {
|
|
|
|
// Prevent triggered image.load events from bubbling to window.load
|
|
noBubble: true
|
|
},
|
|
focus: {
|
|
|
|
// Fire native event if possible so blur/focus sequence is correct
|
|
trigger: function() {
|
|
if ( this !== safeActiveElement() && this.focus ) {
|
|
this.focus();
|
|
return false;
|
|
}
|
|
},
|
|
delegateType: "focusin"
|
|
},
|
|
blur: {
|
|
trigger: function() {
|
|
if ( this === safeActiveElement() && this.blur ) {
|
|
this.blur();
|
|
return false;
|
|
}
|
|
},
|
|
delegateType: "focusout"
|
|
},
|
|
click: {
|
|
|
|
// For checkbox, fire native event so checked state will be right
|
|
trigger: function() {
|
|
if ( this.type === "checkbox" && this.click && nodeName( this, "input" ) ) {
|
|
this.click();
|
|
return false;
|
|
}
|
|
},
|
|
|
|
// For cross-browser consistency, don't fire native .click() on links
|
|
_default: function( event ) {
|
|
return nodeName( event.target, "a" );
|
|
}
|
|
},
|
|
|
|
beforeunload: {
|
|
postDispatch: function( event ) {
|
|
|
|
// Support: Firefox 20+
|
|
// Firefox doesn't alert if the returnValue field is not set.
|
|
if ( event.result !== undefined && event.originalEvent ) {
|
|
event.originalEvent.returnValue = event.result;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
jQuery.removeEvent = function( elem, type, handle ) {
|
|
|
|
// This "if" is needed for plain objects
|
|
if ( elem.removeEventListener ) {
|
|
elem.removeEventListener( type, handle );
|
|
}
|
|
};
|
|
|
|
jQuery.Event = function( src, props ) {
|
|
|
|
// Allow instantiation without the 'new' keyword
|
|
if ( !( this instanceof jQuery.Event ) ) {
|
|
return new jQuery.Event( src, props );
|
|
}
|
|
|
|
// Event object
|
|
if ( src && src.type ) {
|
|
this.originalEvent = src;
|
|
this.type = src.type;
|
|
|
|
// Events bubbling up the document may have been marked as prevented
|
|
// by a handler lower down the tree; reflect the correct value.
|
|
this.isDefaultPrevented = src.defaultPrevented ||
|
|
src.defaultPrevented === undefined &&
|
|
|
|
// Support: Android <=2.3 only
|
|
src.returnValue === false ?
|
|
returnTrue :
|
|
returnFalse;
|
|
|
|
// Create target properties
|
|
// Support: Safari <=6 - 7 only
|
|
// Target should not be a text node (#504, #13143)
|
|
this.target = ( src.target && src.target.nodeType === 3 ) ?
|
|
src.target.parentNode :
|
|
src.target;
|
|
|
|
this.currentTarget = src.currentTarget;
|
|
this.relatedTarget = src.relatedTarget;
|
|
|
|
// Event type
|
|
} else {
|
|
this.type = src;
|
|
}
|
|
|
|
// Put explicitly provided properties onto the event object
|
|
if ( props ) {
|
|
jQuery.extend( this, props );
|
|
}
|
|
|
|
// Create a timestamp if incoming event doesn't have one
|
|
this.timeStamp = src && src.timeStamp || jQuery.now();
|
|
|
|
// Mark it as fixed
|
|
this[ jQuery.expando ] = true;
|
|
};
|
|
|
|
// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
|
|
// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
|
|
jQuery.Event.prototype = {
|
|
constructor: jQuery.Event,
|
|
isDefaultPrevented: returnFalse,
|
|
isPropagationStopped: returnFalse,
|
|
isImmediatePropagationStopped: returnFalse,
|
|
isSimulated: false,
|
|
|
|
preventDefault: function() {
|
|
var e = this.originalEvent;
|
|
|
|
this.isDefaultPrevented = returnTrue;
|
|
|
|
if ( e && !this.isSimulated ) {
|
|
e.preventDefault();
|
|
}
|
|
},
|
|
stopPropagation: function() {
|
|
var e = this.originalEvent;
|
|
|
|
this.isPropagationStopped = returnTrue;
|
|
|
|
if ( e && !this.isSimulated ) {
|
|
e.stopPropagation();
|
|
}
|
|
},
|
|
stopImmediatePropagation: function() {
|
|
var e = this.originalEvent;
|
|
|
|
this.isImmediatePropagationStopped = returnTrue;
|
|
|
|
if ( e && !this.isSimulated ) {
|
|
e.stopImmediatePropagation();
|
|
}
|
|
|
|
this.stopPropagation();
|
|
}
|
|
};
|
|
|
|
// Includes all common event props including KeyEvent and MouseEvent specific props
|
|
jQuery.each( {
|
|
altKey: true,
|
|
bubbles: true,
|
|
cancelable: true,
|
|
changedTouches: true,
|
|
ctrlKey: true,
|
|
detail: true,
|
|
eventPhase: true,
|
|
metaKey: true,
|
|
pageX: true,
|
|
pageY: true,
|
|
shiftKey: true,
|
|
view: true,
|
|
"char": true,
|
|
charCode: true,
|
|
key: true,
|
|
keyCode: true,
|
|
button: true,
|
|
buttons: true,
|
|
clientX: true,
|
|
clientY: true,
|
|
offsetX: true,
|
|
offsetY: true,
|
|
pointerId: true,
|
|
pointerType: true,
|
|
screenX: true,
|
|
screenY: true,
|
|
targetTouches: true,
|
|
toElement: true,
|
|
touches: true,
|
|
|
|
which: function( event ) {
|
|
var button = event.button;
|
|
|
|
// Add which for key events
|
|
if ( event.which == null && rkeyEvent.test( event.type ) ) {
|
|
return event.charCode != null ? event.charCode : event.keyCode;
|
|
}
|
|
|
|
// Add which for click: 1 === left; 2 === middle; 3 === right
|
|
if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {
|
|
if ( button & 1 ) {
|
|
return 1;
|
|
}
|
|
|
|
if ( button & 2 ) {
|
|
return 3;
|
|
}
|
|
|
|
if ( button & 4 ) {
|
|
return 2;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
return event.which;
|
|
}
|
|
}, jQuery.event.addProp );
|
|
|
|
// Create mouseenter/leave events using mouseover/out and event-time checks
|
|
// so that event delegation works in jQuery.
|
|
// Do the same for pointerenter/pointerleave and pointerover/pointerout
|
|
//
|
|
// Support: Safari 7 only
|
|
// Safari sends mouseenter too often; see:
|
|
// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
|
|
// for the description of the bug (it existed in older Chrome versions as well).
|
|
jQuery.each( {
|
|
mouseenter: "mouseover",
|
|
mouseleave: "mouseout",
|
|
pointerenter: "pointerover",
|
|
pointerleave: "pointerout"
|
|
}, function( orig, fix ) {
|
|
jQuery.event.special[ orig ] = {
|
|
delegateType: fix,
|
|
bindType: fix,
|
|
|
|
handle: function( event ) {
|
|
var ret,
|
|
target = this,
|
|
related = event.relatedTarget,
|
|
handleObj = event.handleObj;
|
|
|
|
// For mouseenter/leave call the handler if related is outside the target.
|
|
// NB: No relatedTarget if the mouse left/entered the browser window
|
|
if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
|
|
event.type = handleObj.origType;
|
|
ret = handleObj.handler.apply( this, arguments );
|
|
event.type = fix;
|
|
}
|
|
return ret;
|
|
}
|
|
};
|
|
} );
|
|
|
|
jQuery.fn.extend( {
|
|
|
|
on: function( types, selector, data, fn ) {
|
|
return on( this, types, selector, data, fn );
|
|
},
|
|
one: function( types, selector, data, fn ) {
|
|
return on( this, types, selector, data, fn, 1 );
|
|
},
|
|
off: function( types, selector, fn ) {
|
|
var handleObj, type;
|
|
if ( types && types.preventDefault && types.handleObj ) {
|
|
|
|
// ( event ) dispatched jQuery.Event
|
|
handleObj = types.handleObj;
|
|
jQuery( types.delegateTarget ).off(
|
|
handleObj.namespace ?
|
|
handleObj.origType + "." + handleObj.namespace :
|
|
handleObj.origType,
|
|
handleObj.selector,
|
|
handleObj.handler
|
|
);
|
|
return this;
|
|
}
|
|
if ( typeof types === "object" ) {
|
|
|
|
// ( types-object [, selector] )
|
|
for ( type in types ) {
|
|
this.off( type, selector, types[ type ] );
|
|
}
|
|
return this;
|
|
}
|
|
if ( selector === false || typeof selector === "function" ) {
|
|
|
|
// ( types [, fn] )
|
|
fn = selector;
|
|
selector = undefined;
|
|
}
|
|
if ( fn === false ) {
|
|
fn = returnFalse;
|
|
}
|
|
return this.each( function() {
|
|
jQuery.event.remove( this, types, fn, selector );
|
|
} );
|
|
}
|
|
} );
|
|
|
|
|
|
var
|
|
|
|
/* eslint-disable max-len */
|
|
|
|
// See https://github.com/eslint/eslint/issues/3229
|
|
rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,
|
|
|
|
/* eslint-enable */
|
|
|
|
// Support: IE <=10 - 11, Edge 12 - 13
|
|
// In IE/Edge using regex groups here causes severe slowdowns.
|
|
// See https://connect.microsoft.com/IE/feedback/details/1736512/
|
|
rnoInnerhtml = /<script|<style|<link/i,
|
|
|
|
// checked="checked" or checked
|
|
rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
|
|
rscriptTypeMasked = /^true\/(.*)/,
|
|
rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
|
|
|
|
// Prefer a tbody over its parent table for containing new rows
|
|
function manipulationTarget( elem, content ) {
|
|
if ( nodeName( elem, "table" ) &&
|
|
nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {
|
|
|
|
return jQuery( ">tbody", elem )[ 0 ] || elem;
|
|
}
|
|
|
|
return elem;
|
|
}
|
|
|
|
// Replace/restore the type attribute of script elements for safe DOM manipulation
|
|
function disableScript( elem ) {
|
|
elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
|
|
return elem;
|
|
}
|
|
function restoreScript( elem ) {
|
|
var match = rscriptTypeMasked.exec( elem.type );
|
|
|
|
if ( match ) {
|
|
elem.type = match[ 1 ];
|
|
} else {
|
|
elem.removeAttribute( "type" );
|
|
}
|
|
|
|
return elem;
|
|
}
|
|
|
|
function cloneCopyEvent( src, dest ) {
|
|
var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
|
|
|
|
if ( dest.nodeType !== 1 ) {
|
|
return;
|
|
}
|
|
|
|
// 1. Copy private data: events, handlers, etc.
|
|
if ( dataPriv.hasData( src ) ) {
|
|
pdataOld = dataPriv.access( src );
|
|
pdataCur = dataPriv.set( dest, pdataOld );
|
|
events = pdataOld.events;
|
|
|
|
if ( events ) {
|
|
delete pdataCur.handle;
|
|
pdataCur.events = {};
|
|
|
|
for ( type in events ) {
|
|
for ( i = 0, l = events[ type ].length; i < l; i++ ) {
|
|
jQuery.event.add( dest, type, events[ type ][ i ] );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 2. Copy user data
|
|
if ( dataUser.hasData( src ) ) {
|
|
udataOld = dataUser.access( src );
|
|
udataCur = jQuery.extend( {}, udataOld );
|
|
|
|
dataUser.set( dest, udataCur );
|
|
}
|
|
}
|
|
|
|
// Fix IE bugs, see support tests
|
|
function fixInput( src, dest ) {
|
|
var nodeName = dest.nodeName.toLowerCase();
|
|
|
|
// Fails to persist the checked state of a cloned checkbox or radio button.
|
|
if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
|
|
dest.checked = src.checked;
|
|
|
|
// Fails to return the selected option to the default selected state when cloning options
|
|
} else if ( nodeName === "input" || nodeName === "textarea" ) {
|
|
dest.defaultValue = src.defaultValue;
|
|
}
|
|
}
|
|
|
|
function domManip( collection, args, callback, ignored ) {
|
|
|
|
// Flatten any nested arrays
|
|
args = concat.apply( [], args );
|
|
|
|
var fragment, first, scripts, hasScripts, node, doc,
|
|
i = 0,
|
|
l = collection.length,
|
|
iNoClone = l - 1,
|
|
value = args[ 0 ],
|
|
isFunction = jQuery.isFunction( value );
|
|
|
|
// We can't cloneNode fragments that contain checked, in WebKit
|
|
if ( isFunction ||
|
|
( l > 1 && typeof value === "string" &&
|
|
!support.checkClone && rchecked.test( value ) ) ) {
|
|
return collection.each( function( index ) {
|
|
var self = collection.eq( index );
|
|
if ( isFunction ) {
|
|
args[ 0 ] = value.call( this, index, self.html() );
|
|
}
|
|
domManip( self, args, callback, ignored );
|
|
} );
|
|
}
|
|
|
|
if ( l ) {
|
|
fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
|
|
first = fragment.firstChild;
|
|
|
|
if ( fragment.childNodes.length === 1 ) {
|
|
fragment = first;
|
|
}
|
|
|
|
// Require either new content or an interest in ignored elements to invoke the callback
|
|
if ( first || ignored ) {
|
|
scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
|
|
hasScripts = scripts.length;
|
|
|
|
// Use the original fragment for the last item
|
|
// instead of the first because it can end up
|
|
// being emptied incorrectly in certain situations (#8070).
|
|
for ( ; i < l; i++ ) {
|
|
node = fragment;
|
|
|
|
if ( i !== iNoClone ) {
|
|
node = jQuery.clone( node, true, true );
|
|
|
|
// Keep references to cloned scripts for later restoration
|
|
if ( hasScripts ) {
|
|
|
|
// Support: Android <=4.0 only, PhantomJS 1 only
|
|
// push.apply(_, arraylike) throws on ancient WebKit
|
|
jQuery.merge( scripts, getAll( node, "script" ) );
|
|
}
|
|
}
|
|
|
|
callback.call( collection[ i ], node, i );
|
|
}
|
|
|
|
if ( hasScripts ) {
|
|
doc = scripts[ scripts.length - 1 ].ownerDocument;
|
|
|
|
// Reenable scripts
|
|
jQuery.map( scripts, restoreScript );
|
|
|
|
// Evaluate executable scripts on first document insertion
|
|
for ( i = 0; i < hasScripts; i++ ) {
|
|
node = scripts[ i ];
|
|
if ( rscriptType.test( node.type || "" ) &&
|
|
!dataPriv.access( node, "globalEval" ) &&
|
|
jQuery.contains( doc, node ) ) {
|
|
|
|
if ( node.src ) {
|
|
|
|
// Optional AJAX dependency, but won't run scripts if not present
|
|
if ( jQuery._evalUrl ) {
|
|
jQuery._evalUrl( node.src );
|
|
}
|
|
} else {
|
|
DOMEval( node.textContent.replace( rcleanScript, "" ), doc );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return collection;
|
|
}
|
|
|
|
function remove( elem, selector, keepData ) {
|
|
var node,
|
|
nodes = selector ? jQuery.filter( selector, elem ) : elem,
|
|
i = 0;
|
|
|
|
for ( ; ( node = nodes[ i ] ) != null; i++ ) {
|
|
if ( !keepData && node.nodeType === 1 ) {
|
|
jQuery.cleanData( getAll( node ) );
|
|
}
|
|
|
|
if ( node.parentNode ) {
|
|
if ( keepData && jQuery.contains( node.ownerDocument, node ) ) {
|
|
setGlobalEval( getAll( node, "script" ) );
|
|
}
|
|
node.parentNode.removeChild( node );
|
|
}
|
|
}
|
|
|
|
return elem;
|
|
}
|
|
|
|
jQuery.extend( {
|
|
htmlPrefilter: function( html ) {
|
|
return html.replace( rxhtmlTag, "<$1></$2>" );
|
|
},
|
|
|
|
clone: function( elem, dataAndEvents, deepDataAndEvents ) {
|
|
var i, l, srcElements, destElements,
|
|
clone = elem.cloneNode( true ),
|
|
inPage = jQuery.contains( elem.ownerDocument, elem );
|
|
|
|
// Fix IE cloning issues
|
|
if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
|
|
!jQuery.isXMLDoc( elem ) ) {
|
|
|
|
// We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
|
|
destElements = getAll( clone );
|
|
srcElements = getAll( elem );
|
|
|
|
for ( i = 0, l = srcElements.length; i < l; i++ ) {
|
|
fixInput( srcElements[ i ], destElements[ i ] );
|
|
}
|
|
}
|
|
|
|
// Copy the events from the original to the clone
|
|
if ( dataAndEvents ) {
|
|
if ( deepDataAndEvents ) {
|
|
srcElements = srcElements || getAll( elem );
|
|
destElements = destElements || getAll( clone );
|
|
|
|
for ( i = 0, l = srcElements.length; i < l; i++ ) {
|
|
cloneCopyEvent( srcElements[ i ], destElements[ i ] );
|
|
}
|
|
} else {
|
|
cloneCopyEvent( elem, clone );
|
|
}
|
|
}
|
|
|
|
// Preserve script evaluation history
|
|
destElements = getAll( clone, "script" );
|
|
if ( destElements.length > 0 ) {
|
|
setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
|
|
}
|
|
|
|
// Return the cloned set
|
|
return clone;
|
|
},
|
|
|
|
cleanData: function( elems ) {
|
|
var data, elem, type,
|
|
special = jQuery.event.special,
|
|
i = 0;
|
|
|
|
for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
|
|
if ( acceptData( elem ) ) {
|
|
if ( ( data = elem[ dataPriv.expando ] ) ) {
|
|
if ( data.events ) {
|
|
for ( type in data.events ) {
|
|
if ( special[ type ] ) {
|
|
jQuery.event.remove( elem, type );
|
|
|
|
// This is a shortcut to avoid jQuery.event.remove's overhead
|
|
} else {
|
|
jQuery.removeEvent( elem, type, data.handle );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Support: Chrome <=35 - 45+
|
|
// Assign undefined instead of using delete, see Data#remove
|
|
elem[ dataPriv.expando ] = undefined;
|
|
}
|
|
if ( elem[ dataUser.expando ] ) {
|
|
|
|
// Support: Chrome <=35 - 45+
|
|
// Assign undefined instead of using delete, see Data#remove
|
|
elem[ dataUser.expando ] = undefined;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} );
|
|
|
|
jQuery.fn.extend( {
|
|
detach: function( selector ) {
|
|
return remove( this, selector, true );
|
|
},
|
|
|
|
remove: function( selector ) {
|
|
return remove( this, selector );
|
|
},
|
|
|
|
text: function( value ) {
|
|
return access( this, function( value ) {
|
|
return value === undefined ?
|
|
jQuery.text( this ) :
|
|
this.empty().each( function() {
|
|
if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
|
|
this.textContent = value;
|
|
}
|
|
} );
|
|
}, null, value, arguments.length );
|
|
},
|
|
|
|
append: function() {
|
|
return domManip( this, arguments, function( elem ) {
|
|
if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
|
|
var target = manipulationTarget( this, elem );
|
|
target.appendChild( elem );
|
|
}
|
|
} );
|
|
},
|
|
|
|
prepend: function() {
|
|
return domManip( this, arguments, function( elem ) {
|
|
if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
|
|
var target = manipulationTarget( this, elem );
|
|
target.insertBefore( elem, target.firstChild );
|
|
}
|
|
} );
|
|
},
|
|
|
|
before: function() {
|
|
return domManip( this, arguments, function( elem ) {
|
|
if ( this.parentNode ) {
|
|
this.parentNode.insertBefore( elem, this );
|
|
}
|
|
} );
|
|
},
|
|
|
|
after: function() {
|
|
return domManip( this, arguments, function( elem ) {
|
|
if ( this.parentNode ) {
|
|
this.parentNode.insertBefore( elem, this.nextSibling );
|
|
}
|
|
} );
|
|
},
|
|
|
|
empty: function() {
|
|
var elem,
|
|
i = 0;
|
|
|
|
for ( ; ( elem = this[ i ] ) != null; i++ ) {
|
|
if ( elem.nodeType === 1 ) {
|
|
|
|
// Prevent memory leaks
|
|
jQuery.cleanData( getAll( elem, false ) );
|
|
|
|
// Remove any remaining nodes
|
|
elem.textContent = "";
|
|
}
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
clone: function( dataAndEvents, deepDataAndEvents ) {
|
|
dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
|
|
deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
|
|
|
|
return this.map( function() {
|
|
return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
|
|
} );
|
|
},
|
|
|
|
html: function( value ) {
|
|
return access( this, function( value ) {
|
|
var elem = this[ 0 ] || {},
|
|
i = 0,
|
|
l = this.length;
|
|
|
|
if ( value === undefined && elem.nodeType === 1 ) {
|
|
return elem.innerHTML;
|
|
}
|
|
|
|
// See if we can take a shortcut and just use innerHTML
|
|
if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
|
|
!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
|
|
|
|
value = jQuery.htmlPrefilter( value );
|
|
|
|
try {
|
|
for ( ; i < l; i++ ) {
|
|
elem = this[ i ] || {};
|
|
|
|
// Remove element nodes and prevent memory leaks
|
|
if ( elem.nodeType === 1 ) {
|
|
jQuery.cleanData( getAll( elem, false ) );
|
|
elem.innerHTML = value;
|
|
}
|
|
}
|
|
|
|
elem = 0;
|
|
|
|
// If using innerHTML throws an exception, use the fallback method
|
|
} catch ( e ) {}
|
|
}
|
|
|
|
if ( elem ) {
|
|
this.empty().append( value );
|
|
}
|
|
}, null, value, arguments.length );
|
|
},
|
|
|
|
replaceWith: function() {
|
|
var ignored = [];
|
|
|
|
// Make the changes, replacing each non-ignored context element with the new content
|
|
return domManip( this, arguments, function( elem ) {
|
|
var parent = this.parentNode;
|
|
|
|
if ( jQuery.inArray( this, ignored ) < 0 ) {
|
|
jQuery.cleanData( getAll( this ) );
|
|
if ( parent ) {
|
|
parent.replaceChild( elem, this );
|
|
}
|
|
}
|
|
|
|
// Force callback invocation
|
|
}, ignored );
|
|
}
|
|
} );
|
|
|
|
jQuery.each( {
|
|
appendTo: "append",
|
|
prependTo: "prepend",
|
|
insertBefore: "before",
|
|
insertAfter: "after",
|
|
replaceAll: "replaceWith"
|
|
}, function( name, original ) {
|
|
jQuery.fn[ name ] = function( selector ) {
|
|
var elems,
|
|
ret = [],
|
|
insert = jQuery( selector ),
|
|
last = insert.length - 1,
|
|
i = 0;
|
|
|
|
for ( ; i <= last; i++ ) {
|
|
elems = i === last ? this : this.clone( true );
|
|
jQuery( insert[ i ] )[ original ]( elems );
|
|
|
|
// Support: Android <=4.0 only, PhantomJS 1 only
|
|
// .get() because push.apply(_, arraylike) throws on ancient WebKit
|
|
push.apply( ret, elems.get() );
|
|
}
|
|
|
|
return this.pushStack( ret );
|
|
};
|
|
} );
|
|
var rmargin = ( /^margin/ );
|
|
|
|
var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
|
|
|
|
var getStyles = function( elem ) {
|
|
|
|
// Support: IE <=11 only, Firefox <=30 (#15098, #14150)
|
|
// IE throws on elements created in popups
|
|
// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
|
|
var view = elem.ownerDocument.defaultView;
|
|
|
|
if ( !view || !view.opener ) {
|
|
view = window;
|
|
}
|
|
|
|
return view.getComputedStyle( elem );
|
|
};
|
|
|
|
|
|
|
|
( function() {
|
|
|
|
// Executing both pixelPosition & boxSizingReliable tests require only one layout
|
|
// so they're executed at the same time to save the second computation.
|
|
function computeStyleTests() {
|
|
|
|
// This is a singleton, we need to execute it only once
|
|
if ( !div ) {
|
|
return;
|
|
}
|
|
|
|
div.style.cssText =
|
|
"box-sizing:border-box;" +
|
|
"position:relative;display:block;" +
|
|
"margin:auto;border:1px;padding:1px;" +
|
|
"top:1%;width:50%";
|
|
div.innerHTML = "";
|
|
documentElement.appendChild( container );
|
|
|
|
var divStyle = window.getComputedStyle( div );
|
|
pixelPositionVal = divStyle.top !== "1%";
|
|
|
|
// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
|
|
reliableMarginLeftVal = divStyle.marginLeft === "2px";
|
|
boxSizingReliableVal = divStyle.width === "4px";
|
|
|
|
// Support: Android 4.0 - 4.3 only
|
|
// Some styles come back with percentage values, even though they shouldn't
|
|
div.style.marginRight = "50%";
|
|
pixelMarginRightVal = divStyle.marginRight === "4px";
|
|
|
|
documentElement.removeChild( container );
|
|
|
|
// Nullify the div so it wouldn't be stored in the memory and
|
|
// it will also be a sign that checks already performed
|
|
div = null;
|
|
}
|
|
|
|
var pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal,
|
|
container = document.createElement( "div" ),
|
|
div = document.createElement( "div" );
|
|
|
|
// Finish early in limited (non-browser) environments
|
|
if ( !div.style ) {
|
|
return;
|
|
}
|
|
|
|
// Support: IE <=9 - 11 only
|
|
// Style of cloned element affects source element cloned (#8908)
|
|
div.style.backgroundClip = "content-box";
|
|
div.cloneNode( true ).style.backgroundClip = "";
|
|
support.clearCloneStyle = div.style.backgroundClip === "content-box";
|
|
|
|
container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" +
|
|
"padding:0;margin-top:1px;position:absolute";
|
|
container.appendChild( div );
|
|
|
|
jQuery.extend( support, {
|
|
pixelPosition: function() {
|
|
computeStyleTests();
|
|
return pixelPositionVal;
|
|
},
|
|
boxSizingReliable: function() {
|
|
computeStyleTests();
|
|
return boxSizingReliableVal;
|
|
},
|
|
pixelMarginRight: function() {
|
|
computeStyleTests();
|
|
return pixelMarginRightVal;
|
|
},
|
|
reliableMarginLeft: function() {
|
|
computeStyleTests();
|
|
return reliableMarginLeftVal;
|
|
}
|
|
} );
|
|
} )();
|
|
|
|
|
|
function curCSS( elem, name, computed ) {
|
|
var width, minWidth, maxWidth, ret,
|
|
|
|
// Support: Firefox 51+
|
|
// Retrieving style before computed somehow
|
|
// fixes an issue with getting wrong values
|
|
// on detached elements
|
|
style = elem.style;
|
|
|
|
computed = computed || getStyles( elem );
|
|
|
|
// getPropertyValue is needed for:
|
|
// .css('filter') (IE 9 only, #12537)
|
|
// .css('--customProperty) (#3144)
|
|
if ( computed ) {
|
|
ret = computed.getPropertyValue( name ) || computed[ name ];
|
|
|
|
if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
|
|
ret = jQuery.style( elem, name );
|
|
}
|
|
|
|
// A tribute to the "awesome hack by Dean Edwards"
|
|
// Android Browser returns percentage for some values,
|
|
// but width seems to be reliably pixels.
|
|
// This is against the CSSOM draft spec:
|
|
// https://drafts.csswg.org/cssom/#resolved-values
|
|
if ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {
|
|
|
|
// Remember the original values
|
|
width = style.width;
|
|
minWidth = style.minWidth;
|
|
maxWidth = style.maxWidth;
|
|
|
|
// Put in the new values to get a computed value out
|
|
style.minWidth = style.maxWidth = style.width = ret;
|
|
ret = computed.width;
|
|
|
|
// Revert the changed values
|
|
style.width = width;
|
|
style.minWidth = minWidth;
|
|
style.maxWidth = maxWidth;
|
|
}
|
|
}
|
|
|
|
return ret !== undefined ?
|
|
|
|
// Support: IE <=9 - 11 only
|
|
// IE returns zIndex value as an integer.
|
|
ret + "" :
|
|
ret;
|
|
}
|
|
|
|
|
|
function addGetHookIf( conditionFn, hookFn ) {
|
|
|
|
// Define the hook, we'll check on the first run if it's really needed.
|
|
return {
|
|
get: function() {
|
|
if ( conditionFn() ) {
|
|
|
|
// Hook not needed (or it's not possible to use it due
|
|
// to missing dependency), remove it.
|
|
delete this.get;
|
|
return;
|
|
}
|
|
|
|
// Hook needed; redefine it so that the support test is not executed again.
|
|
return ( this.get = hookFn ).apply( this, arguments );
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
var
|
|
|
|
// Swappable if display is none or starts with table
|
|
// except "table", "table-cell", or "table-caption"
|
|
// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
|
|
rdisplayswap = /^(none|table(?!-c[ea]).+)/,
|
|
rcustomProp = /^--/,
|
|
cssShow = { position: "absolute", visibility: "hidden", display: "block" },
|
|
cssNormalTransform = {
|
|
letterSpacing: "0",
|
|
fontWeight: "400"
|
|
},
|
|
|
|
cssPrefixes = [ "Webkit", "Moz", "ms" ],
|
|
emptyStyle = document.createElement( "div" ).style;
|
|
|
|
// Return a css property mapped to a potentially vendor prefixed property
|
|
function vendorPropName( name ) {
|
|
|
|
// Shortcut for names that are not vendor prefixed
|
|
if ( name in emptyStyle ) {
|
|
return name;
|
|
}
|
|
|
|
// Check for vendor prefixed names
|
|
var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
|
|
i = cssPrefixes.length;
|
|
|
|
while ( i-- ) {
|
|
name = cssPrefixes[ i ] + capName;
|
|
if ( name in emptyStyle ) {
|
|
return name;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Return a property mapped along what jQuery.cssProps suggests or to
|
|
// a vendor prefixed property.
|
|
function finalPropName( name ) {
|
|
var ret = jQuery.cssProps[ name ];
|
|
if ( !ret ) {
|
|
ret = jQuery.cssProps[ name ] = vendorPropName( name ) || name;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
function setPositiveNumber( elem, value, subtract ) {
|
|
|
|
// Any relative (+/-) values have already been
|
|
// normalized at this point
|
|
var matches = rcssNum.exec( value );
|
|
return matches ?
|
|
|
|
// Guard against undefined "subtract", e.g., when used as in cssHooks
|
|
Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
|
|
value;
|
|
}
|
|
|
|
function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
|
|
var i,
|
|
val = 0;
|
|
|
|
// If we already have the right measurement, avoid augmentation
|
|
if ( extra === ( isBorderBox ? "border" : "content" ) ) {
|
|
i = 4;
|
|
|
|
// Otherwise initialize for horizontal or vertical properties
|
|
} else {
|
|
i = name === "width" ? 1 : 0;
|
|
}
|
|
|
|
for ( ; i < 4; i += 2 ) {
|
|
|
|
// Both box models exclude margin, so add it if we want it
|
|
if ( extra === "margin" ) {
|
|
val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
|
|
}
|
|
|
|
if ( isBorderBox ) {
|
|
|
|
// border-box includes padding, so remove it if we want content
|
|
if ( extra === "content" ) {
|
|
val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
|
|
}
|
|
|
|
// At this point, extra isn't border nor margin, so remove border
|
|
if ( extra !== "margin" ) {
|
|
val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
|
|
}
|
|
} else {
|
|
|
|
// At this point, extra isn't content, so add padding
|
|
val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
|
|
|
|
// At this point, extra isn't content nor padding, so add border
|
|
if ( extra !== "padding" ) {
|
|
val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
|
|
}
|
|
}
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
function getWidthOrHeight( elem, name, extra ) {
|
|
|
|
// Start with computed style
|
|
var valueIsBorderBox,
|
|
styles = getStyles( elem ),
|
|
val = curCSS( elem, name, styles ),
|
|
isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
|
|
|
|
// Computed unit is not pixels. Stop here and return.
|
|
if ( rnumnonpx.test( val ) ) {
|
|
return val;
|
|
}
|
|
|
|
// Check for style in case a browser which returns unreliable values
|
|
// for getComputedStyle silently falls back to the reliable elem.style
|
|
valueIsBorderBox = isBorderBox &&
|
|
( support.boxSizingReliable() || val === elem.style[ name ] );
|
|
|
|
// Fall back to offsetWidth/Height when value is "auto"
|
|
// This happens for inline elements with no explicit setting (gh-3571)
|
|
if ( val === "auto" ) {
|
|
val = elem[ "offset" + name[ 0 ].toUpperCase() + name.slice( 1 ) ];
|
|
}
|
|
|
|
// Normalize "", auto, and prepare for extra
|
|
val = parseFloat( val ) || 0;
|
|
|
|
// Use the active box-sizing model to add/subtract irrelevant styles
|
|
return ( val +
|
|
augmentWidthOrHeight(
|
|
elem,
|
|
name,
|
|
extra || ( isBorderBox ? "border" : "content" ),
|
|
valueIsBorderBox,
|
|
styles
|
|
)
|
|
) + "px";
|
|
}
|
|
|
|
jQuery.extend( {
|
|
|
|
// Add in style property hooks for overriding the default
|
|
// behavior of getting and setting a style property
|
|
cssHooks: {
|
|
opacity: {
|
|
get: function( elem, computed ) {
|
|
if ( computed ) {
|
|
|
|
// We should always get a number back from opacity
|
|
var ret = curCSS( elem, "opacity" );
|
|
return ret === "" ? "1" : ret;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
// Don't automatically add "px" to these possibly-unitless properties
|
|
cssNumber: {
|
|
"animationIterationCount": true,
|
|
"columnCount": true,
|
|
"fillOpacity": true,
|
|
"flexGrow": true,
|
|
"flexShrink": true,
|
|
"fontWeight": true,
|
|
"lineHeight": true,
|
|
"opacity": true,
|
|
"order": true,
|
|
"orphans": true,
|
|
"widows": true,
|
|
"zIndex": true,
|
|
"zoom": true
|
|
},
|
|
|
|
// Add in properties whose names you wish to fix before
|
|
// setting or getting the value
|
|
cssProps: {
|
|
"float": "cssFloat"
|
|
},
|
|
|
|
// Get and set the style property on a DOM Node
|
|
style: function( elem, name, value, extra ) {
|
|
|
|
// Don't set styles on text and comment nodes
|
|
if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
|
|
return;
|
|
}
|
|
|
|
// Make sure that we're working with the right name
|
|
var ret, type, hooks,
|
|
origName = jQuery.camelCase( name ),
|
|
isCustomProp = rcustomProp.test( name ),
|
|
style = elem.style;
|
|
|
|
// Make sure that we're working with the right name. We don't
|
|
// want to query the value if it is a CSS custom property
|
|
// since they are user-defined.
|
|
if ( !isCustomProp ) {
|
|
name = finalPropName( origName );
|
|
}
|
|
|
|
// Gets hook for the prefixed version, then unprefixed version
|
|
hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
|
|
|
|
// Check if we're setting a value
|
|
if ( value !== undefined ) {
|
|
type = typeof value;
|
|
|
|
// Convert "+=" or "-=" to relative numbers (#7345)
|
|
if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
|
|
value = adjustCSS( elem, name, ret );
|
|
|
|
// Fixes bug #9237
|
|
type = "number";
|
|
}
|
|
|
|
// Make sure that null and NaN values aren't set (#7116)
|
|
if ( value == null || value !== value ) {
|
|
return;
|
|
}
|
|
|
|
// If a number was passed in, add the unit (except for certain CSS properties)
|
|
if ( type === "number" ) {
|
|
value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
|
|
}
|
|
|
|
// background-* props affect original clone's values
|
|
if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
|
|
style[ name ] = "inherit";
|
|
}
|
|
|
|
// If a hook was provided, use that value, otherwise just set the specified value
|
|
if ( !hooks || !( "set" in hooks ) ||
|
|
( value = hooks.set( elem, value, extra ) ) !== undefined ) {
|
|
|
|
if ( isCustomProp ) {
|
|
style.setProperty( name, value );
|
|
} else {
|
|
style[ name ] = value;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
// If a hook was provided get the non-computed value from there
|
|
if ( hooks && "get" in hooks &&
|
|
( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
|
|
|
|
return ret;
|
|
}
|
|
|
|
// Otherwise just get the value from the style object
|
|
return style[ name ];
|
|
}
|
|
},
|
|
|
|
css: function( elem, name, extra, styles ) {
|
|
var val, num, hooks,
|
|
origName = jQuery.camelCase( name ),
|
|
isCustomProp = rcustomProp.test( name );
|
|
|
|
// Make sure that we're working with the right name. We don't
|
|
// want to modify the value if it is a CSS custom property
|
|
// since they are user-defined.
|
|
if ( !isCustomProp ) {
|
|
name = finalPropName( origName );
|
|
}
|
|
|
|
// Try prefixed name followed by the unprefixed name
|
|
hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
|
|
|
|
// If a hook was provided get the computed value from there
|
|
if ( hooks && "get" in hooks ) {
|
|
val = hooks.get( elem, true, extra );
|
|
}
|
|
|
|
// Otherwise, if a way to get the computed value exists, use that
|
|
if ( val === undefined ) {
|
|
val = curCSS( elem, name, styles );
|
|
}
|
|
|
|
// Convert "normal" to computed value
|
|
if ( val === "normal" && name in cssNormalTransform ) {
|
|
val = cssNormalTransform[ name ];
|
|
}
|
|
|
|
// Make numeric if forced or a qualifier was provided and val looks numeric
|
|
if ( extra === "" || extra ) {
|
|
num = parseFloat( val );
|
|
return extra === true || isFinite( num ) ? num || 0 : val;
|
|
}
|
|
|
|
return val;
|
|
}
|
|
} );
|
|
|
|
jQuery.each( [ "height", "width" ], function( i, name ) {
|
|
jQuery.cssHooks[ name ] = {
|
|
get: function( elem, computed, extra ) {
|
|
if ( computed ) {
|
|
|
|
// Certain elements can have dimension info if we invisibly show them
|
|
// but it must have a current display style that would benefit
|
|
return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
|
|
|
|
// Support: Safari 8+
|
|
// Table columns in Safari have non-zero offsetWidth & zero
|
|
// getBoundingClientRect().width unless display is changed.
|
|
// Support: IE <=11 only
|
|
// Running getBoundingClientRect on a disconnected node
|
|
// in IE throws an error.
|
|
( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
|
|
swap( elem, cssShow, function() {
|
|
return getWidthOrHeight( elem, name, extra );
|
|
} ) :
|
|
getWidthOrHeight( elem, name, extra );
|
|
}
|
|
},
|
|
|
|
set: function( elem, value, extra ) {
|
|
var matches,
|
|
styles = extra && getStyles( elem ),
|
|
subtract = extra && augmentWidthOrHeight(
|
|
elem,
|
|
name,
|
|
extra,
|
|
jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
|
|
styles
|
|
);
|
|
|
|
// Convert to pixels if value adjustment is needed
|
|
if ( subtract && ( matches = rcssNum.exec( value ) ) &&
|
|
( matches[ 3 ] || "px" ) !== "px" ) {
|
|
|
|
elem.style[ name ] = value;
|
|
value = jQuery.css( elem, name );
|
|
}
|
|
|
|
return setPositiveNumber( elem, value, subtract );
|
|
}
|
|
};
|
|
} );
|
|
|
|
jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
|
|
function( elem, computed ) {
|
|
if ( computed ) {
|
|
return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
|
|
elem.getBoundingClientRect().left -
|
|
swap( elem, { marginLeft: 0 }, function() {
|
|
return elem.getBoundingClientRect().left;
|
|
} )
|
|
) + "px";
|
|
}
|
|
}
|
|
);
|
|
|
|
// These hooks are used by animate to expand properties
|
|
jQuery.each( {
|
|
margin: "",
|
|
padding: "",
|
|
border: "Width"
|
|
}, function( prefix, suffix ) {
|
|
jQuery.cssHooks[ prefix + suffix ] = {
|
|
expand: function( value ) {
|
|
var i = 0,
|
|
expanded = {},
|
|
|
|
// Assumes a single number if not a string
|
|
parts = typeof value === "string" ? value.split( " " ) : [ value ];
|
|
|
|
for ( ; i < 4; i++ ) {
|
|
expanded[ prefix + cssExpand[ i ] + suffix ] =
|
|
parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
|
|
}
|
|
|
|
return expanded;
|
|
}
|
|
};
|
|
|
|
if ( !rmargin.test( prefix ) ) {
|
|
jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
|
|
}
|
|
} );
|
|
|
|
jQuery.fn.extend( {
|
|
css: function( name, value ) {
|
|
return access( this, function( elem, name, value ) {
|
|
var styles, len,
|
|
map = {},
|
|
i = 0;
|
|
|
|
if ( Array.isArray( name ) ) {
|
|
styles = getStyles( elem );
|
|
len = name.length;
|
|
|
|
for ( ; i < len; i++ ) {
|
|
map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
|
|
}
|
|
|
|
return map;
|
|
}
|
|
|
|
return value !== undefined ?
|
|
jQuery.style( elem, name, value ) :
|
|
jQuery.css( elem, name );
|
|
}, name, value, arguments.length > 1 );
|
|
}
|
|
} );
|
|
|
|
|
|
function Tween( elem, options, prop, end, easing ) {
|
|
return new Tween.prototype.init( elem, options, prop, end, easing );
|
|
}
|
|
jQuery.Tween = Tween;
|
|
|
|
Tween.prototype = {
|
|
constructor: Tween,
|
|
init: function( elem, options, prop, end, easing, unit ) {
|
|
this.elem = elem;
|
|
this.prop = prop;
|
|
this.easing = easing || jQuery.easing._default;
|
|
this.options = options;
|
|
this.start = this.now = this.cur();
|
|
this.end = end;
|
|
this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
|
|
},
|
|
cur: function() {
|
|
var hooks = Tween.propHooks[ this.prop ];
|
|
|
|
return hooks && hooks.get ?
|
|
hooks.get( this ) :
|
|
Tween.propHooks._default.get( this );
|
|
},
|
|
run: function( percent ) {
|
|
var eased,
|
|
hooks = Tween.propHooks[ this.prop ];
|
|
|
|
if ( this.options.duration ) {
|
|
this.pos = eased = jQuery.easing[ this.easing ](
|
|
percent, this.options.duration * percent, 0, 1, this.options.duration
|
|
);
|
|
} else {
|
|
this.pos = eased = percent;
|
|
}
|
|
this.now = ( this.end - this.start ) * eased + this.start;
|
|
|
|
if ( this.options.step ) {
|
|
this.options.step.call( this.elem, this.now, this );
|
|
}
|
|
|
|
if ( hooks && hooks.set ) {
|
|
hooks.set( this );
|
|
} else {
|
|
Tween.propHooks._default.set( this );
|
|
}
|
|
return this;
|
|
}
|
|
};
|
|
|
|
Tween.prototype.init.prototype = Tween.prototype;
|
|
|
|
Tween.propHooks = {
|
|
_default: {
|
|
get: function( tween ) {
|
|
var result;
|
|
|
|
// Use a property on the element directly when it is not a DOM element,
|
|
// or when there is no matching style property that exists.
|
|
if ( tween.elem.nodeType !== 1 ||
|
|
tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
|
|
return tween.elem[ tween.prop ];
|
|
}
|
|
|
|
// Passing an empty string as a 3rd parameter to .css will automatically
|
|
// attempt a parseFloat and fallback to a string if the parse fails.
|
|
// Simple values such as "10px" are parsed to Float;
|
|
// complex values such as "rotate(1rad)" are returned as-is.
|
|
result = jQuery.css( tween.elem, tween.prop, "" );
|
|
|
|
// Empty strings, null, undefined and "auto" are converted to 0.
|
|
return !result || result === "auto" ? 0 : result;
|
|
},
|
|
set: function( tween ) {
|
|
|
|
// Use step hook for back compat.
|
|
// Use cssHook if its there.
|
|
// Use .style if available and use plain properties where available.
|
|
if ( jQuery.fx.step[ tween.prop ] ) {
|
|
jQuery.fx.step[ tween.prop ]( tween );
|
|
} else if ( tween.elem.nodeType === 1 &&
|
|
( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||
|
|
jQuery.cssHooks[ tween.prop ] ) ) {
|
|
jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
|
|
} else {
|
|
tween.elem[ tween.prop ] = tween.now;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// Support: IE <=9 only
|
|
// Panic based approach to setting things on disconnected nodes
|
|
Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
|
|
set: function( tween ) {
|
|
if ( tween.elem.nodeType && tween.elem.parentNode ) {
|
|
tween.elem[ tween.prop ] = tween.now;
|
|
}
|
|
}
|
|
};
|
|
|
|
jQuery.easing = {
|
|
linear: function( p ) {
|
|
return p;
|
|
},
|
|
swing: function( p ) {
|
|
return 0.5 - Math.cos( p * Math.PI ) / 2;
|
|
},
|
|
_default: "swing"
|
|
};
|
|
|
|
jQuery.fx = Tween.prototype.init;
|
|
|
|
// Back compat <1.8 extension point
|
|
jQuery.fx.step = {};
|
|
|
|
|
|
|
|
|
|
var
|
|
fxNow, inProgress,
|
|
rfxtypes = /^(?:toggle|show|hide)$/,
|
|
rrun = /queueHooks$/;
|
|
|
|
function schedule() {
|
|
if ( inProgress ) {
|
|
if ( document.hidden === false && window.requestAnimationFrame ) {
|
|
window.requestAnimationFrame( schedule );
|
|
} else {
|
|
window.setTimeout( schedule, jQuery.fx.interval );
|
|
}
|
|
|
|
jQuery.fx.tick();
|
|
}
|
|
}
|
|
|
|
// Animations created synchronously will run synchronously
|
|
function createFxNow() {
|
|
window.setTimeout( function() {
|
|
fxNow = undefined;
|
|
} );
|
|
return ( fxNow = jQuery.now() );
|
|
}
|
|
|
|
// Generate parameters to create a standard animation
|
|
function genFx( type, includeWidth ) {
|
|
var which,
|
|
i = 0,
|
|
attrs = { height: type };
|
|
|
|
// If we include width, step value is 1 to do all cssExpand values,
|
|
// otherwise step value is 2 to skip over Left and Right
|
|
includeWidth = includeWidth ? 1 : 0;
|
|
for ( ; i < 4; i += 2 - includeWidth ) {
|
|
which = cssExpand[ i ];
|
|
attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
|
|
}
|
|
|
|
if ( includeWidth ) {
|
|
attrs.opacity = attrs.width = type;
|
|
}
|
|
|
|
return attrs;
|
|
}
|
|
|
|
function createTween( value, prop, animation ) {
|
|
var tween,
|
|
collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
|
|
index = 0,
|
|
length = collection.length;
|
|
for ( ; index < length; index++ ) {
|
|
if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
|
|
|
|
// We're done with this property
|
|
return tween;
|
|
}
|
|
}
|
|
}
|
|
|
|
function defaultPrefilter( elem, props, opts ) {
|
|
var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
|
|
isBox = "width" in props || "height" in props,
|
|
anim = this,
|
|
orig = {},
|
|
style = elem.style,
|
|
hidden = elem.nodeType && isHiddenWithinTree( elem ),
|
|
dataShow = dataPriv.get( elem, "fxshow" );
|
|
|
|
// Queue-skipping animations hijack the fx hooks
|
|
if ( !opts.queue ) {
|
|
hooks = jQuery._queueHooks( elem, "fx" );
|
|
if ( hooks.unqueued == null ) {
|
|
hooks.unqueued = 0;
|
|
oldfire = hooks.empty.fire;
|
|
hooks.empty.fire = function() {
|
|
if ( !hooks.unqueued ) {
|
|
oldfire();
|
|
}
|
|
};
|
|
}
|
|
hooks.unqueued++;
|
|
|
|
anim.always( function() {
|
|
|
|
// Ensure the complete handler is called before this completes
|
|
anim.always( function() {
|
|
hooks.unqueued--;
|
|
if ( !jQuery.queue( elem, "fx" ).length ) {
|
|
hooks.empty.fire();
|
|
}
|
|
} );
|
|
} );
|
|
}
|
|
|
|
// Detect show/hide animations
|
|
for ( prop in props ) {
|
|
value = props[ prop ];
|
|
if ( rfxtypes.test( value ) ) {
|
|
delete props[ prop ];
|
|
toggle = toggle || value === "toggle";
|
|
if ( value === ( hidden ? "hide" : "show" ) ) {
|
|
|
|
// Pretend to be hidden if this is a "show" and
|
|
// there is still data from a stopped show/hide
|
|
if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
|
|
hidden = true;
|
|
|
|
// Ignore all other no-op show/hide data
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
|
|
}
|
|
}
|
|
|
|
// Bail out if this is a no-op like .hide().hide()
|
|
propTween = !jQuery.isEmptyObject( props );
|
|
if ( !propTween && jQuery.isEmptyObject( orig ) ) {
|
|
return;
|
|
}
|
|
|
|
// Restrict "overflow" and "display" styles during box animations
|
|
if ( isBox && elem.nodeType === 1 ) {
|
|
|
|
// Support: IE <=9 - 11, Edge 12 - 13
|
|
// Record all 3 overflow attributes because IE does not infer the shorthand
|
|
// from identically-valued overflowX and overflowY
|
|
opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
|
|
|
|
// Identify a display type, preferring old show/hide data over the CSS cascade
|
|
restoreDisplay = dataShow && dataShow.display;
|
|
if ( restoreDisplay == null ) {
|
|
restoreDisplay = dataPriv.get( elem, "display" );
|
|
}
|
|
display = jQuery.css( elem, "display" );
|
|
if ( display === "none" ) {
|
|
if ( restoreDisplay ) {
|
|
display = restoreDisplay;
|
|
} else {
|
|
|
|
// Get nonempty value(s) by temporarily forcing visibility
|
|
showHide( [ elem ], true );
|
|
restoreDisplay = elem.style.display || restoreDisplay;
|
|
display = jQuery.css( elem, "display" );
|
|
showHide( [ elem ] );
|
|
}
|
|
}
|
|
|
|
// Animate inline elements as inline-block
|
|
if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
|
|
if ( jQuery.css( elem, "float" ) === "none" ) {
|
|
|
|
// Restore the original display value at the end of pure show/hide animations
|
|
if ( !propTween ) {
|
|
anim.done( function() {
|
|
style.display = restoreDisplay;
|
|
} );
|
|
if ( restoreDisplay == null ) {
|
|
display = style.display;
|
|
restoreDisplay = display === "none" ? "" : display;
|
|
}
|
|
}
|
|
style.display = "inline-block";
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( opts.overflow ) {
|
|
style.overflow = "hidden";
|
|
anim.always( function() {
|
|
style.overflow = opts.overflow[ 0 ];
|
|
style.overflowX = opts.overflow[ 1 ];
|
|
style.overflowY = opts.overflow[ 2 ];
|
|
} );
|
|
}
|
|
|
|
// Implement show/hide animations
|
|
propTween = false;
|
|
for ( prop in orig ) {
|
|
|
|
// General show/hide setup for this element animation
|
|
if ( !propTween ) {
|
|
if ( dataShow ) {
|
|
if ( "hidden" in dataShow ) {
|
|
hidden = dataShow.hidden;
|
|
}
|
|
} else {
|
|
dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
|
|
}
|
|
|
|
// Store hidden/visible for toggle so `.stop().toggle()` "reverses"
|
|
if ( toggle ) {
|
|
dataShow.hidden = !hidden;
|
|
}
|
|
|
|
// Show elements before animating them
|
|
if ( hidden ) {
|
|
showHide( [ elem ], true );
|
|
}
|
|
|
|
/* eslint-disable no-loop-func */
|
|
|
|
anim.done( function() {
|
|
|
|
/* eslint-enable no-loop-func */
|
|
|
|
// The final step of a "hide" animation is actually hiding the element
|
|
if ( !hidden ) {
|
|
showHide( [ elem ] );
|
|
}
|
|
dataPriv.remove( elem, "fxshow" );
|
|
for ( prop in orig ) {
|
|
jQuery.style( elem, prop, orig[ prop ] );
|
|
}
|
|
} );
|
|
}
|
|
|
|
// Per-property setup
|
|
propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
|
|
if ( !( prop in dataShow ) ) {
|
|
dataShow[ prop ] = propTween.start;
|
|
if ( hidden ) {
|
|
propTween.end = propTween.start;
|
|
propTween.start = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function propFilter( props, specialEasing ) {
|
|
var index, name, easing, value, hooks;
|
|
|
|
// camelCase, specialEasing and expand cssHook pass
|
|
for ( index in props ) {
|
|
name = jQuery.camelCase( index );
|
|
easing = specialEasing[ name ];
|
|
value = props[ index ];
|
|
if ( Array.isArray( value ) ) {
|
|
easing = value[ 1 ];
|
|
value = props[ index ] = value[ 0 ];
|
|
}
|
|
|
|
if ( index !== name ) {
|
|
props[ name ] = value;
|
|
delete props[ index ];
|
|
}
|
|
|
|
hooks = jQuery.cssHooks[ name ];
|
|
if ( hooks && "expand" in hooks ) {
|
|
value = hooks.expand( value );
|
|
delete props[ name ];
|
|
|
|
// Not quite $.extend, this won't overwrite existing keys.
|
|
// Reusing 'index' because we have the correct "name"
|
|
for ( index in value ) {
|
|
if ( !( index in props ) ) {
|
|
props[ index ] = value[ index ];
|
|
specialEasing[ index ] = easing;
|
|
}
|
|
}
|
|
} else {
|
|
specialEasing[ name ] = easing;
|
|
}
|
|
}
|
|
}
|
|
|
|
function Animation( elem, properties, options ) {
|
|
var result,
|
|
stopped,
|
|
index = 0,
|
|
length = Animation.prefilters.length,
|
|
deferred = jQuery.Deferred().always( function() {
|
|
|
|
// Don't match elem in the :animated selector
|
|
delete tick.elem;
|
|
} ),
|
|
tick = function() {
|
|
if ( stopped ) {
|
|
return false;
|
|
}
|
|
var currentTime = fxNow || createFxNow(),
|
|
remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
|
|
|
|
// Support: Android 2.3 only
|
|
// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
|
|
temp = remaining / animation.duration || 0,
|
|
percent = 1 - temp,
|
|
index = 0,
|
|
length = animation.tweens.length;
|
|
|
|
for ( ; index < length; index++ ) {
|
|
animation.tweens[ index ].run( percent );
|
|
}
|
|
|
|
deferred.notifyWith( elem, [ animation, percent, remaining ] );
|
|
|
|
// If there's more to do, yield
|
|
if ( percent < 1 && length ) {
|
|
return remaining;
|
|
}
|
|
|
|
// If this was an empty animation, synthesize a final progress notification
|
|
if ( !length ) {
|
|
deferred.notifyWith( elem, [ animation, 1, 0 ] );
|
|
}
|
|
|
|
// Resolve the animation and report its conclusion
|
|
deferred.resolveWith( elem, [ animation ] );
|
|
return false;
|
|
},
|
|
animation = deferred.promise( {
|
|
elem: elem,
|
|
props: jQuery.extend( {}, properties ),
|
|
opts: jQuery.extend( true, {
|
|
specialEasing: {},
|
|
easing: jQuery.easing._default
|
|
}, options ),
|
|
originalProperties: properties,
|
|
originalOptions: options,
|
|
startTime: fxNow || createFxNow(),
|
|
duration: options.duration,
|
|
tweens: [],
|
|
createTween: function( prop, end ) {
|
|
var tween = jQuery.Tween( elem, animation.opts, prop, end,
|
|
animation.opts.specialEasing[ prop ] || animation.opts.easing );
|
|
animation.tweens.push( tween );
|
|
return tween;
|
|
},
|
|
stop: function( gotoEnd ) {
|
|
var index = 0,
|
|
|
|
// If we are going to the end, we want to run all the tweens
|
|
// otherwise we skip this part
|
|
length = gotoEnd ? animation.tweens.length : 0;
|
|
if ( stopped ) {
|
|
return this;
|
|
}
|
|
stopped = true;
|
|
for ( ; index < length; index++ ) {
|
|
animation.tweens[ index ].run( 1 );
|
|
}
|
|
|
|
// Resolve when we played the last frame; otherwise, reject
|
|
if ( gotoEnd ) {
|
|
deferred.notifyWith( elem, [ animation, 1, 0 ] );
|
|
deferred.resolveWith( elem, [ animation, gotoEnd ] );
|
|
} else {
|
|
deferred.rejectWith( elem, [ animation, gotoEnd ] );
|
|
}
|
|
return this;
|
|
}
|
|
} ),
|
|
props = animation.props;
|
|
|
|
propFilter( props, animation.opts.specialEasing );
|
|
|
|
for ( ; index < length; index++ ) {
|
|
result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
|
|
if ( result ) {
|
|
if ( jQuery.isFunction( result.stop ) ) {
|
|
jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
|
|
jQuery.proxy( result.stop, result );
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
jQuery.map( props, createTween, animation );
|
|
|
|
if ( jQuery.isFunction( animation.opts.start ) ) {
|
|
animation.opts.start.call( elem, animation );
|
|
}
|
|
|
|
// Attach callbacks from options
|
|
animation
|
|
.progress( animation.opts.progress )
|
|
.done( animation.opts.done, animation.opts.complete )
|
|
.fail( animation.opts.fail )
|
|
.always( animation.opts.always );
|
|
|
|
jQuery.fx.timer(
|
|
jQuery.extend( tick, {
|
|
elem: elem,
|
|
anim: animation,
|
|
queue: animation.opts.queue
|
|
} )
|
|
);
|
|
|
|
return animation;
|
|
}
|
|
|
|
jQuery.Animation = jQuery.extend( Animation, {
|
|
|
|
tweeners: {
|
|
"*": [ function( prop, value ) {
|
|
var tween = this.createTween( prop, value );
|
|
adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
|
|
return tween;
|
|
} ]
|
|
},
|
|
|
|
tweener: function( props, callback ) {
|
|
if ( jQuery.isFunction( props ) ) {
|
|
callback = props;
|
|
props = [ "*" ];
|
|
} else {
|
|
props = props.match( rnothtmlwhite );
|
|
}
|
|
|
|
var prop,
|
|
index = 0,
|
|
length = props.length;
|
|
|
|
for ( ; index < length; index++ ) {
|
|
prop = props[ index ];
|
|
Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
|
|
Animation.tweeners[ prop ].unshift( callback );
|
|
}
|
|
},
|
|
|
|
prefilters: [ defaultPrefilter ],
|
|
|
|
prefilter: function( callback, prepend ) {
|
|
if ( prepend ) {
|
|
Animation.prefilters.unshift( callback );
|
|
} else {
|
|
Animation.prefilters.push( callback );
|
|
}
|
|
}
|
|
} );
|
|
|
|
jQuery.speed = function( speed, easing, fn ) {
|
|
var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
|
|
complete: fn || !fn && easing ||
|
|
jQuery.isFunction( speed ) && speed,
|
|
duration: speed,
|
|
easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
|
|
};
|
|
|
|
// Go to the end state if fx are off
|
|
if ( jQuery.fx.off ) {
|
|
opt.duration = 0;
|
|
|
|
} else {
|
|
if ( typeof opt.duration !== "number" ) {
|
|
if ( opt.duration in jQuery.fx.speeds ) {
|
|
opt.duration = jQuery.fx.speeds[ opt.duration ];
|
|
|
|
} else {
|
|
opt.duration = jQuery.fx.speeds._default;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Normalize opt.queue - true/undefined/null -> "fx"
|
|
if ( opt.queue == null || opt.queue === true ) {
|
|
opt.queue = "fx";
|
|
}
|
|
|
|
// Queueing
|
|
opt.old = opt.complete;
|
|
|
|
opt.complete = function() {
|
|
if ( jQuery.isFunction( opt.old ) ) {
|
|
opt.old.call( this );
|
|
}
|
|
|
|
if ( opt.queue ) {
|
|
jQuery.dequeue( this, opt.queue );
|
|
}
|
|
};
|
|
|
|
return opt;
|
|
};
|
|
|
|
jQuery.fn.extend( {
|
|
fadeTo: function( speed, to, easing, callback ) {
|
|
|
|
// Show any hidden elements after setting opacity to 0
|
|
return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()
|
|
|
|
// Animate to the value specified
|
|
.end().animate( { opacity: to }, speed, easing, callback );
|
|
},
|
|
animate: function( prop, speed, easing, callback ) {
|
|
var empty = jQuery.isEmptyObject( prop ),
|
|
optall = jQuery.speed( speed, easing, callback ),
|
|
doAnimation = function() {
|
|
|
|
// Operate on a copy of prop so per-property easing won't be lost
|
|
var anim = Animation( this, jQuery.extend( {}, prop ), optall );
|
|
|
|
// Empty animations, or finishing resolves immediately
|
|
if ( empty || dataPriv.get( this, "finish" ) ) {
|
|
anim.stop( true );
|
|
}
|
|
};
|
|
doAnimation.finish = doAnimation;
|
|
|
|
return empty || optall.queue === false ?
|
|
this.each( doAnimation ) :
|
|
this.queue( optall.queue, doAnimation );
|
|
},
|
|
stop: function( type, clearQueue, gotoEnd ) {
|
|
var stopQueue = function( hooks ) {
|
|
var stop = hooks.stop;
|
|
delete hooks.stop;
|
|
stop( gotoEnd );
|
|
};
|
|
|
|
if ( typeof type !== "string" ) {
|
|
gotoEnd = clearQueue;
|
|
clearQueue = type;
|
|
type = undefined;
|
|
}
|
|
if ( clearQueue && type !== false ) {
|
|
this.queue( type || "fx", [] );
|
|
}
|
|
|
|
return this.each( function() {
|
|
var dequeue = true,
|
|
index = type != null && type + "queueHooks",
|
|
timers = jQuery.timers,
|
|
data = dataPriv.get( this );
|
|
|
|
if ( index ) {
|
|
if ( data[ index ] && data[ index ].stop ) {
|
|
stopQueue( data[ index ] );
|
|
}
|
|
} else {
|
|
for ( index in data ) {
|
|
if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
|
|
stopQueue( data[ index ] );
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( index = timers.length; index--; ) {
|
|
if ( timers[ index ].elem === this &&
|
|
( type == null || timers[ index ].queue === type ) ) {
|
|
|
|
timers[ index ].anim.stop( gotoEnd );
|
|
dequeue = false;
|
|
timers.splice( index, 1 );
|
|
}
|
|
}
|
|
|
|
// Start the next in the queue if the last step wasn't forced.
|
|
// Timers currently will call their complete callbacks, which
|
|
// will dequeue but only if they were gotoEnd.
|
|
if ( dequeue || !gotoEnd ) {
|
|
jQuery.dequeue( this, type );
|
|
}
|
|
} );
|
|
},
|
|
finish: function( type ) {
|
|
if ( type !== false ) {
|
|
type = type || "fx";
|
|
}
|
|
return this.each( function() {
|
|
var index,
|
|
data = dataPriv.get( this ),
|
|
queue = data[ type + "queue" ],
|
|
hooks = data[ type + "queueHooks" ],
|
|
timers = jQuery.timers,
|
|
length = queue ? queue.length : 0;
|
|
|
|
// Enable finishing flag on private data
|
|
data.finish = true;
|
|
|
|
// Empty the queue first
|
|
jQuery.queue( this, type, [] );
|
|
|
|
if ( hooks && hooks.stop ) {
|
|
hooks.stop.call( this, true );
|
|
}
|
|
|
|
// Look for any active animations, and finish them
|
|
for ( index = timers.length; index--; ) {
|
|
if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
|
|
timers[ index ].anim.stop( true );
|
|
timers.splice( index, 1 );
|
|
}
|
|
}
|
|
|
|
// Look for any animations in the old queue and finish them
|
|
for ( index = 0; index < length; index++ ) {
|
|
if ( queue[ index ] && queue[ index ].finish ) {
|
|
queue[ index ].finish.call( this );
|
|
}
|
|
}
|
|
|
|
// Turn off finishing flag
|
|
delete data.finish;
|
|
} );
|
|
}
|
|
} );
|
|
|
|
jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) {
|
|
var cssFn = jQuery.fn[ name ];
|
|
jQuery.fn[ name ] = function( speed, easing, callback ) {
|
|
return speed == null || typeof speed === "boolean" ?
|
|
cssFn.apply( this, arguments ) :
|
|
this.animate( genFx( name, true ), speed, easing, callback );
|
|
};
|
|
} );
|
|
|
|
// Generate shortcuts for custom animations
|
|
jQuery.each( {
|
|
slideDown: genFx( "show" ),
|
|
slideUp: genFx( "hide" ),
|
|
slideToggle: genFx( "toggle" ),
|
|
fadeIn: { opacity: "show" },
|
|
fadeOut: { opacity: "hide" },
|
|
fadeToggle: { opacity: "toggle" }
|
|
}, function( name, props ) {
|
|
jQuery.fn[ name ] = function( speed, easing, callback ) {
|
|
return this.animate( props, speed, easing, callback );
|
|
};
|
|
} );
|
|
|
|
jQuery.timers = [];
|
|
jQuery.fx.tick = function() {
|
|
var timer,
|
|
i = 0,
|
|
timers = jQuery.timers;
|
|
|
|
fxNow = jQuery.now();
|
|
|
|
for ( ; i < timers.length; i++ ) {
|
|
timer = timers[ i ];
|
|
|
|
// Run the timer and safely remove it when done (allowing for external removal)
|
|
if ( !timer() && timers[ i ] === timer ) {
|
|
timers.splice( i--, 1 );
|
|
}
|
|
}
|
|
|
|
if ( !timers.length ) {
|
|
jQuery.fx.stop();
|
|
}
|
|
fxNow = undefined;
|
|
};
|
|
|
|
jQuery.fx.timer = function( timer ) {
|
|
jQuery.timers.push( timer );
|
|
jQuery.fx.start();
|
|
};
|
|
|
|
jQuery.fx.interval = 13;
|
|
jQuery.fx.start = function() {
|
|
if ( inProgress ) {
|
|
return;
|
|
}
|
|
|
|
inProgress = true;
|
|
schedule();
|
|
};
|
|
|
|
jQuery.fx.stop = function() {
|
|
inProgress = null;
|
|
};
|
|
|
|
jQuery.fx.speeds = {
|
|
slow: 600,
|
|
fast: 200,
|
|
|
|
// Default speed
|
|
_default: 400
|
|
};
|
|
|
|
|
|
// Based off of the plugin by Clint Helfers, with permission.
|
|
// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
|
|
jQuery.fn.delay = function( time, type ) {
|
|
time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
|
|
type = type || "fx";
|
|
|
|
return this.queue( type, function( next, hooks ) {
|
|
var timeout = window.setTimeout( next, time );
|
|
hooks.stop = function() {
|
|
window.clearTimeout( timeout );
|
|
};
|
|
} );
|
|
};
|
|
|
|
|
|
( function() {
|
|
var input = document.createElement( "input" ),
|
|
select = document.createElement( "select" ),
|
|
opt = select.appendChild( document.createElement( "option" ) );
|
|
|
|
input.type = "checkbox";
|
|
|
|
// Support: Android <=4.3 only
|
|
// Default value for a checkbox should be "on"
|
|
support.checkOn = input.value !== "";
|
|
|
|
// Support: IE <=11 only
|
|
// Must access selectedIndex to make default options select
|
|
support.optSelected = opt.selected;
|
|
|
|
// Support: IE <=11 only
|
|
// An input loses its value after becoming a radio
|
|
input = document.createElement( "input" );
|
|
input.value = "t";
|
|
input.type = "radio";
|
|
support.radioValue = input.value === "t";
|
|
} )();
|
|
|
|
|
|
var boolHook,
|
|
attrHandle = jQuery.expr.attrHandle;
|
|
|
|
jQuery.fn.extend( {
|
|
attr: function( name, value ) {
|
|
return access( this, jQuery.attr, name, value, arguments.length > 1 );
|
|
},
|
|
|
|
removeAttr: function( name ) {
|
|
return this.each( function() {
|
|
jQuery.removeAttr( this, name );
|
|
} );
|
|
}
|
|
} );
|
|
|
|
jQuery.extend( {
|
|
attr: function( elem, name, value ) {
|
|
var ret, hooks,
|
|
nType = elem.nodeType;
|
|
|
|
// Don't get/set attributes on text, comment and attribute nodes
|
|
if ( nType === 3 || nType === 8 || nType === 2 ) {
|
|
return;
|
|
}
|
|
|
|
// Fallback to prop when attributes are not supported
|
|
if ( typeof elem.getAttribute === "undefined" ) {
|
|
return jQuery.prop( elem, name, value );
|
|
}
|
|
|
|
// Attribute hooks are determined by the lowercase version
|
|
// Grab necessary hook if one is defined
|
|
if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
|
|
hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
|
|
( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
|
|
}
|
|
|
|
if ( value !== undefined ) {
|
|
if ( value === null ) {
|
|
jQuery.removeAttr( elem, name );
|
|
return;
|
|
}
|
|
|
|
if ( hooks && "set" in hooks &&
|
|
( ret = hooks.set( elem, value, name ) ) !== undefined ) {
|
|
return ret;
|
|
}
|
|
|
|
elem.setAttribute( name, value + "" );
|
|
return value;
|
|
}
|
|
|
|
if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
|
|
return ret;
|
|
}
|
|
|
|
ret = jQuery.find.attr( elem, name );
|
|
|
|
// Non-existent attributes return null, we normalize to undefined
|
|
return ret == null ? undefined : ret;
|
|
},
|
|
|
|
attrHooks: {
|
|
type: {
|
|
set: function( elem, value ) {
|
|
if ( !support.radioValue && value === "radio" &&
|
|
nodeName( elem, "input" ) ) {
|
|
var val = elem.value;
|
|
elem.setAttribute( "type", value );
|
|
if ( val ) {
|
|
elem.value = val;
|
|
}
|
|
return value;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
removeAttr: function( elem, value ) {
|
|
var name,
|
|
i = 0,
|
|
|
|
// Attribute names can contain non-HTML whitespace characters
|
|
// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
|
|
attrNames = value && value.match( rnothtmlwhite );
|
|
|
|
if ( attrNames && elem.nodeType === 1 ) {
|
|
while ( ( name = attrNames[ i++ ] ) ) {
|
|
elem.removeAttribute( name );
|
|
}
|
|
}
|
|
}
|
|
} );
|
|
|
|
// Hooks for boolean attributes
|
|
boolHook = {
|
|
set: function( elem, value, name ) {
|
|
if ( value === false ) {
|
|
|
|
// Remove boolean attributes when set to false
|
|
jQuery.removeAttr( elem, name );
|
|
} else {
|
|
elem.setAttribute( name, name );
|
|
}
|
|
return name;
|
|
}
|
|
};
|
|
|
|
jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
|
|
var getter = attrHandle[ name ] || jQuery.find.attr;
|
|
|
|
attrHandle[ name ] = function( elem, name, isXML ) {
|
|
var ret, handle,
|
|
lowercaseName = name.toLowerCase();
|
|
|
|
if ( !isXML ) {
|
|
|
|
// Avoid an infinite loop by temporarily removing this function from the getter
|
|
handle = attrHandle[ lowercaseName ];
|
|
attrHandle[ lowercaseName ] = ret;
|
|
ret = getter( elem, name, isXML ) != null ?
|
|
lowercaseName :
|
|
null;
|
|
attrHandle[ lowercaseName ] = handle;
|
|
}
|
|
return ret;
|
|
};
|
|
} );
|
|
|
|
|
|
|
|
|
|
var rfocusable = /^(?:input|select|textarea|button)$/i,
|
|
rclickable = /^(?:a|area)$/i;
|
|
|
|
jQuery.fn.extend( {
|
|
prop: function( name, value ) {
|
|
return access( this, jQuery.prop, name, value, arguments.length > 1 );
|
|
},
|
|
|
|
removeProp: function( name ) {
|
|
return this.each( function() {
|
|
delete this[ jQuery.propFix[ name ] || name ];
|
|
} );
|
|
}
|
|
} );
|
|
|
|
jQuery.extend( {
|
|
prop: function( elem, name, value ) {
|
|
var ret, hooks,
|
|
nType = elem.nodeType;
|
|
|
|
// Don't get/set properties on text, comment and attribute nodes
|
|
if ( nType === 3 || nType === 8 || nType === 2 ) {
|
|
return;
|
|
}
|
|
|
|
if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
|
|
|
|
// Fix name and attach hooks
|
|
name = jQuery.propFix[ name ] || name;
|
|
hooks = jQuery.propHooks[ name ];
|
|
}
|
|
|
|
if ( value !== undefined ) {
|
|
if ( hooks && "set" in hooks &&
|
|
( ret = hooks.set( elem, value, name ) ) !== undefined ) {
|
|
return ret;
|
|
}
|
|
|
|
return ( elem[ name ] = value );
|
|
}
|
|
|
|
if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
|
|
return ret;
|
|
}
|
|
|
|
return elem[ name ];
|
|
},
|
|
|
|
propHooks: {
|
|
tabIndex: {
|
|
get: function( elem ) {
|
|
|
|
// Support: IE <=9 - 11 only
|
|
// elem.tabIndex doesn't always return the
|
|
// correct value when it hasn't been explicitly set
|
|
// https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
|
|
// Use proper attribute retrieval(#12072)
|
|
var tabindex = jQuery.find.attr( elem, "tabindex" );
|
|
|
|
if ( tabindex ) {
|
|
return parseInt( tabindex, 10 );
|
|
}
|
|
|
|
if (
|
|
rfocusable.test( elem.nodeName ) ||
|
|
rclickable.test( elem.nodeName ) &&
|
|
elem.href
|
|
) {
|
|
return 0;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
}
|
|
},
|
|
|
|
propFix: {
|
|
"for": "htmlFor",
|
|
"class": "className"
|
|
}
|
|
} );
|
|
|
|
// Support: IE <=11 only
|
|
// Accessing the selectedIndex property
|
|
// forces the browser to respect setting selected
|
|
// on the option
|
|
// The getter ensures a default option is selected
|
|
// when in an optgroup
|
|
// eslint rule "no-unused-expressions" is disabled for this code
|
|
// since it considers such accessions noop
|
|
if ( !support.optSelected ) {
|
|
jQuery.propHooks.selected = {
|
|
get: function( elem ) {
|
|
|
|
/* eslint no-unused-expressions: "off" */
|
|
|
|
var parent = elem.parentNode;
|
|
if ( parent && parent.parentNode ) {
|
|
parent.parentNode.selectedIndex;
|
|
}
|
|
return null;
|
|
},
|
|
set: function( elem ) {
|
|
|
|
/* eslint no-unused-expressions: "off" */
|
|
|
|
var parent = elem.parentNode;
|
|
if ( parent ) {
|
|
parent.selectedIndex;
|
|
|
|
if ( parent.parentNode ) {
|
|
parent.parentNode.selectedIndex;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
jQuery.each( [
|
|
"tabIndex",
|
|
"readOnly",
|
|
"maxLength",
|
|
"cellSpacing",
|
|
"cellPadding",
|
|
"rowSpan",
|
|
"colSpan",
|
|
"useMap",
|
|
"frameBorder",
|
|
"contentEditable"
|
|
], function() {
|
|
jQuery.propFix[ this.toLowerCase() ] = this;
|
|
} );
|
|
|
|
|
|
|
|
|
|
// Strip and collapse whitespace according to HTML spec
|
|
// https://html.spec.whatwg.org/multipage/infrastructure.html#strip-and-collapse-whitespace
|
|
function stripAndCollapse( value ) {
|
|
var tokens = value.match( rnothtmlwhite ) || [];
|
|
return tokens.join( " " );
|
|
}
|
|
|
|
|
|
function getClass( elem ) {
|
|
return elem.getAttribute && elem.getAttribute( "class" ) || "";
|
|
}
|
|
|
|
jQuery.fn.extend( {
|
|
addClass: function( value ) {
|
|
var classes, elem, cur, curValue, clazz, j, finalValue,
|
|
i = 0;
|
|
|
|
if ( jQuery.isFunction( value ) ) {
|
|
return this.each( function( j ) {
|
|
jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
|
|
} );
|
|
}
|
|
|
|
if ( typeof value === "string" && value ) {
|
|
classes = value.match( rnothtmlwhite ) || [];
|
|
|
|
while ( ( elem = this[ i++ ] ) ) {
|
|
curValue = getClass( elem );
|
|
cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
|
|
|
|
if ( cur ) {
|
|
j = 0;
|
|
while ( ( clazz = classes[ j++ ] ) ) {
|
|
if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
|
|
cur += clazz + " ";
|
|
}
|
|
}
|
|
|
|
// Only assign if different to avoid unneeded rendering.
|
|
finalValue = stripAndCollapse( cur );
|
|
if ( curValue !== finalValue ) {
|
|
elem.setAttribute( "class", finalValue );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
removeClass: function( value ) {
|
|
var classes, elem, cur, curValue, clazz, j, finalValue,
|
|
i = 0;
|
|
|
|
if ( jQuery.isFunction( value ) ) {
|
|
return this.each( function( j ) {
|
|
jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
|
|
} );
|
|
}
|
|
|
|
if ( !arguments.length ) {
|
|
return this.attr( "class", "" );
|
|
}
|
|
|
|
if ( typeof value === "string" && value ) {
|
|
classes = value.match( rnothtmlwhite ) || [];
|
|
|
|
while ( ( elem = this[ i++ ] ) ) {
|
|
curValue = getClass( elem );
|
|
|
|
// This expression is here for better compressibility (see addClass)
|
|
cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
|
|
|
|
if ( cur ) {
|
|
j = 0;
|
|
while ( ( clazz = classes[ j++ ] ) ) {
|
|
|
|
// Remove *all* instances
|
|
while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
|
|
cur = cur.replace( " " + clazz + " ", " " );
|
|
}
|
|
}
|
|
|
|
// Only assign if different to avoid unneeded rendering.
|
|
finalValue = stripAndCollapse( cur );
|
|
if ( curValue !== finalValue ) {
|
|
elem.setAttribute( "class", finalValue );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
toggleClass: function( value, stateVal ) {
|
|
var type = typeof value;
|
|
|
|
if ( typeof stateVal === "boolean" && type === "string" ) {
|
|
return stateVal ? this.addClass( value ) : this.removeClass( value );
|
|
}
|
|
|
|
if ( jQuery.isFunction( value ) ) {
|
|
return this.each( function( i ) {
|
|
jQuery( this ).toggleClass(
|
|
value.call( this, i, getClass( this ), stateVal ),
|
|
stateVal
|
|
);
|
|
} );
|
|
}
|
|
|
|
return this.each( function() {
|
|
var className, i, self, classNames;
|
|
|
|
if ( type === "string" ) {
|
|
|
|
// Toggle individual class names
|
|
i = 0;
|
|
self = jQuery( this );
|
|
classNames = value.match( rnothtmlwhite ) || [];
|
|
|
|
while ( ( className = classNames[ i++ ] ) ) {
|
|
|
|
// Check each className given, space separated list
|
|
if ( self.hasClass( className ) ) {
|
|
self.removeClass( className );
|
|
} else {
|
|
self.addClass( className );
|
|
}
|
|
}
|
|
|
|
// Toggle whole class name
|
|
} else if ( value === undefined || type === "boolean" ) {
|
|
className = getClass( this );
|
|
if ( className ) {
|
|
|
|
// Store className if set
|
|
dataPriv.set( this, "__className__", className );
|
|
}
|
|
|
|
// If the element has a class name or if we're passed `false`,
|
|
// then remove the whole classname (if there was one, the above saved it).
|
|
// Otherwise bring back whatever was previously saved (if anything),
|
|
// falling back to the empty string if nothing was stored.
|
|
if ( this.setAttribute ) {
|
|
this.setAttribute( "class",
|
|
className || value === false ?
|
|
"" :
|
|
dataPriv.get( this, "__className__" ) || ""
|
|
);
|
|
}
|
|
}
|
|
} );
|
|
},
|
|
|
|
hasClass: function( selector ) {
|
|
var className, elem,
|
|
i = 0;
|
|
|
|
className = " " + selector + " ";
|
|
while ( ( elem = this[ i++ ] ) ) {
|
|
if ( elem.nodeType === 1 &&
|
|
( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
} );
|
|
|
|
|
|
|
|
|
|
var rreturn = /\r/g;
|
|
|
|
jQuery.fn.extend( {
|
|
val: function( value ) {
|
|
var hooks, ret, isFunction,
|
|
elem = this[ 0 ];
|
|
|
|
if ( !arguments.length ) {
|
|
if ( elem ) {
|
|
hooks = jQuery.valHooks[ elem.type ] ||
|
|
jQuery.valHooks[ elem.nodeName.toLowerCase() ];
|
|
|
|
if ( hooks &&
|
|
"get" in hooks &&
|
|
( ret = hooks.get( elem, "value" ) ) !== undefined
|
|
) {
|
|
return ret;
|
|
}
|
|
|
|
ret = elem.value;
|
|
|
|
// Handle most common string cases
|
|
if ( typeof ret === "string" ) {
|
|
return ret.replace( rreturn, "" );
|
|
}
|
|
|
|
// Handle cases where value is null/undef or number
|
|
return ret == null ? "" : ret;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
isFunction = jQuery.isFunction( value );
|
|
|
|
return this.each( function( i ) {
|
|
var val;
|
|
|
|
if ( this.nodeType !== 1 ) {
|
|
return;
|
|
}
|
|
|
|
if ( isFunction ) {
|
|
val = value.call( this, i, jQuery( this ).val() );
|
|
} else {
|
|
val = value;
|
|
}
|
|
|
|
// Treat null/undefined as ""; convert numbers to string
|
|
if ( val == null ) {
|
|
val = "";
|
|
|
|
} else if ( typeof val === "number" ) {
|
|
val += "";
|
|
|
|
} else if ( Array.isArray( val ) ) {
|
|
val = jQuery.map( val, function( value ) {
|
|
return value == null ? "" : value + "";
|
|
} );
|
|
}
|
|
|
|
hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
|
|
|
|
// If set returns undefined, fall back to normal setting
|
|
if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
|
|
this.value = val;
|
|
}
|
|
} );
|
|
}
|
|
} );
|
|
|
|
jQuery.extend( {
|
|
valHooks: {
|
|
option: {
|
|
get: function( elem ) {
|
|
|
|
var val = jQuery.find.attr( elem, "value" );
|
|
return val != null ?
|
|
val :
|
|
|
|
// Support: IE <=10 - 11 only
|
|
// option.text throws exceptions (#14686, #14858)
|
|
// Strip and collapse whitespace
|
|
// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
|
|
stripAndCollapse( jQuery.text( elem ) );
|
|
}
|
|
},
|
|
select: {
|
|
get: function( elem ) {
|
|
var value, option, i,
|
|
options = elem.options,
|
|
index = elem.selectedIndex,
|
|
one = elem.type === "select-one",
|
|
values = one ? null : [],
|
|
max = one ? index + 1 : options.length;
|
|
|
|
if ( index < 0 ) {
|
|
i = max;
|
|
|
|
} else {
|
|
i = one ? index : 0;
|
|
}
|
|
|
|
// Loop through all the selected options
|
|
for ( ; i < max; i++ ) {
|
|
option = options[ i ];
|
|
|
|
// Support: IE <=9 only
|
|
// IE8-9 doesn't update selected after form reset (#2551)
|
|
if ( ( option.selected || i === index ) &&
|
|
|
|
// Don't return options that are disabled or in a disabled optgroup
|
|
!option.disabled &&
|
|
( !option.parentNode.disabled ||
|
|
!nodeName( option.parentNode, "optgroup" ) ) ) {
|
|
|
|
// Get the specific value for the option
|
|
value = jQuery( option ).val();
|
|
|
|
// We don't need an array for one selects
|
|
if ( one ) {
|
|
return value;
|
|
}
|
|
|
|
// Multi-Selects return an array
|
|
values.push( value );
|
|
}
|
|
}
|
|
|
|
return values;
|
|
},
|
|
|
|
set: function( elem, value ) {
|
|
var optionSet, option,
|
|
options = elem.options,
|
|
values = jQuery.makeArray( value ),
|
|
i = options.length;
|
|
|
|
while ( i-- ) {
|
|
option = options[ i ];
|
|
|
|
/* eslint-disable no-cond-assign */
|
|
|
|
if ( option.selected =
|
|
jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
|
|
) {
|
|
optionSet = true;
|
|
}
|
|
|
|
/* eslint-enable no-cond-assign */
|
|
}
|
|
|
|
// Force browsers to behave consistently when non-matching value is set
|
|
if ( !optionSet ) {
|
|
elem.selectedIndex = -1;
|
|
}
|
|
return values;
|
|
}
|
|
}
|
|
}
|
|
} );
|
|
|
|
// Radios and checkboxes getter/setter
|
|
jQuery.each( [ "radio", "checkbox" ], function() {
|
|
jQuery.valHooks[ this ] = {
|
|
set: function( elem, value ) {
|
|
if ( Array.isArray( value ) ) {
|
|
return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
|
|
}
|
|
}
|
|
};
|
|
if ( !support.checkOn ) {
|
|
jQuery.valHooks[ this ].get = function( elem ) {
|
|
return elem.getAttribute( "value" ) === null ? "on" : elem.value;
|
|
};
|
|
}
|
|
} );
|
|
|
|
|
|
|
|
|
|
// Return jQuery for attributes-only inclusion
|
|
|
|
|
|
var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
|
|
|
|
jQuery.extend( jQuery.event, {
|
|
|
|
trigger: function( event, data, elem, onlyHandlers ) {
|
|
|
|
var i, cur, tmp, bubbleType, ontype, handle, special,
|
|
eventPath = [ elem || document ],
|
|
type = hasOwn.call( event, "type" ) ? event.type : event,
|
|
namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
|
|
|
|
cur = tmp = elem = elem || document;
|
|
|
|
// Don't do events on text and comment nodes
|
|
if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
|
|
return;
|
|
}
|
|
|
|
// focus/blur morphs to focusin/out; ensure we're not firing them right now
|
|
if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
|
|
return;
|
|
}
|
|
|
|
if ( type.indexOf( "." ) > -1 ) {
|
|
|
|
// Namespaced trigger; create a regexp to match event type in handle()
|
|
namespaces = type.split( "." );
|
|
type = namespaces.shift();
|
|
namespaces.sort();
|
|
}
|
|
ontype = type.indexOf( ":" ) < 0 && "on" + type;
|
|
|
|
// Caller can pass in a jQuery.Event object, Object, or just an event type string
|
|
event = event[ jQuery.expando ] ?
|
|
event :
|
|
new jQuery.Event( type, typeof event === "object" && event );
|
|
|
|
// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
|
|
event.isTrigger = onlyHandlers ? 2 : 3;
|
|
event.namespace = namespaces.join( "." );
|
|
event.rnamespace = event.namespace ?
|
|
new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
|
|
null;
|
|
|
|
// Clean up the event in case it is being reused
|
|
event.result = undefined;
|
|
if ( !event.target ) {
|
|
event.target = elem;
|
|
}
|
|
|
|
// Clone any incoming data and prepend the event, creating the handler arg list
|
|
data = data == null ?
|
|
[ event ] :
|
|
jQuery.makeArray( data, [ event ] );
|
|
|
|
// Allow special events to draw outside the lines
|
|
special = jQuery.event.special[ type ] || {};
|
|
if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
|
|
return;
|
|
}
|
|
|
|
// Determine event propagation path in advance, per W3C events spec (#9951)
|
|
// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
|
|
if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
|
|
|
|
bubbleType = special.delegateType || type;
|
|
if ( !rfocusMorph.test( bubbleType + type ) ) {
|
|
cur = cur.parentNode;
|
|
}
|
|
for ( ; cur; cur = cur.parentNode ) {
|
|
eventPath.push( cur );
|
|
tmp = cur;
|
|
}
|
|
|
|
// Only add window if we got to document (e.g., not plain obj or detached DOM)
|
|
if ( tmp === ( elem.ownerDocument || document ) ) {
|
|
eventPath.push( tmp.defaultView || tmp.parentWindow || window );
|
|
}
|
|
}
|
|
|
|
// Fire handlers on the event path
|
|
i = 0;
|
|
while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
|
|
|
|
event.type = i > 1 ?
|
|
bubbleType :
|
|
special.bindType || type;
|
|
|
|
// jQuery handler
|
|
handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] &&
|
|
dataPriv.get( cur, "handle" );
|
|
if ( handle ) {
|
|
handle.apply( cur, data );
|
|
}
|
|
|
|
// Native handler
|
|
handle = ontype && cur[ ontype ];
|
|
if ( handle && handle.apply && acceptData( cur ) ) {
|
|
event.result = handle.apply( cur, data );
|
|
if ( event.result === false ) {
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}
|
|
event.type = type;
|
|
|
|
// If nobody prevented the default action, do it now
|
|
if ( !onlyHandlers && !event.isDefaultPrevented() ) {
|
|
|
|
if ( ( !special._default ||
|
|
special._default.apply( eventPath.pop(), data ) === false ) &&
|
|
acceptData( elem ) ) {
|
|
|
|
// Call a native DOM method on the target with the same name as the event.
|
|
// Don't do default actions on window, that's where global variables be (#6170)
|
|
if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) {
|
|
|
|
// Don't re-trigger an onFOO event when we call its FOO() method
|
|
tmp = elem[ ontype ];
|
|
|
|
if ( tmp ) {
|
|
elem[ ontype ] = null;
|
|
}
|
|
|
|
// Prevent re-triggering of the same event, since we already bubbled it above
|
|
jQuery.event.triggered = type;
|
|
elem[ type ]();
|
|
jQuery.event.triggered = undefined;
|
|
|
|
if ( tmp ) {
|
|
elem[ ontype ] = tmp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return event.result;
|
|
},
|
|
|
|
// Piggyback on a donor event to simulate a different one
|
|
// Used only for `focus(in | out)` events
|
|
simulate: function( type, elem, event ) {
|
|
var e = jQuery.extend(
|
|
new jQuery.Event(),
|
|
event,
|
|
{
|
|
type: type,
|
|
isSimulated: true
|
|
}
|
|
);
|
|
|
|
jQuery.event.trigger( e, null, elem );
|
|
}
|
|
|
|
} );
|
|
|
|
jQuery.fn.extend( {
|
|
|
|
trigger: function( type, data ) {
|
|
return this.each( function() {
|
|
jQuery.event.trigger( type, data, this );
|
|
} );
|
|
},
|
|
triggerHandler: function( type, data ) {
|
|
var elem = this[ 0 ];
|
|
if ( elem ) {
|
|
return jQuery.event.trigger( type, data, elem, true );
|
|
}
|
|
}
|
|
} );
|
|
|
|
|
|
jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " +
|
|
"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
|
|
"change select submit keydown keypress keyup contextmenu" ).split( " " ),
|
|
function( i, name ) {
|
|
|
|
// Handle event binding
|
|
jQuery.fn[ name ] = function( data, fn ) {
|
|
return arguments.length > 0 ?
|
|
this.on( name, null, data, fn ) :
|
|
this.trigger( name );
|
|
};
|
|
} );
|
|
|
|
jQuery.fn.extend( {
|
|
hover: function( fnOver, fnOut ) {
|
|
return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
|
|
}
|
|
} );
|
|
|
|
|
|
|
|
|
|
support.focusin = "onfocusin" in window;
|
|
|
|
|
|
// Support: Firefox <=44
|
|
// Firefox doesn't have focus(in | out) events
|
|
// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
|
|
//
|
|
// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
|
|
// focus(in | out) events fire after focus & blur events,
|
|
// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
|
|
// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
|
|
if ( !support.focusin ) {
|
|
jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {
|
|
|
|
// Attach a single capturing handler on the document while someone wants focusin/focusout
|
|
var handler = function( event ) {
|
|
jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
|
|
};
|
|
|
|
jQuery.event.special[ fix ] = {
|
|
setup: function() {
|
|
var doc = this.ownerDocument || this,
|
|
attaches = dataPriv.access( doc, fix );
|
|
|
|
if ( !attaches ) {
|
|
doc.addEventListener( orig, handler, true );
|
|
}
|
|
dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );
|
|
},
|
|
teardown: function() {
|
|
var doc = this.ownerDocument || this,
|
|
attaches = dataPriv.access( doc, fix ) - 1;
|
|
|
|
if ( !attaches ) {
|
|
doc.removeEventListener( orig, handler, true );
|
|
dataPriv.remove( doc, fix );
|
|
|
|
} else {
|
|
dataPriv.access( doc, fix, attaches );
|
|
}
|
|
}
|
|
};
|
|
} );
|
|
}
|
|
var location = window.location;
|
|
|
|
var nonce = jQuery.now();
|
|
|
|
var rquery = ( /\?/ );
|
|
|
|
|
|
|
|
// Cross-browser xml parsing
|
|
jQuery.parseXML = function( data ) {
|
|
var xml;
|
|
if ( !data || typeof data !== "string" ) {
|
|
return null;
|
|
}
|
|
|
|
// Support: IE 9 - 11 only
|
|
// IE throws on parseFromString with invalid input.
|
|
try {
|
|
xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
|
|
} catch ( e ) {
|
|
xml = undefined;
|
|
}
|
|
|
|
if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {
|
|
jQuery.error( "Invalid XML: " + data );
|
|
}
|
|
return xml;
|
|
};
|
|
|
|
|
|
var
|
|
rbracket = /\[\]$/,
|
|
rCRLF = /\r?\n/g,
|
|
rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
|
|
rsubmittable = /^(?:input|select|textarea|keygen)/i;
|
|
|
|
function buildParams( prefix, obj, traditional, add ) {
|
|
var name;
|
|
|
|
if ( Array.isArray( obj ) ) {
|
|
|
|
// Serialize array item.
|
|
jQuery.each( obj, function( i, v ) {
|
|
if ( traditional || rbracket.test( prefix ) ) {
|
|
|
|
// Treat each array item as a scalar.
|
|
add( prefix, v );
|
|
|
|
} else {
|
|
|
|
// Item is non-scalar (array or object), encode its numeric index.
|
|
buildParams(
|
|
prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
|
|
v,
|
|
traditional,
|
|
add
|
|
);
|
|
}
|
|
} );
|
|
|
|
} else if ( !traditional && jQuery.type( obj ) === "object" ) {
|
|
|
|
// Serialize object item.
|
|
for ( name in obj ) {
|
|
buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
|
|
}
|
|
|
|
} else {
|
|
|
|
// Serialize scalar item.
|
|
add( prefix, obj );
|
|
}
|
|
}
|
|
|
|
// Serialize an array of form elements or a set of
|
|
// key/values into a query string
|
|
jQuery.param = function( a, traditional ) {
|
|
var prefix,
|
|
s = [],
|
|
add = function( key, valueOrFunction ) {
|
|
|
|
// If value is a function, invoke it and use its return value
|
|
var value = jQuery.isFunction( valueOrFunction ) ?
|
|
valueOrFunction() :
|
|
valueOrFunction;
|
|
|
|
s[ s.length ] = encodeURIComponent( key ) + "=" +
|
|
encodeURIComponent( value == null ? "" : value );
|
|
};
|
|
|
|
// If an array was passed in, assume that it is an array of form elements.
|
|
if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
|
|
|
|
// Serialize the form elements
|
|
jQuery.each( a, function() {
|
|
add( this.name, this.value );
|
|
} );
|
|
|
|
} else {
|
|
|
|
// If traditional, encode the "old" way (the way 1.3.2 or older
|
|
// did it), otherwise encode params recursively.
|
|
for ( prefix in a ) {
|
|
buildParams( prefix, a[ prefix ], traditional, add );
|
|
}
|
|
}
|
|
|
|
// Return the resulting serialization
|
|
return s.join( "&" );
|
|
};
|
|
|
|
jQuery.fn.extend( {
|
|
serialize: function() {
|
|
return jQuery.param( this.serializeArray() );
|
|
},
|
|
serializeArray: function() {
|
|
return this.map( function() {
|
|
|
|
// Can add propHook for "elements" to filter or add form elements
|
|
var elements = jQuery.prop( this, "elements" );
|
|
return elements ? jQuery.makeArray( elements ) : this;
|
|
} )
|
|
.filter( function() {
|
|
var type = this.type;
|
|
|
|
// Use .is( ":disabled" ) so that fieldset[disabled] works
|
|
return this.name && !jQuery( this ).is( ":disabled" ) &&
|
|
rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
|
|
( this.checked || !rcheckableType.test( type ) );
|
|
} )
|
|
.map( function( i, elem ) {
|
|
var val = jQuery( this ).val();
|
|
|
|
if ( val == null ) {
|
|
return null;
|
|
}
|
|
|
|
if ( Array.isArray( val ) ) {
|
|
return jQuery.map( val, function( val ) {
|
|
return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
|
|
} );
|
|
}
|
|
|
|
return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
|
|
} ).get();
|
|
}
|
|
} );
|
|
|
|
|
|
var
|
|
r20 = /%20/g,
|
|
rhash = /#.*$/,
|
|
rantiCache = /([?&])_=[^&]*/,
|
|
rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
|
|
|
|
// #7653, #8125, #8152: local protocol detection
|
|
rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
|
|
rnoContent = /^(?:GET|HEAD)$/,
|
|
rprotocol = /^\/\//,
|
|
|
|
/* Prefilters
|
|
* 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
|
|
* 2) These are called:
|
|
* - BEFORE asking for a transport
|
|
* - AFTER param serialization (s.data is a string if s.processData is true)
|
|
* 3) key is the dataType
|
|
* 4) the catchall symbol "*" can be used
|
|
* 5) execution will start with transport dataType and THEN continue down to "*" if needed
|
|
*/
|
|
prefilters = {},
|
|
|
|
/* Transports bindings
|
|
* 1) key is the dataType
|
|
* 2) the catchall symbol "*" can be used
|
|
* 3) selection will start with transport dataType and THEN go to "*" if needed
|
|
*/
|
|
transports = {},
|
|
|
|
// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
|
|
allTypes = "*/".concat( "*" ),
|
|
|
|
// Anchor tag for parsing the document origin
|
|
originAnchor = document.createElement( "a" );
|
|
originAnchor.href = location.href;
|
|
|
|
// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
|
|
function addToPrefiltersOrTransports( structure ) {
|
|
|
|
// dataTypeExpression is optional and defaults to "*"
|
|
return function( dataTypeExpression, func ) {
|
|
|
|
if ( typeof dataTypeExpression !== "string" ) {
|
|
func = dataTypeExpression;
|
|
dataTypeExpression = "*";
|
|
}
|
|
|
|
var dataType,
|
|
i = 0,
|
|
dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
|
|
|
|
if ( jQuery.isFunction( func ) ) {
|
|
|
|
// For each dataType in the dataTypeExpression
|
|
while ( ( dataType = dataTypes[ i++ ] ) ) {
|
|
|
|
// Prepend if requested
|
|
if ( dataType[ 0 ] === "+" ) {
|
|
dataType = dataType.slice( 1 ) || "*";
|
|
( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
|
|
|
|
// Otherwise append
|
|
} else {
|
|
( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// Base inspection function for prefilters and transports
|
|
function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
|
|
|
|
var inspected = {},
|
|
seekingTransport = ( structure === transports );
|
|
|
|
function inspect( dataType ) {
|
|
var selected;
|
|
inspected[ dataType ] = true;
|
|
jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
|
|
var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
|
|
if ( typeof dataTypeOrTransport === "string" &&
|
|
!seekingTransport && !inspected[ dataTypeOrTransport ] ) {
|
|
|
|
options.dataTypes.unshift( dataTypeOrTransport );
|
|
inspect( dataTypeOrTransport );
|
|
return false;
|
|
} else if ( seekingTransport ) {
|
|
return !( selected = dataTypeOrTransport );
|
|
}
|
|
} );
|
|
return selected;
|
|
}
|
|
|
|
return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
|
|
}
|
|
|
|
// A special extend for ajax options
|
|
// that takes "flat" options (not to be deep extended)
|
|
// Fixes #9887
|
|
function ajaxExtend( target, src ) {
|
|
var key, deep,
|
|
flatOptions = jQuery.ajaxSettings.flatOptions || {};
|
|
|
|
for ( key in src ) {
|
|
if ( src[ key ] !== undefined ) {
|
|
( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
|
|
}
|
|
}
|
|
if ( deep ) {
|
|
jQuery.extend( true, target, deep );
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
/* Handles responses to an ajax request:
|
|
* - finds the right dataType (mediates between content-type and expected dataType)
|
|
* - returns the corresponding response
|
|
*/
|
|
function ajaxHandleResponses( s, jqXHR, responses ) {
|
|
|
|
var ct, type, finalDataType, firstDataType,
|
|
contents = s.contents,
|
|
dataTypes = s.dataTypes;
|
|
|
|
// Remove auto dataType and get content-type in the process
|
|
while ( dataTypes[ 0 ] === "*" ) {
|
|
dataTypes.shift();
|
|
if ( ct === undefined ) {
|
|
ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
|
|
}
|
|
}
|
|
|
|
// Check if we're dealing with a known content-type
|
|
if ( ct ) {
|
|
for ( type in contents ) {
|
|
if ( contents[ type ] && contents[ type ].test( ct ) ) {
|
|
dataTypes.unshift( type );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check to see if we have a response for the expected dataType
|
|
if ( dataTypes[ 0 ] in responses ) {
|
|
finalDataType = dataTypes[ 0 ];
|
|
} else {
|
|
|
|
// Try convertible dataTypes
|
|
for ( type in responses ) {
|
|
if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
|
|
finalDataType = type;
|
|
break;
|
|
}
|
|
if ( !firstDataType ) {
|
|
firstDataType = type;
|
|
}
|
|
}
|
|
|
|
// Or just use first one
|
|
finalDataType = finalDataType || firstDataType;
|
|
}
|
|
|
|
// If we found a dataType
|
|
// We add the dataType to the list if needed
|
|
// and return the corresponding response
|
|
if ( finalDataType ) {
|
|
if ( finalDataType !== dataTypes[ 0 ] ) {
|
|
dataTypes.unshift( finalDataType );
|
|
}
|
|
return responses[ finalDataType ];
|
|
}
|
|
}
|
|
|
|
/* Chain conversions given the request and the original response
|
|
* Also sets the responseXXX fields on the jqXHR instance
|
|
*/
|
|
function ajaxConvert( s, response, jqXHR, isSuccess ) {
|
|
var conv2, current, conv, tmp, prev,
|
|
converters = {},
|
|
|
|
// Work with a copy of dataTypes in case we need to modify it for conversion
|
|
dataTypes = s.dataTypes.slice();
|
|
|
|
// Create converters map with lowercased keys
|
|
if ( dataTypes[ 1 ] ) {
|
|
for ( conv in s.converters ) {
|
|
converters[ conv.toLowerCase() ] = s.converters[ conv ];
|
|
}
|
|
}
|
|
|
|
current = dataTypes.shift();
|
|
|
|
// Convert to each sequential dataType
|
|
while ( current ) {
|
|
|
|
if ( s.responseFields[ current ] ) {
|
|
jqXHR[ s.responseFields[ current ] ] = response;
|
|
}
|
|
|
|
// Apply the dataFilter if provided
|
|
if ( !prev && isSuccess && s.dataFilter ) {
|
|
response = s.dataFilter( response, s.dataType );
|
|
}
|
|
|
|
prev = current;
|
|
current = dataTypes.shift();
|
|
|
|
if ( current ) {
|
|
|
|
// There's only work to do if current dataType is non-auto
|
|
if ( current === "*" ) {
|
|
|
|
current = prev;
|
|
|
|
// Convert response if prev dataType is non-auto and differs from current
|
|
} else if ( prev !== "*" && prev !== current ) {
|
|
|
|
// Seek a direct converter
|
|
conv = converters[ prev + " " + current ] || converters[ "* " + current ];
|
|
|
|
// If none found, seek a pair
|
|
if ( !conv ) {
|
|
for ( conv2 in converters ) {
|
|
|
|
// If conv2 outputs current
|
|
tmp = conv2.split( " " );
|
|
if ( tmp[ 1 ] === current ) {
|
|
|
|
// If prev can be converted to accepted input
|
|
conv = converters[ prev + " " + tmp[ 0 ] ] ||
|
|
converters[ "* " + tmp[ 0 ] ];
|
|
if ( conv ) {
|
|
|
|
// Condense equivalence converters
|
|
if ( conv === true ) {
|
|
conv = converters[ conv2 ];
|
|
|
|
// Otherwise, insert the intermediate dataType
|
|
} else if ( converters[ conv2 ] !== true ) {
|
|
current = tmp[ 0 ];
|
|
dataTypes.unshift( tmp[ 1 ] );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Apply converter (if not an equivalence)
|
|
if ( conv !== true ) {
|
|
|
|
// Unless errors are allowed to bubble, catch and return them
|
|
if ( conv && s.throws ) {
|
|
response = conv( response );
|
|
} else {
|
|
try {
|
|
response = conv( response );
|
|
} catch ( e ) {
|
|
return {
|
|
state: "parsererror",
|
|
error: conv ? e : "No conversion from " + prev + " to " + current
|
|
};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return { state: "success", data: response };
|
|
}
|
|
|
|
jQuery.extend( {
|
|
|
|
// Counter for holding the number of active queries
|
|
active: 0,
|
|
|
|
// Last-Modified header cache for next request
|
|
lastModified: {},
|
|
etag: {},
|
|
|
|
ajaxSettings: {
|
|
url: location.href,
|
|
type: "GET",
|
|
isLocal: rlocalProtocol.test( location.protocol ),
|
|
global: true,
|
|
processData: true,
|
|
async: true,
|
|
contentType: "application/x-www-form-urlencoded; charset=UTF-8",
|
|
|
|
/*
|
|
timeout: 0,
|
|
data: null,
|
|
dataType: null,
|
|
username: null,
|
|
password: null,
|
|
cache: null,
|
|
throws: false,
|
|
traditional: false,
|
|
headers: {},
|
|
*/
|
|
|
|
accepts: {
|
|
"*": allTypes,
|
|
text: "text/plain",
|
|
html: "text/html",
|
|
xml: "application/xml, text/xml",
|
|
json: "application/json, text/javascript"
|
|
},
|
|
|
|
contents: {
|
|
xml: /\bxml\b/,
|
|
html: /\bhtml/,
|
|
json: /\bjson\b/
|
|
},
|
|
|
|
responseFields: {
|
|
xml: "responseXML",
|
|
text: "responseText",
|
|
json: "responseJSON"
|
|
},
|
|
|
|
// Data converters
|
|
// Keys separate source (or catchall "*") and destination types with a single space
|
|
converters: {
|
|
|
|
// Convert anything to text
|
|
"* text": String,
|
|
|
|
// Text to html (true = no transformation)
|
|
"text html": true,
|
|
|
|
// Evaluate text as a json expression
|
|
"text json": JSON.parse,
|
|
|
|
// Parse text as xml
|
|
"text xml": jQuery.parseXML
|
|
},
|
|
|
|
// For options that shouldn't be deep extended:
|
|
// you can add your own custom options here if
|
|
// and when you create one that shouldn't be
|
|
// deep extended (see ajaxExtend)
|
|
flatOptions: {
|
|
url: true,
|
|
context: true
|
|
}
|
|
},
|
|
|
|
// Creates a full fledged settings object into target
|
|
// with both ajaxSettings and settings fields.
|
|
// If target is omitted, writes into ajaxSettings.
|
|
ajaxSetup: function( target, settings ) {
|
|
return settings ?
|
|
|
|
// Building a settings object
|
|
ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
|
|
|
|
// Extending ajaxSettings
|
|
ajaxExtend( jQuery.ajaxSettings, target );
|
|
},
|
|
|
|
ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
|
|
ajaxTransport: addToPrefiltersOrTransports( transports ),
|
|
|
|
// Main method
|
|
ajax: function( url, options ) {
|
|
|
|
// If url is an object, simulate pre-1.5 signature
|
|
if ( typeof url === "object" ) {
|
|
options = url;
|
|
url = undefined;
|
|
}
|
|
|
|
// Force options to be an object
|
|
options = options || {};
|
|
|
|
var transport,
|
|
|
|
// URL without anti-cache param
|
|
cacheURL,
|
|
|
|
// Response headers
|
|
responseHeadersString,
|
|
responseHeaders,
|
|
|
|
// timeout handle
|
|
timeoutTimer,
|
|
|
|
// Url cleanup var
|
|
urlAnchor,
|
|
|
|
// Request state (becomes false upon send and true upon completion)
|
|
completed,
|
|
|
|
// To know if global events are to be dispatched
|
|
fireGlobals,
|
|
|
|
// Loop variable
|
|
i,
|
|
|
|
// uncached part of the url
|
|
uncached,
|
|
|
|
// Create the final options object
|
|
s = jQuery.ajaxSetup( {}, options ),
|
|
|
|
// Callbacks context
|
|
callbackContext = s.context || s,
|
|
|
|
// Context for global events is callbackContext if it is a DOM node or jQuery collection
|
|
globalEventContext = s.context &&
|
|
( callbackContext.nodeType || callbackContext.jquery ) ?
|
|
jQuery( callbackContext ) :
|
|
jQuery.event,
|
|
|
|
// Deferreds
|
|
deferred = jQuery.Deferred(),
|
|
completeDeferred = jQuery.Callbacks( "once memory" ),
|
|
|
|
// Status-dependent callbacks
|
|
statusCode = s.statusCode || {},
|
|
|
|
// Headers (they are sent all at once)
|
|
requestHeaders = {},
|
|
requestHeadersNames = {},
|
|
|
|
// Default abort message
|
|
strAbort = "canceled",
|
|
|
|
// Fake xhr
|
|
jqXHR = {
|
|
readyState: 0,
|
|
|
|
// Builds headers hashtable if needed
|
|
getResponseHeader: function( key ) {
|
|
var match;
|
|
if ( completed ) {
|
|
if ( !responseHeaders ) {
|
|
responseHeaders = {};
|
|
while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
|
|
responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
|
|
}
|
|
}
|
|
match = responseHeaders[ key.toLowerCase() ];
|
|
}
|
|
return match == null ? null : match;
|
|
},
|
|
|
|
// Raw string
|
|
getAllResponseHeaders: function() {
|
|
return completed ? responseHeadersString : null;
|
|
},
|
|
|
|
// Caches the header
|
|
setRequestHeader: function( name, value ) {
|
|
if ( completed == null ) {
|
|
name = requestHeadersNames[ name.toLowerCase() ] =
|
|
requestHeadersNames[ name.toLowerCase() ] || name;
|
|
requestHeaders[ name ] = value;
|
|
}
|
|
return this;
|
|
},
|
|
|
|
// Overrides response content-type header
|
|
overrideMimeType: function( type ) {
|
|
if ( completed == null ) {
|
|
s.mimeType = type;
|
|
}
|
|
return this;
|
|
},
|
|
|
|
// Status-dependent callbacks
|
|
statusCode: function( map ) {
|
|
var code;
|
|
if ( map ) {
|
|
if ( completed ) {
|
|
|
|
// Execute the appropriate callbacks
|
|
jqXHR.always( map[ jqXHR.status ] );
|
|
} else {
|
|
|
|
// Lazy-add the new callbacks in a way that preserves old ones
|
|
for ( code in map ) {
|
|
statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
|
|
}
|
|
}
|
|
}
|
|
return this;
|
|
},
|
|
|
|
// Cancel the request
|
|
abort: function( statusText ) {
|
|
var finalText = statusText || strAbort;
|
|
if ( transport ) {
|
|
transport.abort( finalText );
|
|
}
|
|
done( 0, finalText );
|
|
return this;
|
|
}
|
|
};
|
|
|
|
// Attach deferreds
|
|
deferred.promise( jqXHR );
|
|
|
|
// Add protocol if not provided (prefilters might expect it)
|
|
// Handle falsy url in the settings object (#10093: consistency with old signature)
|
|
// We also use the url parameter if available
|
|
s.url = ( ( url || s.url || location.href ) + "" )
|
|
.replace( rprotocol, location.protocol + "//" );
|
|
|
|
// Alias method option to type as per ticket #12004
|
|
s.type = options.method || options.type || s.method || s.type;
|
|
|
|
// Extract dataTypes list
|
|
s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
|
|
|
|
// A cross-domain request is in order when the origin doesn't match the current origin.
|
|
if ( s.crossDomain == null ) {
|
|
urlAnchor = document.createElement( "a" );
|
|
|
|
// Support: IE <=8 - 11, Edge 12 - 13
|
|
// IE throws exception on accessing the href property if url is malformed,
|
|
// e.g. http://example.com:80x/
|
|
try {
|
|
urlAnchor.href = s.url;
|
|
|
|
// Support: IE <=8 - 11 only
|
|
// Anchor's host property isn't correctly set when s.url is relative
|
|
urlAnchor.href = urlAnchor.href;
|
|
s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
|
|
urlAnchor.protocol + "//" + urlAnchor.host;
|
|
} catch ( e ) {
|
|
|
|
// If there is an error parsing the URL, assume it is crossDomain,
|
|
// it can be rejected by the transport if it is invalid
|
|
s.crossDomain = true;
|
|
}
|
|
}
|
|
|
|
// Convert data if not already a string
|
|
if ( s.data && s.processData && typeof s.data !== "string" ) {
|
|
s.data = jQuery.param( s.data, s.traditional );
|
|
}
|
|
|
|
// Apply prefilters
|
|
inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
|
|
|
|
// If request was aborted inside a prefilter, stop there
|
|
if ( completed ) {
|
|
return jqXHR;
|
|
}
|
|
|
|
// We can fire global events as of now if asked to
|
|
// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
|
|
fireGlobals = jQuery.event && s.global;
|
|
|
|
// Watch for a new set of requests
|
|
if ( fireGlobals && jQuery.active++ === 0 ) {
|
|
jQuery.event.trigger( "ajaxStart" );
|
|
}
|
|
|
|
// Uppercase the type
|
|
s.type = s.type.toUpperCase();
|
|
|
|
// Determine if request has content
|
|
s.hasContent = !rnoContent.test( s.type );
|
|
|
|
// Save the URL in case we're toying with the If-Modified-Since
|
|
// and/or If-None-Match header later on
|
|
// Remove hash to simplify url manipulation
|
|
cacheURL = s.url.replace( rhash, "" );
|
|
|
|
// More options handling for requests with no content
|
|
if ( !s.hasContent ) {
|
|
|
|
// Remember the hash so we can put it back
|
|
uncached = s.url.slice( cacheURL.length );
|
|
|
|
// If data is available, append data to url
|
|
if ( s.data ) {
|
|
cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
|
|
|
|
// #9682: remove data so that it's not used in an eventual retry
|
|
delete s.data;
|
|
}
|
|
|
|
// Add or update anti-cache param if needed
|
|
if ( s.cache === false ) {
|
|
cacheURL = cacheURL.replace( rantiCache, "$1" );
|
|
uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached;
|
|
}
|
|
|
|
// Put hash and anti-cache on the URL that will be requested (gh-1732)
|
|
s.url = cacheURL + uncached;
|
|
|
|
// Change '%20' to '+' if this is encoded form body content (gh-2658)
|
|
} else if ( s.data && s.processData &&
|
|
( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
|
|
s.data = s.data.replace( r20, "+" );
|
|
}
|
|
|
|
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
|
|
if ( s.ifModified ) {
|
|
if ( jQuery.lastModified[ cacheURL ] ) {
|
|
jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
|
|
}
|
|
if ( jQuery.etag[ cacheURL ] ) {
|
|
jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
|
|
}
|
|
}
|
|
|
|
// Set the correct header, if data is being sent
|
|
if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
|
|
jqXHR.setRequestHeader( "Content-Type", s.contentType );
|
|
}
|
|
|
|
// Set the Accepts header for the server, depending on the dataType
|
|
jqXHR.setRequestHeader(
|
|
"Accept",
|
|
s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
|
|
s.accepts[ s.dataTypes[ 0 ] ] +
|
|
( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
|
|
s.accepts[ "*" ]
|
|
);
|
|
|
|
// Check for headers option
|
|
for ( i in s.headers ) {
|
|
jqXHR.setRequestHeader( i, s.headers[ i ] );
|
|
}
|
|
|
|
// Allow custom headers/mimetypes and early abort
|
|
if ( s.beforeSend &&
|
|
( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
|
|
|
|
// Abort if not done already and return
|
|
return jqXHR.abort();
|
|
}
|
|
|
|
// Aborting is no longer a cancellation
|
|
strAbort = "abort";
|
|
|
|
// Install callbacks on deferreds
|
|
completeDeferred.add( s.complete );
|
|
jqXHR.done( s.success );
|
|
jqXHR.fail( s.error );
|
|
|
|
// Get transport
|
|
transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
|
|
|
|
// If no transport, we auto-abort
|
|
if ( !transport ) {
|
|
done( -1, "No Transport" );
|
|
} else {
|
|
jqXHR.readyState = 1;
|
|
|
|
// Send global event
|
|
if ( fireGlobals ) {
|
|
globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
|
|
}
|
|
|
|
// If request was aborted inside ajaxSend, stop there
|
|
if ( completed ) {
|
|
return jqXHR;
|
|
}
|
|
|
|
// Timeout
|
|
if ( s.async && s.timeout > 0 ) {
|
|
timeoutTimer = window.setTimeout( function() {
|
|
jqXHR.abort( "timeout" );
|
|
}, s.timeout );
|
|
}
|
|
|
|
try {
|
|
completed = false;
|
|
transport.send( requestHeaders, done );
|
|
} catch ( e ) {
|
|
|
|
// Rethrow post-completion exceptions
|
|
if ( completed ) {
|
|
throw e;
|
|
}
|
|
|
|
// Propagate others as results
|
|
done( -1, e );
|
|
}
|
|
}
|
|
|
|
// Callback for when everything is done
|
|
function done( status, nativeStatusText, responses, headers ) {
|
|
var isSuccess, success, error, response, modified,
|
|
statusText = nativeStatusText;
|
|
|
|
// Ignore repeat invocations
|
|
if ( completed ) {
|
|
return;
|
|
}
|
|
|
|
completed = true;
|
|
|
|
// Clear timeout if it exists
|
|
if ( timeoutTimer ) {
|
|
window.clearTimeout( timeoutTimer );
|
|
}
|
|
|
|
// Dereference transport for early garbage collection
|
|
// (no matter how long the jqXHR object will be used)
|
|
transport = undefined;
|
|
|
|
// Cache response headers
|
|
responseHeadersString = headers || "";
|
|
|
|
// Set readyState
|
|
jqXHR.readyState = status > 0 ? 4 : 0;
|
|
|
|
// Determine if successful
|
|
isSuccess = status >= 200 && status < 300 || status === 304;
|
|
|
|
// Get response data
|
|
if ( responses ) {
|
|
response = ajaxHandleResponses( s, jqXHR, responses );
|
|
}
|
|
|
|
// Convert no matter what (that way responseXXX fields are always set)
|
|
response = ajaxConvert( s, response, jqXHR, isSuccess );
|
|
|
|
// If successful, handle type chaining
|
|
if ( isSuccess ) {
|
|
|
|
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
|
|
if ( s.ifModified ) {
|
|
modified = jqXHR.getResponseHeader( "Last-Modified" );
|
|
if ( modified ) {
|
|
jQuery.lastModified[ cacheURL ] = modified;
|
|
}
|
|
modified = jqXHR.getResponseHeader( "etag" );
|
|
if ( modified ) {
|
|
jQuery.etag[ cacheURL ] = modified;
|
|
}
|
|
}
|
|
|
|
// if no content
|
|
if ( status === 204 || s.type === "HEAD" ) {
|
|
statusText = "nocontent";
|
|
|
|
// if not modified
|
|
} else if ( status === 304 ) {
|
|
statusText = "notmodified";
|
|
|
|
// If we have data, let's convert it
|
|
} else {
|
|
statusText = response.state;
|
|
success = response.data;
|
|
error = response.error;
|
|
isSuccess = !error;
|
|
}
|
|
} else {
|
|
|
|
// Extract error from statusText and normalize for non-aborts
|
|
error = statusText;
|
|
if ( status || !statusText ) {
|
|
statusText = "error";
|
|
if ( status < 0 ) {
|
|
status = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set data for the fake xhr object
|
|
jqXHR.status = status;
|
|
jqXHR.statusText = ( nativeStatusText || statusText ) + "";
|
|
|
|
// Success/Error
|
|
if ( isSuccess ) {
|
|
deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
|
|
} else {
|
|
deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
|
|
}
|
|
|
|
// Status-dependent callbacks
|
|
jqXHR.statusCode( statusCode );
|
|
statusCode = undefined;
|
|
|
|
if ( fireGlobals ) {
|
|
globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
|
|
[ jqXHR, s, isSuccess ? success : error ] );
|
|
}
|
|
|
|
// Complete
|
|
completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
|
|
|
|
if ( fireGlobals ) {
|
|
globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
|
|
|
|
// Handle the global AJAX counter
|
|
if ( !( --jQuery.active ) ) {
|
|
jQuery.event.trigger( "ajaxStop" );
|
|
}
|
|
}
|
|
}
|
|
|
|
return jqXHR;
|
|
},
|
|
|
|
getJSON: function( url, data, callback ) {
|
|
return jQuery.get( url, data, callback, "json" );
|
|
},
|
|
|
|
getScript: function( url, callback ) {
|
|
return jQuery.get( url, undefined, callback, "script" );
|
|
}
|
|
} );
|
|
|
|
jQuery.each( [ "get", "post" ], function( i, method ) {
|
|
jQuery[ method ] = function( url, data, callback, type ) {
|
|
|
|
// Shift arguments if data argument was omitted
|
|
if ( jQuery.isFunction( data ) ) {
|
|
type = type || callback;
|
|
callback = data;
|
|
data = undefined;
|
|
}
|
|
|
|
// The url can be an options object (which then must have .url)
|
|
return jQuery.ajax( jQuery.extend( {
|
|
url: url,
|
|
type: method,
|
|
dataType: type,
|
|
data: data,
|
|
success: callback
|
|
}, jQuery.isPlainObject( url ) && url ) );
|
|
};
|
|
} );
|
|
|
|
|
|
jQuery._evalUrl = function( url ) {
|
|
return jQuery.ajax( {
|
|
url: url,
|
|
|
|
// Make this explicit, since user can override this through ajaxSetup (#11264)
|
|
type: "GET",
|
|
dataType: "script",
|
|
cache: true,
|
|
async: false,
|
|
global: false,
|
|
"throws": true
|
|
} );
|
|
};
|
|
|
|
|
|
jQuery.fn.extend( {
|
|
wrapAll: function( html ) {
|
|
var wrap;
|
|
|
|
if ( this[ 0 ] ) {
|
|
if ( jQuery.isFunction( html ) ) {
|
|
html = html.call( this[ 0 ] );
|
|
}
|
|
|
|
// The elements to wrap the target around
|
|
wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
|
|
|
|
if ( this[ 0 ].parentNode ) {
|
|
wrap.insertBefore( this[ 0 ] );
|
|
}
|
|
|
|
wrap.map( function() {
|
|
var elem = this;
|
|
|
|
while ( elem.firstElementChild ) {
|
|
elem = elem.firstElementChild;
|
|
}
|
|
|
|
return elem;
|
|
} ).append( this );
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
wrapInner: function( html ) {
|
|
if ( jQuery.isFunction( html ) ) {
|
|
return this.each( function( i ) {
|
|
jQuery( this ).wrapInner( html.call( this, i ) );
|
|
} );
|
|
}
|
|
|
|
return this.each( function() {
|
|
var self = jQuery( this ),
|
|
contents = self.contents();
|
|
|
|
if ( contents.length ) {
|
|
contents.wrapAll( html );
|
|
|
|
} else {
|
|
self.append( html );
|
|
}
|
|
} );
|
|
},
|
|
|
|
wrap: function( html ) {
|
|
var isFunction = jQuery.isFunction( html );
|
|
|
|
return this.each( function( i ) {
|
|
jQuery( this ).wrapAll( isFunction ? html.call( this, i ) : html );
|
|
} );
|
|
},
|
|
|
|
unwrap: function( selector ) {
|
|
this.parent( selector ).not( "body" ).each( function() {
|
|
jQuery( this ).replaceWith( this.childNodes );
|
|
} );
|
|
return this;
|
|
}
|
|
} );
|
|
|
|
|
|
jQuery.expr.pseudos.hidden = function( elem ) {
|
|
return !jQuery.expr.pseudos.visible( elem );
|
|
};
|
|
jQuery.expr.pseudos.visible = function( elem ) {
|
|
return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
|
|
};
|
|
|
|
|
|
|
|
|
|
jQuery.ajaxSettings.xhr = function() {
|
|
try {
|
|
return new window.XMLHttpRequest();
|
|
} catch ( e ) {}
|
|
};
|
|
|
|
var xhrSuccessStatus = {
|
|
|
|
// File protocol always yields status code 0, assume 200
|
|
0: 200,
|
|
|
|
// Support: IE <=9 only
|
|
// #1450: sometimes IE returns 1223 when it should be 204
|
|
1223: 204
|
|
},
|
|
xhrSupported = jQuery.ajaxSettings.xhr();
|
|
|
|
support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
|
|
support.ajax = xhrSupported = !!xhrSupported;
|
|
|
|
jQuery.ajaxTransport( function( options ) {
|
|
var callback, errorCallback;
|
|
|
|
// Cross domain only allowed if supported through XMLHttpRequest
|
|
if ( support.cors || xhrSupported && !options.crossDomain ) {
|
|
return {
|
|
send: function( headers, complete ) {
|
|
var i,
|
|
xhr = options.xhr();
|
|
|
|
xhr.open(
|
|
options.type,
|
|
options.url,
|
|
options.async,
|
|
options.username,
|
|
options.password
|
|
);
|
|
|
|
// Apply custom fields if provided
|
|
if ( options.xhrFields ) {
|
|
for ( i in options.xhrFields ) {
|
|
xhr[ i ] = options.xhrFields[ i ];
|
|
}
|
|
}
|
|
|
|
// Override mime type if needed
|
|
if ( options.mimeType && xhr.overrideMimeType ) {
|
|
xhr.overrideMimeType( options.mimeType );
|
|
}
|
|
|
|
// X-Requested-With header
|
|
// For cross-domain requests, seeing as conditions for a preflight are
|
|
// akin to a jigsaw puzzle, we simply never set it to be sure.
|
|
// (it can always be set on a per-request basis or even using ajaxSetup)
|
|
// For same-domain requests, won't change header if already provided.
|
|
if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
|
|
headers[ "X-Requested-With" ] = "XMLHttpRequest";
|
|
}
|
|
|
|
// Set headers
|
|
for ( i in headers ) {
|
|
xhr.setRequestHeader( i, headers[ i ] );
|
|
}
|
|
|
|
// Callback
|
|
callback = function( type ) {
|
|
return function() {
|
|
if ( callback ) {
|
|
callback = errorCallback = xhr.onload =
|
|
xhr.onerror = xhr.onabort = xhr.onreadystatechange = null;
|
|
|
|
if ( type === "abort" ) {
|
|
xhr.abort();
|
|
} else if ( type === "error" ) {
|
|
|
|
// Support: IE <=9 only
|
|
// On a manual native abort, IE9 throws
|
|
// errors on any property access that is not readyState
|
|
if ( typeof xhr.status !== "number" ) {
|
|
complete( 0, "error" );
|
|
} else {
|
|
complete(
|
|
|
|
// File: protocol always yields status 0; see #8605, #14207
|
|
xhr.status,
|
|
xhr.statusText
|
|
);
|
|
}
|
|
} else {
|
|
complete(
|
|
xhrSuccessStatus[ xhr.status ] || xhr.status,
|
|
xhr.statusText,
|
|
|
|
// Support: IE <=9 only
|
|
// IE9 has no XHR2 but throws on binary (trac-11426)
|
|
// For XHR2 non-text, let the caller handle it (gh-2498)
|
|
( xhr.responseType || "text" ) !== "text" ||
|
|
typeof xhr.responseText !== "string" ?
|
|
{ binary: xhr.response } :
|
|
{ text: xhr.responseText },
|
|
xhr.getAllResponseHeaders()
|
|
);
|
|
}
|
|
}
|
|
};
|
|
};
|
|
|
|
// Listen to events
|
|
xhr.onload = callback();
|
|
errorCallback = xhr.onerror = callback( "error" );
|
|
|
|
// Support: IE 9 only
|
|
// Use onreadystatechange to replace onabort
|
|
// to handle uncaught aborts
|
|
if ( xhr.onabort !== undefined ) {
|
|
xhr.onabort = errorCallback;
|
|
} else {
|
|
xhr.onreadystatechange = function() {
|
|
|
|
// Check readyState before timeout as it changes
|
|
if ( xhr.readyState === 4 ) {
|
|
|
|
// Allow onerror to be called first,
|
|
// but that will not handle a native abort
|
|
// Also, save errorCallback to a variable
|
|
// as xhr.onerror cannot be accessed
|
|
window.setTimeout( function() {
|
|
if ( callback ) {
|
|
errorCallback();
|
|
}
|
|
} );
|
|
}
|
|
};
|
|
}
|
|
|
|
// Create the abort callback
|
|
callback = callback( "abort" );
|
|
|
|
try {
|
|
|
|
// Do send the request (this may raise an exception)
|
|
xhr.send( options.hasContent && options.data || null );
|
|
} catch ( e ) {
|
|
|
|
// #14683: Only rethrow if this hasn't been notified as an error yet
|
|
if ( callback ) {
|
|
throw e;
|
|
}
|
|
}
|
|
},
|
|
|
|
abort: function() {
|
|
if ( callback ) {
|
|
callback();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
} );
|
|
|
|
|
|
|
|
|
|
// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
|
|
jQuery.ajaxPrefilter( function( s ) {
|
|
if ( s.crossDomain ) {
|
|
s.contents.script = false;
|
|
}
|
|
} );
|
|
|
|
// Install script dataType
|
|
jQuery.ajaxSetup( {
|
|
accepts: {
|
|
script: "text/javascript, application/javascript, " +
|
|
"application/ecmascript, application/x-ecmascript"
|
|
},
|
|
contents: {
|
|
script: /\b(?:java|ecma)script\b/
|
|
},
|
|
converters: {
|
|
"text script": function( text ) {
|
|
jQuery.globalEval( text );
|
|
return text;
|
|
}
|
|
}
|
|
} );
|
|
|
|
// Handle cache's special case and crossDomain
|
|
jQuery.ajaxPrefilter( "script", function( s ) {
|
|
if ( s.cache === undefined ) {
|
|
s.cache = false;
|
|
}
|
|
if ( s.crossDomain ) {
|
|
s.type = "GET";
|
|
}
|
|
} );
|
|
|
|
// Bind script tag hack transport
|
|
jQuery.ajaxTransport( "script", function( s ) {
|
|
|
|
// This transport only deals with cross domain requests
|
|
if ( s.crossDomain ) {
|
|
var script, callback;
|
|
return {
|
|
send: function( _, complete ) {
|
|
script = jQuery( "<script>" ).prop( {
|
|
charset: s.scriptCharset,
|
|
src: s.url
|
|
} ).on(
|
|
"load error",
|
|
callback = function( evt ) {
|
|
script.remove();
|
|
callback = null;
|
|
if ( evt ) {
|
|
complete( evt.type === "error" ? 404 : 200, evt.type );
|
|
}
|
|
}
|
|
);
|
|
|
|
// Use native DOM manipulation to avoid our domManip AJAX trickery
|
|
document.head.appendChild( script[ 0 ] );
|
|
},
|
|
abort: function() {
|
|
if ( callback ) {
|
|
callback();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
} );
|
|
|
|
|
|
|
|
|
|
var oldCallbacks = [],
|
|
rjsonp = /(=)\?(?=&|$)|\?\?/;
|
|
|
|
// Default jsonp settings
|
|
jQuery.ajaxSetup( {
|
|
jsonp: "callback",
|
|
jsonpCallback: function() {
|
|
var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
|
|
this[ callback ] = true;
|
|
return callback;
|
|
}
|
|
} );
|
|
|
|
// Detect, normalize options and install callbacks for jsonp requests
|
|
jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
|
|
|
|
var callbackName, overwritten, responseContainer,
|
|
jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
|
|
"url" :
|
|
typeof s.data === "string" &&
|
|
( s.contentType || "" )
|
|
.indexOf( "application/x-www-form-urlencoded" ) === 0 &&
|
|
rjsonp.test( s.data ) && "data"
|
|
);
|
|
|
|
// Handle iff the expected data type is "jsonp" or we have a parameter to set
|
|
if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
|
|
|
|
// Get callback name, remembering preexisting value associated with it
|
|
callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
|
|
s.jsonpCallback() :
|
|
s.jsonpCallback;
|
|
|
|
// Insert callback into url or form data
|
|
if ( jsonProp ) {
|
|
s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
|
|
} else if ( s.jsonp !== false ) {
|
|
s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
|
|
}
|
|
|
|
// Use data converter to retrieve json after script execution
|
|
s.converters[ "script json" ] = function() {
|
|
if ( !responseContainer ) {
|
|
jQuery.error( callbackName + " was not called" );
|
|
}
|
|
return responseContainer[ 0 ];
|
|
};
|
|
|
|
// Force json dataType
|
|
s.dataTypes[ 0 ] = "json";
|
|
|
|
// Install callback
|
|
overwritten = window[ callbackName ];
|
|
window[ callbackName ] = function() {
|
|
responseContainer = arguments;
|
|
};
|
|
|
|
// Clean-up function (fires after converters)
|
|
jqXHR.always( function() {
|
|
|
|
// If previous value didn't exist - remove it
|
|
if ( overwritten === undefined ) {
|
|
jQuery( window ).removeProp( callbackName );
|
|
|
|
// Otherwise restore preexisting value
|
|
} else {
|
|
window[ callbackName ] = overwritten;
|
|
}
|
|
|
|
// Save back as free
|
|
if ( s[ callbackName ] ) {
|
|
|
|
// Make sure that re-using the options doesn't screw things around
|
|
s.jsonpCallback = originalSettings.jsonpCallback;
|
|
|
|
// Save the callback name for future use
|
|
oldCallbacks.push( callbackName );
|
|
}
|
|
|
|
// Call if it was a function and we have a response
|
|
if ( responseContainer && jQuery.isFunction( overwritten ) ) {
|
|
overwritten( responseContainer[ 0 ] );
|
|
}
|
|
|
|
responseContainer = overwritten = undefined;
|
|
} );
|
|
|
|
// Delegate to script
|
|
return "script";
|
|
}
|
|
} );
|
|
|
|
|
|
|
|
|
|
// Support: Safari 8 only
|
|
// In Safari 8 documents created via document.implementation.createHTMLDocument
|
|
// collapse sibling forms: the second one becomes a child of the first one.
|
|
// Because of that, this security measure has to be disabled in Safari 8.
|
|
// https://bugs.webkit.org/show_bug.cgi?id=137337
|
|
support.createHTMLDocument = ( function() {
|
|
var body = document.implementation.createHTMLDocument( "" ).body;
|
|
body.innerHTML = "<form></form><form></form>";
|
|
return body.childNodes.length === 2;
|
|
} )();
|
|
|
|
|
|
// Argument "data" should be string of html
|
|
// context (optional): If specified, the fragment will be created in this context,
|
|
// defaults to document
|
|
// keepScripts (optional): If true, will include scripts passed in the html string
|
|
jQuery.parseHTML = function( data, context, keepScripts ) {
|
|
if ( typeof data !== "string" ) {
|
|
return [];
|
|
}
|
|
if ( typeof context === "boolean" ) {
|
|
keepScripts = context;
|
|
context = false;
|
|
}
|
|
|
|
var base, parsed, scripts;
|
|
|
|
if ( !context ) {
|
|
|
|
// Stop scripts or inline event handlers from being executed immediately
|
|
// by using document.implementation
|
|
if ( support.createHTMLDocument ) {
|
|
context = document.implementation.createHTMLDocument( "" );
|
|
|
|
// Set the base href for the created document
|
|
// so any parsed elements with URLs
|
|
// are based on the document's URL (gh-2965)
|
|
base = context.createElement( "base" );
|
|
base.href = document.location.href;
|
|
context.head.appendChild( base );
|
|
} else {
|
|
context = document;
|
|
}
|
|
}
|
|
|
|
parsed = rsingleTag.exec( data );
|
|
scripts = !keepScripts && [];
|
|
|
|
// Single tag
|
|
if ( parsed ) {
|
|
return [ context.createElement( parsed[ 1 ] ) ];
|
|
}
|
|
|
|
parsed = buildFragment( [ data ], context, scripts );
|
|
|
|
if ( scripts && scripts.length ) {
|
|
jQuery( scripts ).remove();
|
|
}
|
|
|
|
return jQuery.merge( [], parsed.childNodes );
|
|
};
|
|
|
|
|
|
/**
|
|
* Load a url into a page
|
|
*/
|
|
jQuery.fn.load = function( url, params, callback ) {
|
|
var selector, type, response,
|
|
self = this,
|
|
off = url.indexOf( " " );
|
|
|
|
if ( off > -1 ) {
|
|
selector = stripAndCollapse( url.slice( off ) );
|
|
url = url.slice( 0, off );
|
|
}
|
|
|
|
// If it's a function
|
|
if ( jQuery.isFunction( params ) ) {
|
|
|
|
// We assume that it's the callback
|
|
callback = params;
|
|
params = undefined;
|
|
|
|
// Otherwise, build a param string
|
|
} else if ( params && typeof params === "object" ) {
|
|
type = "POST";
|
|
}
|
|
|
|
// If we have elements to modify, make the request
|
|
if ( self.length > 0 ) {
|
|
jQuery.ajax( {
|
|
url: url,
|
|
|
|
// If "type" variable is undefined, then "GET" method will be used.
|
|
// Make value of this field explicit since
|
|
// user can override it through ajaxSetup method
|
|
type: type || "GET",
|
|
dataType: "html",
|
|
data: params
|
|
} ).done( function( responseText ) {
|
|
|
|
// Save response for use in complete callback
|
|
response = arguments;
|
|
|
|
self.html( selector ?
|
|
|
|
// If a selector was specified, locate the right elements in a dummy div
|
|
// Exclude scripts to avoid IE 'Permission Denied' errors
|
|
jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
|
|
|
|
// Otherwise use the full result
|
|
responseText );
|
|
|
|
// If the request succeeds, this function gets "data", "status", "jqXHR"
|
|
// but they are ignored because response was set above.
|
|
// If it fails, this function gets "jqXHR", "status", "error"
|
|
} ).always( callback && function( jqXHR, status ) {
|
|
self.each( function() {
|
|
callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
|
|
} );
|
|
} );
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
|
|
|
|
|
|
// Attach a bunch of functions for handling common AJAX events
|
|
jQuery.each( [
|
|
"ajaxStart",
|
|
"ajaxStop",
|
|
"ajaxComplete",
|
|
"ajaxError",
|
|
"ajaxSuccess",
|
|
"ajaxSend"
|
|
], function( i, type ) {
|
|
jQuery.fn[ type ] = function( fn ) {
|
|
return this.on( type, fn );
|
|
};
|
|
} );
|
|
|
|
|
|
|
|
|
|
jQuery.expr.pseudos.animated = function( elem ) {
|
|
return jQuery.grep( jQuery.timers, function( fn ) {
|
|
return elem === fn.elem;
|
|
} ).length;
|
|
};
|
|
|
|
|
|
|
|
|
|
jQuery.offset = {
|
|
setOffset: function( elem, options, i ) {
|
|
var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
|
|
position = jQuery.css( elem, "position" ),
|
|
curElem = jQuery( elem ),
|
|
props = {};
|
|
|
|
// Set position first, in-case top/left are set even on static elem
|
|
if ( position === "static" ) {
|
|
elem.style.position = "relative";
|
|
}
|
|
|
|
curOffset = curElem.offset();
|
|
curCSSTop = jQuery.css( elem, "top" );
|
|
curCSSLeft = jQuery.css( elem, "left" );
|
|
calculatePosition = ( position === "absolute" || position === "fixed" ) &&
|
|
( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;
|
|
|
|
// Need to be able to calculate position if either
|
|
// top or left is auto and position is either absolute or fixed
|
|
if ( calculatePosition ) {
|
|
curPosition = curElem.position();
|
|
curTop = curPosition.top;
|
|
curLeft = curPosition.left;
|
|
|
|
} else {
|
|
curTop = parseFloat( curCSSTop ) || 0;
|
|
curLeft = parseFloat( curCSSLeft ) || 0;
|
|
}
|
|
|
|
if ( jQuery.isFunction( options ) ) {
|
|
|
|
// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
|
|
options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
|
|
}
|
|
|
|
if ( options.top != null ) {
|
|
props.top = ( options.top - curOffset.top ) + curTop;
|
|
}
|
|
if ( options.left != null ) {
|
|
props.left = ( options.left - curOffset.left ) + curLeft;
|
|
}
|
|
|
|
if ( "using" in options ) {
|
|
options.using.call( elem, props );
|
|
|
|
} else {
|
|
curElem.css( props );
|
|
}
|
|
}
|
|
};
|
|
|
|
jQuery.fn.extend( {
|
|
offset: function( options ) {
|
|
|
|
// Preserve chaining for setter
|
|
if ( arguments.length ) {
|
|
return options === undefined ?
|
|
this :
|
|
this.each( function( i ) {
|
|
jQuery.offset.setOffset( this, options, i );
|
|
} );
|
|
}
|
|
|
|
var doc, docElem, rect, win,
|
|
elem = this[ 0 ];
|
|
|
|
if ( !elem ) {
|
|
return;
|
|
}
|
|
|
|
// Return zeros for disconnected and hidden (display: none) elements (gh-2310)
|
|
// Support: IE <=11 only
|
|
// Running getBoundingClientRect on a
|
|
// disconnected node in IE throws an error
|
|
if ( !elem.getClientRects().length ) {
|
|
return { top: 0, left: 0 };
|
|
}
|
|
|
|
rect = elem.getBoundingClientRect();
|
|
|
|
doc = elem.ownerDocument;
|
|
docElem = doc.documentElement;
|
|
win = doc.defaultView;
|
|
|
|
return {
|
|
top: rect.top + win.pageYOffset - docElem.clientTop,
|
|
left: rect.left + win.pageXOffset - docElem.clientLeft
|
|
};
|
|
},
|
|
|
|
position: function() {
|
|
if ( !this[ 0 ] ) {
|
|
return;
|
|
}
|
|
|
|
var offsetParent, offset,
|
|
elem = this[ 0 ],
|
|
parentOffset = { top: 0, left: 0 };
|
|
|
|
// Fixed elements are offset from window (parentOffset = {top:0, left: 0},
|
|
// because it is its only offset parent
|
|
if ( jQuery.css( elem, "position" ) === "fixed" ) {
|
|
|
|
// Assume getBoundingClientRect is there when computed position is fixed
|
|
offset = elem.getBoundingClientRect();
|
|
|
|
} else {
|
|
|
|
// Get *real* offsetParent
|
|
offsetParent = this.offsetParent();
|
|
|
|
// Get correct offsets
|
|
offset = this.offset();
|
|
if ( !nodeName( offsetParent[ 0 ], "html" ) ) {
|
|
parentOffset = offsetParent.offset();
|
|
}
|
|
|
|
// Add offsetParent borders
|
|
parentOffset = {
|
|
top: parentOffset.top + jQuery.css( offsetParent[ 0 ], "borderTopWidth", true ),
|
|
left: parentOffset.left + jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true )
|
|
};
|
|
}
|
|
|
|
// Subtract parent offsets and element margins
|
|
return {
|
|
top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
|
|
left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
|
|
};
|
|
},
|
|
|
|
// This method will return documentElement in the following cases:
|
|
// 1) For the element inside the iframe without offsetParent, this method will return
|
|
// documentElement of the parent window
|
|
// 2) For the hidden or detached element
|
|
// 3) For body or html element, i.e. in case of the html node - it will return itself
|
|
//
|
|
// but those exceptions were never presented as a real life use-cases
|
|
// and might be considered as more preferable results.
|
|
//
|
|
// This logic, however, is not guaranteed and can change at any point in the future
|
|
offsetParent: function() {
|
|
return this.map( function() {
|
|
var offsetParent = this.offsetParent;
|
|
|
|
while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {
|
|
offsetParent = offsetParent.offsetParent;
|
|
}
|
|
|
|
return offsetParent || documentElement;
|
|
} );
|
|
}
|
|
} );
|
|
|
|
// Create scrollLeft and scrollTop methods
|
|
jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
|
|
var top = "pageYOffset" === prop;
|
|
|
|
jQuery.fn[ method ] = function( val ) {
|
|
return access( this, function( elem, method, val ) {
|
|
|
|
// Coalesce documents and windows
|
|
var win;
|
|
if ( jQuery.isWindow( elem ) ) {
|
|
win = elem;
|
|
} else if ( elem.nodeType === 9 ) {
|
|
win = elem.defaultView;
|
|
}
|
|
|
|
if ( val === undefined ) {
|
|
return win ? win[ prop ] : elem[ method ];
|
|
}
|
|
|
|
if ( win ) {
|
|
win.scrollTo(
|
|
!top ? val : win.pageXOffset,
|
|
top ? val : win.pageYOffset
|
|
);
|
|
|
|
} else {
|
|
elem[ method ] = val;
|
|
}
|
|
}, method, val, arguments.length );
|
|
};
|
|
} );
|
|
|
|
// Support: Safari <=7 - 9.1, Chrome <=37 - 49
|
|
// Add the top/left cssHooks using jQuery.fn.position
|
|
// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
|
|
// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
|
|
// getComputedStyle returns percent when specified for top/left/bottom/right;
|
|
// rather than make the css module depend on the offset module, just check for it here
|
|
jQuery.each( [ "top", "left" ], function( i, prop ) {
|
|
jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
|
|
function( elem, computed ) {
|
|
if ( computed ) {
|
|
computed = curCSS( elem, prop );
|
|
|
|
// If curCSS returns percentage, fallback to offset
|
|
return rnumnonpx.test( computed ) ?
|
|
jQuery( elem ).position()[ prop ] + "px" :
|
|
computed;
|
|
}
|
|
}
|
|
);
|
|
} );
|
|
|
|
|
|
// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
|
|
jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
|
|
jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name },
|
|
function( defaultExtra, funcName ) {
|
|
|
|
// Margin is only for outerHeight, outerWidth
|
|
jQuery.fn[ funcName ] = function( margin, value ) {
|
|
var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
|
|
extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
|
|
|
|
return access( this, function( elem, type, value ) {
|
|
var doc;
|
|
|
|
if ( jQuery.isWindow( elem ) ) {
|
|
|
|
// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
|
|
return funcName.indexOf( "outer" ) === 0 ?
|
|
elem[ "inner" + name ] :
|
|
elem.document.documentElement[ "client" + name ];
|
|
}
|
|
|
|
// Get document width or height
|
|
if ( elem.nodeType === 9 ) {
|
|
doc = elem.documentElement;
|
|
|
|
// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
|
|
// whichever is greatest
|
|
return Math.max(
|
|
elem.body[ "scroll" + name ], doc[ "scroll" + name ],
|
|
elem.body[ "offset" + name ], doc[ "offset" + name ],
|
|
doc[ "client" + name ]
|
|
);
|
|
}
|
|
|
|
return value === undefined ?
|
|
|
|
// Get width or height on the element, requesting but not forcing parseFloat
|
|
jQuery.css( elem, type, extra ) :
|
|
|
|
// Set width or height on the element
|
|
jQuery.style( elem, type, value, extra );
|
|
}, type, chainable ? margin : undefined, chainable );
|
|
};
|
|
} );
|
|
} );
|
|
|
|
|
|
jQuery.fn.extend( {
|
|
|
|
bind: function( types, data, fn ) {
|
|
return this.on( types, null, data, fn );
|
|
},
|
|
unbind: function( types, fn ) {
|
|
return this.off( types, null, fn );
|
|
},
|
|
|
|
delegate: function( selector, types, data, fn ) {
|
|
return this.on( types, selector, data, fn );
|
|
},
|
|
undelegate: function( selector, types, fn ) {
|
|
|
|
// ( namespace ) or ( selector, types [, fn] )
|
|
return arguments.length === 1 ?
|
|
this.off( selector, "**" ) :
|
|
this.off( types, selector || "**", fn );
|
|
}
|
|
} );
|
|
|
|
jQuery.holdReady = function( hold ) {
|
|
if ( hold ) {
|
|
jQuery.readyWait++;
|
|
} else {
|
|
jQuery.ready( true );
|
|
}
|
|
};
|
|
jQuery.isArray = Array.isArray;
|
|
jQuery.parseJSON = JSON.parse;
|
|
jQuery.nodeName = nodeName;
|
|
|
|
|
|
|
|
|
|
// Register as a named AMD module, since jQuery can be concatenated with other
|
|
// files that may use define, but not via a proper concatenation script that
|
|
// understands anonymous AMD modules. A named AMD is safest and most robust
|
|
// way to register. Lowercase jquery is used because AMD module names are
|
|
// derived from file names, and jQuery is normally delivered in a lowercase
|
|
// file name. Do this after creating the global so that if an AMD module wants
|
|
// to call noConflict to hide this version of jQuery, it will work.
|
|
|
|
// Note that for maximum portability, libraries that are not jQuery should
|
|
// declare themselves as anonymous modules, and avoid setting a global if an
|
|
// AMD loader is present. jQuery is a special case. For more information, see
|
|
// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
|
|
|
|
if ( typeof define === "function" && define.amd ) {
|
|
define( "jquery", [], function() {
|
|
return jQuery;
|
|
} );
|
|
}
|
|
|
|
|
|
|
|
|
|
var
|
|
|
|
// Map over jQuery in case of overwrite
|
|
_jQuery = window.jQuery,
|
|
|
|
// Map over the $ in case of overwrite
|
|
_$ = window.$;
|
|
|
|
jQuery.noConflict = function( deep ) {
|
|
if ( window.$ === jQuery ) {
|
|
window.$ = _$;
|
|
}
|
|
|
|
if ( deep && window.jQuery === jQuery ) {
|
|
window.jQuery = _jQuery;
|
|
}
|
|
|
|
return jQuery;
|
|
};
|
|
|
|
// Expose jQuery and $ identifiers, even in AMD
|
|
// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
|
|
// and CommonJS for browser emulators (#13566)
|
|
if ( !noGlobal ) {
|
|
window.jQuery = window.$ = jQuery;
|
|
}
|
|
|
|
|
|
|
|
|
|
return jQuery;
|
|
} );
|
|
|
|
/*
|
|
Leaflet 1.0.3, a JS library for interactive maps. http://leafletjs.com
|
|
(c) 2010-2016 Vladimir Agafonkin, (c) 2010-2011 CloudMade
|
|
*/
|
|
!function(t,e,i){function n(){var e=t.L;o.noConflict=function(){return t.L=e,this},t.L=o}var o={version:"1.0.3"};"object"==typeof module&&"object"==typeof module.exports?module.exports=o:"function"==typeof define&&define.amd&&define(o),"undefined"!=typeof t&&n(),o.Util={extend:function(t){var e,i,n,o;for(i=1,n=arguments.length;i<n;i++){o=arguments[i];for(e in o)t[e]=o[e]}return t},create:Object.create||function(){function t(){}return function(e){return t.prototype=e,new t}}(),bind:function(t,e){var i=Array.prototype.slice;if(t.bind)return t.bind.apply(t,i.call(arguments,1));var n=i.call(arguments,2);return function(){return t.apply(e,n.length?n.concat(i.call(arguments)):arguments)}},stamp:function(t){return t._leaflet_id=t._leaflet_id||++o.Util.lastId,t._leaflet_id},lastId:0,throttle:function(t,e,i){var n,o,s,r;return r=function(){n=!1,o&&(s.apply(i,o),o=!1)},s=function(){n?o=arguments:(t.apply(i,arguments),setTimeout(r,e),n=!0)}},wrapNum:function(t,e,i){var n=e[1],o=e[0],s=n-o;return t===n&&i?t:((t-o)%s+s)%s+o},falseFn:function(){return!1},formatNum:function(t,e){var i=Math.pow(10,e||5);return Math.round(t*i)/i},trim:function(t){return t.trim?t.trim():t.replace(/^\s+|\s+$/g,"")},splitWords:function(t){return o.Util.trim(t).split(/\s+/)},setOptions:function(t,e){t.hasOwnProperty("options")||(t.options=t.options?o.Util.create(t.options):{});for(var i in e)t.options[i]=e[i];return t.options},getParamString:function(t,e,i){var n=[];for(var o in t)n.push(encodeURIComponent(i?o.toUpperCase():o)+"="+encodeURIComponent(t[o]));return(e&&e.indexOf("?")!==-1?"&":"?")+n.join("&")},template:function(t,e){return t.replace(o.Util.templateRe,function(t,n){var o=e[n];if(o===i)throw new Error("No value provided for variable "+t);return"function"==typeof o&&(o=o(e)),o})},templateRe:/\{ *([\w_\-]+) *\}/g,isArray:Array.isArray||function(t){return"[object Array]"===Object.prototype.toString.call(t)},indexOf:function(t,e){for(var i=0;i<t.length;i++)if(t[i]===e)return i;return-1},emptyImageUrl:"data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs="},function(){function e(e){return t["webkit"+e]||t["moz"+e]||t["ms"+e]}function i(e){var i=+new Date,o=Math.max(0,16-(i-n));return n=i+o,t.setTimeout(e,o)}var n=0,s=t.requestAnimationFrame||e("RequestAnimationFrame")||i,r=t.cancelAnimationFrame||e("CancelAnimationFrame")||e("CancelRequestAnimationFrame")||function(e){t.clearTimeout(e)};o.Util.requestAnimFrame=function(e,n,r){return r&&s===i?void e.call(n):s.call(t,o.bind(e,n))},o.Util.cancelAnimFrame=function(e){e&&r.call(t,e)}}(),o.extend=o.Util.extend,o.bind=o.Util.bind,o.stamp=o.Util.stamp,o.setOptions=o.Util.setOptions,o.Class=function(){},o.Class.extend=function(t){var e=function(){this.initialize&&this.initialize.apply(this,arguments),this.callInitHooks()},i=e.__super__=this.prototype,n=o.Util.create(i);n.constructor=e,e.prototype=n;for(var s in this)this.hasOwnProperty(s)&&"prototype"!==s&&(e[s]=this[s]);return t.statics&&(o.extend(e,t.statics),delete t.statics),t.includes&&(o.Util.extend.apply(null,[n].concat(t.includes)),delete t.includes),n.options&&(t.options=o.Util.extend(o.Util.create(n.options),t.options)),o.extend(n,t),n._initHooks=[],n.callInitHooks=function(){if(!this._initHooksCalled){i.callInitHooks&&i.callInitHooks.call(this),this._initHooksCalled=!0;for(var t=0,e=n._initHooks.length;t<e;t++)n._initHooks[t].call(this)}},e},o.Class.include=function(t){return o.extend(this.prototype,t),this},o.Class.mergeOptions=function(t){return o.extend(this.prototype.options,t),this},o.Class.addInitHook=function(t){var e=Array.prototype.slice.call(arguments,1),i="function"==typeof t?t:function(){this[t].apply(this,e)};return this.prototype._initHooks=this.prototype._initHooks||[],this.prototype._initHooks.push(i),this},o.Evented=o.Class.extend({on:function(t,e,i){if("object"==typeof t)for(var n in t)this._on(n,t[n],e);else{t=o.Util.splitWords(t);for(var s=0,r=t.length;s<r;s++)this._on(t[s],e,i)}return this},off:function(t,e,i){if(t)if("object"==typeof t)for(var n in t)this._off(n,t[n],e);else{t=o.Util.splitWords(t);for(var s=0,r=t.length;s<r;s++)this._off(t[s],e,i)}else delete this._events;return this},_on:function(t,e,n){this._events=this._events||{};var o=this._events[t];o||(o=[],this._events[t]=o),n===this&&(n=i);for(var s={fn:e,ctx:n},r=o,a=0,h=r.length;a<h;a++)if(r[a].fn===e&&r[a].ctx===n)return;r.push(s)},_off:function(t,e,n){var s,r,a;if(this._events&&(s=this._events[t])){if(!e){for(r=0,a=s.length;r<a;r++)s[r].fn=o.Util.falseFn;return void delete this._events[t]}if(n===this&&(n=i),s)for(r=0,a=s.length;r<a;r++){var h=s[r];if(h.ctx===n&&h.fn===e)return h.fn=o.Util.falseFn,this._firingCount&&(this._events[t]=s=s.slice()),void s.splice(r,1)}}},fire:function(t,e,i){if(!this.listens(t,i))return this;var n=o.Util.extend({},e,{type:t,target:this});if(this._events){var s=this._events[t];if(s){this._firingCount=this._firingCount+1||1;for(var r=0,a=s.length;r<a;r++){var h=s[r];h.fn.call(h.ctx||this,n)}this._firingCount--}}return i&&this._propagateEvent(n),this},listens:function(t,e){var i=this._events&&this._events[t];if(i&&i.length)return!0;if(e)for(var n in this._eventParents)if(this._eventParents[n].listens(t,e))return!0;return!1},once:function(t,e,i){if("object"==typeof t){for(var n in t)this.once(n,t[n],e);return this}var s=o.bind(function(){this.off(t,e,i).off(t,s,i)},this);return this.on(t,e,i).on(t,s,i)},addEventParent:function(t){return this._eventParents=this._eventParents||{},this._eventParents[o.stamp(t)]=t,this},removeEventParent:function(t){return this._eventParents&&delete this._eventParents[o.stamp(t)],this},_propagateEvent:function(t){for(var e in this._eventParents)this._eventParents[e].fire(t.type,o.extend({layer:t.target},t),!0)}});var s=o.Evented.prototype;s.addEventListener=s.on,s.removeEventListener=s.clearAllEventListeners=s.off,s.addOneTimeEventListener=s.once,s.fireEvent=s.fire,s.hasEventListeners=s.listens,o.Mixin={Events:s},function(){var i=navigator.userAgent.toLowerCase(),n=e.documentElement,s="ActiveXObject"in t,r=i.indexOf("webkit")!==-1,a=i.indexOf("phantom")!==-1,h=i.search("android [23]")!==-1,l=i.indexOf("chrome")!==-1,u=i.indexOf("gecko")!==-1&&!r&&!t.opera&&!s,c=0===navigator.platform.indexOf("Win"),d="undefined"!=typeof orientation||i.indexOf("mobile")!==-1,_=!t.PointerEvent&&t.MSPointerEvent,m=t.PointerEvent||_,p=s&&"transition"in n.style,f="WebKitCSSMatrix"in t&&"m11"in new t.WebKitCSSMatrix&&!h,g="MozPerspective"in n.style,v="OTransition"in n.style,y=!t.L_NO_TOUCH&&(m||"ontouchstart"in t||t.DocumentTouch&&e instanceof t.DocumentTouch);o.Browser={ie:s,ielt9:s&&!e.addEventListener,edge:"msLaunchUri"in navigator&&!("documentMode"in e),webkit:r,gecko:u,android:i.indexOf("android")!==-1,android23:h,chrome:l,safari:!l&&i.indexOf("safari")!==-1,win:c,ie3d:p,webkit3d:f,gecko3d:g,opera12:v,any3d:!t.L_DISABLE_3D&&(p||f||g)&&!v&&!a,mobile:d,mobileWebkit:d&&r,mobileWebkit3d:d&&f,mobileOpera:d&&t.opera,mobileGecko:d&&u,touch:!!y,msPointer:!!_,pointer:!!m,retina:(t.devicePixelRatio||t.screen.deviceXDPI/t.screen.logicalXDPI)>1}}(),o.Point=function(t,e,i){this.x=i?Math.round(t):t,this.y=i?Math.round(e):e},o.Point.prototype={clone:function(){return new o.Point(this.x,this.y)},add:function(t){return this.clone()._add(o.point(t))},_add:function(t){return this.x+=t.x,this.y+=t.y,this},subtract:function(t){return this.clone()._subtract(o.point(t))},_subtract:function(t){return this.x-=t.x,this.y-=t.y,this},divideBy:function(t){return this.clone()._divideBy(t)},_divideBy:function(t){return this.x/=t,this.y/=t,this},multiplyBy:function(t){return this.clone()._multiplyBy(t)},_multiplyBy:function(t){return this.x*=t,this.y*=t,this},scaleBy:function(t){return new o.Point(this.x*t.x,this.y*t.y)},unscaleBy:function(t){return new o.Point(this.x/t.x,this.y/t.y)},round:function(){return this.clone()._round()},_round:function(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this},floor:function(){return this.clone()._floor()},_floor:function(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this},ceil:function(){return this.clone()._ceil()},_ceil:function(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this},distanceTo:function(t){t=o.point(t);var e=t.x-this.x,i=t.y-this.y;return Math.sqrt(e*e+i*i)},equals:function(t){return t=o.point(t),t.x===this.x&&t.y===this.y},contains:function(t){return t=o.point(t),Math.abs(t.x)<=Math.abs(this.x)&&Math.abs(t.y)<=Math.abs(this.y)},toString:function(){return"Point("+o.Util.formatNum(this.x)+", "+o.Util.formatNum(this.y)+")"}},o.point=function(t,e,n){return t instanceof o.Point?t:o.Util.isArray(t)?new o.Point(t[0],t[1]):t===i||null===t?t:"object"==typeof t&&"x"in t&&"y"in t?new o.Point(t.x,t.y):new o.Point(t,e,n)},o.Bounds=function(t,e){if(t)for(var i=e?[t,e]:t,n=0,o=i.length;n<o;n++)this.extend(i[n])},o.Bounds.prototype={extend:function(t){return t=o.point(t),this.min||this.max?(this.min.x=Math.min(t.x,this.min.x),this.max.x=Math.max(t.x,this.max.x),this.min.y=Math.min(t.y,this.min.y),this.max.y=Math.max(t.y,this.max.y)):(this.min=t.clone(),this.max=t.clone()),this},getCenter:function(t){return new o.Point((this.min.x+this.max.x)/2,(this.min.y+this.max.y)/2,t)},getBottomLeft:function(){return new o.Point(this.min.x,this.max.y)},getTopRight:function(){return new o.Point(this.max.x,this.min.y)},getSize:function(){return this.max.subtract(this.min)},contains:function(t){var e,i;return t="number"==typeof t[0]||t instanceof o.Point?o.point(t):o.bounds(t),t instanceof o.Bounds?(e=t.min,i=t.max):e=i=t,e.x>=this.min.x&&i.x<=this.max.x&&e.y>=this.min.y&&i.y<=this.max.y},intersects:function(t){t=o.bounds(t);var e=this.min,i=this.max,n=t.min,s=t.max,r=s.x>=e.x&&n.x<=i.x,a=s.y>=e.y&&n.y<=i.y;return r&&a},overlaps:function(t){t=o.bounds(t);var e=this.min,i=this.max,n=t.min,s=t.max,r=s.x>e.x&&n.x<i.x,a=s.y>e.y&&n.y<i.y;return r&&a},isValid:function(){return!(!this.min||!this.max)}},o.bounds=function(t,e){return!t||t instanceof o.Bounds?t:new o.Bounds(t,e)},o.Transformation=function(t,e,i,n){this._a=t,this._b=e,this._c=i,this._d=n},o.Transformation.prototype={transform:function(t,e){return this._transform(t.clone(),e)},_transform:function(t,e){return e=e||1,t.x=e*(this._a*t.x+this._b),t.y=e*(this._c*t.y+this._d),t},untransform:function(t,e){return e=e||1,new o.Point((t.x/e-this._b)/this._a,(t.y/e-this._d)/this._c)}},o.DomUtil={get:function(t){return"string"==typeof t?e.getElementById(t):t},getStyle:function(t,i){var n=t.style[i]||t.currentStyle&&t.currentStyle[i];if((!n||"auto"===n)&&e.defaultView){var o=e.defaultView.getComputedStyle(t,null);n=o?o[i]:null}return"auto"===n?null:n},create:function(t,i,n){var o=e.createElement(t);return o.className=i||"",n&&n.appendChild(o),o},remove:function(t){var e=t.parentNode;e&&e.removeChild(t)},empty:function(t){for(;t.firstChild;)t.removeChild(t.firstChild)},toFront:function(t){t.parentNode.appendChild(t)},toBack:function(t){var e=t.parentNode;e.insertBefore(t,e.firstChild)},hasClass:function(t,e){if(t.classList!==i)return t.classList.contains(e);var n=o.DomUtil.getClass(t);return n.length>0&&new RegExp("(^|\\s)"+e+"(\\s|$)").test(n)},addClass:function(t,e){if(t.classList!==i)for(var n=o.Util.splitWords(e),s=0,r=n.length;s<r;s++)t.classList.add(n[s]);else if(!o.DomUtil.hasClass(t,e)){var a=o.DomUtil.getClass(t);o.DomUtil.setClass(t,(a?a+" ":"")+e)}},removeClass:function(t,e){t.classList!==i?t.classList.remove(e):o.DomUtil.setClass(t,o.Util.trim((" "+o.DomUtil.getClass(t)+" ").replace(" "+e+" "," ")))},setClass:function(t,e){t.className.baseVal===i?t.className=e:t.className.baseVal=e},getClass:function(t){return t.className.baseVal===i?t.className:t.className.baseVal},setOpacity:function(t,e){"opacity"in t.style?t.style.opacity=e:"filter"in t.style&&o.DomUtil._setOpacityIE(t,e)},_setOpacityIE:function(t,e){var i=!1,n="DXImageTransform.Microsoft.Alpha";try{i=t.filters.item(n)}catch(t){if(1===e)return}e=Math.round(100*e),i?(i.Enabled=100!==e,i.Opacity=e):t.style.filter+=" progid:"+n+"(opacity="+e+")"},testProp:function(t){for(var i=e.documentElement.style,n=0;n<t.length;n++)if(t[n]in i)return t[n];return!1},setTransform:function(t,e,i){var n=e||new o.Point(0,0);t.style[o.DomUtil.TRANSFORM]=(o.Browser.ie3d?"translate("+n.x+"px,"+n.y+"px)":"translate3d("+n.x+"px,"+n.y+"px,0)")+(i?" scale("+i+")":"")},setPosition:function(t,e){t._leaflet_pos=e,o.Browser.any3d?o.DomUtil.setTransform(t,e):(t.style.left=e.x+"px",t.style.top=e.y+"px")},getPosition:function(t){return t._leaflet_pos||new o.Point(0,0)}},function(){o.DomUtil.TRANSFORM=o.DomUtil.testProp(["transform","WebkitTransform","OTransform","MozTransform","msTransform"]);var i=o.DomUtil.TRANSITION=o.DomUtil.testProp(["webkitTransition","transition","OTransition","MozTransition","msTransition"]);if(o.DomUtil.TRANSITION_END="webkitTransition"===i||"OTransition"===i?i+"End":"transitionend","onselectstart"in e)o.DomUtil.disableTextSelection=function(){o.DomEvent.on(t,"selectstart",o.DomEvent.preventDefault)},o.DomUtil.enableTextSelection=function(){o.DomEvent.off(t,"selectstart",o.DomEvent.preventDefault)};else{var n=o.DomUtil.testProp(["userSelect","WebkitUserSelect","OUserSelect","MozUserSelect","msUserSelect"]);o.DomUtil.disableTextSelection=function(){if(n){var t=e.documentElement.style;this._userSelect=t[n],t[n]="none"}},o.DomUtil.enableTextSelection=function(){n&&(e.documentElement.style[n]=this._userSelect,delete this._userSelect)}}o.DomUtil.disableImageDrag=function(){o.DomEvent.on(t,"dragstart",o.DomEvent.preventDefault)},o.DomUtil.enableImageDrag=function(){o.DomEvent.off(t,"dragstart",o.DomEvent.preventDefault)},o.DomUtil.preventOutline=function(e){for(;e.tabIndex===-1;)e=e.parentNode;e&&e.style&&(o.DomUtil.restoreOutline(),this._outlineElement=e,this._outlineStyle=e.style.outline,e.style.outline="none",o.DomEvent.on(t,"keydown",o.DomUtil.restoreOutline,this))},o.DomUtil.restoreOutline=function(){this._outlineElement&&(this._outlineElement.style.outline=this._outlineStyle,delete this._outlineElement,delete this._outlineStyle,o.DomEvent.off(t,"keydown",o.DomUtil.restoreOutline,this))}}(),o.LatLng=function(t,e,n){if(isNaN(t)||isNaN(e))throw new Error("Invalid LatLng object: ("+t+", "+e+")");this.lat=+t,this.lng=+e,n!==i&&(this.alt=+n)},o.LatLng.prototype={equals:function(t,e){if(!t)return!1;t=o.latLng(t);var n=Math.max(Math.abs(this.lat-t.lat),Math.abs(this.lng-t.lng));return n<=(e===i?1e-9:e)},toString:function(t){return"LatLng("+o.Util.formatNum(this.lat,t)+", "+o.Util.formatNum(this.lng,t)+")"},distanceTo:function(t){return o.CRS.Earth.distance(this,o.latLng(t))},wrap:function(){return o.CRS.Earth.wrapLatLng(this)},toBounds:function(t){var e=180*t/40075017,i=e/Math.cos(Math.PI/180*this.lat);return o.latLngBounds([this.lat-e,this.lng-i],[this.lat+e,this.lng+i])},clone:function(){return new o.LatLng(this.lat,this.lng,this.alt)}},o.latLng=function(t,e,n){return t instanceof o.LatLng?t:o.Util.isArray(t)&&"object"!=typeof t[0]?3===t.length?new o.LatLng(t[0],t[1],t[2]):2===t.length?new o.LatLng(t[0],t[1]):null:t===i||null===t?t:"object"==typeof t&&"lat"in t?new o.LatLng(t.lat,"lng"in t?t.lng:t.lon,t.alt):e===i?null:new o.LatLng(t,e,n)},o.LatLngBounds=function(t,e){if(t)for(var i=e?[t,e]:t,n=0,o=i.length;n<o;n++)this.extend(i[n])},o.LatLngBounds.prototype={extend:function(t){var e,i,n=this._southWest,s=this._northEast;if(t instanceof o.LatLng)e=t,i=t;else{if(!(t instanceof o.LatLngBounds))return t?this.extend(o.latLng(t)||o.latLngBounds(t)):this;if(e=t._southWest,i=t._northEast,!e||!i)return this}return n||s?(n.lat=Math.min(e.lat,n.lat),n.lng=Math.min(e.lng,n.lng),s.lat=Math.max(i.lat,s.lat),s.lng=Math.max(i.lng,s.lng)):(this._southWest=new o.LatLng(e.lat,e.lng),this._northEast=new o.LatLng(i.lat,i.lng)),this},pad:function(t){var e=this._southWest,i=this._northEast,n=Math.abs(e.lat-i.lat)*t,s=Math.abs(e.lng-i.lng)*t;return new o.LatLngBounds(new o.LatLng(e.lat-n,e.lng-s),new o.LatLng(i.lat+n,i.lng+s))},getCenter:function(){return new o.LatLng((this._southWest.lat+this._northEast.lat)/2,(this._southWest.lng+this._northEast.lng)/2)},getSouthWest:function(){return this._southWest},getNorthEast:function(){return this._northEast},getNorthWest:function(){return new o.LatLng(this.getNorth(),this.getWest())},getSouthEast:function(){return new o.LatLng(this.getSouth(),this.getEast())},getWest:function(){return this._southWest.lng},getSouth:function(){return this._southWest.lat},getEast:function(){return this._northEast.lng},getNorth:function(){return this._northEast.lat},contains:function(t){t="number"==typeof t[0]||t instanceof o.LatLng||"lat"in t?o.latLng(t):o.latLngBounds(t);var e,i,n=this._southWest,s=this._northEast;return t instanceof o.LatLngBounds?(e=t.getSouthWest(),i=t.getNorthEast()):e=i=t,e.lat>=n.lat&&i.lat<=s.lat&&e.lng>=n.lng&&i.lng<=s.lng},intersects:function(t){t=o.latLngBounds(t);var e=this._southWest,i=this._northEast,n=t.getSouthWest(),s=t.getNorthEast(),r=s.lat>=e.lat&&n.lat<=i.lat,a=s.lng>=e.lng&&n.lng<=i.lng;return r&&a},overlaps:function(t){t=o.latLngBounds(t);var e=this._southWest,i=this._northEast,n=t.getSouthWest(),s=t.getNorthEast(),r=s.lat>e.lat&&n.lat<i.lat,a=s.lng>e.lng&&n.lng<i.lng;return r&&a},toBBoxString:function(){return[this.getWest(),this.getSouth(),this.getEast(),this.getNorth()].join(",")},equals:function(t){return!!t&&(t=o.latLngBounds(t),this._southWest.equals(t.getSouthWest())&&this._northEast.equals(t.getNorthEast()))},isValid:function(){return!(!this._southWest||!this._northEast)}},o.latLngBounds=function(t,e){return t instanceof o.LatLngBounds?t:new o.LatLngBounds(t,e)},o.Projection={},o.Projection.LonLat={project:function(t){return new o.Point(t.lng,t.lat)},unproject:function(t){return new o.LatLng(t.y,t.x)},bounds:o.bounds([-180,-90],[180,90])},o.Projection.SphericalMercator={R:6378137,MAX_LATITUDE:85.0511287798,project:function(t){var e=Math.PI/180,i=this.MAX_LATITUDE,n=Math.max(Math.min(i,t.lat),-i),s=Math.sin(n*e);return new o.Point(this.R*t.lng*e,this.R*Math.log((1+s)/(1-s))/2)},unproject:function(t){var e=180/Math.PI;return new o.LatLng((2*Math.atan(Math.exp(t.y/this.R))-Math.PI/2)*e,t.x*e/this.R)},bounds:function(){var t=6378137*Math.PI;return o.bounds([-t,-t],[t,t])}()},o.CRS={latLngToPoint:function(t,e){var i=this.projection.project(t),n=this.scale(e);return this.transformation._transform(i,n)},pointToLatLng:function(t,e){var i=this.scale(e),n=this.transformation.untransform(t,i);return this.projection.unproject(n)},project:function(t){return this.projection.project(t)},unproject:function(t){return this.projection.unproject(t)},scale:function(t){return 256*Math.pow(2,t)},zoom:function(t){return Math.log(t/256)/Math.LN2},getProjectedBounds:function(t){if(this.infinite)return null;var e=this.projection.bounds,i=this.scale(t),n=this.transformation.transform(e.min,i),s=this.transformation.transform(e.max,i);return o.bounds(n,s)},infinite:!1,wrapLatLng:function(t){var e=this.wrapLng?o.Util.wrapNum(t.lng,this.wrapLng,!0):t.lng,i=this.wrapLat?o.Util.wrapNum(t.lat,this.wrapLat,!0):t.lat,n=t.alt;return o.latLng(i,e,n)},wrapLatLngBounds:function(t){var e=t.getCenter(),i=this.wrapLatLng(e),n=e.lat-i.lat,s=e.lng-i.lng;if(0===n&&0===s)return t;var r=t.getSouthWest(),a=t.getNorthEast(),h=o.latLng({lat:r.lat-n,lng:r.lng-s}),l=o.latLng({lat:a.lat-n,lng:a.lng-s});return new o.LatLngBounds(h,l)}},o.CRS.Simple=o.extend({},o.CRS,{projection:o.Projection.LonLat,transformation:new o.Transformation(1,0,-1,0),scale:function(t){return Math.pow(2,t)},zoom:function(t){return Math.log(t)/Math.LN2},distance:function(t,e){var i=e.lng-t.lng,n=e.lat-t.lat;return Math.sqrt(i*i+n*n)},infinite:!0}),o.CRS.Earth=o.extend({},o.CRS,{wrapLng:[-180,180],R:6371e3,distance:function(t,e){var i=Math.PI/180,n=t.lat*i,o=e.lat*i,s=Math.sin(n)*Math.sin(o)+Math.cos(n)*Math.cos(o)*Math.cos((e.lng-t.lng)*i);return this.R*Math.acos(Math.min(s,1))}}),o.CRS.EPSG3857=o.extend({},o.CRS.Earth,{code:"EPSG:3857",projection:o.Projection.SphericalMercator,transformation:function(){var t=.5/(Math.PI*o.Projection.SphericalMercator.R);return new o.Transformation(t,.5,-t,.5)}()}),o.CRS.EPSG900913=o.extend({},o.CRS.EPSG3857,{code:"EPSG:900913"}),o.CRS.EPSG4326=o.extend({},o.CRS.Earth,{code:"EPSG:4326",projection:o.Projection.LonLat,transformation:new o.Transformation(1/180,1,-1/180,.5)}),o.Map=o.Evented.extend({options:{crs:o.CRS.EPSG3857,center:i,zoom:i,minZoom:i,maxZoom:i,layers:[],maxBounds:i,renderer:i,zoomAnimation:!0,zoomAnimationThreshold:4,fadeAnimation:!0,markerZoomAnimation:!0,transform3DLimit:8388608,zoomSnap:1,zoomDelta:1,trackResize:!0},initialize:function(t,e){e=o.setOptions(this,e),this._initContainer(t),this._initLayout(),this._onResize=o.bind(this._onResize,this),this._initEvents(),e.maxBounds&&this.setMaxBounds(e.maxBounds),e.zoom!==i&&(this._zoom=this._limitZoom(e.zoom)),e.center&&e.zoom!==i&&this.setView(o.latLng(e.center),e.zoom,{reset:!0}),this._handlers=[],this._layers={},this._zoomBoundLayers={},this._sizeChanged=!0,this.callInitHooks(),this._zoomAnimated=o.DomUtil.TRANSITION&&o.Browser.any3d&&!o.Browser.mobileOpera&&this.options.zoomAnimation,this._zoomAnimated&&(this._createAnimProxy(),o.DomEvent.on(this._proxy,o.DomUtil.TRANSITION_END,this._catchTransitionEnd,this)),this._addLayers(this.options.layers)},setView:function(t,e,n){if(e=e===i?this._zoom:this._limitZoom(e),t=this._limitCenter(o.latLng(t),e,this.options.maxBounds),n=n||{},this._stop(),this._loaded&&!n.reset&&n!==!0){n.animate!==i&&(n.zoom=o.extend({animate:n.animate},n.zoom),n.pan=o.extend({animate:n.animate,duration:n.duration},n.pan));var s=this._zoom!==e?this._tryAnimatedZoom&&this._tryAnimatedZoom(t,e,n.zoom):this._tryAnimatedPan(t,n.pan);if(s)return clearTimeout(this._sizeTimer),this}return this._resetView(t,e),this},setZoom:function(t,e){return this._loaded?this.setView(this.getCenter(),t,{zoom:e}):(this._zoom=t,this)},zoomIn:function(t,e){return t=t||(o.Browser.any3d?this.options.zoomDelta:1),this.setZoom(this._zoom+t,e)},zoomOut:function(t,e){return t=t||(o.Browser.any3d?this.options.zoomDelta:1),this.setZoom(this._zoom-t,e)},setZoomAround:function(t,e,i){var n=this.getZoomScale(e),s=this.getSize().divideBy(2),r=t instanceof o.Point?t:this.latLngToContainerPoint(t),a=r.subtract(s).multiplyBy(1-1/n),h=this.containerPointToLatLng(s.add(a));return this.setView(h,e,{zoom:i})},_getBoundsCenterZoom:function(t,e){e=e||{},t=t.getBounds?t.getBounds():o.latLngBounds(t);var i=o.point(e.paddingTopLeft||e.padding||[0,0]),n=o.point(e.paddingBottomRight||e.padding||[0,0]),s=this.getBoundsZoom(t,!1,i.add(n));s="number"==typeof e.maxZoom?Math.min(e.maxZoom,s):s;var r=n.subtract(i).divideBy(2),a=this.project(t.getSouthWest(),s),h=this.project(t.getNorthEast(),s),l=this.unproject(a.add(h).divideBy(2).add(r),s);return{center:l,zoom:s}},fitBounds:function(t,e){if(t=o.latLngBounds(t),!t.isValid())throw new Error("Bounds are not valid.");var i=this._getBoundsCenterZoom(t,e);return this.setView(i.center,i.zoom,e)},fitWorld:function(t){return this.fitBounds([[-90,-180],[90,180]],t)},panTo:function(t,e){return this.setView(t,this._zoom,{pan:e})},panBy:function(t,e){if(t=o.point(t).round(),e=e||{},!t.x&&!t.y)return this.fire("moveend");if(e.animate!==!0&&!this.getSize().contains(t))return this._resetView(this.unproject(this.project(this.getCenter()).add(t)),this.getZoom()),this;if(this._panAnim||(this._panAnim=new o.PosAnimation,this._panAnim.on({step:this._onPanTransitionStep,end:this._onPanTransitionEnd},this)),e.noMoveStart||this.fire("movestart"),e.animate!==!1){o.DomUtil.addClass(this._mapPane,"leaflet-pan-anim");var i=this._getMapPanePos().subtract(t).round();this._panAnim.run(this._mapPane,i,e.duration||.25,e.easeLinearity)}else this._rawPanBy(t),this.fire("move").fire("moveend");return this},flyTo:function(t,e,n){function s(t){var e=t?-1:1,i=t?v:g,n=v*v-g*g+e*L*L*y*y,o=2*i*L*y,s=n/o,r=Math.sqrt(s*s+1)-s,a=r<1e-9?-18:Math.log(r);return a}function r(t){return(Math.exp(t)-Math.exp(-t))/2}function a(t){return(Math.exp(t)+Math.exp(-t))/2}function h(t){return r(t)/a(t)}function l(t){return g*(a(x)/a(x+P*t))}function u(t){return g*(a(x)*h(x+P*t)-r(x))/L}function c(t){return 1-Math.pow(1-t,1.5)}function d(){var i=(Date.now()-w)/T,n=c(i)*b;i<=1?(this._flyToFrame=o.Util.requestAnimFrame(d,this),this._move(this.unproject(_.add(m.subtract(_).multiplyBy(u(n)/y)),f),this.getScaleZoom(g/l(n),f),{flyTo:!0})):this._move(t,e)._moveEnd(!0)}if(n=n||{},n.animate===!1||!o.Browser.any3d)return this.setView(t,e,n);this._stop();var _=this.project(this.getCenter()),m=this.project(t),p=this.getSize(),f=this._zoom;t=o.latLng(t),e=e===i?f:e;var g=Math.max(p.x,p.y),v=g*this.getZoomScale(f,e),y=m.distanceTo(_)||1,P=1.42,L=P*P,x=s(0),w=Date.now(),b=(s(1)-x)/P,T=n.duration?1e3*n.duration:1e3*b*.8;return this._moveStart(!0),d.call(this),this},flyToBounds:function(t,e){var i=this._getBoundsCenterZoom(t,e);return this.flyTo(i.center,i.zoom,e)},setMaxBounds:function(t){return t=o.latLngBounds(t),t.isValid()?(this.options.maxBounds&&this.off("moveend",this._panInsideMaxBounds),this.options.maxBounds=t,this._loaded&&this._panInsideMaxBounds(),this.on("moveend",this._panInsideMaxBounds)):(this.options.maxBounds=null,this.off("moveend",this._panInsideMaxBounds))},setMinZoom:function(t){return this.options.minZoom=t,this._loaded&&this.getZoom()<this.options.minZoom?this.setZoom(t):this},setMaxZoom:function(t){return this.options.maxZoom=t,this._loaded&&this.getZoom()>this.options.maxZoom?this.setZoom(t):this},panInsideBounds:function(t,e){this._enforcingBounds=!0;var i=this.getCenter(),n=this._limitCenter(i,this._zoom,o.latLngBounds(t));return i.equals(n)||this.panTo(n,e),this._enforcingBounds=!1,this},invalidateSize:function(t){if(!this._loaded)return this;t=o.extend({animate:!1,pan:!0},t===!0?{animate:!0}:t);var e=this.getSize();this._sizeChanged=!0,this._lastCenter=null;var i=this.getSize(),n=e.divideBy(2).round(),s=i.divideBy(2).round(),r=n.subtract(s);return r.x||r.y?(t.animate&&t.pan?this.panBy(r):(t.pan&&this._rawPanBy(r),this.fire("move"),t.debounceMoveend?(clearTimeout(this._sizeTimer),this._sizeTimer=setTimeout(o.bind(this.fire,this,"moveend"),200)):this.fire("moveend")),this.fire("resize",{oldSize:e,newSize:i})):this},stop:function(){return this.setZoom(this._limitZoom(this._zoom)),this.options.zoomSnap||this.fire("viewreset"),this._stop()},locate:function(t){if(t=this._locateOptions=o.extend({timeout:1e4,watch:!1},t),!("geolocation"in navigator))return this._handleGeolocationError({code:0,message:"Geolocation not supported."}),this;var e=o.bind(this._handleGeolocationResponse,this),i=o.bind(this._handleGeolocationError,this);return t.watch?this._locationWatchId=navigator.geolocation.watchPosition(e,i,t):navigator.geolocation.getCurrentPosition(e,i,t),this},stopLocate:function(){return navigator.geolocation&&navigator.geolocation.clearWatch&&navigator.geolocation.clearWatch(this._locationWatchId),this._locateOptions&&(this._locateOptions.setView=!1),this},_handleGeolocationError:function(t){var e=t.code,i=t.message||(1===e?"permission denied":2===e?"position unavailable":"timeout");this._locateOptions.setView&&!this._loaded&&this.fitWorld(),this.fire("locationerror",{code:e,message:"Geolocation error: "+i+"."})},_handleGeolocationResponse:function(t){var e=t.coords.latitude,i=t.coords.longitude,n=new o.LatLng(e,i),s=n.toBounds(t.coords.accuracy),r=this._locateOptions;if(r.setView){var a=this.getBoundsZoom(s);this.setView(n,r.maxZoom?Math.min(a,r.maxZoom):a)}var h={latlng:n,bounds:s,timestamp:t.timestamp};for(var l in t.coords)"number"==typeof t.coords[l]&&(h[l]=t.coords[l]);this.fire("locationfound",h)},addHandler:function(t,e){if(!e)return this;var i=this[t]=new e(this);return this._handlers.push(i),this.options[t]&&i.enable(),this},remove:function(){if(this._initEvents(!0),this._containerId!==this._container._leaflet_id)throw new Error("Map container is being reused by another instance");try{delete this._container._leaflet_id,delete this._containerId}catch(t){this._container._leaflet_id=i,this._containerId=i}o.DomUtil.remove(this._mapPane),this._clearControlPos&&this._clearControlPos(),this._clearHandlers(),this._loaded&&this.fire("unload");for(var t in this._layers)this._layers[t].remove();return this},createPane:function(t,e){var i="leaflet-pane"+(t?" leaflet-"+t.replace("Pane","")+"-pane":""),n=o.DomUtil.create("div",i,e||this._mapPane);return t&&(this._panes[t]=n),n},getCenter:function(){return this._checkIfLoaded(),this._lastCenter&&!this._moved()?this._lastCenter:this.layerPointToLatLng(this._getCenterLayerPoint())},getZoom:function(){return this._zoom},getBounds:function(){var t=this.getPixelBounds(),e=this.unproject(t.getBottomLeft()),i=this.unproject(t.getTopRight());return new o.LatLngBounds(e,i)},getMinZoom:function(){return this.options.minZoom===i?this._layersMinZoom||0:this.options.minZoom},getMaxZoom:function(){return this.options.maxZoom===i?this._layersMaxZoom===i?1/0:this._layersMaxZoom:this.options.maxZoom},getBoundsZoom:function(t,e,i){t=o.latLngBounds(t),i=o.point(i||[0,0]);var n=this.getZoom()||0,s=this.getMinZoom(),r=this.getMaxZoom(),a=t.getNorthWest(),h=t.getSouthEast(),l=this.getSize().subtract(i),u=o.bounds(this.project(h,n),this.project(a,n)).getSize(),c=o.Browser.any3d?this.options.zoomSnap:1,d=Math.min(l.x/u.x,l.y/u.y);return n=this.getScaleZoom(d,n),c&&(n=Math.round(n/(c/100))*(c/100),n=e?Math.ceil(n/c)*c:Math.floor(n/c)*c),Math.max(s,Math.min(r,n))},getSize:function(){return this._size&&!this._sizeChanged||(this._size=new o.Point(this._container.clientWidth||0,this._container.clientHeight||0),this._sizeChanged=!1),this._size.clone()},getPixelBounds:function(t,e){var i=this._getTopLeftPoint(t,e);return new o.Bounds(i,i.add(this.getSize()))},getPixelOrigin:function(){return this._checkIfLoaded(),this._pixelOrigin},getPixelWorldBounds:function(t){return this.options.crs.getProjectedBounds(t===i?this.getZoom():t)},getPane:function(t){return"string"==typeof t?this._panes[t]:t},getPanes:function(){return this._panes},getContainer:function(){return this._container},getZoomScale:function(t,e){var n=this.options.crs;return e=e===i?this._zoom:e,n.scale(t)/n.scale(e)},getScaleZoom:function(t,e){var n=this.options.crs;e=e===i?this._zoom:e;var o=n.zoom(t*n.scale(e));return isNaN(o)?1/0:o},project:function(t,e){return e=e===i?this._zoom:e,this.options.crs.latLngToPoint(o.latLng(t),e)},unproject:function(t,e){return e=e===i?this._zoom:e,this.options.crs.pointToLatLng(o.point(t),e)},layerPointToLatLng:function(t){var e=o.point(t).add(this.getPixelOrigin());return this.unproject(e)},latLngToLayerPoint:function(t){var e=this.project(o.latLng(t))._round();return e._subtract(this.getPixelOrigin())},wrapLatLng:function(t){return this.options.crs.wrapLatLng(o.latLng(t))},wrapLatLngBounds:function(t){return this.options.crs.wrapLatLngBounds(o.latLngBounds(t))},distance:function(t,e){return this.options.crs.distance(o.latLng(t),o.latLng(e))},containerPointToLayerPoint:function(t){return o.point(t).subtract(this._getMapPanePos())},layerPointToContainerPoint:function(t){return o.point(t).add(this._getMapPanePos())},containerPointToLatLng:function(t){var e=this.containerPointToLayerPoint(o.point(t));return this.layerPointToLatLng(e)},latLngToContainerPoint:function(t){return this.layerPointToContainerPoint(this.latLngToLayerPoint(o.latLng(t)))},mouseEventToContainerPoint:function(t){return o.DomEvent.getMousePosition(t,this._container)},mouseEventToLayerPoint:function(t){return this.containerPointToLayerPoint(this.mouseEventToContainerPoint(t))},mouseEventToLatLng:function(t){return this.layerPointToLatLng(this.mouseEventToLayerPoint(t))},_initContainer:function(t){var e=this._container=o.DomUtil.get(t);if(!e)throw new Error("Map container not found.");if(e._leaflet_id)throw new Error("Map container is already initialized.");o.DomEvent.addListener(e,"scroll",this._onScroll,this),this._containerId=o.Util.stamp(e)},_initLayout:function(){var t=this._container;this._fadeAnimated=this.options.fadeAnimation&&o.Browser.any3d,o.DomUtil.addClass(t,"leaflet-container"+(o.Browser.touch?" leaflet-touch":"")+(o.Browser.retina?" leaflet-retina":"")+(o.Browser.ielt9?" leaflet-oldie":"")+(o.Browser.safari?" leaflet-safari":"")+(this._fadeAnimated?" leaflet-fade-anim":""));
|
|
var e=o.DomUtil.getStyle(t,"position");"absolute"!==e&&"relative"!==e&&"fixed"!==e&&(t.style.position="relative"),this._initPanes(),this._initControlPos&&this._initControlPos()},_initPanes:function(){var t=this._panes={};this._paneRenderers={},this._mapPane=this.createPane("mapPane",this._container),o.DomUtil.setPosition(this._mapPane,new o.Point(0,0)),this.createPane("tilePane"),this.createPane("shadowPane"),this.createPane("overlayPane"),this.createPane("markerPane"),this.createPane("tooltipPane"),this.createPane("popupPane"),this.options.markerZoomAnimation||(o.DomUtil.addClass(t.markerPane,"leaflet-zoom-hide"),o.DomUtil.addClass(t.shadowPane,"leaflet-zoom-hide"))},_resetView:function(t,e){o.DomUtil.setPosition(this._mapPane,new o.Point(0,0));var i=!this._loaded;this._loaded=!0,e=this._limitZoom(e),this.fire("viewprereset");var n=this._zoom!==e;this._moveStart(n)._move(t,e)._moveEnd(n),this.fire("viewreset"),i&&this.fire("load")},_moveStart:function(t){return t&&this.fire("zoomstart"),this.fire("movestart")},_move:function(t,e,n){e===i&&(e=this._zoom);var o=this._zoom!==e;return this._zoom=e,this._lastCenter=t,this._pixelOrigin=this._getNewPixelOrigin(t),(o||n&&n.pinch)&&this.fire("zoom",n),this.fire("move",n)},_moveEnd:function(t){return t&&this.fire("zoomend"),this.fire("moveend")},_stop:function(){return o.Util.cancelAnimFrame(this._flyToFrame),this._panAnim&&this._panAnim.stop(),this},_rawPanBy:function(t){o.DomUtil.setPosition(this._mapPane,this._getMapPanePos().subtract(t))},_getZoomSpan:function(){return this.getMaxZoom()-this.getMinZoom()},_panInsideMaxBounds:function(){this._enforcingBounds||this.panInsideBounds(this.options.maxBounds)},_checkIfLoaded:function(){if(!this._loaded)throw new Error("Set map center and zoom first.")},_initEvents:function(e){if(o.DomEvent){this._targets={},this._targets[o.stamp(this._container)]=this;var i=e?"off":"on";o.DomEvent[i](this._container,"click dblclick mousedown mouseup mouseover mouseout mousemove contextmenu keypress",this._handleDOMEvent,this),this.options.trackResize&&o.DomEvent[i](t,"resize",this._onResize,this),o.Browser.any3d&&this.options.transform3DLimit&&this[i]("moveend",this._onMoveEnd)}},_onResize:function(){o.Util.cancelAnimFrame(this._resizeRequest),this._resizeRequest=o.Util.requestAnimFrame(function(){this.invalidateSize({debounceMoveend:!0})},this)},_onScroll:function(){this._container.scrollTop=0,this._container.scrollLeft=0},_onMoveEnd:function(){var t=this._getMapPanePos();Math.max(Math.abs(t.x),Math.abs(t.y))>=this.options.transform3DLimit&&this._resetView(this.getCenter(),this.getZoom())},_findEventTargets:function(t,e){for(var i,n=[],s="mouseout"===e||"mouseover"===e,r=t.target||t.srcElement,a=!1;r;){if(i=this._targets[o.stamp(r)],i&&("click"===e||"preclick"===e)&&!t._simulated&&this._draggableMoved(i)){a=!0;break}if(i&&i.listens(e,!0)){if(s&&!o.DomEvent._isExternalTarget(r,t))break;if(n.push(i),s)break}if(r===this._container)break;r=r.parentNode}return n.length||a||s||!o.DomEvent._isExternalTarget(r,t)||(n=[this]),n},_handleDOMEvent:function(t){if(this._loaded&&!o.DomEvent._skipped(t)){var e="keypress"===t.type&&13===t.keyCode?"click":t.type;"mousedown"===e&&o.DomUtil.preventOutline(t.target||t.srcElement),this._fireDOMEvent(t,e)}},_fireDOMEvent:function(t,e,i){if("click"===t.type){var n=o.Util.extend({},t);n.type="preclick",this._fireDOMEvent(n,n.type,i)}if(!t._stopped&&(i=(i||[]).concat(this._findEventTargets(t,e)),i.length)){var s=i[0];"contextmenu"===e&&s.listens(e,!0)&&o.DomEvent.preventDefault(t);var r={originalEvent:t};if("keypress"!==t.type){var a=s instanceof o.Marker;r.containerPoint=a?this.latLngToContainerPoint(s.getLatLng()):this.mouseEventToContainerPoint(t),r.layerPoint=this.containerPointToLayerPoint(r.containerPoint),r.latlng=a?s.getLatLng():this.layerPointToLatLng(r.layerPoint)}for(var h=0;h<i.length;h++)if(i[h].fire(e,r,!0),r.originalEvent._stopped||i[h].options.nonBubblingEvents&&o.Util.indexOf(i[h].options.nonBubblingEvents,e)!==-1)return}},_draggableMoved:function(t){return t=t.dragging&&t.dragging.enabled()?t:this,t.dragging&&t.dragging.moved()||this.boxZoom&&this.boxZoom.moved()},_clearHandlers:function(){for(var t=0,e=this._handlers.length;t<e;t++)this._handlers[t].disable()},whenReady:function(t,e){return this._loaded?t.call(e||this,{target:this}):this.on("load",t,e),this},_getMapPanePos:function(){return o.DomUtil.getPosition(this._mapPane)||new o.Point(0,0)},_moved:function(){var t=this._getMapPanePos();return t&&!t.equals([0,0])},_getTopLeftPoint:function(t,e){var n=t&&e!==i?this._getNewPixelOrigin(t,e):this.getPixelOrigin();return n.subtract(this._getMapPanePos())},_getNewPixelOrigin:function(t,e){var i=this.getSize()._divideBy(2);return this.project(t,e)._subtract(i)._add(this._getMapPanePos())._round()},_latLngToNewLayerPoint:function(t,e,i){var n=this._getNewPixelOrigin(i,e);return this.project(t,e)._subtract(n)},_latLngBoundsToNewLayerBounds:function(t,e,i){var n=this._getNewPixelOrigin(i,e);return o.bounds([this.project(t.getSouthWest(),e)._subtract(n),this.project(t.getNorthWest(),e)._subtract(n),this.project(t.getSouthEast(),e)._subtract(n),this.project(t.getNorthEast(),e)._subtract(n)])},_getCenterLayerPoint:function(){return this.containerPointToLayerPoint(this.getSize()._divideBy(2))},_getCenterOffset:function(t){return this.latLngToLayerPoint(t).subtract(this._getCenterLayerPoint())},_limitCenter:function(t,e,i){if(!i)return t;var n=this.project(t,e),s=this.getSize().divideBy(2),r=new o.Bounds(n.subtract(s),n.add(s)),a=this._getBoundsOffset(r,i,e);return a.round().equals([0,0])?t:this.unproject(n.add(a),e)},_limitOffset:function(t,e){if(!e)return t;var i=this.getPixelBounds(),n=new o.Bounds(i.min.add(t),i.max.add(t));return t.add(this._getBoundsOffset(n,e))},_getBoundsOffset:function(t,e,i){var n=o.bounds(this.project(e.getNorthEast(),i),this.project(e.getSouthWest(),i)),s=n.min.subtract(t.min),r=n.max.subtract(t.max),a=this._rebound(s.x,-r.x),h=this._rebound(s.y,-r.y);return new o.Point(a,h)},_rebound:function(t,e){return t+e>0?Math.round(t-e)/2:Math.max(0,Math.ceil(t))-Math.max(0,Math.floor(e))},_limitZoom:function(t){var e=this.getMinZoom(),i=this.getMaxZoom(),n=o.Browser.any3d?this.options.zoomSnap:1;return n&&(t=Math.round(t/n)*n),Math.max(e,Math.min(i,t))},_onPanTransitionStep:function(){this.fire("move")},_onPanTransitionEnd:function(){o.DomUtil.removeClass(this._mapPane,"leaflet-pan-anim"),this.fire("moveend")},_tryAnimatedPan:function(t,e){var i=this._getCenterOffset(t)._floor();return!((e&&e.animate)!==!0&&!this.getSize().contains(i))&&(this.panBy(i,e),!0)},_createAnimProxy:function(){var t=this._proxy=o.DomUtil.create("div","leaflet-proxy leaflet-zoom-animated");this._panes.mapPane.appendChild(t),this.on("zoomanim",function(e){var i=o.DomUtil.TRANSFORM,n=t.style[i];o.DomUtil.setTransform(t,this.project(e.center,e.zoom),this.getZoomScale(e.zoom,1)),n===t.style[i]&&this._animatingZoom&&this._onZoomTransitionEnd()},this),this.on("load moveend",function(){var e=this.getCenter(),i=this.getZoom();o.DomUtil.setTransform(t,this.project(e,i),this.getZoomScale(i,1))},this)},_catchTransitionEnd:function(t){this._animatingZoom&&t.propertyName.indexOf("transform")>=0&&this._onZoomTransitionEnd()},_nothingToAnimate:function(){return!this._container.getElementsByClassName("leaflet-zoom-animated").length},_tryAnimatedZoom:function(t,e,i){if(this._animatingZoom)return!0;if(i=i||{},!this._zoomAnimated||i.animate===!1||this._nothingToAnimate()||Math.abs(e-this._zoom)>this.options.zoomAnimationThreshold)return!1;var n=this.getZoomScale(e),s=this._getCenterOffset(t)._divideBy(1-1/n);return!(i.animate!==!0&&!this.getSize().contains(s))&&(o.Util.requestAnimFrame(function(){this._moveStart(!0)._animateZoom(t,e,!0)},this),!0)},_animateZoom:function(t,e,i,n){i&&(this._animatingZoom=!0,this._animateToCenter=t,this._animateToZoom=e,o.DomUtil.addClass(this._mapPane,"leaflet-zoom-anim")),this.fire("zoomanim",{center:t,zoom:e,noUpdate:n}),setTimeout(o.bind(this._onZoomTransitionEnd,this),250)},_onZoomTransitionEnd:function(){this._animatingZoom&&(o.DomUtil.removeClass(this._mapPane,"leaflet-zoom-anim"),this._animatingZoom=!1,this._move(this._animateToCenter,this._animateToZoom),o.Util.requestAnimFrame(function(){this._moveEnd(!0)},this))}}),o.map=function(t,e){return new o.Map(t,e)},o.Layer=o.Evented.extend({options:{pane:"overlayPane",nonBubblingEvents:[],attribution:null},addTo:function(t){return t.addLayer(this),this},remove:function(){return this.removeFrom(this._map||this._mapToAdd)},removeFrom:function(t){return t&&t.removeLayer(this),this},getPane:function(t){return this._map.getPane(t?this.options[t]||t:this.options.pane)},addInteractiveTarget:function(t){return this._map._targets[o.stamp(t)]=this,this},removeInteractiveTarget:function(t){return delete this._map._targets[o.stamp(t)],this},getAttribution:function(){return this.options.attribution},_layerAdd:function(t){var e=t.target;if(e.hasLayer(this)){if(this._map=e,this._zoomAnimated=e._zoomAnimated,this.getEvents){var i=this.getEvents();e.on(i,this),this.once("remove",function(){e.off(i,this)},this)}this.onAdd(e),this.getAttribution&&e.attributionControl&&e.attributionControl.addAttribution(this.getAttribution()),this.fire("add"),e.fire("layeradd",{layer:this})}}}),o.Map.include({addLayer:function(t){var e=o.stamp(t);return this._layers[e]?this:(this._layers[e]=t,t._mapToAdd=this,t.beforeAdd&&t.beforeAdd(this),this.whenReady(t._layerAdd,t),this)},removeLayer:function(t){var e=o.stamp(t);return this._layers[e]?(this._loaded&&t.onRemove(this),t.getAttribution&&this.attributionControl&&this.attributionControl.removeAttribution(t.getAttribution()),delete this._layers[e],this._loaded&&(this.fire("layerremove",{layer:t}),t.fire("remove")),t._map=t._mapToAdd=null,this):this},hasLayer:function(t){return!!t&&o.stamp(t)in this._layers},eachLayer:function(t,e){for(var i in this._layers)t.call(e,this._layers[i]);return this},_addLayers:function(t){t=t?o.Util.isArray(t)?t:[t]:[];for(var e=0,i=t.length;e<i;e++)this.addLayer(t[e])},_addZoomLimit:function(t){!isNaN(t.options.maxZoom)&&isNaN(t.options.minZoom)||(this._zoomBoundLayers[o.stamp(t)]=t,this._updateZoomLevels())},_removeZoomLimit:function(t){var e=o.stamp(t);this._zoomBoundLayers[e]&&(delete this._zoomBoundLayers[e],this._updateZoomLevels())},_updateZoomLevels:function(){var t=1/0,e=-(1/0),n=this._getZoomSpan();for(var o in this._zoomBoundLayers){var s=this._zoomBoundLayers[o].options;t=s.minZoom===i?t:Math.min(t,s.minZoom),e=s.maxZoom===i?e:Math.max(e,s.maxZoom)}this._layersMaxZoom=e===-(1/0)?i:e,this._layersMinZoom=t===1/0?i:t,n!==this._getZoomSpan()&&this.fire("zoomlevelschange"),this.options.maxZoom===i&&this._layersMaxZoom&&this.getZoom()>this._layersMaxZoom&&this.setZoom(this._layersMaxZoom),this.options.minZoom===i&&this._layersMinZoom&&this.getZoom()<this._layersMinZoom&&this.setZoom(this._layersMinZoom)}});var r="_leaflet_events";o.DomEvent={on:function(t,e,i,n){if("object"==typeof e)for(var s in e)this._on(t,s,e[s],i);else{e=o.Util.splitWords(e);for(var r=0,a=e.length;r<a;r++)this._on(t,e[r],i,n)}return this},off:function(t,e,i,n){if("object"==typeof e)for(var s in e)this._off(t,s,e[s],i);else{e=o.Util.splitWords(e);for(var r=0,a=e.length;r<a;r++)this._off(t,e[r],i,n)}return this},_on:function(e,i,n,s){var a=i+o.stamp(n)+(s?"_"+o.stamp(s):"");if(e[r]&&e[r][a])return this;var h=function(i){return n.call(s||e,i||t.event)},l=h;return o.Browser.pointer&&0===i.indexOf("touch")?this.addPointerListener(e,i,h,a):!o.Browser.touch||"dblclick"!==i||!this.addDoubleTapListener||o.Browser.pointer&&o.Browser.chrome?"addEventListener"in e?"mousewheel"===i?e.addEventListener("onwheel"in e?"wheel":"mousewheel",h,!1):"mouseenter"===i||"mouseleave"===i?(h=function(i){i=i||t.event,o.DomEvent._isExternalTarget(e,i)&&l(i)},e.addEventListener("mouseenter"===i?"mouseover":"mouseout",h,!1)):("click"===i&&o.Browser.android&&(h=function(t){return o.DomEvent._filterClick(t,l)}),e.addEventListener(i,h,!1)):"attachEvent"in e&&e.attachEvent("on"+i,h):this.addDoubleTapListener(e,h,a),e[r]=e[r]||{},e[r][a]=h,this},_off:function(t,e,i,n){var s=e+o.stamp(i)+(n?"_"+o.stamp(n):""),a=t[r]&&t[r][s];return a?(o.Browser.pointer&&0===e.indexOf("touch")?this.removePointerListener(t,e,s):o.Browser.touch&&"dblclick"===e&&this.removeDoubleTapListener?this.removeDoubleTapListener(t,s):"removeEventListener"in t?"mousewheel"===e?t.removeEventListener("onwheel"in t?"wheel":"mousewheel",a,!1):t.removeEventListener("mouseenter"===e?"mouseover":"mouseleave"===e?"mouseout":e,a,!1):"detachEvent"in t&&t.detachEvent("on"+e,a),t[r][s]=null,this):this},stopPropagation:function(t){return t.stopPropagation?t.stopPropagation():t.originalEvent?t.originalEvent._stopped=!0:t.cancelBubble=!0,o.DomEvent._skipped(t),this},disableScrollPropagation:function(t){return o.DomEvent.on(t,"mousewheel",o.DomEvent.stopPropagation)},disableClickPropagation:function(t){var e=o.DomEvent.stopPropagation;return o.DomEvent.on(t,o.Draggable.START.join(" "),e),o.DomEvent.on(t,{click:o.DomEvent._fakeStop,dblclick:e})},preventDefault:function(t){return t.preventDefault?t.preventDefault():t.returnValue=!1,this},stop:function(t){return o.DomEvent.preventDefault(t).stopPropagation(t)},getMousePosition:function(t,e){if(!e)return new o.Point(t.clientX,t.clientY);var i=e.getBoundingClientRect();return new o.Point(t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop)},_wheelPxFactor:o.Browser.win&&o.Browser.chrome?2:o.Browser.gecko?t.devicePixelRatio:1,getWheelDelta:function(t){return o.Browser.edge?t.wheelDeltaY/2:t.deltaY&&0===t.deltaMode?-t.deltaY/o.DomEvent._wheelPxFactor:t.deltaY&&1===t.deltaMode?20*-t.deltaY:t.deltaY&&2===t.deltaMode?60*-t.deltaY:t.deltaX||t.deltaZ?0:t.wheelDelta?(t.wheelDeltaY||t.wheelDelta)/2:t.detail&&Math.abs(t.detail)<32765?20*-t.detail:t.detail?t.detail/-32765*60:0},_skipEvents:{},_fakeStop:function(t){o.DomEvent._skipEvents[t.type]=!0},_skipped:function(t){var e=this._skipEvents[t.type];return this._skipEvents[t.type]=!1,e},_isExternalTarget:function(t,e){var i=e.relatedTarget;if(!i)return!0;try{for(;i&&i!==t;)i=i.parentNode}catch(t){return!1}return i!==t},_filterClick:function(t,e){var i=t.timeStamp||t.originalEvent&&t.originalEvent.timeStamp,n=o.DomEvent._lastClick&&i-o.DomEvent._lastClick;return n&&n>100&&n<500||t.target._simulatedClick&&!t._simulated?void o.DomEvent.stop(t):(o.DomEvent._lastClick=i,void e(t))}},o.DomEvent.addListener=o.DomEvent.on,o.DomEvent.removeListener=o.DomEvent.off,o.PosAnimation=o.Evented.extend({run:function(t,e,i,n){this.stop(),this._el=t,this._inProgress=!0,this._duration=i||.25,this._easeOutPower=1/Math.max(n||.5,.2),this._startPos=o.DomUtil.getPosition(t),this._offset=e.subtract(this._startPos),this._startTime=+new Date,this.fire("start"),this._animate()},stop:function(){this._inProgress&&(this._step(!0),this._complete())},_animate:function(){this._animId=o.Util.requestAnimFrame(this._animate,this),this._step()},_step:function(t){var e=+new Date-this._startTime,i=1e3*this._duration;e<i?this._runFrame(this._easeOut(e/i),t):(this._runFrame(1),this._complete())},_runFrame:function(t,e){var i=this._startPos.add(this._offset.multiplyBy(t));e&&i._round(),o.DomUtil.setPosition(this._el,i),this.fire("step")},_complete:function(){o.Util.cancelAnimFrame(this._animId),this._inProgress=!1,this.fire("end")},_easeOut:function(t){return 1-Math.pow(1-t,this._easeOutPower)}}),o.Projection.Mercator={R:6378137,R_MINOR:6356752.314245179,bounds:o.bounds([-20037508.34279,-15496570.73972],[20037508.34279,18764656.23138]),project:function(t){var e=Math.PI/180,i=this.R,n=t.lat*e,s=this.R_MINOR/i,r=Math.sqrt(1-s*s),a=r*Math.sin(n),h=Math.tan(Math.PI/4-n/2)/Math.pow((1-a)/(1+a),r/2);return n=-i*Math.log(Math.max(h,1e-10)),new o.Point(t.lng*e*i,n)},unproject:function(t){for(var e,i=180/Math.PI,n=this.R,s=this.R_MINOR/n,r=Math.sqrt(1-s*s),a=Math.exp(-t.y/n),h=Math.PI/2-2*Math.atan(a),l=0,u=.1;l<15&&Math.abs(u)>1e-7;l++)e=r*Math.sin(h),e=Math.pow((1-e)/(1+e),r/2),u=Math.PI/2-2*Math.atan(a*e)-h,h+=u;return new o.LatLng(h*i,t.x*i/n)}},o.CRS.EPSG3395=o.extend({},o.CRS.Earth,{code:"EPSG:3395",projection:o.Projection.Mercator,transformation:function(){var t=.5/(Math.PI*o.Projection.Mercator.R);return new o.Transformation(t,.5,-t,.5)}()}),o.GridLayer=o.Layer.extend({options:{tileSize:256,opacity:1,updateWhenIdle:o.Browser.mobile,updateWhenZooming:!0,updateInterval:200,zIndex:1,bounds:null,minZoom:0,maxZoom:i,noWrap:!1,pane:"tilePane",className:"",keepBuffer:2},initialize:function(t){o.setOptions(this,t)},onAdd:function(){this._initContainer(),this._levels={},this._tiles={},this._resetView(),this._update()},beforeAdd:function(t){t._addZoomLimit(this)},onRemove:function(t){this._removeAllTiles(),o.DomUtil.remove(this._container),t._removeZoomLimit(this),this._container=null,this._tileZoom=null},bringToFront:function(){return this._map&&(o.DomUtil.toFront(this._container),this._setAutoZIndex(Math.max)),this},bringToBack:function(){return this._map&&(o.DomUtil.toBack(this._container),this._setAutoZIndex(Math.min)),this},getContainer:function(){return this._container},setOpacity:function(t){return this.options.opacity=t,this._updateOpacity(),this},setZIndex:function(t){return this.options.zIndex=t,this._updateZIndex(),this},isLoading:function(){return this._loading},redraw:function(){return this._map&&(this._removeAllTiles(),this._update()),this},getEvents:function(){var t={viewprereset:this._invalidateAll,viewreset:this._resetView,zoom:this._resetView,moveend:this._onMoveEnd};return this.options.updateWhenIdle||(this._onMove||(this._onMove=o.Util.throttle(this._onMoveEnd,this.options.updateInterval,this)),t.move=this._onMove),this._zoomAnimated&&(t.zoomanim=this._animateZoom),t},createTile:function(){return e.createElement("div")},getTileSize:function(){var t=this.options.tileSize;return t instanceof o.Point?t:new o.Point(t,t)},_updateZIndex:function(){this._container&&this.options.zIndex!==i&&null!==this.options.zIndex&&(this._container.style.zIndex=this.options.zIndex)},_setAutoZIndex:function(t){for(var e,i=this.getPane().children,n=-t(-(1/0),1/0),o=0,s=i.length;o<s;o++)e=i[o].style.zIndex,i[o]!==this._container&&e&&(n=t(n,+e));isFinite(n)&&(this.options.zIndex=n+t(-1,1),this._updateZIndex())},_updateOpacity:function(){if(this._map&&!o.Browser.ielt9){o.DomUtil.setOpacity(this._container,this.options.opacity);var t=+new Date,e=!1,i=!1;for(var n in this._tiles){var s=this._tiles[n];if(s.current&&s.loaded){var r=Math.min(1,(t-s.loaded)/200);o.DomUtil.setOpacity(s.el,r),r<1?e=!0:(s.active&&(i=!0),s.active=!0)}}i&&!this._noPrune&&this._pruneTiles(),e&&(o.Util.cancelAnimFrame(this._fadeFrame),this._fadeFrame=o.Util.requestAnimFrame(this._updateOpacity,this))}},_initContainer:function(){this._container||(this._container=o.DomUtil.create("div","leaflet-layer "+(this.options.className||"")),this._updateZIndex(),this.options.opacity<1&&this._updateOpacity(),this.getPane().appendChild(this._container))},_updateLevels:function(){var t=this._tileZoom,e=this.options.maxZoom;if(t===i)return i;for(var n in this._levels)this._levels[n].el.children.length||n===t?this._levels[n].el.style.zIndex=e-Math.abs(t-n):(o.DomUtil.remove(this._levels[n].el),this._removeTilesAtZoom(n),delete this._levels[n]);var s=this._levels[t],r=this._map;return s||(s=this._levels[t]={},s.el=o.DomUtil.create("div","leaflet-tile-container leaflet-zoom-animated",this._container),s.el.style.zIndex=e,s.origin=r.project(r.unproject(r.getPixelOrigin()),t).round(),s.zoom=t,this._setZoomTransform(s,r.getCenter(),r.getZoom()),o.Util.falseFn(s.el.offsetWidth)),this._level=s,s},_pruneTiles:function(){if(this._map){var t,e,i=this._map.getZoom();if(i>this.options.maxZoom||i<this.options.minZoom)return void this._removeAllTiles();for(t in this._tiles)e=this._tiles[t],e.retain=e.current;for(t in this._tiles)if(e=this._tiles[t],e.current&&!e.active){var n=e.coords;this._retainParent(n.x,n.y,n.z,n.z-5)||this._retainChildren(n.x,n.y,n.z,n.z+2)}for(t in this._tiles)this._tiles[t].retain||this._removeTile(t)}},_removeTilesAtZoom:function(t){for(var e in this._tiles)this._tiles[e].coords.z===t&&this._removeTile(e)},_removeAllTiles:function(){for(var t in this._tiles)this._removeTile(t)},_invalidateAll:function(){for(var t in this._levels)o.DomUtil.remove(this._levels[t].el),delete this._levels[t];this._removeAllTiles(),this._tileZoom=null},_retainParent:function(t,e,i,n){var s=Math.floor(t/2),r=Math.floor(e/2),a=i-1,h=new o.Point(+s,+r);h.z=+a;var l=this._tileCoordsToKey(h),u=this._tiles[l];return u&&u.active?(u.retain=!0,!0):(u&&u.loaded&&(u.retain=!0),a>n&&this._retainParent(s,r,a,n))},_retainChildren:function(t,e,i,n){for(var s=2*t;s<2*t+2;s++)for(var r=2*e;r<2*e+2;r++){var a=new o.Point(s,r);a.z=i+1;var h=this._tileCoordsToKey(a),l=this._tiles[h];l&&l.active?l.retain=!0:(l&&l.loaded&&(l.retain=!0),i+1<n&&this._retainChildren(s,r,i+1,n))}},_resetView:function(t){var e=t&&(t.pinch||t.flyTo);this._setView(this._map.getCenter(),this._map.getZoom(),e,e)},_animateZoom:function(t){this._setView(t.center,t.zoom,!0,t.noUpdate)},_setView:function(t,e,n,o){var s=Math.round(e);(this.options.maxZoom!==i&&s>this.options.maxZoom||this.options.minZoom!==i&&s<this.options.minZoom)&&(s=i);var r=this.options.updateWhenZooming&&s!==this._tileZoom;o&&!r||(this._tileZoom=s,this._abortLoading&&this._abortLoading(),this._updateLevels(),this._resetGrid(),s!==i&&this._update(t),n||this._pruneTiles(),this._noPrune=!!n),this._setZoomTransforms(t,e)},_setZoomTransforms:function(t,e){for(var i in this._levels)this._setZoomTransform(this._levels[i],t,e)},_setZoomTransform:function(t,e,i){var n=this._map.getZoomScale(i,t.zoom),s=t.origin.multiplyBy(n).subtract(this._map._getNewPixelOrigin(e,i)).round();o.Browser.any3d?o.DomUtil.setTransform(t.el,s,n):o.DomUtil.setPosition(t.el,s)},_resetGrid:function(){var t=this._map,e=t.options.crs,i=this._tileSize=this.getTileSize(),n=this._tileZoom,o=this._map.getPixelWorldBounds(this._tileZoom);o&&(this._globalTileRange=this._pxBoundsToTileRange(o)),this._wrapX=e.wrapLng&&!this.options.noWrap&&[Math.floor(t.project([0,e.wrapLng[0]],n).x/i.x),Math.ceil(t.project([0,e.wrapLng[1]],n).x/i.y)],this._wrapY=e.wrapLat&&!this.options.noWrap&&[Math.floor(t.project([e.wrapLat[0],0],n).y/i.x),Math.ceil(t.project([e.wrapLat[1],0],n).y/i.y)]},_onMoveEnd:function(){this._map&&!this._map._animatingZoom&&this._update()},_getTiledPixelBounds:function(t){var e=this._map,i=e._animatingZoom?Math.max(e._animateToZoom,e.getZoom()):e.getZoom(),n=e.getZoomScale(i,this._tileZoom),s=e.project(t,this._tileZoom).floor(),r=e.getSize().divideBy(2*n);return new o.Bounds(s.subtract(r),s.add(r))},_update:function(t){var n=this._map;if(n){var s=n.getZoom();if(t===i&&(t=n.getCenter()),this._tileZoom!==i){var r=this._getTiledPixelBounds(t),a=this._pxBoundsToTileRange(r),h=a.getCenter(),l=[],u=this.options.keepBuffer,c=new o.Bounds(a.getBottomLeft().subtract([u,-u]),a.getTopRight().add([u,-u]));for(var d in this._tiles){var _=this._tiles[d].coords;_.z===this._tileZoom&&c.contains(o.point(_.x,_.y))||(this._tiles[d].current=!1)}if(Math.abs(s-this._tileZoom)>1)return void this._setView(t,s);for(var m=a.min.y;m<=a.max.y;m++)for(var p=a.min.x;p<=a.max.x;p++){var f=new o.Point(p,m);if(f.z=this._tileZoom,this._isValidTile(f)){var g=this._tiles[this._tileCoordsToKey(f)];g?g.current=!0:l.push(f)}}if(l.sort(function(t,e){return t.distanceTo(h)-e.distanceTo(h)}),0!==l.length){this._loading||(this._loading=!0,this.fire("loading"));var v=e.createDocumentFragment();for(p=0;p<l.length;p++)this._addTile(l[p],v);this._level.el.appendChild(v)}}}},_isValidTile:function(t){var e=this._map.options.crs;if(!e.infinite){var i=this._globalTileRange;if(!e.wrapLng&&(t.x<i.min.x||t.x>i.max.x)||!e.wrapLat&&(t.y<i.min.y||t.y>i.max.y))return!1}if(!this.options.bounds)return!0;var n=this._tileCoordsToBounds(t);return o.latLngBounds(this.options.bounds).overlaps(n)},_keyToBounds:function(t){return this._tileCoordsToBounds(this._keyToTileCoords(t))},_tileCoordsToBounds:function(t){var e=this._map,i=this.getTileSize(),n=t.scaleBy(i),s=n.add(i),r=e.unproject(n,t.z),a=e.unproject(s,t.z),h=new o.LatLngBounds(r,a);return this.options.noWrap||e.wrapLatLngBounds(h),h},_tileCoordsToKey:function(t){return t.x+":"+t.y+":"+t.z},_keyToTileCoords:function(t){var e=t.split(":"),i=new o.Point(+e[0],+e[1]);return i.z=+e[2],i},_removeTile:function(t){var e=this._tiles[t];e&&(o.DomUtil.remove(e.el),delete this._tiles[t],this.fire("tileunload",{tile:e.el,coords:this._keyToTileCoords(t)}))},_initTile:function(t){o.DomUtil.addClass(t,"leaflet-tile");var e=this.getTileSize();t.style.width=e.x+"px",t.style.height=e.y+"px",t.onselectstart=o.Util.falseFn,t.onmousemove=o.Util.falseFn,o.Browser.ielt9&&this.options.opacity<1&&o.DomUtil.setOpacity(t,this.options.opacity),o.Browser.android&&!o.Browser.android23&&(t.style.WebkitBackfaceVisibility="hidden")},_addTile:function(t,e){var i=this._getTilePos(t),n=this._tileCoordsToKey(t),s=this.createTile(this._wrapCoords(t),o.bind(this._tileReady,this,t));this._initTile(s),this.createTile.length<2&&o.Util.requestAnimFrame(o.bind(this._tileReady,this,t,null,s)),o.DomUtil.setPosition(s,i),this._tiles[n]={el:s,coords:t,current:!0},e.appendChild(s),this.fire("tileloadstart",{tile:s,coords:t})},_tileReady:function(t,e,i){if(this._map){e&&this.fire("tileerror",{error:e,tile:i,coords:t});var n=this._tileCoordsToKey(t);i=this._tiles[n],i&&(i.loaded=+new Date,this._map._fadeAnimated?(o.DomUtil.setOpacity(i.el,0),o.Util.cancelAnimFrame(this._fadeFrame),this._fadeFrame=o.Util.requestAnimFrame(this._updateOpacity,this)):(i.active=!0,this._pruneTiles()),e||(o.DomUtil.addClass(i.el,"leaflet-tile-loaded"),this.fire("tileload",{tile:i.el,coords:t})),this._noTilesToLoad()&&(this._loading=!1,this.fire("load"),o.Browser.ielt9||!this._map._fadeAnimated?o.Util.requestAnimFrame(this._pruneTiles,this):setTimeout(o.bind(this._pruneTiles,this),250)))}},_getTilePos:function(t){return t.scaleBy(this.getTileSize()).subtract(this._level.origin)},_wrapCoords:function(t){var e=new o.Point(this._wrapX?o.Util.wrapNum(t.x,this._wrapX):t.x,this._wrapY?o.Util.wrapNum(t.y,this._wrapY):t.y);return e.z=t.z,e},_pxBoundsToTileRange:function(t){var e=this.getTileSize();return new o.Bounds(t.min.unscaleBy(e).floor(),t.max.unscaleBy(e).ceil().subtract([1,1]))},_noTilesToLoad:function(){for(var t in this._tiles)if(!this._tiles[t].loaded)return!1;return!0}}),o.gridLayer=function(t){return new o.GridLayer(t)},o.TileLayer=o.GridLayer.extend({options:{minZoom:0,maxZoom:18,maxNativeZoom:null,minNativeZoom:null,subdomains:"abc",errorTileUrl:"",zoomOffset:0,tms:!1,zoomReverse:!1,detectRetina:!1,crossOrigin:!1},initialize:function(t,e){this._url=t,e=o.setOptions(this,e),e.detectRetina&&o.Browser.retina&&e.maxZoom>0&&(e.tileSize=Math.floor(e.tileSize/2),e.zoomReverse?(e.zoomOffset--,e.minZoom++):(e.zoomOffset++,e.maxZoom--),e.minZoom=Math.max(0,e.minZoom)),"string"==typeof e.subdomains&&(e.subdomains=e.subdomains.split("")),o.Browser.android||this.on("tileunload",this._onTileRemove)},setUrl:function(t,e){return this._url=t,e||this.redraw(),this},createTile:function(t,i){var n=e.createElement("img");return o.DomEvent.on(n,"load",o.bind(this._tileOnLoad,this,i,n)),o.DomEvent.on(n,"error",o.bind(this._tileOnError,this,i,n)),this.options.crossOrigin&&(n.crossOrigin=""),n.alt="",n.setAttribute("role","presentation"),n.src=this.getTileUrl(t),n},getTileUrl:function(t){var e={r:o.Browser.retina?"@2x":"",s:this._getSubdomain(t),x:t.x,y:t.y,z:this._getZoomForUrl()};if(this._map&&!this._map.options.crs.infinite){var i=this._globalTileRange.max.y-t.y;this.options.tms&&(e.y=i),e["-y"]=i}return o.Util.template(this._url,o.extend(e,this.options))},_tileOnLoad:function(t,e){o.Browser.ielt9?setTimeout(o.bind(t,this,null,e),0):t(null,e)},_tileOnError:function(t,e,i){var n=this.options.errorTileUrl;n&&e.src!==n&&(e.src=n),t(i,e)},getTileSize:function(){var t=this._map,e=o.GridLayer.prototype.getTileSize.call(this),i=this._tileZoom+this.options.zoomOffset,n=this.options.minNativeZoom,s=this.options.maxNativeZoom;return null!==n&&i<n?e.divideBy(t.getZoomScale(n,i)).round():null!==s&&i>s?e.divideBy(t.getZoomScale(s,i)).round():e},_onTileRemove:function(t){t.tile.onload=null},_getZoomForUrl:function(){var t=this._tileZoom,e=this.options.maxZoom,i=this.options.zoomReverse,n=this.options.zoomOffset,o=this.options.minNativeZoom,s=this.options.maxNativeZoom;return i&&(t=e-t),t+=n,null!==o&&t<o?o:null!==s&&t>s?s:t},_getSubdomain:function(t){var e=Math.abs(t.x+t.y)%this.options.subdomains.length;return this.options.subdomains[e]},_abortLoading:function(){var t,e;for(t in this._tiles)this._tiles[t].coords.z!==this._tileZoom&&(e=this._tiles[t].el,e.onload=o.Util.falseFn,e.onerror=o.Util.falseFn,e.complete||(e.src=o.Util.emptyImageUrl,o.DomUtil.remove(e)))}}),o.tileLayer=function(t,e){return new o.TileLayer(t,e)},o.TileLayer.WMS=o.TileLayer.extend({defaultWmsParams:{service:"WMS",request:"GetMap",layers:"",styles:"",format:"image/jpeg",transparent:!1,version:"1.1.1"},options:{crs:null,uppercase:!1},initialize:function(t,e){this._url=t;var i=o.extend({},this.defaultWmsParams);for(var n in e)n in this.options||(i[n]=e[n]);e=o.setOptions(this,e),i.width=i.height=e.tileSize*(e.detectRetina&&o.Browser.retina?2:1),this.wmsParams=i},onAdd:function(t){this._crs=this.options.crs||t.options.crs,this._wmsVersion=parseFloat(this.wmsParams.version);var e=this._wmsVersion>=1.3?"crs":"srs";this.wmsParams[e]=this._crs.code,o.TileLayer.prototype.onAdd.call(this,t)},getTileUrl:function(t){var e=this._tileCoordsToBounds(t),i=this._crs.project(e.getNorthWest()),n=this._crs.project(e.getSouthEast()),s=(this._wmsVersion>=1.3&&this._crs===o.CRS.EPSG4326?[n.y,i.x,i.y,n.x]:[i.x,n.y,n.x,i.y]).join(","),r=o.TileLayer.prototype.getTileUrl.call(this,t);return r+o.Util.getParamString(this.wmsParams,r,this.options.uppercase)+(this.options.uppercase?"&BBOX=":"&bbox=")+s},setParams:function(t,e){return o.extend(this.wmsParams,t),e||this.redraw(),this}}),o.tileLayer.wms=function(t,e){return new o.TileLayer.WMS(t,e)},o.ImageOverlay=o.Layer.extend({options:{opacity:1,alt:"",interactive:!1,crossOrigin:!1},initialize:function(t,e,i){this._url=t,this._bounds=o.latLngBounds(e),o.setOptions(this,i)},onAdd:function(){this._image||(this._initImage(),this.options.opacity<1&&this._updateOpacity()),this.options.interactive&&(o.DomUtil.addClass(this._image,"leaflet-interactive"),this.addInteractiveTarget(this._image)),this.getPane().appendChild(this._image),this._reset()},onRemove:function(){o.DomUtil.remove(this._image),this.options.interactive&&this.removeInteractiveTarget(this._image)},setOpacity:function(t){return this.options.opacity=t,this._image&&this._updateOpacity(),this},setStyle:function(t){return t.opacity&&this.setOpacity(t.opacity),this},bringToFront:function(){return this._map&&o.DomUtil.toFront(this._image),this},bringToBack:function(){return this._map&&o.DomUtil.toBack(this._image),this},setUrl:function(t){return this._url=t,this._image&&(this._image.src=t),this},setBounds:function(t){return this._bounds=t,this._map&&this._reset(),this},getEvents:function(){var t={zoom:this._reset,viewreset:this._reset};return this._zoomAnimated&&(t.zoomanim=this._animateZoom),t},getBounds:function(){return this._bounds},getElement:function(){return this._image},_initImage:function(){var t=this._image=o.DomUtil.create("img","leaflet-image-layer "+(this._zoomAnimated?"leaflet-zoom-animated":""));t.onselectstart=o.Util.falseFn,t.onmousemove=o.Util.falseFn,t.onload=o.bind(this.fire,this,"load"),this.options.crossOrigin&&(t.crossOrigin=""),t.src=this._url,t.alt=this.options.alt},_animateZoom:function(t){var e=this._map.getZoomScale(t.zoom),i=this._map._latLngBoundsToNewLayerBounds(this._bounds,t.zoom,t.center).min;o.DomUtil.setTransform(this._image,i,e)},_reset:function(){var t=this._image,e=new o.Bounds(this._map.latLngToLayerPoint(this._bounds.getNorthWest()),this._map.latLngToLayerPoint(this._bounds.getSouthEast())),i=e.getSize();
|
|
o.DomUtil.setPosition(t,e.min),t.style.width=i.x+"px",t.style.height=i.y+"px"},_updateOpacity:function(){o.DomUtil.setOpacity(this._image,this.options.opacity)}}),o.imageOverlay=function(t,e,i){return new o.ImageOverlay(t,e,i)},o.Icon=o.Class.extend({initialize:function(t){o.setOptions(this,t)},createIcon:function(t){return this._createIcon("icon",t)},createShadow:function(t){return this._createIcon("shadow",t)},_createIcon:function(t,e){var i=this._getIconUrl(t);if(!i){if("icon"===t)throw new Error("iconUrl not set in Icon options (see the docs).");return null}var n=this._createImg(i,e&&"IMG"===e.tagName?e:null);return this._setIconStyles(n,t),n},_setIconStyles:function(t,e){var i=this.options,n=i[e+"Size"];"number"==typeof n&&(n=[n,n]);var s=o.point(n),r=o.point("shadow"===e&&i.shadowAnchor||i.iconAnchor||s&&s.divideBy(2,!0));t.className="leaflet-marker-"+e+" "+(i.className||""),r&&(t.style.marginLeft=-r.x+"px",t.style.marginTop=-r.y+"px"),s&&(t.style.width=s.x+"px",t.style.height=s.y+"px")},_createImg:function(t,i){return i=i||e.createElement("img"),i.src=t,i},_getIconUrl:function(t){return o.Browser.retina&&this.options[t+"RetinaUrl"]||this.options[t+"Url"]}}),o.icon=function(t){return new o.Icon(t)},o.Icon.Default=o.Icon.extend({options:{iconUrl:"marker-icon.png",iconRetinaUrl:"marker-icon-2x.png",shadowUrl:"marker-shadow.png",iconSize:[25,41],iconAnchor:[12,41],popupAnchor:[1,-34],tooltipAnchor:[16,-28],shadowSize:[41,41]},_getIconUrl:function(t){return o.Icon.Default.imagePath||(o.Icon.Default.imagePath=this._detectIconPath()),(this.options.imagePath||o.Icon.Default.imagePath)+o.Icon.prototype._getIconUrl.call(this,t)},_detectIconPath:function(){var t=o.DomUtil.create("div","leaflet-default-icon-path",e.body),i=o.DomUtil.getStyle(t,"background-image")||o.DomUtil.getStyle(t,"backgroundImage");return e.body.removeChild(t),0===i.indexOf("url")?i.replace(/^url\([\"\']?/,"").replace(/marker-icon\.png[\"\']?\)$/,""):""}}),o.Marker=o.Layer.extend({options:{icon:new o.Icon.Default,interactive:!0,draggable:!1,keyboard:!0,title:"",alt:"",zIndexOffset:0,opacity:1,riseOnHover:!1,riseOffset:250,pane:"markerPane",nonBubblingEvents:["click","dblclick","mouseover","mouseout","contextmenu"]},initialize:function(t,e){o.setOptions(this,e),this._latlng=o.latLng(t)},onAdd:function(t){this._zoomAnimated=this._zoomAnimated&&t.options.markerZoomAnimation,this._zoomAnimated&&t.on("zoomanim",this._animateZoom,this),this._initIcon(),this.update()},onRemove:function(t){this.dragging&&this.dragging.enabled()&&(this.options.draggable=!0,this.dragging.removeHooks()),this._zoomAnimated&&t.off("zoomanim",this._animateZoom,this),this._removeIcon(),this._removeShadow()},getEvents:function(){return{zoom:this.update,viewreset:this.update}},getLatLng:function(){return this._latlng},setLatLng:function(t){var e=this._latlng;return this._latlng=o.latLng(t),this.update(),this.fire("move",{oldLatLng:e,latlng:this._latlng})},setZIndexOffset:function(t){return this.options.zIndexOffset=t,this.update()},setIcon:function(t){return this.options.icon=t,this._map&&(this._initIcon(),this.update()),this._popup&&this.bindPopup(this._popup,this._popup.options),this},getElement:function(){return this._icon},update:function(){if(this._icon){var t=this._map.latLngToLayerPoint(this._latlng).round();this._setPos(t)}return this},_initIcon:function(){var t=this.options,e="leaflet-zoom-"+(this._zoomAnimated?"animated":"hide"),i=t.icon.createIcon(this._icon),n=!1;i!==this._icon&&(this._icon&&this._removeIcon(),n=!0,t.title&&(i.title=t.title),t.alt&&(i.alt=t.alt)),o.DomUtil.addClass(i,e),t.keyboard&&(i.tabIndex="0"),this._icon=i,t.riseOnHover&&this.on({mouseover:this._bringToFront,mouseout:this._resetZIndex});var s=t.icon.createShadow(this._shadow),r=!1;s!==this._shadow&&(this._removeShadow(),r=!0),s&&(o.DomUtil.addClass(s,e),s.alt=""),this._shadow=s,t.opacity<1&&this._updateOpacity(),n&&this.getPane().appendChild(this._icon),this._initInteraction(),s&&r&&this.getPane("shadowPane").appendChild(this._shadow)},_removeIcon:function(){this.options.riseOnHover&&this.off({mouseover:this._bringToFront,mouseout:this._resetZIndex}),o.DomUtil.remove(this._icon),this.removeInteractiveTarget(this._icon),this._icon=null},_removeShadow:function(){this._shadow&&o.DomUtil.remove(this._shadow),this._shadow=null},_setPos:function(t){o.DomUtil.setPosition(this._icon,t),this._shadow&&o.DomUtil.setPosition(this._shadow,t),this._zIndex=t.y+this.options.zIndexOffset,this._resetZIndex()},_updateZIndex:function(t){this._icon.style.zIndex=this._zIndex+t},_animateZoom:function(t){var e=this._map._latLngToNewLayerPoint(this._latlng,t.zoom,t.center).round();this._setPos(e)},_initInteraction:function(){if(this.options.interactive&&(o.DomUtil.addClass(this._icon,"leaflet-interactive"),this.addInteractiveTarget(this._icon),o.Handler.MarkerDrag)){var t=this.options.draggable;this.dragging&&(t=this.dragging.enabled(),this.dragging.disable()),this.dragging=new o.Handler.MarkerDrag(this),t&&this.dragging.enable()}},setOpacity:function(t){return this.options.opacity=t,this._map&&this._updateOpacity(),this},_updateOpacity:function(){var t=this.options.opacity;o.DomUtil.setOpacity(this._icon,t),this._shadow&&o.DomUtil.setOpacity(this._shadow,t)},_bringToFront:function(){this._updateZIndex(this.options.riseOffset)},_resetZIndex:function(){this._updateZIndex(0)},_getPopupAnchor:function(){return this.options.icon.options.popupAnchor||[0,0]},_getTooltipAnchor:function(){return this.options.icon.options.tooltipAnchor||[0,0]}}),o.marker=function(t,e){return new o.Marker(t,e)},o.DivIcon=o.Icon.extend({options:{iconSize:[12,12],html:!1,bgPos:null,className:"leaflet-div-icon"},createIcon:function(t){var i=t&&"DIV"===t.tagName?t:e.createElement("div"),n=this.options;if(i.innerHTML=n.html!==!1?n.html:"",n.bgPos){var s=o.point(n.bgPos);i.style.backgroundPosition=-s.x+"px "+-s.y+"px"}return this._setIconStyles(i,"icon"),i},createShadow:function(){return null}}),o.divIcon=function(t){return new o.DivIcon(t)},o.DivOverlay=o.Layer.extend({options:{offset:[0,7],className:"",pane:"popupPane"},initialize:function(t,e){o.setOptions(this,t),this._source=e},onAdd:function(t){this._zoomAnimated=t._zoomAnimated,this._container||this._initLayout(),t._fadeAnimated&&o.DomUtil.setOpacity(this._container,0),clearTimeout(this._removeTimeout),this.getPane().appendChild(this._container),this.update(),t._fadeAnimated&&o.DomUtil.setOpacity(this._container,1),this.bringToFront()},onRemove:function(t){t._fadeAnimated?(o.DomUtil.setOpacity(this._container,0),this._removeTimeout=setTimeout(o.bind(o.DomUtil.remove,o.DomUtil,this._container),200)):o.DomUtil.remove(this._container)},getLatLng:function(){return this._latlng},setLatLng:function(t){return this._latlng=o.latLng(t),this._map&&(this._updatePosition(),this._adjustPan()),this},getContent:function(){return this._content},setContent:function(t){return this._content=t,this.update(),this},getElement:function(){return this._container},update:function(){this._map&&(this._container.style.visibility="hidden",this._updateContent(),this._updateLayout(),this._updatePosition(),this._container.style.visibility="",this._adjustPan())},getEvents:function(){var t={zoom:this._updatePosition,viewreset:this._updatePosition};return this._zoomAnimated&&(t.zoomanim=this._animateZoom),t},isOpen:function(){return!!this._map&&this._map.hasLayer(this)},bringToFront:function(){return this._map&&o.DomUtil.toFront(this._container),this},bringToBack:function(){return this._map&&o.DomUtil.toBack(this._container),this},_updateContent:function(){if(this._content){var t=this._contentNode,e="function"==typeof this._content?this._content(this._source||this):this._content;if("string"==typeof e)t.innerHTML=e;else{for(;t.hasChildNodes();)t.removeChild(t.firstChild);t.appendChild(e)}this.fire("contentupdate")}},_updatePosition:function(){if(this._map){var t=this._map.latLngToLayerPoint(this._latlng),e=o.point(this.options.offset),i=this._getAnchor();this._zoomAnimated?o.DomUtil.setPosition(this._container,t.add(i)):e=e.add(t).add(i);var n=this._containerBottom=-e.y,s=this._containerLeft=-Math.round(this._containerWidth/2)+e.x;this._container.style.bottom=n+"px",this._container.style.left=s+"px"}},_getAnchor:function(){return[0,0]}}),o.Popup=o.DivOverlay.extend({options:{maxWidth:300,minWidth:50,maxHeight:null,autoPan:!0,autoPanPaddingTopLeft:null,autoPanPaddingBottomRight:null,autoPanPadding:[5,5],keepInView:!1,closeButton:!0,autoClose:!0,className:""},openOn:function(t){return t.openPopup(this),this},onAdd:function(t){o.DivOverlay.prototype.onAdd.call(this,t),t.fire("popupopen",{popup:this}),this._source&&(this._source.fire("popupopen",{popup:this},!0),this._source instanceof o.Path||this._source.on("preclick",o.DomEvent.stopPropagation))},onRemove:function(t){o.DivOverlay.prototype.onRemove.call(this,t),t.fire("popupclose",{popup:this}),this._source&&(this._source.fire("popupclose",{popup:this},!0),this._source instanceof o.Path||this._source.off("preclick",o.DomEvent.stopPropagation))},getEvents:function(){var t=o.DivOverlay.prototype.getEvents.call(this);return("closeOnClick"in this.options?this.options.closeOnClick:this._map.options.closePopupOnClick)&&(t.preclick=this._close),this.options.keepInView&&(t.moveend=this._adjustPan),t},_close:function(){this._map&&this._map.closePopup(this)},_initLayout:function(){var t="leaflet-popup",e=this._container=o.DomUtil.create("div",t+" "+(this.options.className||"")+" leaflet-zoom-animated");if(this.options.closeButton){var i=this._closeButton=o.DomUtil.create("a",t+"-close-button",e);i.href="#close",i.innerHTML="×",o.DomEvent.on(i,"click",this._onCloseButtonClick,this)}var n=this._wrapper=o.DomUtil.create("div",t+"-content-wrapper",e);this._contentNode=o.DomUtil.create("div",t+"-content",n),o.DomEvent.disableClickPropagation(n).disableScrollPropagation(this._contentNode).on(n,"contextmenu",o.DomEvent.stopPropagation),this._tipContainer=o.DomUtil.create("div",t+"-tip-container",e),this._tip=o.DomUtil.create("div",t+"-tip",this._tipContainer)},_updateLayout:function(){var t=this._contentNode,e=t.style;e.width="",e.whiteSpace="nowrap";var i=t.offsetWidth;i=Math.min(i,this.options.maxWidth),i=Math.max(i,this.options.minWidth),e.width=i+1+"px",e.whiteSpace="",e.height="";var n=t.offsetHeight,s=this.options.maxHeight,r="leaflet-popup-scrolled";s&&n>s?(e.height=s+"px",o.DomUtil.addClass(t,r)):o.DomUtil.removeClass(t,r),this._containerWidth=this._container.offsetWidth},_animateZoom:function(t){var e=this._map._latLngToNewLayerPoint(this._latlng,t.zoom,t.center),i=this._getAnchor();o.DomUtil.setPosition(this._container,e.add(i))},_adjustPan:function(){if(!(!this.options.autoPan||this._map._panAnim&&this._map._panAnim._inProgress)){var t=this._map,e=parseInt(o.DomUtil.getStyle(this._container,"marginBottom"),10)||0,i=this._container.offsetHeight+e,n=this._containerWidth,s=new o.Point(this._containerLeft,-i-this._containerBottom);s._add(o.DomUtil.getPosition(this._container));var r=t.layerPointToContainerPoint(s),a=o.point(this.options.autoPanPadding),h=o.point(this.options.autoPanPaddingTopLeft||a),l=o.point(this.options.autoPanPaddingBottomRight||a),u=t.getSize(),c=0,d=0;r.x+n+l.x>u.x&&(c=r.x+n-u.x+l.x),r.x-c-h.x<0&&(c=r.x-h.x),r.y+i+l.y>u.y&&(d=r.y+i-u.y+l.y),r.y-d-h.y<0&&(d=r.y-h.y),(c||d)&&t.fire("autopanstart").panBy([c,d])}},_onCloseButtonClick:function(t){this._close(),o.DomEvent.stop(t)},_getAnchor:function(){return o.point(this._source&&this._source._getPopupAnchor?this._source._getPopupAnchor():[0,0])}}),o.popup=function(t,e){return new o.Popup(t,e)},o.Map.mergeOptions({closePopupOnClick:!0}),o.Map.include({openPopup:function(t,e,i){return t instanceof o.Popup||(t=new o.Popup(i).setContent(t)),e&&t.setLatLng(e),this.hasLayer(t)?this:(this._popup&&this._popup.options.autoClose&&this.closePopup(),this._popup=t,this.addLayer(t))},closePopup:function(t){return t&&t!==this._popup||(t=this._popup,this._popup=null),t&&this.removeLayer(t),this}}),o.Layer.include({bindPopup:function(t,e){return t instanceof o.Popup?(o.setOptions(t,e),this._popup=t,t._source=this):(this._popup&&!e||(this._popup=new o.Popup(e,this)),this._popup.setContent(t)),this._popupHandlersAdded||(this.on({click:this._openPopup,remove:this.closePopup,move:this._movePopup}),this._popupHandlersAdded=!0),this},unbindPopup:function(){return this._popup&&(this.off({click:this._openPopup,remove:this.closePopup,move:this._movePopup}),this._popupHandlersAdded=!1,this._popup=null),this},openPopup:function(t,e){if(t instanceof o.Layer||(e=t,t=this),t instanceof o.FeatureGroup)for(var i in this._layers){t=this._layers[i];break}return e||(e=t.getCenter?t.getCenter():t.getLatLng()),this._popup&&this._map&&(this._popup._source=t,this._popup.update(),this._map.openPopup(this._popup,e)),this},closePopup:function(){return this._popup&&this._popup._close(),this},togglePopup:function(t){return this._popup&&(this._popup._map?this.closePopup():this.openPopup(t)),this},isPopupOpen:function(){return!!this._popup&&this._popup.isOpen()},setPopupContent:function(t){return this._popup&&this._popup.setContent(t),this},getPopup:function(){return this._popup},_openPopup:function(t){var e=t.layer||t.target;if(this._popup&&this._map)return o.DomEvent.stop(t),e instanceof o.Path?void this.openPopup(t.layer||t.target,t.latlng):void(this._map.hasLayer(this._popup)&&this._popup._source===e?this.closePopup():this.openPopup(e,t.latlng))},_movePopup:function(t){this._popup.setLatLng(t.latlng)}}),o.Tooltip=o.DivOverlay.extend({options:{pane:"tooltipPane",offset:[0,0],direction:"auto",permanent:!1,sticky:!1,interactive:!1,opacity:.9},onAdd:function(t){o.DivOverlay.prototype.onAdd.call(this,t),this.setOpacity(this.options.opacity),t.fire("tooltipopen",{tooltip:this}),this._source&&this._source.fire("tooltipopen",{tooltip:this},!0)},onRemove:function(t){o.DivOverlay.prototype.onRemove.call(this,t),t.fire("tooltipclose",{tooltip:this}),this._source&&this._source.fire("tooltipclose",{tooltip:this},!0)},getEvents:function(){var t=o.DivOverlay.prototype.getEvents.call(this);return o.Browser.touch&&!this.options.permanent&&(t.preclick=this._close),t},_close:function(){this._map&&this._map.closeTooltip(this)},_initLayout:function(){var t="leaflet-tooltip",e=t+" "+(this.options.className||"")+" leaflet-zoom-"+(this._zoomAnimated?"animated":"hide");this._contentNode=this._container=o.DomUtil.create("div",e)},_updateLayout:function(){},_adjustPan:function(){},_setPosition:function(t){var e=this._map,i=this._container,n=e.latLngToContainerPoint(e.getCenter()),s=e.layerPointToContainerPoint(t),r=this.options.direction,a=i.offsetWidth,h=i.offsetHeight,l=o.point(this.options.offset),u=this._getAnchor();"top"===r?t=t.add(o.point(-a/2+l.x,-h+l.y+u.y,!0)):"bottom"===r?t=t.subtract(o.point(a/2-l.x,-l.y,!0)):"center"===r?t=t.subtract(o.point(a/2+l.x,h/2-u.y+l.y,!0)):"right"===r||"auto"===r&&s.x<n.x?(r="right",t=t.add(o.point(l.x+u.x,u.y-h/2+l.y,!0))):(r="left",t=t.subtract(o.point(a+u.x-l.x,h/2-u.y-l.y,!0))),o.DomUtil.removeClass(i,"leaflet-tooltip-right"),o.DomUtil.removeClass(i,"leaflet-tooltip-left"),o.DomUtil.removeClass(i,"leaflet-tooltip-top"),o.DomUtil.removeClass(i,"leaflet-tooltip-bottom"),o.DomUtil.addClass(i,"leaflet-tooltip-"+r),o.DomUtil.setPosition(i,t)},_updatePosition:function(){var t=this._map.latLngToLayerPoint(this._latlng);this._setPosition(t)},setOpacity:function(t){this.options.opacity=t,this._container&&o.DomUtil.setOpacity(this._container,t)},_animateZoom:function(t){var e=this._map._latLngToNewLayerPoint(this._latlng,t.zoom,t.center);this._setPosition(e)},_getAnchor:function(){return o.point(this._source&&this._source._getTooltipAnchor&&!this.options.sticky?this._source._getTooltipAnchor():[0,0])}}),o.tooltip=function(t,e){return new o.Tooltip(t,e)},o.Map.include({openTooltip:function(t,e,i){return t instanceof o.Tooltip||(t=new o.Tooltip(i).setContent(t)),e&&t.setLatLng(e),this.hasLayer(t)?this:this.addLayer(t)},closeTooltip:function(t){return t&&this.removeLayer(t),this}}),o.Layer.include({bindTooltip:function(t,e){return t instanceof o.Tooltip?(o.setOptions(t,e),this._tooltip=t,t._source=this):(this._tooltip&&!e||(this._tooltip=o.tooltip(e,this)),this._tooltip.setContent(t)),this._initTooltipInteractions(),this._tooltip.options.permanent&&this._map&&this._map.hasLayer(this)&&this.openTooltip(),this},unbindTooltip:function(){return this._tooltip&&(this._initTooltipInteractions(!0),this.closeTooltip(),this._tooltip=null),this},_initTooltipInteractions:function(t){if(t||!this._tooltipHandlersAdded){var e=t?"off":"on",i={remove:this.closeTooltip,move:this._moveTooltip};this._tooltip.options.permanent?i.add=this._openTooltip:(i.mouseover=this._openTooltip,i.mouseout=this.closeTooltip,this._tooltip.options.sticky&&(i.mousemove=this._moveTooltip),o.Browser.touch&&(i.click=this._openTooltip)),this[e](i),this._tooltipHandlersAdded=!t}},openTooltip:function(t,e){if(t instanceof o.Layer||(e=t,t=this),t instanceof o.FeatureGroup)for(var i in this._layers){t=this._layers[i];break}return e||(e=t.getCenter?t.getCenter():t.getLatLng()),this._tooltip&&this._map&&(this._tooltip._source=t,this._tooltip.update(),this._map.openTooltip(this._tooltip,e),this._tooltip.options.interactive&&this._tooltip._container&&(o.DomUtil.addClass(this._tooltip._container,"leaflet-clickable"),this.addInteractiveTarget(this._tooltip._container))),this},closeTooltip:function(){return this._tooltip&&(this._tooltip._close(),this._tooltip.options.interactive&&this._tooltip._container&&(o.DomUtil.removeClass(this._tooltip._container,"leaflet-clickable"),this.removeInteractiveTarget(this._tooltip._container))),this},toggleTooltip:function(t){return this._tooltip&&(this._tooltip._map?this.closeTooltip():this.openTooltip(t)),this},isTooltipOpen:function(){return this._tooltip.isOpen()},setTooltipContent:function(t){return this._tooltip&&this._tooltip.setContent(t),this},getTooltip:function(){return this._tooltip},_openTooltip:function(t){var e=t.layer||t.target;this._tooltip&&this._map&&this.openTooltip(e,this._tooltip.options.sticky?t.latlng:i)},_moveTooltip:function(t){var e,i,n=t.latlng;this._tooltip.options.sticky&&t.originalEvent&&(e=this._map.mouseEventToContainerPoint(t.originalEvent),i=this._map.containerPointToLayerPoint(e),n=this._map.layerPointToLatLng(i)),this._tooltip.setLatLng(n)}}),o.LayerGroup=o.Layer.extend({initialize:function(t){this._layers={};var e,i;if(t)for(e=0,i=t.length;e<i;e++)this.addLayer(t[e])},addLayer:function(t){var e=this.getLayerId(t);return this._layers[e]=t,this._map&&this._map.addLayer(t),this},removeLayer:function(t){var e=t in this._layers?t:this.getLayerId(t);return this._map&&this._layers[e]&&this._map.removeLayer(this._layers[e]),delete this._layers[e],this},hasLayer:function(t){return!!t&&(t in this._layers||this.getLayerId(t)in this._layers)},clearLayers:function(){for(var t in this._layers)this.removeLayer(this._layers[t]);return this},invoke:function(t){var e,i,n=Array.prototype.slice.call(arguments,1);for(e in this._layers)i=this._layers[e],i[t]&&i[t].apply(i,n);return this},onAdd:function(t){for(var e in this._layers)t.addLayer(this._layers[e])},onRemove:function(t){for(var e in this._layers)t.removeLayer(this._layers[e])},eachLayer:function(t,e){for(var i in this._layers)t.call(e,this._layers[i]);return this},getLayer:function(t){return this._layers[t]},getLayers:function(){var t=[];for(var e in this._layers)t.push(this._layers[e]);return t},setZIndex:function(t){return this.invoke("setZIndex",t)},getLayerId:function(t){return o.stamp(t)}}),o.layerGroup=function(t){return new o.LayerGroup(t)},o.FeatureGroup=o.LayerGroup.extend({addLayer:function(t){return this.hasLayer(t)?this:(t.addEventParent(this),o.LayerGroup.prototype.addLayer.call(this,t),this.fire("layeradd",{layer:t}))},removeLayer:function(t){return this.hasLayer(t)?(t in this._layers&&(t=this._layers[t]),t.removeEventParent(this),o.LayerGroup.prototype.removeLayer.call(this,t),this.fire("layerremove",{layer:t})):this},setStyle:function(t){return this.invoke("setStyle",t)},bringToFront:function(){return this.invoke("bringToFront")},bringToBack:function(){return this.invoke("bringToBack")},getBounds:function(){var t=new o.LatLngBounds;for(var e in this._layers){var i=this._layers[e];t.extend(i.getBounds?i.getBounds():i.getLatLng())}return t}}),o.featureGroup=function(t){return new o.FeatureGroup(t)},o.Renderer=o.Layer.extend({options:{padding:.1},initialize:function(t){o.setOptions(this,t),o.stamp(this),this._layers=this._layers||{}},onAdd:function(){this._container||(this._initContainer(),this._zoomAnimated&&o.DomUtil.addClass(this._container,"leaflet-zoom-animated")),this.getPane().appendChild(this._container),this._update(),this.on("update",this._updatePaths,this)},onRemove:function(){o.DomUtil.remove(this._container),this.off("update",this._updatePaths,this)},getEvents:function(){var t={viewreset:this._reset,zoom:this._onZoom,moveend:this._update,zoomend:this._onZoomEnd};return this._zoomAnimated&&(t.zoomanim=this._onAnimZoom),t},_onAnimZoom:function(t){this._updateTransform(t.center,t.zoom)},_onZoom:function(){this._updateTransform(this._map.getCenter(),this._map.getZoom())},_updateTransform:function(t,e){var i=this._map.getZoomScale(e,this._zoom),n=o.DomUtil.getPosition(this._container),s=this._map.getSize().multiplyBy(.5+this.options.padding),r=this._map.project(this._center,e),a=this._map.project(t,e),h=a.subtract(r),l=s.multiplyBy(-i).add(n).add(s).subtract(h);o.Browser.any3d?o.DomUtil.setTransform(this._container,l,i):o.DomUtil.setPosition(this._container,l)},_reset:function(){this._update(),this._updateTransform(this._center,this._zoom);for(var t in this._layers)this._layers[t]._reset()},_onZoomEnd:function(){for(var t in this._layers)this._layers[t]._project()},_updatePaths:function(){for(var t in this._layers)this._layers[t]._update()},_update:function(){var t=this.options.padding,e=this._map.getSize(),i=this._map.containerPointToLayerPoint(e.multiplyBy(-t)).round();this._bounds=new o.Bounds(i,i.add(e.multiplyBy(1+2*t)).round()),this._center=this._map.getCenter(),this._zoom=this._map.getZoom()}}),o.Map.include({getRenderer:function(t){var e=t.options.renderer||this._getPaneRenderer(t.options.pane)||this.options.renderer||this._renderer;return e||(e=this._renderer=this.options.preferCanvas&&o.canvas()||o.svg()),this.hasLayer(e)||this.addLayer(e),e},_getPaneRenderer:function(t){if("overlayPane"===t||t===i)return!1;var e=this._paneRenderers[t];return e===i&&(e=o.SVG&&o.svg({pane:t})||o.Canvas&&o.canvas({pane:t}),this._paneRenderers[t]=e),e}}),o.Path=o.Layer.extend({options:{stroke:!0,color:"#3388ff",weight:3,opacity:1,lineCap:"round",lineJoin:"round",dashArray:null,dashOffset:null,fill:!1,fillColor:null,fillOpacity:.2,fillRule:"evenodd",interactive:!0},beforeAdd:function(t){this._renderer=t.getRenderer(this)},onAdd:function(){this._renderer._initPath(this),this._reset(),this._renderer._addPath(this)},onRemove:function(){this._renderer._removePath(this)},redraw:function(){return this._map&&this._renderer._updatePath(this),this},setStyle:function(t){return o.setOptions(this,t),this._renderer&&this._renderer._updateStyle(this),this},bringToFront:function(){return this._renderer&&this._renderer._bringToFront(this),this},bringToBack:function(){return this._renderer&&this._renderer._bringToBack(this),this},getElement:function(){return this._path},_reset:function(){this._project(),this._update()},_clickTolerance:function(){return(this.options.stroke?this.options.weight/2:0)+(o.Browser.touch?10:0)}}),o.LineUtil={simplify:function(t,e){if(!e||!t.length)return t.slice();var i=e*e;return t=this._reducePoints(t,i),t=this._simplifyDP(t,i)},pointToSegmentDistance:function(t,e,i){return Math.sqrt(this._sqClosestPointOnSegment(t,e,i,!0))},closestPointOnSegment:function(t,e,i){return this._sqClosestPointOnSegment(t,e,i)},_simplifyDP:function(t,e){var n=t.length,o=typeof Uint8Array!=i+""?Uint8Array:Array,s=new o(n);s[0]=s[n-1]=1,this._simplifyDPStep(t,s,e,0,n-1);var r,a=[];for(r=0;r<n;r++)s[r]&&a.push(t[r]);return a},_simplifyDPStep:function(t,e,i,n,o){var s,r,a,h=0;for(r=n+1;r<=o-1;r++)a=this._sqClosestPointOnSegment(t[r],t[n],t[o],!0),a>h&&(s=r,h=a);h>i&&(e[s]=1,this._simplifyDPStep(t,e,i,n,s),this._simplifyDPStep(t,e,i,s,o))},_reducePoints:function(t,e){for(var i=[t[0]],n=1,o=0,s=t.length;n<s;n++)this._sqDist(t[n],t[o])>e&&(i.push(t[n]),o=n);return o<s-1&&i.push(t[s-1]),i},clipSegment:function(t,e,i,n,o){var s,r,a,h=n?this._lastCode:this._getBitCode(t,i),l=this._getBitCode(e,i);for(this._lastCode=l;;){if(!(h|l))return[t,e];if(h&l)return!1;s=h||l,r=this._getEdgeIntersection(t,e,s,i,o),a=this._getBitCode(r,i),s===h?(t=r,h=a):(e=r,l=a)}},_getEdgeIntersection:function(t,e,i,n,s){var r,a,h=e.x-t.x,l=e.y-t.y,u=n.min,c=n.max;return 8&i?(r=t.x+h*(c.y-t.y)/l,a=c.y):4&i?(r=t.x+h*(u.y-t.y)/l,a=u.y):2&i?(r=c.x,a=t.y+l*(c.x-t.x)/h):1&i&&(r=u.x,a=t.y+l*(u.x-t.x)/h),new o.Point(r,a,s)},_getBitCode:function(t,e){var i=0;return t.x<e.min.x?i|=1:t.x>e.max.x&&(i|=2),t.y<e.min.y?i|=4:t.y>e.max.y&&(i|=8),i},_sqDist:function(t,e){var i=e.x-t.x,n=e.y-t.y;return i*i+n*n},_sqClosestPointOnSegment:function(t,e,i,n){var s,r=e.x,a=e.y,h=i.x-r,l=i.y-a,u=h*h+l*l;return u>0&&(s=((t.x-r)*h+(t.y-a)*l)/u,s>1?(r=i.x,a=i.y):s>0&&(r+=h*s,a+=l*s)),h=t.x-r,l=t.y-a,n?h*h+l*l:new o.Point(r,a)}},o.Polyline=o.Path.extend({options:{smoothFactor:1,noClip:!1},initialize:function(t,e){o.setOptions(this,e),this._setLatLngs(t)},getLatLngs:function(){return this._latlngs},setLatLngs:function(t){return this._setLatLngs(t),this.redraw()},isEmpty:function(){return!this._latlngs.length},closestLayerPoint:function(t){for(var e,i,n=1/0,s=null,r=o.LineUtil._sqClosestPointOnSegment,a=0,h=this._parts.length;a<h;a++)for(var l=this._parts[a],u=1,c=l.length;u<c;u++){e=l[u-1],i=l[u];var d=r(t,e,i,!0);d<n&&(n=d,s=r(t,e,i))}return s&&(s.distance=Math.sqrt(n)),s},getCenter:function(){if(!this._map)throw new Error("Must add layer to map before using getCenter()");var t,e,i,n,o,s,r,a=this._rings[0],h=a.length;if(!h)return null;for(t=0,e=0;t<h-1;t++)e+=a[t].distanceTo(a[t+1])/2;if(0===e)return this._map.layerPointToLatLng(a[0]);for(t=0,n=0;t<h-1;t++)if(o=a[t],s=a[t+1],i=o.distanceTo(s),n+=i,n>e)return r=(n-e)/i,this._map.layerPointToLatLng([s.x-r*(s.x-o.x),s.y-r*(s.y-o.y)])},getBounds:function(){return this._bounds},addLatLng:function(t,e){return e=e||this._defaultShape(),t=o.latLng(t),e.push(t),this._bounds.extend(t),this.redraw()},_setLatLngs:function(t){this._bounds=new o.LatLngBounds,this._latlngs=this._convertLatLngs(t)},_defaultShape:function(){return o.Polyline._flat(this._latlngs)?this._latlngs:this._latlngs[0]},_convertLatLngs:function(t){for(var e=[],i=o.Polyline._flat(t),n=0,s=t.length;n<s;n++)i?(e[n]=o.latLng(t[n]),this._bounds.extend(e[n])):e[n]=this._convertLatLngs(t[n]);return e},_project:function(){var t=new o.Bounds;this._rings=[],this._projectLatlngs(this._latlngs,this._rings,t);var e=this._clickTolerance(),i=new o.Point(e,e);this._bounds.isValid()&&t.isValid()&&(t.min._subtract(i),t.max._add(i),this._pxBounds=t)},_projectLatlngs:function(t,e,i){var n,s,r=t[0]instanceof o.LatLng,a=t.length;if(r){for(s=[],n=0;n<a;n++)s[n]=this._map.latLngToLayerPoint(t[n]),i.extend(s[n]);e.push(s)}else for(n=0;n<a;n++)this._projectLatlngs(t[n],e,i)},_clipPoints:function(){var t=this._renderer._bounds;if(this._parts=[],this._pxBounds&&this._pxBounds.intersects(t)){if(this.options.noClip)return void(this._parts=this._rings);var e,i,n,s,r,a,h,l=this._parts;for(e=0,n=0,s=this._rings.length;e<s;e++)for(h=this._rings[e],i=0,r=h.length;i<r-1;i++)a=o.LineUtil.clipSegment(h[i],h[i+1],t,i,!0),a&&(l[n]=l[n]||[],l[n].push(a[0]),a[1]===h[i+1]&&i!==r-2||(l[n].push(a[1]),n++))}},_simplifyPoints:function(){for(var t=this._parts,e=this.options.smoothFactor,i=0,n=t.length;i<n;i++)t[i]=o.LineUtil.simplify(t[i],e)},_update:function(){this._map&&(this._clipPoints(),this._simplifyPoints(),this._updatePath())},_updatePath:function(){this._renderer._updatePoly(this)}}),o.polyline=function(t,e){return new o.Polyline(t,e)},o.Polyline._flat=function(t){return!o.Util.isArray(t[0])||"object"!=typeof t[0][0]&&"undefined"!=typeof t[0][0]},o.PolyUtil={},o.PolyUtil.clipPolygon=function(t,e,i){var n,s,r,a,h,l,u,c,d,_=[1,4,2,8],m=o.LineUtil;for(s=0,u=t.length;s<u;s++)t[s]._code=m._getBitCode(t[s],e);for(a=0;a<4;a++){for(c=_[a],n=[],s=0,u=t.length,r=u-1;s<u;r=s++)h=t[s],l=t[r],h._code&c?l._code&c||(d=m._getEdgeIntersection(l,h,c,e,i),d._code=m._getBitCode(d,e),n.push(d)):(l._code&c&&(d=m._getEdgeIntersection(l,h,c,e,i),d._code=m._getBitCode(d,e),n.push(d)),n.push(h));t=n}return t},o.Polygon=o.Polyline.extend({options:{fill:!0},isEmpty:function(){return!this._latlngs.length||!this._latlngs[0].length},getCenter:function(){if(!this._map)throw new Error("Must add layer to map before using getCenter()");var t,e,i,n,o,s,r,a,h,l=this._rings[0],u=l.length;if(!u)return null;for(s=r=a=0,t=0,e=u-1;t<u;e=t++)i=l[t],n=l[e],o=i.y*n.x-n.y*i.x,r+=(i.x+n.x)*o,a+=(i.y+n.y)*o,s+=3*o;return h=0===s?l[0]:[r/s,a/s],this._map.layerPointToLatLng(h)},_convertLatLngs:function(t){var e=o.Polyline.prototype._convertLatLngs.call(this,t),i=e.length;return i>=2&&e[0]instanceof o.LatLng&&e[0].equals(e[i-1])&&e.pop(),e},_setLatLngs:function(t){o.Polyline.prototype._setLatLngs.call(this,t),o.Polyline._flat(this._latlngs)&&(this._latlngs=[this._latlngs])},_defaultShape:function(){return o.Polyline._flat(this._latlngs[0])?this._latlngs[0]:this._latlngs[0][0]},_clipPoints:function(){var t=this._renderer._bounds,e=this.options.weight,i=new o.Point(e,e);if(t=new o.Bounds(t.min.subtract(i),t.max.add(i)),this._parts=[],this._pxBounds&&this._pxBounds.intersects(t)){if(this.options.noClip)return void(this._parts=this._rings);for(var n,s=0,r=this._rings.length;s<r;s++)n=o.PolyUtil.clipPolygon(this._rings[s],t,!0),n.length&&this._parts.push(n)}},_updatePath:function(){this._renderer._updatePoly(this,!0)}}),o.polygon=function(t,e){return new o.Polygon(t,e)},o.Rectangle=o.Polygon.extend({initialize:function(t,e){o.Polygon.prototype.initialize.call(this,this._boundsToLatLngs(t),e)},setBounds:function(t){return this.setLatLngs(this._boundsToLatLngs(t))},_boundsToLatLngs:function(t){return t=o.latLngBounds(t),[t.getSouthWest(),t.getNorthWest(),t.getNorthEast(),t.getSouthEast()]}}),o.rectangle=function(t,e){return new o.Rectangle(t,e)},o.CircleMarker=o.Path.extend({options:{fill:!0,radius:10},initialize:function(t,e){o.setOptions(this,e),this._latlng=o.latLng(t),this._radius=this.options.radius},setLatLng:function(t){return this._latlng=o.latLng(t),this.redraw(),this.fire("move",{latlng:this._latlng})},getLatLng:function(){return this._latlng},setRadius:function(t){return this.options.radius=this._radius=t,this.redraw()},getRadius:function(){return this._radius},setStyle:function(t){var e=t&&t.radius||this._radius;return o.Path.prototype.setStyle.call(this,t),this.setRadius(e),this},_project:function(){this._point=this._map.latLngToLayerPoint(this._latlng),this._updateBounds()},_updateBounds:function(){var t=this._radius,e=this._radiusY||t,i=this._clickTolerance(),n=[t+i,e+i];this._pxBounds=new o.Bounds(this._point.subtract(n),this._point.add(n))},_update:function(){this._map&&this._updatePath()},_updatePath:function(){this._renderer._updateCircle(this)},_empty:function(){return this._radius&&!this._renderer._bounds.intersects(this._pxBounds)}}),o.circleMarker=function(t,e){return new o.CircleMarker(t,e)},o.Circle=o.CircleMarker.extend({initialize:function(t,e,i){if("number"==typeof e&&(e=o.extend({},i,{radius:e})),o.setOptions(this,e),this._latlng=o.latLng(t),isNaN(this.options.radius))throw new Error("Circle radius cannot be NaN");this._mRadius=this.options.radius},setRadius:function(t){return this._mRadius=t,this.redraw()},getRadius:function(){return this._mRadius},getBounds:function(){var t=[this._radius,this._radiusY||this._radius];return new o.LatLngBounds(this._map.layerPointToLatLng(this._point.subtract(t)),this._map.layerPointToLatLng(this._point.add(t)));
|
|
},setStyle:o.Path.prototype.setStyle,_project:function(){var t=this._latlng.lng,e=this._latlng.lat,i=this._map,n=i.options.crs;if(n.distance===o.CRS.Earth.distance){var s=Math.PI/180,r=this._mRadius/o.CRS.Earth.R/s,a=i.project([e+r,t]),h=i.project([e-r,t]),l=a.add(h).divideBy(2),u=i.unproject(l).lat,c=Math.acos((Math.cos(r*s)-Math.sin(e*s)*Math.sin(u*s))/(Math.cos(e*s)*Math.cos(u*s)))/s;(isNaN(c)||0===c)&&(c=r/Math.cos(Math.PI/180*e)),this._point=l.subtract(i.getPixelOrigin()),this._radius=isNaN(c)?0:Math.max(Math.round(l.x-i.project([u,t-c]).x),1),this._radiusY=Math.max(Math.round(l.y-a.y),1)}else{var d=n.unproject(n.project(this._latlng).subtract([this._mRadius,0]));this._point=i.latLngToLayerPoint(this._latlng),this._radius=this._point.x-i.latLngToLayerPoint(d).x}this._updateBounds()}}),o.circle=function(t,e,i){return new o.Circle(t,e,i)},o.SVG=o.Renderer.extend({getEvents:function(){var t=o.Renderer.prototype.getEvents.call(this);return t.zoomstart=this._onZoomStart,t},_initContainer:function(){this._container=o.SVG.create("svg"),this._container.setAttribute("pointer-events","none"),this._rootGroup=o.SVG.create("g"),this._container.appendChild(this._rootGroup)},_onZoomStart:function(){this._update()},_update:function(){if(!this._map._animatingZoom||!this._bounds){o.Renderer.prototype._update.call(this);var t=this._bounds,e=t.getSize(),i=this._container;this._svgSize&&this._svgSize.equals(e)||(this._svgSize=e,i.setAttribute("width",e.x),i.setAttribute("height",e.y)),o.DomUtil.setPosition(i,t.min),i.setAttribute("viewBox",[t.min.x,t.min.y,e.x,e.y].join(" ")),this.fire("update")}},_initPath:function(t){var e=t._path=o.SVG.create("path");t.options.className&&o.DomUtil.addClass(e,t.options.className),t.options.interactive&&o.DomUtil.addClass(e,"leaflet-interactive"),this._updateStyle(t),this._layers[o.stamp(t)]=t},_addPath:function(t){this._rootGroup.appendChild(t._path),t.addInteractiveTarget(t._path)},_removePath:function(t){o.DomUtil.remove(t._path),t.removeInteractiveTarget(t._path),delete this._layers[o.stamp(t)]},_updatePath:function(t){t._project(),t._update()},_updateStyle:function(t){var e=t._path,i=t.options;e&&(i.stroke?(e.setAttribute("stroke",i.color),e.setAttribute("stroke-opacity",i.opacity),e.setAttribute("stroke-width",i.weight),e.setAttribute("stroke-linecap",i.lineCap),e.setAttribute("stroke-linejoin",i.lineJoin),i.dashArray?e.setAttribute("stroke-dasharray",i.dashArray):e.removeAttribute("stroke-dasharray"),i.dashOffset?e.setAttribute("stroke-dashoffset",i.dashOffset):e.removeAttribute("stroke-dashoffset")):e.setAttribute("stroke","none"),i.fill?(e.setAttribute("fill",i.fillColor||i.color),e.setAttribute("fill-opacity",i.fillOpacity),e.setAttribute("fill-rule",i.fillRule||"evenodd")):e.setAttribute("fill","none"))},_updatePoly:function(t,e){this._setPath(t,o.SVG.pointsToPath(t._parts,e))},_updateCircle:function(t){var e=t._point,i=t._radius,n=t._radiusY||i,o="a"+i+","+n+" 0 1,0 ",s=t._empty()?"M0 0":"M"+(e.x-i)+","+e.y+o+2*i+",0 "+o+2*-i+",0 ";this._setPath(t,s)},_setPath:function(t,e){t._path.setAttribute("d",e)},_bringToFront:function(t){o.DomUtil.toFront(t._path)},_bringToBack:function(t){o.DomUtil.toBack(t._path)}}),o.extend(o.SVG,{create:function(t){return e.createElementNS("http://www.w3.org/2000/svg",t)},pointsToPath:function(t,e){var i,n,s,r,a,h,l="";for(i=0,s=t.length;i<s;i++){for(a=t[i],n=0,r=a.length;n<r;n++)h=a[n],l+=(n?"L":"M")+h.x+" "+h.y;l+=e?o.Browser.svg?"z":"x":""}return l||"M0 0"}}),o.Browser.svg=!(!e.createElementNS||!o.SVG.create("svg").createSVGRect),o.svg=function(t){return o.Browser.svg||o.Browser.vml?new o.SVG(t):null},o.Browser.vml=!o.Browser.svg&&function(){try{var t=e.createElement("div");t.innerHTML='<v:shape adj="1"/>';var i=t.firstChild;return i.style.behavior="url(#default#VML)",i&&"object"==typeof i.adj}catch(t){return!1}}(),o.SVG.include(o.Browser.vml?{_initContainer:function(){this._container=o.DomUtil.create("div","leaflet-vml-container")},_update:function(){this._map._animatingZoom||(o.Renderer.prototype._update.call(this),this.fire("update"))},_initPath:function(t){var e=t._container=o.SVG.create("shape");o.DomUtil.addClass(e,"leaflet-vml-shape "+(this.options.className||"")),e.coordsize="1 1",t._path=o.SVG.create("path"),e.appendChild(t._path),this._updateStyle(t),this._layers[o.stamp(t)]=t},_addPath:function(t){var e=t._container;this._container.appendChild(e),t.options.interactive&&t.addInteractiveTarget(e)},_removePath:function(t){var e=t._container;o.DomUtil.remove(e),t.removeInteractiveTarget(e),delete this._layers[o.stamp(t)]},_updateStyle:function(t){var e=t._stroke,i=t._fill,n=t.options,s=t._container;s.stroked=!!n.stroke,s.filled=!!n.fill,n.stroke?(e||(e=t._stroke=o.SVG.create("stroke")),s.appendChild(e),e.weight=n.weight+"px",e.color=n.color,e.opacity=n.opacity,n.dashArray?e.dashStyle=o.Util.isArray(n.dashArray)?n.dashArray.join(" "):n.dashArray.replace(/( *, *)/g," "):e.dashStyle="",e.endcap=n.lineCap.replace("butt","flat"),e.joinstyle=n.lineJoin):e&&(s.removeChild(e),t._stroke=null),n.fill?(i||(i=t._fill=o.SVG.create("fill")),s.appendChild(i),i.color=n.fillColor||n.color,i.opacity=n.fillOpacity):i&&(s.removeChild(i),t._fill=null)},_updateCircle:function(t){var e=t._point.round(),i=Math.round(t._radius),n=Math.round(t._radiusY||i);this._setPath(t,t._empty()?"M0 0":"AL "+e.x+","+e.y+" "+i+","+n+" 0,23592600")},_setPath:function(t,e){t._path.v=e},_bringToFront:function(t){o.DomUtil.toFront(t._container)},_bringToBack:function(t){o.DomUtil.toBack(t._container)}}:{}),o.Browser.vml&&(o.SVG.create=function(){try{return e.namespaces.add("lvml","urn:schemas-microsoft-com:vml"),function(t){return e.createElement("<lvml:"+t+' class="lvml">')}}catch(t){return function(t){return e.createElement("<"+t+' xmlns="urn:schemas-microsoft.com:vml" class="lvml">')}}}()),o.Canvas=o.Renderer.extend({getEvents:function(){var t=o.Renderer.prototype.getEvents.call(this);return t.viewprereset=this._onViewPreReset,t},_onViewPreReset:function(){this._postponeUpdatePaths=!0},onAdd:function(){o.Renderer.prototype.onAdd.call(this),this._draw()},_initContainer:function(){var t=this._container=e.createElement("canvas");o.DomEvent.on(t,"mousemove",o.Util.throttle(this._onMouseMove,32,this),this).on(t,"click dblclick mousedown mouseup contextmenu",this._onClick,this).on(t,"mouseout",this._handleMouseOut,this),this._ctx=t.getContext("2d")},_updatePaths:function(){if(!this._postponeUpdatePaths){var t;this._redrawBounds=null;for(var e in this._layers)t=this._layers[e],t._update();this._redraw()}},_update:function(){if(!this._map._animatingZoom||!this._bounds){this._drawnLayers={},o.Renderer.prototype._update.call(this);var t=this._bounds,e=this._container,i=t.getSize(),n=o.Browser.retina?2:1;o.DomUtil.setPosition(e,t.min),e.width=n*i.x,e.height=n*i.y,e.style.width=i.x+"px",e.style.height=i.y+"px",o.Browser.retina&&this._ctx.scale(2,2),this._ctx.translate(-t.min.x,-t.min.y),this.fire("update")}},_reset:function(){o.Renderer.prototype._reset.call(this),this._postponeUpdatePaths&&(this._postponeUpdatePaths=!1,this._updatePaths())},_initPath:function(t){this._updateDashArray(t),this._layers[o.stamp(t)]=t;var e=t._order={layer:t,prev:this._drawLast,next:null};this._drawLast&&(this._drawLast.next=e),this._drawLast=e,this._drawFirst=this._drawFirst||this._drawLast},_addPath:function(t){this._requestRedraw(t)},_removePath:function(t){var e=t._order,i=e.next,n=e.prev;i?i.prev=n:this._drawLast=n,n?n.next=i:this._drawFirst=i,delete t._order,delete this._layers[o.stamp(t)],this._requestRedraw(t)},_updatePath:function(t){this._extendRedrawBounds(t),t._project(),t._update(),this._requestRedraw(t)},_updateStyle:function(t){this._updateDashArray(t),this._requestRedraw(t)},_updateDashArray:function(t){if(t.options.dashArray){var e,i=t.options.dashArray.split(","),n=[];for(e=0;e<i.length;e++)n.push(Number(i[e]));t.options._dashArray=n}},_requestRedraw:function(t){this._map&&(this._extendRedrawBounds(t),this._redrawRequest=this._redrawRequest||o.Util.requestAnimFrame(this._redraw,this))},_extendRedrawBounds:function(t){var e=(t.options.weight||0)+1;this._redrawBounds=this._redrawBounds||new o.Bounds,this._redrawBounds.extend(t._pxBounds.min.subtract([e,e])),this._redrawBounds.extend(t._pxBounds.max.add([e,e]))},_redraw:function(){this._redrawRequest=null,this._redrawBounds&&(this._redrawBounds.min._floor(),this._redrawBounds.max._ceil()),this._clear(),this._draw(),this._redrawBounds=null},_clear:function(){var t=this._redrawBounds;if(t){var e=t.getSize();this._ctx.clearRect(t.min.x,t.min.y,e.x,e.y)}else this._ctx.clearRect(0,0,this._container.width,this._container.height)},_draw:function(){var t,e=this._redrawBounds;if(this._ctx.save(),e){var i=e.getSize();this._ctx.beginPath(),this._ctx.rect(e.min.x,e.min.y,i.x,i.y),this._ctx.clip()}this._drawing=!0;for(var n=this._drawFirst;n;n=n.next)t=n.layer,(!e||t._pxBounds&&t._pxBounds.intersects(e))&&t._updatePath();this._drawing=!1,this._ctx.restore()},_updatePoly:function(t,e){if(this._drawing){var i,n,o,s,r=t._parts,a=r.length,h=this._ctx;if(a){for(this._drawnLayers[t._leaflet_id]=t,h.beginPath(),h.setLineDash&&h.setLineDash(t.options&&t.options._dashArray||[]),i=0;i<a;i++){for(n=0,o=r[i].length;n<o;n++)s=r[i][n],h[n?"lineTo":"moveTo"](s.x,s.y);e&&h.closePath()}this._fillStroke(h,t)}}},_updateCircle:function(t){if(this._drawing&&!t._empty()){var e=t._point,i=this._ctx,n=t._radius,o=(t._radiusY||n)/n;this._drawnLayers[t._leaflet_id]=t,1!==o&&(i.save(),i.scale(1,o)),i.beginPath(),i.arc(e.x,e.y/o,n,0,2*Math.PI,!1),1!==o&&i.restore(),this._fillStroke(i,t)}},_fillStroke:function(t,e){var i=e.options;i.fill&&(t.globalAlpha=i.fillOpacity,t.fillStyle=i.fillColor||i.color,t.fill(i.fillRule||"evenodd")),i.stroke&&0!==i.weight&&(t.globalAlpha=i.opacity,t.lineWidth=i.weight,t.strokeStyle=i.color,t.lineCap=i.lineCap,t.lineJoin=i.lineJoin,t.stroke())},_onClick:function(t){for(var e,i,n=this._map.mouseEventToLayerPoint(t),s=this._drawFirst;s;s=s.next)e=s.layer,e.options.interactive&&e._containsPoint(n)&&!this._map._draggableMoved(e)&&(i=e);i&&(o.DomEvent._fakeStop(t),this._fireEvent([i],t))},_onMouseMove:function(t){if(this._map&&!this._map.dragging.moving()&&!this._map._animatingZoom){var e=this._map.mouseEventToLayerPoint(t);this._handleMouseHover(t,e)}},_handleMouseOut:function(t){var e=this._hoveredLayer;e&&(o.DomUtil.removeClass(this._container,"leaflet-interactive"),this._fireEvent([e],t,"mouseout"),this._hoveredLayer=null)},_handleMouseHover:function(t,e){for(var i,n,s=this._drawFirst;s;s=s.next)i=s.layer,i.options.interactive&&i._containsPoint(e)&&(n=i);n!==this._hoveredLayer&&(this._handleMouseOut(t),n&&(o.DomUtil.addClass(this._container,"leaflet-interactive"),this._fireEvent([n],t,"mouseover"),this._hoveredLayer=n)),this._hoveredLayer&&this._fireEvent([this._hoveredLayer],t)},_fireEvent:function(t,e,i){this._map._fireDOMEvent(e,i||e.type,t)},_bringToFront:function(t){var e=t._order,i=e.next,n=e.prev;i&&(i.prev=n,n?n.next=i:i&&(this._drawFirst=i),e.prev=this._drawLast,this._drawLast.next=e,e.next=null,this._drawLast=e,this._requestRedraw(t))},_bringToBack:function(t){var e=t._order,i=e.next,n=e.prev;n&&(n.next=i,i?i.prev=n:n&&(this._drawLast=n),e.prev=null,e.next=this._drawFirst,this._drawFirst.prev=e,this._drawFirst=e,this._requestRedraw(t))}}),o.Browser.canvas=function(){return!!e.createElement("canvas").getContext}(),o.canvas=function(t){return o.Browser.canvas?new o.Canvas(t):null},o.Polyline.prototype._containsPoint=function(t,e){var i,n,s,r,a,h,l=this._clickTolerance();if(!this._pxBounds.contains(t))return!1;for(i=0,r=this._parts.length;i<r;i++)for(h=this._parts[i],n=0,a=h.length,s=a-1;n<a;s=n++)if((e||0!==n)&&o.LineUtil.pointToSegmentDistance(t,h[s],h[n])<=l)return!0;return!1},o.Polygon.prototype._containsPoint=function(t){var e,i,n,s,r,a,h,l,u=!1;if(!this._pxBounds.contains(t))return!1;for(s=0,h=this._parts.length;s<h;s++)for(e=this._parts[s],r=0,l=e.length,a=l-1;r<l;a=r++)i=e[r],n=e[a],i.y>t.y!=n.y>t.y&&t.x<(n.x-i.x)*(t.y-i.y)/(n.y-i.y)+i.x&&(u=!u);return u||o.Polyline.prototype._containsPoint.call(this,t,!0)},o.CircleMarker.prototype._containsPoint=function(t){return t.distanceTo(this._point)<=this._radius+this._clickTolerance()},o.GeoJSON=o.FeatureGroup.extend({initialize:function(t,e){o.setOptions(this,e),this._layers={},t&&this.addData(t)},addData:function(t){var e,i,n,s=o.Util.isArray(t)?t:t.features;if(s){for(e=0,i=s.length;e<i;e++)n=s[e],(n.geometries||n.geometry||n.features||n.coordinates)&&this.addData(n);return this}var r=this.options;if(r.filter&&!r.filter(t))return this;var a=o.GeoJSON.geometryToLayer(t,r);return a?(a.feature=o.GeoJSON.asFeature(t),a.defaultOptions=a.options,this.resetStyle(a),r.onEachFeature&&r.onEachFeature(t,a),this.addLayer(a)):this},resetStyle:function(t){return t.options=o.Util.extend({},t.defaultOptions),this._setLayerStyle(t,this.options.style),this},setStyle:function(t){return this.eachLayer(function(e){this._setLayerStyle(e,t)},this)},_setLayerStyle:function(t,e){"function"==typeof e&&(e=e(t.feature)),t.setStyle&&t.setStyle(e)}}),o.extend(o.GeoJSON,{geometryToLayer:function(t,e){var i,n,s,r,a="Feature"===t.type?t.geometry:t,h=a?a.coordinates:null,l=[],u=e&&e.pointToLayer,c=e&&e.coordsToLatLng||this.coordsToLatLng;if(!h&&!a)return null;switch(a.type){case"Point":return i=c(h),u?u(t,i):new o.Marker(i);case"MultiPoint":for(s=0,r=h.length;s<r;s++)i=c(h[s]),l.push(u?u(t,i):new o.Marker(i));return new o.FeatureGroup(l);case"LineString":case"MultiLineString":return n=this.coordsToLatLngs(h,"LineString"===a.type?0:1,c),new o.Polyline(n,e);case"Polygon":case"MultiPolygon":return n=this.coordsToLatLngs(h,"Polygon"===a.type?1:2,c),new o.Polygon(n,e);case"GeometryCollection":for(s=0,r=a.geometries.length;s<r;s++){var d=this.geometryToLayer({geometry:a.geometries[s],type:"Feature",properties:t.properties},e);d&&l.push(d)}return new o.FeatureGroup(l);default:throw new Error("Invalid GeoJSON object.")}},coordsToLatLng:function(t){return new o.LatLng(t[1],t[0],t[2])},coordsToLatLngs:function(t,e,i){for(var n,o=[],s=0,r=t.length;s<r;s++)n=e?this.coordsToLatLngs(t[s],e-1,i):(i||this.coordsToLatLng)(t[s]),o.push(n);return o},latLngToCoords:function(t){return t.alt!==i?[t.lng,t.lat,t.alt]:[t.lng,t.lat]},latLngsToCoords:function(t,e,i){for(var n=[],s=0,r=t.length;s<r;s++)n.push(e?o.GeoJSON.latLngsToCoords(t[s],e-1,i):o.GeoJSON.latLngToCoords(t[s]));return!e&&i&&n.push(n[0]),n},getFeature:function(t,e){return t.feature?o.extend({},t.feature,{geometry:e}):o.GeoJSON.asFeature(e)},asFeature:function(t){return"Feature"===t.type||"FeatureCollection"===t.type?t:{type:"Feature",properties:{},geometry:t}}});var a={toGeoJSON:function(){return o.GeoJSON.getFeature(this,{type:"Point",coordinates:o.GeoJSON.latLngToCoords(this.getLatLng())})}};o.Marker.include(a),o.Circle.include(a),o.CircleMarker.include(a),o.Polyline.prototype.toGeoJSON=function(){var t=!o.Polyline._flat(this._latlngs),e=o.GeoJSON.latLngsToCoords(this._latlngs,t?1:0);return o.GeoJSON.getFeature(this,{type:(t?"Multi":"")+"LineString",coordinates:e})},o.Polygon.prototype.toGeoJSON=function(){var t=!o.Polyline._flat(this._latlngs),e=t&&!o.Polyline._flat(this._latlngs[0]),i=o.GeoJSON.latLngsToCoords(this._latlngs,e?2:t?1:0,!0);return t||(i=[i]),o.GeoJSON.getFeature(this,{type:(e?"Multi":"")+"Polygon",coordinates:i})},o.LayerGroup.include({toMultiPoint:function(){var t=[];return this.eachLayer(function(e){t.push(e.toGeoJSON().geometry.coordinates)}),o.GeoJSON.getFeature(this,{type:"MultiPoint",coordinates:t})},toGeoJSON:function(){var t=this.feature&&this.feature.geometry&&this.feature.geometry.type;if("MultiPoint"===t)return this.toMultiPoint();var e="GeometryCollection"===t,i=[];return this.eachLayer(function(t){if(t.toGeoJSON){var n=t.toGeoJSON();i.push(e?n.geometry:o.GeoJSON.asFeature(n))}}),e?o.GeoJSON.getFeature(this,{geometries:i,type:"GeometryCollection"}):{type:"FeatureCollection",features:i}}}),o.geoJSON=function(t,e){return new o.GeoJSON(t,e)},o.geoJson=o.geoJSON,o.Draggable=o.Evented.extend({options:{clickTolerance:3},statics:{START:o.Browser.touch?["touchstart","mousedown"]:["mousedown"],END:{mousedown:"mouseup",touchstart:"touchend",pointerdown:"touchend",MSPointerDown:"touchend"},MOVE:{mousedown:"mousemove",touchstart:"touchmove",pointerdown:"touchmove",MSPointerDown:"touchmove"}},initialize:function(t,e,i){this._element=t,this._dragStartTarget=e||t,this._preventOutline=i},enable:function(){this._enabled||(o.DomEvent.on(this._dragStartTarget,o.Draggable.START.join(" "),this._onDown,this),this._enabled=!0)},disable:function(){this._enabled&&(o.Draggable._dragging===this&&this.finishDrag(),o.DomEvent.off(this._dragStartTarget,o.Draggable.START.join(" "),this._onDown,this),this._enabled=!1,this._moved=!1)},_onDown:function(t){if(!t._simulated&&this._enabled&&(this._moved=!1,!o.DomUtil.hasClass(this._element,"leaflet-zoom-anim")&&!(o.Draggable._dragging||t.shiftKey||1!==t.which&&1!==t.button&&!t.touches||(o.Draggable._dragging=this,this._preventOutline&&o.DomUtil.preventOutline(this._element),o.DomUtil.disableImageDrag(),o.DomUtil.disableTextSelection(),this._moving)))){this.fire("down");var i=t.touches?t.touches[0]:t;this._startPoint=new o.Point(i.clientX,i.clientY),o.DomEvent.on(e,o.Draggable.MOVE[t.type],this._onMove,this).on(e,o.Draggable.END[t.type],this._onUp,this)}},_onMove:function(i){if(!i._simulated&&this._enabled){if(i.touches&&i.touches.length>1)return void(this._moved=!0);var n=i.touches&&1===i.touches.length?i.touches[0]:i,s=new o.Point(n.clientX,n.clientY),r=s.subtract(this._startPoint);(r.x||r.y)&&(Math.abs(r.x)+Math.abs(r.y)<this.options.clickTolerance||(o.DomEvent.preventDefault(i),this._moved||(this.fire("dragstart"),this._moved=!0,this._startPos=o.DomUtil.getPosition(this._element).subtract(r),o.DomUtil.addClass(e.body,"leaflet-dragging"),this._lastTarget=i.target||i.srcElement,t.SVGElementInstance&&this._lastTarget instanceof SVGElementInstance&&(this._lastTarget=this._lastTarget.correspondingUseElement),o.DomUtil.addClass(this._lastTarget,"leaflet-drag-target")),this._newPos=this._startPos.add(r),this._moving=!0,o.Util.cancelAnimFrame(this._animRequest),this._lastEvent=i,this._animRequest=o.Util.requestAnimFrame(this._updatePosition,this,!0)))}},_updatePosition:function(){var t={originalEvent:this._lastEvent};this.fire("predrag",t),o.DomUtil.setPosition(this._element,this._newPos),this.fire("drag",t)},_onUp:function(t){!t._simulated&&this._enabled&&this.finishDrag()},finishDrag:function(){o.DomUtil.removeClass(e.body,"leaflet-dragging"),this._lastTarget&&(o.DomUtil.removeClass(this._lastTarget,"leaflet-drag-target"),this._lastTarget=null);for(var t in o.Draggable.MOVE)o.DomEvent.off(e,o.Draggable.MOVE[t],this._onMove,this).off(e,o.Draggable.END[t],this._onUp,this);o.DomUtil.enableImageDrag(),o.DomUtil.enableTextSelection(),this._moved&&this._moving&&(o.Util.cancelAnimFrame(this._animRequest),this.fire("dragend",{distance:this._newPos.distanceTo(this._startPos)})),this._moving=!1,o.Draggable._dragging=!1}}),o.Handler=o.Class.extend({initialize:function(t){this._map=t},enable:function(){return this._enabled?this:(this._enabled=!0,this.addHooks(),this)},disable:function(){return this._enabled?(this._enabled=!1,this.removeHooks(),this):this},enabled:function(){return!!this._enabled}}),o.Map.mergeOptions({dragging:!0,inertia:!o.Browser.android23,inertiaDeceleration:3400,inertiaMaxSpeed:1/0,easeLinearity:.2,worldCopyJump:!1,maxBoundsViscosity:0}),o.Map.Drag=o.Handler.extend({addHooks:function(){if(!this._draggable){var t=this._map;this._draggable=new o.Draggable(t._mapPane,t._container),this._draggable.on({down:this._onDown,dragstart:this._onDragStart,drag:this._onDrag,dragend:this._onDragEnd},this),this._draggable.on("predrag",this._onPreDragLimit,this),t.options.worldCopyJump&&(this._draggable.on("predrag",this._onPreDragWrap,this),t.on("zoomend",this._onZoomEnd,this),t.whenReady(this._onZoomEnd,this))}o.DomUtil.addClass(this._map._container,"leaflet-grab leaflet-touch-drag"),this._draggable.enable(),this._positions=[],this._times=[]},removeHooks:function(){o.DomUtil.removeClass(this._map._container,"leaflet-grab"),o.DomUtil.removeClass(this._map._container,"leaflet-touch-drag"),this._draggable.disable()},moved:function(){return this._draggable&&this._draggable._moved},moving:function(){return this._draggable&&this._draggable._moving},_onDown:function(){this._map._stop()},_onDragStart:function(){var t=this._map;if(this._map.options.maxBounds&&this._map.options.maxBoundsViscosity){var e=o.latLngBounds(this._map.options.maxBounds);this._offsetLimit=o.bounds(this._map.latLngToContainerPoint(e.getNorthWest()).multiplyBy(-1),this._map.latLngToContainerPoint(e.getSouthEast()).multiplyBy(-1).add(this._map.getSize())),this._viscosity=Math.min(1,Math.max(0,this._map.options.maxBoundsViscosity))}else this._offsetLimit=null;t.fire("movestart").fire("dragstart"),t.options.inertia&&(this._positions=[],this._times=[])},_onDrag:function(t){if(this._map.options.inertia){var e=this._lastTime=+new Date,i=this._lastPos=this._draggable._absPos||this._draggable._newPos;this._positions.push(i),this._times.push(e),e-this._times[0]>50&&(this._positions.shift(),this._times.shift())}this._map.fire("move",t).fire("drag",t)},_onZoomEnd:function(){var t=this._map.getSize().divideBy(2),e=this._map.latLngToLayerPoint([0,0]);this._initialWorldOffset=e.subtract(t).x,this._worldWidth=this._map.getPixelWorldBounds().getSize().x},_viscousLimit:function(t,e){return t-(t-e)*this._viscosity},_onPreDragLimit:function(){if(this._viscosity&&this._offsetLimit){var t=this._draggable._newPos.subtract(this._draggable._startPos),e=this._offsetLimit;t.x<e.min.x&&(t.x=this._viscousLimit(t.x,e.min.x)),t.y<e.min.y&&(t.y=this._viscousLimit(t.y,e.min.y)),t.x>e.max.x&&(t.x=this._viscousLimit(t.x,e.max.x)),t.y>e.max.y&&(t.y=this._viscousLimit(t.y,e.max.y)),this._draggable._newPos=this._draggable._startPos.add(t)}},_onPreDragWrap:function(){var t=this._worldWidth,e=Math.round(t/2),i=this._initialWorldOffset,n=this._draggable._newPos.x,o=(n-e+i)%t+e-i,s=(n+e+i)%t-e-i,r=Math.abs(o+i)<Math.abs(s+i)?o:s;this._draggable._absPos=this._draggable._newPos.clone(),this._draggable._newPos.x=r},_onDragEnd:function(t){var e=this._map,i=e.options,n=!i.inertia||this._times.length<2;if(e.fire("dragend",t),n)e.fire("moveend");else{var s=this._lastPos.subtract(this._positions[0]),r=(this._lastTime-this._times[0])/1e3,a=i.easeLinearity,h=s.multiplyBy(a/r),l=h.distanceTo([0,0]),u=Math.min(i.inertiaMaxSpeed,l),c=h.multiplyBy(u/l),d=u/(i.inertiaDeceleration*a),_=c.multiplyBy(-d/2).round();_.x||_.y?(_=e._limitOffset(_,e.options.maxBounds),o.Util.requestAnimFrame(function(){e.panBy(_,{duration:d,easeLinearity:a,noMoveStart:!0,animate:!0})})):e.fire("moveend")}}}),o.Map.addInitHook("addHandler","dragging",o.Map.Drag),o.Map.mergeOptions({doubleClickZoom:!0}),o.Map.DoubleClickZoom=o.Handler.extend({addHooks:function(){this._map.on("dblclick",this._onDoubleClick,this)},removeHooks:function(){this._map.off("dblclick",this._onDoubleClick,this)},_onDoubleClick:function(t){var e=this._map,i=e.getZoom(),n=e.options.zoomDelta,o=t.originalEvent.shiftKey?i-n:i+n;"center"===e.options.doubleClickZoom?e.setZoom(o):e.setZoomAround(t.containerPoint,o)}}),o.Map.addInitHook("addHandler","doubleClickZoom",o.Map.DoubleClickZoom),o.Map.mergeOptions({scrollWheelZoom:!0,wheelDebounceTime:40,wheelPxPerZoomLevel:60}),o.Map.ScrollWheelZoom=o.Handler.extend({addHooks:function(){o.DomEvent.on(this._map._container,"mousewheel",this._onWheelScroll,this),this._delta=0},removeHooks:function(){o.DomEvent.off(this._map._container,"mousewheel",this._onWheelScroll,this)},_onWheelScroll:function(t){var e=o.DomEvent.getWheelDelta(t),i=this._map.options.wheelDebounceTime;this._delta+=e,this._lastMousePos=this._map.mouseEventToContainerPoint(t),this._startTime||(this._startTime=+new Date);var n=Math.max(i-(+new Date-this._startTime),0);clearTimeout(this._timer),this._timer=setTimeout(o.bind(this._performZoom,this),n),o.DomEvent.stop(t)},_performZoom:function(){var t=this._map,e=t.getZoom(),i=this._map.options.zoomSnap||0;t._stop();var n=this._delta/(4*this._map.options.wheelPxPerZoomLevel),o=4*Math.log(2/(1+Math.exp(-Math.abs(n))))/Math.LN2,s=i?Math.ceil(o/i)*i:o,r=t._limitZoom(e+(this._delta>0?s:-s))-e;this._delta=0,this._startTime=null,r&&("center"===t.options.scrollWheelZoom?t.setZoom(e+r):t.setZoomAround(this._lastMousePos,e+r))}}),o.Map.addInitHook("addHandler","scrollWheelZoom",o.Map.ScrollWheelZoom),o.extend(o.DomEvent,{_touchstart:o.Browser.msPointer?"MSPointerDown":o.Browser.pointer?"pointerdown":"touchstart",_touchend:o.Browser.msPointer?"MSPointerUp":o.Browser.pointer?"pointerup":"touchend",addDoubleTapListener:function(t,e,i){function n(t){var e;if(o.Browser.pointer){if(!o.Browser.edge||"mouse"===t.pointerType)return;e=o.DomEvent._pointersCount}else e=t.touches.length;if(!(e>1)){var i=Date.now(),n=i-(r||i);a=t.touches?t.touches[0]:t,h=n>0&&n<=l,r=i}}function s(t){if(h&&!a.cancelBubble){if(o.Browser.pointer){if(!o.Browser.edge||"mouse"===t.pointerType)return;var i,n,s={};for(n in a)i=a[n],s[n]=i&&i.bind?i.bind(a):i;a=s}a.type="dblclick",e(a),r=null}}var r,a,h=!1,l=250,u="_leaflet_",c=this._touchstart,d=this._touchend;return t[u+c+i]=n,t[u+d+i]=s,t[u+"dblclick"+i]=e,t.addEventListener(c,n,!1),t.addEventListener(d,s,!1),t.addEventListener("dblclick",e,!1),this},removeDoubleTapListener:function(t,e){var i="_leaflet_",n=t[i+this._touchstart+e],s=t[i+this._touchend+e],r=t[i+"dblclick"+e];return t.removeEventListener(this._touchstart,n,!1),t.removeEventListener(this._touchend,s,!1),o.Browser.edge||t.removeEventListener("dblclick",r,!1),this}}),o.extend(o.DomEvent,{POINTER_DOWN:o.Browser.msPointer?"MSPointerDown":"pointerdown",POINTER_MOVE:o.Browser.msPointer?"MSPointerMove":"pointermove",POINTER_UP:o.Browser.msPointer?"MSPointerUp":"pointerup",POINTER_CANCEL:o.Browser.msPointer?"MSPointerCancel":"pointercancel",TAG_WHITE_LIST:["INPUT","SELECT","OPTION"],_pointers:{},_pointersCount:0,addPointerListener:function(t,e,i,n){return"touchstart"===e?this._addPointerStart(t,i,n):"touchmove"===e?this._addPointerMove(t,i,n):"touchend"===e&&this._addPointerEnd(t,i,n),this},removePointerListener:function(t,e,i){var n=t["_leaflet_"+e+i];return"touchstart"===e?t.removeEventListener(this.POINTER_DOWN,n,!1):"touchmove"===e?t.removeEventListener(this.POINTER_MOVE,n,!1):"touchend"===e&&(t.removeEventListener(this.POINTER_UP,n,!1),t.removeEventListener(this.POINTER_CANCEL,n,!1)),this},_addPointerStart:function(t,i,n){var s=o.bind(function(t){if("mouse"!==t.pointerType&&t.MSPOINTER_TYPE_MOUSE&&t.pointerType!==t.MSPOINTER_TYPE_MOUSE){if(!(this.TAG_WHITE_LIST.indexOf(t.target.tagName)<0))return;o.DomEvent.preventDefault(t)}this._handlePointer(t,i)},this);if(t["_leaflet_touchstart"+n]=s,t.addEventListener(this.POINTER_DOWN,s,!1),!this._pointerDocListener){var r=o.bind(this._globalPointerUp,this);e.documentElement.addEventListener(this.POINTER_DOWN,o.bind(this._globalPointerDown,this),!0),e.documentElement.addEventListener(this.POINTER_MOVE,o.bind(this._globalPointerMove,this),!0),e.documentElement.addEventListener(this.POINTER_UP,r,!0),e.documentElement.addEventListener(this.POINTER_CANCEL,r,!0),this._pointerDocListener=!0}},_globalPointerDown:function(t){this._pointers[t.pointerId]=t,this._pointersCount++},_globalPointerMove:function(t){this._pointers[t.pointerId]&&(this._pointers[t.pointerId]=t)},_globalPointerUp:function(t){delete this._pointers[t.pointerId],this._pointersCount--},_handlePointer:function(t,e){t.touches=[];for(var i in this._pointers)t.touches.push(this._pointers[i]);t.changedTouches=[t],e(t)},_addPointerMove:function(t,e,i){var n=o.bind(function(t){(t.pointerType!==t.MSPOINTER_TYPE_MOUSE&&"mouse"!==t.pointerType||0!==t.buttons)&&this._handlePointer(t,e)},this);t["_leaflet_touchmove"+i]=n,t.addEventListener(this.POINTER_MOVE,n,!1)},_addPointerEnd:function(t,e,i){var n=o.bind(function(t){this._handlePointer(t,e)},this);t["_leaflet_touchend"+i]=n,t.addEventListener(this.POINTER_UP,n,!1),t.addEventListener(this.POINTER_CANCEL,n,!1)}}),o.Map.mergeOptions({touchZoom:o.Browser.touch&&!o.Browser.android23,bounceAtZoomLimits:!0}),o.Map.TouchZoom=o.Handler.extend({addHooks:function(){o.DomUtil.addClass(this._map._container,"leaflet-touch-zoom"),o.DomEvent.on(this._map._container,"touchstart",this._onTouchStart,this)},removeHooks:function(){o.DomUtil.removeClass(this._map._container,"leaflet-touch-zoom"),o.DomEvent.off(this._map._container,"touchstart",this._onTouchStart,this)},_onTouchStart:function(t){var i=this._map;if(t.touches&&2===t.touches.length&&!i._animatingZoom&&!this._zooming){var n=i.mouseEventToContainerPoint(t.touches[0]),s=i.mouseEventToContainerPoint(t.touches[1]);this._centerPoint=i.getSize()._divideBy(2),this._startLatLng=i.containerPointToLatLng(this._centerPoint),"center"!==i.options.touchZoom&&(this._pinchStartLatLng=i.containerPointToLatLng(n.add(s)._divideBy(2))),this._startDist=n.distanceTo(s),this._startZoom=i.getZoom(),this._moved=!1,this._zooming=!0,i._stop(),o.DomEvent.on(e,"touchmove",this._onTouchMove,this).on(e,"touchend",this._onTouchEnd,this),o.DomEvent.preventDefault(t)}},_onTouchMove:function(t){if(t.touches&&2===t.touches.length&&this._zooming){var e=this._map,i=e.mouseEventToContainerPoint(t.touches[0]),n=e.mouseEventToContainerPoint(t.touches[1]),s=i.distanceTo(n)/this._startDist;if(this._zoom=e.getScaleZoom(s,this._startZoom),!e.options.bounceAtZoomLimits&&(this._zoom<e.getMinZoom()&&s<1||this._zoom>e.getMaxZoom()&&s>1)&&(this._zoom=e._limitZoom(this._zoom)),"center"===e.options.touchZoom){if(this._center=this._startLatLng,1===s)return}else{var r=i._add(n)._divideBy(2)._subtract(this._centerPoint);if(1===s&&0===r.x&&0===r.y)return;this._center=e.unproject(e.project(this._pinchStartLatLng,this._zoom).subtract(r),this._zoom)}this._moved||(e._moveStart(!0),this._moved=!0),o.Util.cancelAnimFrame(this._animRequest);var a=o.bind(e._move,e,this._center,this._zoom,{pinch:!0,round:!1});this._animRequest=o.Util.requestAnimFrame(a,this,!0),o.DomEvent.preventDefault(t)}},_onTouchEnd:function(){return this._moved&&this._zooming?(this._zooming=!1,o.Util.cancelAnimFrame(this._animRequest),o.DomEvent.off(e,"touchmove",this._onTouchMove).off(e,"touchend",this._onTouchEnd),void(this._map.options.zoomAnimation?this._map._animateZoom(this._center,this._map._limitZoom(this._zoom),!0,this._map.options.zoomSnap):this._map._resetView(this._center,this._map._limitZoom(this._zoom)))):void(this._zooming=!1)}}),o.Map.addInitHook("addHandler","touchZoom",o.Map.TouchZoom),o.Map.mergeOptions({tap:!0,tapTolerance:15}),o.Map.Tap=o.Handler.extend({addHooks:function(){o.DomEvent.on(this._map._container,"touchstart",this._onDown,this)},removeHooks:function(){o.DomEvent.off(this._map._container,"touchstart",this._onDown,this)},_onDown:function(t){if(t.touches){if(o.DomEvent.preventDefault(t),this._fireClick=!0,t.touches.length>1)return this._fireClick=!1,void clearTimeout(this._holdTimeout);var i=t.touches[0],n=i.target;this._startPos=this._newPos=new o.Point(i.clientX,i.clientY),n.tagName&&"a"===n.tagName.toLowerCase()&&o.DomUtil.addClass(n,"leaflet-active"),this._holdTimeout=setTimeout(o.bind(function(){this._isTapValid()&&(this._fireClick=!1,this._onUp(),this._simulateEvent("contextmenu",i))},this),1e3),this._simulateEvent("mousedown",i),o.DomEvent.on(e,{touchmove:this._onMove,touchend:this._onUp},this)}},_onUp:function(t){if(clearTimeout(this._holdTimeout),o.DomEvent.off(e,{touchmove:this._onMove,touchend:this._onUp},this),this._fireClick&&t&&t.changedTouches){var i=t.changedTouches[0],n=i.target;n&&n.tagName&&"a"===n.tagName.toLowerCase()&&o.DomUtil.removeClass(n,"leaflet-active"),this._simulateEvent("mouseup",i),this._isTapValid()&&this._simulateEvent("click",i)}},_isTapValid:function(){return this._newPos.distanceTo(this._startPos)<=this._map.options.tapTolerance},_onMove:function(t){var e=t.touches[0];this._newPos=new o.Point(e.clientX,e.clientY),
|
|
this._simulateEvent("mousemove",e)},_simulateEvent:function(i,n){var o=e.createEvent("MouseEvents");o._simulated=!0,n.target._simulatedClick=!0,o.initMouseEvent(i,!0,!0,t,1,n.screenX,n.screenY,n.clientX,n.clientY,!1,!1,!1,!1,0,null),n.target.dispatchEvent(o)}}),o.Browser.touch&&!o.Browser.pointer&&o.Map.addInitHook("addHandler","tap",o.Map.Tap),o.Map.mergeOptions({boxZoom:!0}),o.Map.BoxZoom=o.Handler.extend({initialize:function(t){this._map=t,this._container=t._container,this._pane=t._panes.overlayPane},addHooks:function(){o.DomEvent.on(this._container,"mousedown",this._onMouseDown,this)},removeHooks:function(){o.DomEvent.off(this._container,"mousedown",this._onMouseDown,this)},moved:function(){return this._moved},_resetState:function(){this._moved=!1},_onMouseDown:function(t){return!(!t.shiftKey||1!==t.which&&1!==t.button)&&(this._resetState(),o.DomUtil.disableTextSelection(),o.DomUtil.disableImageDrag(),this._startPoint=this._map.mouseEventToContainerPoint(t),void o.DomEvent.on(e,{contextmenu:o.DomEvent.stop,mousemove:this._onMouseMove,mouseup:this._onMouseUp,keydown:this._onKeyDown},this))},_onMouseMove:function(t){this._moved||(this._moved=!0,this._box=o.DomUtil.create("div","leaflet-zoom-box",this._container),o.DomUtil.addClass(this._container,"leaflet-crosshair"),this._map.fire("boxzoomstart")),this._point=this._map.mouseEventToContainerPoint(t);var e=new o.Bounds(this._point,this._startPoint),i=e.getSize();o.DomUtil.setPosition(this._box,e.min),this._box.style.width=i.x+"px",this._box.style.height=i.y+"px"},_finish:function(){this._moved&&(o.DomUtil.remove(this._box),o.DomUtil.removeClass(this._container,"leaflet-crosshair")),o.DomUtil.enableTextSelection(),o.DomUtil.enableImageDrag(),o.DomEvent.off(e,{contextmenu:o.DomEvent.stop,mousemove:this._onMouseMove,mouseup:this._onMouseUp,keydown:this._onKeyDown},this)},_onMouseUp:function(t){if((1===t.which||1===t.button)&&(this._finish(),this._moved)){setTimeout(o.bind(this._resetState,this),0);var e=new o.LatLngBounds(this._map.containerPointToLatLng(this._startPoint),this._map.containerPointToLatLng(this._point));this._map.fitBounds(e).fire("boxzoomend",{boxZoomBounds:e})}},_onKeyDown:function(t){27===t.keyCode&&this._finish()}}),o.Map.addInitHook("addHandler","boxZoom",o.Map.BoxZoom),o.Map.mergeOptions({keyboard:!0,keyboardPanDelta:80}),o.Map.Keyboard=o.Handler.extend({keyCodes:{left:[37],right:[39],down:[40],up:[38],zoomIn:[187,107,61,171],zoomOut:[189,109,54,173]},initialize:function(t){this._map=t,this._setPanDelta(t.options.keyboardPanDelta),this._setZoomDelta(t.options.zoomDelta)},addHooks:function(){var t=this._map._container;t.tabIndex<=0&&(t.tabIndex="0"),o.DomEvent.on(t,{focus:this._onFocus,blur:this._onBlur,mousedown:this._onMouseDown},this),this._map.on({focus:this._addHooks,blur:this._removeHooks},this)},removeHooks:function(){this._removeHooks(),o.DomEvent.off(this._map._container,{focus:this._onFocus,blur:this._onBlur,mousedown:this._onMouseDown},this),this._map.off({focus:this._addHooks,blur:this._removeHooks},this)},_onMouseDown:function(){if(!this._focused){var i=e.body,n=e.documentElement,o=i.scrollTop||n.scrollTop,s=i.scrollLeft||n.scrollLeft;this._map._container.focus(),t.scrollTo(s,o)}},_onFocus:function(){this._focused=!0,this._map.fire("focus")},_onBlur:function(){this._focused=!1,this._map.fire("blur")},_setPanDelta:function(t){var e,i,n=this._panKeys={},o=this.keyCodes;for(e=0,i=o.left.length;e<i;e++)n[o.left[e]]=[-1*t,0];for(e=0,i=o.right.length;e<i;e++)n[o.right[e]]=[t,0];for(e=0,i=o.down.length;e<i;e++)n[o.down[e]]=[0,t];for(e=0,i=o.up.length;e<i;e++)n[o.up[e]]=[0,-1*t]},_setZoomDelta:function(t){var e,i,n=this._zoomKeys={},o=this.keyCodes;for(e=0,i=o.zoomIn.length;e<i;e++)n[o.zoomIn[e]]=t;for(e=0,i=o.zoomOut.length;e<i;e++)n[o.zoomOut[e]]=-t},_addHooks:function(){o.DomEvent.on(e,"keydown",this._onKeyDown,this)},_removeHooks:function(){o.DomEvent.off(e,"keydown",this._onKeyDown,this)},_onKeyDown:function(t){if(!(t.altKey||t.ctrlKey||t.metaKey)){var e,i=t.keyCode,n=this._map;if(i in this._panKeys){if(n._panAnim&&n._panAnim._inProgress)return;e=this._panKeys[i],t.shiftKey&&(e=o.point(e).multiplyBy(3)),n.panBy(e),n.options.maxBounds&&n.panInsideBounds(n.options.maxBounds)}else if(i in this._zoomKeys)n.setZoom(n.getZoom()+(t.shiftKey?3:1)*this._zoomKeys[i]);else{if(27!==i)return;n.closePopup()}o.DomEvent.stop(t)}}}),o.Map.addInitHook("addHandler","keyboard",o.Map.Keyboard),o.Handler.MarkerDrag=o.Handler.extend({initialize:function(t){this._marker=t},addHooks:function(){var t=this._marker._icon;this._draggable||(this._draggable=new o.Draggable(t,t,!0)),this._draggable.on({dragstart:this._onDragStart,drag:this._onDrag,dragend:this._onDragEnd},this).enable(),o.DomUtil.addClass(t,"leaflet-marker-draggable")},removeHooks:function(){this._draggable.off({dragstart:this._onDragStart,drag:this._onDrag,dragend:this._onDragEnd},this).disable(),this._marker._icon&&o.DomUtil.removeClass(this._marker._icon,"leaflet-marker-draggable")},moved:function(){return this._draggable&&this._draggable._moved},_onDragStart:function(){this._oldLatLng=this._marker.getLatLng(),this._marker.closePopup().fire("movestart").fire("dragstart")},_onDrag:function(t){var e=this._marker,i=e._shadow,n=o.DomUtil.getPosition(e._icon),s=e._map.layerPointToLatLng(n);i&&o.DomUtil.setPosition(i,n),e._latlng=s,t.latlng=s,t.oldLatLng=this._oldLatLng,e.fire("move",t).fire("drag",t)},_onDragEnd:function(t){delete this._oldLatLng,this._marker.fire("moveend").fire("dragend",t)}}),o.Control=o.Class.extend({options:{position:"topright"},initialize:function(t){o.setOptions(this,t)},getPosition:function(){return this.options.position},setPosition:function(t){var e=this._map;return e&&e.removeControl(this),this.options.position=t,e&&e.addControl(this),this},getContainer:function(){return this._container},addTo:function(t){this.remove(),this._map=t;var e=this._container=this.onAdd(t),i=this.getPosition(),n=t._controlCorners[i];return o.DomUtil.addClass(e,"leaflet-control"),i.indexOf("bottom")!==-1?n.insertBefore(e,n.firstChild):n.appendChild(e),this},remove:function(){return this._map?(o.DomUtil.remove(this._container),this.onRemove&&this.onRemove(this._map),this._map=null,this):this},_refocusOnMap:function(t){this._map&&t&&t.screenX>0&&t.screenY>0&&this._map.getContainer().focus()}}),o.control=function(t){return new o.Control(t)},o.Map.include({addControl:function(t){return t.addTo(this),this},removeControl:function(t){return t.remove(),this},_initControlPos:function(){function t(t,s){var r=i+t+" "+i+s;e[t+s]=o.DomUtil.create("div",r,n)}var e=this._controlCorners={},i="leaflet-",n=this._controlContainer=o.DomUtil.create("div",i+"control-container",this._container);t("top","left"),t("top","right"),t("bottom","left"),t("bottom","right")},_clearControlPos:function(){o.DomUtil.remove(this._controlContainer)}}),o.Control.Zoom=o.Control.extend({options:{position:"topleft",zoomInText:"+",zoomInTitle:"Zoom in",zoomOutText:"-",zoomOutTitle:"Zoom out"},onAdd:function(t){var e="leaflet-control-zoom",i=o.DomUtil.create("div",e+" leaflet-bar"),n=this.options;return this._zoomInButton=this._createButton(n.zoomInText,n.zoomInTitle,e+"-in",i,this._zoomIn),this._zoomOutButton=this._createButton(n.zoomOutText,n.zoomOutTitle,e+"-out",i,this._zoomOut),this._updateDisabled(),t.on("zoomend zoomlevelschange",this._updateDisabled,this),i},onRemove:function(t){t.off("zoomend zoomlevelschange",this._updateDisabled,this)},disable:function(){return this._disabled=!0,this._updateDisabled(),this},enable:function(){return this._disabled=!1,this._updateDisabled(),this},_zoomIn:function(t){!this._disabled&&this._map._zoom<this._map.getMaxZoom()&&this._map.zoomIn(this._map.options.zoomDelta*(t.shiftKey?3:1))},_zoomOut:function(t){!this._disabled&&this._map._zoom>this._map.getMinZoom()&&this._map.zoomOut(this._map.options.zoomDelta*(t.shiftKey?3:1))},_createButton:function(t,e,i,n,s){var r=o.DomUtil.create("a",i,n);return r.innerHTML=t,r.href="#",r.title=e,r.setAttribute("role","button"),r.setAttribute("aria-label",e),o.DomEvent.on(r,"mousedown dblclick",o.DomEvent.stopPropagation).on(r,"click",o.DomEvent.stop).on(r,"click",s,this).on(r,"click",this._refocusOnMap,this),r},_updateDisabled:function(){var t=this._map,e="leaflet-disabled";o.DomUtil.removeClass(this._zoomInButton,e),o.DomUtil.removeClass(this._zoomOutButton,e),(this._disabled||t._zoom===t.getMinZoom())&&o.DomUtil.addClass(this._zoomOutButton,e),(this._disabled||t._zoom===t.getMaxZoom())&&o.DomUtil.addClass(this._zoomInButton,e)}}),o.Map.mergeOptions({zoomControl:!0}),o.Map.addInitHook(function(){this.options.zoomControl&&(this.zoomControl=new o.Control.Zoom,this.addControl(this.zoomControl))}),o.control.zoom=function(t){return new o.Control.Zoom(t)},o.Control.Attribution=o.Control.extend({options:{position:"bottomright",prefix:'<a href="http://leafletjs.com" title="A JS library for interactive maps">Leaflet</a>'},initialize:function(t){o.setOptions(this,t),this._attributions={}},onAdd:function(t){t.attributionControl=this,this._container=o.DomUtil.create("div","leaflet-control-attribution"),o.DomEvent&&o.DomEvent.disableClickPropagation(this._container);for(var e in t._layers)t._layers[e].getAttribution&&this.addAttribution(t._layers[e].getAttribution());return this._update(),this._container},setPrefix:function(t){return this.options.prefix=t,this._update(),this},addAttribution:function(t){return t?(this._attributions[t]||(this._attributions[t]=0),this._attributions[t]++,this._update(),this):this},removeAttribution:function(t){return t?(this._attributions[t]&&(this._attributions[t]--,this._update()),this):this},_update:function(){if(this._map){var t=[];for(var e in this._attributions)this._attributions[e]&&t.push(e);var i=[];this.options.prefix&&i.push(this.options.prefix),t.length&&i.push(t.join(", ")),this._container.innerHTML=i.join(" | ")}}}),o.Map.mergeOptions({attributionControl:!0}),o.Map.addInitHook(function(){this.options.attributionControl&&(new o.Control.Attribution).addTo(this)}),o.control.attribution=function(t){return new o.Control.Attribution(t)},o.Control.Scale=o.Control.extend({options:{position:"bottomleft",maxWidth:100,metric:!0,imperial:!0},onAdd:function(t){var e="leaflet-control-scale",i=o.DomUtil.create("div",e),n=this.options;return this._addScales(n,e+"-line",i),t.on(n.updateWhenIdle?"moveend":"move",this._update,this),t.whenReady(this._update,this),i},onRemove:function(t){t.off(this.options.updateWhenIdle?"moveend":"move",this._update,this)},_addScales:function(t,e,i){t.metric&&(this._mScale=o.DomUtil.create("div",e,i)),t.imperial&&(this._iScale=o.DomUtil.create("div",e,i))},_update:function(){var t=this._map,e=t.getSize().y/2,i=t.distance(t.containerPointToLatLng([0,e]),t.containerPointToLatLng([this.options.maxWidth,e]));this._updateScales(i)},_updateScales:function(t){this.options.metric&&t&&this._updateMetric(t),this.options.imperial&&t&&this._updateImperial(t)},_updateMetric:function(t){var e=this._getRoundNum(t),i=e<1e3?e+" m":e/1e3+" km";this._updateScale(this._mScale,i,e/t)},_updateImperial:function(t){var e,i,n,o=3.2808399*t;o>5280?(e=o/5280,i=this._getRoundNum(e),this._updateScale(this._iScale,i+" mi",i/e)):(n=this._getRoundNum(o),this._updateScale(this._iScale,n+" ft",n/o))},_updateScale:function(t,e,i){t.style.width=Math.round(this.options.maxWidth*i)+"px",t.innerHTML=e},_getRoundNum:function(t){var e=Math.pow(10,(Math.floor(t)+"").length-1),i=t/e;return i=i>=10?10:i>=5?5:i>=3?3:i>=2?2:1,e*i}}),o.control.scale=function(t){return new o.Control.Scale(t)},o.Control.Layers=o.Control.extend({options:{collapsed:!0,position:"topright",autoZIndex:!0,hideSingleBase:!1,sortLayers:!1,sortFunction:function(t,e,i,n){return i<n?-1:n<i?1:0}},initialize:function(t,e,i){o.setOptions(this,i),this._layers=[],this._lastZIndex=0,this._handlingClick=!1;for(var n in t)this._addLayer(t[n],n);for(n in e)this._addLayer(e[n],n,!0)},onAdd:function(t){return this._initLayout(),this._update(),this._map=t,t.on("zoomend",this._checkDisabledLayers,this),this._container},onRemove:function(){this._map.off("zoomend",this._checkDisabledLayers,this);for(var t=0;t<this._layers.length;t++)this._layers[t].layer.off("add remove",this._onLayerChange,this)},addBaseLayer:function(t,e){return this._addLayer(t,e),this._map?this._update():this},addOverlay:function(t,e){return this._addLayer(t,e,!0),this._map?this._update():this},removeLayer:function(t){t.off("add remove",this._onLayerChange,this);var e=this._getLayer(o.stamp(t));return e&&this._layers.splice(this._layers.indexOf(e),1),this._map?this._update():this},expand:function(){o.DomUtil.addClass(this._container,"leaflet-control-layers-expanded"),this._form.style.height=null;var t=this._map.getSize().y-(this._container.offsetTop+50);return t<this._form.clientHeight?(o.DomUtil.addClass(this._form,"leaflet-control-layers-scrollbar"),this._form.style.height=t+"px"):o.DomUtil.removeClass(this._form,"leaflet-control-layers-scrollbar"),this._checkDisabledLayers(),this},collapse:function(){return o.DomUtil.removeClass(this._container,"leaflet-control-layers-expanded"),this},_initLayout:function(){var t="leaflet-control-layers",e=this._container=o.DomUtil.create("div",t),i=this.options.collapsed;e.setAttribute("aria-haspopup",!0),o.DomEvent.disableClickPropagation(e),o.Browser.touch||o.DomEvent.disableScrollPropagation(e);var n=this._form=o.DomUtil.create("form",t+"-list");i&&(this._map.on("click",this.collapse,this),o.Browser.android||o.DomEvent.on(e,{mouseenter:this.expand,mouseleave:this.collapse},this));var s=this._layersLink=o.DomUtil.create("a",t+"-toggle",e);s.href="#",s.title="Layers",o.Browser.touch?o.DomEvent.on(s,"click",o.DomEvent.stop).on(s,"click",this.expand,this):o.DomEvent.on(s,"focus",this.expand,this),o.DomEvent.on(n,"click",function(){setTimeout(o.bind(this._onInputClick,this),0)},this),i||this.expand(),this._baseLayersList=o.DomUtil.create("div",t+"-base",n),this._separator=o.DomUtil.create("div",t+"-separator",n),this._overlaysList=o.DomUtil.create("div",t+"-overlays",n),e.appendChild(n)},_getLayer:function(t){for(var e=0;e<this._layers.length;e++)if(this._layers[e]&&o.stamp(this._layers[e].layer)===t)return this._layers[e]},_addLayer:function(t,e,i){t.on("add remove",this._onLayerChange,this),this._layers.push({layer:t,name:e,overlay:i}),this.options.sortLayers&&this._layers.sort(o.bind(function(t,e){return this.options.sortFunction(t.layer,e.layer,t.name,e.name)},this)),this.options.autoZIndex&&t.setZIndex&&(this._lastZIndex++,t.setZIndex(this._lastZIndex))},_update:function(){if(!this._container)return this;o.DomUtil.empty(this._baseLayersList),o.DomUtil.empty(this._overlaysList);var t,e,i,n,s=0;for(i=0;i<this._layers.length;i++)n=this._layers[i],this._addItem(n),e=e||n.overlay,t=t||!n.overlay,s+=n.overlay?0:1;return this.options.hideSingleBase&&(t=t&&s>1,this._baseLayersList.style.display=t?"":"none"),this._separator.style.display=e&&t?"":"none",this},_onLayerChange:function(t){this._handlingClick||this._update();var e=this._getLayer(o.stamp(t.target)),i=e.overlay?"add"===t.type?"overlayadd":"overlayremove":"add"===t.type?"baselayerchange":null;i&&this._map.fire(i,e)},_createRadioElement:function(t,i){var n='<input type="radio" class="leaflet-control-layers-selector" name="'+t+'"'+(i?' checked="checked"':"")+"/>",o=e.createElement("div");return o.innerHTML=n,o.firstChild},_addItem:function(t){var i,n=e.createElement("label"),s=this._map.hasLayer(t.layer);t.overlay?(i=e.createElement("input"),i.type="checkbox",i.className="leaflet-control-layers-selector",i.defaultChecked=s):i=this._createRadioElement("leaflet-base-layers",s),i.layerId=o.stamp(t.layer),o.DomEvent.on(i,"click",this._onInputClick,this);var r=e.createElement("span");r.innerHTML=" "+t.name;var a=e.createElement("div");n.appendChild(a),a.appendChild(i),a.appendChild(r);var h=t.overlay?this._overlaysList:this._baseLayersList;return h.appendChild(n),this._checkDisabledLayers(),n},_onInputClick:function(){var t,e,i,n=this._form.getElementsByTagName("input"),o=[],s=[];this._handlingClick=!0;for(var r=n.length-1;r>=0;r--)t=n[r],e=this._getLayer(t.layerId).layer,i=this._map.hasLayer(e),t.checked&&!i?o.push(e):!t.checked&&i&&s.push(e);for(r=0;r<s.length;r++)this._map.removeLayer(s[r]);for(r=0;r<o.length;r++)this._map.addLayer(o[r]);this._handlingClick=!1,this._refocusOnMap()},_checkDisabledLayers:function(){for(var t,e,n=this._form.getElementsByTagName("input"),o=this._map.getZoom(),s=n.length-1;s>=0;s--)t=n[s],e=this._getLayer(t.layerId).layer,t.disabled=e.options.minZoom!==i&&o<e.options.minZoom||e.options.maxZoom!==i&&o>e.options.maxZoom},_expand:function(){return this.expand()},_collapse:function(){return this.collapse()}}),o.control.layers=function(t,e,i){return new o.Control.Layers(t,e,i)}}(window,document);
|
|
/**
|
|
* what-input - A global utility for tracking the current input method (mouse, keyboard or touch).
|
|
* @version v4.1.3
|
|
* @link https://github.com/ten1seven/what-input
|
|
* @license MIT
|
|
*/
|
|
(function webpackUniversalModuleDefinition(root, factory) {
|
|
if(typeof exports === 'object' && typeof module === 'object')
|
|
module.exports = factory();
|
|
else if(typeof define === 'function' && define.amd)
|
|
define("whatInput", [], factory);
|
|
else if(typeof exports === 'object')
|
|
exports["whatInput"] = factory();
|
|
else
|
|
root["whatInput"] = factory();
|
|
})(this, function() {
|
|
return /******/ (function(modules) { // webpackBootstrap
|
|
/******/ // The module cache
|
|
/******/ var installedModules = {};
|
|
|
|
/******/ // The require function
|
|
/******/ function __webpack_require__(moduleId) {
|
|
|
|
/******/ // Check if module is in cache
|
|
/******/ if(installedModules[moduleId])
|
|
/******/ return installedModules[moduleId].exports;
|
|
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = installedModules[moduleId] = {
|
|
/******/ exports: {},
|
|
/******/ id: moduleId,
|
|
/******/ loaded: false
|
|
/******/ };
|
|
|
|
/******/ // Execute the module function
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
|
|
/******/ // Flag the module as loaded
|
|
/******/ module.loaded = true;
|
|
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
|
|
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
/******/ __webpack_require__.m = modules;
|
|
|
|
/******/ // expose the module cache
|
|
/******/ __webpack_require__.c = installedModules;
|
|
|
|
/******/ // __webpack_public_path__
|
|
/******/ __webpack_require__.p = "";
|
|
|
|
/******/ // Load entry module and return exports
|
|
/******/ return __webpack_require__(0);
|
|
/******/ })
|
|
/************************************************************************/
|
|
/******/ ([
|
|
/* 0 */
|
|
/***/ (function(module, exports) {
|
|
|
|
'use strict';
|
|
|
|
module.exports = function () {
|
|
/*
|
|
* variables
|
|
*/
|
|
|
|
// cache document.documentElement
|
|
var docElem = document.documentElement;
|
|
|
|
// last used input type
|
|
var currentInput = 'initial';
|
|
|
|
// last used input intent
|
|
var currentIntent = null;
|
|
|
|
// form input types
|
|
var formInputs = ['input', 'select', 'textarea'];
|
|
|
|
// list of modifier keys commonly used with the mouse and
|
|
// can be safely ignored to prevent false keyboard detection
|
|
var ignoreMap = [16, // shift
|
|
17, // control
|
|
18, // alt
|
|
91, // Windows key / left Apple cmd
|
|
93 // Windows menu / right Apple cmd
|
|
];
|
|
|
|
// mapping of events to input types
|
|
var inputMap = {
|
|
keydown: 'keyboard',
|
|
mousedown: 'mouse',
|
|
mousemove: 'mouse',
|
|
MSPointerDown: 'pointer',
|
|
MSPointerMove: 'pointer',
|
|
pointerdown: 'pointer',
|
|
pointermove: 'pointer',
|
|
touchstart: 'touch'
|
|
};
|
|
|
|
// array of all used input types
|
|
var inputTypes = [];
|
|
|
|
// boolean: true if touch buffer is active
|
|
var isBuffering = false;
|
|
|
|
// boolean: true if the page is being scrolled
|
|
var isScrolling = false;
|
|
|
|
// store current mouse position
|
|
var mousePos = {
|
|
x: null,
|
|
y: null
|
|
};
|
|
|
|
// map of IE 10 pointer events
|
|
var pointerMap = {
|
|
2: 'touch',
|
|
3: 'touch', // treat pen like touch
|
|
4: 'mouse'
|
|
};
|
|
|
|
/*
|
|
* set up
|
|
*/
|
|
|
|
var setUp = function setUp() {
|
|
// add correct mouse wheel event mapping to `inputMap`
|
|
inputMap[detectWheel()] = 'mouse';
|
|
|
|
addListeners();
|
|
setInput();
|
|
};
|
|
|
|
/*
|
|
* events
|
|
*/
|
|
|
|
var addListeners = function addListeners() {
|
|
// `pointermove`, `MSPointerMove`, `mousemove` and mouse wheel event binding
|
|
// can only demonstrate potential, but not actual, interaction
|
|
// and are treated separately
|
|
|
|
// pointer events (mouse, pen, touch)
|
|
if (window.PointerEvent) {
|
|
docElem.addEventListener('pointerdown', updateInput);
|
|
docElem.addEventListener('pointermove', setIntent);
|
|
} else if (window.MSPointerEvent) {
|
|
docElem.addEventListener('MSPointerDown', updateInput);
|
|
docElem.addEventListener('MSPointerMove', setIntent);
|
|
} else {
|
|
// mouse events
|
|
docElem.addEventListener('mousedown', updateInput);
|
|
docElem.addEventListener('mousemove', setIntent);
|
|
|
|
// touch events
|
|
if ('ontouchstart' in window) {
|
|
docElem.addEventListener('touchstart', touchBuffer);
|
|
docElem.addEventListener('touchend', touchBuffer);
|
|
}
|
|
}
|
|
|
|
// mouse wheel
|
|
docElem.addEventListener(detectWheel(), setIntent);
|
|
|
|
// keyboard events
|
|
docElem.addEventListener('keydown', updateInput);
|
|
};
|
|
|
|
// checks conditions before updating new input
|
|
var updateInput = function updateInput(event) {
|
|
// only execute if the touch buffer timer isn't running
|
|
if (!isBuffering) {
|
|
var eventKey = event.which;
|
|
var value = inputMap[event.type];
|
|
if (value === 'pointer') value = pointerType(event);
|
|
|
|
if (currentInput !== value || currentIntent !== value) {
|
|
var activeElem = document.activeElement;
|
|
var activeInput = false;
|
|
|
|
if (activeElem && activeElem.nodeName && formInputs.indexOf(activeElem.nodeName.toLowerCase()) === -1) {
|
|
activeInput = true;
|
|
}
|
|
|
|
if (value === 'touch' ||
|
|
// ignore mouse modifier keys
|
|
value === 'mouse' ||
|
|
// don't switch if the current element is a form input
|
|
value === 'keyboard' && activeInput && ignoreMap.indexOf(eventKey) === -1) {
|
|
// set the current and catch-all variable
|
|
currentInput = currentIntent = value;
|
|
|
|
setInput();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// updates the doc and `inputTypes` array with new input
|
|
var setInput = function setInput() {
|
|
docElem.setAttribute('data-whatinput', currentInput);
|
|
docElem.setAttribute('data-whatintent', currentInput);
|
|
|
|
if (inputTypes.indexOf(currentInput) === -1) {
|
|
inputTypes.push(currentInput);
|
|
docElem.className += ' whatinput-types-' + currentInput;
|
|
}
|
|
};
|
|
|
|
// updates input intent for `mousemove` and `pointermove`
|
|
var setIntent = function setIntent(event) {
|
|
// test to see if `mousemove` happened relative to the screen
|
|
// to detect scrolling versus mousemove
|
|
if (mousePos['x'] !== event.screenX || mousePos['y'] !== event.screenY) {
|
|
isScrolling = false;
|
|
|
|
mousePos['x'] = event.screenX;
|
|
mousePos['y'] = event.screenY;
|
|
} else {
|
|
isScrolling = true;
|
|
}
|
|
|
|
// only execute if the touch buffer timer isn't running
|
|
// or scrolling isn't happening
|
|
if (!isBuffering && !isScrolling) {
|
|
var value = inputMap[event.type];
|
|
if (value === 'pointer') value = pointerType(event);
|
|
|
|
if (currentIntent !== value) {
|
|
currentIntent = value;
|
|
|
|
docElem.setAttribute('data-whatintent', currentIntent);
|
|
}
|
|
}
|
|
};
|
|
|
|
// buffers touch events because they frequently also fire mouse events
|
|
var touchBuffer = function touchBuffer(event) {
|
|
if (event.type === 'touchstart') {
|
|
isBuffering = false;
|
|
|
|
// set the current input
|
|
updateInput(event);
|
|
} else {
|
|
isBuffering = true;
|
|
}
|
|
};
|
|
|
|
/*
|
|
* utilities
|
|
*/
|
|
|
|
var pointerType = function pointerType(event) {
|
|
if (typeof event.pointerType === 'number') {
|
|
return pointerMap[event.pointerType];
|
|
} else {
|
|
// treat pen like touch
|
|
return event.pointerType === 'pen' ? 'touch' : event.pointerType;
|
|
}
|
|
};
|
|
|
|
// detect version of mouse wheel event to use
|
|
// via https://developer.mozilla.org/en-US/docs/Web/Events/wheel
|
|
var detectWheel = function detectWheel() {
|
|
var wheelType = void 0;
|
|
|
|
// Modern browsers support "wheel"
|
|
if ('onwheel' in document.createElement('div')) {
|
|
wheelType = 'wheel';
|
|
} else {
|
|
// Webkit and IE support at least "mousewheel"
|
|
// or assume that remaining browsers are older Firefox
|
|
wheelType = document.onmousewheel !== undefined ? 'mousewheel' : 'DOMMouseScroll';
|
|
}
|
|
|
|
return wheelType;
|
|
};
|
|
|
|
/*
|
|
* init
|
|
*/
|
|
|
|
// don't start script unless browser cuts the mustard
|
|
// (also passes if polyfills are used)
|
|
if ('addEventListener' in window && Array.prototype.indexOf) {
|
|
setUp();
|
|
}
|
|
|
|
/*
|
|
* api
|
|
*/
|
|
|
|
return {
|
|
// returns string: the current input type
|
|
// opt: 'loose'|'strict'
|
|
// 'strict' (default): returns the same value as the `data-whatinput` attribute
|
|
// 'loose': includes `data-whatintent` value if it's more current than `data-whatinput`
|
|
ask: function ask(opt) {
|
|
return opt === 'loose' ? currentIntent : currentInput;
|
|
},
|
|
|
|
// returns array: all the detected input types
|
|
types: function types() {
|
|
return inputTypes;
|
|
}
|
|
};
|
|
}();
|
|
|
|
/***/ })
|
|
/******/ ])
|
|
});
|
|
;
|
|
!function ($) {
|
|
|
|
"use strict";
|
|
|
|
var FOUNDATION_VERSION = '6.2.4';
|
|
|
|
// Global Foundation object
|
|
// This is attached to the window, or used as a module for AMD/Browserify
|
|
var Foundation = {
|
|
version: FOUNDATION_VERSION,
|
|
|
|
/**
|
|
* Stores initialized plugins.
|
|
*/
|
|
_plugins: {},
|
|
|
|
/**
|
|
* Stores generated unique ids for plugin instances
|
|
*/
|
|
_uuids: [],
|
|
|
|
/**
|
|
* Returns a boolean for RTL support
|
|
*/
|
|
rtl: function () {
|
|
return $('html').attr('dir') === 'rtl';
|
|
},
|
|
/**
|
|
* Defines a Foundation plugin, adding it to the `Foundation` namespace and the list of plugins to initialize when reflowing.
|
|
* @param {Object} plugin - The constructor of the plugin.
|
|
*/
|
|
plugin: function (plugin, name) {
|
|
// Object key to use when adding to global Foundation object
|
|
// Examples: Foundation.Reveal, Foundation.OffCanvas
|
|
var className = name || functionName(plugin);
|
|
// Object key to use when storing the plugin, also used to create the identifying data attribute for the plugin
|
|
// Examples: data-reveal, data-off-canvas
|
|
var attrName = hyphenate(className);
|
|
|
|
// Add to the Foundation object and the plugins list (for reflowing)
|
|
this._plugins[attrName] = this[className] = plugin;
|
|
},
|
|
/**
|
|
* @function
|
|
* Populates the _uuids array with pointers to each individual plugin instance.
|
|
* Adds the `zfPlugin` data-attribute to programmatically created plugins to allow use of $(selector).foundation(method) calls.
|
|
* Also fires the initialization event for each plugin, consolidating repetitive code.
|
|
* @param {Object} plugin - an instance of a plugin, usually `this` in context.
|
|
* @param {String} name - the name of the plugin, passed as a camelCased string.
|
|
* @fires Plugin#init
|
|
*/
|
|
registerPlugin: function (plugin, name) {
|
|
var pluginName = name ? hyphenate(name) : functionName(plugin.constructor).toLowerCase();
|
|
plugin.uuid = this.GetYoDigits(6, pluginName);
|
|
|
|
if (!plugin.$element.attr('data-' + pluginName)) {
|
|
plugin.$element.attr('data-' + pluginName, plugin.uuid);
|
|
}
|
|
if (!plugin.$element.data('zfPlugin')) {
|
|
plugin.$element.data('zfPlugin', plugin);
|
|
}
|
|
/**
|
|
* Fires when the plugin has initialized.
|
|
* @event Plugin#init
|
|
*/
|
|
plugin.$element.trigger('init.zf.' + pluginName);
|
|
|
|
this._uuids.push(plugin.uuid);
|
|
|
|
return;
|
|
},
|
|
/**
|
|
* @function
|
|
* Removes the plugins uuid from the _uuids array.
|
|
* Removes the zfPlugin data attribute, as well as the data-plugin-name attribute.
|
|
* Also fires the destroyed event for the plugin, consolidating repetitive code.
|
|
* @param {Object} plugin - an instance of a plugin, usually `this` in context.
|
|
* @fires Plugin#destroyed
|
|
*/
|
|
unregisterPlugin: function (plugin) {
|
|
var pluginName = hyphenate(functionName(plugin.$element.data('zfPlugin').constructor));
|
|
|
|
this._uuids.splice(this._uuids.indexOf(plugin.uuid), 1);
|
|
plugin.$element.removeAttr('data-' + pluginName).removeData('zfPlugin')
|
|
/**
|
|
* Fires when the plugin has been destroyed.
|
|
* @event Plugin#destroyed
|
|
*/
|
|
.trigger('destroyed.zf.' + pluginName);
|
|
for (var prop in plugin) {
|
|
plugin[prop] = null; //clean up script to prep for garbage collection.
|
|
}
|
|
return;
|
|
},
|
|
|
|
/**
|
|
* @function
|
|
* Causes one or more active plugins to re-initialize, resetting event listeners, recalculating positions, etc.
|
|
* @param {String} plugins - optional string of an individual plugin key, attained by calling `$(element).data('pluginName')`, or string of a plugin class i.e. `'dropdown'`
|
|
* @default If no argument is passed, reflow all currently active plugins.
|
|
*/
|
|
reInit: function (plugins) {
|
|
var isJQ = plugins instanceof $;
|
|
try {
|
|
if (isJQ) {
|
|
plugins.each(function () {
|
|
$(this).data('zfPlugin')._init();
|
|
});
|
|
} else {
|
|
var type = typeof plugins,
|
|
_this = this,
|
|
fns = {
|
|
'object': function (plgs) {
|
|
plgs.forEach(function (p) {
|
|
p = hyphenate(p);
|
|
$('[data-' + p + ']').foundation('_init');
|
|
});
|
|
},
|
|
'string': function () {
|
|
plugins = hyphenate(plugins);
|
|
$('[data-' + plugins + ']').foundation('_init');
|
|
},
|
|
'undefined': function () {
|
|
this['object'](Object.keys(_this._plugins));
|
|
}
|
|
};
|
|
fns[type](plugins);
|
|
}
|
|
} catch (err) {
|
|
console.error(err);
|
|
} finally {
|
|
return plugins;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* returns a random base-36 uid with namespacing
|
|
* @function
|
|
* @param {Number} length - number of random base-36 digits desired. Increase for more random strings.
|
|
* @param {String} namespace - name of plugin to be incorporated in uid, optional.
|
|
* @default {String} '' - if no plugin name is provided, nothing is appended to the uid.
|
|
* @returns {String} - unique id
|
|
*/
|
|
GetYoDigits: function (length, namespace) {
|
|
length = length || 6;
|
|
return Math.round(Math.pow(36, length + 1) - Math.random() * Math.pow(36, length)).toString(36).slice(1) + (namespace ? '-' + namespace : '');
|
|
},
|
|
/**
|
|
* Initialize plugins on any elements within `elem` (and `elem` itself) that aren't already initialized.
|
|
* @param {Object} elem - jQuery object containing the element to check inside. Also checks the element itself, unless it's the `document` object.
|
|
* @param {String|Array} plugins - A list of plugins to initialize. Leave this out to initialize everything.
|
|
*/
|
|
reflow: function (elem, plugins) {
|
|
|
|
// If plugins is undefined, just grab everything
|
|
if (typeof plugins === 'undefined') {
|
|
plugins = Object.keys(this._plugins);
|
|
}
|
|
// If plugins is a string, convert it to an array with one item
|
|
else if (typeof plugins === 'string') {
|
|
plugins = [plugins];
|
|
}
|
|
|
|
var _this = this;
|
|
|
|
// Iterate through each plugin
|
|
$.each(plugins, function (i, name) {
|
|
// Get the current plugin
|
|
var plugin = _this._plugins[name];
|
|
|
|
// Localize the search to all elements inside elem, as well as elem itself, unless elem === document
|
|
var $elem = $(elem).find('[data-' + name + ']').addBack('[data-' + name + ']');
|
|
|
|
// For each plugin found, initialize it
|
|
$elem.each(function () {
|
|
var $el = $(this),
|
|
opts = {};
|
|
// Don't double-dip on plugins
|
|
if ($el.data('zfPlugin')) {
|
|
console.warn("Tried to initialize " + name + " on an element that already has a Foundation plugin.");
|
|
return;
|
|
}
|
|
|
|
if ($el.attr('data-options')) {
|
|
var thing = $el.attr('data-options').split(';').forEach(function (e, i) {
|
|
var opt = e.split(':').map(function (el) {
|
|
return el.trim();
|
|
});
|
|
if (opt[0]) opts[opt[0]] = parseValue(opt[1]);
|
|
});
|
|
}
|
|
try {
|
|
$el.data('zfPlugin', new plugin($(this), opts));
|
|
} catch (er) {
|
|
console.error(er);
|
|
} finally {
|
|
return;
|
|
}
|
|
});
|
|
});
|
|
},
|
|
getFnName: functionName,
|
|
transitionend: function ($elem) {
|
|
var transitions = {
|
|
'transition': 'transitionend',
|
|
'WebkitTransition': 'webkitTransitionEnd',
|
|
'MozTransition': 'transitionend',
|
|
'OTransition': 'otransitionend'
|
|
};
|
|
var elem = document.createElement('div'),
|
|
end;
|
|
|
|
for (var t in transitions) {
|
|
if (typeof elem.style[t] !== 'undefined') {
|
|
end = transitions[t];
|
|
}
|
|
}
|
|
if (end) {
|
|
return end;
|
|
} else {
|
|
end = setTimeout(function () {
|
|
$elem.triggerHandler('transitionend', [$elem]);
|
|
}, 1);
|
|
return 'transitionend';
|
|
}
|
|
}
|
|
};
|
|
|
|
Foundation.util = {
|
|
/**
|
|
* Function for applying a debounce effect to a function call.
|
|
* @function
|
|
* @param {Function} func - Function to be called at end of timeout.
|
|
* @param {Number} delay - Time in ms to delay the call of `func`.
|
|
* @returns function
|
|
*/
|
|
throttle: function (func, delay) {
|
|
var timer = null;
|
|
|
|
return function () {
|
|
var context = this,
|
|
args = arguments;
|
|
|
|
if (timer === null) {
|
|
timer = setTimeout(function () {
|
|
func.apply(context, args);
|
|
timer = null;
|
|
}, delay);
|
|
}
|
|
};
|
|
}
|
|
};
|
|
|
|
// TODO: consider not making this a jQuery function
|
|
// TODO: need way to reflow vs. re-initialize
|
|
/**
|
|
* The Foundation jQuery method.
|
|
* @param {String|Array} method - An action to perform on the current jQuery object.
|
|
*/
|
|
var foundation = function (method) {
|
|
var type = typeof method,
|
|
$meta = $('meta.foundation-mq'),
|
|
$noJS = $('.no-js');
|
|
|
|
if (!$meta.length) {
|
|
$('<meta class="foundation-mq">').appendTo(document.head);
|
|
}
|
|
if ($noJS.length) {
|
|
$noJS.removeClass('no-js');
|
|
}
|
|
|
|
if (type === 'undefined') {
|
|
//needs to initialize the Foundation object, or an individual plugin.
|
|
Foundation.MediaQuery._init();
|
|
Foundation.reflow(this);
|
|
} else if (type === 'string') {
|
|
//an individual method to invoke on a plugin or group of plugins
|
|
var args = Array.prototype.slice.call(arguments, 1); //collect all the arguments, if necessary
|
|
var plugClass = this.data('zfPlugin'); //determine the class of plugin
|
|
|
|
if (plugClass !== undefined && plugClass[method] !== undefined) {
|
|
//make sure both the class and method exist
|
|
if (this.length === 1) {
|
|
//if there's only one, call it directly.
|
|
plugClass[method].apply(plugClass, args);
|
|
} else {
|
|
this.each(function (i, el) {
|
|
//otherwise loop through the jQuery collection and invoke the method on each
|
|
plugClass[method].apply($(el).data('zfPlugin'), args);
|
|
});
|
|
}
|
|
} else {
|
|
//error for no class or no method
|
|
throw new ReferenceError("We're sorry, '" + method + "' is not an available method for " + (plugClass ? functionName(plugClass) : 'this element') + '.');
|
|
}
|
|
} else {
|
|
//error for invalid argument type
|
|
throw new TypeError('We\'re sorry, ' + type + ' is not a valid parameter. You must use a string representing the method you wish to invoke.');
|
|
}
|
|
return this;
|
|
};
|
|
|
|
window.Foundation = Foundation;
|
|
$.fn.foundation = foundation;
|
|
|
|
// Polyfill for requestAnimationFrame
|
|
(function () {
|
|
if (!Date.now || !window.Date.now) window.Date.now = Date.now = function () {
|
|
return new Date().getTime();
|
|
};
|
|
|
|
var vendors = ['webkit', 'moz'];
|
|
for (var i = 0; i < vendors.length && !window.requestAnimationFrame; ++i) {
|
|
var vp = vendors[i];
|
|
window.requestAnimationFrame = window[vp + 'RequestAnimationFrame'];
|
|
window.cancelAnimationFrame = window[vp + 'CancelAnimationFrame'] || window[vp + 'CancelRequestAnimationFrame'];
|
|
}
|
|
if (/iP(ad|hone|od).*OS 6/.test(window.navigator.userAgent) || !window.requestAnimationFrame || !window.cancelAnimationFrame) {
|
|
var lastTime = 0;
|
|
window.requestAnimationFrame = function (callback) {
|
|
var now = Date.now();
|
|
var nextTime = Math.max(lastTime + 16, now);
|
|
return setTimeout(function () {
|
|
callback(lastTime = nextTime);
|
|
}, nextTime - now);
|
|
};
|
|
window.cancelAnimationFrame = clearTimeout;
|
|
}
|
|
/**
|
|
* Polyfill for performance.now, required by rAF
|
|
*/
|
|
if (!window.performance || !window.performance.now) {
|
|
window.performance = {
|
|
start: Date.now(),
|
|
now: function () {
|
|
return Date.now() - this.start;
|
|
}
|
|
};
|
|
}
|
|
})();
|
|
if (!Function.prototype.bind) {
|
|
Function.prototype.bind = function (oThis) {
|
|
if (typeof this !== 'function') {
|
|
// closest thing possible to the ECMAScript 5
|
|
// internal IsCallable function
|
|
throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable');
|
|
}
|
|
|
|
var aArgs = Array.prototype.slice.call(arguments, 1),
|
|
fToBind = this,
|
|
fNOP = function () {},
|
|
fBound = function () {
|
|
return fToBind.apply(this instanceof fNOP ? this : oThis, aArgs.concat(Array.prototype.slice.call(arguments)));
|
|
};
|
|
|
|
if (this.prototype) {
|
|
// native functions don't have a prototype
|
|
fNOP.prototype = this.prototype;
|
|
}
|
|
fBound.prototype = new fNOP();
|
|
|
|
return fBound;
|
|
};
|
|
}
|
|
// Polyfill to get the name of a function in IE9
|
|
function functionName(fn) {
|
|
if (Function.prototype.name === undefined) {
|
|
var funcNameRegex = /function\s([^(]{1,})\(/;
|
|
var results = funcNameRegex.exec(fn.toString());
|
|
return results && results.length > 1 ? results[1].trim() : "";
|
|
} else if (fn.prototype === undefined) {
|
|
return fn.constructor.name;
|
|
} else {
|
|
return fn.prototype.constructor.name;
|
|
}
|
|
}
|
|
function parseValue(str) {
|
|
if (/true/.test(str)) return true;else if (/false/.test(str)) return false;else if (!isNaN(str * 1)) return parseFloat(str);
|
|
return str;
|
|
}
|
|
// Convert PascalCase to kebab-case
|
|
// Thank you: http://stackoverflow.com/a/8955580
|
|
function hyphenate(str) {
|
|
return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
|
|
}
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
!function ($) {
|
|
|
|
Foundation.Box = {
|
|
ImNotTouchingYou: ImNotTouchingYou,
|
|
GetDimensions: GetDimensions,
|
|
GetOffsets: GetOffsets
|
|
};
|
|
|
|
/**
|
|
* Compares the dimensions of an element to a container and determines collision events with container.
|
|
* @function
|
|
* @param {jQuery} element - jQuery object to test for collisions.
|
|
* @param {jQuery} parent - jQuery object to use as bounding container.
|
|
* @param {Boolean} lrOnly - set to true to check left and right values only.
|
|
* @param {Boolean} tbOnly - set to true to check top and bottom values only.
|
|
* @default if no parent object passed, detects collisions with `window`.
|
|
* @returns {Boolean} - true if collision free, false if a collision in any direction.
|
|
*/
|
|
function ImNotTouchingYou(element, parent, lrOnly, tbOnly) {
|
|
var eleDims = GetDimensions(element),
|
|
top,
|
|
bottom,
|
|
left,
|
|
right;
|
|
|
|
if (parent) {
|
|
var parDims = GetDimensions(parent);
|
|
|
|
bottom = eleDims.offset.top + eleDims.height <= parDims.height + parDims.offset.top;
|
|
top = eleDims.offset.top >= parDims.offset.top;
|
|
left = eleDims.offset.left >= parDims.offset.left;
|
|
right = eleDims.offset.left + eleDims.width <= parDims.width + parDims.offset.left;
|
|
} else {
|
|
bottom = eleDims.offset.top + eleDims.height <= eleDims.windowDims.height + eleDims.windowDims.offset.top;
|
|
top = eleDims.offset.top >= eleDims.windowDims.offset.top;
|
|
left = eleDims.offset.left >= eleDims.windowDims.offset.left;
|
|
right = eleDims.offset.left + eleDims.width <= eleDims.windowDims.width;
|
|
}
|
|
|
|
var allDirs = [bottom, top, left, right];
|
|
|
|
if (lrOnly) {
|
|
return left === right === true;
|
|
}
|
|
|
|
if (tbOnly) {
|
|
return top === bottom === true;
|
|
}
|
|
|
|
return allDirs.indexOf(false) === -1;
|
|
};
|
|
|
|
/**
|
|
* Uses native methods to return an object of dimension values.
|
|
* @function
|
|
* @param {jQuery || HTML} element - jQuery object or DOM element for which to get the dimensions. Can be any element other that document or window.
|
|
* @returns {Object} - nested object of integer pixel values
|
|
* TODO - if element is window, return only those values.
|
|
*/
|
|
function GetDimensions(elem, test) {
|
|
elem = elem.length ? elem[0] : elem;
|
|
|
|
if (elem === window || elem === document) {
|
|
throw new Error("I'm sorry, Dave. I'm afraid I can't do that.");
|
|
}
|
|
|
|
var rect = elem.getBoundingClientRect(),
|
|
parRect = elem.parentNode.getBoundingClientRect(),
|
|
winRect = document.body.getBoundingClientRect(),
|
|
winY = window.pageYOffset,
|
|
winX = window.pageXOffset;
|
|
|
|
return {
|
|
width: rect.width,
|
|
height: rect.height,
|
|
offset: {
|
|
top: rect.top + winY,
|
|
left: rect.left + winX
|
|
},
|
|
parentDims: {
|
|
width: parRect.width,
|
|
height: parRect.height,
|
|
offset: {
|
|
top: parRect.top + winY,
|
|
left: parRect.left + winX
|
|
}
|
|
},
|
|
windowDims: {
|
|
width: winRect.width,
|
|
height: winRect.height,
|
|
offset: {
|
|
top: winY,
|
|
left: winX
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Returns an object of top and left integer pixel values for dynamically rendered elements,
|
|
* such as: Tooltip, Reveal, and Dropdown
|
|
* @function
|
|
* @param {jQuery} element - jQuery object for the element being positioned.
|
|
* @param {jQuery} anchor - jQuery object for the element's anchor point.
|
|
* @param {String} position - a string relating to the desired position of the element, relative to it's anchor
|
|
* @param {Number} vOffset - integer pixel value of desired vertical separation between anchor and element.
|
|
* @param {Number} hOffset - integer pixel value of desired horizontal separation between anchor and element.
|
|
* @param {Boolean} isOverflow - if a collision event is detected, sets to true to default the element to full width - any desired offset.
|
|
* TODO alter/rewrite to work with `em` values as well/instead of pixels
|
|
*/
|
|
function GetOffsets(element, anchor, position, vOffset, hOffset, isOverflow) {
|
|
var $eleDims = GetDimensions(element),
|
|
$anchorDims = anchor ? GetDimensions(anchor) : null;
|
|
|
|
switch (position) {
|
|
case 'top':
|
|
return {
|
|
left: Foundation.rtl() ? $anchorDims.offset.left - $eleDims.width + $anchorDims.width : $anchorDims.offset.left,
|
|
top: $anchorDims.offset.top - ($eleDims.height + vOffset)
|
|
};
|
|
break;
|
|
case 'left':
|
|
return {
|
|
left: $anchorDims.offset.left - ($eleDims.width + hOffset),
|
|
top: $anchorDims.offset.top
|
|
};
|
|
break;
|
|
case 'right':
|
|
return {
|
|
left: $anchorDims.offset.left + $anchorDims.width + hOffset,
|
|
top: $anchorDims.offset.top
|
|
};
|
|
break;
|
|
case 'center top':
|
|
return {
|
|
left: $anchorDims.offset.left + $anchorDims.width / 2 - $eleDims.width / 2,
|
|
top: $anchorDims.offset.top - ($eleDims.height + vOffset)
|
|
};
|
|
break;
|
|
case 'center bottom':
|
|
return {
|
|
left: isOverflow ? hOffset : $anchorDims.offset.left + $anchorDims.width / 2 - $eleDims.width / 2,
|
|
top: $anchorDims.offset.top + $anchorDims.height + vOffset
|
|
};
|
|
break;
|
|
case 'center left':
|
|
return {
|
|
left: $anchorDims.offset.left - ($eleDims.width + hOffset),
|
|
top: $anchorDims.offset.top + $anchorDims.height / 2 - $eleDims.height / 2
|
|
};
|
|
break;
|
|
case 'center right':
|
|
return {
|
|
left: $anchorDims.offset.left + $anchorDims.width + hOffset + 1,
|
|
top: $anchorDims.offset.top + $anchorDims.height / 2 - $eleDims.height / 2
|
|
};
|
|
break;
|
|
case 'center':
|
|
return {
|
|
left: $eleDims.windowDims.offset.left + $eleDims.windowDims.width / 2 - $eleDims.width / 2,
|
|
top: $eleDims.windowDims.offset.top + $eleDims.windowDims.height / 2 - $eleDims.height / 2
|
|
};
|
|
break;
|
|
case 'reveal':
|
|
return {
|
|
left: ($eleDims.windowDims.width - $eleDims.width) / 2,
|
|
top: $eleDims.windowDims.offset.top + vOffset
|
|
};
|
|
case 'reveal full':
|
|
return {
|
|
left: $eleDims.windowDims.offset.left,
|
|
top: $eleDims.windowDims.offset.top
|
|
};
|
|
break;
|
|
case 'left bottom':
|
|
return {
|
|
left: $anchorDims.offset.left,
|
|
top: $anchorDims.offset.top + $anchorDims.height
|
|
};
|
|
break;
|
|
case 'right bottom':
|
|
return {
|
|
left: $anchorDims.offset.left + $anchorDims.width + hOffset - $eleDims.width,
|
|
top: $anchorDims.offset.top + $anchorDims.height
|
|
};
|
|
break;
|
|
default:
|
|
return {
|
|
left: Foundation.rtl() ? $anchorDims.offset.left - $eleDims.width + $anchorDims.width : $anchorDims.offset.left + hOffset,
|
|
top: $anchorDims.offset.top + $anchorDims.height + vOffset
|
|
};
|
|
}
|
|
}
|
|
}(jQuery);
|
|
/*******************************************
|
|
* *
|
|
* This util was created by Marius Olbertz *
|
|
* Please thank Marius on GitHub /owlbertz *
|
|
* or the web http://www.mariusolbertz.de/ *
|
|
* *
|
|
******************************************/
|
|
|
|
'use strict';
|
|
|
|
!function ($) {
|
|
|
|
var keyCodes = {
|
|
9: 'TAB',
|
|
13: 'ENTER',
|
|
27: 'ESCAPE',
|
|
32: 'SPACE',
|
|
37: 'ARROW_LEFT',
|
|
38: 'ARROW_UP',
|
|
39: 'ARROW_RIGHT',
|
|
40: 'ARROW_DOWN'
|
|
};
|
|
|
|
var commands = {};
|
|
|
|
var Keyboard = {
|
|
keys: getKeyCodes(keyCodes),
|
|
|
|
/**
|
|
* Parses the (keyboard) event and returns a String that represents its key
|
|
* Can be used like Foundation.parseKey(event) === Foundation.keys.SPACE
|
|
* @param {Event} event - the event generated by the event handler
|
|
* @return String key - String that represents the key pressed
|
|
*/
|
|
parseKey: function (event) {
|
|
var key = keyCodes[event.which || event.keyCode] || String.fromCharCode(event.which).toUpperCase();
|
|
if (event.shiftKey) key = 'SHIFT_' + key;
|
|
if (event.ctrlKey) key = 'CTRL_' + key;
|
|
if (event.altKey) key = 'ALT_' + key;
|
|
return key;
|
|
},
|
|
|
|
|
|
/**
|
|
* Handles the given (keyboard) event
|
|
* @param {Event} event - the event generated by the event handler
|
|
* @param {String} component - Foundation component's name, e.g. Slider or Reveal
|
|
* @param {Objects} functions - collection of functions that are to be executed
|
|
*/
|
|
handleKey: function (event, component, functions) {
|
|
var commandList = commands[component],
|
|
keyCode = this.parseKey(event),
|
|
cmds,
|
|
command,
|
|
fn;
|
|
|
|
if (!commandList) return console.warn('Component not defined!');
|
|
|
|
if (typeof commandList.ltr === 'undefined') {
|
|
// this component does not differentiate between ltr and rtl
|
|
cmds = commandList; // use plain list
|
|
} else {
|
|
// merge ltr and rtl: if document is rtl, rtl overwrites ltr and vice versa
|
|
if (Foundation.rtl()) cmds = $.extend({}, commandList.ltr, commandList.rtl);else cmds = $.extend({}, commandList.rtl, commandList.ltr);
|
|
}
|
|
command = cmds[keyCode];
|
|
|
|
fn = functions[command];
|
|
if (fn && typeof fn === 'function') {
|
|
// execute function if exists
|
|
var returnValue = fn.apply();
|
|
if (functions.handled || typeof functions.handled === 'function') {
|
|
// execute function when event was handled
|
|
functions.handled(returnValue);
|
|
}
|
|
} else {
|
|
if (functions.unhandled || typeof functions.unhandled === 'function') {
|
|
// execute function when event was not handled
|
|
functions.unhandled();
|
|
}
|
|
}
|
|
},
|
|
|
|
|
|
/**
|
|
* Finds all focusable elements within the given `$element`
|
|
* @param {jQuery} $element - jQuery object to search within
|
|
* @return {jQuery} $focusable - all focusable elements within `$element`
|
|
*/
|
|
findFocusable: function ($element) {
|
|
return $element.find('a[href], area[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, *[tabindex], *[contenteditable]').filter(function () {
|
|
if (!$(this).is(':visible') || $(this).attr('tabindex') < 0) {
|
|
return false;
|
|
} //only have visible elements and those that have a tabindex greater or equal 0
|
|
return true;
|
|
});
|
|
},
|
|
|
|
|
|
/**
|
|
* Returns the component name name
|
|
* @param {Object} component - Foundation component, e.g. Slider or Reveal
|
|
* @return String componentName
|
|
*/
|
|
|
|
register: function (componentName, cmds) {
|
|
commands[componentName] = cmds;
|
|
}
|
|
};
|
|
|
|
/*
|
|
* Constants for easier comparing.
|
|
* Can be used like Foundation.parseKey(event) === Foundation.keys.SPACE
|
|
*/
|
|
function getKeyCodes(kcs) {
|
|
var k = {};
|
|
for (var kc in kcs) {
|
|
k[kcs[kc]] = kcs[kc];
|
|
}return k;
|
|
}
|
|
|
|
Foundation.Keyboard = Keyboard;
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
!function ($) {
|
|
|
|
// Default set of media queries
|
|
var defaultQueries = {
|
|
'default': 'only screen',
|
|
landscape: 'only screen and (orientation: landscape)',
|
|
portrait: 'only screen and (orientation: portrait)',
|
|
retina: 'only screen and (-webkit-min-device-pixel-ratio: 2),' + 'only screen and (min--moz-device-pixel-ratio: 2),' + 'only screen and (-o-min-device-pixel-ratio: 2/1),' + 'only screen and (min-device-pixel-ratio: 2),' + 'only screen and (min-resolution: 192dpi),' + 'only screen and (min-resolution: 2dppx)'
|
|
};
|
|
|
|
var MediaQuery = {
|
|
queries: [],
|
|
|
|
current: '',
|
|
|
|
/**
|
|
* Initializes the media query helper, by extracting the breakpoint list from the CSS and activating the breakpoint watcher.
|
|
* @function
|
|
* @private
|
|
*/
|
|
_init: function () {
|
|
var self = this;
|
|
var extractedStyles = $('.foundation-mq').css('font-family');
|
|
var namedQueries;
|
|
|
|
namedQueries = parseStyleToObject(extractedStyles);
|
|
|
|
for (var key in namedQueries) {
|
|
if (namedQueries.hasOwnProperty(key)) {
|
|
self.queries.push({
|
|
name: key,
|
|
value: 'only screen and (min-width: ' + namedQueries[key] + ')'
|
|
});
|
|
}
|
|
}
|
|
|
|
this.current = this._getCurrentSize();
|
|
|
|
this._watcher();
|
|
},
|
|
|
|
|
|
/**
|
|
* Checks if the screen is at least as wide as a breakpoint.
|
|
* @function
|
|
* @param {String} size - Name of the breakpoint to check.
|
|
* @returns {Boolean} `true` if the breakpoint matches, `false` if it's smaller.
|
|
*/
|
|
atLeast: function (size) {
|
|
var query = this.get(size);
|
|
|
|
if (query) {
|
|
return window.matchMedia(query).matches;
|
|
}
|
|
|
|
return false;
|
|
},
|
|
|
|
|
|
/**
|
|
* Gets the media query of a breakpoint.
|
|
* @function
|
|
* @param {String} size - Name of the breakpoint to get.
|
|
* @returns {String|null} - The media query of the breakpoint, or `null` if the breakpoint doesn't exist.
|
|
*/
|
|
get: function (size) {
|
|
for (var i in this.queries) {
|
|
if (this.queries.hasOwnProperty(i)) {
|
|
var query = this.queries[i];
|
|
if (size === query.name) return query.value;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
},
|
|
|
|
|
|
/**
|
|
* Gets the current breakpoint name by testing every breakpoint and returning the last one to match (the biggest one).
|
|
* @function
|
|
* @private
|
|
* @returns {String} Name of the current breakpoint.
|
|
*/
|
|
_getCurrentSize: function () {
|
|
var matched;
|
|
|
|
for (var i = 0; i < this.queries.length; i++) {
|
|
var query = this.queries[i];
|
|
|
|
if (window.matchMedia(query.value).matches) {
|
|
matched = query;
|
|
}
|
|
}
|
|
|
|
if (typeof matched === 'object') {
|
|
return matched.name;
|
|
} else {
|
|
return matched;
|
|
}
|
|
},
|
|
|
|
|
|
/**
|
|
* Activates the breakpoint watcher, which fires an event on the window whenever the breakpoint changes.
|
|
* @function
|
|
* @private
|
|
*/
|
|
_watcher: function () {
|
|
var _this = this;
|
|
|
|
$(window).on('resize.zf.mediaquery', function () {
|
|
var newSize = _this._getCurrentSize(),
|
|
currentSize = _this.current;
|
|
|
|
if (newSize !== currentSize) {
|
|
// Change the current media query
|
|
_this.current = newSize;
|
|
|
|
// Broadcast the media query change on the window
|
|
$(window).trigger('changed.zf.mediaquery', [newSize, currentSize]);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
Foundation.MediaQuery = MediaQuery;
|
|
|
|
// matchMedia() polyfill - Test a CSS media type/query in JS.
|
|
// Authors & copyright (c) 2012: Scott Jehl, Paul Irish, Nicholas Zakas, David Knight. Dual MIT/BSD license
|
|
window.matchMedia || (window.matchMedia = function () {
|
|
'use strict';
|
|
|
|
// For browsers that support matchMedium api such as IE 9 and webkit
|
|
|
|
var styleMedia = window.styleMedia || window.media;
|
|
|
|
// For those that don't support matchMedium
|
|
if (!styleMedia) {
|
|
var style = document.createElement('style'),
|
|
script = document.getElementsByTagName('script')[0],
|
|
info = null;
|
|
|
|
style.type = 'text/css';
|
|
style.id = 'matchmediajs-test';
|
|
|
|
script && script.parentNode && script.parentNode.insertBefore(style, script);
|
|
|
|
// 'style.currentStyle' is used by IE <= 8 and 'window.getComputedStyle' for all other browsers
|
|
info = 'getComputedStyle' in window && window.getComputedStyle(style, null) || style.currentStyle;
|
|
|
|
styleMedia = {
|
|
matchMedium: function (media) {
|
|
var text = '@media ' + media + '{ #matchmediajs-test { width: 1px; } }';
|
|
|
|
// 'style.styleSheet' is used by IE <= 8 and 'style.textContent' for all other browsers
|
|
if (style.styleSheet) {
|
|
style.styleSheet.cssText = text;
|
|
} else {
|
|
style.textContent = text;
|
|
}
|
|
|
|
// Test if media query is true or false
|
|
return info.width === '1px';
|
|
}
|
|
};
|
|
}
|
|
|
|
return function (media) {
|
|
return {
|
|
matches: styleMedia.matchMedium(media || 'all'),
|
|
media: media || 'all'
|
|
};
|
|
};
|
|
}());
|
|
|
|
// Thank you: https://github.com/sindresorhus/query-string
|
|
function parseStyleToObject(str) {
|
|
var styleObject = {};
|
|
|
|
if (typeof str !== 'string') {
|
|
return styleObject;
|
|
}
|
|
|
|
str = str.trim().slice(1, -1); // browsers re-quote string style values
|
|
|
|
if (!str) {
|
|
return styleObject;
|
|
}
|
|
|
|
styleObject = str.split('&').reduce(function (ret, param) {
|
|
var parts = param.replace(/\+/g, ' ').split('=');
|
|
var key = parts[0];
|
|
var val = parts[1];
|
|
key = decodeURIComponent(key);
|
|
|
|
// missing `=` should be `null`:
|
|
// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
|
|
val = val === undefined ? null : decodeURIComponent(val);
|
|
|
|
if (!ret.hasOwnProperty(key)) {
|
|
ret[key] = val;
|
|
} else if (Array.isArray(ret[key])) {
|
|
ret[key].push(val);
|
|
} else {
|
|
ret[key] = [ret[key], val];
|
|
}
|
|
return ret;
|
|
}, {});
|
|
|
|
return styleObject;
|
|
}
|
|
|
|
Foundation.MediaQuery = MediaQuery;
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* Motion module.
|
|
* @module foundation.motion
|
|
*/
|
|
|
|
var initClasses = ['mui-enter', 'mui-leave'];
|
|
var activeClasses = ['mui-enter-active', 'mui-leave-active'];
|
|
|
|
var Motion = {
|
|
animateIn: function (element, animation, cb) {
|
|
animate(true, element, animation, cb);
|
|
},
|
|
|
|
animateOut: function (element, animation, cb) {
|
|
animate(false, element, animation, cb);
|
|
}
|
|
};
|
|
|
|
function Move(duration, elem, fn) {
|
|
var anim,
|
|
prog,
|
|
start = null;
|
|
// console.log('called');
|
|
|
|
function move(ts) {
|
|
if (!start) start = window.performance.now();
|
|
// console.log(start, ts);
|
|
prog = ts - start;
|
|
fn.apply(elem);
|
|
|
|
if (prog < duration) {
|
|
anim = window.requestAnimationFrame(move, elem);
|
|
} else {
|
|
window.cancelAnimationFrame(anim);
|
|
elem.trigger('finished.zf.animate', [elem]).triggerHandler('finished.zf.animate', [elem]);
|
|
}
|
|
}
|
|
anim = window.requestAnimationFrame(move);
|
|
}
|
|
|
|
/**
|
|
* Animates an element in or out using a CSS transition class.
|
|
* @function
|
|
* @private
|
|
* @param {Boolean} isIn - Defines if the animation is in or out.
|
|
* @param {Object} element - jQuery or HTML object to animate.
|
|
* @param {String} animation - CSS class to use.
|
|
* @param {Function} cb - Callback to run when animation is finished.
|
|
*/
|
|
function animate(isIn, element, animation, cb) {
|
|
element = $(element).eq(0);
|
|
|
|
if (!element.length) return;
|
|
|
|
var initClass = isIn ? initClasses[0] : initClasses[1];
|
|
var activeClass = isIn ? activeClasses[0] : activeClasses[1];
|
|
|
|
// Set up the animation
|
|
reset();
|
|
|
|
element.addClass(animation).css('transition', 'none');
|
|
|
|
requestAnimationFrame(function () {
|
|
element.addClass(initClass);
|
|
if (isIn) element.show();
|
|
});
|
|
|
|
// Start the animation
|
|
requestAnimationFrame(function () {
|
|
element[0].offsetWidth;
|
|
element.css('transition', '').addClass(activeClass);
|
|
});
|
|
|
|
// Clean up the animation when it finishes
|
|
element.one(Foundation.transitionend(element), finish);
|
|
|
|
// Hides the element (for out animations), resets the element, and runs a callback
|
|
function finish() {
|
|
if (!isIn) element.hide();
|
|
reset();
|
|
if (cb) cb.apply(element);
|
|
}
|
|
|
|
// Resets transitions and removes motion-specific classes
|
|
function reset() {
|
|
element[0].style.transitionDuration = 0;
|
|
element.removeClass(initClass + ' ' + activeClass + ' ' + animation);
|
|
}
|
|
}
|
|
|
|
Foundation.Move = Move;
|
|
Foundation.Motion = Motion;
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
!function ($) {
|
|
|
|
var Nest = {
|
|
Feather: function (menu) {
|
|
var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'zf';
|
|
|
|
menu.attr('role', 'menubar');
|
|
|
|
var items = menu.find('li').attr({ 'role': 'menuitem' }),
|
|
subMenuClass = 'is-' + type + '-submenu',
|
|
subItemClass = subMenuClass + '-item',
|
|
hasSubClass = 'is-' + type + '-submenu-parent';
|
|
|
|
menu.find('a:first').attr('tabindex', 0);
|
|
|
|
items.each(function () {
|
|
var $item = $(this),
|
|
$sub = $item.children('ul');
|
|
|
|
if ($sub.length) {
|
|
$item.addClass(hasSubClass).attr({
|
|
'aria-haspopup': true,
|
|
'aria-expanded': false,
|
|
'aria-label': $item.children('a:first').text()
|
|
});
|
|
|
|
$sub.addClass('submenu ' + subMenuClass).attr({
|
|
'data-submenu': '',
|
|
'aria-hidden': true,
|
|
'role': 'menu'
|
|
});
|
|
}
|
|
|
|
if ($item.parent('[data-submenu]').length) {
|
|
$item.addClass('is-submenu-item ' + subItemClass);
|
|
}
|
|
});
|
|
|
|
return;
|
|
},
|
|
Burn: function (menu, type) {
|
|
var items = menu.find('li').removeAttr('tabindex'),
|
|
subMenuClass = 'is-' + type + '-submenu',
|
|
subItemClass = subMenuClass + '-item',
|
|
hasSubClass = 'is-' + type + '-submenu-parent';
|
|
|
|
menu.find('>li, .menu, .menu > li').removeClass(subMenuClass + ' ' + subItemClass + ' ' + hasSubClass + ' is-submenu-item submenu is-active').removeAttr('data-submenu').css('display', '');
|
|
|
|
// console.log( menu.find('.' + subMenuClass + ', .' + subItemClass + ', .has-submenu, .is-submenu-item, .submenu, [data-submenu]')
|
|
// .removeClass(subMenuClass + ' ' + subItemClass + ' has-submenu is-submenu-item submenu')
|
|
// .removeAttr('data-submenu'));
|
|
// items.each(function(){
|
|
// var $item = $(this),
|
|
// $sub = $item.children('ul');
|
|
// if($item.parent('[data-submenu]').length){
|
|
// $item.removeClass('is-submenu-item ' + subItemClass);
|
|
// }
|
|
// if($sub.length){
|
|
// $item.removeClass('has-submenu');
|
|
// $sub.removeClass('submenu ' + subMenuClass).removeAttr('data-submenu');
|
|
// }
|
|
// });
|
|
}
|
|
};
|
|
|
|
Foundation.Nest = Nest;
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
!function ($) {
|
|
|
|
function Timer(elem, options, cb) {
|
|
var _this = this,
|
|
duration = options.duration,
|
|
//options is an object for easily adding features later.
|
|
nameSpace = Object.keys(elem.data())[0] || 'timer',
|
|
remain = -1,
|
|
start,
|
|
timer;
|
|
|
|
this.isPaused = false;
|
|
|
|
this.restart = function () {
|
|
remain = -1;
|
|
clearTimeout(timer);
|
|
this.start();
|
|
};
|
|
|
|
this.start = function () {
|
|
this.isPaused = false;
|
|
// if(!elem.data('paused')){ return false; }//maybe implement this sanity check if used for other things.
|
|
clearTimeout(timer);
|
|
remain = remain <= 0 ? duration : remain;
|
|
elem.data('paused', false);
|
|
start = Date.now();
|
|
timer = setTimeout(function () {
|
|
if (options.infinite) {
|
|
_this.restart(); //rerun the timer.
|
|
}
|
|
if (cb && typeof cb === 'function') {
|
|
cb();
|
|
}
|
|
}, remain);
|
|
elem.trigger('timerstart.zf.' + nameSpace);
|
|
};
|
|
|
|
this.pause = function () {
|
|
this.isPaused = true;
|
|
//if(elem.data('paused')){ return false; }//maybe implement this sanity check if used for other things.
|
|
clearTimeout(timer);
|
|
elem.data('paused', true);
|
|
var end = Date.now();
|
|
remain = remain - (end - start);
|
|
elem.trigger('timerpaused.zf.' + nameSpace);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Runs a callback function when images are fully loaded.
|
|
* @param {Object} images - Image(s) to check if loaded.
|
|
* @param {Func} callback - Function to execute when image is fully loaded.
|
|
*/
|
|
function onImagesLoaded(images, callback) {
|
|
var self = this,
|
|
unloaded = images.length;
|
|
|
|
if (unloaded === 0) {
|
|
callback();
|
|
}
|
|
|
|
images.each(function () {
|
|
if (this.complete) {
|
|
singleImageLoaded();
|
|
} else if (typeof this.naturalWidth !== 'undefined' && this.naturalWidth > 0) {
|
|
singleImageLoaded();
|
|
} else {
|
|
$(this).one('load', function () {
|
|
singleImageLoaded();
|
|
});
|
|
}
|
|
});
|
|
|
|
function singleImageLoaded() {
|
|
unloaded--;
|
|
if (unloaded === 0) {
|
|
callback();
|
|
}
|
|
}
|
|
}
|
|
|
|
Foundation.Timer = Timer;
|
|
Foundation.onImagesLoaded = onImagesLoaded;
|
|
}(jQuery);
|
|
//**************************************************
|
|
//**Work inspired by multiple jquery swipe plugins**
|
|
//**Done by Yohai Ararat ***************************
|
|
//**************************************************
|
|
(function ($) {
|
|
|
|
$.spotSwipe = {
|
|
version: '1.0.0',
|
|
enabled: 'ontouchstart' in document.documentElement,
|
|
preventDefault: false,
|
|
moveThreshold: 75,
|
|
timeThreshold: 200
|
|
};
|
|
|
|
var startPosX,
|
|
startPosY,
|
|
startTime,
|
|
elapsedTime,
|
|
isMoving = false;
|
|
|
|
function onTouchEnd() {
|
|
// alert(this);
|
|
this.removeEventListener('touchmove', onTouchMove);
|
|
this.removeEventListener('touchend', onTouchEnd);
|
|
isMoving = false;
|
|
}
|
|
|
|
function onTouchMove(e) {
|
|
if ($.spotSwipe.preventDefault) {
|
|
e.preventDefault();
|
|
}
|
|
if (isMoving) {
|
|
var x = e.touches[0].pageX;
|
|
var y = e.touches[0].pageY;
|
|
var dx = startPosX - x;
|
|
var dy = startPosY - y;
|
|
var dir;
|
|
elapsedTime = new Date().getTime() - startTime;
|
|
if (Math.abs(dx) >= $.spotSwipe.moveThreshold && elapsedTime <= $.spotSwipe.timeThreshold) {
|
|
dir = dx > 0 ? 'left' : 'right';
|
|
}
|
|
// else if(Math.abs(dy) >= $.spotSwipe.moveThreshold && elapsedTime <= $.spotSwipe.timeThreshold) {
|
|
// dir = dy > 0 ? 'down' : 'up';
|
|
// }
|
|
if (dir) {
|
|
e.preventDefault();
|
|
onTouchEnd.call(this);
|
|
$(this).trigger('swipe', dir).trigger('swipe' + dir);
|
|
}
|
|
}
|
|
}
|
|
|
|
function onTouchStart(e) {
|
|
if (e.touches.length == 1) {
|
|
startPosX = e.touches[0].pageX;
|
|
startPosY = e.touches[0].pageY;
|
|
isMoving = true;
|
|
startTime = new Date().getTime();
|
|
this.addEventListener('touchmove', onTouchMove, false);
|
|
this.addEventListener('touchend', onTouchEnd, false);
|
|
}
|
|
}
|
|
|
|
function init() {
|
|
this.addEventListener && this.addEventListener('touchstart', onTouchStart, false);
|
|
}
|
|
|
|
function teardown() {
|
|
this.removeEventListener('touchstart', onTouchStart);
|
|
}
|
|
|
|
$.event.special.swipe = { setup: init };
|
|
|
|
$.each(['left', 'up', 'down', 'right'], function () {
|
|
$.event.special['swipe' + this] = { setup: function () {
|
|
$(this).on('swipe', $.noop);
|
|
} };
|
|
});
|
|
})(jQuery);
|
|
/****************************************************
|
|
* Method for adding psuedo drag events to elements *
|
|
***************************************************/
|
|
!function ($) {
|
|
$.fn.addTouch = function () {
|
|
this.each(function (i, el) {
|
|
$(el).bind('touchstart touchmove touchend touchcancel', function () {
|
|
//we pass the original event object because the jQuery event
|
|
//object is normalized to w3c specs and does not provide the TouchList
|
|
handleTouch(event);
|
|
});
|
|
});
|
|
|
|
var handleTouch = function (event) {
|
|
var touches = event.changedTouches,
|
|
first = touches[0],
|
|
eventTypes = {
|
|
touchstart: 'mousedown',
|
|
touchmove: 'mousemove',
|
|
touchend: 'mouseup'
|
|
},
|
|
type = eventTypes[event.type],
|
|
simulatedEvent;
|
|
|
|
if ('MouseEvent' in window && typeof window.MouseEvent === 'function') {
|
|
simulatedEvent = new window.MouseEvent(type, {
|
|
'bubbles': true,
|
|
'cancelable': true,
|
|
'screenX': first.screenX,
|
|
'screenY': first.screenY,
|
|
'clientX': first.clientX,
|
|
'clientY': first.clientY
|
|
});
|
|
} else {
|
|
simulatedEvent = document.createEvent('MouseEvent');
|
|
simulatedEvent.initMouseEvent(type, true, true, window, 1, first.screenX, first.screenY, first.clientX, first.clientY, false, false, false, false, 0 /*left*/, null);
|
|
}
|
|
first.target.dispatchEvent(simulatedEvent);
|
|
};
|
|
};
|
|
}(jQuery);
|
|
|
|
//**********************************
|
|
//**From the jQuery Mobile Library**
|
|
//**need to recreate functionality**
|
|
//**and try to improve if possible**
|
|
//**********************************
|
|
|
|
/* Removing the jQuery function ****
|
|
************************************
|
|
|
|
(function( $, window, undefined ) {
|
|
|
|
var $document = $( document ),
|
|
// supportTouch = $.mobile.support.touch,
|
|
touchStartEvent = 'touchstart'//supportTouch ? "touchstart" : "mousedown",
|
|
touchStopEvent = 'touchend'//supportTouch ? "touchend" : "mouseup",
|
|
touchMoveEvent = 'touchmove'//supportTouch ? "touchmove" : "mousemove";
|
|
|
|
// setup new event shortcuts
|
|
$.each( ( "touchstart touchmove touchend " +
|
|
"swipe swipeleft swiperight" ).split( " " ), function( i, name ) {
|
|
|
|
$.fn[ name ] = function( fn ) {
|
|
return fn ? this.bind( name, fn ) : this.trigger( name );
|
|
};
|
|
|
|
// jQuery < 1.8
|
|
if ( $.attrFn ) {
|
|
$.attrFn[ name ] = true;
|
|
}
|
|
});
|
|
|
|
function triggerCustomEvent( obj, eventType, event, bubble ) {
|
|
var originalType = event.type;
|
|
event.type = eventType;
|
|
if ( bubble ) {
|
|
$.event.trigger( event, undefined, obj );
|
|
} else {
|
|
$.event.dispatch.call( obj, event );
|
|
}
|
|
event.type = originalType;
|
|
}
|
|
|
|
// also handles taphold
|
|
|
|
// Also handles swipeleft, swiperight
|
|
$.event.special.swipe = {
|
|
|
|
// More than this horizontal displacement, and we will suppress scrolling.
|
|
scrollSupressionThreshold: 30,
|
|
|
|
// More time than this, and it isn't a swipe.
|
|
durationThreshold: 1000,
|
|
|
|
// Swipe horizontal displacement must be more than this.
|
|
horizontalDistanceThreshold: window.devicePixelRatio >= 2 ? 15 : 30,
|
|
|
|
// Swipe vertical displacement must be less than this.
|
|
verticalDistanceThreshold: window.devicePixelRatio >= 2 ? 15 : 30,
|
|
|
|
getLocation: function ( event ) {
|
|
var winPageX = window.pageXOffset,
|
|
winPageY = window.pageYOffset,
|
|
x = event.clientX,
|
|
y = event.clientY;
|
|
|
|
if ( event.pageY === 0 && Math.floor( y ) > Math.floor( event.pageY ) ||
|
|
event.pageX === 0 && Math.floor( x ) > Math.floor( event.pageX ) ) {
|
|
|
|
// iOS4 clientX/clientY have the value that should have been
|
|
// in pageX/pageY. While pageX/page/ have the value 0
|
|
x = x - winPageX;
|
|
y = y - winPageY;
|
|
} else if ( y < ( event.pageY - winPageY) || x < ( event.pageX - winPageX ) ) {
|
|
|
|
// Some Android browsers have totally bogus values for clientX/Y
|
|
// when scrolling/zooming a page. Detectable since clientX/clientY
|
|
// should never be smaller than pageX/pageY minus page scroll
|
|
x = event.pageX - winPageX;
|
|
y = event.pageY - winPageY;
|
|
}
|
|
|
|
return {
|
|
x: x,
|
|
y: y
|
|
};
|
|
},
|
|
|
|
start: function( event ) {
|
|
var data = event.originalEvent.touches ?
|
|
event.originalEvent.touches[ 0 ] : event,
|
|
location = $.event.special.swipe.getLocation( data );
|
|
return {
|
|
time: ( new Date() ).getTime(),
|
|
coords: [ location.x, location.y ],
|
|
origin: $( event.target )
|
|
};
|
|
},
|
|
|
|
stop: function( event ) {
|
|
var data = event.originalEvent.touches ?
|
|
event.originalEvent.touches[ 0 ] : event,
|
|
location = $.event.special.swipe.getLocation( data );
|
|
return {
|
|
time: ( new Date() ).getTime(),
|
|
coords: [ location.x, location.y ]
|
|
};
|
|
},
|
|
|
|
handleSwipe: function( start, stop, thisObject, origTarget ) {
|
|
if ( stop.time - start.time < $.event.special.swipe.durationThreshold &&
|
|
Math.abs( start.coords[ 0 ] - stop.coords[ 0 ] ) > $.event.special.swipe.horizontalDistanceThreshold &&
|
|
Math.abs( start.coords[ 1 ] - stop.coords[ 1 ] ) < $.event.special.swipe.verticalDistanceThreshold ) {
|
|
var direction = start.coords[0] > stop.coords[ 0 ] ? "swipeleft" : "swiperight";
|
|
|
|
triggerCustomEvent( thisObject, "swipe", $.Event( "swipe", { target: origTarget, swipestart: start, swipestop: stop }), true );
|
|
triggerCustomEvent( thisObject, direction,$.Event( direction, { target: origTarget, swipestart: start, swipestop: stop } ), true );
|
|
return true;
|
|
}
|
|
return false;
|
|
|
|
},
|
|
|
|
// This serves as a flag to ensure that at most one swipe event event is
|
|
// in work at any given time
|
|
eventInProgress: false,
|
|
|
|
setup: function() {
|
|
var events,
|
|
thisObject = this,
|
|
$this = $( thisObject ),
|
|
context = {};
|
|
|
|
// Retrieve the events data for this element and add the swipe context
|
|
events = $.data( this, "mobile-events" );
|
|
if ( !events ) {
|
|
events = { length: 0 };
|
|
$.data( this, "mobile-events", events );
|
|
}
|
|
events.length++;
|
|
events.swipe = context;
|
|
|
|
context.start = function( event ) {
|
|
|
|
// Bail if we're already working on a swipe event
|
|
if ( $.event.special.swipe.eventInProgress ) {
|
|
return;
|
|
}
|
|
$.event.special.swipe.eventInProgress = true;
|
|
|
|
var stop,
|
|
start = $.event.special.swipe.start( event ),
|
|
origTarget = event.target,
|
|
emitted = false;
|
|
|
|
context.move = function( event ) {
|
|
if ( !start || event.isDefaultPrevented() ) {
|
|
return;
|
|
}
|
|
|
|
stop = $.event.special.swipe.stop( event );
|
|
if ( !emitted ) {
|
|
emitted = $.event.special.swipe.handleSwipe( start, stop, thisObject, origTarget );
|
|
if ( emitted ) {
|
|
|
|
// Reset the context to make way for the next swipe event
|
|
$.event.special.swipe.eventInProgress = false;
|
|
}
|
|
}
|
|
// prevent scrolling
|
|
if ( Math.abs( start.coords[ 0 ] - stop.coords[ 0 ] ) > $.event.special.swipe.scrollSupressionThreshold ) {
|
|
event.preventDefault();
|
|
}
|
|
};
|
|
|
|
context.stop = function() {
|
|
emitted = true;
|
|
|
|
// Reset the context to make way for the next swipe event
|
|
$.event.special.swipe.eventInProgress = false;
|
|
$document.off( touchMoveEvent, context.move );
|
|
context.move = null;
|
|
};
|
|
|
|
$document.on( touchMoveEvent, context.move )
|
|
.one( touchStopEvent, context.stop );
|
|
};
|
|
$this.on( touchStartEvent, context.start );
|
|
},
|
|
|
|
teardown: function() {
|
|
var events, context;
|
|
|
|
events = $.data( this, "mobile-events" );
|
|
if ( events ) {
|
|
context = events.swipe;
|
|
delete events.swipe;
|
|
events.length--;
|
|
if ( events.length === 0 ) {
|
|
$.removeData( this, "mobile-events" );
|
|
}
|
|
}
|
|
|
|
if ( context ) {
|
|
if ( context.start ) {
|
|
$( this ).off( touchStartEvent, context.start );
|
|
}
|
|
if ( context.move ) {
|
|
$document.off( touchMoveEvent, context.move );
|
|
}
|
|
if ( context.stop ) {
|
|
$document.off( touchStopEvent, context.stop );
|
|
}
|
|
}
|
|
}
|
|
};
|
|
$.each({
|
|
swipeleft: "swipe.left",
|
|
swiperight: "swipe.right"
|
|
}, function( event, sourceEvent ) {
|
|
|
|
$.event.special[ event ] = {
|
|
setup: function() {
|
|
$( this ).bind( sourceEvent, $.noop );
|
|
},
|
|
teardown: function() {
|
|
$( this ).unbind( sourceEvent );
|
|
}
|
|
};
|
|
});
|
|
})( jQuery, this );
|
|
*/
|
|
'use strict';
|
|
|
|
!function ($) {
|
|
|
|
var MutationObserver = function () {
|
|
var prefixes = ['WebKit', 'Moz', 'O', 'Ms', ''];
|
|
for (var i = 0; i < prefixes.length; i++) {
|
|
if (prefixes[i] + 'MutationObserver' in window) {
|
|
return window[prefixes[i] + 'MutationObserver'];
|
|
}
|
|
}
|
|
return false;
|
|
}();
|
|
|
|
var triggers = function (el, type) {
|
|
el.data(type).split(' ').forEach(function (id) {
|
|
$('#' + id)[type === 'close' ? 'trigger' : 'triggerHandler'](type + '.zf.trigger', [el]);
|
|
});
|
|
};
|
|
// Elements with [data-open] will reveal a plugin that supports it when clicked.
|
|
$(document).on('click.zf.trigger', '[data-open]', function () {
|
|
triggers($(this), 'open');
|
|
});
|
|
|
|
// Elements with [data-close] will close a plugin that supports it when clicked.
|
|
// If used without a value on [data-close], the event will bubble, allowing it to close a parent component.
|
|
$(document).on('click.zf.trigger', '[data-close]', function () {
|
|
var id = $(this).data('close');
|
|
if (id) {
|
|
triggers($(this), 'close');
|
|
} else {
|
|
$(this).trigger('close.zf.trigger');
|
|
}
|
|
});
|
|
|
|
// Elements with [data-toggle] will toggle a plugin that supports it when clicked.
|
|
$(document).on('click.zf.trigger', '[data-toggle]', function () {
|
|
triggers($(this), 'toggle');
|
|
});
|
|
|
|
// Elements with [data-closable] will respond to close.zf.trigger events.
|
|
$(document).on('close.zf.trigger', '[data-closable]', function (e) {
|
|
e.stopPropagation();
|
|
var animation = $(this).data('closable');
|
|
|
|
if (animation !== '') {
|
|
Foundation.Motion.animateOut($(this), animation, function () {
|
|
$(this).trigger('closed.zf');
|
|
});
|
|
} else {
|
|
$(this).fadeOut().trigger('closed.zf');
|
|
}
|
|
});
|
|
|
|
$(document).on('focus.zf.trigger blur.zf.trigger', '[data-toggle-focus]', function () {
|
|
var id = $(this).data('toggle-focus');
|
|
$('#' + id).triggerHandler('toggle.zf.trigger', [$(this)]);
|
|
});
|
|
|
|
/**
|
|
* Fires once after all other scripts have loaded
|
|
* @function
|
|
* @private
|
|
*/
|
|
$(window).on('load', function () {
|
|
checkListeners();
|
|
});
|
|
|
|
function checkListeners() {
|
|
eventsListener();
|
|
resizeListener();
|
|
scrollListener();
|
|
closemeListener();
|
|
}
|
|
|
|
//******** only fires this function once on load, if there's something to watch ********
|
|
function closemeListener(pluginName) {
|
|
var yetiBoxes = $('[data-yeti-box]'),
|
|
plugNames = ['dropdown', 'tooltip', 'reveal'];
|
|
|
|
if (pluginName) {
|
|
if (typeof pluginName === 'string') {
|
|
plugNames.push(pluginName);
|
|
} else if (typeof pluginName === 'object' && typeof pluginName[0] === 'string') {
|
|
plugNames.concat(pluginName);
|
|
} else {
|
|
console.error('Plugin names must be strings');
|
|
}
|
|
}
|
|
if (yetiBoxes.length) {
|
|
var listeners = plugNames.map(function (name) {
|
|
return 'closeme.zf.' + name;
|
|
}).join(' ');
|
|
|
|
$(window).off(listeners).on(listeners, function (e, pluginId) {
|
|
var plugin = e.namespace.split('.')[0];
|
|
var plugins = $('[data-' + plugin + ']').not('[data-yeti-box="' + pluginId + '"]');
|
|
|
|
plugins.each(function () {
|
|
var _this = $(this);
|
|
|
|
_this.triggerHandler('close.zf.trigger', [_this]);
|
|
});
|
|
});
|
|
}
|
|
}
|
|
|
|
function resizeListener(debounce) {
|
|
var timer = void 0,
|
|
$nodes = $('[data-resize]');
|
|
if ($nodes.length) {
|
|
$(window).off('resize.zf.trigger').on('resize.zf.trigger', function (e) {
|
|
if (timer) {
|
|
clearTimeout(timer);
|
|
}
|
|
|
|
timer = setTimeout(function () {
|
|
|
|
if (!MutationObserver) {
|
|
//fallback for IE 9
|
|
$nodes.each(function () {
|
|
$(this).triggerHandler('resizeme.zf.trigger');
|
|
});
|
|
}
|
|
//trigger all listening elements and signal a resize event
|
|
$nodes.attr('data-events', "resize");
|
|
}, debounce || 10); //default time to emit resize event
|
|
});
|
|
}
|
|
}
|
|
|
|
function scrollListener(debounce) {
|
|
var timer = void 0,
|
|
$nodes = $('[data-scroll]');
|
|
if ($nodes.length) {
|
|
$(window).off('scroll.zf.trigger').on('scroll.zf.trigger', function (e) {
|
|
if (timer) {
|
|
clearTimeout(timer);
|
|
}
|
|
|
|
timer = setTimeout(function () {
|
|
|
|
if (!MutationObserver) {
|
|
//fallback for IE 9
|
|
$nodes.each(function () {
|
|
$(this).triggerHandler('scrollme.zf.trigger');
|
|
});
|
|
}
|
|
//trigger all listening elements and signal a scroll event
|
|
$nodes.attr('data-events', "scroll");
|
|
}, debounce || 10); //default time to emit scroll event
|
|
});
|
|
}
|
|
}
|
|
|
|
function eventsListener() {
|
|
if (!MutationObserver) {
|
|
return false;
|
|
}
|
|
var nodes = document.querySelectorAll('[data-resize], [data-scroll], [data-mutate]');
|
|
|
|
//element callback
|
|
var listeningElementsMutation = function (mutationRecordsList) {
|
|
var $target = $(mutationRecordsList[0].target);
|
|
//trigger the event handler for the element depending on type
|
|
switch ($target.attr("data-events")) {
|
|
|
|
case "resize":
|
|
$target.triggerHandler('resizeme.zf.trigger', [$target]);
|
|
break;
|
|
|
|
case "scroll":
|
|
$target.triggerHandler('scrollme.zf.trigger', [$target, window.pageYOffset]);
|
|
break;
|
|
|
|
// case "mutate" :
|
|
// console.log('mutate', $target);
|
|
// $target.triggerHandler('mutate.zf.trigger');
|
|
//
|
|
// //make sure we don't get stuck in an infinite loop from sloppy codeing
|
|
// if ($target.index('[data-mutate]') == $("[data-mutate]").length-1) {
|
|
// domMutationObserver();
|
|
// }
|
|
// break;
|
|
|
|
default:
|
|
return false;
|
|
//nothing
|
|
}
|
|
};
|
|
|
|
if (nodes.length) {
|
|
//for each element that needs to listen for resizing, scrolling, (or coming soon mutation) add a single observer
|
|
for (var i = 0; i <= nodes.length - 1; i++) {
|
|
var elementObserver = new MutationObserver(listeningElementsMutation);
|
|
elementObserver.observe(nodes[i], { attributes: true, childList: false, characterData: false, subtree: false, attributeFilter: ["data-events"] });
|
|
}
|
|
}
|
|
}
|
|
|
|
// ------------------------------------
|
|
|
|
// [PH]
|
|
// Foundation.CheckWatchers = checkWatchers;
|
|
Foundation.IHearYou = checkListeners;
|
|
// Foundation.ISeeYou = scrollListener;
|
|
// Foundation.IFeelYou = closemeListener;
|
|
}(jQuery);
|
|
|
|
// function domMutationObserver(debounce) {
|
|
// // !!! This is coming soon and needs more work; not active !!! //
|
|
// var timer,
|
|
// nodes = document.querySelectorAll('[data-mutate]');
|
|
// //
|
|
// if (nodes.length) {
|
|
// // var MutationObserver = (function () {
|
|
// // var prefixes = ['WebKit', 'Moz', 'O', 'Ms', ''];
|
|
// // for (var i=0; i < prefixes.length; i++) {
|
|
// // if (prefixes[i] + 'MutationObserver' in window) {
|
|
// // return window[prefixes[i] + 'MutationObserver'];
|
|
// // }
|
|
// // }
|
|
// // return false;
|
|
// // }());
|
|
//
|
|
//
|
|
// //for the body, we need to listen for all changes effecting the style and class attributes
|
|
// var bodyObserver = new MutationObserver(bodyMutation);
|
|
// bodyObserver.observe(document.body, { attributes: true, childList: true, characterData: false, subtree:true, attributeFilter:["style", "class"]});
|
|
//
|
|
//
|
|
// //body callback
|
|
// function bodyMutation(mutate) {
|
|
// //trigger all listening elements and signal a mutation event
|
|
// if (timer) { clearTimeout(timer); }
|
|
//
|
|
// timer = setTimeout(function() {
|
|
// bodyObserver.disconnect();
|
|
// $('[data-mutate]').attr('data-events',"mutate");
|
|
// }, debounce || 150);
|
|
// }
|
|
// }
|
|
// }
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* Abide module.
|
|
* @module foundation.abide
|
|
*/
|
|
|
|
var Abide = function () {
|
|
/**
|
|
* Creates a new instance of Abide.
|
|
* @class
|
|
* @fires Abide#init
|
|
* @param {Object} element - jQuery object to add the trigger to.
|
|
* @param {Object} options - Overrides to the default plugin settings.
|
|
*/
|
|
function Abide(element) {
|
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
|
|
_classCallCheck(this, Abide);
|
|
|
|
this.$element = element;
|
|
this.options = $.extend({}, Abide.defaults, this.$element.data(), options);
|
|
|
|
this._init();
|
|
|
|
Foundation.registerPlugin(this, 'Abide');
|
|
}
|
|
|
|
/**
|
|
* Initializes the Abide plugin and calls functions to get Abide functioning on load.
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(Abide, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
this.$inputs = this.$element.find('input, textarea, select');
|
|
|
|
this._events();
|
|
}
|
|
|
|
/**
|
|
* Initializes events for Abide.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events() {
|
|
var _this2 = this;
|
|
|
|
this.$element.off('.abide').on('reset.zf.abide', function () {
|
|
_this2.resetForm();
|
|
}).on('submit.zf.abide', function () {
|
|
return _this2.validateForm();
|
|
});
|
|
|
|
if (this.options.validateOn === 'fieldChange') {
|
|
this.$inputs.off('change.zf.abide').on('change.zf.abide', function (e) {
|
|
_this2.validateInput($(e.target));
|
|
});
|
|
}
|
|
|
|
if (this.options.liveValidate) {
|
|
this.$inputs.off('input.zf.abide').on('input.zf.abide', function (e) {
|
|
_this2.validateInput($(e.target));
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calls necessary functions to update Abide upon DOM change
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_reflow',
|
|
value: function _reflow() {
|
|
this._init();
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not a form element has the required attribute and if it's checked or not
|
|
* @param {Object} element - jQuery object to check for required attribute
|
|
* @returns {Boolean} Boolean value depends on whether or not attribute is checked or empty
|
|
*/
|
|
|
|
}, {
|
|
key: 'requiredCheck',
|
|
value: function requiredCheck($el) {
|
|
if (!$el.attr('required')) return true;
|
|
|
|
var isGood = true;
|
|
|
|
switch ($el[0].type) {
|
|
case 'checkbox':
|
|
isGood = $el[0].checked;
|
|
break;
|
|
|
|
case 'select':
|
|
case 'select-one':
|
|
case 'select-multiple':
|
|
var opt = $el.find('option:selected');
|
|
if (!opt.length || !opt.val()) isGood = false;
|
|
break;
|
|
|
|
default:
|
|
if (!$el.val() || !$el.val().length) isGood = false;
|
|
}
|
|
|
|
return isGood;
|
|
}
|
|
|
|
/**
|
|
* Based on $el, get the first element with selector in this order:
|
|
* 1. The element's direct sibling('s).
|
|
* 3. The element's parent's children.
|
|
*
|
|
* This allows for multiple form errors per input, though if none are found, no form errors will be shown.
|
|
*
|
|
* @param {Object} $el - jQuery object to use as reference to find the form error selector.
|
|
* @returns {Object} jQuery object with the selector.
|
|
*/
|
|
|
|
}, {
|
|
key: 'findFormError',
|
|
value: function findFormError($el) {
|
|
var $error = $el.siblings(this.options.formErrorSelector);
|
|
|
|
if (!$error.length) {
|
|
$error = $el.parent().find(this.options.formErrorSelector);
|
|
}
|
|
|
|
return $error;
|
|
}
|
|
|
|
/**
|
|
* Get the first element in this order:
|
|
* 2. The <label> with the attribute `[for="someInputId"]`
|
|
* 3. The `.closest()` <label>
|
|
*
|
|
* @param {Object} $el - jQuery object to check for required attribute
|
|
* @returns {Boolean} Boolean value depends on whether or not attribute is checked or empty
|
|
*/
|
|
|
|
}, {
|
|
key: 'findLabel',
|
|
value: function findLabel($el) {
|
|
var id = $el[0].id;
|
|
var $label = this.$element.find('label[for="' + id + '"]');
|
|
|
|
if (!$label.length) {
|
|
return $el.closest('label');
|
|
}
|
|
|
|
return $label;
|
|
}
|
|
|
|
/**
|
|
* Get the set of labels associated with a set of radio els in this order
|
|
* 2. The <label> with the attribute `[for="someInputId"]`
|
|
* 3. The `.closest()` <label>
|
|
*
|
|
* @param {Object} $el - jQuery object to check for required attribute
|
|
* @returns {Boolean} Boolean value depends on whether or not attribute is checked or empty
|
|
*/
|
|
|
|
}, {
|
|
key: 'findRadioLabels',
|
|
value: function findRadioLabels($els) {
|
|
var _this3 = this;
|
|
|
|
var labels = $els.map(function (i, el) {
|
|
var id = el.id;
|
|
var $label = _this3.$element.find('label[for="' + id + '"]');
|
|
|
|
if (!$label.length) {
|
|
$label = $(el).closest('label');
|
|
}
|
|
return $label[0];
|
|
});
|
|
|
|
return $(labels);
|
|
}
|
|
|
|
/**
|
|
* Adds the CSS error class as specified by the Abide settings to the label, input, and the form
|
|
* @param {Object} $el - jQuery object to add the class to
|
|
*/
|
|
|
|
}, {
|
|
key: 'addErrorClasses',
|
|
value: function addErrorClasses($el) {
|
|
var $label = this.findLabel($el);
|
|
var $formError = this.findFormError($el);
|
|
|
|
if ($label.length) {
|
|
$label.addClass(this.options.labelErrorClass);
|
|
}
|
|
|
|
if ($formError.length) {
|
|
$formError.addClass(this.options.formErrorClass);
|
|
}
|
|
|
|
$el.addClass(this.options.inputErrorClass).attr('data-invalid', '');
|
|
}
|
|
|
|
/**
|
|
* Remove CSS error classes etc from an entire radio button group
|
|
* @param {String} groupName - A string that specifies the name of a radio button group
|
|
*
|
|
*/
|
|
|
|
}, {
|
|
key: 'removeRadioErrorClasses',
|
|
value: function removeRadioErrorClasses(groupName) {
|
|
var $els = this.$element.find(':radio[name="' + groupName + '"]');
|
|
var $labels = this.findRadioLabels($els);
|
|
var $formErrors = this.findFormError($els);
|
|
|
|
if ($labels.length) {
|
|
$labels.removeClass(this.options.labelErrorClass);
|
|
}
|
|
|
|
if ($formErrors.length) {
|
|
$formErrors.removeClass(this.options.formErrorClass);
|
|
}
|
|
|
|
$els.removeClass(this.options.inputErrorClass).removeAttr('data-invalid');
|
|
}
|
|
|
|
/**
|
|
* Removes CSS error class as specified by the Abide settings from the label, input, and the form
|
|
* @param {Object} $el - jQuery object to remove the class from
|
|
*/
|
|
|
|
}, {
|
|
key: 'removeErrorClasses',
|
|
value: function removeErrorClasses($el) {
|
|
// radios need to clear all of the els
|
|
if ($el[0].type == 'radio') {
|
|
return this.removeRadioErrorClasses($el.attr('name'));
|
|
}
|
|
|
|
var $label = this.findLabel($el);
|
|
var $formError = this.findFormError($el);
|
|
|
|
if ($label.length) {
|
|
$label.removeClass(this.options.labelErrorClass);
|
|
}
|
|
|
|
if ($formError.length) {
|
|
$formError.removeClass(this.options.formErrorClass);
|
|
}
|
|
|
|
$el.removeClass(this.options.inputErrorClass).removeAttr('data-invalid');
|
|
}
|
|
|
|
/**
|
|
* Goes through a form to find inputs and proceeds to validate them in ways specific to their type
|
|
* @fires Abide#invalid
|
|
* @fires Abide#valid
|
|
* @param {Object} element - jQuery object to validate, should be an HTML input
|
|
* @returns {Boolean} goodToGo - If the input is valid or not.
|
|
*/
|
|
|
|
}, {
|
|
key: 'validateInput',
|
|
value: function validateInput($el) {
|
|
var clearRequire = this.requiredCheck($el),
|
|
validated = false,
|
|
customValidator = true,
|
|
validator = $el.attr('data-validator'),
|
|
equalTo = true;
|
|
|
|
// don't validate ignored inputs or hidden inputs
|
|
if ($el.is('[data-abide-ignore]') || $el.is('[type="hidden"]')) {
|
|
return true;
|
|
}
|
|
|
|
switch ($el[0].type) {
|
|
case 'radio':
|
|
validated = this.validateRadio($el.attr('name'));
|
|
break;
|
|
|
|
case 'checkbox':
|
|
validated = clearRequire;
|
|
break;
|
|
|
|
case 'select':
|
|
case 'select-one':
|
|
case 'select-multiple':
|
|
validated = clearRequire;
|
|
break;
|
|
|
|
default:
|
|
validated = this.validateText($el);
|
|
}
|
|
|
|
if (validator) {
|
|
customValidator = this.matchValidation($el, validator, $el.attr('required'));
|
|
}
|
|
|
|
if ($el.attr('data-equalto')) {
|
|
equalTo = this.options.validators.equalTo($el);
|
|
}
|
|
|
|
var goodToGo = [clearRequire, validated, customValidator, equalTo].indexOf(false) === -1;
|
|
var message = (goodToGo ? 'valid' : 'invalid') + '.zf.abide';
|
|
|
|
this[goodToGo ? 'removeErrorClasses' : 'addErrorClasses']($el);
|
|
|
|
/**
|
|
* Fires when the input is done checking for validation. Event trigger is either `valid.zf.abide` or `invalid.zf.abide`
|
|
* Trigger includes the DOM element of the input.
|
|
* @event Abide#valid
|
|
* @event Abide#invalid
|
|
*/
|
|
$el.trigger(message, [$el]);
|
|
|
|
return goodToGo;
|
|
}
|
|
|
|
/**
|
|
* Goes through a form and if there are any invalid inputs, it will display the form error element
|
|
* @returns {Boolean} noError - true if no errors were detected...
|
|
* @fires Abide#formvalid
|
|
* @fires Abide#forminvalid
|
|
*/
|
|
|
|
}, {
|
|
key: 'validateForm',
|
|
value: function validateForm() {
|
|
var acc = [];
|
|
var _this = this;
|
|
|
|
this.$inputs.each(function () {
|
|
acc.push(_this.validateInput($(this)));
|
|
});
|
|
|
|
var noError = acc.indexOf(false) === -1;
|
|
|
|
this.$element.find('[data-abide-error]').css('display', noError ? 'none' : 'block');
|
|
|
|
/**
|
|
* Fires when the form is finished validating. Event trigger is either `formvalid.zf.abide` or `forminvalid.zf.abide`.
|
|
* Trigger includes the element of the form.
|
|
* @event Abide#formvalid
|
|
* @event Abide#forminvalid
|
|
*/
|
|
this.$element.trigger((noError ? 'formvalid' : 'forminvalid') + '.zf.abide', [this.$element]);
|
|
|
|
return noError;
|
|
}
|
|
|
|
/**
|
|
* Determines whether or a not a text input is valid based on the pattern specified in the attribute. If no matching pattern is found, returns true.
|
|
* @param {Object} $el - jQuery object to validate, should be a text input HTML element
|
|
* @param {String} pattern - string value of one of the RegEx patterns in Abide.options.patterns
|
|
* @returns {Boolean} Boolean value depends on whether or not the input value matches the pattern specified
|
|
*/
|
|
|
|
}, {
|
|
key: 'validateText',
|
|
value: function validateText($el, pattern) {
|
|
// A pattern can be passed to this function, or it will be infered from the input's "pattern" attribute, or it's "type" attribute
|
|
pattern = pattern || $el.attr('pattern') || $el.attr('type');
|
|
var inputText = $el.val();
|
|
var valid = false;
|
|
|
|
if (inputText.length) {
|
|
// If the pattern attribute on the element is in Abide's list of patterns, then test that regexp
|
|
if (this.options.patterns.hasOwnProperty(pattern)) {
|
|
valid = this.options.patterns[pattern].test(inputText);
|
|
}
|
|
// If the pattern name isn't also the type attribute of the field, then test it as a regexp
|
|
else if (pattern !== $el.attr('type')) {
|
|
valid = new RegExp(pattern).test(inputText);
|
|
} else {
|
|
valid = true;
|
|
}
|
|
}
|
|
// An empty field is valid if it's not required
|
|
else if (!$el.prop('required')) {
|
|
valid = true;
|
|
}
|
|
|
|
return valid;
|
|
}
|
|
|
|
/**
|
|
* Determines whether or a not a radio input is valid based on whether or not it is required and selected. Although the function targets a single `<input>`, it validates by checking the `required` and `checked` properties of all radio buttons in its group.
|
|
* @param {String} groupName - A string that specifies the name of a radio button group
|
|
* @returns {Boolean} Boolean value depends on whether or not at least one radio input has been selected (if it's required)
|
|
*/
|
|
|
|
}, {
|
|
key: 'validateRadio',
|
|
value: function validateRadio(groupName) {
|
|
// If at least one radio in the group has the `required` attribute, the group is considered required
|
|
// Per W3C spec, all radio buttons in a group should have `required`, but we're being nice
|
|
var $group = this.$element.find(':radio[name="' + groupName + '"]');
|
|
var valid = false,
|
|
required = false;
|
|
|
|
// For the group to be required, at least one radio needs to be required
|
|
$group.each(function (i, e) {
|
|
if ($(e).attr('required')) {
|
|
required = true;
|
|
}
|
|
});
|
|
if (!required) valid = true;
|
|
|
|
if (!valid) {
|
|
// For the group to be valid, at least one radio needs to be checked
|
|
$group.each(function (i, e) {
|
|
if ($(e).prop('checked')) {
|
|
valid = true;
|
|
}
|
|
});
|
|
};
|
|
|
|
return valid;
|
|
}
|
|
|
|
/**
|
|
* Determines if a selected input passes a custom validation function. Multiple validations can be used, if passed to the element with `data-validator="foo bar baz"` in a space separated listed.
|
|
* @param {Object} $el - jQuery input element.
|
|
* @param {String} validators - a string of function names matching functions in the Abide.options.validators object.
|
|
* @param {Boolean} required - self explanatory?
|
|
* @returns {Boolean} - true if validations passed.
|
|
*/
|
|
|
|
}, {
|
|
key: 'matchValidation',
|
|
value: function matchValidation($el, validators, required) {
|
|
var _this4 = this;
|
|
|
|
required = required ? true : false;
|
|
|
|
var clear = validators.split(' ').map(function (v) {
|
|
return _this4.options.validators[v]($el, required, $el.parent());
|
|
});
|
|
return clear.indexOf(false) === -1;
|
|
}
|
|
|
|
/**
|
|
* Resets form inputs and styles
|
|
* @fires Abide#formreset
|
|
*/
|
|
|
|
}, {
|
|
key: 'resetForm',
|
|
value: function resetForm() {
|
|
var $form = this.$element,
|
|
opts = this.options;
|
|
|
|
$('.' + opts.labelErrorClass, $form).not('small').removeClass(opts.labelErrorClass);
|
|
$('.' + opts.inputErrorClass, $form).not('small').removeClass(opts.inputErrorClass);
|
|
$(opts.formErrorSelector + '.' + opts.formErrorClass).removeClass(opts.formErrorClass);
|
|
$form.find('[data-abide-error]').css('display', 'none');
|
|
$(':input', $form).not(':button, :submit, :reset, :hidden, :radio, :checkbox, [data-abide-ignore]').val('').removeAttr('data-invalid');
|
|
$(':input:radio', $form).not('[data-abide-ignore]').prop('checked', false).removeAttr('data-invalid');
|
|
$(':input:checkbox', $form).not('[data-abide-ignore]').prop('checked', false).removeAttr('data-invalid');
|
|
/**
|
|
* Fires when the form has been reset.
|
|
* @event Abide#formreset
|
|
*/
|
|
$form.trigger('formreset.zf.abide', [$form]);
|
|
}
|
|
|
|
/**
|
|
* Destroys an instance of Abide.
|
|
* Removes error styles and classes from elements, without resetting their values.
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
var _this = this;
|
|
this.$element.off('.abide').find('[data-abide-error]').css('display', 'none');
|
|
|
|
this.$inputs.off('.abide').each(function () {
|
|
_this.removeErrorClasses($(this));
|
|
});
|
|
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return Abide;
|
|
}();
|
|
|
|
/**
|
|
* Default settings for plugin
|
|
*/
|
|
|
|
|
|
Abide.defaults = {
|
|
/**
|
|
* The default event to validate inputs. Checkboxes and radios validate immediately.
|
|
* Remove or change this value for manual validation.
|
|
* @option
|
|
* @example 'fieldChange'
|
|
*/
|
|
validateOn: 'fieldChange',
|
|
|
|
/**
|
|
* Class to be applied to input labels on failed validation.
|
|
* @option
|
|
* @example 'is-invalid-label'
|
|
*/
|
|
labelErrorClass: 'is-invalid-label',
|
|
|
|
/**
|
|
* Class to be applied to inputs on failed validation.
|
|
* @option
|
|
* @example 'is-invalid-input'
|
|
*/
|
|
inputErrorClass: 'is-invalid-input',
|
|
|
|
/**
|
|
* Class selector to use to target Form Errors for show/hide.
|
|
* @option
|
|
* @example '.form-error'
|
|
*/
|
|
formErrorSelector: '.form-error',
|
|
|
|
/**
|
|
* Class added to Form Errors on failed validation.
|
|
* @option
|
|
* @example 'is-visible'
|
|
*/
|
|
formErrorClass: 'is-visible',
|
|
|
|
/**
|
|
* Set to true to validate text inputs on any value change.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
liveValidate: false,
|
|
|
|
patterns: {
|
|
alpha: /^[a-zA-Z]+$/,
|
|
alpha_numeric: /^[a-zA-Z0-9]+$/,
|
|
integer: /^[-+]?\d+$/,
|
|
number: /^[-+]?\d*(?:[\.\,]\d+)?$/,
|
|
|
|
// amex, visa, diners
|
|
card: /^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\d{3})\d{11})$/,
|
|
cvv: /^([0-9]){3,4}$/,
|
|
|
|
// http://www.whatwg.org/specs/web-apps/current-work/multipage/states-of-the-type-attribute.html#valid-e-mail-address
|
|
email: /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+$/,
|
|
|
|
url: /^(https?|ftp|file|ssh):\/\/(((([a-zA-Z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-zA-Z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-zA-Z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-zA-Z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-zA-Z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-zA-Z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-zA-Z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-zA-Z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-zA-Z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-zA-Z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-zA-Z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-zA-Z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(\#((([a-zA-Z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$/,
|
|
// abc.de
|
|
domain: /^([a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,8}$/,
|
|
|
|
datetime: /^([0-2][0-9]{3})\-([0-1][0-9])\-([0-3][0-9])T([0-5][0-9])\:([0-5][0-9])\:([0-5][0-9])(Z|([\-\+]([0-1][0-9])\:00))$/,
|
|
// YYYY-MM-DD
|
|
date: /(?:19|20)[0-9]{2}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-9])|(?:(?!02)(?:0[1-9]|1[0-2])-(?:30))|(?:(?:0[13578]|1[02])-31))$/,
|
|
// HH:MM:SS
|
|
time: /^(0[0-9]|1[0-9]|2[0-3])(:[0-5][0-9]){2}$/,
|
|
dateISO: /^\d{4}[\/\-]\d{1,2}[\/\-]\d{1,2}$/,
|
|
// MM/DD/YYYY
|
|
month_day_year: /^(0[1-9]|1[012])[- \/.](0[1-9]|[12][0-9]|3[01])[- \/.]\d{4}$/,
|
|
// DD/MM/YYYY
|
|
day_month_year: /^(0[1-9]|[12][0-9]|3[01])[- \/.](0[1-9]|1[012])[- \/.]\d{4}$/,
|
|
|
|
// #FFF or #FFFFFF
|
|
color: /^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/
|
|
},
|
|
|
|
/**
|
|
* Optional validation functions to be used. `equalTo` being the only default included function.
|
|
* Functions should return only a boolean if the input is valid or not. Functions are given the following arguments:
|
|
* el : The jQuery element to validate.
|
|
* required : Boolean value of the required attribute be present or not.
|
|
* parent : The direct parent of the input.
|
|
* @option
|
|
*/
|
|
validators: {
|
|
equalTo: function (el, required, parent) {
|
|
return $('#' + el.attr('data-equalto')).val() === el.val();
|
|
}
|
|
}
|
|
};
|
|
|
|
// Window exports
|
|
Foundation.plugin(Abide, 'Abide');
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* Accordion module.
|
|
* @module foundation.accordion
|
|
* @requires foundation.util.keyboard
|
|
* @requires foundation.util.motion
|
|
*/
|
|
|
|
var Accordion = function () {
|
|
/**
|
|
* Creates a new instance of an accordion.
|
|
* @class
|
|
* @fires Accordion#init
|
|
* @param {jQuery} element - jQuery object to make into an accordion.
|
|
* @param {Object} options - a plain object with settings to override the default options.
|
|
*/
|
|
function Accordion(element, options) {
|
|
_classCallCheck(this, Accordion);
|
|
|
|
this.$element = element;
|
|
this.options = $.extend({}, Accordion.defaults, this.$element.data(), options);
|
|
|
|
this._init();
|
|
|
|
Foundation.registerPlugin(this, 'Accordion');
|
|
Foundation.Keyboard.register('Accordion', {
|
|
'ENTER': 'toggle',
|
|
'SPACE': 'toggle',
|
|
'ARROW_DOWN': 'next',
|
|
'ARROW_UP': 'previous'
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Initializes the accordion by animating the preset active pane(s).
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(Accordion, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
this.$element.attr('role', 'tablist');
|
|
this.$tabs = this.$element.children('li, [data-accordion-item]');
|
|
|
|
this.$tabs.each(function (idx, el) {
|
|
var $el = $(el),
|
|
$content = $el.children('[data-tab-content]'),
|
|
id = $content[0].id || Foundation.GetYoDigits(6, 'accordion'),
|
|
linkId = el.id || id + '-label';
|
|
|
|
$el.find('a:first').attr({
|
|
'aria-controls': id,
|
|
'role': 'tab',
|
|
'id': linkId,
|
|
'aria-expanded': false,
|
|
'aria-selected': false
|
|
});
|
|
|
|
$content.attr({ 'role': 'tabpanel', 'aria-labelledby': linkId, 'aria-hidden': true, 'id': id });
|
|
});
|
|
var $initActive = this.$element.find('.is-active').children('[data-tab-content]');
|
|
if ($initActive.length) {
|
|
this.down($initActive, true);
|
|
}
|
|
this._events();
|
|
}
|
|
|
|
/**
|
|
* Adds event handlers for items within the accordion.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events() {
|
|
var _this = this;
|
|
|
|
this.$tabs.each(function () {
|
|
var $elem = $(this);
|
|
var $tabContent = $elem.children('[data-tab-content]');
|
|
if ($tabContent.length) {
|
|
$elem.children('a').off('click.zf.accordion keydown.zf.accordion').on('click.zf.accordion', function (e) {
|
|
e.preventDefault();
|
|
_this.toggle($tabContent);
|
|
}).on('keydown.zf.accordion', function (e) {
|
|
Foundation.Keyboard.handleKey(e, 'Accordion', {
|
|
toggle: function () {
|
|
_this.toggle($tabContent);
|
|
},
|
|
next: function () {
|
|
var $a = $elem.next().find('a').focus();
|
|
if (!_this.options.multiExpand) {
|
|
$a.trigger('click.zf.accordion');
|
|
}
|
|
},
|
|
previous: function () {
|
|
var $a = $elem.prev().find('a').focus();
|
|
if (!_this.options.multiExpand) {
|
|
$a.trigger('click.zf.accordion');
|
|
}
|
|
},
|
|
handled: function () {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Toggles the selected content pane's open/close state.
|
|
* @param {jQuery} $target - jQuery object of the pane to toggle (`.accordion-content`).
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'toggle',
|
|
value: function toggle($target) {
|
|
if ($target.parent().hasClass('is-active')) {
|
|
this.up($target);
|
|
} else {
|
|
this.down($target);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Opens the accordion tab defined by `$target`.
|
|
* @param {jQuery} $target - Accordion pane to open (`.accordion-content`).
|
|
* @param {Boolean} firstTime - flag to determine if reflow should happen.
|
|
* @fires Accordion#down
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'down',
|
|
value: function down($target, firstTime) {
|
|
var _this2 = this;
|
|
|
|
$target.attr('aria-hidden', false).parent('[data-tab-content]').addBack().parent().addClass('is-active');
|
|
|
|
if (!this.options.multiExpand && !firstTime) {
|
|
var $currentActive = this.$element.children('.is-active').children('[data-tab-content]');
|
|
if ($currentActive.length) {
|
|
this.up($currentActive.not($target));
|
|
}
|
|
}
|
|
|
|
$target.slideDown(this.options.slideSpeed, function () {
|
|
/**
|
|
* Fires when the tab is done opening.
|
|
* @event Accordion#down
|
|
*/
|
|
_this2.$element.trigger('down.zf.accordion', [$target]);
|
|
});
|
|
|
|
$('#' + $target.attr('aria-labelledby')).attr({
|
|
'aria-expanded': true,
|
|
'aria-selected': true
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Closes the tab defined by `$target`.
|
|
* @param {jQuery} $target - Accordion tab to close (`.accordion-content`).
|
|
* @fires Accordion#up
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'up',
|
|
value: function up($target) {
|
|
var $aunts = $target.parent().siblings(),
|
|
_this = this;
|
|
|
|
if (!this.options.allowAllClosed && !$aunts.hasClass('is-active') || !$target.parent().hasClass('is-active')) {
|
|
return;
|
|
}
|
|
|
|
// Foundation.Move(this.options.slideSpeed, $target, function(){
|
|
$target.slideUp(_this.options.slideSpeed, function () {
|
|
/**
|
|
* Fires when the tab is done collapsing up.
|
|
* @event Accordion#up
|
|
*/
|
|
_this.$element.trigger('up.zf.accordion', [$target]);
|
|
});
|
|
// });
|
|
|
|
$target.attr('aria-hidden', true).parent().removeClass('is-active');
|
|
|
|
$('#' + $target.attr('aria-labelledby')).attr({
|
|
'aria-expanded': false,
|
|
'aria-selected': false
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Destroys an instance of an accordion.
|
|
* @fires Accordion#destroyed
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
this.$element.find('[data-tab-content]').stop(true).slideUp(0).css('display', '');
|
|
this.$element.find('a').off('.zf.accordion');
|
|
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return Accordion;
|
|
}();
|
|
|
|
Accordion.defaults = {
|
|
/**
|
|
* Amount of time to animate the opening of an accordion pane.
|
|
* @option
|
|
* @example 250
|
|
*/
|
|
slideSpeed: 250,
|
|
/**
|
|
* Allow the accordion to have multiple open panes.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
multiExpand: false,
|
|
/**
|
|
* Allow the accordion to close all panes.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
allowAllClosed: false
|
|
};
|
|
|
|
// Window exports
|
|
Foundation.plugin(Accordion, 'Accordion');
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* AccordionMenu module.
|
|
* @module foundation.accordionMenu
|
|
* @requires foundation.util.keyboard
|
|
* @requires foundation.util.motion
|
|
* @requires foundation.util.nest
|
|
*/
|
|
|
|
var AccordionMenu = function () {
|
|
/**
|
|
* Creates a new instance of an accordion menu.
|
|
* @class
|
|
* @fires AccordionMenu#init
|
|
* @param {jQuery} element - jQuery object to make into an accordion menu.
|
|
* @param {Object} options - Overrides to the default plugin settings.
|
|
*/
|
|
function AccordionMenu(element, options) {
|
|
_classCallCheck(this, AccordionMenu);
|
|
|
|
this.$element = element;
|
|
this.options = $.extend({}, AccordionMenu.defaults, this.$element.data(), options);
|
|
|
|
Foundation.Nest.Feather(this.$element, 'accordion');
|
|
|
|
this._init();
|
|
|
|
Foundation.registerPlugin(this, 'AccordionMenu');
|
|
Foundation.Keyboard.register('AccordionMenu', {
|
|
'ENTER': 'toggle',
|
|
'SPACE': 'toggle',
|
|
'ARROW_RIGHT': 'open',
|
|
'ARROW_UP': 'up',
|
|
'ARROW_DOWN': 'down',
|
|
'ARROW_LEFT': 'close',
|
|
'ESCAPE': 'closeAll'
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Initializes the accordion menu by hiding all nested menus.
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(AccordionMenu, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
this.$element.find('[data-submenu]').not('.is-active').slideUp(0); //.find('a').css('padding-left', '1rem');
|
|
this.$element.attr({
|
|
'role': 'menu',
|
|
'aria-multiselectable': this.options.multiOpen
|
|
});
|
|
|
|
this.$menuLinks = this.$element.find('.is-accordion-submenu-parent');
|
|
this.$menuLinks.each(function () {
|
|
var linkId = this.id || Foundation.GetYoDigits(6, 'acc-menu-link'),
|
|
$elem = $(this),
|
|
$sub = $elem.children('[data-submenu]'),
|
|
subId = $sub[0].id || Foundation.GetYoDigits(6, 'acc-menu'),
|
|
isActive = $sub.hasClass('is-active');
|
|
$elem.attr({
|
|
'aria-controls': subId,
|
|
'aria-expanded': isActive,
|
|
'role': 'menuitem',
|
|
'id': linkId
|
|
});
|
|
$sub.attr({
|
|
'aria-labelledby': linkId,
|
|
'aria-hidden': !isActive,
|
|
'role': 'menu',
|
|
'id': subId
|
|
});
|
|
});
|
|
var initPanes = this.$element.find('.is-active');
|
|
if (initPanes.length) {
|
|
var _this = this;
|
|
initPanes.each(function () {
|
|
_this.down($(this));
|
|
});
|
|
}
|
|
this._events();
|
|
}
|
|
|
|
/**
|
|
* Adds event handlers for items within the menu.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events() {
|
|
var _this = this;
|
|
|
|
this.$element.find('li').each(function () {
|
|
var $submenu = $(this).children('[data-submenu]');
|
|
|
|
if ($submenu.length) {
|
|
$(this).children('a').off('click.zf.accordionMenu').on('click.zf.accordionMenu', function (e) {
|
|
e.preventDefault();
|
|
|
|
_this.toggle($submenu);
|
|
});
|
|
}
|
|
}).on('keydown.zf.accordionmenu', function (e) {
|
|
var $element = $(this),
|
|
$elements = $element.parent('ul').children('li'),
|
|
$prevElement,
|
|
$nextElement,
|
|
$target = $element.children('[data-submenu]');
|
|
|
|
$elements.each(function (i) {
|
|
if ($(this).is($element)) {
|
|
$prevElement = $elements.eq(Math.max(0, i - 1)).find('a').first();
|
|
$nextElement = $elements.eq(Math.min(i + 1, $elements.length - 1)).find('a').first();
|
|
|
|
if ($(this).children('[data-submenu]:visible').length) {
|
|
// has open sub menu
|
|
$nextElement = $element.find('li:first-child').find('a').first();
|
|
}
|
|
if ($(this).is(':first-child')) {
|
|
// is first element of sub menu
|
|
$prevElement = $element.parents('li').first().find('a').first();
|
|
} else if ($prevElement.parents('li').first().children('[data-submenu]:visible').length) {
|
|
// if previous element has open sub menu
|
|
$prevElement = $prevElement.parents('li').find('li:last-child').find('a').first();
|
|
}
|
|
if ($(this).is(':last-child')) {
|
|
// is last element of sub menu
|
|
$nextElement = $element.parents('li').first().next('li').find('a').first();
|
|
}
|
|
|
|
return;
|
|
}
|
|
});
|
|
|
|
Foundation.Keyboard.handleKey(e, 'AccordionMenu', {
|
|
open: function () {
|
|
if ($target.is(':hidden')) {
|
|
_this.down($target);
|
|
$target.find('li').first().find('a').first().focus();
|
|
}
|
|
},
|
|
close: function () {
|
|
if ($target.length && !$target.is(':hidden')) {
|
|
// close active sub of this item
|
|
_this.up($target);
|
|
} else if ($element.parent('[data-submenu]').length) {
|
|
// close currently open sub
|
|
_this.up($element.parent('[data-submenu]'));
|
|
$element.parents('li').first().find('a').first().focus();
|
|
}
|
|
},
|
|
up: function () {
|
|
$prevElement.focus();
|
|
return true;
|
|
},
|
|
down: function () {
|
|
$nextElement.focus();
|
|
return true;
|
|
},
|
|
toggle: function () {
|
|
if ($element.children('[data-submenu]').length) {
|
|
_this.toggle($element.children('[data-submenu]'));
|
|
}
|
|
},
|
|
closeAll: function () {
|
|
_this.hideAll();
|
|
},
|
|
handled: function (preventDefault) {
|
|
if (preventDefault) {
|
|
e.preventDefault();
|
|
}
|
|
e.stopImmediatePropagation();
|
|
}
|
|
});
|
|
}); //.attr('tabindex', 0);
|
|
}
|
|
|
|
/**
|
|
* Closes all panes of the menu.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'hideAll',
|
|
value: function hideAll() {
|
|
this.$element.find('[data-submenu]').slideUp(this.options.slideSpeed);
|
|
}
|
|
|
|
/**
|
|
* Toggles the open/close state of a submenu.
|
|
* @function
|
|
* @param {jQuery} $target - the submenu to toggle
|
|
*/
|
|
|
|
}, {
|
|
key: 'toggle',
|
|
value: function toggle($target) {
|
|
if (!$target.is(':animated')) {
|
|
if (!$target.is(':hidden')) {
|
|
this.up($target);
|
|
} else {
|
|
this.down($target);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Opens the sub-menu defined by `$target`.
|
|
* @param {jQuery} $target - Sub-menu to open.
|
|
* @fires AccordionMenu#down
|
|
*/
|
|
|
|
}, {
|
|
key: 'down',
|
|
value: function down($target) {
|
|
var _this = this;
|
|
|
|
if (!this.options.multiOpen) {
|
|
this.up(this.$element.find('.is-active').not($target.parentsUntil(this.$element).add($target)));
|
|
}
|
|
|
|
$target.addClass('is-active').attr({ 'aria-hidden': false }).parent('.is-accordion-submenu-parent').attr({ 'aria-expanded': true });
|
|
|
|
//Foundation.Move(this.options.slideSpeed, $target, function() {
|
|
$target.slideDown(_this.options.slideSpeed, function () {
|
|
/**
|
|
* Fires when the menu is done opening.
|
|
* @event AccordionMenu#down
|
|
*/
|
|
_this.$element.trigger('down.zf.accordionMenu', [$target]);
|
|
});
|
|
//});
|
|
}
|
|
|
|
/**
|
|
* Closes the sub-menu defined by `$target`. All sub-menus inside the target will be closed as well.
|
|
* @param {jQuery} $target - Sub-menu to close.
|
|
* @fires AccordionMenu#up
|
|
*/
|
|
|
|
}, {
|
|
key: 'up',
|
|
value: function up($target) {
|
|
var _this = this;
|
|
//Foundation.Move(this.options.slideSpeed, $target, function(){
|
|
$target.slideUp(_this.options.slideSpeed, function () {
|
|
/**
|
|
* Fires when the menu is done collapsing up.
|
|
* @event AccordionMenu#up
|
|
*/
|
|
_this.$element.trigger('up.zf.accordionMenu', [$target]);
|
|
});
|
|
//});
|
|
|
|
var $menus = $target.find('[data-submenu]').slideUp(0).addBack().attr('aria-hidden', true);
|
|
|
|
$menus.parent('.is-accordion-submenu-parent').attr('aria-expanded', false);
|
|
}
|
|
|
|
/**
|
|
* Destroys an instance of accordion menu.
|
|
* @fires AccordionMenu#destroyed
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
this.$element.find('[data-submenu]').slideDown(0).css('display', '');
|
|
this.$element.find('a').off('click.zf.accordionMenu');
|
|
|
|
Foundation.Nest.Burn(this.$element, 'accordion');
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return AccordionMenu;
|
|
}();
|
|
|
|
AccordionMenu.defaults = {
|
|
/**
|
|
* Amount of time to animate the opening of a submenu in ms.
|
|
* @option
|
|
* @example 250
|
|
*/
|
|
slideSpeed: 250,
|
|
/**
|
|
* Allow the menu to have multiple open panes.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
multiOpen: true
|
|
};
|
|
|
|
// Window exports
|
|
Foundation.plugin(AccordionMenu, 'AccordionMenu');
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* Drilldown module.
|
|
* @module foundation.drilldown
|
|
* @requires foundation.util.keyboard
|
|
* @requires foundation.util.motion
|
|
* @requires foundation.util.nest
|
|
*/
|
|
|
|
var Drilldown = function () {
|
|
/**
|
|
* Creates a new instance of a drilldown menu.
|
|
* @class
|
|
* @param {jQuery} element - jQuery object to make into an accordion menu.
|
|
* @param {Object} options - Overrides to the default plugin settings.
|
|
*/
|
|
function Drilldown(element, options) {
|
|
_classCallCheck(this, Drilldown);
|
|
|
|
this.$element = element;
|
|
this.options = $.extend({}, Drilldown.defaults, this.$element.data(), options);
|
|
|
|
Foundation.Nest.Feather(this.$element, 'drilldown');
|
|
|
|
this._init();
|
|
|
|
Foundation.registerPlugin(this, 'Drilldown');
|
|
Foundation.Keyboard.register('Drilldown', {
|
|
'ENTER': 'open',
|
|
'SPACE': 'open',
|
|
'ARROW_RIGHT': 'next',
|
|
'ARROW_UP': 'up',
|
|
'ARROW_DOWN': 'down',
|
|
'ARROW_LEFT': 'previous',
|
|
'ESCAPE': 'close',
|
|
'TAB': 'down',
|
|
'SHIFT_TAB': 'up'
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Initializes the drilldown by creating jQuery collections of elements
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(Drilldown, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
this.$submenuAnchors = this.$element.find('li.is-drilldown-submenu-parent').children('a');
|
|
this.$submenus = this.$submenuAnchors.parent('li').children('[data-submenu]');
|
|
this.$menuItems = this.$element.find('li').not('.js-drilldown-back').attr('role', 'menuitem').find('a');
|
|
|
|
this._prepareMenu();
|
|
|
|
this._keyboardEvents();
|
|
}
|
|
|
|
/**
|
|
* prepares drilldown menu by setting attributes to links and elements
|
|
* sets a min height to prevent content jumping
|
|
* wraps the element if not already wrapped
|
|
* @private
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: '_prepareMenu',
|
|
value: function _prepareMenu() {
|
|
var _this = this;
|
|
// if(!this.options.holdOpen){
|
|
// this._menuLinkEvents();
|
|
// }
|
|
this.$submenuAnchors.each(function () {
|
|
var $link = $(this);
|
|
var $sub = $link.parent();
|
|
if (_this.options.parentLink) {
|
|
$link.clone().prependTo($sub.children('[data-submenu]')).wrap('<li class="is-submenu-parent-item is-submenu-item is-drilldown-submenu-item" role="menu-item"></li>');
|
|
}
|
|
$link.data('savedHref', $link.attr('href')).removeAttr('href').attr('tabindex', 0);
|
|
$link.children('[data-submenu]').attr({
|
|
'aria-hidden': true,
|
|
'tabindex': 0,
|
|
'role': 'menu'
|
|
});
|
|
_this._events($link);
|
|
});
|
|
this.$submenus.each(function () {
|
|
var $menu = $(this),
|
|
$back = $menu.find('.js-drilldown-back');
|
|
if (!$back.length) {
|
|
$menu.prepend(_this.options.backButton);
|
|
}
|
|
_this._back($menu);
|
|
});
|
|
if (!this.$element.parent().hasClass('is-drilldown')) {
|
|
this.$wrapper = $(this.options.wrapper).addClass('is-drilldown');
|
|
this.$wrapper = this.$element.wrap(this.$wrapper).parent().css(this._getMaxDims());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds event handlers to elements in the menu.
|
|
* @function
|
|
* @private
|
|
* @param {jQuery} $elem - the current menu item to add handlers to.
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events($elem) {
|
|
var _this = this;
|
|
|
|
$elem.off('click.zf.drilldown').on('click.zf.drilldown', function (e) {
|
|
if ($(e.target).parentsUntil('ul', 'li').hasClass('is-drilldown-submenu-parent')) {
|
|
e.stopImmediatePropagation();
|
|
e.preventDefault();
|
|
}
|
|
|
|
// if(e.target !== e.currentTarget.firstElementChild){
|
|
// return false;
|
|
// }
|
|
_this._show($elem.parent('li'));
|
|
|
|
if (_this.options.closeOnClick) {
|
|
var $body = $('body');
|
|
$body.off('.zf.drilldown').on('click.zf.drilldown', function (e) {
|
|
if (e.target === _this.$element[0] || $.contains(_this.$element[0], e.target)) {
|
|
return;
|
|
}
|
|
e.preventDefault();
|
|
_this._hideAll();
|
|
$body.off('.zf.drilldown');
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Adds keydown event listener to `li`'s in the menu.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_keyboardEvents',
|
|
value: function _keyboardEvents() {
|
|
var _this = this;
|
|
|
|
this.$menuItems.add(this.$element.find('.js-drilldown-back > a')).on('keydown.zf.drilldown', function (e) {
|
|
|
|
var $element = $(this),
|
|
$elements = $element.parent('li').parent('ul').children('li').children('a'),
|
|
$prevElement,
|
|
$nextElement;
|
|
|
|
$elements.each(function (i) {
|
|
if ($(this).is($element)) {
|
|
$prevElement = $elements.eq(Math.max(0, i - 1));
|
|
$nextElement = $elements.eq(Math.min(i + 1, $elements.length - 1));
|
|
return;
|
|
}
|
|
});
|
|
|
|
Foundation.Keyboard.handleKey(e, 'Drilldown', {
|
|
next: function () {
|
|
if ($element.is(_this.$submenuAnchors)) {
|
|
_this._show($element.parent('li'));
|
|
$element.parent('li').one(Foundation.transitionend($element), function () {
|
|
$element.parent('li').find('ul li a').filter(_this.$menuItems).first().focus();
|
|
});
|
|
return true;
|
|
}
|
|
},
|
|
previous: function () {
|
|
_this._hide($element.parent('li').parent('ul'));
|
|
$element.parent('li').parent('ul').one(Foundation.transitionend($element), function () {
|
|
setTimeout(function () {
|
|
$element.parent('li').parent('ul').parent('li').children('a').first().focus();
|
|
}, 1);
|
|
});
|
|
return true;
|
|
},
|
|
up: function () {
|
|
$prevElement.focus();
|
|
return true;
|
|
},
|
|
down: function () {
|
|
$nextElement.focus();
|
|
return true;
|
|
},
|
|
close: function () {
|
|
_this._back();
|
|
//_this.$menuItems.first().focus(); // focus to first element
|
|
},
|
|
open: function () {
|
|
if (!$element.is(_this.$menuItems)) {
|
|
// not menu item means back button
|
|
_this._hide($element.parent('li').parent('ul'));
|
|
$element.parent('li').parent('ul').one(Foundation.transitionend($element), function () {
|
|
setTimeout(function () {
|
|
$element.parent('li').parent('ul').parent('li').children('a').first().focus();
|
|
}, 1);
|
|
});
|
|
return true;
|
|
} else if ($element.is(_this.$submenuAnchors)) {
|
|
_this._show($element.parent('li'));
|
|
$element.parent('li').one(Foundation.transitionend($element), function () {
|
|
$element.parent('li').find('ul li a').filter(_this.$menuItems).first().focus();
|
|
});
|
|
return true;
|
|
}
|
|
},
|
|
handled: function (preventDefault) {
|
|
if (preventDefault) {
|
|
e.preventDefault();
|
|
}
|
|
e.stopImmediatePropagation();
|
|
}
|
|
});
|
|
}); // end keyboardAccess
|
|
}
|
|
|
|
/**
|
|
* Closes all open elements, and returns to root menu.
|
|
* @function
|
|
* @fires Drilldown#closed
|
|
*/
|
|
|
|
}, {
|
|
key: '_hideAll',
|
|
value: function _hideAll() {
|
|
var $elem = this.$element.find('.is-drilldown-submenu.is-active').addClass('is-closing');
|
|
$elem.one(Foundation.transitionend($elem), function (e) {
|
|
$elem.removeClass('is-active is-closing');
|
|
});
|
|
/**
|
|
* Fires when the menu is fully closed.
|
|
* @event Drilldown#closed
|
|
*/
|
|
this.$element.trigger('closed.zf.drilldown');
|
|
}
|
|
|
|
/**
|
|
* Adds event listener for each `back` button, and closes open menus.
|
|
* @function
|
|
* @fires Drilldown#back
|
|
* @param {jQuery} $elem - the current sub-menu to add `back` event.
|
|
*/
|
|
|
|
}, {
|
|
key: '_back',
|
|
value: function _back($elem) {
|
|
var _this = this;
|
|
$elem.off('click.zf.drilldown');
|
|
$elem.children('.js-drilldown-back').on('click.zf.drilldown', function (e) {
|
|
e.stopImmediatePropagation();
|
|
// console.log('mouseup on back');
|
|
_this._hide($elem);
|
|
|
|
// If there is a parent submenu, call show
|
|
var parentSubMenu = $elem.parent('li').parent('ul').parent('li');
|
|
if (parentSubMenu.length) {
|
|
_this._show(parentSubMenu);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Adds event listener to menu items w/o submenus to close open menus on click.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_menuLinkEvents',
|
|
value: function _menuLinkEvents() {
|
|
var _this = this;
|
|
this.$menuItems.not('.is-drilldown-submenu-parent').off('click.zf.drilldown').on('click.zf.drilldown', function (e) {
|
|
// e.stopImmediatePropagation();
|
|
setTimeout(function () {
|
|
_this._hideAll();
|
|
}, 0);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Opens a submenu.
|
|
* @function
|
|
* @fires Drilldown#open
|
|
* @param {jQuery} $elem - the current element with a submenu to open, i.e. the `li` tag.
|
|
*/
|
|
|
|
}, {
|
|
key: '_show',
|
|
value: function _show($elem) {
|
|
$elem.attr('aria-expanded', true);
|
|
$elem.children('[data-submenu]').addClass('is-active').attr('aria-hidden', false);
|
|
/**
|
|
* Fires when the submenu has opened.
|
|
* @event Drilldown#open
|
|
*/
|
|
this.$element.trigger('open.zf.drilldown', [$elem]);
|
|
}
|
|
}, {
|
|
key: '_hide',
|
|
|
|
|
|
/**
|
|
* Hides a submenu
|
|
* @function
|
|
* @fires Drilldown#hide
|
|
* @param {jQuery} $elem - the current sub-menu to hide, i.e. the `ul` tag.
|
|
*/
|
|
value: function _hide($elem) {
|
|
var _this = this;
|
|
$elem.parent('li').attr('aria-expanded', false);
|
|
$elem.attr('aria-hidden', true).addClass('is-closing').one(Foundation.transitionend($elem), function () {
|
|
$elem.removeClass('is-active is-closing');
|
|
$elem.blur();
|
|
});
|
|
/**
|
|
* Fires when the submenu has closed.
|
|
* @event Drilldown#hide
|
|
*/
|
|
$elem.trigger('hide.zf.drilldown', [$elem]);
|
|
}
|
|
|
|
/**
|
|
* Iterates through the nested menus to calculate the min-height, and max-width for the menu.
|
|
* Prevents content jumping.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_getMaxDims',
|
|
value: function _getMaxDims() {
|
|
var biggest = 0;
|
|
var result = {};
|
|
|
|
this.$submenus.add(this.$element).each(function (i, elem) {
|
|
var height = elem.getBoundingClientRect().height;
|
|
if (height > biggest) biggest = height;
|
|
});
|
|
|
|
result['min-height'] = biggest + 'px';
|
|
result['max-width'] = this.$element[0].getBoundingClientRect().width + 'px';
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Destroys the Drilldown Menu
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
this._hideAll();
|
|
Foundation.Nest.Burn(this.$element, 'drilldown');
|
|
this.$element.unwrap().find('.js-drilldown-back, .is-submenu-parent-item').remove().end().find('.is-active, .is-closing, .is-drilldown-submenu').removeClass('is-active is-closing is-drilldown-submenu').end().find('[data-submenu]').removeAttr('aria-hidden tabindex role');
|
|
this.$submenuAnchors.each(function () {
|
|
$(this).off('.zf.drilldown');
|
|
});
|
|
this.$element.find('a').each(function () {
|
|
var $link = $(this);
|
|
$link.removeAttr('tabindex');
|
|
if ($link.data('savedHref')) {
|
|
$link.attr('href', $link.data('savedHref')).removeData('savedHref');
|
|
} else {
|
|
return;
|
|
}
|
|
});
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return Drilldown;
|
|
}();
|
|
|
|
Drilldown.defaults = {
|
|
/**
|
|
* Markup used for JS generated back button. Prepended to submenu lists and deleted on `destroy` method, 'js-drilldown-back' class required. Remove the backslash (`\`) if copy and pasting.
|
|
* @option
|
|
* @example '<\li><\a>Back<\/a><\/li>'
|
|
*/
|
|
backButton: '<li class="js-drilldown-back"><a tabindex="0">Back</a></li>',
|
|
/**
|
|
* Markup used to wrap drilldown menu. Use a class name for independent styling; the JS applied class: `is-drilldown` is required. Remove the backslash (`\`) if copy and pasting.
|
|
* @option
|
|
* @example '<\div class="is-drilldown"><\/div>'
|
|
*/
|
|
wrapper: '<div></div>',
|
|
/**
|
|
* Adds the parent link to the submenu.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
parentLink: false,
|
|
/**
|
|
* Allow the menu to return to root list on body click.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
closeOnClick: false
|
|
// holdOpen: false
|
|
};
|
|
|
|
// Window exports
|
|
Foundation.plugin(Drilldown, 'Drilldown');
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* Dropdown module.
|
|
* @module foundation.dropdown
|
|
* @requires foundation.util.keyboard
|
|
* @requires foundation.util.box
|
|
* @requires foundation.util.triggers
|
|
*/
|
|
|
|
var Dropdown = function () {
|
|
/**
|
|
* Creates a new instance of a dropdown.
|
|
* @class
|
|
* @param {jQuery} element - jQuery object to make into a dropdown.
|
|
* Object should be of the dropdown panel, rather than its anchor.
|
|
* @param {Object} options - Overrides to the default plugin settings.
|
|
*/
|
|
function Dropdown(element, options) {
|
|
_classCallCheck(this, Dropdown);
|
|
|
|
this.$element = element;
|
|
this.options = $.extend({}, Dropdown.defaults, this.$element.data(), options);
|
|
this._init();
|
|
|
|
Foundation.registerPlugin(this, 'Dropdown');
|
|
Foundation.Keyboard.register('Dropdown', {
|
|
'ENTER': 'open',
|
|
'SPACE': 'open',
|
|
'ESCAPE': 'close',
|
|
'TAB': 'tab_forward',
|
|
'SHIFT_TAB': 'tab_backward'
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Initializes the plugin by setting/checking options and attributes, adding helper variables, and saving the anchor.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(Dropdown, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
var $id = this.$element.attr('id');
|
|
|
|
this.$anchor = $('[data-toggle="' + $id + '"]').length ? $('[data-toggle="' + $id + '"]') : $('[data-open="' + $id + '"]');
|
|
this.$anchor.attr({
|
|
'aria-controls': $id,
|
|
'data-is-focus': false,
|
|
'data-yeti-box': $id,
|
|
'aria-haspopup': true,
|
|
'aria-expanded': false
|
|
|
|
});
|
|
|
|
this.options.positionClass = this.getPositionClass();
|
|
this.counter = 4;
|
|
this.usedPositions = [];
|
|
this.$element.attr({
|
|
'aria-hidden': 'true',
|
|
'data-yeti-box': $id,
|
|
'data-resize': $id,
|
|
'aria-labelledby': this.$anchor[0].id || Foundation.GetYoDigits(6, 'dd-anchor')
|
|
});
|
|
this._events();
|
|
}
|
|
|
|
/**
|
|
* Helper function to determine current orientation of dropdown pane.
|
|
* @function
|
|
* @returns {String} position - string value of a position class.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getPositionClass',
|
|
value: function getPositionClass() {
|
|
var verticalPosition = this.$element[0].className.match(/(top|left|right|bottom)/g);
|
|
verticalPosition = verticalPosition ? verticalPosition[0] : '';
|
|
var horizontalPosition = /float-(\S+)/.exec(this.$anchor[0].className);
|
|
horizontalPosition = horizontalPosition ? horizontalPosition[1] : '';
|
|
var position = horizontalPosition ? horizontalPosition + ' ' + verticalPosition : verticalPosition;
|
|
|
|
return position;
|
|
}
|
|
|
|
/**
|
|
* Adjusts the dropdown panes orientation by adding/removing positioning classes.
|
|
* @function
|
|
* @private
|
|
* @param {String} position - position class to remove.
|
|
*/
|
|
|
|
}, {
|
|
key: '_reposition',
|
|
value: function _reposition(position) {
|
|
this.usedPositions.push(position ? position : 'bottom');
|
|
//default, try switching to opposite side
|
|
if (!position && this.usedPositions.indexOf('top') < 0) {
|
|
this.$element.addClass('top');
|
|
} else if (position === 'top' && this.usedPositions.indexOf('bottom') < 0) {
|
|
this.$element.removeClass(position);
|
|
} else if (position === 'left' && this.usedPositions.indexOf('right') < 0) {
|
|
this.$element.removeClass(position).addClass('right');
|
|
} else if (position === 'right' && this.usedPositions.indexOf('left') < 0) {
|
|
this.$element.removeClass(position).addClass('left');
|
|
}
|
|
|
|
//if default change didn't work, try bottom or left first
|
|
else if (!position && this.usedPositions.indexOf('top') > -1 && this.usedPositions.indexOf('left') < 0) {
|
|
this.$element.addClass('left');
|
|
} else if (position === 'top' && this.usedPositions.indexOf('bottom') > -1 && this.usedPositions.indexOf('left') < 0) {
|
|
this.$element.removeClass(position).addClass('left');
|
|
} else if (position === 'left' && this.usedPositions.indexOf('right') > -1 && this.usedPositions.indexOf('bottom') < 0) {
|
|
this.$element.removeClass(position);
|
|
} else if (position === 'right' && this.usedPositions.indexOf('left') > -1 && this.usedPositions.indexOf('bottom') < 0) {
|
|
this.$element.removeClass(position);
|
|
}
|
|
//if nothing cleared, set to bottom
|
|
else {
|
|
this.$element.removeClass(position);
|
|
}
|
|
this.classChanged = true;
|
|
this.counter--;
|
|
}
|
|
|
|
/**
|
|
* Sets the position and orientation of the dropdown pane, checks for collisions.
|
|
* Recursively calls itself if a collision is detected, with a new position class.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_setPosition',
|
|
value: function _setPosition() {
|
|
if (this.$anchor.attr('aria-expanded') === 'false') {
|
|
return false;
|
|
}
|
|
var position = this.getPositionClass(),
|
|
$eleDims = Foundation.Box.GetDimensions(this.$element),
|
|
$anchorDims = Foundation.Box.GetDimensions(this.$anchor),
|
|
_this = this,
|
|
direction = position === 'left' ? 'left' : position === 'right' ? 'left' : 'top',
|
|
param = direction === 'top' ? 'height' : 'width',
|
|
offset = param === 'height' ? this.options.vOffset : this.options.hOffset;
|
|
|
|
if ($eleDims.width >= $eleDims.windowDims.width || !this.counter && !Foundation.Box.ImNotTouchingYou(this.$element)) {
|
|
this.$element.offset(Foundation.Box.GetOffsets(this.$element, this.$anchor, 'center bottom', this.options.vOffset, this.options.hOffset, true)).css({
|
|
'width': $eleDims.windowDims.width - this.options.hOffset * 2,
|
|
'height': 'auto'
|
|
});
|
|
this.classChanged = true;
|
|
return false;
|
|
}
|
|
|
|
this.$element.offset(Foundation.Box.GetOffsets(this.$element, this.$anchor, position, this.options.vOffset, this.options.hOffset));
|
|
|
|
while (!Foundation.Box.ImNotTouchingYou(this.$element, false, true) && this.counter) {
|
|
this._reposition(position);
|
|
this._setPosition();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds event listeners to the element utilizing the triggers utility library.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events() {
|
|
var _this = this;
|
|
this.$element.on({
|
|
'open.zf.trigger': this.open.bind(this),
|
|
'close.zf.trigger': this.close.bind(this),
|
|
'toggle.zf.trigger': this.toggle.bind(this),
|
|
'resizeme.zf.trigger': this._setPosition.bind(this)
|
|
});
|
|
|
|
if (this.options.hover) {
|
|
this.$anchor.off('mouseenter.zf.dropdown mouseleave.zf.dropdown').on('mouseenter.zf.dropdown', function () {
|
|
if ($('body[data-whatinput="mouse"]').is('*')) {
|
|
clearTimeout(_this.timeout);
|
|
_this.timeout = setTimeout(function () {
|
|
_this.open();
|
|
_this.$anchor.data('hover', true);
|
|
}, _this.options.hoverDelay);
|
|
}
|
|
}).on('mouseleave.zf.dropdown', function () {
|
|
clearTimeout(_this.timeout);
|
|
_this.timeout = setTimeout(function () {
|
|
_this.close();
|
|
_this.$anchor.data('hover', false);
|
|
}, _this.options.hoverDelay);
|
|
});
|
|
if (this.options.hoverPane) {
|
|
this.$element.off('mouseenter.zf.dropdown mouseleave.zf.dropdown').on('mouseenter.zf.dropdown', function () {
|
|
clearTimeout(_this.timeout);
|
|
}).on('mouseleave.zf.dropdown', function () {
|
|
clearTimeout(_this.timeout);
|
|
_this.timeout = setTimeout(function () {
|
|
_this.close();
|
|
_this.$anchor.data('hover', false);
|
|
}, _this.options.hoverDelay);
|
|
});
|
|
}
|
|
}
|
|
this.$anchor.add(this.$element).on('keydown.zf.dropdown', function (e) {
|
|
|
|
var $target = $(this),
|
|
visibleFocusableElements = Foundation.Keyboard.findFocusable(_this.$element);
|
|
|
|
Foundation.Keyboard.handleKey(e, 'Dropdown', {
|
|
tab_forward: function () {
|
|
if (_this.$element.find(':focus').is(visibleFocusableElements.eq(-1))) {
|
|
// left modal downwards, setting focus to first element
|
|
if (_this.options.trapFocus) {
|
|
// if focus shall be trapped
|
|
visibleFocusableElements.eq(0).focus();
|
|
e.preventDefault();
|
|
} else {
|
|
// if focus is not trapped, close dropdown on focus out
|
|
_this.close();
|
|
}
|
|
}
|
|
},
|
|
tab_backward: function () {
|
|
if (_this.$element.find(':focus').is(visibleFocusableElements.eq(0)) || _this.$element.is(':focus')) {
|
|
// left modal upwards, setting focus to last element
|
|
if (_this.options.trapFocus) {
|
|
// if focus shall be trapped
|
|
visibleFocusableElements.eq(-1).focus();
|
|
e.preventDefault();
|
|
} else {
|
|
// if focus is not trapped, close dropdown on focus out
|
|
_this.close();
|
|
}
|
|
}
|
|
},
|
|
open: function () {
|
|
if ($target.is(_this.$anchor)) {
|
|
_this.open();
|
|
_this.$element.attr('tabindex', -1).focus();
|
|
e.preventDefault();
|
|
}
|
|
},
|
|
close: function () {
|
|
_this.close();
|
|
_this.$anchor.focus();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Adds an event handler to the body to close any dropdowns on a click.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_addBodyHandler',
|
|
value: function _addBodyHandler() {
|
|
var $body = $(document.body).not(this.$element),
|
|
_this = this;
|
|
$body.off('click.zf.dropdown').on('click.zf.dropdown', function (e) {
|
|
if (_this.$anchor.is(e.target) || _this.$anchor.find(e.target).length) {
|
|
return;
|
|
}
|
|
if (_this.$element.find(e.target).length) {
|
|
return;
|
|
}
|
|
_this.close();
|
|
$body.off('click.zf.dropdown');
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Opens the dropdown pane, and fires a bubbling event to close other dropdowns.
|
|
* @function
|
|
* @fires Dropdown#closeme
|
|
* @fires Dropdown#show
|
|
*/
|
|
|
|
}, {
|
|
key: 'open',
|
|
value: function open() {
|
|
// var _this = this;
|
|
/**
|
|
* Fires to close other open dropdowns
|
|
* @event Dropdown#closeme
|
|
*/
|
|
this.$element.trigger('closeme.zf.dropdown', this.$element.attr('id'));
|
|
this.$anchor.addClass('hover').attr({ 'aria-expanded': true });
|
|
// this.$element/*.show()*/;
|
|
this._setPosition();
|
|
this.$element.addClass('is-open').attr({ 'aria-hidden': false });
|
|
|
|
if (this.options.autoFocus) {
|
|
var $focusable = Foundation.Keyboard.findFocusable(this.$element);
|
|
if ($focusable.length) {
|
|
$focusable.eq(0).focus();
|
|
}
|
|
}
|
|
|
|
if (this.options.closeOnClick) {
|
|
this._addBodyHandler();
|
|
}
|
|
|
|
/**
|
|
* Fires once the dropdown is visible.
|
|
* @event Dropdown#show
|
|
*/
|
|
this.$element.trigger('show.zf.dropdown', [this.$element]);
|
|
}
|
|
|
|
/**
|
|
* Closes the open dropdown pane.
|
|
* @function
|
|
* @fires Dropdown#hide
|
|
*/
|
|
|
|
}, {
|
|
key: 'close',
|
|
value: function close() {
|
|
if (!this.$element.hasClass('is-open')) {
|
|
return false;
|
|
}
|
|
this.$element.removeClass('is-open').attr({ 'aria-hidden': true });
|
|
|
|
this.$anchor.removeClass('hover').attr('aria-expanded', false);
|
|
|
|
if (this.classChanged) {
|
|
var curPositionClass = this.getPositionClass();
|
|
if (curPositionClass) {
|
|
this.$element.removeClass(curPositionClass);
|
|
}
|
|
this.$element.addClass(this.options.positionClass)
|
|
/*.hide()*/.css({ height: '', width: '' });
|
|
this.classChanged = false;
|
|
this.counter = 4;
|
|
this.usedPositions.length = 0;
|
|
}
|
|
this.$element.trigger('hide.zf.dropdown', [this.$element]);
|
|
}
|
|
|
|
/**
|
|
* Toggles the dropdown pane's visibility.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'toggle',
|
|
value: function toggle() {
|
|
if (this.$element.hasClass('is-open')) {
|
|
if (this.$anchor.data('hover')) return;
|
|
this.close();
|
|
} else {
|
|
this.open();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Destroys the dropdown.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
this.$element.off('.zf.trigger').hide();
|
|
this.$anchor.off('.zf.dropdown');
|
|
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return Dropdown;
|
|
}();
|
|
|
|
Dropdown.defaults = {
|
|
/**
|
|
* Amount of time to delay opening a submenu on hover event.
|
|
* @option
|
|
* @example 250
|
|
*/
|
|
hoverDelay: 250,
|
|
/**
|
|
* Allow submenus to open on hover events
|
|
* @option
|
|
* @example false
|
|
*/
|
|
hover: false,
|
|
/**
|
|
* Don't close dropdown when hovering over dropdown pane
|
|
* @option
|
|
* @example true
|
|
*/
|
|
hoverPane: false,
|
|
/**
|
|
* Number of pixels between the dropdown pane and the triggering element on open.
|
|
* @option
|
|
* @example 1
|
|
*/
|
|
vOffset: 1,
|
|
/**
|
|
* Number of pixels between the dropdown pane and the triggering element on open.
|
|
* @option
|
|
* @example 1
|
|
*/
|
|
hOffset: 1,
|
|
/**
|
|
* Class applied to adjust open position. JS will test and fill this in.
|
|
* @option
|
|
* @example 'top'
|
|
*/
|
|
positionClass: '',
|
|
/**
|
|
* Allow the plugin to trap focus to the dropdown pane if opened with keyboard commands.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
trapFocus: false,
|
|
/**
|
|
* Allow the plugin to set focus to the first focusable element within the pane, regardless of method of opening.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
autoFocus: false,
|
|
/**
|
|
* Allows a click on the body to close the dropdown.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
closeOnClick: false
|
|
};
|
|
|
|
// Window exports
|
|
Foundation.plugin(Dropdown, 'Dropdown');
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* DropdownMenu module.
|
|
* @module foundation.dropdown-menu
|
|
* @requires foundation.util.keyboard
|
|
* @requires foundation.util.box
|
|
* @requires foundation.util.nest
|
|
*/
|
|
|
|
var DropdownMenu = function () {
|
|
/**
|
|
* Creates a new instance of DropdownMenu.
|
|
* @class
|
|
* @fires DropdownMenu#init
|
|
* @param {jQuery} element - jQuery object to make into a dropdown menu.
|
|
* @param {Object} options - Overrides to the default plugin settings.
|
|
*/
|
|
function DropdownMenu(element, options) {
|
|
_classCallCheck(this, DropdownMenu);
|
|
|
|
this.$element = element;
|
|
this.options = $.extend({}, DropdownMenu.defaults, this.$element.data(), options);
|
|
|
|
Foundation.Nest.Feather(this.$element, 'dropdown');
|
|
this._init();
|
|
|
|
Foundation.registerPlugin(this, 'DropdownMenu');
|
|
Foundation.Keyboard.register('DropdownMenu', {
|
|
'ENTER': 'open',
|
|
'SPACE': 'open',
|
|
'ARROW_RIGHT': 'next',
|
|
'ARROW_UP': 'up',
|
|
'ARROW_DOWN': 'down',
|
|
'ARROW_LEFT': 'previous',
|
|
'ESCAPE': 'close'
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Initializes the plugin, and calls _prepareMenu
|
|
* @private
|
|
* @function
|
|
*/
|
|
|
|
|
|
_createClass(DropdownMenu, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
var subs = this.$element.find('li.is-dropdown-submenu-parent');
|
|
this.$element.children('.is-dropdown-submenu-parent').children('.is-dropdown-submenu').addClass('first-sub');
|
|
|
|
this.$menuItems = this.$element.find('[role="menuitem"]');
|
|
this.$tabs = this.$element.children('[role="menuitem"]');
|
|
this.$tabs.find('ul.is-dropdown-submenu').addClass(this.options.verticalClass);
|
|
|
|
if (this.$element.hasClass(this.options.rightClass) || this.options.alignment === 'right' || Foundation.rtl() || this.$element.parents('.top-bar-right').is('*')) {
|
|
this.options.alignment = 'right';
|
|
subs.addClass('opens-left');
|
|
} else {
|
|
subs.addClass('opens-right');
|
|
}
|
|
this.changed = false;
|
|
this._events();
|
|
}
|
|
}, {
|
|
key: '_isVertical',
|
|
value: function _isVertical() {
|
|
return this.$tabs.css('display') === 'block';
|
|
}
|
|
|
|
/**
|
|
* Adds event listeners to elements within the menu
|
|
* @private
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events() {
|
|
var _this = this,
|
|
hasTouch = 'ontouchstart' in window || typeof window.ontouchstart !== 'undefined',
|
|
parClass = 'is-dropdown-submenu-parent';
|
|
|
|
// used for onClick and in the keyboard handlers
|
|
var handleClickFn = function (e) {
|
|
var $elem = $(e.target).parentsUntil('ul', '.' + parClass),
|
|
hasSub = $elem.hasClass(parClass),
|
|
hasClicked = $elem.attr('data-is-click') === 'true',
|
|
$sub = $elem.children('.is-dropdown-submenu');
|
|
|
|
if (hasSub) {
|
|
if (hasClicked) {
|
|
if (!_this.options.closeOnClick || !_this.options.clickOpen && !hasTouch || _this.options.forceFollow && hasTouch) {
|
|
return;
|
|
} else {
|
|
e.stopImmediatePropagation();
|
|
e.preventDefault();
|
|
_this._hide($elem);
|
|
}
|
|
} else {
|
|
e.preventDefault();
|
|
e.stopImmediatePropagation();
|
|
_this._show($sub);
|
|
$elem.add($elem.parentsUntil(_this.$element, '.' + parClass)).attr('data-is-click', true);
|
|
}
|
|
} else {
|
|
if (_this.options.closeOnClickInside) {
|
|
_this._hide($elem);
|
|
}
|
|
return;
|
|
}
|
|
};
|
|
|
|
if (this.options.clickOpen || hasTouch) {
|
|
this.$menuItems.on('click.zf.dropdownmenu touchstart.zf.dropdownmenu', handleClickFn);
|
|
}
|
|
|
|
if (!this.options.disableHover) {
|
|
this.$menuItems.on('mouseenter.zf.dropdownmenu', function (e) {
|
|
var $elem = $(this),
|
|
hasSub = $elem.hasClass(parClass);
|
|
|
|
if (hasSub) {
|
|
clearTimeout(_this.delay);
|
|
_this.delay = setTimeout(function () {
|
|
_this._show($elem.children('.is-dropdown-submenu'));
|
|
}, _this.options.hoverDelay);
|
|
}
|
|
}).on('mouseleave.zf.dropdownmenu', function (e) {
|
|
var $elem = $(this),
|
|
hasSub = $elem.hasClass(parClass);
|
|
if (hasSub && _this.options.autoclose) {
|
|
if ($elem.attr('data-is-click') === 'true' && _this.options.clickOpen) {
|
|
return false;
|
|
}
|
|
|
|
clearTimeout(_this.delay);
|
|
_this.delay = setTimeout(function () {
|
|
_this._hide($elem);
|
|
}, _this.options.closingTime);
|
|
}
|
|
});
|
|
}
|
|
this.$menuItems.on('keydown.zf.dropdownmenu', function (e) {
|
|
var $element = $(e.target).parentsUntil('ul', '[role="menuitem"]'),
|
|
isTab = _this.$tabs.index($element) > -1,
|
|
$elements = isTab ? _this.$tabs : $element.siblings('li').add($element),
|
|
$prevElement,
|
|
$nextElement;
|
|
|
|
$elements.each(function (i) {
|
|
if ($(this).is($element)) {
|
|
$prevElement = $elements.eq(i - 1);
|
|
$nextElement = $elements.eq(i + 1);
|
|
return;
|
|
}
|
|
});
|
|
|
|
var nextSibling = function () {
|
|
if (!$element.is(':last-child')) {
|
|
$nextElement.children('a:first').focus();
|
|
e.preventDefault();
|
|
}
|
|
},
|
|
prevSibling = function () {
|
|
$prevElement.children('a:first').focus();
|
|
e.preventDefault();
|
|
},
|
|
openSub = function () {
|
|
var $sub = $element.children('ul.is-dropdown-submenu');
|
|
if ($sub.length) {
|
|
_this._show($sub);
|
|
$element.find('li > a:first').focus();
|
|
e.preventDefault();
|
|
} else {
|
|
return;
|
|
}
|
|
},
|
|
closeSub = function () {
|
|
//if ($element.is(':first-child')) {
|
|
var close = $element.parent('ul').parent('li');
|
|
close.children('a:first').focus();
|
|
_this._hide(close);
|
|
e.preventDefault();
|
|
//}
|
|
};
|
|
var functions = {
|
|
open: openSub,
|
|
close: function () {
|
|
_this._hide(_this.$element);
|
|
_this.$menuItems.find('a:first').focus(); // focus to first element
|
|
e.preventDefault();
|
|
},
|
|
handled: function () {
|
|
e.stopImmediatePropagation();
|
|
}
|
|
};
|
|
|
|
if (isTab) {
|
|
if (_this._isVertical()) {
|
|
// vertical menu
|
|
if (Foundation.rtl()) {
|
|
// right aligned
|
|
$.extend(functions, {
|
|
down: nextSibling,
|
|
up: prevSibling,
|
|
next: closeSub,
|
|
previous: openSub
|
|
});
|
|
} else {
|
|
// left aligned
|
|
$.extend(functions, {
|
|
down: nextSibling,
|
|
up: prevSibling,
|
|
next: openSub,
|
|
previous: closeSub
|
|
});
|
|
}
|
|
} else {
|
|
// horizontal menu
|
|
if (Foundation.rtl()) {
|
|
// right aligned
|
|
$.extend(functions, {
|
|
next: prevSibling,
|
|
previous: nextSibling,
|
|
down: openSub,
|
|
up: closeSub
|
|
});
|
|
} else {
|
|
// left aligned
|
|
$.extend(functions, {
|
|
next: nextSibling,
|
|
previous: prevSibling,
|
|
down: openSub,
|
|
up: closeSub
|
|
});
|
|
}
|
|
}
|
|
} else {
|
|
// not tabs -> one sub
|
|
if (Foundation.rtl()) {
|
|
// right aligned
|
|
$.extend(functions, {
|
|
next: closeSub,
|
|
previous: openSub,
|
|
down: nextSibling,
|
|
up: prevSibling
|
|
});
|
|
} else {
|
|
// left aligned
|
|
$.extend(functions, {
|
|
next: openSub,
|
|
previous: closeSub,
|
|
down: nextSibling,
|
|
up: prevSibling
|
|
});
|
|
}
|
|
}
|
|
Foundation.Keyboard.handleKey(e, 'DropdownMenu', functions);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Adds an event handler to the body to close any dropdowns on a click.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_addBodyHandler',
|
|
value: function _addBodyHandler() {
|
|
var $body = $(document.body),
|
|
_this = this;
|
|
$body.off('mouseup.zf.dropdownmenu touchend.zf.dropdownmenu').on('mouseup.zf.dropdownmenu touchend.zf.dropdownmenu', function (e) {
|
|
var $link = _this.$element.find(e.target);
|
|
if ($link.length) {
|
|
return;
|
|
}
|
|
|
|
_this._hide();
|
|
$body.off('mouseup.zf.dropdownmenu touchend.zf.dropdownmenu');
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Opens a dropdown pane, and checks for collisions first.
|
|
* @param {jQuery} $sub - ul element that is a submenu to show
|
|
* @function
|
|
* @private
|
|
* @fires DropdownMenu#show
|
|
*/
|
|
|
|
}, {
|
|
key: '_show',
|
|
value: function _show($sub) {
|
|
var idx = this.$tabs.index(this.$tabs.filter(function (i, el) {
|
|
return $(el).find($sub).length > 0;
|
|
}));
|
|
var $sibs = $sub.parent('li.is-dropdown-submenu-parent').siblings('li.is-dropdown-submenu-parent');
|
|
this._hide($sibs, idx);
|
|
$sub.css('visibility', 'hidden').addClass('js-dropdown-active').attr({ 'aria-hidden': false }).parent('li.is-dropdown-submenu-parent').addClass('is-active').attr({ 'aria-expanded': true });
|
|
var clear = Foundation.Box.ImNotTouchingYou($sub, null, true);
|
|
if (!clear) {
|
|
var oldClass = this.options.alignment === 'left' ? '-right' : '-left',
|
|
$parentLi = $sub.parent('.is-dropdown-submenu-parent');
|
|
$parentLi.removeClass('opens' + oldClass).addClass('opens-' + this.options.alignment);
|
|
clear = Foundation.Box.ImNotTouchingYou($sub, null, true);
|
|
if (!clear) {
|
|
$parentLi.removeClass('opens-' + this.options.alignment).addClass('opens-inner');
|
|
}
|
|
this.changed = true;
|
|
}
|
|
$sub.css('visibility', '');
|
|
if (this.options.closeOnClick) {
|
|
this._addBodyHandler();
|
|
}
|
|
/**
|
|
* Fires when the new dropdown pane is visible.
|
|
* @event DropdownMenu#show
|
|
*/
|
|
this.$element.trigger('show.zf.dropdownmenu', [$sub]);
|
|
}
|
|
|
|
/**
|
|
* Hides a single, currently open dropdown pane, if passed a parameter, otherwise, hides everything.
|
|
* @function
|
|
* @param {jQuery} $elem - element with a submenu to hide
|
|
* @param {Number} idx - index of the $tabs collection to hide
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_hide',
|
|
value: function _hide($elem, idx) {
|
|
var $toClose;
|
|
if ($elem && $elem.length) {
|
|
$toClose = $elem;
|
|
} else if (idx !== undefined) {
|
|
$toClose = this.$tabs.not(function (i, el) {
|
|
return i === idx;
|
|
});
|
|
} else {
|
|
$toClose = this.$element;
|
|
}
|
|
var somethingToClose = $toClose.hasClass('is-active') || $toClose.find('.is-active').length > 0;
|
|
|
|
if (somethingToClose) {
|
|
$toClose.find('li.is-active').add($toClose).attr({
|
|
'aria-expanded': false,
|
|
'data-is-click': false
|
|
}).removeClass('is-active');
|
|
|
|
$toClose.find('ul.js-dropdown-active').attr({
|
|
'aria-hidden': true
|
|
}).removeClass('js-dropdown-active');
|
|
|
|
if (this.changed || $toClose.find('opens-inner').length) {
|
|
var oldClass = this.options.alignment === 'left' ? 'right' : 'left';
|
|
$toClose.find('li.is-dropdown-submenu-parent').add($toClose).removeClass('opens-inner opens-' + this.options.alignment).addClass('opens-' + oldClass);
|
|
this.changed = false;
|
|
}
|
|
/**
|
|
* Fires when the open menus are closed.
|
|
* @event DropdownMenu#hide
|
|
*/
|
|
this.$element.trigger('hide.zf.dropdownmenu', [$toClose]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Destroys the plugin.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
this.$menuItems.off('.zf.dropdownmenu').removeAttr('data-is-click').removeClass('is-right-arrow is-left-arrow is-down-arrow opens-right opens-left opens-inner');
|
|
$(document.body).off('.zf.dropdownmenu');
|
|
Foundation.Nest.Burn(this.$element, 'dropdown');
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return DropdownMenu;
|
|
}();
|
|
|
|
/**
|
|
* Default settings for plugin
|
|
*/
|
|
|
|
|
|
DropdownMenu.defaults = {
|
|
/**
|
|
* Disallows hover events from opening submenus
|
|
* @option
|
|
* @example false
|
|
*/
|
|
disableHover: false,
|
|
/**
|
|
* Allow a submenu to automatically close on a mouseleave event, if not clicked open.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
autoclose: true,
|
|
/**
|
|
* Amount of time to delay opening a submenu on hover event.
|
|
* @option
|
|
* @example 50
|
|
*/
|
|
hoverDelay: 50,
|
|
/**
|
|
* Allow a submenu to open/remain open on parent click event. Allows cursor to move away from menu.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
clickOpen: false,
|
|
/**
|
|
* Amount of time to delay closing a submenu on a mouseleave event.
|
|
* @option
|
|
* @example 500
|
|
*/
|
|
|
|
closingTime: 500,
|
|
/**
|
|
* Position of the menu relative to what direction the submenus should open. Handled by JS.
|
|
* @option
|
|
* @example 'left'
|
|
*/
|
|
alignment: 'left',
|
|
/**
|
|
* Allow clicks on the body to close any open submenus.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
closeOnClick: true,
|
|
/**
|
|
* Allow clicks on leaf anchor links to close any open submenus.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
closeOnClickInside: true,
|
|
/**
|
|
* Class applied to vertical oriented menus, Foundation default is `vertical`. Update this if using your own class.
|
|
* @option
|
|
* @example 'vertical'
|
|
*/
|
|
verticalClass: 'vertical',
|
|
/**
|
|
* Class applied to right-side oriented menus, Foundation default is `align-right`. Update this if using your own class.
|
|
* @option
|
|
* @example 'align-right'
|
|
*/
|
|
rightClass: 'align-right',
|
|
/**
|
|
* Boolean to force overide the clicking of links to perform default action, on second touch event for mobile.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
forceFollow: true
|
|
};
|
|
|
|
// Window exports
|
|
Foundation.plugin(DropdownMenu, 'DropdownMenu');
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* Equalizer module.
|
|
* @module foundation.equalizer
|
|
* @requires foundation.util.mediaQuery
|
|
* @requires foundation.util.timerAndImageLoader if equalizer contains images
|
|
*/
|
|
|
|
var Equalizer = function () {
|
|
/**
|
|
* Creates a new instance of Equalizer.
|
|
* @class
|
|
* @fires Equalizer#init
|
|
* @param {Object} element - jQuery object to add the trigger to.
|
|
* @param {Object} options - Overrides to the default plugin settings.
|
|
*/
|
|
function Equalizer(element, options) {
|
|
_classCallCheck(this, Equalizer);
|
|
|
|
this.$element = element;
|
|
this.options = $.extend({}, Equalizer.defaults, this.$element.data(), options);
|
|
|
|
this._init();
|
|
|
|
Foundation.registerPlugin(this, 'Equalizer');
|
|
}
|
|
|
|
/**
|
|
* Initializes the Equalizer plugin and calls functions to get equalizer functioning on load.
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(Equalizer, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
var eqId = this.$element.attr('data-equalizer') || '';
|
|
var $watched = this.$element.find('[data-equalizer-watch="' + eqId + '"]');
|
|
|
|
this.$watched = $watched.length ? $watched : this.$element.find('[data-equalizer-watch]');
|
|
this.$element.attr('data-resize', eqId || Foundation.GetYoDigits(6, 'eq'));
|
|
|
|
this.hasNested = this.$element.find('[data-equalizer]').length > 0;
|
|
this.isNested = this.$element.parentsUntil(document.body, '[data-equalizer]').length > 0;
|
|
this.isOn = false;
|
|
this._bindHandler = {
|
|
onResizeMeBound: this._onResizeMe.bind(this),
|
|
onPostEqualizedBound: this._onPostEqualized.bind(this)
|
|
};
|
|
|
|
var imgs = this.$element.find('img');
|
|
var tooSmall;
|
|
if (this.options.equalizeOn) {
|
|
tooSmall = this._checkMQ();
|
|
$(window).on('changed.zf.mediaquery', this._checkMQ.bind(this));
|
|
} else {
|
|
this._events();
|
|
}
|
|
if (tooSmall !== undefined && tooSmall === false || tooSmall === undefined) {
|
|
if (imgs.length) {
|
|
Foundation.onImagesLoaded(imgs, this._reflow.bind(this));
|
|
} else {
|
|
this._reflow();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes event listeners if the breakpoint is too small.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_pauseEvents',
|
|
value: function _pauseEvents() {
|
|
this.isOn = false;
|
|
this.$element.off({
|
|
'.zf.equalizer': this._bindHandler.onPostEqualizedBound,
|
|
'resizeme.zf.trigger': this._bindHandler.onResizeMeBound
|
|
});
|
|
}
|
|
|
|
/**
|
|
* function to handle $elements resizeme.zf.trigger, with bound this on _bindHandler.onResizeMeBound
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_onResizeMe',
|
|
value: function _onResizeMe(e) {
|
|
this._reflow();
|
|
}
|
|
|
|
/**
|
|
* function to handle $elements postequalized.zf.equalizer, with bound this on _bindHandler.onPostEqualizedBound
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_onPostEqualized',
|
|
value: function _onPostEqualized(e) {
|
|
if (e.target !== this.$element[0]) {
|
|
this._reflow();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Initializes events for Equalizer.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events() {
|
|
var _this = this;
|
|
this._pauseEvents();
|
|
if (this.hasNested) {
|
|
this.$element.on('postequalized.zf.equalizer', this._bindHandler.onPostEqualizedBound);
|
|
} else {
|
|
this.$element.on('resizeme.zf.trigger', this._bindHandler.onResizeMeBound);
|
|
}
|
|
this.isOn = true;
|
|
}
|
|
|
|
/**
|
|
* Checks the current breakpoint to the minimum required size.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_checkMQ',
|
|
value: function _checkMQ() {
|
|
var tooSmall = !Foundation.MediaQuery.atLeast(this.options.equalizeOn);
|
|
if (tooSmall) {
|
|
if (this.isOn) {
|
|
this._pauseEvents();
|
|
this.$watched.css('height', 'auto');
|
|
}
|
|
} else {
|
|
if (!this.isOn) {
|
|
this._events();
|
|
}
|
|
}
|
|
return tooSmall;
|
|
}
|
|
|
|
/**
|
|
* A noop version for the plugin
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_killswitch',
|
|
value: function _killswitch() {
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* Calls necessary functions to update Equalizer upon DOM change
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_reflow',
|
|
value: function _reflow() {
|
|
if (!this.options.equalizeOnStack) {
|
|
if (this._isStacked()) {
|
|
this.$watched.css('height', 'auto');
|
|
return false;
|
|
}
|
|
}
|
|
if (this.options.equalizeByRow) {
|
|
this.getHeightsByRow(this.applyHeightByRow.bind(this));
|
|
} else {
|
|
this.getHeights(this.applyHeight.bind(this));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Manually determines if the first 2 elements are *NOT* stacked.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_isStacked',
|
|
value: function _isStacked() {
|
|
return this.$watched[0].getBoundingClientRect().top !== this.$watched[1].getBoundingClientRect().top;
|
|
}
|
|
|
|
/**
|
|
* Finds the outer heights of children contained within an Equalizer parent and returns them in an array
|
|
* @param {Function} cb - A non-optional callback to return the heights array to.
|
|
* @returns {Array} heights - An array of heights of children within Equalizer container
|
|
*/
|
|
|
|
}, {
|
|
key: 'getHeights',
|
|
value: function getHeights(cb) {
|
|
var heights = [];
|
|
for (var i = 0, len = this.$watched.length; i < len; i++) {
|
|
this.$watched[i].style.height = 'auto';
|
|
heights.push(this.$watched[i].offsetHeight);
|
|
}
|
|
cb(heights);
|
|
}
|
|
|
|
/**
|
|
* Finds the outer heights of children contained within an Equalizer parent and returns them in an array
|
|
* @param {Function} cb - A non-optional callback to return the heights array to.
|
|
* @returns {Array} groups - An array of heights of children within Equalizer container grouped by row with element,height and max as last child
|
|
*/
|
|
|
|
}, {
|
|
key: 'getHeightsByRow',
|
|
value: function getHeightsByRow(cb) {
|
|
var lastElTopOffset = this.$watched.length ? this.$watched.first().offset().top : 0,
|
|
groups = [],
|
|
group = 0;
|
|
//group by Row
|
|
groups[group] = [];
|
|
for (var i = 0, len = this.$watched.length; i < len; i++) {
|
|
this.$watched[i].style.height = 'auto';
|
|
//maybe could use this.$watched[i].offsetTop
|
|
var elOffsetTop = $(this.$watched[i]).offset().top;
|
|
if (elOffsetTop != lastElTopOffset) {
|
|
group++;
|
|
groups[group] = [];
|
|
lastElTopOffset = elOffsetTop;
|
|
}
|
|
groups[group].push([this.$watched[i], this.$watched[i].offsetHeight]);
|
|
}
|
|
|
|
for (var j = 0, ln = groups.length; j < ln; j++) {
|
|
var heights = $(groups[j]).map(function () {
|
|
return this[1];
|
|
}).get();
|
|
var max = Math.max.apply(null, heights);
|
|
groups[j].push(max);
|
|
}
|
|
cb(groups);
|
|
}
|
|
|
|
/**
|
|
* Changes the CSS height property of each child in an Equalizer parent to match the tallest
|
|
* @param {array} heights - An array of heights of children within Equalizer container
|
|
* @fires Equalizer#preequalized
|
|
* @fires Equalizer#postequalized
|
|
*/
|
|
|
|
}, {
|
|
key: 'applyHeight',
|
|
value: function applyHeight(heights) {
|
|
var max = Math.max.apply(null, heights);
|
|
/**
|
|
* Fires before the heights are applied
|
|
* @event Equalizer#preequalized
|
|
*/
|
|
this.$element.trigger('preequalized.zf.equalizer');
|
|
|
|
this.$watched.css('height', max);
|
|
|
|
/**
|
|
* Fires when the heights have been applied
|
|
* @event Equalizer#postequalized
|
|
*/
|
|
this.$element.trigger('postequalized.zf.equalizer');
|
|
}
|
|
|
|
/**
|
|
* Changes the CSS height property of each child in an Equalizer parent to match the tallest by row
|
|
* @param {array} groups - An array of heights of children within Equalizer container grouped by row with element,height and max as last child
|
|
* @fires Equalizer#preequalized
|
|
* @fires Equalizer#preequalizedRow
|
|
* @fires Equalizer#postequalizedRow
|
|
* @fires Equalizer#postequalized
|
|
*/
|
|
|
|
}, {
|
|
key: 'applyHeightByRow',
|
|
value: function applyHeightByRow(groups) {
|
|
/**
|
|
* Fires before the heights are applied
|
|
*/
|
|
this.$element.trigger('preequalized.zf.equalizer');
|
|
for (var i = 0, len = groups.length; i < len; i++) {
|
|
var groupsILength = groups[i].length,
|
|
max = groups[i][groupsILength - 1];
|
|
if (groupsILength <= 2) {
|
|
$(groups[i][0][0]).css({ 'height': 'auto' });
|
|
continue;
|
|
}
|
|
/**
|
|
* Fires before the heights per row are applied
|
|
* @event Equalizer#preequalizedRow
|
|
*/
|
|
this.$element.trigger('preequalizedrow.zf.equalizer');
|
|
for (var j = 0, lenJ = groupsILength - 1; j < lenJ; j++) {
|
|
$(groups[i][j][0]).css({ 'height': max });
|
|
}
|
|
/**
|
|
* Fires when the heights per row have been applied
|
|
* @event Equalizer#postequalizedRow
|
|
*/
|
|
this.$element.trigger('postequalizedrow.zf.equalizer');
|
|
}
|
|
/**
|
|
* Fires when the heights have been applied
|
|
*/
|
|
this.$element.trigger('postequalized.zf.equalizer');
|
|
}
|
|
|
|
/**
|
|
* Destroys an instance of Equalizer.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
this._pauseEvents();
|
|
this.$watched.css('height', 'auto');
|
|
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return Equalizer;
|
|
}();
|
|
|
|
/**
|
|
* Default settings for plugin
|
|
*/
|
|
|
|
|
|
Equalizer.defaults = {
|
|
/**
|
|
* Enable height equalization when stacked on smaller screens.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
equalizeOnStack: false,
|
|
/**
|
|
* Enable height equalization row by row.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
equalizeByRow: false,
|
|
/**
|
|
* String representing the minimum breakpoint size the plugin should equalize heights on.
|
|
* @option
|
|
* @example 'medium'
|
|
*/
|
|
equalizeOn: ''
|
|
};
|
|
|
|
// Window exports
|
|
Foundation.plugin(Equalizer, 'Equalizer');
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* Interchange module.
|
|
* @module foundation.interchange
|
|
* @requires foundation.util.mediaQuery
|
|
* @requires foundation.util.timerAndImageLoader
|
|
*/
|
|
|
|
var Interchange = function () {
|
|
/**
|
|
* Creates a new instance of Interchange.
|
|
* @class
|
|
* @fires Interchange#init
|
|
* @param {Object} element - jQuery object to add the trigger to.
|
|
* @param {Object} options - Overrides to the default plugin settings.
|
|
*/
|
|
function Interchange(element, options) {
|
|
_classCallCheck(this, Interchange);
|
|
|
|
this.$element = element;
|
|
this.options = $.extend({}, Interchange.defaults, options);
|
|
this.rules = [];
|
|
this.currentPath = '';
|
|
|
|
this._init();
|
|
this._events();
|
|
|
|
Foundation.registerPlugin(this, 'Interchange');
|
|
}
|
|
|
|
/**
|
|
* Initializes the Interchange plugin and calls functions to get interchange functioning on load.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(Interchange, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
this._addBreakpoints();
|
|
this._generateRules();
|
|
this._reflow();
|
|
}
|
|
|
|
/**
|
|
* Initializes events for Interchange.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events() {
|
|
$(window).on('resize.zf.interchange', Foundation.util.throttle(this._reflow.bind(this), 50));
|
|
}
|
|
|
|
/**
|
|
* Calls necessary functions to update Interchange upon DOM change
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_reflow',
|
|
value: function _reflow() {
|
|
var match;
|
|
|
|
// Iterate through each rule, but only save the last match
|
|
for (var i in this.rules) {
|
|
if (this.rules.hasOwnProperty(i)) {
|
|
var rule = this.rules[i];
|
|
|
|
if (window.matchMedia(rule.query).matches) {
|
|
match = rule;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (match) {
|
|
this.replace(match.path);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the Foundation breakpoints and adds them to the Interchange.SPECIAL_QUERIES object.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_addBreakpoints',
|
|
value: function _addBreakpoints() {
|
|
for (var i in Foundation.MediaQuery.queries) {
|
|
if (Foundation.MediaQuery.queries.hasOwnProperty(i)) {
|
|
var query = Foundation.MediaQuery.queries[i];
|
|
Interchange.SPECIAL_QUERIES[query.name] = query.value;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks the Interchange element for the provided media query + content pairings
|
|
* @function
|
|
* @private
|
|
* @param {Object} element - jQuery object that is an Interchange instance
|
|
* @returns {Array} scenarios - Array of objects that have 'mq' and 'path' keys with corresponding keys
|
|
*/
|
|
|
|
}, {
|
|
key: '_generateRules',
|
|
value: function _generateRules(element) {
|
|
var rulesList = [];
|
|
var rules;
|
|
|
|
if (this.options.rules) {
|
|
rules = this.options.rules;
|
|
} else {
|
|
rules = this.$element.data('interchange').match(/\[.*?\]/g);
|
|
}
|
|
|
|
for (var i in rules) {
|
|
if (rules.hasOwnProperty(i)) {
|
|
var rule = rules[i].slice(1, -1).split(', ');
|
|
var path = rule.slice(0, -1).join('');
|
|
var query = rule[rule.length - 1];
|
|
|
|
if (Interchange.SPECIAL_QUERIES[query]) {
|
|
query = Interchange.SPECIAL_QUERIES[query];
|
|
}
|
|
|
|
rulesList.push({
|
|
path: path,
|
|
query: query
|
|
});
|
|
}
|
|
}
|
|
|
|
this.rules = rulesList;
|
|
}
|
|
|
|
/**
|
|
* Update the `src` property of an image, or change the HTML of a container, to the specified path.
|
|
* @function
|
|
* @param {String} path - Path to the image or HTML partial.
|
|
* @fires Interchange#replaced
|
|
*/
|
|
|
|
}, {
|
|
key: 'replace',
|
|
value: function replace(path) {
|
|
if (this.currentPath === path) return;
|
|
|
|
var _this = this,
|
|
trigger = 'replaced.zf.interchange';
|
|
|
|
// Replacing images
|
|
if (this.$element[0].nodeName === 'IMG') {
|
|
this.$element.attr('src', path).on('load', function () {
|
|
_this.currentPath = path;
|
|
}).trigger(trigger);
|
|
}
|
|
// Replacing background images
|
|
else if (path.match(/\.(gif|jpg|jpeg|png|svg|tiff)([?#].*)?/i)) {
|
|
this.$element.css({ 'background-image': 'url(' + path + ')' }).trigger(trigger);
|
|
}
|
|
// Replacing HTML
|
|
else {
|
|
$.get(path, function (response) {
|
|
_this.$element.html(response).trigger(trigger);
|
|
$(response).foundation();
|
|
_this.currentPath = path;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Fires when content in an Interchange element is done being loaded.
|
|
* @event Interchange#replaced
|
|
*/
|
|
// this.$element.trigger('replaced.zf.interchange');
|
|
}
|
|
|
|
/**
|
|
* Destroys an instance of interchange.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
//TODO this.
|
|
}
|
|
}]);
|
|
|
|
return Interchange;
|
|
}();
|
|
|
|
/**
|
|
* Default settings for plugin
|
|
*/
|
|
|
|
|
|
Interchange.defaults = {
|
|
/**
|
|
* Rules to be applied to Interchange elements. Set with the `data-interchange` array notation.
|
|
* @option
|
|
*/
|
|
rules: null
|
|
};
|
|
|
|
Interchange.SPECIAL_QUERIES = {
|
|
'landscape': 'screen and (orientation: landscape)',
|
|
'portrait': 'screen and (orientation: portrait)',
|
|
'retina': 'only screen and (-webkit-min-device-pixel-ratio: 2), only screen and (min--moz-device-pixel-ratio: 2), only screen and (-o-min-device-pixel-ratio: 2/1), only screen and (min-device-pixel-ratio: 2), only screen and (min-resolution: 192dpi), only screen and (min-resolution: 2dppx)'
|
|
};
|
|
|
|
// Window exports
|
|
Foundation.plugin(Interchange, 'Interchange');
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* Magellan module.
|
|
* @module foundation.magellan
|
|
*/
|
|
|
|
var Magellan = function () {
|
|
/**
|
|
* Creates a new instance of Magellan.
|
|
* @class
|
|
* @fires Magellan#init
|
|
* @param {Object} element - jQuery object to add the trigger to.
|
|
* @param {Object} options - Overrides to the default plugin settings.
|
|
*/
|
|
function Magellan(element, options) {
|
|
_classCallCheck(this, Magellan);
|
|
|
|
this.$element = element;
|
|
this.options = $.extend({}, Magellan.defaults, this.$element.data(), options);
|
|
|
|
this._init();
|
|
|
|
Foundation.registerPlugin(this, 'Magellan');
|
|
}
|
|
|
|
/**
|
|
* Initializes the Magellan plugin and calls functions to get equalizer functioning on load.
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(Magellan, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
var id = this.$element[0].id || Foundation.GetYoDigits(6, 'magellan');
|
|
var _this = this;
|
|
this.$targets = $('[data-magellan-target]');
|
|
this.$links = this.$element.find('a');
|
|
this.$element.attr({
|
|
'data-resize': id,
|
|
'data-scroll': id,
|
|
'id': id
|
|
});
|
|
this.$active = $();
|
|
this.scrollPos = parseInt(window.pageYOffset, 10);
|
|
|
|
this._events();
|
|
}
|
|
|
|
/**
|
|
* Calculates an array of pixel values that are the demarcation lines between locations on the page.
|
|
* Can be invoked if new elements are added or the size of a location changes.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'calcPoints',
|
|
value: function calcPoints() {
|
|
var _this = this,
|
|
body = document.body,
|
|
html = document.documentElement;
|
|
|
|
this.points = [];
|
|
this.winHeight = Math.round(Math.max(window.innerHeight, html.clientHeight));
|
|
this.docHeight = Math.round(Math.max(body.scrollHeight, body.offsetHeight, html.clientHeight, html.scrollHeight, html.offsetHeight));
|
|
|
|
this.$targets.each(function () {
|
|
var $tar = $(this),
|
|
pt = Math.round($tar.offset().top - _this.options.threshold);
|
|
$tar.targetPoint = pt;
|
|
_this.points.push(pt);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Initializes events for Magellan.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events() {
|
|
var _this = this,
|
|
$body = $('html, body'),
|
|
opts = {
|
|
duration: _this.options.animationDuration,
|
|
easing: _this.options.animationEasing
|
|
};
|
|
$(window).one('load', function () {
|
|
if (_this.options.deepLinking) {
|
|
if (location.hash) {
|
|
_this.scrollToLoc(location.hash);
|
|
}
|
|
}
|
|
_this.calcPoints();
|
|
_this._updateActive();
|
|
});
|
|
|
|
this.$element.on({
|
|
'resizeme.zf.trigger': this.reflow.bind(this),
|
|
'scrollme.zf.trigger': this._updateActive.bind(this)
|
|
}).on('click.zf.magellan', 'a[href^="#"]', function (e) {
|
|
e.preventDefault();
|
|
var arrival = this.getAttribute('href');
|
|
_this.scrollToLoc(arrival);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Function to scroll to a given location on the page.
|
|
* @param {String} loc - a properly formatted jQuery id selector. Example: '#foo'
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'scrollToLoc',
|
|
value: function scrollToLoc(loc) {
|
|
// Do nothing if target does not exist to prevent errors
|
|
if (!$(loc).length) {
|
|
return false;
|
|
}
|
|
var scrollPos = Math.round($(loc).offset().top - this.options.threshold / 2 - this.options.barOffset);
|
|
|
|
$('html, body').stop(true).animate({ scrollTop: scrollPos }, this.options.animationDuration, this.options.animationEasing);
|
|
}
|
|
|
|
/**
|
|
* Calls necessary functions to update Magellan upon DOM change
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'reflow',
|
|
value: function reflow() {
|
|
this.calcPoints();
|
|
this._updateActive();
|
|
}
|
|
|
|
/**
|
|
* Updates the visibility of an active location link, and updates the url hash for the page, if deepLinking enabled.
|
|
* @private
|
|
* @function
|
|
* @fires Magellan#update
|
|
*/
|
|
|
|
}, {
|
|
key: '_updateActive',
|
|
value: function _updateActive() /*evt, elem, scrollPos*/{
|
|
var winPos = /*scrollPos ||*/parseInt(window.pageYOffset, 10),
|
|
curIdx;
|
|
|
|
if (winPos + this.winHeight === this.docHeight) {
|
|
curIdx = this.points.length - 1;
|
|
} else if (winPos < this.points[0]) {
|
|
curIdx = 0;
|
|
} else {
|
|
var isDown = this.scrollPos < winPos,
|
|
_this = this,
|
|
curVisible = this.points.filter(function (p, i) {
|
|
return isDown ? p - _this.options.barOffset <= winPos : p - _this.options.barOffset - _this.options.threshold <= winPos;
|
|
});
|
|
curIdx = curVisible.length ? curVisible.length - 1 : 0;
|
|
}
|
|
|
|
this.$active.removeClass(this.options.activeClass);
|
|
this.$active = this.$links.filter('[href="#' + this.$targets.eq(curIdx).data('magellan-target') + '"]').addClass(this.options.activeClass);
|
|
|
|
if (this.options.deepLinking) {
|
|
var hash = this.$active[0].getAttribute('href');
|
|
if (window.history.pushState) {
|
|
window.history.pushState(null, null, hash);
|
|
} else {
|
|
window.location.hash = hash;
|
|
}
|
|
}
|
|
|
|
this.scrollPos = winPos;
|
|
/**
|
|
* Fires when magellan is finished updating to the new active element.
|
|
* @event Magellan#update
|
|
*/
|
|
this.$element.trigger('update.zf.magellan', [this.$active]);
|
|
}
|
|
|
|
/**
|
|
* Destroys an instance of Magellan and resets the url of the window.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
this.$element.off('.zf.trigger .zf.magellan').find('.' + this.options.activeClass).removeClass(this.options.activeClass);
|
|
|
|
if (this.options.deepLinking) {
|
|
var hash = this.$active[0].getAttribute('href');
|
|
window.location.hash.replace(hash, '');
|
|
}
|
|
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return Magellan;
|
|
}();
|
|
|
|
/**
|
|
* Default settings for plugin
|
|
*/
|
|
|
|
|
|
Magellan.defaults = {
|
|
/**
|
|
* Amount of time, in ms, the animated scrolling should take between locations.
|
|
* @option
|
|
* @example 500
|
|
*/
|
|
animationDuration: 500,
|
|
/**
|
|
* Animation style to use when scrolling between locations.
|
|
* @option
|
|
* @example 'ease-in-out'
|
|
*/
|
|
animationEasing: 'linear',
|
|
/**
|
|
* Number of pixels to use as a marker for location changes.
|
|
* @option
|
|
* @example 50
|
|
*/
|
|
threshold: 50,
|
|
/**
|
|
* Class applied to the active locations link on the magellan container.
|
|
* @option
|
|
* @example 'active'
|
|
*/
|
|
activeClass: 'active',
|
|
/**
|
|
* Allows the script to manipulate the url of the current page, and if supported, alter the history.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
deepLinking: false,
|
|
/**
|
|
* Number of pixels to offset the scroll of the page on item click if using a sticky nav bar.
|
|
* @option
|
|
* @example 25
|
|
*/
|
|
barOffset: 0
|
|
};
|
|
|
|
// Window exports
|
|
Foundation.plugin(Magellan, 'Magellan');
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* OffCanvas module.
|
|
* @module foundation.offcanvas
|
|
* @requires foundation.util.mediaQuery
|
|
* @requires foundation.util.triggers
|
|
* @requires foundation.util.motion
|
|
*/
|
|
|
|
var OffCanvas = function () {
|
|
/**
|
|
* Creates a new instance of an off-canvas wrapper.
|
|
* @class
|
|
* @fires OffCanvas#init
|
|
* @param {Object} element - jQuery object to initialize.
|
|
* @param {Object} options - Overrides to the default plugin settings.
|
|
*/
|
|
function OffCanvas(element, options) {
|
|
_classCallCheck(this, OffCanvas);
|
|
|
|
this.$element = element;
|
|
this.options = $.extend({}, OffCanvas.defaults, this.$element.data(), options);
|
|
this.$lastTrigger = $();
|
|
this.$triggers = $();
|
|
|
|
this._init();
|
|
this._events();
|
|
|
|
Foundation.registerPlugin(this, 'OffCanvas');
|
|
Foundation.Keyboard.register('OffCanvas', {
|
|
'ESCAPE': 'close'
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Initializes the off-canvas wrapper by adding the exit overlay (if needed).
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(OffCanvas, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
var id = this.$element.attr('id');
|
|
|
|
this.$element.attr('aria-hidden', 'true');
|
|
|
|
// Find triggers that affect this element and add aria-expanded to them
|
|
this.$triggers = $(document).find('[data-open="' + id + '"], [data-close="' + id + '"], [data-toggle="' + id + '"]').attr('aria-expanded', 'false').attr('aria-controls', id);
|
|
|
|
// Add a close trigger over the body if necessary
|
|
if (this.options.closeOnClick) {
|
|
if ($('.js-off-canvas-exit').length) {
|
|
this.$exiter = $('.js-off-canvas-exit');
|
|
} else {
|
|
var exiter = document.createElement('div');
|
|
exiter.setAttribute('class', 'js-off-canvas-exit');
|
|
$('[data-off-canvas-content]').append(exiter);
|
|
|
|
this.$exiter = $(exiter);
|
|
}
|
|
}
|
|
|
|
this.options.isRevealed = this.options.isRevealed || new RegExp(this.options.revealClass, 'g').test(this.$element[0].className);
|
|
|
|
if (this.options.isRevealed) {
|
|
this.options.revealOn = this.options.revealOn || this.$element[0].className.match(/(reveal-for-medium|reveal-for-large)/g)[0].split('-')[2];
|
|
this._setMQChecker();
|
|
}
|
|
if (!this.options.transitionTime) {
|
|
this.options.transitionTime = parseFloat(window.getComputedStyle($('[data-off-canvas-wrapper]')[0]).transitionDuration) * 1000;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds event handlers to the off-canvas wrapper and the exit overlay.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events() {
|
|
this.$element.off('.zf.trigger .zf.offcanvas').on({
|
|
'open.zf.trigger': this.open.bind(this),
|
|
'close.zf.trigger': this.close.bind(this),
|
|
'toggle.zf.trigger': this.toggle.bind(this),
|
|
'keydown.zf.offcanvas': this._handleKeyboard.bind(this)
|
|
});
|
|
|
|
if (this.options.closeOnClick && this.$exiter.length) {
|
|
this.$exiter.on({ 'click.zf.offcanvas': this.close.bind(this) });
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Applies event listener for elements that will reveal at certain breakpoints.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_setMQChecker',
|
|
value: function _setMQChecker() {
|
|
var _this = this;
|
|
|
|
$(window).on('changed.zf.mediaquery', function () {
|
|
if (Foundation.MediaQuery.atLeast(_this.options.revealOn)) {
|
|
_this.reveal(true);
|
|
} else {
|
|
_this.reveal(false);
|
|
}
|
|
}).one('load.zf.offcanvas', function () {
|
|
if (Foundation.MediaQuery.atLeast(_this.options.revealOn)) {
|
|
_this.reveal(true);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Handles the revealing/hiding the off-canvas at breakpoints, not the same as open.
|
|
* @param {Boolean} isRevealed - true if element should be revealed.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'reveal',
|
|
value: function reveal(isRevealed) {
|
|
var $closer = this.$element.find('[data-close]');
|
|
if (isRevealed) {
|
|
this.close();
|
|
this.isRevealed = true;
|
|
// if (!this.options.forceTop) {
|
|
// var scrollPos = parseInt(window.pageYOffset);
|
|
// this.$element[0].style.transform = 'translate(0,' + scrollPos + 'px)';
|
|
// }
|
|
// if (this.options.isSticky) { this._stick(); }
|
|
this.$element.off('open.zf.trigger toggle.zf.trigger');
|
|
if ($closer.length) {
|
|
$closer.hide();
|
|
}
|
|
} else {
|
|
this.isRevealed = false;
|
|
// if (this.options.isSticky || !this.options.forceTop) {
|
|
// this.$element[0].style.transform = '';
|
|
// $(window).off('scroll.zf.offcanvas');
|
|
// }
|
|
this.$element.on({
|
|
'open.zf.trigger': this.open.bind(this),
|
|
'toggle.zf.trigger': this.toggle.bind(this)
|
|
});
|
|
if ($closer.length) {
|
|
$closer.show();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Opens the off-canvas menu.
|
|
* @function
|
|
* @param {Object} event - Event object passed from listener.
|
|
* @param {jQuery} trigger - element that triggered the off-canvas to open.
|
|
* @fires OffCanvas#opened
|
|
*/
|
|
|
|
}, {
|
|
key: 'open',
|
|
value: function open(event, trigger) {
|
|
if (this.$element.hasClass('is-open') || this.isRevealed) {
|
|
return;
|
|
}
|
|
var _this = this,
|
|
$body = $(document.body);
|
|
|
|
if (this.options.forceTop) {
|
|
$('body').scrollTop(0);
|
|
}
|
|
// window.pageYOffset = 0;
|
|
|
|
// if (!this.options.forceTop) {
|
|
// var scrollPos = parseInt(window.pageYOffset);
|
|
// this.$element[0].style.transform = 'translate(0,' + scrollPos + 'px)';
|
|
// if (this.$exiter.length) {
|
|
// this.$exiter[0].style.transform = 'translate(0,' + scrollPos + 'px)';
|
|
// }
|
|
// }
|
|
/**
|
|
* Fires when the off-canvas menu opens.
|
|
* @event OffCanvas#opened
|
|
*/
|
|
|
|
var $wrapper = $('[data-off-canvas-wrapper]');
|
|
$wrapper.addClass('is-off-canvas-open is-open-' + _this.options.position);
|
|
|
|
_this.$element.addClass('is-open');
|
|
|
|
// if (_this.options.isSticky) {
|
|
// _this._stick();
|
|
// }
|
|
|
|
this.$triggers.attr('aria-expanded', 'true');
|
|
this.$element.attr('aria-hidden', 'false').trigger('opened.zf.offcanvas');
|
|
|
|
if (this.options.closeOnClick) {
|
|
this.$exiter.addClass('is-visible');
|
|
}
|
|
|
|
if (trigger) {
|
|
this.$lastTrigger = trigger;
|
|
}
|
|
|
|
if (this.options.autoFocus) {
|
|
$wrapper.one(Foundation.transitionend($wrapper), function () {
|
|
if (_this.$element.hasClass('is-open')) {
|
|
// handle double clicks
|
|
_this.$element.attr('tabindex', '-1');
|
|
_this.$element.focus();
|
|
}
|
|
});
|
|
}
|
|
|
|
if (this.options.trapFocus) {
|
|
$wrapper.one(Foundation.transitionend($wrapper), function () {
|
|
if (_this.$element.hasClass('is-open')) {
|
|
// handle double clicks
|
|
_this.$element.attr('tabindex', '-1');
|
|
_this.trapFocus();
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Traps focus within the offcanvas on open.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_trapFocus',
|
|
value: function _trapFocus() {
|
|
var focusable = Foundation.Keyboard.findFocusable(this.$element),
|
|
first = focusable.eq(0),
|
|
last = focusable.eq(-1);
|
|
|
|
focusable.off('.zf.offcanvas').on('keydown.zf.offcanvas', function (e) {
|
|
var key = Foundation.Keyboard.parseKey(e);
|
|
if (key === 'TAB' && e.target === last[0]) {
|
|
e.preventDefault();
|
|
first.focus();
|
|
}
|
|
if (key === 'SHIFT_TAB' && e.target === first[0]) {
|
|
e.preventDefault();
|
|
last.focus();
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Allows the offcanvas to appear sticky utilizing translate properties.
|
|
* @private
|
|
*/
|
|
// OffCanvas.prototype._stick = function() {
|
|
// var elStyle = this.$element[0].style;
|
|
//
|
|
// if (this.options.closeOnClick) {
|
|
// var exitStyle = this.$exiter[0].style;
|
|
// }
|
|
//
|
|
// $(window).on('scroll.zf.offcanvas', function(e) {
|
|
// console.log(e);
|
|
// var pageY = window.pageYOffset;
|
|
// elStyle.transform = 'translate(0,' + pageY + 'px)';
|
|
// if (exitStyle !== undefined) { exitStyle.transform = 'translate(0,' + pageY + 'px)'; }
|
|
// });
|
|
// // this.$element.trigger('stuck.zf.offcanvas');
|
|
// };
|
|
/**
|
|
* Closes the off-canvas menu.
|
|
* @function
|
|
* @param {Function} cb - optional cb to fire after closure.
|
|
* @fires OffCanvas#closed
|
|
*/
|
|
|
|
}, {
|
|
key: 'close',
|
|
value: function close(cb) {
|
|
if (!this.$element.hasClass('is-open') || this.isRevealed) {
|
|
return;
|
|
}
|
|
|
|
var _this = this;
|
|
|
|
// Foundation.Move(this.options.transitionTime, this.$element, function() {
|
|
$('[data-off-canvas-wrapper]').removeClass('is-off-canvas-open is-open-' + _this.options.position);
|
|
_this.$element.removeClass('is-open');
|
|
// Foundation._reflow();
|
|
// });
|
|
this.$element.attr('aria-hidden', 'true')
|
|
/**
|
|
* Fires when the off-canvas menu opens.
|
|
* @event OffCanvas#closed
|
|
*/
|
|
.trigger('closed.zf.offcanvas');
|
|
// if (_this.options.isSticky || !_this.options.forceTop) {
|
|
// setTimeout(function() {
|
|
// _this.$element[0].style.transform = '';
|
|
// $(window).off('scroll.zf.offcanvas');
|
|
// }, this.options.transitionTime);
|
|
// }
|
|
if (this.options.closeOnClick) {
|
|
this.$exiter.removeClass('is-visible');
|
|
}
|
|
|
|
this.$triggers.attr('aria-expanded', 'false');
|
|
if (this.options.trapFocus) {
|
|
$('[data-off-canvas-content]').removeAttr('tabindex');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Toggles the off-canvas menu open or closed.
|
|
* @function
|
|
* @param {Object} event - Event object passed from listener.
|
|
* @param {jQuery} trigger - element that triggered the off-canvas to open.
|
|
*/
|
|
|
|
}, {
|
|
key: 'toggle',
|
|
value: function toggle(event, trigger) {
|
|
if (this.$element.hasClass('is-open')) {
|
|
this.close(event, trigger);
|
|
} else {
|
|
this.open(event, trigger);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handles keyboard input when detected. When the escape key is pressed, the off-canvas menu closes, and focus is restored to the element that opened the menu.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_handleKeyboard',
|
|
value: function _handleKeyboard(e) {
|
|
var _this2 = this;
|
|
|
|
Foundation.Keyboard.handleKey(e, 'OffCanvas', {
|
|
close: function () {
|
|
_this2.close();
|
|
_this2.$lastTrigger.focus();
|
|
return true;
|
|
},
|
|
handled: function () {
|
|
e.stopPropagation();
|
|
e.preventDefault();
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Destroys the offcanvas plugin.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
this.close();
|
|
this.$element.off('.zf.trigger .zf.offcanvas');
|
|
this.$exiter.off('.zf.offcanvas');
|
|
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return OffCanvas;
|
|
}();
|
|
|
|
OffCanvas.defaults = {
|
|
/**
|
|
* Allow the user to click outside of the menu to close it.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
closeOnClick: true,
|
|
|
|
/**
|
|
* Amount of time in ms the open and close transition requires. If none selected, pulls from body style.
|
|
* @option
|
|
* @example 500
|
|
*/
|
|
transitionTime: 0,
|
|
|
|
/**
|
|
* Direction the offcanvas opens from. Determines class applied to body.
|
|
* @option
|
|
* @example left
|
|
*/
|
|
position: 'left',
|
|
|
|
/**
|
|
* Force the page to scroll to top on open.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
forceTop: true,
|
|
|
|
/**
|
|
* Allow the offcanvas to remain open for certain breakpoints.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
isRevealed: false,
|
|
|
|
/**
|
|
* Breakpoint at which to reveal. JS will use a RegExp to target standard classes, if changing classnames, pass your class with the `revealClass` option.
|
|
* @option
|
|
* @example reveal-for-large
|
|
*/
|
|
revealOn: null,
|
|
|
|
/**
|
|
* Force focus to the offcanvas on open. If true, will focus the opening trigger on close. Sets tabindex of [data-off-canvas-content] to -1 for accessibility purposes.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
autoFocus: true,
|
|
|
|
/**
|
|
* Class used to force an offcanvas to remain open. Foundation defaults for this are `reveal-for-large` & `reveal-for-medium`.
|
|
* @option
|
|
* TODO improve the regex testing for this.
|
|
* @example reveal-for-large
|
|
*/
|
|
revealClass: 'reveal-for-',
|
|
|
|
/**
|
|
* Triggers optional focus trapping when opening an offcanvas. Sets tabindex of [data-off-canvas-content] to -1 for accessibility purposes.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
trapFocus: false
|
|
};
|
|
|
|
// Window exports
|
|
Foundation.plugin(OffCanvas, 'OffCanvas');
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* Orbit module.
|
|
* @module foundation.orbit
|
|
* @requires foundation.util.keyboard
|
|
* @requires foundation.util.motion
|
|
* @requires foundation.util.timerAndImageLoader
|
|
* @requires foundation.util.touch
|
|
*/
|
|
|
|
var Orbit = function () {
|
|
/**
|
|
* Creates a new instance of an orbit carousel.
|
|
* @class
|
|
* @param {jQuery} element - jQuery object to make into an Orbit Carousel.
|
|
* @param {Object} options - Overrides to the default plugin settings.
|
|
*/
|
|
function Orbit(element, options) {
|
|
_classCallCheck(this, Orbit);
|
|
|
|
this.$element = element;
|
|
this.options = $.extend({}, Orbit.defaults, this.$element.data(), options);
|
|
|
|
this._init();
|
|
|
|
Foundation.registerPlugin(this, 'Orbit');
|
|
Foundation.Keyboard.register('Orbit', {
|
|
'ltr': {
|
|
'ARROW_RIGHT': 'next',
|
|
'ARROW_LEFT': 'previous'
|
|
},
|
|
'rtl': {
|
|
'ARROW_LEFT': 'next',
|
|
'ARROW_RIGHT': 'previous'
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Initializes the plugin by creating jQuery collections, setting attributes, and starting the animation.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(Orbit, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
this.$wrapper = this.$element.find('.' + this.options.containerClass);
|
|
this.$slides = this.$element.find('.' + this.options.slideClass);
|
|
var $images = this.$element.find('img'),
|
|
initActive = this.$slides.filter('.is-active');
|
|
|
|
if (!initActive.length) {
|
|
this.$slides.eq(0).addClass('is-active');
|
|
}
|
|
|
|
if (!this.options.useMUI) {
|
|
this.$slides.addClass('no-motionui');
|
|
}
|
|
|
|
if ($images.length) {
|
|
Foundation.onImagesLoaded($images, this._prepareForOrbit.bind(this));
|
|
} else {
|
|
this._prepareForOrbit(); //hehe
|
|
}
|
|
|
|
if (this.options.bullets) {
|
|
this._loadBullets();
|
|
}
|
|
|
|
this._events();
|
|
|
|
if (this.options.autoPlay && this.$slides.length > 1) {
|
|
this.geoSync();
|
|
}
|
|
|
|
if (this.options.accessible) {
|
|
// allow wrapper to be focusable to enable arrow navigation
|
|
this.$wrapper.attr('tabindex', 0);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a jQuery collection of bullets, if they are being used.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_loadBullets',
|
|
value: function _loadBullets() {
|
|
this.$bullets = this.$element.find('.' + this.options.boxOfBullets).find('button');
|
|
}
|
|
|
|
/**
|
|
* Sets a `timer` object on the orbit, and starts the counter for the next slide.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'geoSync',
|
|
value: function geoSync() {
|
|
var _this = this;
|
|
this.timer = new Foundation.Timer(this.$element, {
|
|
duration: this.options.timerDelay,
|
|
infinite: false
|
|
}, function () {
|
|
_this.changeSlide(true);
|
|
});
|
|
this.timer.start();
|
|
}
|
|
|
|
/**
|
|
* Sets wrapper and slide heights for the orbit.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_prepareForOrbit',
|
|
value: function _prepareForOrbit() {
|
|
var _this = this;
|
|
this._setWrapperHeight(function (max) {
|
|
_this._setSlideHeight(max);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Calulates the height of each slide in the collection, and uses the tallest one for the wrapper height.
|
|
* @function
|
|
* @private
|
|
* @param {Function} cb - a callback function to fire when complete.
|
|
*/
|
|
|
|
}, {
|
|
key: '_setWrapperHeight',
|
|
value: function _setWrapperHeight(cb) {
|
|
//rewrite this to `for` loop
|
|
var max = 0,
|
|
temp,
|
|
counter = 0;
|
|
|
|
this.$slides.each(function () {
|
|
temp = this.getBoundingClientRect().height;
|
|
$(this).attr('data-slide', counter);
|
|
|
|
if (counter) {
|
|
//if not the first slide, set css position and display property
|
|
$(this).css({ 'position': 'relative', 'display': 'none' });
|
|
}
|
|
max = temp > max ? temp : max;
|
|
counter++;
|
|
});
|
|
|
|
if (counter === this.$slides.length) {
|
|
this.$wrapper.css({ 'height': max }); //only change the wrapper height property once.
|
|
cb(max); //fire callback with max height dimension.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the max-height of each slide.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_setSlideHeight',
|
|
value: function _setSlideHeight(height) {
|
|
this.$slides.each(function () {
|
|
$(this).css('max-height', height);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Adds event listeners to basically everything within the element.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events() {
|
|
var _this = this;
|
|
|
|
//***************************************
|
|
//**Now using custom event - thanks to:**
|
|
//** Yohai Ararat of Toronto **
|
|
//***************************************
|
|
if (this.$slides.length > 1) {
|
|
|
|
if (this.options.swipe) {
|
|
this.$slides.off('swipeleft.zf.orbit swiperight.zf.orbit').on('swipeleft.zf.orbit', function (e) {
|
|
e.preventDefault();
|
|
_this.changeSlide(true);
|
|
}).on('swiperight.zf.orbit', function (e) {
|
|
e.preventDefault();
|
|
_this.changeSlide(false);
|
|
});
|
|
}
|
|
//***************************************
|
|
|
|
if (this.options.autoPlay) {
|
|
this.$slides.on('click.zf.orbit', function () {
|
|
_this.$element.data('clickedOn', _this.$element.data('clickedOn') ? false : true);
|
|
_this.timer[_this.$element.data('clickedOn') ? 'pause' : 'start']();
|
|
});
|
|
|
|
if (this.options.pauseOnHover) {
|
|
this.$element.on('mouseenter.zf.orbit', function () {
|
|
_this.timer.pause();
|
|
}).on('mouseleave.zf.orbit', function () {
|
|
if (!_this.$element.data('clickedOn')) {
|
|
_this.timer.start();
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
if (this.options.navButtons) {
|
|
var $controls = this.$element.find('.' + this.options.nextClass + ', .' + this.options.prevClass);
|
|
$controls.attr('tabindex', 0)
|
|
//also need to handle enter/return and spacebar key presses
|
|
.on('click.zf.orbit touchend.zf.orbit', function (e) {
|
|
e.preventDefault();
|
|
_this.changeSlide($(this).hasClass(_this.options.nextClass));
|
|
});
|
|
}
|
|
|
|
if (this.options.bullets) {
|
|
this.$bullets.on('click.zf.orbit touchend.zf.orbit', function () {
|
|
if (/is-active/g.test(this.className)) {
|
|
return false;
|
|
} //if this is active, kick out of function.
|
|
var idx = $(this).data('slide'),
|
|
ltr = idx > _this.$slides.filter('.is-active').data('slide'),
|
|
$slide = _this.$slides.eq(idx);
|
|
|
|
_this.changeSlide(ltr, $slide, idx);
|
|
});
|
|
}
|
|
|
|
if (this.options.accessible) {
|
|
this.$wrapper.add(this.$bullets).on('keydown.zf.orbit', function (e) {
|
|
// handle keyboard event with keyboard util
|
|
Foundation.Keyboard.handleKey(e, 'Orbit', {
|
|
next: function () {
|
|
_this.changeSlide(true);
|
|
},
|
|
previous: function () {
|
|
_this.changeSlide(false);
|
|
},
|
|
handled: function () {
|
|
// if bullet is focused, make sure focus moves
|
|
if ($(e.target).is(_this.$bullets)) {
|
|
_this.$bullets.filter('.is-active').focus();
|
|
}
|
|
}
|
|
});
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Changes the current slide to a new one.
|
|
* @function
|
|
* @param {Boolean} isLTR - flag if the slide should move left to right.
|
|
* @param {jQuery} chosenSlide - the jQuery element of the slide to show next, if one is selected.
|
|
* @param {Number} idx - the index of the new slide in its collection, if one chosen.
|
|
* @fires Orbit#slidechange
|
|
*/
|
|
|
|
}, {
|
|
key: 'changeSlide',
|
|
value: function changeSlide(isLTR, chosenSlide, idx) {
|
|
var $curSlide = this.$slides.filter('.is-active').eq(0);
|
|
|
|
if (/mui/g.test($curSlide[0].className)) {
|
|
return false;
|
|
} //if the slide is currently animating, kick out of the function
|
|
|
|
var $firstSlide = this.$slides.first(),
|
|
$lastSlide = this.$slides.last(),
|
|
dirIn = isLTR ? 'Right' : 'Left',
|
|
dirOut = isLTR ? 'Left' : 'Right',
|
|
_this = this,
|
|
$newSlide;
|
|
|
|
if (!chosenSlide) {
|
|
//most of the time, this will be auto played or clicked from the navButtons.
|
|
$newSlide = isLTR ? //if wrapping enabled, check to see if there is a `next` or `prev` sibling, if not, select the first or last slide to fill in. if wrapping not enabled, attempt to select `next` or `prev`, if there's nothing there, the function will kick out on next step. CRAZY NESTED TERNARIES!!!!!
|
|
this.options.infiniteWrap ? $curSlide.next('.' + this.options.slideClass).length ? $curSlide.next('.' + this.options.slideClass) : $firstSlide : $curSlide.next('.' + this.options.slideClass) : //pick next slide if moving left to right
|
|
this.options.infiniteWrap ? $curSlide.prev('.' + this.options.slideClass).length ? $curSlide.prev('.' + this.options.slideClass) : $lastSlide : $curSlide.prev('.' + this.options.slideClass); //pick prev slide if moving right to left
|
|
} else {
|
|
$newSlide = chosenSlide;
|
|
}
|
|
|
|
if ($newSlide.length) {
|
|
/**
|
|
* Triggers before the next slide starts animating in and only if a next slide has been found.
|
|
* @event Orbit#beforeslidechange
|
|
*/
|
|
this.$element.trigger('beforeslidechange.zf.orbit', [$curSlide, $newSlide]);
|
|
|
|
if (this.options.bullets) {
|
|
idx = idx || this.$slides.index($newSlide); //grab index to update bullets
|
|
this._updateBullets(idx);
|
|
}
|
|
|
|
if (this.options.useMUI) {
|
|
Foundation.Motion.animateIn($newSlide.addClass('is-active').css({ 'position': 'absolute', 'top': 0 }), this.options['animInFrom' + dirIn], function () {
|
|
$newSlide.css({ 'position': 'relative', 'display': 'block' }).attr('aria-live', 'polite');
|
|
});
|
|
|
|
Foundation.Motion.animateOut($curSlide.removeClass('is-active'), this.options['animOutTo' + dirOut], function () {
|
|
$curSlide.removeAttr('aria-live');
|
|
if (_this.options.autoPlay && !_this.timer.isPaused) {
|
|
_this.timer.restart();
|
|
}
|
|
//do stuff?
|
|
});
|
|
} else {
|
|
$curSlide.removeClass('is-active is-in').removeAttr('aria-live').hide();
|
|
$newSlide.addClass('is-active is-in').attr('aria-live', 'polite').show();
|
|
if (this.options.autoPlay && !this.timer.isPaused) {
|
|
this.timer.restart();
|
|
}
|
|
}
|
|
/**
|
|
* Triggers when the slide has finished animating in.
|
|
* @event Orbit#slidechange
|
|
*/
|
|
this.$element.trigger('slidechange.zf.orbit', [$newSlide]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Updates the active state of the bullets, if displayed.
|
|
* @function
|
|
* @private
|
|
* @param {Number} idx - the index of the current slide.
|
|
*/
|
|
|
|
}, {
|
|
key: '_updateBullets',
|
|
value: function _updateBullets(idx) {
|
|
var $oldBullet = this.$element.find('.' + this.options.boxOfBullets).find('.is-active').removeClass('is-active').blur(),
|
|
span = $oldBullet.find('span:last').detach(),
|
|
$newBullet = this.$bullets.eq(idx).addClass('is-active').append(span);
|
|
}
|
|
|
|
/**
|
|
* Destroys the carousel and hides the element.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
this.$element.off('.zf.orbit').find('*').off('.zf.orbit').end().hide();
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return Orbit;
|
|
}();
|
|
|
|
Orbit.defaults = {
|
|
/**
|
|
* Tells the JS to look for and loadBullets.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
bullets: true,
|
|
/**
|
|
* Tells the JS to apply event listeners to nav buttons
|
|
* @option
|
|
* @example true
|
|
*/
|
|
navButtons: true,
|
|
/**
|
|
* motion-ui animation class to apply
|
|
* @option
|
|
* @example 'slide-in-right'
|
|
*/
|
|
animInFromRight: 'slide-in-right',
|
|
/**
|
|
* motion-ui animation class to apply
|
|
* @option
|
|
* @example 'slide-out-right'
|
|
*/
|
|
animOutToRight: 'slide-out-right',
|
|
/**
|
|
* motion-ui animation class to apply
|
|
* @option
|
|
* @example 'slide-in-left'
|
|
*
|
|
*/
|
|
animInFromLeft: 'slide-in-left',
|
|
/**
|
|
* motion-ui animation class to apply
|
|
* @option
|
|
* @example 'slide-out-left'
|
|
*/
|
|
animOutToLeft: 'slide-out-left',
|
|
/**
|
|
* Allows Orbit to automatically animate on page load.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
autoPlay: true,
|
|
/**
|
|
* Amount of time, in ms, between slide transitions
|
|
* @option
|
|
* @example 5000
|
|
*/
|
|
timerDelay: 5000,
|
|
/**
|
|
* Allows Orbit to infinitely loop through the slides
|
|
* @option
|
|
* @example true
|
|
*/
|
|
infiniteWrap: true,
|
|
/**
|
|
* Allows the Orbit slides to bind to swipe events for mobile, requires an additional util library
|
|
* @option
|
|
* @example true
|
|
*/
|
|
swipe: true,
|
|
/**
|
|
* Allows the timing function to pause animation on hover.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
pauseOnHover: true,
|
|
/**
|
|
* Allows Orbit to bind keyboard events to the slider, to animate frames with arrow keys
|
|
* @option
|
|
* @example true
|
|
*/
|
|
accessible: true,
|
|
/**
|
|
* Class applied to the container of Orbit
|
|
* @option
|
|
* @example 'orbit-container'
|
|
*/
|
|
containerClass: 'orbit-container',
|
|
/**
|
|
* Class applied to individual slides.
|
|
* @option
|
|
* @example 'orbit-slide'
|
|
*/
|
|
slideClass: 'orbit-slide',
|
|
/**
|
|
* Class applied to the bullet container. You're welcome.
|
|
* @option
|
|
* @example 'orbit-bullets'
|
|
*/
|
|
boxOfBullets: 'orbit-bullets',
|
|
/**
|
|
* Class applied to the `next` navigation button.
|
|
* @option
|
|
* @example 'orbit-next'
|
|
*/
|
|
nextClass: 'orbit-next',
|
|
/**
|
|
* Class applied to the `previous` navigation button.
|
|
* @option
|
|
* @example 'orbit-previous'
|
|
*/
|
|
prevClass: 'orbit-previous',
|
|
/**
|
|
* Boolean to flag the js to use motion ui classes or not. Default to true for backwards compatability.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
useMUI: true
|
|
};
|
|
|
|
// Window exports
|
|
Foundation.plugin(Orbit, 'Orbit');
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* ResponsiveMenu module.
|
|
* @module foundation.responsiveMenu
|
|
* @requires foundation.util.triggers
|
|
* @requires foundation.util.mediaQuery
|
|
* @requires foundation.util.accordionMenu
|
|
* @requires foundation.util.drilldown
|
|
* @requires foundation.util.dropdown-menu
|
|
*/
|
|
|
|
var ResponsiveMenu = function () {
|
|
/**
|
|
* Creates a new instance of a responsive menu.
|
|
* @class
|
|
* @fires ResponsiveMenu#init
|
|
* @param {jQuery} element - jQuery object to make into a dropdown menu.
|
|
* @param {Object} options - Overrides to the default plugin settings.
|
|
*/
|
|
function ResponsiveMenu(element, options) {
|
|
_classCallCheck(this, ResponsiveMenu);
|
|
|
|
this.$element = $(element);
|
|
this.rules = this.$element.data('responsive-menu');
|
|
this.currentMq = null;
|
|
this.currentPlugin = null;
|
|
|
|
this._init();
|
|
this._events();
|
|
|
|
Foundation.registerPlugin(this, 'ResponsiveMenu');
|
|
}
|
|
|
|
/**
|
|
* Initializes the Menu by parsing the classes from the 'data-ResponsiveMenu' attribute on the element.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(ResponsiveMenu, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
// The first time an Interchange plugin is initialized, this.rules is converted from a string of "classes" to an object of rules
|
|
if (typeof this.rules === 'string') {
|
|
var rulesTree = {};
|
|
|
|
// Parse rules from "classes" pulled from data attribute
|
|
var rules = this.rules.split(' ');
|
|
|
|
// Iterate through every rule found
|
|
for (var i = 0; i < rules.length; i++) {
|
|
var rule = rules[i].split('-');
|
|
var ruleSize = rule.length > 1 ? rule[0] : 'small';
|
|
var rulePlugin = rule.length > 1 ? rule[1] : rule[0];
|
|
|
|
if (MenuPlugins[rulePlugin] !== null) {
|
|
rulesTree[ruleSize] = MenuPlugins[rulePlugin];
|
|
}
|
|
}
|
|
|
|
this.rules = rulesTree;
|
|
}
|
|
|
|
if (!$.isEmptyObject(this.rules)) {
|
|
this._checkMediaQueries();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Initializes events for the Menu.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events() {
|
|
var _this = this;
|
|
|
|
$(window).on('changed.zf.mediaquery', function () {
|
|
_this._checkMediaQueries();
|
|
});
|
|
// $(window).on('resize.zf.ResponsiveMenu', function() {
|
|
// _this._checkMediaQueries();
|
|
// });
|
|
}
|
|
|
|
/**
|
|
* Checks the current screen width against available media queries. If the media query has changed, and the plugin needed has changed, the plugins will swap out.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_checkMediaQueries',
|
|
value: function _checkMediaQueries() {
|
|
var matchedMq,
|
|
_this = this;
|
|
// Iterate through each rule and find the last matching rule
|
|
$.each(this.rules, function (key) {
|
|
if (Foundation.MediaQuery.atLeast(key)) {
|
|
matchedMq = key;
|
|
}
|
|
});
|
|
|
|
// No match? No dice
|
|
if (!matchedMq) return;
|
|
|
|
// Plugin already initialized? We good
|
|
if (this.currentPlugin instanceof this.rules[matchedMq].plugin) return;
|
|
|
|
// Remove existing plugin-specific CSS classes
|
|
$.each(MenuPlugins, function (key, value) {
|
|
_this.$element.removeClass(value.cssClass);
|
|
});
|
|
|
|
// Add the CSS class for the new plugin
|
|
this.$element.addClass(this.rules[matchedMq].cssClass);
|
|
|
|
// Create an instance of the new plugin
|
|
if (this.currentPlugin) this.currentPlugin.destroy();
|
|
this.currentPlugin = new this.rules[matchedMq].plugin(this.$element, {});
|
|
}
|
|
|
|
/**
|
|
* Destroys the instance of the current plugin on this element, as well as the window resize handler that switches the plugins out.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
this.currentPlugin.destroy();
|
|
$(window).off('.zf.ResponsiveMenu');
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return ResponsiveMenu;
|
|
}();
|
|
|
|
ResponsiveMenu.defaults = {};
|
|
|
|
// The plugin matches the plugin classes with these plugin instances.
|
|
var MenuPlugins = {
|
|
dropdown: {
|
|
cssClass: 'dropdown',
|
|
plugin: Foundation._plugins['dropdown-menu'] || null
|
|
},
|
|
drilldown: {
|
|
cssClass: 'drilldown',
|
|
plugin: Foundation._plugins['drilldown'] || null
|
|
},
|
|
accordion: {
|
|
cssClass: 'accordion-menu',
|
|
plugin: Foundation._plugins['accordion-menu'] || null
|
|
}
|
|
};
|
|
|
|
// Window exports
|
|
Foundation.plugin(ResponsiveMenu, 'ResponsiveMenu');
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* ResponsiveToggle module.
|
|
* @module foundation.responsiveToggle
|
|
* @requires foundation.util.mediaQuery
|
|
*/
|
|
|
|
var ResponsiveToggle = function () {
|
|
/**
|
|
* Creates a new instance of Tab Bar.
|
|
* @class
|
|
* @fires ResponsiveToggle#init
|
|
* @param {jQuery} element - jQuery object to attach tab bar functionality to.
|
|
* @param {Object} options - Overrides to the default plugin settings.
|
|
*/
|
|
function ResponsiveToggle(element, options) {
|
|
_classCallCheck(this, ResponsiveToggle);
|
|
|
|
this.$element = $(element);
|
|
this.options = $.extend({}, ResponsiveToggle.defaults, this.$element.data(), options);
|
|
|
|
this._init();
|
|
this._events();
|
|
|
|
Foundation.registerPlugin(this, 'ResponsiveToggle');
|
|
}
|
|
|
|
/**
|
|
* Initializes the tab bar by finding the target element, toggling element, and running update().
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(ResponsiveToggle, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
var targetID = this.$element.data('responsive-toggle');
|
|
if (!targetID) {
|
|
console.error('Your tab bar needs an ID of a Menu as the value of data-tab-bar.');
|
|
}
|
|
|
|
this.$targetMenu = $('#' + targetID);
|
|
this.$toggler = this.$element.find('[data-toggle]');
|
|
|
|
this._update();
|
|
}
|
|
|
|
/**
|
|
* Adds necessary event handlers for the tab bar to work.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events() {
|
|
var _this = this;
|
|
|
|
this._updateMqHandler = this._update.bind(this);
|
|
|
|
$(window).on('changed.zf.mediaquery', this._updateMqHandler);
|
|
|
|
this.$toggler.on('click.zf.responsiveToggle', this.toggleMenu.bind(this));
|
|
}
|
|
|
|
/**
|
|
* Checks the current media query to determine if the tab bar should be visible or hidden.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_update',
|
|
value: function _update() {
|
|
// Mobile
|
|
if (!Foundation.MediaQuery.atLeast(this.options.hideFor)) {
|
|
this.$element.show();
|
|
this.$targetMenu.hide();
|
|
}
|
|
|
|
// Desktop
|
|
else {
|
|
this.$element.hide();
|
|
this.$targetMenu.show();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Toggles the element attached to the tab bar. The toggle only happens if the screen is small enough to allow it.
|
|
* @function
|
|
* @fires ResponsiveToggle#toggled
|
|
*/
|
|
|
|
}, {
|
|
key: 'toggleMenu',
|
|
value: function toggleMenu() {
|
|
if (!Foundation.MediaQuery.atLeast(this.options.hideFor)) {
|
|
this.$targetMenu.toggle(0);
|
|
|
|
/**
|
|
* Fires when the element attached to the tab bar toggles.
|
|
* @event ResponsiveToggle#toggled
|
|
*/
|
|
this.$element.trigger('toggled.zf.responsiveToggle');
|
|
}
|
|
}
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
this.$element.off('.zf.responsiveToggle');
|
|
this.$toggler.off('.zf.responsiveToggle');
|
|
|
|
$(window).off('changed.zf.mediaquery', this._updateMqHandler);
|
|
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return ResponsiveToggle;
|
|
}();
|
|
|
|
ResponsiveToggle.defaults = {
|
|
/**
|
|
* The breakpoint after which the menu is always shown, and the tab bar is hidden.
|
|
* @option
|
|
* @example 'medium'
|
|
*/
|
|
hideFor: 'medium'
|
|
};
|
|
|
|
// Window exports
|
|
Foundation.plugin(ResponsiveToggle, 'ResponsiveToggle');
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* Reveal module.
|
|
* @module foundation.reveal
|
|
* @requires foundation.util.keyboard
|
|
* @requires foundation.util.box
|
|
* @requires foundation.util.triggers
|
|
* @requires foundation.util.mediaQuery
|
|
* @requires foundation.util.motion if using animations
|
|
*/
|
|
|
|
var Reveal = function () {
|
|
/**
|
|
* Creates a new instance of Reveal.
|
|
* @class
|
|
* @param {jQuery} element - jQuery object to use for the modal.
|
|
* @param {Object} options - optional parameters.
|
|
*/
|
|
function Reveal(element, options) {
|
|
_classCallCheck(this, Reveal);
|
|
|
|
this.$element = element;
|
|
this.options = $.extend({}, Reveal.defaults, this.$element.data(), options);
|
|
this._init();
|
|
|
|
Foundation.registerPlugin(this, 'Reveal');
|
|
Foundation.Keyboard.register('Reveal', {
|
|
'ENTER': 'open',
|
|
'SPACE': 'open',
|
|
'ESCAPE': 'close',
|
|
'TAB': 'tab_forward',
|
|
'SHIFT_TAB': 'tab_backward'
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Initializes the modal by adding the overlay and close buttons, (if selected).
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(Reveal, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
this.id = this.$element.attr('id');
|
|
this.isActive = false;
|
|
this.cached = { mq: Foundation.MediaQuery.current };
|
|
this.isMobile = mobileSniff();
|
|
|
|
this.$anchor = $('[data-open="' + this.id + '"]').length ? $('[data-open="' + this.id + '"]') : $('[data-toggle="' + this.id + '"]');
|
|
this.$anchor.attr({
|
|
'aria-controls': this.id,
|
|
'aria-haspopup': true,
|
|
'tabindex': 0
|
|
});
|
|
|
|
if (this.options.fullScreen || this.$element.hasClass('full')) {
|
|
this.options.fullScreen = true;
|
|
this.options.overlay = false;
|
|
}
|
|
if (this.options.overlay && !this.$overlay) {
|
|
this.$overlay = this._makeOverlay(this.id);
|
|
}
|
|
|
|
this.$element.attr({
|
|
'role': 'dialog',
|
|
'aria-hidden': true,
|
|
'data-yeti-box': this.id,
|
|
'data-resize': this.id
|
|
});
|
|
|
|
if (this.$overlay) {
|
|
this.$element.detach().appendTo(this.$overlay);
|
|
} else {
|
|
this.$element.detach().appendTo($('body'));
|
|
this.$element.addClass('without-overlay');
|
|
}
|
|
this._events();
|
|
if (this.options.deepLink && window.location.hash === '#' + this.id) {
|
|
$(window).one('load.zf.reveal', this.open.bind(this));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates an overlay div to display behind the modal.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_makeOverlay',
|
|
value: function _makeOverlay(id) {
|
|
var $overlay = $('<div></div>').addClass('reveal-overlay').appendTo('body');
|
|
return $overlay;
|
|
}
|
|
|
|
/**
|
|
* Updates position of modal
|
|
* TODO: Figure out if we actually need to cache these values or if it doesn't matter
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_updatePosition',
|
|
value: function _updatePosition() {
|
|
var width = this.$element.outerWidth();
|
|
var outerWidth = $(window).width();
|
|
var height = this.$element.outerHeight();
|
|
var outerHeight = $(window).height();
|
|
var left, top;
|
|
if (this.options.hOffset === 'auto') {
|
|
left = parseInt((outerWidth - width) / 2, 10);
|
|
} else {
|
|
left = parseInt(this.options.hOffset, 10);
|
|
}
|
|
if (this.options.vOffset === 'auto') {
|
|
if (height > outerHeight) {
|
|
top = parseInt(Math.min(100, outerHeight / 10), 10);
|
|
} else {
|
|
top = parseInt((outerHeight - height) / 4, 10);
|
|
}
|
|
} else {
|
|
top = parseInt(this.options.vOffset, 10);
|
|
}
|
|
this.$element.css({ top: top + 'px' });
|
|
// only worry about left if we don't have an overlay or we havea horizontal offset,
|
|
// otherwise we're perfectly in the middle
|
|
if (!this.$overlay || this.options.hOffset !== 'auto') {
|
|
this.$element.css({ left: left + 'px' });
|
|
this.$element.css({ margin: '0px' });
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds event handlers for the modal.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events() {
|
|
var _this2 = this;
|
|
|
|
var _this = this;
|
|
|
|
this.$element.on({
|
|
'open.zf.trigger': this.open.bind(this),
|
|
'close.zf.trigger': function (event, $element) {
|
|
if (event.target === _this.$element[0] || $(event.target).parents('[data-closable]')[0] === $element) {
|
|
// only close reveal when it's explicitly called
|
|
return _this2.close.apply(_this2);
|
|
}
|
|
},
|
|
'toggle.zf.trigger': this.toggle.bind(this),
|
|
'resizeme.zf.trigger': function () {
|
|
_this._updatePosition();
|
|
}
|
|
});
|
|
|
|
if (this.$anchor.length) {
|
|
this.$anchor.on('keydown.zf.reveal', function (e) {
|
|
if (e.which === 13 || e.which === 32) {
|
|
e.stopPropagation();
|
|
e.preventDefault();
|
|
_this.open();
|
|
}
|
|
});
|
|
}
|
|
|
|
if (this.options.closeOnClick && this.options.overlay) {
|
|
this.$overlay.off('.zf.reveal').on('click.zf.reveal', function (e) {
|
|
if (e.target === _this.$element[0] || $.contains(_this.$element[0], e.target) || !$.contains(document, e.target)) {
|
|
return;
|
|
}
|
|
_this.close();
|
|
});
|
|
}
|
|
if (this.options.deepLink) {
|
|
$(window).on('popstate.zf.reveal:' + this.id, this._handleState.bind(this));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handles modal methods on back/forward button clicks or any other event that triggers popstate.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_handleState',
|
|
value: function _handleState(e) {
|
|
if (window.location.hash === '#' + this.id && !this.isActive) {
|
|
this.open();
|
|
} else {
|
|
this.close();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Opens the modal controlled by `this.$anchor`, and closes all others by default.
|
|
* @function
|
|
* @fires Reveal#closeme
|
|
* @fires Reveal#open
|
|
*/
|
|
|
|
}, {
|
|
key: 'open',
|
|
value: function open() {
|
|
var _this3 = this;
|
|
|
|
if (this.options.deepLink) {
|
|
var hash = '#' + this.id;
|
|
|
|
if (window.history.pushState) {
|
|
window.history.pushState(null, null, hash);
|
|
} else {
|
|
window.location.hash = hash;
|
|
}
|
|
}
|
|
|
|
this.isActive = true;
|
|
|
|
// Make elements invisible, but remove display: none so we can get size and positioning
|
|
this.$element.css({ 'visibility': 'hidden' }).show().scrollTop(0);
|
|
if (this.options.overlay) {
|
|
this.$overlay.css({ 'visibility': 'hidden' }).show();
|
|
}
|
|
|
|
this._updatePosition();
|
|
|
|
this.$element.hide().css({ 'visibility': '' });
|
|
|
|
if (this.$overlay) {
|
|
this.$overlay.css({ 'visibility': '' }).hide();
|
|
if (this.$element.hasClass('fast')) {
|
|
this.$overlay.addClass('fast');
|
|
} else if (this.$element.hasClass('slow')) {
|
|
this.$overlay.addClass('slow');
|
|
}
|
|
}
|
|
|
|
if (!this.options.multipleOpened) {
|
|
/**
|
|
* Fires immediately before the modal opens.
|
|
* Closes any other modals that are currently open
|
|
* @event Reveal#closeme
|
|
*/
|
|
this.$element.trigger('closeme.zf.reveal', this.id);
|
|
}
|
|
// Motion UI method of reveal
|
|
if (this.options.animationIn) {
|
|
var _this;
|
|
|
|
(function () {
|
|
var afterAnimationFocus = function () {
|
|
_this.$element.attr({
|
|
'aria-hidden': false,
|
|
'tabindex': -1
|
|
}).focus();
|
|
};
|
|
|
|
_this = _this3;
|
|
|
|
if (_this3.options.overlay) {
|
|
Foundation.Motion.animateIn(_this3.$overlay, 'fade-in');
|
|
}
|
|
Foundation.Motion.animateIn(_this3.$element, _this3.options.animationIn, function () {
|
|
_this3.focusableElements = Foundation.Keyboard.findFocusable(_this3.$element);
|
|
afterAnimationFocus();
|
|
});
|
|
})();
|
|
}
|
|
// jQuery method of reveal
|
|
else {
|
|
if (this.options.overlay) {
|
|
this.$overlay.show(0);
|
|
}
|
|
this.$element.show(this.options.showDelay);
|
|
}
|
|
|
|
// handle accessibility
|
|
this.$element.attr({
|
|
'aria-hidden': false,
|
|
'tabindex': -1
|
|
}).focus();
|
|
|
|
/**
|
|
* Fires when the modal has successfully opened.
|
|
* @event Reveal#open
|
|
*/
|
|
this.$element.trigger('open.zf.reveal');
|
|
|
|
if (this.isMobile) {
|
|
this.originalScrollPos = window.pageYOffset;
|
|
$('html, body').addClass('is-reveal-open');
|
|
} else {
|
|
$('body').addClass('is-reveal-open');
|
|
}
|
|
|
|
setTimeout(function () {
|
|
_this3._extraHandlers();
|
|
}, 0);
|
|
}
|
|
|
|
/**
|
|
* Adds extra event handlers for the body and window if necessary.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_extraHandlers',
|
|
value: function _extraHandlers() {
|
|
var _this = this;
|
|
this.focusableElements = Foundation.Keyboard.findFocusable(this.$element);
|
|
|
|
if (!this.options.overlay && this.options.closeOnClick && !this.options.fullScreen) {
|
|
$('body').on('click.zf.reveal', function (e) {
|
|
if (e.target === _this.$element[0] || $.contains(_this.$element[0], e.target) || !$.contains(document, e.target)) {
|
|
return;
|
|
}
|
|
_this.close();
|
|
});
|
|
}
|
|
|
|
if (this.options.closeOnEsc) {
|
|
$(window).on('keydown.zf.reveal', function (e) {
|
|
Foundation.Keyboard.handleKey(e, 'Reveal', {
|
|
close: function () {
|
|
if (_this.options.closeOnEsc) {
|
|
_this.close();
|
|
_this.$anchor.focus();
|
|
}
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
// lock focus within modal while tabbing
|
|
this.$element.on('keydown.zf.reveal', function (e) {
|
|
var $target = $(this);
|
|
// handle keyboard event with keyboard util
|
|
Foundation.Keyboard.handleKey(e, 'Reveal', {
|
|
tab_forward: function () {
|
|
_this.focusableElements = Foundation.Keyboard.findFocusable(_this.$element);
|
|
if (_this.$element.find(':focus').is(_this.focusableElements.eq(-1))) {
|
|
// left modal downwards, setting focus to first element
|
|
_this.focusableElements.eq(0).focus();
|
|
return true;
|
|
}
|
|
if (_this.focusableElements.length === 0) {
|
|
// no focusable elements inside the modal at all, prevent tabbing in general
|
|
return true;
|
|
}
|
|
},
|
|
tab_backward: function () {
|
|
_this.focusableElements = Foundation.Keyboard.findFocusable(_this.$element);
|
|
if (_this.$element.find(':focus').is(_this.focusableElements.eq(0)) || _this.$element.is(':focus')) {
|
|
// left modal upwards, setting focus to last element
|
|
_this.focusableElements.eq(-1).focus();
|
|
return true;
|
|
}
|
|
if (_this.focusableElements.length === 0) {
|
|
// no focusable elements inside the modal at all, prevent tabbing in general
|
|
return true;
|
|
}
|
|
},
|
|
open: function () {
|
|
if (_this.$element.find(':focus').is(_this.$element.find('[data-close]'))) {
|
|
setTimeout(function () {
|
|
// set focus back to anchor if close button has been activated
|
|
_this.$anchor.focus();
|
|
}, 1);
|
|
} else if ($target.is(_this.focusableElements)) {
|
|
// dont't trigger if acual element has focus (i.e. inputs, links, ...)
|
|
_this.open();
|
|
}
|
|
},
|
|
close: function () {
|
|
if (_this.options.closeOnEsc) {
|
|
_this.close();
|
|
_this.$anchor.focus();
|
|
}
|
|
},
|
|
handled: function (preventDefault) {
|
|
if (preventDefault) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Closes the modal.
|
|
* @function
|
|
* @fires Reveal#closed
|
|
*/
|
|
|
|
}, {
|
|
key: 'close',
|
|
value: function close() {
|
|
if (!this.isActive || !this.$element.is(':visible')) {
|
|
return false;
|
|
}
|
|
var _this = this;
|
|
|
|
// Motion UI method of hiding
|
|
if (this.options.animationOut) {
|
|
if (this.options.overlay) {
|
|
Foundation.Motion.animateOut(this.$overlay, 'fade-out', finishUp);
|
|
} else {
|
|
finishUp();
|
|
}
|
|
|
|
Foundation.Motion.animateOut(this.$element, this.options.animationOut);
|
|
}
|
|
// jQuery method of hiding
|
|
else {
|
|
if (this.options.overlay) {
|
|
this.$overlay.hide(0, finishUp);
|
|
} else {
|
|
finishUp();
|
|
}
|
|
|
|
this.$element.hide(this.options.hideDelay);
|
|
}
|
|
|
|
// Conditionals to remove extra event listeners added on open
|
|
if (this.options.closeOnEsc) {
|
|
$(window).off('keydown.zf.reveal');
|
|
}
|
|
|
|
if (!this.options.overlay && this.options.closeOnClick) {
|
|
$('body').off('click.zf.reveal');
|
|
}
|
|
|
|
this.$element.off('keydown.zf.reveal');
|
|
|
|
function finishUp() {
|
|
if (_this.isMobile) {
|
|
$('html, body').removeClass('is-reveal-open');
|
|
if (_this.originalScrollPos) {
|
|
$('body').scrollTop(_this.originalScrollPos);
|
|
_this.originalScrollPos = null;
|
|
}
|
|
} else {
|
|
$('body').removeClass('is-reveal-open');
|
|
}
|
|
|
|
_this.$element.attr('aria-hidden', true);
|
|
|
|
/**
|
|
* Fires when the modal is done closing.
|
|
* @event Reveal#closed
|
|
*/
|
|
_this.$element.trigger('closed.zf.reveal');
|
|
}
|
|
|
|
/**
|
|
* Resets the modal content
|
|
* This prevents a running video to keep going in the background
|
|
*/
|
|
if (this.options.resetOnClose) {
|
|
this.$element.html(this.$element.html());
|
|
}
|
|
|
|
this.isActive = false;
|
|
if (_this.options.deepLink) {
|
|
if (window.history.replaceState) {
|
|
window.history.replaceState("", document.title, window.location.pathname);
|
|
} else {
|
|
window.location.hash = '';
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Toggles the open/closed state of a modal.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'toggle',
|
|
value: function toggle() {
|
|
if (this.isActive) {
|
|
this.close();
|
|
} else {
|
|
this.open();
|
|
}
|
|
}
|
|
}, {
|
|
key: 'destroy',
|
|
|
|
|
|
/**
|
|
* Destroys an instance of a modal.
|
|
* @function
|
|
*/
|
|
value: function destroy() {
|
|
if (this.options.overlay) {
|
|
this.$element.appendTo($('body')); // move $element outside of $overlay to prevent error unregisterPlugin()
|
|
this.$overlay.hide().off().remove();
|
|
}
|
|
this.$element.hide().off();
|
|
this.$anchor.off('.zf');
|
|
$(window).off('.zf.reveal:' + this.id);
|
|
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return Reveal;
|
|
}();
|
|
|
|
Reveal.defaults = {
|
|
/**
|
|
* Motion-UI class to use for animated elements. If none used, defaults to simple show/hide.
|
|
* @option
|
|
* @example 'slide-in-left'
|
|
*/
|
|
animationIn: '',
|
|
/**
|
|
* Motion-UI class to use for animated elements. If none used, defaults to simple show/hide.
|
|
* @option
|
|
* @example 'slide-out-right'
|
|
*/
|
|
animationOut: '',
|
|
/**
|
|
* Time, in ms, to delay the opening of a modal after a click if no animation used.
|
|
* @option
|
|
* @example 10
|
|
*/
|
|
showDelay: 0,
|
|
/**
|
|
* Time, in ms, to delay the closing of a modal after a click if no animation used.
|
|
* @option
|
|
* @example 10
|
|
*/
|
|
hideDelay: 0,
|
|
/**
|
|
* Allows a click on the body/overlay to close the modal.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
closeOnClick: true,
|
|
/**
|
|
* Allows the modal to close if the user presses the `ESCAPE` key.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
closeOnEsc: true,
|
|
/**
|
|
* If true, allows multiple modals to be displayed at once.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
multipleOpened: false,
|
|
/**
|
|
* Distance, in pixels, the modal should push down from the top of the screen.
|
|
* @option
|
|
* @example auto
|
|
*/
|
|
vOffset: 'auto',
|
|
/**
|
|
* Distance, in pixels, the modal should push in from the side of the screen.
|
|
* @option
|
|
* @example auto
|
|
*/
|
|
hOffset: 'auto',
|
|
/**
|
|
* Allows the modal to be fullscreen, completely blocking out the rest of the view. JS checks for this as well.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
fullScreen: false,
|
|
/**
|
|
* Percentage of screen height the modal should push up from the bottom of the view.
|
|
* @option
|
|
* @example 10
|
|
*/
|
|
btmOffsetPct: 10,
|
|
/**
|
|
* Allows the modal to generate an overlay div, which will cover the view when modal opens.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
overlay: true,
|
|
/**
|
|
* Allows the modal to remove and reinject markup on close. Should be true if using video elements w/o using provider's api, otherwise, videos will continue to play in the background.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
resetOnClose: false,
|
|
/**
|
|
* Allows the modal to alter the url on open/close, and allows the use of the `back` button to close modals. ALSO, allows a modal to auto-maniacally open on page load IF the hash === the modal's user-set id.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
deepLink: false
|
|
};
|
|
|
|
// Window exports
|
|
Foundation.plugin(Reveal, 'Reveal');
|
|
|
|
function iPhoneSniff() {
|
|
return (/iP(ad|hone|od).*OS/.test(window.navigator.userAgent)
|
|
);
|
|
}
|
|
|
|
function androidSniff() {
|
|
return (/Android/.test(window.navigator.userAgent)
|
|
);
|
|
}
|
|
|
|
function mobileSniff() {
|
|
return iPhoneSniff() || androidSniff();
|
|
}
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* Slider module.
|
|
* @module foundation.slider
|
|
* @requires foundation.util.motion
|
|
* @requires foundation.util.triggers
|
|
* @requires foundation.util.keyboard
|
|
* @requires foundation.util.touch
|
|
*/
|
|
|
|
var Slider = function () {
|
|
/**
|
|
* Creates a new instance of a drilldown menu.
|
|
* @class
|
|
* @param {jQuery} element - jQuery object to make into an accordion menu.
|
|
* @param {Object} options - Overrides to the default plugin settings.
|
|
*/
|
|
function Slider(element, options) {
|
|
_classCallCheck(this, Slider);
|
|
|
|
this.$element = element;
|
|
this.options = $.extend({}, Slider.defaults, this.$element.data(), options);
|
|
|
|
this._init();
|
|
|
|
Foundation.registerPlugin(this, 'Slider');
|
|
Foundation.Keyboard.register('Slider', {
|
|
'ltr': {
|
|
'ARROW_RIGHT': 'increase',
|
|
'ARROW_UP': 'increase',
|
|
'ARROW_DOWN': 'decrease',
|
|
'ARROW_LEFT': 'decrease',
|
|
'SHIFT_ARROW_RIGHT': 'increase_fast',
|
|
'SHIFT_ARROW_UP': 'increase_fast',
|
|
'SHIFT_ARROW_DOWN': 'decrease_fast',
|
|
'SHIFT_ARROW_LEFT': 'decrease_fast'
|
|
},
|
|
'rtl': {
|
|
'ARROW_LEFT': 'increase',
|
|
'ARROW_RIGHT': 'decrease',
|
|
'SHIFT_ARROW_LEFT': 'increase_fast',
|
|
'SHIFT_ARROW_RIGHT': 'decrease_fast'
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Initilizes the plugin by reading/setting attributes, creating collections and setting the initial position of the handle(s).
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(Slider, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
this.inputs = this.$element.find('input');
|
|
this.handles = this.$element.find('[data-slider-handle]');
|
|
|
|
this.$handle = this.handles.eq(0);
|
|
this.$input = this.inputs.length ? this.inputs.eq(0) : $('#' + this.$handle.attr('aria-controls'));
|
|
this.$fill = this.$element.find('[data-slider-fill]').css(this.options.vertical ? 'height' : 'width', 0);
|
|
|
|
var isDbl = false,
|
|
_this = this;
|
|
if (this.options.disabled || this.$element.hasClass(this.options.disabledClass)) {
|
|
this.options.disabled = true;
|
|
this.$element.addClass(this.options.disabledClass);
|
|
}
|
|
if (!this.inputs.length) {
|
|
this.inputs = $().add(this.$input);
|
|
this.options.binding = true;
|
|
}
|
|
this._setInitAttr(0);
|
|
this._events(this.$handle);
|
|
|
|
if (this.handles[1]) {
|
|
this.options.doubleSided = true;
|
|
this.$handle2 = this.handles.eq(1);
|
|
this.$input2 = this.inputs.length > 1 ? this.inputs.eq(1) : $('#' + this.$handle2.attr('aria-controls'));
|
|
|
|
if (!this.inputs[1]) {
|
|
this.inputs = this.inputs.add(this.$input2);
|
|
}
|
|
isDbl = true;
|
|
|
|
this._setHandlePos(this.$handle, this.options.initialStart, true, function () {
|
|
|
|
_this._setHandlePos(_this.$handle2, _this.options.initialEnd, true);
|
|
});
|
|
// this.$handle.triggerHandler('click.zf.slider');
|
|
this._setInitAttr(1);
|
|
this._events(this.$handle2);
|
|
}
|
|
|
|
if (!isDbl) {
|
|
this._setHandlePos(this.$handle, this.options.initialStart, true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the position of the selected handle and fill bar.
|
|
* @function
|
|
* @private
|
|
* @param {jQuery} $hndl - the selected handle to move.
|
|
* @param {Number} location - floating point between the start and end values of the slider bar.
|
|
* @param {Function} cb - callback function to fire on completion.
|
|
* @fires Slider#moved
|
|
* @fires Slider#changed
|
|
*/
|
|
|
|
}, {
|
|
key: '_setHandlePos',
|
|
value: function _setHandlePos($hndl, location, noInvert, cb) {
|
|
// don't move if the slider has been disabled since its initialization
|
|
if (this.$element.hasClass(this.options.disabledClass)) {
|
|
return;
|
|
}
|
|
//might need to alter that slightly for bars that will have odd number selections.
|
|
location = parseFloat(location); //on input change events, convert string to number...grumble.
|
|
|
|
// prevent slider from running out of bounds, if value exceeds the limits set through options, override the value to min/max
|
|
if (location < this.options.start) {
|
|
location = this.options.start;
|
|
} else if (location > this.options.end) {
|
|
location = this.options.end;
|
|
}
|
|
|
|
var isDbl = this.options.doubleSided;
|
|
|
|
if (isDbl) {
|
|
//this block is to prevent 2 handles from crossing eachother. Could/should be improved.
|
|
if (this.handles.index($hndl) === 0) {
|
|
var h2Val = parseFloat(this.$handle2.attr('aria-valuenow'));
|
|
location = location >= h2Val ? h2Val - this.options.step : location;
|
|
} else {
|
|
var h1Val = parseFloat(this.$handle.attr('aria-valuenow'));
|
|
location = location <= h1Val ? h1Val + this.options.step : location;
|
|
}
|
|
}
|
|
|
|
//this is for single-handled vertical sliders, it adjusts the value to account for the slider being "upside-down"
|
|
//for click and drag events, it's weird due to the scale(-1, 1) css property
|
|
if (this.options.vertical && !noInvert) {
|
|
location = this.options.end - location;
|
|
}
|
|
|
|
var _this = this,
|
|
vert = this.options.vertical,
|
|
hOrW = vert ? 'height' : 'width',
|
|
lOrT = vert ? 'top' : 'left',
|
|
handleDim = $hndl[0].getBoundingClientRect()[hOrW],
|
|
elemDim = this.$element[0].getBoundingClientRect()[hOrW],
|
|
|
|
//percentage of bar min/max value based on click or drag point
|
|
pctOfBar = percent(location - this.options.start, this.options.end - this.options.start).toFixed(2),
|
|
|
|
//number of actual pixels to shift the handle, based on the percentage obtained above
|
|
pxToMove = (elemDim - handleDim) * pctOfBar,
|
|
|
|
//percentage of bar to shift the handle
|
|
movement = (percent(pxToMove, elemDim) * 100).toFixed(this.options.decimal);
|
|
//fixing the decimal value for the location number, is passed to other methods as a fixed floating-point value
|
|
location = parseFloat(location.toFixed(this.options.decimal));
|
|
// declare empty object for css adjustments, only used with 2 handled-sliders
|
|
var css = {};
|
|
|
|
this._setValues($hndl, location);
|
|
|
|
// TODO update to calculate based on values set to respective inputs??
|
|
if (isDbl) {
|
|
var isLeftHndl = this.handles.index($hndl) === 0,
|
|
|
|
//empty variable, will be used for min-height/width for fill bar
|
|
dim,
|
|
|
|
//percentage w/h of the handle compared to the slider bar
|
|
handlePct = ~~(percent(handleDim, elemDim) * 100);
|
|
//if left handle, the math is slightly different than if it's the right handle, and the left/top property needs to be changed for the fill bar
|
|
if (isLeftHndl) {
|
|
//left or top percentage value to apply to the fill bar.
|
|
css[lOrT] = movement + '%';
|
|
//calculate the new min-height/width for the fill bar.
|
|
dim = parseFloat(this.$handle2[0].style[lOrT]) - movement + handlePct;
|
|
//this callback is necessary to prevent errors and allow the proper placement and initialization of a 2-handled slider
|
|
//plus, it means we don't care if 'dim' isNaN on init, it won't be in the future.
|
|
if (cb && typeof cb === 'function') {
|
|
cb();
|
|
} //this is only needed for the initialization of 2 handled sliders
|
|
} else {
|
|
//just caching the value of the left/bottom handle's left/top property
|
|
var handlePos = parseFloat(this.$handle[0].style[lOrT]);
|
|
//calculate the new min-height/width for the fill bar. Use isNaN to prevent false positives for numbers <= 0
|
|
//based on the percentage of movement of the handle being manipulated, less the opposing handle's left/top position, plus the percentage w/h of the handle itself
|
|
dim = movement - (isNaN(handlePos) ? this.options.initialStart / ((this.options.end - this.options.start) / 100) : handlePos) + handlePct;
|
|
}
|
|
// assign the min-height/width to our css object
|
|
css['min-' + hOrW] = dim + '%';
|
|
}
|
|
|
|
this.$element.one('finished.zf.animate', function () {
|
|
/**
|
|
* Fires when the handle is done moving.
|
|
* @event Slider#moved
|
|
*/
|
|
_this.$element.trigger('moved.zf.slider', [$hndl]);
|
|
});
|
|
|
|
//because we don't know exactly how the handle will be moved, check the amount of time it should take to move.
|
|
var moveTime = this.$element.data('dragging') ? 1000 / 60 : this.options.moveTime;
|
|
|
|
Foundation.Move(moveTime, $hndl, function () {
|
|
//adjusting the left/top property of the handle, based on the percentage calculated above
|
|
$hndl.css(lOrT, movement + '%');
|
|
|
|
if (!_this.options.doubleSided) {
|
|
//if single-handled, a simple method to expand the fill bar
|
|
_this.$fill.css(hOrW, pctOfBar * 100 + '%');
|
|
} else {
|
|
//otherwise, use the css object we created above
|
|
_this.$fill.css(css);
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Fires when the value has not been change for a given time.
|
|
* @event Slider#changed
|
|
*/
|
|
clearTimeout(_this.timeout);
|
|
_this.timeout = setTimeout(function () {
|
|
_this.$element.trigger('changed.zf.slider', [$hndl]);
|
|
}, _this.options.changedDelay);
|
|
}
|
|
|
|
/**
|
|
* Sets the initial attribute for the slider element.
|
|
* @function
|
|
* @private
|
|
* @param {Number} idx - index of the current handle/input to use.
|
|
*/
|
|
|
|
}, {
|
|
key: '_setInitAttr',
|
|
value: function _setInitAttr(idx) {
|
|
var id = this.inputs.eq(idx).attr('id') || Foundation.GetYoDigits(6, 'slider');
|
|
this.inputs.eq(idx).attr({
|
|
'id': id,
|
|
'max': this.options.end,
|
|
'min': this.options.start,
|
|
'step': this.options.step
|
|
});
|
|
this.handles.eq(idx).attr({
|
|
'role': 'slider',
|
|
'aria-controls': id,
|
|
'aria-valuemax': this.options.end,
|
|
'aria-valuemin': this.options.start,
|
|
'aria-valuenow': idx === 0 ? this.options.initialStart : this.options.initialEnd,
|
|
'aria-orientation': this.options.vertical ? 'vertical' : 'horizontal',
|
|
'tabindex': 0
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Sets the input and `aria-valuenow` values for the slider element.
|
|
* @function
|
|
* @private
|
|
* @param {jQuery} $handle - the currently selected handle.
|
|
* @param {Number} val - floating point of the new value.
|
|
*/
|
|
|
|
}, {
|
|
key: '_setValues',
|
|
value: function _setValues($handle, val) {
|
|
var idx = this.options.doubleSided ? this.handles.index($handle) : 0;
|
|
this.inputs.eq(idx).val(val);
|
|
$handle.attr('aria-valuenow', val);
|
|
}
|
|
|
|
/**
|
|
* Handles events on the slider element.
|
|
* Calculates the new location of the current handle.
|
|
* If there are two handles and the bar was clicked, it determines which handle to move.
|
|
* @function
|
|
* @private
|
|
* @param {Object} e - the `event` object passed from the listener.
|
|
* @param {jQuery} $handle - the current handle to calculate for, if selected.
|
|
* @param {Number} val - floating point number for the new value of the slider.
|
|
* TODO clean this up, there's a lot of repeated code between this and the _setHandlePos fn.
|
|
*/
|
|
|
|
}, {
|
|
key: '_handleEvent',
|
|
value: function _handleEvent(e, $handle, val) {
|
|
var value, hasVal;
|
|
if (!val) {
|
|
//click or drag events
|
|
e.preventDefault();
|
|
var _this = this,
|
|
vertical = this.options.vertical,
|
|
param = vertical ? 'height' : 'width',
|
|
direction = vertical ? 'top' : 'left',
|
|
eventOffset = vertical ? e.pageY : e.pageX,
|
|
halfOfHandle = this.$handle[0].getBoundingClientRect()[param] / 2,
|
|
barDim = this.$element[0].getBoundingClientRect()[param],
|
|
windowScroll = vertical ? $(window).scrollTop() : $(window).scrollLeft();
|
|
|
|
var elemOffset = this.$element.offset()[direction];
|
|
|
|
// touch events emulated by the touch util give position relative to screen, add window.scroll to event coordinates...
|
|
// best way to guess this is simulated is if clientY == pageY
|
|
if (e.clientY === e.pageY) {
|
|
eventOffset = eventOffset + windowScroll;
|
|
}
|
|
var eventFromBar = eventOffset - elemOffset;
|
|
var barXY;
|
|
if (eventFromBar < 0) {
|
|
barXY = 0;
|
|
} else if (eventFromBar > barDim) {
|
|
barXY = barDim;
|
|
} else {
|
|
barXY = eventFromBar;
|
|
}
|
|
var offsetPct = percent(barXY, barDim);
|
|
|
|
value = (this.options.end - this.options.start) * offsetPct + this.options.start;
|
|
|
|
// turn everything around for RTL, yay math!
|
|
if (Foundation.rtl() && !this.options.vertical) {
|
|
value = this.options.end - value;
|
|
}
|
|
|
|
value = _this._adjustValue(null, value);
|
|
//boolean flag for the setHandlePos fn, specifically for vertical sliders
|
|
hasVal = false;
|
|
|
|
if (!$handle) {
|
|
//figure out which handle it is, pass it to the next function.
|
|
var firstHndlPos = absPosition(this.$handle, direction, barXY, param),
|
|
secndHndlPos = absPosition(this.$handle2, direction, barXY, param);
|
|
$handle = firstHndlPos <= secndHndlPos ? this.$handle : this.$handle2;
|
|
}
|
|
} else {
|
|
//change event on input
|
|
value = this._adjustValue(null, val);
|
|
hasVal = true;
|
|
}
|
|
|
|
this._setHandlePos($handle, value, hasVal);
|
|
}
|
|
|
|
/**
|
|
* Adjustes value for handle in regard to step value. returns adjusted value
|
|
* @function
|
|
* @private
|
|
* @param {jQuery} $handle - the selected handle.
|
|
* @param {Number} value - value to adjust. used if $handle is falsy
|
|
*/
|
|
|
|
}, {
|
|
key: '_adjustValue',
|
|
value: function _adjustValue($handle, value) {
|
|
var val,
|
|
step = this.options.step,
|
|
div = parseFloat(step / 2),
|
|
left,
|
|
prev_val,
|
|
next_val;
|
|
if (!!$handle) {
|
|
val = parseFloat($handle.attr('aria-valuenow'));
|
|
} else {
|
|
val = value;
|
|
}
|
|
left = val % step;
|
|
prev_val = val - left;
|
|
next_val = prev_val + step;
|
|
if (left === 0) {
|
|
return val;
|
|
}
|
|
val = val >= prev_val + div ? next_val : prev_val;
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* Adds event listeners to the slider elements.
|
|
* @function
|
|
* @private
|
|
* @param {jQuery} $handle - the current handle to apply listeners to.
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events($handle) {
|
|
var _this = this,
|
|
curHandle,
|
|
timer;
|
|
|
|
this.inputs.off('change.zf.slider').on('change.zf.slider', function (e) {
|
|
var idx = _this.inputs.index($(this));
|
|
_this._handleEvent(e, _this.handles.eq(idx), $(this).val());
|
|
});
|
|
|
|
if (this.options.clickSelect) {
|
|
this.$element.off('click.zf.slider').on('click.zf.slider', function (e) {
|
|
if (_this.$element.data('dragging')) {
|
|
return false;
|
|
}
|
|
|
|
if (!$(e.target).is('[data-slider-handle]')) {
|
|
if (_this.options.doubleSided) {
|
|
_this._handleEvent(e);
|
|
} else {
|
|
_this._handleEvent(e, _this.$handle);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
if (this.options.draggable) {
|
|
this.handles.addTouch();
|
|
|
|
var $body = $('body');
|
|
$handle.off('mousedown.zf.slider').on('mousedown.zf.slider', function (e) {
|
|
$handle.addClass('is-dragging');
|
|
_this.$fill.addClass('is-dragging'); //
|
|
_this.$element.data('dragging', true);
|
|
|
|
curHandle = $(e.currentTarget);
|
|
|
|
$body.on('mousemove.zf.slider', function (e) {
|
|
e.preventDefault();
|
|
_this._handleEvent(e, curHandle);
|
|
}).on('mouseup.zf.slider', function (e) {
|
|
_this._handleEvent(e, curHandle);
|
|
|
|
$handle.removeClass('is-dragging');
|
|
_this.$fill.removeClass('is-dragging');
|
|
_this.$element.data('dragging', false);
|
|
|
|
$body.off('mousemove.zf.slider mouseup.zf.slider');
|
|
});
|
|
})
|
|
// prevent events triggered by touch
|
|
.on('selectstart.zf.slider touchmove.zf.slider', function (e) {
|
|
e.preventDefault();
|
|
});
|
|
}
|
|
|
|
$handle.off('keydown.zf.slider').on('keydown.zf.slider', function (e) {
|
|
var _$handle = $(this),
|
|
idx = _this.options.doubleSided ? _this.handles.index(_$handle) : 0,
|
|
oldValue = parseFloat(_this.inputs.eq(idx).val()),
|
|
newValue;
|
|
|
|
// handle keyboard event with keyboard util
|
|
Foundation.Keyboard.handleKey(e, 'Slider', {
|
|
decrease: function () {
|
|
newValue = oldValue - _this.options.step;
|
|
},
|
|
increase: function () {
|
|
newValue = oldValue + _this.options.step;
|
|
},
|
|
decrease_fast: function () {
|
|
newValue = oldValue - _this.options.step * 10;
|
|
},
|
|
increase_fast: function () {
|
|
newValue = oldValue + _this.options.step * 10;
|
|
},
|
|
handled: function () {
|
|
// only set handle pos when event was handled specially
|
|
e.preventDefault();
|
|
_this._setHandlePos(_$handle, newValue, true);
|
|
}
|
|
});
|
|
/*if (newValue) { // if pressed key has special function, update value
|
|
e.preventDefault();
|
|
_this._setHandlePos(_$handle, newValue);
|
|
}*/
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Destroys the slider plugin.
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
this.handles.off('.zf.slider');
|
|
this.inputs.off('.zf.slider');
|
|
this.$element.off('.zf.slider');
|
|
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return Slider;
|
|
}();
|
|
|
|
Slider.defaults = {
|
|
/**
|
|
* Minimum value for the slider scale.
|
|
* @option
|
|
* @example 0
|
|
*/
|
|
start: 0,
|
|
/**
|
|
* Maximum value for the slider scale.
|
|
* @option
|
|
* @example 100
|
|
*/
|
|
end: 100,
|
|
/**
|
|
* Minimum value change per change event.
|
|
* @option
|
|
* @example 1
|
|
*/
|
|
step: 1,
|
|
/**
|
|
* Value at which the handle/input *(left handle/first input)* should be set to on initialization.
|
|
* @option
|
|
* @example 0
|
|
*/
|
|
initialStart: 0,
|
|
/**
|
|
* Value at which the right handle/second input should be set to on initialization.
|
|
* @option
|
|
* @example 100
|
|
*/
|
|
initialEnd: 100,
|
|
/**
|
|
* Allows the input to be located outside the container and visible. Set to by the JS
|
|
* @option
|
|
* @example false
|
|
*/
|
|
binding: false,
|
|
/**
|
|
* Allows the user to click/tap on the slider bar to select a value.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
clickSelect: true,
|
|
/**
|
|
* Set to true and use the `vertical` class to change alignment to vertical.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
vertical: false,
|
|
/**
|
|
* Allows the user to drag the slider handle(s) to select a value.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
draggable: true,
|
|
/**
|
|
* Disables the slider and prevents event listeners from being applied. Double checked by JS with `disabledClass`.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
disabled: false,
|
|
/**
|
|
* Allows the use of two handles. Double checked by the JS. Changes some logic handling.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
doubleSided: false,
|
|
/**
|
|
* Potential future feature.
|
|
*/
|
|
// steps: 100,
|
|
/**
|
|
* Number of decimal places the plugin should go to for floating point precision.
|
|
* @option
|
|
* @example 2
|
|
*/
|
|
decimal: 2,
|
|
/**
|
|
* Time delay for dragged elements.
|
|
*/
|
|
// dragDelay: 0,
|
|
/**
|
|
* Time, in ms, to animate the movement of a slider handle if user clicks/taps on the bar. Needs to be manually set if updating the transition time in the Sass settings.
|
|
* @option
|
|
* @example 200
|
|
*/
|
|
moveTime: 200, //update this if changing the transition time in the sass
|
|
/**
|
|
* Class applied to disabled sliders.
|
|
* @option
|
|
* @example 'disabled'
|
|
*/
|
|
disabledClass: 'disabled',
|
|
/**
|
|
* Will invert the default layout for a vertical<span data-tooltip title="who would do this???"> </span>slider.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
invertVertical: false,
|
|
/**
|
|
* Milliseconds before the `changed.zf-slider` event is triggered after value change.
|
|
* @option
|
|
* @example 500
|
|
*/
|
|
changedDelay: 500
|
|
};
|
|
|
|
function percent(frac, num) {
|
|
return frac / num;
|
|
}
|
|
function absPosition($handle, dir, clickPos, param) {
|
|
return Math.abs($handle.position()[dir] + $handle[param]() / 2 - clickPos);
|
|
}
|
|
|
|
// Window exports
|
|
Foundation.plugin(Slider, 'Slider');
|
|
}(jQuery);
|
|
|
|
//*********this is in case we go to static, absolute positions instead of dynamic positioning********
|
|
// this.setSteps(function() {
|
|
// _this._events();
|
|
// var initStart = _this.options.positions[_this.options.initialStart - 1] || null;
|
|
// var initEnd = _this.options.initialEnd ? _this.options.position[_this.options.initialEnd - 1] : null;
|
|
// if (initStart || initEnd) {
|
|
// _this._handleEvent(initStart, initEnd);
|
|
// }
|
|
// });
|
|
|
|
//***********the other part of absolute positions*************
|
|
// Slider.prototype.setSteps = function(cb) {
|
|
// var posChange = this.$element.outerWidth() / this.options.steps;
|
|
// var counter = 0
|
|
// while(counter < this.options.steps) {
|
|
// if (counter) {
|
|
// this.options.positions.push(this.options.positions[counter - 1] + posChange);
|
|
// } else {
|
|
// this.options.positions.push(posChange);
|
|
// }
|
|
// counter++;
|
|
// }
|
|
// cb();
|
|
// };
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* Sticky module.
|
|
* @module foundation.sticky
|
|
* @requires foundation.util.triggers
|
|
* @requires foundation.util.mediaQuery
|
|
*/
|
|
|
|
var Sticky = function () {
|
|
/**
|
|
* Creates a new instance of a sticky thing.
|
|
* @class
|
|
* @param {jQuery} element - jQuery object to make sticky.
|
|
* @param {Object} options - options object passed when creating the element programmatically.
|
|
*/
|
|
function Sticky(element, options) {
|
|
_classCallCheck(this, Sticky);
|
|
|
|
this.$element = element;
|
|
this.options = $.extend({}, Sticky.defaults, this.$element.data(), options);
|
|
|
|
this._init();
|
|
|
|
Foundation.registerPlugin(this, 'Sticky');
|
|
}
|
|
|
|
/**
|
|
* Initializes the sticky element by adding classes, getting/setting dimensions, breakpoints and attributes
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(Sticky, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
var $parent = this.$element.parent('[data-sticky-container]'),
|
|
id = this.$element[0].id || Foundation.GetYoDigits(6, 'sticky'),
|
|
_this = this;
|
|
|
|
if (!$parent.length) {
|
|
this.wasWrapped = true;
|
|
}
|
|
this.$container = $parent.length ? $parent : $(this.options.container).wrapInner(this.$element);
|
|
this.$container.addClass(this.options.containerClass);
|
|
|
|
this.$element.addClass(this.options.stickyClass).attr({ 'data-resize': id });
|
|
|
|
this.scrollCount = this.options.checkEvery;
|
|
this.isStuck = false;
|
|
$(window).one('load.zf.sticky', function () {
|
|
//We calculate the container height to have correct values for anchor points offset calculation.
|
|
_this.containerHeight = _this.$element.css("display") == "none" ? 0 : _this.$element[0].getBoundingClientRect().height;
|
|
_this.$container.css('height', _this.containerHeight);
|
|
_this.elemHeight = _this.containerHeight;
|
|
if (_this.options.anchor !== '') {
|
|
_this.$anchor = $('#' + _this.options.anchor);
|
|
} else {
|
|
_this._parsePoints();
|
|
}
|
|
|
|
_this._setSizes(function () {
|
|
_this._calc(false);
|
|
});
|
|
_this._events(id.split('-').reverse().join('-'));
|
|
});
|
|
}
|
|
|
|
/**
|
|
* If using multiple elements as anchors, calculates the top and bottom pixel values the sticky thing should stick and unstick on.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_parsePoints',
|
|
value: function _parsePoints() {
|
|
var top = this.options.topAnchor == "" ? 1 : this.options.topAnchor,
|
|
btm = this.options.btmAnchor == "" ? document.documentElement.scrollHeight : this.options.btmAnchor,
|
|
pts = [top, btm],
|
|
breaks = {};
|
|
for (var i = 0, len = pts.length; i < len && pts[i]; i++) {
|
|
var pt;
|
|
if (typeof pts[i] === 'number') {
|
|
pt = pts[i];
|
|
} else {
|
|
var place = pts[i].split(':'),
|
|
anchor = $('#' + place[0]);
|
|
|
|
pt = anchor.offset().top;
|
|
if (place[1] && place[1].toLowerCase() === 'bottom') {
|
|
pt += anchor[0].getBoundingClientRect().height;
|
|
}
|
|
}
|
|
breaks[i] = pt;
|
|
}
|
|
|
|
this.points = breaks;
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* Adds event handlers for the scrolling element.
|
|
* @private
|
|
* @param {String} id - psuedo-random id for unique scroll event listener.
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events(id) {
|
|
var _this = this,
|
|
scrollListener = this.scrollListener = 'scroll.zf.' + id;
|
|
if (this.isOn) {
|
|
return;
|
|
}
|
|
if (this.canStick) {
|
|
this.isOn = true;
|
|
$(window).off(scrollListener).on(scrollListener, function (e) {
|
|
if (_this.scrollCount === 0) {
|
|
_this.scrollCount = _this.options.checkEvery;
|
|
_this._setSizes(function () {
|
|
_this._calc(false, window.pageYOffset);
|
|
});
|
|
} else {
|
|
_this.scrollCount--;
|
|
_this._calc(false, window.pageYOffset);
|
|
}
|
|
});
|
|
}
|
|
|
|
this.$element.off('resizeme.zf.trigger').on('resizeme.zf.trigger', function (e, el) {
|
|
_this._setSizes(function () {
|
|
_this._calc(false);
|
|
if (_this.canStick) {
|
|
if (!_this.isOn) {
|
|
_this._events(id);
|
|
}
|
|
} else if (_this.isOn) {
|
|
_this._pauseListeners(scrollListener);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Removes event handlers for scroll and change events on anchor.
|
|
* @fires Sticky#pause
|
|
* @param {String} scrollListener - unique, namespaced scroll listener attached to `window`
|
|
*/
|
|
|
|
}, {
|
|
key: '_pauseListeners',
|
|
value: function _pauseListeners(scrollListener) {
|
|
this.isOn = false;
|
|
$(window).off(scrollListener);
|
|
|
|
/**
|
|
* Fires when the plugin is paused due to resize event shrinking the view.
|
|
* @event Sticky#pause
|
|
* @private
|
|
*/
|
|
this.$element.trigger('pause.zf.sticky');
|
|
}
|
|
|
|
/**
|
|
* Called on every `scroll` event and on `_init`
|
|
* fires functions based on booleans and cached values
|
|
* @param {Boolean} checkSizes - true if plugin should recalculate sizes and breakpoints.
|
|
* @param {Number} scroll - current scroll position passed from scroll event cb function. If not passed, defaults to `window.pageYOffset`.
|
|
*/
|
|
|
|
}, {
|
|
key: '_calc',
|
|
value: function _calc(checkSizes, scroll) {
|
|
if (checkSizes) {
|
|
this._setSizes();
|
|
}
|
|
|
|
if (!this.canStick) {
|
|
if (this.isStuck) {
|
|
this._removeSticky(true);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if (!scroll) {
|
|
scroll = window.pageYOffset;
|
|
}
|
|
|
|
if (scroll >= this.topPoint) {
|
|
if (scroll <= this.bottomPoint) {
|
|
if (!this.isStuck) {
|
|
this._setSticky();
|
|
}
|
|
} else {
|
|
if (this.isStuck) {
|
|
this._removeSticky(false);
|
|
}
|
|
}
|
|
} else {
|
|
if (this.isStuck) {
|
|
this._removeSticky(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Causes the $element to become stuck.
|
|
* Adds `position: fixed;`, and helper classes.
|
|
* @fires Sticky#stuckto
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_setSticky',
|
|
value: function _setSticky() {
|
|
var _this = this,
|
|
stickTo = this.options.stickTo,
|
|
mrgn = stickTo === 'top' ? 'marginTop' : 'marginBottom',
|
|
notStuckTo = stickTo === 'top' ? 'bottom' : 'top',
|
|
css = {};
|
|
|
|
css[mrgn] = this.options[mrgn] + 'em';
|
|
css[stickTo] = 0;
|
|
css[notStuckTo] = 'auto';
|
|
css['left'] = this.$container.offset().left + parseInt(window.getComputedStyle(this.$container[0])["padding-left"], 10);
|
|
this.isStuck = true;
|
|
this.$element.removeClass('is-anchored is-at-' + notStuckTo).addClass('is-stuck is-at-' + stickTo).css(css)
|
|
/**
|
|
* Fires when the $element has become `position: fixed;`
|
|
* Namespaced to `top` or `bottom`, e.g. `sticky.zf.stuckto:top`
|
|
* @event Sticky#stuckto
|
|
*/
|
|
.trigger('sticky.zf.stuckto:' + stickTo);
|
|
this.$element.on("transitionend webkitTransitionEnd oTransitionEnd otransitionend MSTransitionEnd", function () {
|
|
_this._setSizes();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Causes the $element to become unstuck.
|
|
* Removes `position: fixed;`, and helper classes.
|
|
* Adds other helper classes.
|
|
* @param {Boolean} isTop - tells the function if the $element should anchor to the top or bottom of its $anchor element.
|
|
* @fires Sticky#unstuckfrom
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_removeSticky',
|
|
value: function _removeSticky(isTop) {
|
|
var stickTo = this.options.stickTo,
|
|
stickToTop = stickTo === 'top',
|
|
css = {},
|
|
anchorPt = (this.points ? this.points[1] - this.points[0] : this.anchorHeight) - this.elemHeight,
|
|
mrgn = stickToTop ? 'marginTop' : 'marginBottom',
|
|
notStuckTo = stickToTop ? 'bottom' : 'top',
|
|
topOrBottom = isTop ? 'top' : 'bottom';
|
|
|
|
css[mrgn] = 0;
|
|
|
|
css['bottom'] = 'auto';
|
|
if (isTop) {
|
|
css['top'] = 0;
|
|
} else {
|
|
css['top'] = anchorPt;
|
|
}
|
|
|
|
css['left'] = '';
|
|
this.isStuck = false;
|
|
this.$element.removeClass('is-stuck is-at-' + stickTo).addClass('is-anchored is-at-' + topOrBottom).css(css)
|
|
/**
|
|
* Fires when the $element has become anchored.
|
|
* Namespaced to `top` or `bottom`, e.g. `sticky.zf.unstuckfrom:bottom`
|
|
* @event Sticky#unstuckfrom
|
|
*/
|
|
.trigger('sticky.zf.unstuckfrom:' + topOrBottom);
|
|
}
|
|
|
|
/**
|
|
* Sets the $element and $container sizes for plugin.
|
|
* Calls `_setBreakPoints`.
|
|
* @param {Function} cb - optional callback function to fire on completion of `_setBreakPoints`.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_setSizes',
|
|
value: function _setSizes(cb) {
|
|
this.canStick = Foundation.MediaQuery.atLeast(this.options.stickyOn);
|
|
if (!this.canStick) {
|
|
if (cb && typeof cb === 'function') {
|
|
cb();
|
|
}
|
|
}
|
|
var _this = this,
|
|
newElemWidth = this.$container[0].getBoundingClientRect().width,
|
|
comp = window.getComputedStyle(this.$container[0]),
|
|
pdng = parseInt(comp['padding-right'], 10);
|
|
|
|
if (this.$anchor && this.$anchor.length) {
|
|
this.anchorHeight = this.$anchor[0].getBoundingClientRect().height;
|
|
} else {
|
|
this._parsePoints();
|
|
}
|
|
|
|
this.$element.css({
|
|
'max-width': newElemWidth - pdng + 'px'
|
|
});
|
|
|
|
var newContainerHeight = this.$element[0].getBoundingClientRect().height || this.containerHeight;
|
|
if (this.$element.css("display") == "none") {
|
|
newContainerHeight = 0;
|
|
}
|
|
this.containerHeight = newContainerHeight;
|
|
this.$container.css({
|
|
height: newContainerHeight
|
|
});
|
|
this.elemHeight = newContainerHeight;
|
|
|
|
if (this.isStuck) {
|
|
this.$element.css({ "left": this.$container.offset().left + parseInt(comp['padding-left'], 10) });
|
|
} else {
|
|
if (this.$element.hasClass('is-at-bottom')) {
|
|
var anchorPt = (this.points ? this.points[1] - this.$container.offset().top : this.anchorHeight) - this.elemHeight;
|
|
this.$element.css('top', anchorPt);
|
|
}
|
|
}
|
|
|
|
this._setBreakPoints(newContainerHeight, function () {
|
|
if (cb && typeof cb === 'function') {
|
|
cb();
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Sets the upper and lower breakpoints for the element to become sticky/unsticky.
|
|
* @param {Number} elemHeight - px value for sticky.$element height, calculated by `_setSizes`.
|
|
* @param {Function} cb - optional callback function to be called on completion.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_setBreakPoints',
|
|
value: function _setBreakPoints(elemHeight, cb) {
|
|
if (!this.canStick) {
|
|
if (cb && typeof cb === 'function') {
|
|
cb();
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
var mTop = emCalc(this.options.marginTop),
|
|
mBtm = emCalc(this.options.marginBottom),
|
|
topPoint = this.points ? this.points[0] : this.$anchor.offset().top,
|
|
bottomPoint = this.points ? this.points[1] : topPoint + this.anchorHeight,
|
|
|
|
// topPoint = this.$anchor.offset().top || this.points[0],
|
|
// bottomPoint = topPoint + this.anchorHeight || this.points[1],
|
|
winHeight = window.innerHeight;
|
|
|
|
if (this.options.stickTo === 'top') {
|
|
topPoint -= mTop;
|
|
bottomPoint -= elemHeight + mTop;
|
|
} else if (this.options.stickTo === 'bottom') {
|
|
topPoint -= winHeight - (elemHeight + mBtm);
|
|
bottomPoint -= winHeight - mBtm;
|
|
} else {
|
|
//this would be the stickTo: both option... tricky
|
|
}
|
|
|
|
this.topPoint = topPoint;
|
|
this.bottomPoint = bottomPoint;
|
|
|
|
if (cb && typeof cb === 'function') {
|
|
cb();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Destroys the current sticky element.
|
|
* Resets the element to the top position first.
|
|
* Removes event listeners, JS-added css properties and classes, and unwraps the $element if the JS added the $container.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
this._removeSticky(true);
|
|
|
|
this.$element.removeClass(this.options.stickyClass + ' is-anchored is-at-top').css({
|
|
height: '',
|
|
top: '',
|
|
bottom: '',
|
|
'max-width': ''
|
|
}).off('resizeme.zf.trigger');
|
|
if (this.$anchor && this.$anchor.length) {
|
|
this.$anchor.off('change.zf.sticky');
|
|
}
|
|
$(window).off(this.scrollListener);
|
|
|
|
if (this.wasWrapped) {
|
|
this.$element.unwrap();
|
|
} else {
|
|
this.$container.removeClass(this.options.containerClass).css({
|
|
height: ''
|
|
});
|
|
}
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return Sticky;
|
|
}();
|
|
|
|
Sticky.defaults = {
|
|
/**
|
|
* Customizable container template. Add your own classes for styling and sizing.
|
|
* @option
|
|
* @example '<div data-sticky-container class="small-6 columns"></div>'
|
|
*/
|
|
container: '<div data-sticky-container></div>',
|
|
/**
|
|
* Location in the view the element sticks to.
|
|
* @option
|
|
* @example 'top'
|
|
*/
|
|
stickTo: 'top',
|
|
/**
|
|
* If anchored to a single element, the id of that element.
|
|
* @option
|
|
* @example 'exampleId'
|
|
*/
|
|
anchor: '',
|
|
/**
|
|
* If using more than one element as anchor points, the id of the top anchor.
|
|
* @option
|
|
* @example 'exampleId:top'
|
|
*/
|
|
topAnchor: '',
|
|
/**
|
|
* If using more than one element as anchor points, the id of the bottom anchor.
|
|
* @option
|
|
* @example 'exampleId:bottom'
|
|
*/
|
|
btmAnchor: '',
|
|
/**
|
|
* Margin, in `em`'s to apply to the top of the element when it becomes sticky.
|
|
* @option
|
|
* @example 1
|
|
*/
|
|
marginTop: 1,
|
|
/**
|
|
* Margin, in `em`'s to apply to the bottom of the element when it becomes sticky.
|
|
* @option
|
|
* @example 1
|
|
*/
|
|
marginBottom: 1,
|
|
/**
|
|
* Breakpoint string that is the minimum screen size an element should become sticky.
|
|
* @option
|
|
* @example 'medium'
|
|
*/
|
|
stickyOn: 'medium',
|
|
/**
|
|
* Class applied to sticky element, and removed on destruction. Foundation defaults to `sticky`.
|
|
* @option
|
|
* @example 'sticky'
|
|
*/
|
|
stickyClass: 'sticky',
|
|
/**
|
|
* Class applied to sticky container. Foundation defaults to `sticky-container`.
|
|
* @option
|
|
* @example 'sticky-container'
|
|
*/
|
|
containerClass: 'sticky-container',
|
|
/**
|
|
* Number of scroll events between the plugin's recalculating sticky points. Setting it to `0` will cause it to recalc every scroll event, setting it to `-1` will prevent recalc on scroll.
|
|
* @option
|
|
* @example 50
|
|
*/
|
|
checkEvery: -1
|
|
};
|
|
|
|
/**
|
|
* Helper function to calculate em values
|
|
* @param Number {em} - number of em's to calculate into pixels
|
|
*/
|
|
function emCalc(em) {
|
|
return parseInt(window.getComputedStyle(document.body, null).fontSize, 10) * em;
|
|
}
|
|
|
|
// Window exports
|
|
Foundation.plugin(Sticky, 'Sticky');
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* Tabs module.
|
|
* @module foundation.tabs
|
|
* @requires foundation.util.keyboard
|
|
* @requires foundation.util.timerAndImageLoader if tabs contain images
|
|
*/
|
|
|
|
var Tabs = function () {
|
|
/**
|
|
* Creates a new instance of tabs.
|
|
* @class
|
|
* @fires Tabs#init
|
|
* @param {jQuery} element - jQuery object to make into tabs.
|
|
* @param {Object} options - Overrides to the default plugin settings.
|
|
*/
|
|
function Tabs(element, options) {
|
|
_classCallCheck(this, Tabs);
|
|
|
|
this.$element = element;
|
|
this.options = $.extend({}, Tabs.defaults, this.$element.data(), options);
|
|
|
|
this._init();
|
|
Foundation.registerPlugin(this, 'Tabs');
|
|
Foundation.Keyboard.register('Tabs', {
|
|
'ENTER': 'open',
|
|
'SPACE': 'open',
|
|
'ARROW_RIGHT': 'next',
|
|
'ARROW_UP': 'previous',
|
|
'ARROW_DOWN': 'next',
|
|
'ARROW_LEFT': 'previous'
|
|
// 'TAB': 'next',
|
|
// 'SHIFT_TAB': 'previous'
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Initializes the tabs by showing and focusing (if autoFocus=true) the preset active tab.
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(Tabs, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
var _this = this;
|
|
|
|
this.$tabTitles = this.$element.find('.' + this.options.linkClass);
|
|
this.$tabContent = $('[data-tabs-content="' + this.$element[0].id + '"]');
|
|
|
|
this.$tabTitles.each(function () {
|
|
var $elem = $(this),
|
|
$link = $elem.find('a'),
|
|
isActive = $elem.hasClass('is-active'),
|
|
hash = $link[0].hash.slice(1),
|
|
linkId = $link[0].id ? $link[0].id : hash + '-label',
|
|
$tabContent = $('#' + hash);
|
|
|
|
$elem.attr({ 'role': 'presentation' });
|
|
|
|
$link.attr({
|
|
'role': 'tab',
|
|
'aria-controls': hash,
|
|
'aria-selected': isActive,
|
|
'id': linkId
|
|
});
|
|
|
|
$tabContent.attr({
|
|
'role': 'tabpanel',
|
|
'aria-hidden': !isActive,
|
|
'aria-labelledby': linkId
|
|
});
|
|
|
|
if (isActive && _this.options.autoFocus) {
|
|
$link.focus();
|
|
}
|
|
});
|
|
|
|
if (this.options.matchHeight) {
|
|
var $images = this.$tabContent.find('img');
|
|
|
|
if ($images.length) {
|
|
Foundation.onImagesLoaded($images, this._setHeight.bind(this));
|
|
} else {
|
|
this._setHeight();
|
|
}
|
|
}
|
|
|
|
this._events();
|
|
}
|
|
|
|
/**
|
|
* Adds event handlers for items within the tabs.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events() {
|
|
this._addKeyHandler();
|
|
this._addClickHandler();
|
|
this._setHeightMqHandler = null;
|
|
|
|
if (this.options.matchHeight) {
|
|
this._setHeightMqHandler = this._setHeight.bind(this);
|
|
|
|
$(window).on('changed.zf.mediaquery', this._setHeightMqHandler);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds click handlers for items within the tabs.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_addClickHandler',
|
|
value: function _addClickHandler() {
|
|
var _this = this;
|
|
|
|
this.$element.off('click.zf.tabs').on('click.zf.tabs', '.' + this.options.linkClass, function (e) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
if ($(this).hasClass('is-active')) {
|
|
return;
|
|
}
|
|
_this._handleTabChange($(this));
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Adds keyboard event handlers for items within the tabs.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_addKeyHandler',
|
|
value: function _addKeyHandler() {
|
|
var _this = this;
|
|
var $firstTab = _this.$element.find('li:first-of-type');
|
|
var $lastTab = _this.$element.find('li:last-of-type');
|
|
|
|
this.$tabTitles.off('keydown.zf.tabs').on('keydown.zf.tabs', function (e) {
|
|
if (e.which === 9) return;
|
|
|
|
var $element = $(this),
|
|
$elements = $element.parent('ul').children('li'),
|
|
$prevElement,
|
|
$nextElement;
|
|
|
|
$elements.each(function (i) {
|
|
if ($(this).is($element)) {
|
|
if (_this.options.wrapOnKeys) {
|
|
$prevElement = i === 0 ? $elements.last() : $elements.eq(i - 1);
|
|
$nextElement = i === $elements.length - 1 ? $elements.first() : $elements.eq(i + 1);
|
|
} else {
|
|
$prevElement = $elements.eq(Math.max(0, i - 1));
|
|
$nextElement = $elements.eq(Math.min(i + 1, $elements.length - 1));
|
|
}
|
|
return;
|
|
}
|
|
});
|
|
|
|
// handle keyboard event with keyboard util
|
|
Foundation.Keyboard.handleKey(e, 'Tabs', {
|
|
open: function () {
|
|
$element.find('[role="tab"]').focus();
|
|
_this._handleTabChange($element);
|
|
},
|
|
previous: function () {
|
|
$prevElement.find('[role="tab"]').focus();
|
|
_this._handleTabChange($prevElement);
|
|
},
|
|
next: function () {
|
|
$nextElement.find('[role="tab"]').focus();
|
|
_this._handleTabChange($nextElement);
|
|
},
|
|
handled: function () {
|
|
e.stopPropagation();
|
|
e.preventDefault();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Opens the tab `$targetContent` defined by `$target`.
|
|
* @param {jQuery} $target - Tab to open.
|
|
* @fires Tabs#change
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: '_handleTabChange',
|
|
value: function _handleTabChange($target) {
|
|
var $tabLink = $target.find('[role="tab"]'),
|
|
hash = $tabLink[0].hash,
|
|
$targetContent = this.$tabContent.find(hash),
|
|
$oldTab = this.$element.find('.' + this.options.linkClass + '.is-active').removeClass('is-active').find('[role="tab"]').attr({ 'aria-selected': 'false' });
|
|
|
|
$('#' + $oldTab.attr('aria-controls')).removeClass('is-active').attr({ 'aria-hidden': 'true' });
|
|
|
|
$target.addClass('is-active');
|
|
|
|
$tabLink.attr({ 'aria-selected': 'true' });
|
|
|
|
$targetContent.addClass('is-active').attr({ 'aria-hidden': 'false' });
|
|
|
|
/**
|
|
* Fires when the plugin has successfully changed tabs.
|
|
* @event Tabs#change
|
|
*/
|
|
this.$element.trigger('change.zf.tabs', [$target]);
|
|
}
|
|
|
|
/**
|
|
* Public method for selecting a content pane to display.
|
|
* @param {jQuery | String} elem - jQuery object or string of the id of the pane to display.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'selectTab',
|
|
value: function selectTab(elem) {
|
|
var idStr;
|
|
|
|
if (typeof elem === 'object') {
|
|
idStr = elem[0].id;
|
|
} else {
|
|
idStr = elem;
|
|
}
|
|
|
|
if (idStr.indexOf('#') < 0) {
|
|
idStr = '#' + idStr;
|
|
}
|
|
|
|
var $target = this.$tabTitles.find('[href="' + idStr + '"]').parent('.' + this.options.linkClass);
|
|
|
|
this._handleTabChange($target);
|
|
}
|
|
}, {
|
|
key: '_setHeight',
|
|
|
|
/**
|
|
* Sets the height of each panel to the height of the tallest panel.
|
|
* If enabled in options, gets called on media query change.
|
|
* If loading content via external source, can be called directly or with _reflow.
|
|
* @function
|
|
* @private
|
|
*/
|
|
value: function _setHeight() {
|
|
var max = 0;
|
|
this.$tabContent.find('.' + this.options.panelClass).css('height', '').each(function () {
|
|
var panel = $(this),
|
|
isActive = panel.hasClass('is-active');
|
|
|
|
if (!isActive) {
|
|
panel.css({ 'visibility': 'hidden', 'display': 'block' });
|
|
}
|
|
|
|
var temp = this.getBoundingClientRect().height;
|
|
|
|
if (!isActive) {
|
|
panel.css({
|
|
'visibility': '',
|
|
'display': ''
|
|
});
|
|
}
|
|
|
|
max = temp > max ? temp : max;
|
|
}).css('height', max + 'px');
|
|
}
|
|
|
|
/**
|
|
* Destroys an instance of an tabs.
|
|
* @fires Tabs#destroyed
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
this.$element.find('.' + this.options.linkClass).off('.zf.tabs').hide().end().find('.' + this.options.panelClass).hide();
|
|
|
|
if (this.options.matchHeight) {
|
|
if (this._setHeightMqHandler != null) {
|
|
$(window).off('changed.zf.mediaquery', this._setHeightMqHandler);
|
|
}
|
|
}
|
|
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return Tabs;
|
|
}();
|
|
|
|
Tabs.defaults = {
|
|
/**
|
|
* Allows the window to scroll to content of active pane on load if set to true.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
autoFocus: false,
|
|
|
|
/**
|
|
* Allows keyboard input to 'wrap' around the tab links.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
wrapOnKeys: true,
|
|
|
|
/**
|
|
* Allows the tab content panes to match heights if set to true.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
matchHeight: false,
|
|
|
|
/**
|
|
* Class applied to `li`'s in tab link list.
|
|
* @option
|
|
* @example 'tabs-title'
|
|
*/
|
|
linkClass: 'tabs-title',
|
|
|
|
/**
|
|
* Class applied to the content containers.
|
|
* @option
|
|
* @example 'tabs-panel'
|
|
*/
|
|
panelClass: 'tabs-panel'
|
|
};
|
|
|
|
function checkClass($elem) {
|
|
return $elem.hasClass('is-active');
|
|
}
|
|
|
|
// Window exports
|
|
Foundation.plugin(Tabs, 'Tabs');
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* Toggler module.
|
|
* @module foundation.toggler
|
|
* @requires foundation.util.motion
|
|
* @requires foundation.util.triggers
|
|
*/
|
|
|
|
var Toggler = function () {
|
|
/**
|
|
* Creates a new instance of Toggler.
|
|
* @class
|
|
* @fires Toggler#init
|
|
* @param {Object} element - jQuery object to add the trigger to.
|
|
* @param {Object} options - Overrides to the default plugin settings.
|
|
*/
|
|
function Toggler(element, options) {
|
|
_classCallCheck(this, Toggler);
|
|
|
|
this.$element = element;
|
|
this.options = $.extend({}, Toggler.defaults, element.data(), options);
|
|
this.className = '';
|
|
|
|
this._init();
|
|
this._events();
|
|
|
|
Foundation.registerPlugin(this, 'Toggler');
|
|
}
|
|
|
|
/**
|
|
* Initializes the Toggler plugin by parsing the toggle class from data-toggler, or animation classes from data-animate.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(Toggler, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
var input;
|
|
// Parse animation classes if they were set
|
|
if (this.options.animate) {
|
|
input = this.options.animate.split(' ');
|
|
|
|
this.animationIn = input[0];
|
|
this.animationOut = input[1] || null;
|
|
}
|
|
// Otherwise, parse toggle class
|
|
else {
|
|
input = this.$element.data('toggler');
|
|
// Allow for a . at the beginning of the string
|
|
this.className = input[0] === '.' ? input.slice(1) : input;
|
|
}
|
|
|
|
// Add ARIA attributes to triggers
|
|
var id = this.$element[0].id;
|
|
$('[data-open="' + id + '"], [data-close="' + id + '"], [data-toggle="' + id + '"]').attr('aria-controls', id);
|
|
// If the target is hidden, add aria-hidden
|
|
this.$element.attr('aria-expanded', this.$element.is(':hidden') ? false : true);
|
|
}
|
|
|
|
/**
|
|
* Initializes events for the toggle trigger.
|
|
* @function
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events() {
|
|
this.$element.off('toggle.zf.trigger').on('toggle.zf.trigger', this.toggle.bind(this));
|
|
}
|
|
|
|
/**
|
|
* Toggles the target class on the target element. An event is fired from the original trigger depending on if the resultant state was "on" or "off".
|
|
* @function
|
|
* @fires Toggler#on
|
|
* @fires Toggler#off
|
|
*/
|
|
|
|
}, {
|
|
key: 'toggle',
|
|
value: function toggle() {
|
|
this[this.options.animate ? '_toggleAnimate' : '_toggleClass']();
|
|
}
|
|
}, {
|
|
key: '_toggleClass',
|
|
value: function _toggleClass() {
|
|
this.$element.toggleClass(this.className);
|
|
|
|
var isOn = this.$element.hasClass(this.className);
|
|
if (isOn) {
|
|
/**
|
|
* Fires if the target element has the class after a toggle.
|
|
* @event Toggler#on
|
|
*/
|
|
this.$element.trigger('on.zf.toggler');
|
|
} else {
|
|
/**
|
|
* Fires if the target element does not have the class after a toggle.
|
|
* @event Toggler#off
|
|
*/
|
|
this.$element.trigger('off.zf.toggler');
|
|
}
|
|
|
|
this._updateARIA(isOn);
|
|
}
|
|
}, {
|
|
key: '_toggleAnimate',
|
|
value: function _toggleAnimate() {
|
|
var _this = this;
|
|
|
|
if (this.$element.is(':hidden')) {
|
|
Foundation.Motion.animateIn(this.$element, this.animationIn, function () {
|
|
_this._updateARIA(true);
|
|
this.trigger('on.zf.toggler');
|
|
});
|
|
} else {
|
|
Foundation.Motion.animateOut(this.$element, this.animationOut, function () {
|
|
_this._updateARIA(false);
|
|
this.trigger('off.zf.toggler');
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: '_updateARIA',
|
|
value: function _updateARIA(isOn) {
|
|
this.$element.attr('aria-expanded', isOn ? true : false);
|
|
}
|
|
|
|
/**
|
|
* Destroys the instance of Toggler on the element.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
this.$element.off('.zf.toggler');
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return Toggler;
|
|
}();
|
|
|
|
Toggler.defaults = {
|
|
/**
|
|
* Tells the plugin if the element should animated when toggled.
|
|
* @option
|
|
* @example false
|
|
*/
|
|
animate: false
|
|
};
|
|
|
|
// Window exports
|
|
Foundation.plugin(Toggler, 'Toggler');
|
|
}(jQuery);
|
|
'use strict';
|
|
|
|
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; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
!function ($) {
|
|
|
|
/**
|
|
* Tooltip module.
|
|
* @module foundation.tooltip
|
|
* @requires foundation.util.box
|
|
* @requires foundation.util.mediaQuery
|
|
* @requires foundation.util.triggers
|
|
*/
|
|
|
|
var Tooltip = function () {
|
|
/**
|
|
* Creates a new instance of a Tooltip.
|
|
* @class
|
|
* @fires Tooltip#init
|
|
* @param {jQuery} element - jQuery object to attach a tooltip to.
|
|
* @param {Object} options - object to extend the default configuration.
|
|
*/
|
|
function Tooltip(element, options) {
|
|
_classCallCheck(this, Tooltip);
|
|
|
|
this.$element = element;
|
|
this.options = $.extend({}, Tooltip.defaults, this.$element.data(), options);
|
|
|
|
this.isActive = false;
|
|
this.isClick = false;
|
|
this._init();
|
|
|
|
Foundation.registerPlugin(this, 'Tooltip');
|
|
}
|
|
|
|
/**
|
|
* Initializes the tooltip by setting the creating the tip element, adding it's text, setting private variables and setting attributes on the anchor.
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(Tooltip, [{
|
|
key: '_init',
|
|
value: function _init() {
|
|
var elemId = this.$element.attr('aria-describedby') || Foundation.GetYoDigits(6, 'tooltip');
|
|
|
|
this.options.positionClass = this.options.positionClass || this._getPositionClass(this.$element);
|
|
this.options.tipText = this.options.tipText || this.$element.attr('title');
|
|
this.template = this.options.template ? $(this.options.template) : this._buildTemplate(elemId);
|
|
|
|
this.template.appendTo(document.body).text(this.options.tipText).hide();
|
|
|
|
this.$element.attr({
|
|
'title': '',
|
|
'aria-describedby': elemId,
|
|
'data-yeti-box': elemId,
|
|
'data-toggle': elemId,
|
|
'data-resize': elemId
|
|
}).addClass(this.options.triggerClass);
|
|
|
|
//helper variables to track movement on collisions
|
|
this.usedPositions = [];
|
|
this.counter = 4;
|
|
this.classChanged = false;
|
|
|
|
this._events();
|
|
}
|
|
|
|
/**
|
|
* Grabs the current positioning class, if present, and returns the value or an empty string.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_getPositionClass',
|
|
value: function _getPositionClass(element) {
|
|
if (!element) {
|
|
return '';
|
|
}
|
|
// var position = element.attr('class').match(/top|left|right/g);
|
|
var position = element[0].className.match(/\b(top|left|right)\b/g);
|
|
position = position ? position[0] : '';
|
|
return position;
|
|
}
|
|
}, {
|
|
key: '_buildTemplate',
|
|
|
|
/**
|
|
* builds the tooltip element, adds attributes, and returns the template.
|
|
* @private
|
|
*/
|
|
value: function _buildTemplate(id) {
|
|
var templateClasses = (this.options.tooltipClass + ' ' + this.options.positionClass + ' ' + this.options.templateClasses).trim();
|
|
var $template = $('<div></div>').addClass(templateClasses).attr({
|
|
'role': 'tooltip',
|
|
'aria-hidden': true,
|
|
'data-is-active': false,
|
|
'data-is-focus': false,
|
|
'id': id
|
|
});
|
|
return $template;
|
|
}
|
|
|
|
/**
|
|
* Function that gets called if a collision event is detected.
|
|
* @param {String} position - positioning class to try
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_reposition',
|
|
value: function _reposition(position) {
|
|
this.usedPositions.push(position ? position : 'bottom');
|
|
|
|
//default, try switching to opposite side
|
|
if (!position && this.usedPositions.indexOf('top') < 0) {
|
|
this.template.addClass('top');
|
|
} else if (position === 'top' && this.usedPositions.indexOf('bottom') < 0) {
|
|
this.template.removeClass(position);
|
|
} else if (position === 'left' && this.usedPositions.indexOf('right') < 0) {
|
|
this.template.removeClass(position).addClass('right');
|
|
} else if (position === 'right' && this.usedPositions.indexOf('left') < 0) {
|
|
this.template.removeClass(position).addClass('left');
|
|
}
|
|
|
|
//if default change didn't work, try bottom or left first
|
|
else if (!position && this.usedPositions.indexOf('top') > -1 && this.usedPositions.indexOf('left') < 0) {
|
|
this.template.addClass('left');
|
|
} else if (position === 'top' && this.usedPositions.indexOf('bottom') > -1 && this.usedPositions.indexOf('left') < 0) {
|
|
this.template.removeClass(position).addClass('left');
|
|
} else if (position === 'left' && this.usedPositions.indexOf('right') > -1 && this.usedPositions.indexOf('bottom') < 0) {
|
|
this.template.removeClass(position);
|
|
} else if (position === 'right' && this.usedPositions.indexOf('left') > -1 && this.usedPositions.indexOf('bottom') < 0) {
|
|
this.template.removeClass(position);
|
|
}
|
|
//if nothing cleared, set to bottom
|
|
else {
|
|
this.template.removeClass(position);
|
|
}
|
|
this.classChanged = true;
|
|
this.counter--;
|
|
}
|
|
|
|
/**
|
|
* sets the position class of an element and recursively calls itself until there are no more possible positions to attempt, or the tooltip element is no longer colliding.
|
|
* if the tooltip is larger than the screen width, default to full width - any user selected margin
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_setPosition',
|
|
value: function _setPosition() {
|
|
var position = this._getPositionClass(this.template),
|
|
$tipDims = Foundation.Box.GetDimensions(this.template),
|
|
$anchorDims = Foundation.Box.GetDimensions(this.$element),
|
|
direction = position === 'left' ? 'left' : position === 'right' ? 'left' : 'top',
|
|
param = direction === 'top' ? 'height' : 'width',
|
|
offset = param === 'height' ? this.options.vOffset : this.options.hOffset,
|
|
_this = this;
|
|
|
|
if ($tipDims.width >= $tipDims.windowDims.width || !this.counter && !Foundation.Box.ImNotTouchingYou(this.template)) {
|
|
this.template.offset(Foundation.Box.GetOffsets(this.template, this.$element, 'center bottom', this.options.vOffset, this.options.hOffset, true)).css({
|
|
// this.$element.offset(Foundation.GetOffsets(this.template, this.$element, 'center bottom', this.options.vOffset, this.options.hOffset, true)).css({
|
|
'width': $anchorDims.windowDims.width - this.options.hOffset * 2,
|
|
'height': 'auto'
|
|
});
|
|
return false;
|
|
}
|
|
|
|
this.template.offset(Foundation.Box.GetOffsets(this.template, this.$element, 'center ' + (position || 'bottom'), this.options.vOffset, this.options.hOffset));
|
|
|
|
while (!Foundation.Box.ImNotTouchingYou(this.template) && this.counter) {
|
|
this._reposition(position);
|
|
this._setPosition();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* reveals the tooltip, and fires an event to close any other open tooltips on the page
|
|
* @fires Tooltip#closeme
|
|
* @fires Tooltip#show
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'show',
|
|
value: function show() {
|
|
if (this.options.showOn !== 'all' && !Foundation.MediaQuery.atLeast(this.options.showOn)) {
|
|
// console.error('The screen is too small to display this tooltip');
|
|
return false;
|
|
}
|
|
|
|
var _this = this;
|
|
this.template.css('visibility', 'hidden').show();
|
|
this._setPosition();
|
|
|
|
/**
|
|
* Fires to close all other open tooltips on the page
|
|
* @event Closeme#tooltip
|
|
*/
|
|
this.$element.trigger('closeme.zf.tooltip', this.template.attr('id'));
|
|
|
|
this.template.attr({
|
|
'data-is-active': true,
|
|
'aria-hidden': false
|
|
});
|
|
_this.isActive = true;
|
|
// console.log(this.template);
|
|
this.template.stop().hide().css('visibility', '').fadeIn(this.options.fadeInDuration, function () {
|
|
//maybe do stuff?
|
|
});
|
|
/**
|
|
* Fires when the tooltip is shown
|
|
* @event Tooltip#show
|
|
*/
|
|
this.$element.trigger('show.zf.tooltip');
|
|
}
|
|
|
|
/**
|
|
* Hides the current tooltip, and resets the positioning class if it was changed due to collision
|
|
* @fires Tooltip#hide
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'hide',
|
|
value: function hide() {
|
|
// console.log('hiding', this.$element.data('yeti-box'));
|
|
var _this = this;
|
|
this.template.stop().attr({
|
|
'aria-hidden': true,
|
|
'data-is-active': false
|
|
}).fadeOut(this.options.fadeOutDuration, function () {
|
|
_this.isActive = false;
|
|
_this.isClick = false;
|
|
if (_this.classChanged) {
|
|
_this.template.removeClass(_this._getPositionClass(_this.template)).addClass(_this.options.positionClass);
|
|
|
|
_this.usedPositions = [];
|
|
_this.counter = 4;
|
|
_this.classChanged = false;
|
|
}
|
|
});
|
|
/**
|
|
* fires when the tooltip is hidden
|
|
* @event Tooltip#hide
|
|
*/
|
|
this.$element.trigger('hide.zf.tooltip');
|
|
}
|
|
|
|
/**
|
|
* adds event listeners for the tooltip and its anchor
|
|
* TODO combine some of the listeners like focus and mouseenter, etc.
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: '_events',
|
|
value: function _events() {
|
|
var _this = this;
|
|
var $template = this.template;
|
|
var isFocus = false;
|
|
|
|
if (!this.options.disableHover) {
|
|
|
|
this.$element.on('mouseenter.zf.tooltip', function (e) {
|
|
if (!_this.isActive) {
|
|
_this.timeout = setTimeout(function () {
|
|
_this.show();
|
|
}, _this.options.hoverDelay);
|
|
}
|
|
}).on('mouseleave.zf.tooltip', function (e) {
|
|
clearTimeout(_this.timeout);
|
|
if (!isFocus || _this.isClick && !_this.options.clickOpen) {
|
|
_this.hide();
|
|
}
|
|
});
|
|
}
|
|
|
|
if (this.options.clickOpen) {
|
|
this.$element.on('mousedown.zf.tooltip', function (e) {
|
|
e.stopImmediatePropagation();
|
|
if (_this.isClick) {
|
|
//_this.hide();
|
|
// _this.isClick = false;
|
|
} else {
|
|
_this.isClick = true;
|
|
if ((_this.options.disableHover || !_this.$element.attr('tabindex')) && !_this.isActive) {
|
|
_this.show();
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
this.$element.on('mousedown.zf.tooltip', function (e) {
|
|
e.stopImmediatePropagation();
|
|
_this.isClick = true;
|
|
});
|
|
}
|
|
|
|
if (!this.options.disableForTouch) {
|
|
this.$element.on('tap.zf.tooltip touchend.zf.tooltip', function (e) {
|
|
_this.isActive ? _this.hide() : _this.show();
|
|
});
|
|
}
|
|
|
|
this.$element.on({
|
|
// 'toggle.zf.trigger': this.toggle.bind(this),
|
|
// 'close.zf.trigger': this.hide.bind(this)
|
|
'close.zf.trigger': this.hide.bind(this)
|
|
});
|
|
|
|
this.$element.on('focus.zf.tooltip', function (e) {
|
|
isFocus = true;
|
|
if (_this.isClick) {
|
|
// If we're not showing open on clicks, we need to pretend a click-launched focus isn't
|
|
// a real focus, otherwise on hover and come back we get bad behavior
|
|
if (!_this.options.clickOpen) {
|
|
isFocus = false;
|
|
}
|
|
return false;
|
|
} else {
|
|
_this.show();
|
|
}
|
|
}).on('focusout.zf.tooltip', function (e) {
|
|
isFocus = false;
|
|
_this.isClick = false;
|
|
_this.hide();
|
|
}).on('resizeme.zf.trigger', function () {
|
|
if (_this.isActive) {
|
|
_this._setPosition();
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* adds a toggle method, in addition to the static show() & hide() functions
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'toggle',
|
|
value: function toggle() {
|
|
if (this.isActive) {
|
|
this.hide();
|
|
} else {
|
|
this.show();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Destroys an instance of tooltip, removes template element from the view.
|
|
* @function
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
this.$element.attr('title', this.template.text()).off('.zf.trigger .zf.tootip')
|
|
// .removeClass('has-tip')
|
|
.removeAttr('aria-describedby').removeAttr('data-yeti-box').removeAttr('data-toggle').removeAttr('data-resize');
|
|
|
|
this.template.remove();
|
|
|
|
Foundation.unregisterPlugin(this);
|
|
}
|
|
}]);
|
|
|
|
return Tooltip;
|
|
}();
|
|
|
|
Tooltip.defaults = {
|
|
disableForTouch: false,
|
|
/**
|
|
* Time, in ms, before a tooltip should open on hover.
|
|
* @option
|
|
* @example 200
|
|
*/
|
|
hoverDelay: 200,
|
|
/**
|
|
* Time, in ms, a tooltip should take to fade into view.
|
|
* @option
|
|
* @example 150
|
|
*/
|
|
fadeInDuration: 150,
|
|
/**
|
|
* Time, in ms, a tooltip should take to fade out of view.
|
|
* @option
|
|
* @example 150
|
|
*/
|
|
fadeOutDuration: 150,
|
|
/**
|
|
* Disables hover events from opening the tooltip if set to true
|
|
* @option
|
|
* @example false
|
|
*/
|
|
disableHover: false,
|
|
/**
|
|
* Optional addtional classes to apply to the tooltip template on init.
|
|
* @option
|
|
* @example 'my-cool-tip-class'
|
|
*/
|
|
templateClasses: '',
|
|
/**
|
|
* Non-optional class added to tooltip templates. Foundation default is 'tooltip'.
|
|
* @option
|
|
* @example 'tooltip'
|
|
*/
|
|
tooltipClass: 'tooltip',
|
|
/**
|
|
* Class applied to the tooltip anchor element.
|
|
* @option
|
|
* @example 'has-tip'
|
|
*/
|
|
triggerClass: 'has-tip',
|
|
/**
|
|
* Minimum breakpoint size at which to open the tooltip.
|
|
* @option
|
|
* @example 'small'
|
|
*/
|
|
showOn: 'small',
|
|
/**
|
|
* Custom template to be used to generate markup for tooltip.
|
|
* @option
|
|
* @example '<div class="tooltip"></div>'
|
|
*/
|
|
template: '',
|
|
/**
|
|
* Text displayed in the tooltip template on open.
|
|
* @option
|
|
* @example 'Some cool space fact here.'
|
|
*/
|
|
tipText: '',
|
|
touchCloseText: 'Tap to close.',
|
|
/**
|
|
* Allows the tooltip to remain open if triggered with a click or touch event.
|
|
* @option
|
|
* @example true
|
|
*/
|
|
clickOpen: true,
|
|
/**
|
|
* Additional positioning classes, set by the JS
|
|
* @option
|
|
* @example 'top'
|
|
*/
|
|
positionClass: '',
|
|
/**
|
|
* Distance, in pixels, the template should push away from the anchor on the Y axis.
|
|
* @option
|
|
* @example 10
|
|
*/
|
|
vOffset: 10,
|
|
/**
|
|
* Distance, in pixels, the template should push away from the anchor on the X axis, if aligned to a side.
|
|
* @option
|
|
* @example 12
|
|
*/
|
|
hOffset: 12
|
|
};
|
|
|
|
/**
|
|
* TODO utilize resize event trigger
|
|
*/
|
|
|
|
// Window exports
|
|
Foundation.plugin(Tooltip, 'Tooltip');
|
|
}(jQuery);
|
|
//# sourceMappingURL=vendor.js.map
|