You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10629 lines
1004 KiB
10629 lines
1004 KiB
/** |
|
* what-input - A global utility for tracking the current input method (mouse, keyboard or touch). |
|
* @version v4.0.6 |
|
* @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) { |
|
|
|
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 = { |
|
'keyup': '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 timer is running |
|
var isBuffering = false; |
|
|
|
// map of IE 10 pointer events |
|
var pointerMap = { |
|
2: 'touch', |
|
3: 'touch', // treat pen like touch |
|
4: 'mouse' |
|
}; |
|
|
|
// touch buffer timer |
|
var touchTimer = null; |
|
|
|
|
|
/* |
|
--------------- |
|
Set up |
|
--------------- |
|
*/ |
|
|
|
var setUp = function() { |
|
|
|
// add correct mouse wheel event mapping to `inputMap` |
|
inputMap[detectWheel()] = 'mouse'; |
|
|
|
addListeners(); |
|
setInput(); |
|
}; |
|
|
|
|
|
/* |
|
--------------- |
|
Events |
|
--------------- |
|
*/ |
|
|
|
var addListeners = function() { |
|
|
|
// `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); |
|
} |
|
} |
|
|
|
// mouse wheel |
|
docElem.addEventListener(detectWheel(), setIntent); |
|
|
|
// keyboard events |
|
docElem.addEventListener('keydown', updateInput); |
|
docElem.addEventListener('keyup', updateInput); |
|
}; |
|
|
|
// checks conditions before updating new input |
|
var updateInput = function(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 = ( |
|
activeElem && |
|
activeElem.nodeName && |
|
formInputs.indexOf(activeElem.nodeName.toLowerCase()) === -1 |
|
) ? true : false; |
|
|
|
if ( |
|
value === 'touch' || |
|
|
|
// ignore mouse modifier keys |
|
(value === 'mouse' && ignoreMap.indexOf(eventKey) === -1) || |
|
|
|
// don't switch if the current element is a form input |
|
(value === 'keyboard' && activeInput) |
|
) { |
|
|
|
// set the current and catch-all variable |
|
currentInput = currentIntent = value; |
|
|
|
setInput(); |
|
} |
|
} |
|
} |
|
}; |
|
|
|
// updates the doc and `inputTypes` array with new input |
|
var setInput = function() { |
|
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(event) { |
|
|
|
// only execute if the touch buffer timer isn't running |
|
if (!isBuffering) { |
|
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(event) { |
|
|
|
// clear the timer if it happens to be running |
|
window.clearTimeout(touchTimer); |
|
|
|
// set the current input |
|
updateInput(event); |
|
|
|
// set the isBuffering to `true` |
|
isBuffering = true; |
|
|
|
// run the timer |
|
touchTimer = window.setTimeout(function() { |
|
|
|
// if the timer runs out, set isBuffering back to `false` |
|
isBuffering = false; |
|
}, 200); |
|
}; |
|
|
|
|
|
/* |
|
--------------- |
|
Utilities |
|
--------------- |
|
*/ |
|
|
|
var pointerType = function(event) { |
|
if (typeof event.pointerType === 'number') { |
|
return pointerMap[event.pointerType]; |
|
} else { |
|
return (event.pointerType === 'pen') ? 'touch' : event.pointerType; // treat pen like touch |
|
} |
|
}; |
|
|
|
// detect version of mouse wheel event to use |
|
// via https://developer.mozilla.org/en-US/docs/Web/Events/wheel |
|
var detectWheel = function() { |
|
return 'onwheel' in document.createElement('div') ? |
|
'wheel' : // Modern browsers support "wheel" |
|
|
|
document.onmousewheel !== undefined ? |
|
'mousewheel' : // Webkit and IE support at least "mousewheel" |
|
'DOMMouseScroll'; // let's assume that remaining browsers are older Firefox |
|
}; |
|
|
|
|
|
/* |
|
--------------- |
|
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(opt) { return (opt === 'loose') ? currentIntent : currentInput; }, |
|
|
|
// returns array: all the detected input types |
|
types: function() { return inputTypes; } |
|
|
|
}; |
|
|
|
}()); |
|
|
|
|
|
/***/ } |
|
/******/ ]) |
|
}); |
|
; |
|
'use strict'; |
|
|
|
!function ($) { |
|
|
|
"use strict"; |
|
|
|
var FOUNDATION_VERSION = '6.3.1'; |
|
|
|
// 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' === str) return true;else if ('false' === 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 + vOffset |
|
}; |
|
break; |
|
case 'right bottom': |
|
return { |
|
left: $anchorDims.offset.left + $anchorDims.width + hOffset - $eleDims.width, |
|
top: $anchorDims.offset.top + $anchorDims.height + vOffset |
|
}; |
|
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(); |
|
|
|
// Remove un-printable characters, e.g. for `fromCharCode` calls for CTRL only events |
|
key = key.replace(/\W+/, ''); |
|
|
|
if (event.shiftKey) key = 'SHIFT_' + key; |
|
if (event.ctrlKey) key = 'CTRL_' + key; |
|
if (event.altKey) key = 'ALT_' + key; |
|
|
|
// Remove trailing underscore, in case only modifiers were used (e.g. only `CTRL_ALT`) |
|
key = key.replace(/_$/, ''); |
|
|
|
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) { |
|
if (!$element) { |
|
return false; |
|
} |
|
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; |
|
}, |
|
|
|
|
|
/** |
|
* Traps the focus in the given element. |
|
* @param {jQuery} $element jQuery object to trap the foucs into. |
|
*/ |
|
trapFocus: function ($element) { |
|
var $focusable = Foundation.Keyboard.findFocusable($element), |
|
$firstFocusable = $focusable.eq(0), |
|
$lastFocusable = $focusable.eq(-1); |
|
|
|
$element.on('keydown.zf.trapfocus', function (event) { |
|
if (event.target === $lastFocusable[0] && Foundation.Keyboard.parseKey(event) === 'TAB') { |
|
event.preventDefault(); |
|
$firstFocusable.focus(); |
|
} else if (event.target === $firstFocusable[0] && Foundation.Keyboard.parseKey(event) === 'SHIFT_TAB') { |
|
event.preventDefault(); |
|
$lastFocusable.focus(); |
|
} |
|
}); |
|
}, |
|
|
|
/** |
|
* Releases the trapped focus from the given element. |
|
* @param {jQuery} $element jQuery object to release the focus for. |
|
*/ |
|
releaseFocus: function ($element) { |
|
$element.off('keydown.zf.trapfocus'); |
|
} |
|
}; |
|
|
|
/* |
|
* 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; |
|
}, |
|
|
|
|
|
/** |
|
* Checks if the screen matches to a breakpoint. |
|
* @function |
|
* @param {String} size - Name of the breakpoint to check, either 'small only' or 'small'. Omitting 'only' falls back to using atLeast() method. |
|
* @returns {Boolean} `true` if the breakpoint matches, `false` if it does not. |
|
*/ |
|
is: function (size) { |
|
size = size.trim().split(' '); |
|
if (size.length > 1 && size[1] === 'only') { |
|
if (size[0] === this._getCurrentSize()) return true; |
|
} else { |
|
return this.atLeast(size[0]); |
|
} |
|
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'); |
|
|
|
if (duration === 0) { |
|
fn.apply(elem); |
|
elem.trigger('finished.zf.animate', [elem]).triggerHandler('finished.zf.animate', [elem]); |
|
return; |
|
} |
|
|
|
function move(ts) { |
|
if (!start) start = ts; |
|
// 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'; |
|
|
|
items.each(function () { |
|
var $item = $(this), |
|
$sub = $item.children('ul'); |
|
|
|
if ($sub.length) { |
|
$item.addClass(hasSubClass).attr({ |
|
'aria-haspopup': true, |
|
'aria-label': $item.children('a:first').text() |
|
}); |
|
// Note: Drilldowns behave differently in how they hide, and so need |
|
// additional attributes. We should look if this possibly over-generalized |
|
// utility (Nest) is appropriate when we rework menus in 6.4 |
|
if (type === 'drilldown') { |
|
$item.attr({ 'aria-expanded': false }); |
|
} |
|
|
|
$sub.addClass('submenu ' + subMenuClass).attr({ |
|
'data-submenu': '', |
|
'role': 'menu' |
|
}); |
|
if (type === 'drilldown') { |
|
$sub.attr({ 'aria-hidden': true }); |
|
} |
|
} |
|
|
|
if ($item.parent('[data-submenu]').length) { |
|
$item.addClass('is-submenu-item ' + subItemClass); |
|
} |
|
}); |
|
|
|
return; |
|
}, |
|
Burn: function (menu, type) { |
|
var //items = menu.find('li'), |
|
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 () { |
|
// Check if image is loaded |
|
if (this.complete || this.readyState === 4 || this.readyState === 'complete') { |
|
singleImageLoaded(); |
|
} |
|
// Force load the image |
|
else { |
|
// fix for IE. See https://css-tricks.com/snippets/jquery/fixing-load-in-ie-for-cached-images/ |
|
var src = $(this).attr('src'); |
|
$(this).attr('src', src + (src.indexOf('?') >= 0 ? '&' : '?') + new Date().getTime()); |
|
$(this).one('load', function () { |
|
singleImageLoaded(); |
|
}); |
|
} |
|
}); |
|
|
|
function singleImageLoaded() { |
|
unloaded--; |
|
if (unloaded === 0) { |
|
callback(); |
|
} |
|
} |
|
} |
|
|
|
Foundation.Timer = Timer; |
|
Foundation.onImagesLoaded = onImagesLoaded; |
|
}(jQuery); |
|
'use strict'; |
|
|
|
//************************************************** |
|
//**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 () { |
|
var id = $(this).data('toggle'); |
|
if (id) { |
|
triggers($(this), 'toggle'); |
|
} else { |
|
$(this).trigger('toggle.zf.trigger'); |
|
} |
|
}); |
|
|
|
// 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 (mutationRecordsList[0].type) { |
|
|
|
case "attributes": |
|
if ($target.attr("data-events") === "scroll" && mutationRecordsList[0].attributeName === "data-events") { |
|
$target.triggerHandler('scrollme.zf.trigger', [$target, window.pageYOffset]); |
|
} |
|
if ($target.attr("data-events") === "resize" && mutationRecordsList[0].attributeName === "data-events") { |
|
$target.triggerHandler('resizeme.zf.trigger', [$target]); |
|
} |
|
if (mutationRecordsList[0].attributeName === "style") { |
|
$target.closest("[data-mutate]").attr("data-events", "mutate"); |
|
$target.closest("[data-mutate]").triggerHandler('mutateme.zf.trigger', [$target.closest("[data-mutate]")]); |
|
} |
|
break; |
|
|
|
case "childList": |
|
$target.closest("[data-mutate]").attr("data-events", "mutate"); |
|
$target.closest("[data-mutate]").triggerHandler('mutateme.zf.trigger', [$target.closest("[data-mutate]")]); |
|
break; |
|
|
|
default: |
|
return false; |
|
//nothing |
|
} |
|
}; |
|
|
|
if (nodes.length) { |
|
//for each element that needs to listen for resizing, scrolling, or 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: true, characterData: false, subtree: true, attributeFilter: ["data-events", "style"] }); |
|
} |
|
} |
|
} |
|
|
|
// ------------------------------------ |
|
|
|
// [PH] |
|
// Foundation.CheckWatchers = checkWatchers; |
|
Foundation.IHearYou = checkListeners; |
|
// Foundation.ISeeYou = scrollListener; |
|
// Foundation.IFeelYou = closemeListener; |
|
}(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 ($) { |
|
|
|
/** |
|
* 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)); |
|
}); |
|
} |
|
|
|
if (this.options.validateOnBlur) { |
|
this.$inputs.off('blur.zf.abide').on('blur.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; |
|
} |
|
|
|
/** |
|
* Get: |
|
* - Based on $el, the first element(s) corresponding to `formErrorSelector` in this order: |
|
* 1. The element's direct sibling('s). |
|
* 2. The element's parent's children. |
|
* - Element(s) with the attribute `[data-form-error-for]` set with the element's id. |
|
* |
|
* 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 id = $el[0].id; |
|
var $error = $el.siblings(this.options.formErrorSelector); |
|
|
|
if (!$error.length) { |
|
$error = $el.parent().find(this.options.formErrorSelector); |
|
} |
|
|
|
$error = $error.add(this.$element.find('[data-form-error-for="' + id + '"]')); |
|
|
|
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. |
|
* Ignores inputs with data-abide-ignore, type="hidden" or disabled attributes set |
|
* @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 or disabled inputs |
|
if ($el.is('[data-abide-ignore]') || $el.is('[type="hidden"]') || $el.is('[disabled]')) { |
|
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'; |
|
|
|
if (goodToGo) { |
|
// Re-validate inputs that depend on this one with equalto |
|
var dependentElements = this.$element.find('[data-equalto="' + $el.attr('id') + '"]'); |
|
if (dependentElements.length) { |
|
var _this = this; |
|
dependentElements.each(function () { |
|
if ($(this).val()) { |
|
_this.validateInput($(this)); |
|
} |
|
}); |
|
} |
|
} |
|
|
|
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 |
|
* @type {?string} |
|
* @default 'fieldChange' |
|
*/ |
|
validateOn: 'fieldChange', |
|
|
|
/** |
|
* Class to be applied to input labels on failed validation. |
|
* @option |
|
* @type {string} |
|
* @default 'is-invalid-label' |
|
*/ |
|
labelErrorClass: 'is-invalid-label', |
|
|
|
/** |
|
* Class to be applied to inputs on failed validation. |
|
* @option |
|
* @type {string} |
|
* @default 'is-invalid-input' |
|
*/ |
|
inputErrorClass: 'is-invalid-input', |
|
|
|
/** |
|
* Class selector to use to target Form Errors for show/hide. |
|
* @option |
|
* @type {string} |
|
* @default '.form-error' |
|
*/ |
|
formErrorSelector: '.form-error', |
|
|
|
/** |
|
* Class added to Form Errors on failed validation. |
|
* @option |
|
* @type {string} |
|
* @default 'is-visible' |
|
*/ |
|
formErrorClass: 'is-visible', |
|
|
|
/** |
|
* Set to true to validate text inputs on any value change. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
liveValidate: false, |
|
|
|
/** |
|
* Set to true to validate inputs on blur. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
validateOnBlur: 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() { |
|
var _this2 = this; |
|
|
|
this.$element.attr('role', 'tablist'); |
|
this.$tabs = this.$element.children('[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]'); |
|
this.firstTimeInit = true; |
|
if ($initActive.length) { |
|
this.down($initActive, this.firstTimeInit); |
|
this.firstTimeInit = false; |
|
} |
|
|
|
this._checkDeepLink = function () { |
|
var anchor = window.location.hash; |
|
//need a hash and a relevant anchor in this tabset |
|
if (anchor.length) { |
|
var $link = _this2.$element.find('[href$="' + anchor + '"]'), |
|
$anchor = $(anchor); |
|
|
|
if ($link.length && $anchor) { |
|
if (!$link.parent('[data-accordion-item]').hasClass('is-active')) { |
|
_this2.down($anchor, _this2.firstTimeInit); |
|
_this2.firstTimeInit = false; |
|
}; |
|
|
|
//roll up a little to show the titles |
|
if (_this2.options.deepLinkSmudge) { |
|
var _this = _this2; |
|
$(window).load(function () { |
|
var offset = _this.$element.offset(); |
|
$('html, body').animate({ scrollTop: offset.top }, _this.options.deepLinkSmudgeDelay); |
|
}); |
|
} |
|
|
|
/** |
|
* Fires when the zplugin has deeplinked at pageload |
|
* @event Accordion#deeplink |
|
*/ |
|
_this2.$element.trigger('deeplink.zf.accordion', [$link, $anchor]); |
|
} |
|
} |
|
}; |
|
|
|
//use browser to open a tab, if it exists in this tabset |
|
if (this.options.deepLink) { |
|
this._checkDeepLink(); |
|
} |
|
|
|
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(); |
|
} |
|
}); |
|
}); |
|
} |
|
}); |
|
if (this.options.deepLink) { |
|
$(window).on('popstate', this._checkDeepLink); |
|
} |
|
} |
|
|
|
/** |
|
* 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); |
|
} |
|
//either replace or update browser history |
|
if (this.options.deepLink) { |
|
var anchor = $target.prev('a').attr('href'); |
|
|
|
if (this.options.updateHistory) { |
|
history.pushState({}, '', anchor); |
|
} else { |
|
history.replaceState({}, '', anchor); |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* 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 _this3 = 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 |
|
*/ |
|
_this3.$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'); |
|
if (this.options.deepLink) { |
|
$(window).off('popstate', this._checkDeepLink); |
|
} |
|
|
|
Foundation.unregisterPlugin(this); |
|
} |
|
}]); |
|
|
|
return Accordion; |
|
}(); |
|
|
|
Accordion.defaults = { |
|
/** |
|
* Amount of time to animate the opening of an accordion pane. |
|
* @option |
|
* @type {number} |
|
* @default 250 |
|
*/ |
|
slideSpeed: 250, |
|
/** |
|
* Allow the accordion to have multiple open panes. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
multiExpand: false, |
|
/** |
|
* Allow the accordion to close all panes. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
allowAllClosed: false, |
|
/** |
|
* Allows the window to scroll to content of pane specified by hash anchor |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
deepLink: false, |
|
|
|
/** |
|
* Adjust the deep link scroll to make sure the top of the accordion panel is visible |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
deepLinkSmudge: false, |
|
|
|
/** |
|
* Animation time (ms) for the deep link adjustment |
|
* @option |
|
* @type {number} |
|
* @default 300 |
|
*/ |
|
deepLinkSmudgeDelay: 300, |
|
|
|
/** |
|
* Update the browser history with the open accordion |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
updateHistory: 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.up(this.$element.find('[data-submenu]')); |
|
} |
|
|
|
/** |
|
* Opens all panes of the menu. |
|
* @function |
|
*/ |
|
|
|
}, { |
|
key: 'showAll', |
|
value: function showAll() { |
|
this.down(this.$element.find('[data-submenu]')); |
|
} |
|
|
|
/** |
|
* 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 |
|
* @type {number} |
|
* @default 250 |
|
*/ |
|
slideSpeed: 250, |
|
/** |
|
* Allow the menu to have multiple open panes. |
|
* @option |
|
* @type {boolean} |
|
* @default 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.$element.attr('data-mutate', this.$element.attr('data-drilldown') || Foundation.GetYoDigits(6, 'drilldown')); |
|
|
|
this._prepareMenu(); |
|
this._registerEvents(); |
|
|
|
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) { |
|
switch (_this.options.backButtonPosition) { |
|
case "bottom": |
|
$menu.append(_this.options.backButton); |
|
break; |
|
case "top": |
|
$menu.prepend(_this.options.backButton); |
|
break; |
|
default: |
|
console.error("Unsupported backButtonPosition value '" + _this.options.backButtonPosition + "'"); |
|
} |
|
} |
|
_this._back($menu); |
|
}); |
|
|
|
this.$submenus.addClass('invisible'); |
|
if (!this.options.autoHeight) { |
|
this.$submenus.addClass('drilldown-submenu-cover-previous'); |
|
} |
|
|
|
// create a wrapper on element if it doesn't exist. |
|
if (!this.$element.parent().hasClass('is-drilldown')) { |
|
this.$wrapper = $(this.options.wrapper).addClass('is-drilldown'); |
|
if (this.options.animateHeight) this.$wrapper.addClass('animate-height'); |
|
this.$element.wrap(this.$wrapper); |
|
} |
|
// set wrapper |
|
this.$wrapper = this.$element.parent(); |
|
this.$wrapper.css(this._getMaxDims()); |
|
} |
|
}, { |
|
key: '_resize', |
|
value: function _resize() { |
|
this.$wrapper.css({ 'max-width': 'none', 'min-height': 'none' }); |
|
// _getMaxDims has side effects (boo) but calling it should update all other necessary heights & widths |
|
this.$wrapper.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'); |
|
}); |
|
} |
|
}); |
|
this.$element.on('mutateme.zf.trigger', this._resize.bind(this)); |
|
} |
|
|
|
/** |
|
* Adds event handlers to the menu element. |
|
* @function |
|
* @private |
|
*/ |
|
|
|
}, { |
|
key: '_registerEvents', |
|
value: function _registerEvents() { |
|
if (this.options.scrollTop) { |
|
this._bindHandler = this._scrollTop.bind(this); |
|
this.$element.on('open.zf.drilldown hide.zf.drilldown closed.zf.drilldown', this._bindHandler); |
|
} |
|
} |
|
|
|
/** |
|
* Scroll to Top of Element or data-scroll-top-element |
|
* @function |
|
* @fires Drilldown#scrollme |
|
*/ |
|
|
|
}, { |
|
key: '_scrollTop', |
|
value: function _scrollTop() { |
|
var _this = this; |
|
var $scrollTopElement = _this.options.scrollTopElement != '' ? $(_this.options.scrollTopElement) : _this.$element, |
|
scrollPos = parseInt($scrollTopElement.offset().top + _this.options.scrollTopOffset); |
|
$('html, body').stop(true).animate({ scrollTop: scrollPos }, _this.options.animationDuration, _this.options.animationEasing, function () { |
|
/** |
|
* Fires after the menu has scrolled |
|
* @event Drilldown#scrollme |
|
*/ |
|
if (this === $('html')[0]) _this.$element.trigger('scrollme.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, .is-submenu-parent-item > 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(); |
|
// Don't tap focus on first element in root ul |
|
return !$element.is(_this.$element.find('> li:first-child > a')); |
|
}, |
|
down: function () { |
|
$nextElement.focus(); |
|
// Don't tap focus on last element in root ul |
|
return !$element.is(_this.$element.find('> li:last-child > a')); |
|
}, |
|
close: function () { |
|
// Don't close on element in root ul |
|
if (!$element.is(_this.$element.find('> li > a'))) { |
|
_this._hide($element.parent().parent()); |
|
$element.parent().parent().siblings('a').focus(); |
|
} |
|
}, |
|
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'); |
|
if (this.options.autoHeight) this.$wrapper.css({ height: $elem.parent().closest('ul').data('calcHeight') }); |
|
$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) { |
|
if (this.options.autoHeight) this.$wrapper.css({ height: $elem.children('[data-submenu]').data('calcHeight') }); |
|
$elem.attr('aria-expanded', true); |
|
$elem.children('[data-submenu]').addClass('is-active').removeClass('invisible').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) { |
|
if (this.options.autoHeight) this.$wrapper.css({ height: $elem.parent().closest('ul').data('calcHeight') }); |
|
var _this = this; |
|
$elem.parent('li').attr('aria-expanded', false); |
|
$elem.attr('aria-hidden', true).addClass('is-closing'); |
|
$elem.addClass('is-closing').one(Foundation.transitionend($elem), function () { |
|
$elem.removeClass('is-active is-closing'); |
|
$elem.blur().addClass('invisible'); |
|
}); |
|
/** |
|
* 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 maxHeight = 0, |
|
result = {}, |
|
_this = this; |
|
this.$submenus.add(this.$element).each(function () { |
|
var numOfElems = $(this).children('li').length; |
|
var height = Foundation.Box.GetDimensions(this).height; |
|
maxHeight = height > maxHeight ? height : maxHeight; |
|
if (_this.options.autoHeight) { |
|
$(this).data('calcHeight', height); |
|
if (!$(this).hasClass('is-drilldown-submenu')) result['height'] = height; |
|
} |
|
}); |
|
|
|
if (!this.options.autoHeight) result['min-height'] = maxHeight + 'px'; |
|
|
|
result['max-width'] = this.$element[0].getBoundingClientRect().width + 'px'; |
|
|
|
return result; |
|
} |
|
|
|
/** |
|
* Destroys the Drilldown Menu |
|
* @function |
|
*/ |
|
|
|
}, { |
|
key: 'destroy', |
|
value: function destroy() { |
|
if (this.options.scrollTop) this.$element.off('.zf.drilldown', this._bindHandler); |
|
this._hideAll(); |
|
this.$element.off('mutateme.zf.trigger'); |
|
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.$submenus.removeClass('drilldown-submenu-cover-previous'); |
|
|
|
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 or appended (see backButtonPosition) to submenu lists and deleted on `destroy` method, 'js-drilldown-back' class required. Remove the backslash (`\`) if copy and pasting. |
|
* @option |
|
* @type {string} |
|
* @default '<li class="js-drilldown-back"><a tabindex="0">Back</a></li>' |
|
*/ |
|
backButton: '<li class="js-drilldown-back"><a tabindex="0">Back</a></li>', |
|
/** |
|
* Position the back button either at the top or bottom of drilldown submenus. Can be `'left'` or `'bottom'`. |
|
* @option |
|
* @type {string} |
|
* @default top |
|
*/ |
|
backButtonPosition: 'top', |
|
/** |
|
* 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 |
|
* @type {string} |
|
* @default '<div></div>' |
|
*/ |
|
wrapper: '<div></div>', |
|
/** |
|
* Adds the parent link to the submenu. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
parentLink: false, |
|
/** |
|
* Allow the menu to return to root list on body click. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
closeOnClick: false, |
|
/** |
|
* Allow the menu to auto adjust height. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
autoHeight: false, |
|
/** |
|
* Animate the auto adjust height. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
animateHeight: false, |
|
/** |
|
* Scroll to the top of the menu after opening a submenu or navigating back using the menu back button |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
scrollTop: false, |
|
/** |
|
* String jquery selector (for example 'body') of element to take offset().top from, if empty string the drilldown menu offset().top is taken |
|
* @option |
|
* @type {string} |
|
* @default '' |
|
*/ |
|
scrollTopElement: '', |
|
/** |
|
* ScrollTop offset |
|
* @option |
|
* @type {number} |
|
* @default 0 |
|
*/ |
|
scrollTopOffset: 0, |
|
/** |
|
* Scroll animation duration |
|
* @option |
|
* @type {number} |
|
* @default 500 |
|
*/ |
|
animationDuration: 500, |
|
/** |
|
* Scroll animation easing. Can be `'swing'` or `'linear'`. |
|
* @option |
|
* @type {string} |
|
* @see {@link https://api.jquery.com/animate|JQuery animate} |
|
* @default 'swing' |
|
*/ |
|
animationEasing: 'swing' |
|
// 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' |
|
}); |
|
} |
|
|
|
/** |
|
* 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 |
|
|
|
}); |
|
|
|
if (this.options.parentClass) { |
|
this.$parent = this.$element.parents('.' + this.options.parentClass); |
|
} else { |
|
this.$parent = null; |
|
} |
|
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.$parent)) { |
|
var newWidth = $eleDims.windowDims.width, |
|
parentHOffset = 0; |
|
if (this.$parent) { |
|
var $parentDims = Foundation.Box.GetDimensions(this.$parent), |
|
parentHOffset = $parentDims.offset.left; |
|
if ($parentDims.width < newWidth) { |
|
newWidth = $parentDims.width; |
|
} |
|
} |
|
|
|
this.$element.offset(Foundation.Box.GetOffsets(this.$element, this.$anchor, 'center bottom', this.options.vOffset, this.options.hOffset + parentHOffset, true)).css({ |
|
'width': newWidth - 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, this.$parent, 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 () { |
|
var bodyData = $('body').data(); |
|
if (typeof bodyData.whatinput === 'undefined' || bodyData.whatinput === 'mouse') { |
|
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', { |
|
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, typically when dropdown is opening |
|
* @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(); |
|
} |
|
|
|
if (this.options.trapFocus) { |
|
Foundation.Keyboard.trapFocus(this.$element); |
|
} |
|
|
|
/** |
|
* 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; |
|
} |
|
/** |
|
* Fires once the dropdown is no longer visible. |
|
* @event Dropdown#hide |
|
*/ |
|
this.$element.trigger('hide.zf.dropdown', [this.$element]); |
|
|
|
if (this.options.trapFocus) { |
|
Foundation.Keyboard.releaseFocus(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 = { |
|
/** |
|
* Class that designates bounding container of Dropdown (default: window) |
|
* @option |
|
* @type {?string} |
|
* @default null |
|
*/ |
|
parentClass: null, |
|
/** |
|
* Amount of time to delay opening a submenu on hover event. |
|
* @option |
|
* @type {number} |
|
* @default 250 |
|
*/ |
|
hoverDelay: 250, |
|
/** |
|
* Allow submenus to open on hover events |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
hover: false, |
|
/** |
|
* Don't close dropdown when hovering over dropdown pane |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
hoverPane: false, |
|
/** |
|
* Number of pixels between the dropdown pane and the triggering element on open. |
|
* @option |
|
* @type {number} |
|
* @default 1 |
|
*/ |
|
vOffset: 1, |
|
/** |
|
* Number of pixels between the dropdown pane and the triggering element on open. |
|
* @option |
|
* @type {number} |
|
* @default 1 |
|
*/ |
|
hOffset: 1, |
|
/** |
|
* Class applied to adjust open position. JS will test and fill this in. |
|
* @option |
|
* @type {string} |
|
* @default '' |
|
*/ |
|
positionClass: '', |
|
/** |
|
* Allow the plugin to trap focus to the dropdown pane if opened with keyboard commands. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
trapFocus: false, |
|
/** |
|
* Allow the plugin to set focus to the first focusable element within the pane, regardless of method of opening. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
autoFocus: false, |
|
/** |
|
* Allows a click on the body to close the dropdown. |
|
* @option |
|
* @type {boolean} |
|
* @default 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); |
|
} |
|
} |
|
}; |
|
|
|
if (this.options.clickOpen || hasTouch) { |
|
this.$menuItems.on('click.zf.dropdownmenu touchstart.zf.dropdownmenu', handleClickFn); |
|
} |
|
|
|
// Handle Leaf element Clicks |
|
if (_this.options.closeOnClickInside) { |
|
this.$menuItems.on('click.zf.dropdownmenu', function (e) { |
|
var $elem = $(this), |
|
hasSub = $elem.hasClass(parClass); |
|
if (!hasSub) { |
|
_this._hide(); |
|
} |
|
}); |
|
} |
|
|
|
if (!this.options.disableHover) { |
|
this.$menuItems.on('mouseenter.zf.dropdownmenu', function (e) { |
|
var $elem = $(this), |
|
hasSub = $elem.hasClass(parClass); |
|
|
|
if (hasSub) { |
|
clearTimeout($elem.data('_delay')); |
|
$elem.data('_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($elem.data('_delay')); |
|
$elem.data('_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').parent('li.is-dropdown-submenu-parent').addClass('is-active'); |
|
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({ |
|
'data-is-click': false |
|
}).removeClass('is-active'); |
|
|
|
$toClose.find('ul.js-dropdown-active').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 |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
disableHover: false, |
|
/** |
|
* Allow a submenu to automatically close on a mouseleave event, if not clicked open. |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
autoclose: true, |
|
/** |
|
* Amount of time to delay opening a submenu on hover event. |
|
* @option |
|
* @type {number} |
|
* @default 50 |
|
*/ |
|
hoverDelay: 50, |
|
/** |
|
* Allow a submenu to open/remain open on parent click event. Allows cursor to move away from menu. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
clickOpen: false, |
|
/** |
|
* Amount of time to delay closing a submenu on a mouseleave event. |
|
* @option |
|
* @type {number} |
|
* @default 500 |
|
*/ |
|
|
|
closingTime: 500, |
|
/** |
|
* Position of the menu relative to what direction the submenus should open. Handled by JS. Can be `'left'` or `'right'`. |
|
* @option |
|
* @type {string} |
|
* @default 'left' |
|
*/ |
|
alignment: 'left', |
|
/** |
|
* Allow clicks on the body to close any open submenus. |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
closeOnClick: true, |
|
/** |
|
* Allow clicks on leaf anchor links to close any open submenus. |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
closeOnClickInside: true, |
|
/** |
|
* Class applied to vertical oriented menus, Foundation default is `vertical`. Update this if using your own class. |
|
* @option |
|
* @type {string} |
|
* @default 'vertical' |
|
*/ |
|
verticalClass: 'vertical', |
|
/** |
|
* Class applied to right-side oriented menus, Foundation default is `align-right`. Update this if using your own class. |
|
* @option |
|
* @type {string} |
|
* @default 'align-right' |
|
*/ |
|
rightClass: 'align-right', |
|
/** |
|
* Boolean to force overide the clicking of links to perform default action, on second touch event for mobile. |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
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.$element.attr('data-mutate', 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, |
|
'mutateme.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.$element.on('mutateme.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.is(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() { |
|
if (!this.$watched[0] || !this.$watched[1]) { |
|
return true; |
|
} |
|
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 |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
equalizeOnStack: false, |
|
/** |
|
* Enable height equalization row by row. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
equalizeByRow: false, |
|
/** |
|
* String representing the minimum breakpoint size the plugin should equalize heights on. |
|
* @option |
|
* @type {string} |
|
* @default '' |
|
*/ |
|
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() { |
|
var _this2 = this; |
|
|
|
$(window).on('resize.zf.interchange', Foundation.util.throttle(function () { |
|
_this2._reflow(); |
|
}, 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'); |
|
} |
|
|
|
rules = typeof rules === 'string' ? rules.match(/\[.*?\]/g) : rules; |
|
|
|
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 |
|
* @type {?array} |
|
* @default null |
|
*/ |
|
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(); |
|
this.calcPoints(); |
|
|
|
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); |
|
}); |
|
$(window).on('popstate', function (e) { |
|
if (_this.options.deepLinking) { |
|
_this.scrollToLoc(window.location.hash); |
|
} |
|
}); |
|
} |
|
|
|
/** |
|
* 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; |
|
} |
|
this._inTransition = true; |
|
var _this = this, |
|
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, function () { |
|
_this._inTransition = false;_this._updateActive(); |
|
}); |
|
} |
|
|
|
/** |
|
* 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*/{ |
|
if (this._inTransition) { |
|
return; |
|
} |
|
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 = undefined; |
|
} 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 = ""; |
|
if (curIdx != undefined) { |
|
hash = this.$active[0].getAttribute('href'); |
|
} |
|
if (hash !== window.location.hash) { |
|
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 |
|
* @type {number} |
|
* @default 500 |
|
*/ |
|
animationDuration: 500, |
|
/** |
|
* Animation style to use when scrolling between locations. Can be `'swing'` or `'linear'`. |
|
* @option |
|
* @type {string} |
|
* @default 'linear' |
|
* @see {@link https://api.jquery.com/animate|Jquery animate} |
|
*/ |
|
animationEasing: 'linear', |
|
/** |
|
* Number of pixels to use as a marker for location changes. |
|
* @option |
|
* @type {number} |
|
* @default 50 |
|
*/ |
|
threshold: 50, |
|
/** |
|
* Class applied to the active locations link on the magellan container. |
|
* @option |
|
* @type {string} |
|
* @default 'active' |
|
*/ |
|
activeClass: 'active', |
|
/** |
|
* Allows the script to manipulate the url of the current page, and if supported, alter the history. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
deepLinking: false, |
|
/** |
|
* Number of pixels to offset the scroll of the page on item click if using a sticky nav bar. |
|
* @option |
|
* @type {number} |
|
* @default 0 |
|
*/ |
|
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.keyboard |
|
* @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'); |
|
|
|
this.$element.addClass('is-transition-' + this.options.transition); |
|
|
|
// 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 an overlay over the content if necessary |
|
if (this.options.contentOverlay === true) { |
|
var overlay = document.createElement('div'); |
|
var overlayPosition = $(this.$element).css("position") === 'fixed' ? 'is-overlay-fixed' : 'is-overlay-absolute'; |
|
overlay.setAttribute('class', 'js-off-canvas-overlay ' + overlayPosition); |
|
this.$overlay = $(overlay); |
|
if (overlayPosition === 'is-overlay-fixed') { |
|
$('body').append(this.$overlay); |
|
} else { |
|
this.$element.siblings('[data-off-canvas-content]').append(this.$overlay); |
|
} |
|
} |
|
|
|
this.options.isRevealed = this.options.isRevealed || new RegExp(this.options.revealClass, 'g').test(this.$element[0].className); |
|
|
|
if (this.options.isRevealed === true) { |
|
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 === true) { |
|
this.options.transitionTime = parseFloat(window.getComputedStyle($('[data-off-canvas]')[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 === true) { |
|
var $target = this.options.contentOverlay ? this.$overlay : $('[data-off-canvas-content]'); |
|
$target.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; |
|
this.$element.attr('aria-hidden', 'false'); |
|
this.$element.off('open.zf.trigger toggle.zf.trigger'); |
|
if ($closer.length) { |
|
$closer.hide(); |
|
} |
|
} else { |
|
this.isRevealed = false; |
|
this.$element.attr('aria-hidden', 'true'); |
|
this.$element.off('open.zf.trigger toggle.zf.trigger').on({ |
|
'open.zf.trigger': this.open.bind(this), |
|
'toggle.zf.trigger': this.toggle.bind(this) |
|
}); |
|
if ($closer.length) { |
|
$closer.show(); |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* Stops scrolling of the body when offcanvas is open on mobile Safari and other troublesome browsers. |
|
* @private |
|
*/ |
|
|
|
}, { |
|
key: '_stopScrolling', |
|
value: function _stopScrolling(event) { |
|
return false; |
|
} |
|
|
|
// Taken and adapted from http://stackoverflow.com/questions/16889447/prevent-full-page-scrolling-ios |
|
// Only really works for y, not sure how to extend to x or if we need to. |
|
|
|
}, { |
|
key: '_recordScrollable', |
|
value: function _recordScrollable(event) { |
|
var elem = this; // called from event handler context with this as elem |
|
|
|
// If the element is scrollable (content overflows), then... |
|
if (elem.scrollHeight !== elem.clientHeight) { |
|
// If we're at the top, scroll down one pixel to allow scrolling up |
|
if (elem.scrollTop === 0) { |
|
elem.scrollTop = 1; |
|
} |
|
// If we're at the bottom, scroll up one pixel to allow scrolling down |
|
if (elem.scrollTop === elem.scrollHeight - elem.clientHeight) { |
|
elem.scrollTop = elem.scrollHeight - elem.clientHeight - 1; |
|
} |
|
} |
|
elem.allowUp = elem.scrollTop > 0; |
|
elem.allowDown = elem.scrollTop < elem.scrollHeight - elem.clientHeight; |
|
elem.lastY = event.originalEvent.pageY; |
|
} |
|
}, { |
|
key: '_stopScrollPropagation', |
|
value: function _stopScrollPropagation(event) { |
|
var elem = this; // called from event handler context with this as elem |
|
var up = event.pageY < elem.lastY; |
|
var down = !up; |
|
elem.lastY = event.pageY; |
|
|
|
if (up && elem.allowUp || down && elem.allowDown) { |
|
event.stopPropagation(); |
|
} else { |
|
event.preventDefault(); |
|
} |
|
} |
|
|
|
/** |
|
* 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; |
|
|
|
if (trigger) { |
|
this.$lastTrigger = trigger; |
|
} |
|
|
|
if (this.options.forceTo === 'top') { |
|
window.scrollTo(0, 0); |
|
} else if (this.options.forceTo === 'bottom') { |
|
window.scrollTo(0, document.body.scrollHeight); |
|
} |
|
|
|
/** |
|
* Fires when the off-canvas menu opens. |
|
* @event OffCanvas#opened |
|
*/ |
|
_this.$element.addClass('is-open'); |
|
|
|
this.$triggers.attr('aria-expanded', 'true'); |
|
this.$element.attr('aria-hidden', 'false').trigger('opened.zf.offcanvas'); |
|
|
|
// If `contentScroll` is set to false, add class and disable scrolling on touch devices. |
|
if (this.options.contentScroll === false) { |
|
$('body').addClass('is-off-canvas-open').on('touchmove', this._stopScrolling); |
|
this.$element.on('touchstart', this._recordScrollable); |
|
this.$element.on('touchmove', this._stopScrollPropagation); |
|
} |
|
|
|
if (this.options.contentOverlay === true) { |
|
this.$overlay.addClass('is-visible'); |
|
} |
|
|
|
if (this.options.closeOnClick === true && this.options.contentOverlay === true) { |
|
this.$overlay.addClass('is-closable'); |
|
} |
|
|
|
if (this.options.autoFocus === true) { |
|
this.$element.one(Foundation.transitionend(this.$element), function () { |
|
var canvasFocus = _this.$element.find('[data-autofocus]'); |
|
if (canvasFocus.length) { |
|
canvasFocus.eq(0).focus(); |
|
} else { |
|
_this.$element.find('a, button').eq(0).focus(); |
|
} |
|
}); |
|
} |
|
|
|
if (this.options.trapFocus === true) { |
|
this.$element.siblings('[data-off-canvas-content]').attr('tabindex', '-1'); |
|
Foundation.Keyboard.trapFocus(this.$element); |
|
} |
|
} |
|
|
|
/** |
|
* 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; |
|
|
|
_this.$element.removeClass('is-open'); |
|
|
|
this.$element.attr('aria-hidden', 'true') |
|
/** |
|
* Fires when the off-canvas menu opens. |
|
* @event OffCanvas#closed |
|
*/ |
|
.trigger('closed.zf.offcanvas'); |
|
|
|
// If `contentScroll` is set to false, remove class and re-enable scrolling on touch devices. |
|
if (this.options.contentScroll === false) { |
|
$('body').removeClass('is-off-canvas-open').off('touchmove', this._stopScrolling); |
|
this.$element.off('touchstart', this._recordScrollable); |
|
this.$element.off('touchmove', this._stopScrollPropagation); |
|
} |
|
|
|
if (this.options.contentOverlay === true) { |
|
this.$overlay.removeClass('is-visible'); |
|
} |
|
|
|
if (this.options.closeOnClick === true && this.options.contentOverlay === true) { |
|
this.$overlay.removeClass('is-closable'); |
|
} |
|
|
|
this.$triggers.attr('aria-expanded', 'false'); |
|
|
|
if (this.options.trapFocus === true) { |
|
this.$element.siblings('[data-off-canvas-content]').removeAttr('tabindex'); |
|
Foundation.Keyboard.releaseFocus(this.$element); |
|
} |
|
} |
|
|
|
/** |
|
* 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.$overlay.off('.zf.offcanvas'); |
|
|
|
Foundation.unregisterPlugin(this); |
|
} |
|
}]); |
|
|
|
return OffCanvas; |
|
}(); |
|
|
|
OffCanvas.defaults = { |
|
/** |
|
* Allow the user to click outside of the menu to close it. |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
closeOnClick: true, |
|
|
|
/** |
|
* Adds an overlay on top of `[data-off-canvas-content]`. |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
contentOverlay: true, |
|
|
|
/** |
|
* Enable/disable scrolling of the main content when an off canvas panel is open. |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
contentScroll: true, |
|
|
|
/** |
|
* Amount of time in ms the open and close transition requires. If none selected, pulls from body style. |
|
* @option |
|
* @type {number} |
|
* @default 0 |
|
*/ |
|
transitionTime: 0, |
|
|
|
/** |
|
* Type of transition for the offcanvas menu. Options are 'push', 'detached' or 'slide'. |
|
* @option |
|
* @type {string} |
|
* @default push |
|
*/ |
|
transition: 'push', |
|
|
|
/** |
|
* Force the page to scroll to top or bottom on open. |
|
* @option |
|
* @type {?string} |
|
* @default null |
|
*/ |
|
forceTo: null, |
|
|
|
/** |
|
* Allow the offcanvas to remain open for certain breakpoints. |
|
* @option |
|
* @type {boolean} |
|
* @default 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 |
|
* @type {?string} |
|
* @default null |
|
*/ |
|
revealOn: null, |
|
|
|
/** |
|
* Force focus to the offcanvas on open. If true, will focus the opening trigger on close. |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
autoFocus: true, |
|
|
|
/** |
|
* Class used to force an offcanvas to remain open. Foundation defaults for this are `reveal-for-large` & `reveal-for-medium`. |
|
* @option |
|
* @type {string} |
|
* @default reveal-for- |
|
* @todo improve the regex testing for this. |
|
*/ |
|
revealClass: 'reveal-for-', |
|
|
|
/** |
|
* Triggers optional focus trapping when opening an offcanvas. Sets tabindex of [data-off-canvas-content] to -1 for accessibility purposes. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
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() { |
|
// @TODO: consider discussion on PR #9278 about DOM pollution by changeSlide |
|
this._reset(); |
|
|
|
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'), |
|
id = this.$element[0].id || Foundation.GetYoDigits(6, 'orbit'); |
|
|
|
this.$element.attr({ |
|
'data-resize': id, |
|
'id': id |
|
}); |
|
|
|
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(); |
|
} |
|
|
|
/** |
|
* 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 = this; |
|
|
|
this.$slides.each(function () { |
|
temp = this.getBoundingClientRect().height; |
|
$(this).attr('data-slide', counter); |
|
|
|
if (_this.$slides.filter('.is-active')[0] !== _this.$slides.eq(counter)[0]) { |
|
//if not the active 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. |
|
if (cb) { |
|
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 ** |
|
//*************************************** |
|
// |
|
this.$element.off('.resizeme.zf.trigger').on({ |
|
'resizeme.zf.trigger': this._prepareForOrbit.bind(this) |
|
}); |
|
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(); |
|
} |
|
} |
|
}); |
|
}); |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* Resets Orbit so it can be reinitialized |
|
*/ |
|
|
|
}, { |
|
key: '_reset', |
|
value: function _reset() { |
|
// Don't do anything if there are no slides (first run) |
|
if (typeof this.$slides == 'undefined') { |
|
return; |
|
} |
|
|
|
if (this.$slides.length > 1) { |
|
// Remove old events |
|
this.$element.off('.zf.orbit').find('*').off('.zf.orbit'); |
|
|
|
// Restart timer if autoPlay is enabled |
|
if (this.options.autoPlay) { |
|
this.timer.restart(); |
|
} |
|
|
|
// Reset all sliddes |
|
this.$slides.each(function (el) { |
|
$(el).removeClass('is-active is-active is-in').removeAttr('aria-live').hide(); |
|
}); |
|
|
|
// Show the first slide |
|
this.$slides.first().addClass('is-active').show(); |
|
|
|
// Triggers when the slide has finished animating |
|
this.$element.trigger('slidechange.zf.orbit', [this.$slides.first()]); |
|
|
|
// Select first bullet if bullets are present |
|
if (this.options.bullets) { |
|
this._updateBullets(0); |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* 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) { |
|
if (!this.$slides) { |
|
return; |
|
} // Don't freak out if we're in the middle of cleanup |
|
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 && !this.$element.is(':hidden')) { |
|
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 |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
bullets: true, |
|
/** |
|
* Tells the JS to apply event listeners to nav buttons |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
navButtons: true, |
|
/** |
|
* motion-ui animation class to apply |
|
* @option |
|
* @type {string} |
|
* @default 'slide-in-right' |
|
*/ |
|
animInFromRight: 'slide-in-right', |
|
/** |
|
* motion-ui animation class to apply |
|
* @option |
|
* @type {string} |
|
* @default 'slide-out-right' |
|
*/ |
|
animOutToRight: 'slide-out-right', |
|
/** |
|
* motion-ui animation class to apply |
|
* @option |
|
* @type {string} |
|
* @default 'slide-in-left' |
|
* |
|
*/ |
|
animInFromLeft: 'slide-in-left', |
|
/** |
|
* motion-ui animation class to apply |
|
* @option |
|
* @type {string} |
|
* @default 'slide-out-left' |
|
*/ |
|
animOutToLeft: 'slide-out-left', |
|
/** |
|
* Allows Orbit to automatically animate on page load. |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
autoPlay: true, |
|
/** |
|
* Amount of time, in ms, between slide transitions |
|
* @option |
|
* @type {number} |
|
* @default 5000 |
|
*/ |
|
timerDelay: 5000, |
|
/** |
|
* Allows Orbit to infinitely loop through the slides |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
infiniteWrap: true, |
|
/** |
|
* Allows the Orbit slides to bind to swipe events for mobile, requires an additional util library |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
swipe: true, |
|
/** |
|
* Allows the timing function to pause animation on hover. |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
pauseOnHover: true, |
|
/** |
|
* Allows Orbit to bind keyboard events to the slider, to animate frames with arrow keys |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
accessible: true, |
|
/** |
|
* Class applied to the container of Orbit |
|
* @option |
|
* @type {string} |
|
* @default 'orbit-container' |
|
*/ |
|
containerClass: 'orbit-container', |
|
/** |
|
* Class applied to individual slides. |
|
* @option |
|
* @type {string} |
|
* @default 'orbit-slide' |
|
*/ |
|
slideClass: 'orbit-slide', |
|
/** |
|
* Class applied to the bullet container. You're welcome. |
|
* @option |
|
* @type {string} |
|
* @default 'orbit-bullets' |
|
*/ |
|
boxOfBullets: 'orbit-bullets', |
|
/** |
|
* Class applied to the `next` navigation button. |
|
* @option |
|
* @type {string} |
|
* @default 'orbit-next' |
|
*/ |
|
nextClass: 'orbit-next', |
|
/** |
|
* Class applied to the `previous` navigation button. |
|
* @option |
|
* @type {string} |
|
* @default 'orbit-previous' |
|
*/ |
|
prevClass: 'orbit-previous', |
|
/** |
|
* Boolean to flag the js to use motion ui classes or not. Default to true for backwards compatability. |
|
* @option |
|
* @type {boolean} |
|
* @default 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 |
|
*/ |
|
|
|
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(); |
|
} |
|
// Add data-mutate since children may need it. |
|
this.$element.attr('data-mutate', this.$element.attr('data-mutate') || Foundation.GetYoDigits(6, 'responsive-menu')); |
|
} |
|
|
|
/** |
|
* 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]').filter(function () { |
|
var target = $(this).data('toggle'); |
|
return target === targetID || target === ""; |
|
}); |
|
this.options = $.extend({}, this.options, this.$targetMenu.data()); |
|
|
|
// If they were set, parse the animation classes |
|
if (this.options.animate) { |
|
var input = this.options.animate.split(' '); |
|
|
|
this.animationIn = input[0]; |
|
this.animationOut = input[1] || null; |
|
} |
|
|
|
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() { |
|
var _this2 = this; |
|
|
|
if (!Foundation.MediaQuery.atLeast(this.options.hideFor)) { |
|
/** |
|
* Fires when the element attached to the tab bar toggles. |
|
* @event ResponsiveToggle#toggled |
|
*/ |
|
if (this.options.animate) { |
|
if (this.$targetMenu.is(':hidden')) { |
|
Foundation.Motion.animateIn(this.$targetMenu, this.animationIn, function () { |
|
_this2.$element.trigger('toggled.zf.responsiveToggle'); |
|
_this2.$targetMenu.find('[data-mutate]').triggerHandler('mutateme.zf.trigger'); |
|
}); |
|
} else { |
|
Foundation.Motion.animateOut(this.$targetMenu, this.animationOut, function () { |
|
_this2.$element.trigger('toggled.zf.responsiveToggle'); |
|
}); |
|
} |
|
} else { |
|
this.$targetMenu.toggle(0); |
|
this.$targetMenu.find('[data-mutate]').trigger('mutateme.zf.trigger'); |
|
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 |
|
* @type {string} |
|
* @default 'medium' |
|
*/ |
|
hideFor: 'medium', |
|
|
|
/** |
|
* To decide if the toggle should be animated or not. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
animate: false |
|
}; |
|
|
|
// 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' |
|
}); |
|
} |
|
|
|
/** |
|
* 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($(this.options.appendTo)); |
|
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() { |
|
return $('<div></div>').addClass('reveal-overlay').appendTo(this.options.appendTo); |
|
} |
|
|
|
/** |
|
* 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); |
|
} |
|
|
|
var _this = this; |
|
|
|
function addRevealOpenClasses() { |
|
if (_this.isMobile) { |
|
if (!_this.originalScrollPos) { |
|
_this.originalScrollPos = window.pageYOffset; |
|
} |
|
$('html, body').addClass('is-reveal-open'); |
|
} else { |
|
$('body').addClass('is-reveal-open'); |
|
} |
|
} |
|
// Motion UI method of reveal |
|
if (this.options.animationIn) { |
|
var afterAnimation = function () { |
|
_this.$element.attr({ |
|
'aria-hidden': false, |
|
'tabindex': -1 |
|
}).focus(); |
|
addRevealOpenClasses(); |
|
Foundation.Keyboard.trapFocus(_this.$element); |
|
}; |
|
|
|
if (this.options.overlay) { |
|
Foundation.Motion.animateIn(this.$overlay, 'fade-in'); |
|
} |
|
Foundation.Motion.animateIn(this.$element, this.options.animationIn, function () { |
|
if (_this3.$element) { |
|
// protect against object having been removed |
|
_this3.focusableElements = Foundation.Keyboard.findFocusable(_this3.$element); |
|
afterAnimation(); |
|
} |
|
}); |
|
} |
|
// 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(); |
|
Foundation.Keyboard.trapFocus(this.$element); |
|
|
|
/** |
|
* Fires when the modal has successfully opened. |
|
* @event Reveal#open |
|
*/ |
|
this.$element.trigger('open.zf.reveal'); |
|
|
|
addRevealOpenClasses(); |
|
|
|
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; |
|
if (!this.$element) { |
|
return; |
|
} // If we're in the middle of cleanup, don't freak out |
|
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', { |
|
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 { |
|
|
|
this.$element.hide(this.options.hideDelay); |
|
|
|
if (this.options.overlay) { |
|
this.$overlay.hide(0, finishUp); |
|
} else { |
|
finishUp(); |
|
} |
|
} |
|
|
|
// 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) { |
|
if ($('.reveal:visible').length === 0) { |
|
$('html, body').removeClass('is-reveal-open'); |
|
} |
|
if (_this.originalScrollPos) { |
|
$('body').scrollTop(_this.originalScrollPos); |
|
_this.originalScrollPos = null; |
|
} |
|
} else { |
|
if ($('.reveal:visible').length === 0) { |
|
$('body').removeClass('is-reveal-open'); |
|
} |
|
} |
|
|
|
Foundation.Keyboard.releaseFocus(_this.$element); |
|
|
|
_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.href.replace('#' + this.id, '')); |
|
} 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($(this.options.appendTo)); // 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 |
|
* @type {string} |
|
* @default '' |
|
*/ |
|
animationIn: '', |
|
/** |
|
* Motion-UI class to use for animated elements. If none used, defaults to simple show/hide. |
|
* @option |
|
* @type {string} |
|
* @default '' |
|
*/ |
|
animationOut: '', |
|
/** |
|
* Time, in ms, to delay the opening of a modal after a click if no animation used. |
|
* @option |
|
* @type {number} |
|
* @default 0 |
|
*/ |
|
showDelay: 0, |
|
/** |
|
* Time, in ms, to delay the closing of a modal after a click if no animation used. |
|
* @option |
|
* @type {number} |
|
* @default 0 |
|
*/ |
|
hideDelay: 0, |
|
/** |
|
* Allows a click on the body/overlay to close the modal. |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
closeOnClick: true, |
|
/** |
|
* Allows the modal to close if the user presses the `ESCAPE` key. |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
closeOnEsc: true, |
|
/** |
|
* If true, allows multiple modals to be displayed at once. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
multipleOpened: false, |
|
/** |
|
* Distance, in pixels, the modal should push down from the top of the screen. |
|
* @option |
|
* @type {number|string} |
|
* @default auto |
|
*/ |
|
vOffset: 'auto', |
|
/** |
|
* Distance, in pixels, the modal should push in from the side of the screen. |
|
* @option |
|
* @type {number|string} |
|
* @default auto |
|
*/ |
|
hOffset: 'auto', |
|
/** |
|
* Allows the modal to be fullscreen, completely blocking out the rest of the view. JS checks for this as well. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
fullScreen: false, |
|
/** |
|
* Percentage of screen height the modal should push up from the bottom of the view. |
|
* @option |
|
* @type {number} |
|
* @default 10 |
|
*/ |
|
btmOffsetPct: 10, |
|
/** |
|
* Allows the modal to generate an overlay div, which will cover the view when modal opens. |
|
* @option |
|
* @type {boolean} |
|
* @default 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 |
|
* @type {boolean} |
|
* @default 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 |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
deepLink: false, |
|
/** |
|
* Allows the modal to append to custom div. |
|
* @option |
|
* @type {string} |
|
* @default "body" |
|
*/ |
|
appendTo: "body" |
|
|
|
}; |
|
|
|
// 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 slider control. |
|
* @class |
|
* @param {jQuery} element - jQuery object to make into a slider control. |
|
* @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); |
|
|
|
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.$handle.triggerHandler('click.zf.slider'); |
|
this._setInitAttr(1); |
|
} |
|
|
|
// Set handle positions |
|
this.setHandles(); |
|
|
|
this._events(); |
|
} |
|
}, { |
|
key: 'setHandles', |
|
value: function setHandles() { |
|
var _this2 = this; |
|
|
|
if (this.handles[1]) { |
|
this._setHandlePos(this.$handle, this.inputs.eq(0).val(), true, function () { |
|
_this2._setHandlePos(_this2.$handle2, _this2.inputs.eq(1).val(), true); |
|
}); |
|
} else { |
|
this._setHandlePos(this.$handle, this.inputs.eq(0).val(), true); |
|
} |
|
} |
|
}, { |
|
key: '_reflow', |
|
value: function _reflow() { |
|
this.setHandles(); |
|
} |
|
/** |
|
* @function |
|
* @private |
|
* @param {Number} value - floating point (the value) to be transformed using to a relative position on the slider (the inverse of _value) |
|
*/ |
|
|
|
}, { |
|
key: '_pctOfBar', |
|
value: function _pctOfBar(value) { |
|
var pctOfBar = percent(value - this.options.start, this.options.end - this.options.start); |
|
|
|
switch (this.options.positionValueFunction) { |
|
case "pow": |
|
pctOfBar = this._logTransform(pctOfBar); |
|
break; |
|
case "log": |
|
pctOfBar = this._powTransform(pctOfBar); |
|
break; |
|
} |
|
|
|
return pctOfBar.toFixed(2); |
|
} |
|
|
|
/** |
|
* @function |
|
* @private |
|
* @param {Number} pctOfBar - floating point, the relative position of the slider (typically between 0-1) to be transformed to a value |
|
*/ |
|
|
|
}, { |
|
key: '_value', |
|
value: function _value(pctOfBar) { |
|
switch (this.options.positionValueFunction) { |
|
case "pow": |
|
pctOfBar = this._powTransform(pctOfBar); |
|
break; |
|
case "log": |
|
pctOfBar = this._logTransform(pctOfBar); |
|
break; |
|
} |
|
var value = (this.options.end - this.options.start) * pctOfBar + this.options.start; |
|
|
|
return value; |
|
} |
|
|
|
/** |
|
* @function |
|
* @private |
|
* @param {Number} value - floating point (typically between 0-1) to be transformed using the log function |
|
*/ |
|
|
|
}, { |
|
key: '_logTransform', |
|
value: function _logTransform(value) { |
|
return baseLog(this.options.nonLinearBase, value * (this.options.nonLinearBase - 1) + 1); |
|
} |
|
|
|
/** |
|
* @function |
|
* @private |
|
* @param {Number} value - floating point (typically between 0-1) to be transformed using the power function |
|
*/ |
|
|
|
}, { |
|
key: '_powTransform', |
|
value: function _powTransform(value) { |
|
return (Math.pow(this.options.nonLinearBase, value) - 1) / (this.options.nonLinearBase - 1); |
|
} |
|
|
|
/** |
|
* 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 = this._pctOfBar(location), |
|
|
|
//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.start) / ((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 |
|
// if movement isNaN, that is because the slider is hidden and we cannot determine handle width, |
|
// fall back to next best guess. |
|
if (isNaN(movement)) { |
|
$hndl.css(lOrT, pctOfBar * 100 + '%'); |
|
} else { |
|
$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 initVal = idx === 0 ? this.options.initialStart : this.options.initialEnd; |
|
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.inputs.eq(idx).val(initVal); |
|
this.handles.eq(idx).attr({ |
|
'role': 'slider', |
|
'aria-controls': id, |
|
'aria-valuemax': this.options.end, |
|
'aria-valuemin': this.options.start, |
|
'aria-valuenow': initVal, |
|
'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._value(offsetPct); |
|
|
|
// 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 |
|
*/ |
|
|
|
}, { |
|
key: '_events', |
|
value: function _events() { |
|
this._eventsForHandle(this.$handle); |
|
if (this.handles[1]) { |
|
this._eventsForHandle(this.$handle2); |
|
} |
|
} |
|
|
|
/** |
|
* Adds event listeners a particular handle |
|
* @function |
|
* @private |
|
* @param {jQuery} $handle - the current handle to apply listeners to. |
|
*/ |
|
|
|
}, { |
|
key: '_eventsForHandle', |
|
value: function _eventsForHandle($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'); |
|
|
|
clearTimeout(this.timeout); |
|
|
|
Foundation.unregisterPlugin(this); |
|
} |
|
}]); |
|
|
|
return Slider; |
|
}(); |
|
|
|
Slider.defaults = { |
|
/** |
|
* Minimum value for the slider scale. |
|
* @option |
|
* @type {number} |
|
* @default 0 |
|
*/ |
|
start: 0, |
|
/** |
|
* Maximum value for the slider scale. |
|
* @option |
|
* @type {number} |
|
* @default 100 |
|
*/ |
|
end: 100, |
|
/** |
|
* Minimum value change per change event. |
|
* @option |
|
* @type {number} |
|
* @default 1 |
|
*/ |
|
step: 1, |
|
/** |
|
* Value at which the handle/input *(left handle/first input)* should be set to on initialization. |
|
* @option |
|
* @type {number} |
|
* @default 0 |
|
*/ |
|
initialStart: 0, |
|
/** |
|
* Value at which the right handle/second input should be set to on initialization. |
|
* @option |
|
* @type {number} |
|
* @default 100 |
|
*/ |
|
initialEnd: 100, |
|
/** |
|
* Allows the input to be located outside the container and visible. Set to by the JS |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
binding: false, |
|
/** |
|
* Allows the user to click/tap on the slider bar to select a value. |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
clickSelect: true, |
|
/** |
|
* Set to true and use the `vertical` class to change alignment to vertical. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
vertical: false, |
|
/** |
|
* Allows the user to drag the slider handle(s) to select a value. |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
draggable: true, |
|
/** |
|
* Disables the slider and prevents event listeners from being applied. Double checked by JS with `disabledClass`. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
disabled: false, |
|
/** |
|
* Allows the use of two handles. Double checked by the JS. Changes some logic handling. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
doubleSided: false, |
|
/** |
|
* Potential future feature. |
|
*/ |
|
// steps: 100, |
|
/** |
|
* Number of decimal places the plugin should go to for floating point precision. |
|
* @option |
|
* @type {number} |
|
* @default 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 |
|
* @type {number} |
|
* @default 200 |
|
*/ |
|
moveTime: 200, //update this if changing the transition time in the sass |
|
/** |
|
* Class applied to disabled sliders. |
|
* @option |
|
* @type {string} |
|
* @default 'disabled' |
|
*/ |
|
disabledClass: 'disabled', |
|
/** |
|
* Will invert the default layout for a vertical<span data-tooltip title="who would do this???"> </span>slider. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
invertVertical: false, |
|
/** |
|
* Milliseconds before the `changed.zf-slider` event is triggered after value change. |
|
* @option |
|
* @type {number} |
|
* @default 500 |
|
*/ |
|
changedDelay: 500, |
|
/** |
|
* Basevalue for non-linear sliders |
|
* @option |
|
* @type {number} |
|
* @default 5 |
|
*/ |
|
nonLinearBase: 5, |
|
/** |
|
* Basevalue for non-linear sliders, possible values are: `'linear'`, `'pow'` & `'log'`. Pow and Log use the nonLinearBase setting. |
|
* @option |
|
* @type {string} |
|
* @default 'linear' |
|
*/ |
|
positionValueFunction: 'linear' |
|
}; |
|
|
|
function percent(frac, num) { |
|
return frac / num; |
|
} |
|
function absPosition($handle, dir, clickPos, param) { |
|
return Math.abs($handle.position()[dir] + $handle[param]() / 2 - clickPos); |
|
} |
|
function baseLog(base, value) { |
|
return Math.log(value) / Math.log(base); |
|
} |
|
|
|
// Window exports |
|
Foundation.plugin(Slider, 'Slider'); |
|
}(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 ($) { |
|
|
|
/** |
|
* 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, 'data-mutate': id }); |
|
if (this.options.anchor !== '') { |
|
$('#' + _this.options.anchor).attr({ 'data-mutate': 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 () { |
|
var scroll = window.pageYOffset; |
|
_this._calc(false, scroll); |
|
//Unstick the element will ensure that proper classes are set. |
|
if (!_this.isStuck) { |
|
_this._removeSticky(scroll >= _this.topPoint ? false : true); |
|
} |
|
}); |
|
_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._eventsHandler(id); |
|
}); |
|
|
|
this.$element.on('mutateme.zf.trigger', function (e, el) { |
|
_this._eventsHandler(id); |
|
}); |
|
|
|
if (this.$anchor) { |
|
this.$anchor.on('mutateme.zf.trigger', function (e, el) { |
|
_this._eventsHandler(id); |
|
}); |
|
} |
|
} |
|
|
|
/** |
|
* Handler for events. |
|
* @private |
|
* @param {String} id - psuedo-random id for unique scroll event listener. |
|
*/ |
|
|
|
}, { |
|
key: '_eventsHandler', |
|
value: function _eventsHandler(id) { |
|
var _this = this, |
|
scrollListener = this.scrollListener = 'scroll.zf.' + id; |
|
|
|
_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'; |
|
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; |
|
} |
|
|
|
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.is(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]), |
|
pdngl = parseInt(comp['padding-left'], 10), |
|
pdngr = 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 - pdngl - pdngr + '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) { |
|
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').off('mutateme.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 |
|
* @type {string} |
|
* @default '<div data-sticky-container></div>' |
|
*/ |
|
container: '<div data-sticky-container></div>', |
|
/** |
|
* Location in the view the element sticks to. Can be `'top'` or `'bottom'`. |
|
* @option |
|
* @type {string} |
|
* @default 'top' |
|
*/ |
|
stickTo: 'top', |
|
/** |
|
* If anchored to a single element, the id of that element. |
|
* @option |
|
* @type {string} |
|
* @default '' |
|
*/ |
|
anchor: '', |
|
/** |
|
* If using more than one element as anchor points, the id of the top anchor. |
|
* @option |
|
* @type {string} |
|
* @default '' |
|
*/ |
|
topAnchor: '', |
|
/** |
|
* If using more than one element as anchor points, the id of the bottom anchor. |
|
* @option |
|
* @type {string} |
|
* @default '' |
|
*/ |
|
btmAnchor: '', |
|
/** |
|
* Margin, in `em`'s to apply to the top of the element when it becomes sticky. |
|
* @option |
|
* @type {number} |
|
* @default 1 |
|
*/ |
|
marginTop: 1, |
|
/** |
|
* Margin, in `em`'s to apply to the bottom of the element when it becomes sticky. |
|
* @option |
|
* @type {number} |
|
* @default 1 |
|
*/ |
|
marginBottom: 1, |
|
/** |
|
* Breakpoint string that is the minimum screen size an element should become sticky. |
|
* @option |
|
* @type {string} |
|
* @default 'medium' |
|
*/ |
|
stickyOn: 'medium', |
|
/** |
|
* Class applied to sticky element, and removed on destruction. Foundation defaults to `sticky`. |
|
* @option |
|
* @type {string} |
|
* @default 'sticky' |
|
*/ |
|
stickyClass: 'sticky', |
|
/** |
|
* Class applied to sticky container. Foundation defaults to `sticky-container`. |
|
* @option |
|
* @type {string} |
|
* @default '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 |
|
* @type {number} |
|
* @default -1 |
|
*/ |
|
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 _this2 = this; |
|
|
|
var _this = this; |
|
|
|
this.$element.attr({ 'role': 'tablist' }); |
|
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('' + _this.options.linkActiveClass), |
|
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) { |
|
$(window).load(function () { |
|
$('html, body').animate({ scrollTop: $elem.offset().top }, _this.options.deepLinkSmudgeDelay, function () { |
|
$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(); |
|
} |
|
} |
|
|
|
//current context-bound function to open tabs on page load or history popstate |
|
this._checkDeepLink = function () { |
|
var anchor = window.location.hash; |
|
//need a hash and a relevant anchor in this tabset |
|
if (anchor.length) { |
|
var $link = _this2.$element.find('[href$="' + anchor + '"]'); |
|
if ($link.length) { |
|
_this2.selectTab($(anchor), true); |
|
|
|
//roll up a little to show the titles |
|
if (_this2.options.deepLinkSmudge) { |
|
var offset = _this2.$element.offset(); |
|
$('html, body').animate({ scrollTop: offset.top }, _this2.options.deepLinkSmudgeDelay); |
|
} |
|
|
|
/** |
|
* Fires when the zplugin has deeplinked at pageload |
|
* @event Tabs#deeplink |
|
*/ |
|
_this2.$element.trigger('deeplink.zf.tabs', [$link, $(anchor)]); |
|
} |
|
} |
|
}; |
|
|
|
//use browser to open a tab, if it exists in this tabset |
|
if (this.options.deepLink) { |
|
this._checkDeepLink(); |
|
} |
|
|
|
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); |
|
} |
|
|
|
if (this.options.deepLink) { |
|
$(window).on('popstate', this._checkDeepLink); |
|
} |
|
} |
|
|
|
/** |
|
* 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(); |
|
_this._handleTabChange($(this)); |
|
}); |
|
} |
|
|
|
/** |
|
* Adds keyboard event handlers for items within the tabs. |
|
* @private |
|
*/ |
|
|
|
}, { |
|
key: '_addKeyHandler', |
|
value: function _addKeyHandler() { |
|
var _this = this; |
|
|
|
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`. Collapses active tab. |
|
* @param {jQuery} $target - Tab to open. |
|
* @param {boolean} historyHandled - browser has already handled a history update |
|
* @fires Tabs#change |
|
* @function |
|
*/ |
|
|
|
}, { |
|
key: '_handleTabChange', |
|
value: function _handleTabChange($target, historyHandled) { |
|
|
|
/** |
|
* Check for active class on target. Collapse if exists. |
|
*/ |
|
if ($target.hasClass('' + this.options.linkActiveClass)) { |
|
if (this.options.activeCollapse) { |
|
this._collapseTab($target); |
|
|
|
/** |
|
* Fires when the zplugin has successfully collapsed tabs. |
|
* @event Tabs#collapse |
|
*/ |
|
this.$element.trigger('collapse.zf.tabs', [$target]); |
|
} |
|
return; |
|
} |
|
|
|
var $oldTab = this.$element.find('.' + this.options.linkClass + '.' + this.options.linkActiveClass), |
|
$tabLink = $target.find('[role="tab"]'), |
|
hash = $tabLink[0].hash, |
|
$targetContent = this.$tabContent.find(hash); |
|
|
|
//close old tab |
|
this._collapseTab($oldTab); |
|
|
|
//open new tab |
|
this._openTab($target); |
|
|
|
//either replace or update browser history |
|
if (this.options.deepLink && !historyHandled) { |
|
var anchor = $target.find('a').attr('href'); |
|
|
|
if (this.options.updateHistory) { |
|
history.pushState({}, '', anchor); |
|
} else { |
|
history.replaceState({}, '', anchor); |
|
} |
|
} |
|
|
|
/** |
|
* Fires when the plugin has successfully changed tabs. |
|
* @event Tabs#change |
|
*/ |
|
this.$element.trigger('change.zf.tabs', [$target, $targetContent]); |
|
|
|
//fire to children a mutation event |
|
$targetContent.find("[data-mutate]").trigger("mutateme.zf.trigger"); |
|
} |
|
|
|
/** |
|
* Opens the tab `$targetContent` defined by `$target`. |
|
* @param {jQuery} $target - Tab to Open. |
|
* @function |
|
*/ |
|
|
|
}, { |
|
key: '_openTab', |
|
value: function _openTab($target) { |
|
var $tabLink = $target.find('[role="tab"]'), |
|
hash = $tabLink[0].hash, |
|
$targetContent = this.$tabContent.find(hash); |
|
|
|
$target.addClass('' + this.options.linkActiveClass); |
|
|
|
$tabLink.attr({ 'aria-selected': 'true' }); |
|
|
|
$targetContent.addClass('' + this.options.panelActiveClass).attr({ 'aria-hidden': 'false' }); |
|
} |
|
|
|
/** |
|
* Collapses `$targetContent` defined by `$target`. |
|
* @param {jQuery} $target - Tab to Open. |
|
* @function |
|
*/ |
|
|
|
}, { |
|
key: '_collapseTab', |
|
value: function _collapseTab($target) { |
|
var $target_anchor = $target.removeClass('' + this.options.linkActiveClass).find('[role="tab"]').attr({ 'aria-selected': 'false' }); |
|
|
|
$('#' + $target_anchor.attr('aria-controls')).removeClass('' + this.options.panelActiveClass).attr({ 'aria-hidden': 'true' }); |
|
} |
|
|
|
/** |
|
* 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. |
|
* @param {boolean} historyHandled - browser has already handled a history update |
|
* @function |
|
*/ |
|
|
|
}, { |
|
key: 'selectTab', |
|
value: function selectTab(elem, historyHandled) { |
|
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, historyHandled); |
|
} |
|
}, { |
|
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. |
|
* If enabled with `data-match-height="true"`, tabs sets to equal height |
|
* @function |
|
* @private |
|
*/ |
|
value: function _setHeight() { |
|
var max = 0, |
|
_this = this; // Lock down the `this` value for the root tabs object |
|
|
|
this.$tabContent.find('.' + this.options.panelClass).css('height', '').each(function () { |
|
|
|
var panel = $(this), |
|
isActive = panel.hasClass('' + _this.options.panelActiveClass); // get the options from the parent instead of trying to get them from the child |
|
|
|
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); |
|
} |
|
} |
|
|
|
if (this.options.deepLink) { |
|
$(window).off('popstate', this._checkDeepLink); |
|
} |
|
|
|
Foundation.unregisterPlugin(this); |
|
} |
|
}]); |
|
|
|
return Tabs; |
|
}(); |
|
|
|
Tabs.defaults = { |
|
/** |
|
* Allows the window to scroll to content of pane specified by hash anchor |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
deepLink: false, |
|
|
|
/** |
|
* Adjust the deep link scroll to make sure the top of the tab panel is visible |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
deepLinkSmudge: false, |
|
|
|
/** |
|
* Animation time (ms) for the deep link adjustment |
|
* @option |
|
* @type {number} |
|
* @default 300 |
|
*/ |
|
deepLinkSmudgeDelay: 300, |
|
|
|
/** |
|
* Update the browser history with the open tab |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
updateHistory: false, |
|
|
|
/** |
|
* Allows the window to scroll to content of active pane on load if set to true. |
|
* Not recommended if more than one tab panel per page. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
autoFocus: false, |
|
|
|
/** |
|
* Allows keyboard input to 'wrap' around the tab links. |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
wrapOnKeys: true, |
|
|
|
/** |
|
* Allows the tab content panes to match heights if set to true. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
matchHeight: false, |
|
|
|
/** |
|
* Allows active tabs to collapse when clicked. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
activeCollapse: false, |
|
|
|
/** |
|
* Class applied to `li`'s in tab link list. |
|
* @option |
|
* @type {string} |
|
* @default 'tabs-title' |
|
*/ |
|
linkClass: 'tabs-title', |
|
|
|
/** |
|
* Class applied to the active `li` in tab link list. |
|
* @option |
|
* @type {string} |
|
* @default 'is-active' |
|
*/ |
|
linkActiveClass: 'is-active', |
|
|
|
/** |
|
* Class applied to the content containers. |
|
* @option |
|
* @type {string} |
|
* @default 'tabs-panel' |
|
*/ |
|
panelClass: 'tabs-panel', |
|
|
|
/** |
|
* Class applied to the active content container. |
|
* @option |
|
* @type {string} |
|
* @default 'is-active' |
|
*/ |
|
panelActiveClass: '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); |
|
this.$element.find('[data-mutate]').trigger('mutateme.zf.trigger'); |
|
} |
|
}, { |
|
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'); |
|
this.find('[data-mutate]').trigger('mutateme.zf.trigger'); |
|
}); |
|
} else { |
|
Foundation.Motion.animateOut(this.$element, this.animationOut, function () { |
|
_this._updateARIA(false); |
|
this.trigger('off.zf.toggler'); |
|
this.find('[data-mutate]').trigger('mutateme.zf.trigger'); |
|
}); |
|
} |
|
} |
|
}, { |
|
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 |
|
* @type {boolean} |
|
* @default 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); |
|
|
|
if (this.options.allowHtml) { |
|
this.template.appendTo(document.body).html(this.options.tipText).hide(); |
|
} else { |
|
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.is(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.tooltip').removeClass('has-tip top right left').removeAttr('aria-describedby aria-haspopup data-disable-hover data-resize data-toggle data-tooltip data-yeti-box'); |
|
|
|
this.template.remove(); |
|
|
|
Foundation.unregisterPlugin(this); |
|
} |
|
}]); |
|
|
|
return Tooltip; |
|
}(); |
|
|
|
Tooltip.defaults = { |
|
disableForTouch: false, |
|
/** |
|
* Time, in ms, before a tooltip should open on hover. |
|
* @option |
|
* @type {number} |
|
* @default 200 |
|
*/ |
|
hoverDelay: 200, |
|
/** |
|
* Time, in ms, a tooltip should take to fade into view. |
|
* @option |
|
* @type {number} |
|
* @default 150 |
|
*/ |
|
fadeInDuration: 150, |
|
/** |
|
* Time, in ms, a tooltip should take to fade out of view. |
|
* @option |
|
* @type {number} |
|
* @default 150 |
|
*/ |
|
fadeOutDuration: 150, |
|
/** |
|
* Disables hover events from opening the tooltip if set to true |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
disableHover: false, |
|
/** |
|
* Optional addtional classes to apply to the tooltip template on init. |
|
* @option |
|
* @type {string} |
|
* @default '' |
|
*/ |
|
templateClasses: '', |
|
/** |
|
* Non-optional class added to tooltip templates. Foundation default is 'tooltip'. |
|
* @option |
|
* @type {string} |
|
* @default 'tooltip' |
|
*/ |
|
tooltipClass: 'tooltip', |
|
/** |
|
* Class applied to the tooltip anchor element. |
|
* @option |
|
* @type {string} |
|
* @default 'has-tip' |
|
*/ |
|
triggerClass: 'has-tip', |
|
/** |
|
* Minimum breakpoint size at which to open the tooltip. |
|
* @option |
|
* @type {string} |
|
* @default 'small' |
|
*/ |
|
showOn: 'small', |
|
/** |
|
* Custom template to be used to generate markup for tooltip. |
|
* @option |
|
* @type {string} |
|
* @default '' |
|
*/ |
|
template: '', |
|
/** |
|
* Text displayed in the tooltip template on open. |
|
* @option |
|
* @type {string} |
|
* @default '' |
|
*/ |
|
tipText: '', |
|
touchCloseText: 'Tap to close.', |
|
/** |
|
* Allows the tooltip to remain open if triggered with a click or touch event. |
|
* @option |
|
* @type {boolean} |
|
* @default true |
|
*/ |
|
clickOpen: true, |
|
/** |
|
* Additional positioning classes, set by the JS |
|
* @option |
|
* @type {string} |
|
* @default '' |
|
*/ |
|
positionClass: '', |
|
/** |
|
* Distance, in pixels, the template should push away from the anchor on the Y axis. |
|
* @option |
|
* @type {number} |
|
* @default 10 |
|
*/ |
|
vOffset: 10, |
|
/** |
|
* Distance, in pixels, the template should push away from the anchor on the X axis, if aligned to a side. |
|
* @option |
|
* @type {number} |
|
* @default 12 |
|
*/ |
|
hOffset: 12, |
|
/** |
|
* Allow HTML in tooltip. Warning: If you are loading user-generated content into tooltips, |
|
* allowing HTML may open yourself up to XSS attacks. |
|
* @option |
|
* @type {boolean} |
|
* @default false |
|
*/ |
|
allowHtml: false |
|
}; |
|
|
|
/** |
|
* TODO utilize resize event trigger |
|
*/ |
|
|
|
// Window exports |
|
Foundation.plugin(Tooltip, 'Tooltip'); |
|
}(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 ($) { |
|
|
|
/** |
|
* ResponsiveAccordionTabs module. |
|
* @module foundation.responsiveAccordionTabs |
|
* @requires foundation.util.keyboard |
|
* @requires foundation.util.timerAndImageLoader |
|
* @requires foundation.util.motion |
|
* @requires foundation.accordion |
|
* @requires foundation.tabs |
|
*/ |
|
|
|
var ResponsiveAccordionTabs = function () { |
|
/** |
|
* Creates a new instance of a responsive accordion tabs. |
|
* @class |
|
* @fires ResponsiveAccordionTabs#init |
|
* @param {jQuery} element - jQuery object to make into a dropdown menu. |
|
* @param {Object} options - Overrides to the default plugin settings. |
|
*/ |
|
function ResponsiveAccordionTabs(element, options) { |
|
_classCallCheck(this, ResponsiveAccordionTabs); |
|
|
|
this.$element = $(element); |
|
this.options = $.extend({}, this.$element.data(), options); |
|
this.rules = this.$element.data('responsive-accordion-tabs'); |
|
this.currentMq = null; |
|
this.currentPlugin = null; |
|
if (!this.$element.attr('id')) { |
|
this.$element.attr('id', Foundation.GetYoDigits(6, 'responsiveaccordiontabs')); |
|
}; |
|
|
|
this._init(); |
|
this._events(); |
|
|
|
Foundation.registerPlugin(this, 'ResponsiveAccordionTabs'); |
|
} |
|
|
|
/** |
|
* Initializes the Menu by parsing the classes from the 'data-responsive-accordion-tabs' attribute on the element. |
|
* @function |
|
* @private |
|
*/ |
|
|
|
|
|
_createClass(ResponsiveAccordionTabs, [{ |
|
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; |
|
} |
|
|
|
this._getAllOptions(); |
|
|
|
if (!$.isEmptyObject(this.rules)) { |
|
this._checkMediaQueries(); |
|
} |
|
} |
|
}, { |
|
key: '_getAllOptions', |
|
value: function _getAllOptions() { |
|
//get all defaults and options |
|
var _this = this; |
|
_this.allOptions = {}; |
|
for (var key in MenuPlugins) { |
|
if (MenuPlugins.hasOwnProperty(key)) { |
|
var obj = MenuPlugins[key]; |
|
try { |
|
var dummyPlugin = $('<ul></ul>'); |
|
var tmpPlugin = new obj.plugin(dummyPlugin, _this.options); |
|
for (var keyKey in tmpPlugin.options) { |
|
if (tmpPlugin.options.hasOwnProperty(keyKey) && keyKey !== 'zfPlugin') { |
|
var objObj = tmpPlugin.options[keyKey]; |
|
_this.allOptions[keyKey] = objObj; |
|
} |
|
} |
|
tmpPlugin.destroy(); |
|
} catch (e) {} |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* Initializes events for the Menu. |
|
* @function |
|
* @private |
|
*/ |
|
|
|
}, { |
|
key: '_events', |
|
value: function _events() { |
|
var _this = this; |
|
|
|
$(window).on('changed.zf.mediaquery', 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) { |
|
//don't know why but on nested elements data zfPlugin get's lost |
|
if (!this.currentPlugin.$element.data('zfPlugin') && this.storezfData) this.currentPlugin.$element.data('zfPlugin', this.storezfData); |
|
this.currentPlugin.destroy(); |
|
} |
|
this._handleMarkup(this.rules[matchedMq].cssClass); |
|
this.currentPlugin = new this.rules[matchedMq].plugin(this.$element, {}); |
|
this.storezfData = this.currentPlugin.$element.data('zfPlugin'); |
|
} |
|
}, { |
|
key: '_handleMarkup', |
|
value: function _handleMarkup(toSet) { |
|
var _this = this, |
|
fromString = 'accordion'; |
|
var $panels = $('[data-tabs-content=' + this.$element.attr('id') + ']'); |
|
if ($panels.length) fromString = 'tabs'; |
|
if (fromString === toSet) { |
|
return; |
|
}; |
|
|
|
var tabsTitle = _this.allOptions.linkClass ? _this.allOptions.linkClass : 'tabs-title'; |
|
var tabsPanel = _this.allOptions.panelClass ? _this.allOptions.panelClass : 'tabs-panel'; |
|
|
|
this.$element.removeAttr('role'); |
|
var $liHeads = this.$element.children('.' + tabsTitle + ',[data-accordion-item]').removeClass(tabsTitle).removeClass('accordion-item').removeAttr('data-accordion-item'); |
|
var $liHeadsA = $liHeads.children('a').removeClass('accordion-title'); |
|
|
|
if (fromString === 'tabs') { |
|
$panels = $panels.children('.' + tabsPanel).removeClass(tabsPanel).removeAttr('role').removeAttr('aria-hidden').removeAttr('aria-labelledby'); |
|
$panels.children('a').removeAttr('role').removeAttr('aria-controls').removeAttr('aria-selected'); |
|
} else { |
|
$panels = $liHeads.children('[data-tab-content]').removeClass('accordion-content'); |
|
}; |
|
|
|
$panels.css({ display: '', visibility: '' }); |
|
$liHeads.css({ display: '', visibility: '' }); |
|
if (toSet === 'accordion') { |
|
$panels.each(function (key, value) { |
|
$(value).appendTo($liHeads.get(key)).addClass('accordion-content').attr('data-tab-content', '').removeClass('is-active').css({ height: '' }); |
|
$('[data-tabs-content=' + _this.$element.attr('id') + ']').after('<div id="tabs-placeholder-' + _this.$element.attr('id') + '"></div>').remove(); |
|
$liHeads.addClass('accordion-item').attr('data-accordion-item', ''); |
|
$liHeadsA.addClass('accordion-title'); |
|
}); |
|
} else if (toSet === 'tabs') { |
|
var $tabsContent = $('[data-tabs-content=' + _this.$element.attr('id') + ']'); |
|
var $placeholder = $('#tabs-placeholder-' + _this.$element.attr('id')); |
|
if ($placeholder.length) { |
|
$tabsContent = $('<div class="tabs-content"></div>').insertAfter($placeholder).attr('data-tabs-content', _this.$element.attr('id')); |
|
$placeholder.remove(); |
|
} else { |
|
$tabsContent = $('<div class="tabs-content"></div>').insertAfter(_this.$element).attr('data-tabs-content', _this.$element.attr('id')); |
|
}; |
|
$panels.each(function (key, value) { |
|
var tempValue = $(value).appendTo($tabsContent).addClass(tabsPanel); |
|
var hash = $liHeadsA.get(key).hash.slice(1); |
|
var id = $(value).attr('id') || Foundation.GetYoDigits(6, 'accordion'); |
|
if (hash !== id) { |
|
if (hash !== '') { |
|
$(value).attr('id', hash); |
|
} else { |
|
hash = id; |
|
$(value).attr('id', hash); |
|
$($liHeadsA.get(key)).attr('href', $($liHeadsA.get(key)).attr('href').replace('#', '') + '#' + hash); |
|
}; |
|
}; |
|
var isActive = $($liHeads.get(key)).hasClass('is-active'); |
|
if (isActive) { |
|
tempValue.addClass('is-active'); |
|
}; |
|
}); |
|
$liHeads.addClass(tabsTitle); |
|
}; |
|
} |
|
|
|
/** |
|
* 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() { |
|
if (this.currentPlugin) this.currentPlugin.destroy(); |
|
$(window).off('.zf.ResponsiveAccordionTabs'); |
|
Foundation.unregisterPlugin(this); |
|
} |
|
}]); |
|
|
|
return ResponsiveAccordionTabs; |
|
}(); |
|
|
|
ResponsiveAccordionTabs.defaults = {}; |
|
|
|
// The plugin matches the plugin classes with these plugin instances. |
|
var MenuPlugins = { |
|
tabs: { |
|
cssClass: 'tabs', |
|
plugin: Foundation._plugins.tabs || null |
|
}, |
|
accordion: { |
|
cssClass: 'accordion', |
|
plugin: Foundation._plugins.accordion || null |
|
} |
|
}; |
|
|
|
// Window exports |
|
Foundation.plugin(ResponsiveAccordionTabs, 'ResponsiveAccordionTabs'); |
|
}(jQuery); |
|
"use strict"; |
|
|
|
(function ($) { |
|
//$('p').remove(); |
|
|
|
$(document).foundation(); |
|
})(jQuery); |
|
//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["what-input.js","foundation.core.js","foundation.util.box.js","foundation.util.keyboard.js","foundation.util.mediaQuery.js","foundation.util.motion.js","foundation.util.nest.js","foundation.util.timerAndImageLoader.js","foundation.util.touch.js","foundation.util.triggers.js","foundation.abide.js","foundation.accordion.js","foundation.accordionMenu.js","foundation.drilldown.js","foundation.dropdown.js","foundation.dropdownMenu.js","foundation.equalizer.js","foundation.interchange.js","foundation.magellan.js","foundation.offcanvas.js","foundation.orbit.js","foundation.responsiveMenu.js","foundation.responsiveToggle.js","foundation.reveal.js","foundation.slider.js","foundation.sticky.js","foundation.tabs.js","foundation.toggler.js","foundation.tooltip.js","foundation.zf.responsiveAccordionTabs.js","app.js"],"names":["$","FOUNDATION_VERSION","Foundation","version","_plugins","_uuids","rtl","attr","plugin","name","className","functionName","attrName","hyphenate","registerPlugin","pluginName","constructor","toLowerCase","uuid","GetYoDigits","$element","data","trigger","push","unregisterPlugin","splice","indexOf","removeAttr","removeData","prop","reInit","plugins","isJQ","each","_init","type","_this","fns","plgs","forEach","p","foundation","Object","keys","err","console","error","length","namespace","Math","round","pow","random","toString","slice","reflow","elem","i","$elem","find","addBack","$el","opts","warn","thing","split","e","opt","map","el","trim","parseValue","er","getFnName","transitionend","transitions","document","createElement","end","t","style","setTimeout","triggerHandler","util","throttle","func","delay","timer","context","args","arguments","apply","method","$meta","$noJS","appendTo","head","removeClass","MediaQuery","Array","prototype","call","plugClass","undefined","ReferenceError","TypeError","window","fn","Date","now","getTime","vendors","requestAnimationFrame","vp","cancelAnimationFrame","test","navigator","userAgent","lastTime","callback","nextTime","max","clearTimeout","performance","start","Function","bind","oThis","aArgs","fToBind","fNOP","fBound","concat","funcNameRegex","results","exec","str","isNaN","parseFloat","replace","jQuery","Box","ImNotTouchingYou","GetDimensions","GetOffsets","element","parent","lrOnly","tbOnly","eleDims","top","bottom","left","right","parDims","offset","height","width","windowDims","allDirs","Error","rect","getBoundingClientRect","parRect","parentNode","winRect","body","winY","pageYOffset","winX","pageXOffset","parentDims","anchor","position","vOffset","hOffset","isOverflow","$eleDims","$anchorDims","keyCodes","commands","Keyboard","getKeyCodes","parseKey","event","key","which","keyCode","String","fromCharCode","toUpperCase","shiftKey","ctrlKey","altKey","handleKey","component","functions","commandList","cmds","command","ltr","extend","returnValue","handled","unhandled","findFocusable","filter","is","register","componentName","trapFocus","$focusable","$firstFocusable","eq","$lastFocusable","on","target","preventDefault","focus","releaseFocus","off","kcs","k","kc","defaultQueries","landscape","portrait","retina","queries","current","self","extractedStyles","css","namedQueries","parseStyleToObject","hasOwnProperty","value","_getCurrentSize","_watcher","atLeast","size","query","get","matchMedia","matches","matched","newSize","currentSize","styleMedia","media","script","getElementsByTagName","info","id","insertBefore","getComputedStyle","currentStyle","matchMedium","text","styleSheet","cssText","textContent","styleObject","reduce","ret","param","parts","val","decodeURIComponent","isArray","initClasses","activeClasses","Motion","animateIn","animation","cb","animate","animateOut","Move","duration","anim","prog","move","ts","isIn","initClass","activeClass","reset","addClass","show","offsetWidth","one","finish","hide","transitionDuration","Nest","Feather","menu","items","subMenuClass","subItemClass","hasSubClass","$item","$sub","children","Burn","Timer","options","nameSpace","remain","isPaused","restart","infinite","pause","onImagesLoaded","images","unloaded","complete","readyState","singleImageLoaded","src","spotSwipe","enabled","documentElement","moveThreshold","timeThreshold","startPosX","startPosY","startTime","elapsedTime","isMoving","onTouchEnd","removeEventListener","onTouchMove","x","touches","pageX","y","pageY","dx","dy","dir","abs","onTouchStart","addEventListener","init","teardown","special","swipe","setup","noop","addTouch","handleTouch","changedTouches","first","eventTypes","touchstart","touchmove","touchend","simulatedEvent","MouseEvent","screenX","screenY","clientX","clientY","createEvent","initMouseEvent","dispatchEvent","MutationObserver","prefixes","triggers","stopPropagation","fadeOut","checkListeners","eventsListener","resizeListener","scrollListener","closemeListener","yetiBoxes","plugNames","listeners","join","pluginId","not","debounce","$nodes","nodes","querySelectorAll","listeningElementsMutation","mutationRecordsList","$target","attributeName","closest","elementObserver","observe","attributes","childList","characterData","subtree","attributeFilter","IHearYou","Abide","defaults","$inputs","_events","resetForm","validateForm","validateOn","validateInput","liveValidate","validateOnBlur","isGood","checked","$error","siblings","formErrorSelector","add","$label","$els","labels","findLabel","$formError","findFormError","labelErrorClass","formErrorClass","inputErrorClass","groupName","$labels","findRadioLabels","$formErrors","removeRadioErrorClasses","clearRequire","requiredCheck","validated","customValidator","validator","equalTo","validateRadio","validateText","matchValidation","validators","goodToGo","message","dependentElements","acc","noError","pattern","inputText","valid","patterns","RegExp","$group","required","clear","v","$form","removeErrorClasses","alpha","alpha_numeric","integer","number","card","cvv","email","url","domain","datetime","date","time","dateISO","month_day_year","day_month_year","color","Accordion","$tabs","idx","$content","linkId","$initActive","firstTimeInit","down","_checkDeepLink","location","hash","$link","$anchor","hasClass","deepLinkSmudge","load","scrollTop","deepLinkSmudgeDelay","deepLink","$tabContent","toggle","next","$a","multiExpand","previous","prev","up","updateHistory","history","pushState","replaceState","firstTime","$currentActive","slideDown","slideSpeed","$aunts","allowAllClosed","slideUp","stop","AccordionMenu","multiOpen","$menuLinks","subId","isActive","initPanes","$submenu","$elements","$prevElement","$nextElement","min","parents","open","close","closeAll","hideAll","stopImmediatePropagation","parentsUntil","$menus","Drilldown","$submenuAnchors","$submenus","$menuItems","_prepareMenu","_registerEvents","_keyboardEvents","parentLink","clone","prependTo","wrap","$menu","$back","backButtonPosition","append","backButton","prepend","_back","autoHeight","$wrapper","wrapper","animateHeight","_getMaxDims","_show","closeOnClick","$body","contains","_hideAll","_resize","_bindHandler","_scrollTop","$scrollTopElement","scrollTopElement","scrollPos","parseInt","scrollTopOffset","animationDuration","animationEasing","_hide","parentSubMenu","blur","maxHeight","result","numOfElems","unwrap","remove","Dropdown","$id","parentClass","$parent","positionClass","getPositionClass","counter","usedPositions","verticalPosition","match","horizontalPosition","classChanged","direction","newWidth","parentHOffset","$parentDims","_reposition","_setPosition","hover","bodyData","whatinput","timeout","hoverDelay","hoverPane","visibleFocusableElements","autoFocus","_addBodyHandler","curPositionClass","DropdownMenu","subs","verticalClass","rightClass","alignment","changed","hasTouch","ontouchstart","parClass","handleClickFn","hasSub","hasClicked","clickOpen","forceFollow","closeOnClickInside","disableHover","autoclose","closingTime","isTab","index","nextSibling","prevSibling","openSub","closeSub","_isVertical","$sibs","oldClass","$parentLi","$toClose","somethingToClose","Equalizer","eqId","$watched","hasNested","isNested","isOn","onResizeMeBound","_onResizeMe","onPostEqualizedBound","_onPostEqualized","imgs","tooSmall","equalizeOn","_checkMQ","_reflow","_pauseEvents","equalizeOnStack","_isStacked","equalizeByRow","getHeightsByRow","applyHeightByRow","getHeights","applyHeight","heights","len","offsetHeight","lastElTopOffset","groups","group","elOffsetTop","j","ln","groupsILength","lenJ","Interchange","rules","currentPath","_addBreakpoints","_generateRules","rule","path","SPECIAL_QUERIES","rulesList","nodeName","response","html","Magellan","calcPoints","$targets","$links","$active","points","winHeight","innerHeight","clientHeight","docHeight","scrollHeight","$tar","pt","threshold","targetPoint","easing","deepLinking","scrollToLoc","_updateActive","arrival","getAttribute","loc","_inTransition","barOffset","winPos","curIdx","isDown","curVisible","OffCanvas","$lastTrigger","$triggers","transition","contentOverlay","overlay","overlayPosition","setAttribute","$overlay","isRevealed","revealClass","revealOn","_setMQChecker","transitionTime","_handleKeyboard","reveal","$closer","allowUp","allowDown","lastY","originalEvent","forceTo","scrollTo","contentScroll","_stopScrolling","_recordScrollable","_stopScrollPropagation","canvasFocus","Orbit","_reset","containerClass","$slides","slideClass","$images","initActive","useMUI","_prepareForOrbit","bullets","_loadBullets","autoPlay","geoSync","accessible","$bullets","boxOfBullets","timerDelay","changeSlide","_setWrapperHeight","temp","pauseOnHover","navButtons","$controls","nextClass","prevClass","$slide","_updateBullets","isLTR","chosenSlide","$curSlide","$firstSlide","$lastSlide","last","dirIn","dirOut","$newSlide","infiniteWrap","$oldBullet","span","detach","$newBullet","animInFromRight","animOutToRight","animInFromLeft","animOutToLeft","ResponsiveMenu","currentMq","currentPlugin","rulesTree","ruleSize","rulePlugin","MenuPlugins","isEmptyObject","_checkMediaQueries","matchedMq","cssClass","destroy","dropdown","drilldown","accordion","ResponsiveToggle","targetID","$targetMenu","$toggler","input","animationIn","animationOut","_update","_updateMqHandler","toggleMenu","hideFor","Reveal","cached","mq","isMobile","mobileSniff","fullScreen","_makeOverlay","outerWidth","outerHeight","margin","_updatePosition","_handleState","multipleOpened","addRevealOpenClasses","originalScrollPos","afterAnimation","focusableElements","showDelay","_extraHandlers","closeOnEsc","finishUp","hideDelay","resetOnClose","title","href","btmOffsetPct","iPhoneSniff","androidSniff","Slider","inputs","handles","$handle","$input","$fill","vertical","isDbl","disabled","disabledClass","binding","_setInitAttr","doubleSided","$handle2","$input2","setHandles","_setHandlePos","pctOfBar","percent","positionValueFunction","_logTransform","_powTransform","toFixed","baseLog","nonLinearBase","$hndl","noInvert","h2Val","step","h1Val","vert","hOrW","lOrT","handleDim","elemDim","_pctOfBar","pxToMove","movement","decimal","_setValues","isLeftHndl","dim","handlePct","handlePos","initialStart","moveTime","changedDelay","initVal","initialEnd","hasVal","eventOffset","halfOfHandle","barDim","windowScroll","scrollLeft","elemOffset","eventFromBar","barXY","offsetPct","_value","_adjustValue","firstHndlPos","absPosition","secndHndlPos","div","prev_val","next_val","_eventsForHandle","curHandle","_handleEvent","clickSelect","draggable","currentTarget","_$handle","oldValue","newValue","decrease","increase","decrease_fast","increase_fast","invertVertical","frac","num","clickPos","base","log","Sticky","wasWrapped","$container","container","wrapInner","stickyClass","scrollCount","checkEvery","isStuck","containerHeight","elemHeight","_parsePoints","_setSizes","scroll","_calc","_removeSticky","topPoint","reverse","topAnchor","btm","btmAnchor","pts","breaks","place","canStick","_eventsHandler","_pauseListeners","checkSizes","bottomPoint","_setSticky","stickTo","mrgn","notStuckTo","isTop","stickToTop","anchorPt","anchorHeight","topOrBottom","stickyOn","newElemWidth","comp","pdngl","pdngr","newContainerHeight","_setBreakPoints","mTop","emCalc","marginTop","mBtm","marginBottom","em","fontSize","Tabs","$tabTitles","linkClass","linkActiveClass","matchHeight","_setHeight","selectTab","_addKeyHandler","_addClickHandler","_setHeightMqHandler","_handleTabChange","wrapOnKeys","historyHandled","activeCollapse","_collapseTab","$oldTab","$tabLink","$targetContent","_openTab","panelActiveClass","$target_anchor","idStr","panelClass","panel","Toggler","toggleClass","_updateARIA","Tooltip","isClick","elemId","_getPositionClass","tipText","template","_buildTemplate","allowHtml","triggerClass","templateClasses","tooltipClass","$template","$tipDims","showOn","fadeIn","fadeInDuration","fadeOutDuration","isFocus","disableForTouch","touchCloseText","ResponsiveAccordionTabs","_getAllOptions","allOptions","obj","dummyPlugin","tmpPlugin","keyKey","objObj","storezfData","_handleMarkup","toSet","fromString","$panels","tabsTitle","tabsPanel","$liHeads","$liHeadsA","display","visibility","after","$tabsContent","$placeholder","insertAfter","tempValue","tabs"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AChVA,CAAC,UAASA,CAAT,EAAY;;AAEb;;AAEA,MAAIC,qBAAqB,OAAzB;;AAEA;AACA;AACA,MAAIC,aAAa;AACfC,aAASF,kBADM;;AAGf;;;AAGAG,cAAU,EANK;;AAQf;;;AAGAC,YAAQ,EAXO;;AAaf;;;AAGAC,SAAK,YAAU;AACb,aAAON,EAAE,MAAF,EAAUO,IAAV,CAAe,KAAf,MAA0B,KAAjC;AACD,KAlBc;AAmBf;;;;AAIAC,YAAQ,UAASA,MAAT,EAAiBC,IAAjB,EAAuB;AAC7B;AACA;AACA,UAAIC,YAAaD,QAAQE,aAAaH,MAAb,CAAzB;AACA;AACA;AACA,UAAII,WAAYC,UAAUH,SAAV,CAAhB;;AAEA;AACA,WAAKN,QAAL,CAAcQ,QAAd,IAA0B,KAAKF,SAAL,IAAkBF,MAA5C;AACD,KAjCc;AAkCf;;;;;;;;;AASAM,oBAAgB,UAASN,MAAT,EAAiBC,IAAjB,EAAsB;AACpC,UAAIM,aAAaN,OAAOI,UAAUJ,IAAV,CAAP,GAAyBE,aAAaH,OAAOQ,WAApB,EAAiCC,WAAjC,EAA1C;AACAT,aAAOU,IAAP,GAAc,KAAKC,WAAL,CAAiB,CAAjB,EAAoBJ,UAApB,CAAd;;AAEA,UAAG,CAACP,OAAOY,QAAP,CAAgBb,IAAhB,WAA6BQ,UA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","file":"app.js","sourcesContent":["/**\n * what-input - A global utility for tracking the current input method (mouse, keyboard or touch).\n * @version v4.0.6\n * @link https://github.com/ten1seven/what-input\n * @license MIT\n */\n(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"whatInput\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"whatInput\"] = factory();\n\telse\n\t\troot[\"whatInput\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n\n\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ function(module, exports) {\n\n\tmodule.exports = (function() {\n\n\t  /*\n\t    ---------------\n\t    Variables\n\t    ---------------\n\t  */\n\n\t  // cache document.documentElement\n\t  var docElem = document.documentElement;\n\n\t  // last used input type\n\t  var currentInput = 'initial';\n\n\t  // last used input intent\n\t  var currentIntent = null;\n\n\t  // form input types\n\t  var formInputs = [\n\t    'input',\n\t    'select',\n\t    'textarea'\n\t  ];\n\n\t  // list of modifier keys commonly used with the mouse and\n\t  // can be safely ignored to prevent false keyboard detection\n\t  var ignoreMap = [\n\t    16, // shift\n\t    17, // control\n\t    18, // alt\n\t    91, // Windows key / left Apple cmd\n\t    93  // Windows menu / right Apple cmd\n\t  ];\n\n\t  // mapping of events to input types\n\t  var inputMap = {\n\t    'keyup': 'keyboard',\n\t    'mousedown': 'mouse',\n\t    'mousemove': 'mouse',\n\t    'MSPointerDown': 'pointer',\n\t    'MSPointerMove': 'pointer',\n\t    'pointerdown': 'pointer',\n\t    'pointermove': 'pointer',\n\t    'touchstart': 'touch'\n\t  };\n\n\t  // array of all used input types\n\t  var inputTypes = [];\n\n\t  // boolean: true if touch buffer timer is running\n\t  var isBuffering = false;\n\n\t  // map of IE 10 pointer events\n\t  var pointerMap = {\n\t    2: 'touch',\n\t    3: 'touch', // treat pen like touch\n\t    4: 'mouse'\n\t  };\n\n\t  // touch buffer timer\n\t  var touchTimer = null;\n\n\n\t  /*\n\t    ---------------\n\t    Set up\n\t    ---------------\n\t  */\n\n\t  var setUp = function() {\n\n\t    // add correct mouse wheel event mapping to `inputMap`\n\t    inputMap[detectWheel()] = 'mouse';\n\n\t    addListeners();\n\t    setInput();\n\t  };\n\n\n\t  /*\n\t    ---------------\n\t    Events\n\t    ---------------\n\t  */\n\n\t  var addListeners = function() {\n\n\t    // `pointermove`, `MSPointerMove`, `mousemove` and mouse wheel event binding\n\t    // can only demonstrate potential, but not actual, interaction\n\t    // and are treated separately\n\n\t    // pointer events (mouse, pen, touch)\n\t    if (window.PointerEvent) {\n\t      docElem.addEventListener('pointerdown', updateInput);\n\t      docElem.addEventListener('pointermove', setIntent);\n\t    } else if (window.MSPointerEvent) {\n\t      docElem.addEventListener('MSPointerDown', updateInput);\n\t      docElem.addEventListener('MSPointerMove', setIntent);\n\t    } else {\n\n\t      // mouse events\n\t      docElem.addEventListener('mousedown', updateInput);\n\t      docElem.addEventListener('mousemove', setIntent);\n\n\t      // touch events\n\t      if ('ontouchstart' in window) {\n\t        docElem.addEventListener('touchstart', touchBuffer);\n\t      }\n\t    }\n\n\t    // mouse wheel\n\t    docElem.addEventListener(detectWheel(), setIntent);\n\n\t    // keyboard events\n\t    docElem.addEventListener('keydown', updateInput);\n\t    docElem.addEventListener('keyup', updateInput);\n\t  };\n\n\t  // checks conditions before updating new input\n\t  var updateInput = function(event) {\n\n\t    // only execute if the touch buffer timer isn't running\n\t    if (!isBuffering) {\n\t      var eventKey = event.which;\n\t      var value = inputMap[event.type];\n\t      if (value === 'pointer') value = pointerType(event);\n\n\t      if (\n\t        currentInput !== value ||\n\t        currentIntent !== value\n\t      ) {\n\n\t        var activeElem = document.activeElement;\n\t        var activeInput = (\n\t          activeElem &&\n\t          activeElem.nodeName &&\n\t          formInputs.indexOf(activeElem.nodeName.toLowerCase()) === -1\n\t        ) ? true : false;\n\n\t        if (\n\t          value === 'touch' ||\n\n\t          // ignore mouse modifier keys\n\t          (value === 'mouse' && ignoreMap.indexOf(eventKey) === -1) ||\n\n\t          // don't switch if the current element is a form input\n\t          (value === 'keyboard' && activeInput)\n\t        ) {\n\n\t          // set the current and catch-all variable\n\t          currentInput = currentIntent = value;\n\n\t          setInput();\n\t        }\n\t      }\n\t    }\n\t  };\n\n\t  // updates the doc and `inputTypes` array with new input\n\t  var setInput = function() {\n\t    docElem.setAttribute('data-whatinput', currentInput);\n\t    docElem.setAttribute('data-whatintent', currentInput);\n\n\t    if (inputTypes.indexOf(currentInput) === -1) {\n\t      inputTypes.push(currentInput);\n\t      docElem.className += ' whatinput-types-' + currentInput;\n\t    }\n\t  };\n\n\t  // updates input intent for `mousemove` and `pointermove`\n\t  var setIntent = function(event) {\n\n\t    // only execute if the touch buffer timer isn't running\n\t    if (!isBuffering) {\n\t      var value = inputMap[event.type];\n\t      if (value === 'pointer') value = pointerType(event);\n\n\t      if (currentIntent !== value) {\n\t        currentIntent = value;\n\n\t        docElem.setAttribute('data-whatintent', currentIntent);\n\t      }\n\t    }\n\t  };\n\n\t  // buffers touch events because they frequently also fire mouse events\n\t  var touchBuffer = function(event) {\n\n\t    // clear the timer if it happens to be running\n\t    window.clearTimeout(touchTimer);\n\n\t    // set the current input\n\t    updateInput(event);\n\n\t    // set the isBuffering to `true`\n\t    isBuffering = true;\n\n\t    // run the timer\n\t    touchTimer = window.setTimeout(function() {\n\n\t      // if the timer runs out, set isBuffering back to `false`\n\t      isBuffering = false;\n\t    }, 200);\n\t  };\n\n\n\t  /*\n\t    ---------------\n\t    Utilities\n\t    ---------------\n\t  */\n\n\t  var pointerType = function(event) {\n\t   if (typeof event.pointerType === 'number') {\n\t      return pointerMap[event.pointerType];\n\t   } else {\n\t      return (event.pointerType === 'pen') ? 'touch' : event.pointerType; // treat pen like touch\n\t   }\n\t  };\n\n\t  // detect version of mouse wheel event to use\n\t  // via https://developer.mozilla.org/en-US/docs/Web/Events/wheel\n\t  var detectWheel = function() {\n\t    return 'onwheel' in document.createElement('div') ?\n\t      'wheel' : // Modern browsers support \"wheel\"\n\n\t      document.onmousewheel !== undefined ?\n\t        'mousewheel' : // Webkit and IE support at least \"mousewheel\"\n\t        'DOMMouseScroll'; // let's assume that remaining browsers are older Firefox\n\t  };\n\n\n\t  /*\n\t    ---------------\n\t    Init\n\n\t    don't start script unless browser cuts the mustard\n\t    (also passes if polyfills are used)\n\t    ---------------\n\t  */\n\n\t  if (\n\t    'addEventListener' in window &&\n\t    Array.prototype.indexOf\n\t  ) {\n\t    setUp();\n\t  }\n\n\n\t  /*\n\t    ---------------\n\t    API\n\t    ---------------\n\t  */\n\n\t  return {\n\n\t    // returns string: the current input type\n\t    // opt: 'loose'|'strict'\n\t    // 'strict' (default): returns the same value as the `data-whatinput` attribute\n\t    // 'loose': includes `data-whatintent` value if it's more current than `data-whatinput`\n\t    ask: function(opt) { return (opt === 'loose') ? currentIntent : currentInput; },\n\n\t    // returns array: all the detected input types\n\t    types: function() { return inputTypes; }\n\n\t  };\n\n\t}());\n\n\n/***/ }\n/******/ ])\n});\n;","!function($) {\n\n\"use strict\";\n\nvar FOUNDATION_VERSION = '6.3.1';\n\n// Global Foundation object\n// This is attached to the window, or used as a module for AMD/Browserify\nvar Foundation = {\n  version: FOUNDATION_VERSION,\n\n  /**\n   * Stores initialized plugins.\n   */\n  _plugins: {},\n\n  /**\n   * Stores generated unique ids for plugin instances\n   */\n  _uuids: [],\n\n  /**\n   * Returns a boolean for RTL support\n   */\n  rtl: function(){\n    return $('html').attr('dir') === 'rtl';\n  },\n  /**\n   * Defines a Foundation plugin, adding it to the `Foundation` namespace and the list of plugins to initialize when reflowing.\n   * @param {Object} plugin - The constructor of the plugin.\n   */\n  plugin: function(plugin, name) {\n    // Object key to use when adding to global Foundation object\n    // Examples: Foundation.Reveal, Foundation.OffCanvas\n    var className = (name || functionName(plugin));\n    // Object key to use when storing the plugin, also used to create the identifying data attribute for the plugin\n    // Examples: data-reveal, data-off-canvas\n    var attrName  = hyphenate(className);\n\n    // Add to the Foundation object and the plugins list (for reflowing)\n    this._plugins[attrName] = this[className] = plugin;\n  },\n  /**\n   * @function\n   * Populates the _uuids array with pointers to each individual plugin instance.\n   * Adds the `zfPlugin` data-attribute to programmatically created plugins to allow use of $(selector).foundation(method) calls.\n   * Also fires the initialization event for each plugin, consolidating repetitive code.\n   * @param {Object} plugin - an instance of a plugin, usually `this` in context.\n   * @param {String} name - the name of the plugin, passed as a camelCased string.\n   * @fires Plugin#init\n   */\n  registerPlugin: function(plugin, name){\n    var pluginName = name ? hyphenate(name) : functionName(plugin.constructor).toLowerCase();\n    plugin.uuid = this.GetYoDigits(6, pluginName);\n\n    if(!plugin.$element.attr(`data-${pluginName}`)){ plugin.$element.attr(`data-${pluginName}`, plugin.uuid); }\n    if(!plugin.$element.data('zfPlugin')){ plugin.$element.data('zfPlugin', plugin); }\n          /**\n           * Fires when the plugin has initialized.\n           * @event Plugin#init\n           */\n    plugin.$element.trigger(`init.zf.${pluginName}`);\n\n    this._uuids.push(plugin.uuid);\n\n    return;\n  },\n  /**\n   * @function\n   * Removes the plugins uuid from the _uuids array.\n   * Removes the zfPlugin data attribute, as well as the data-plugin-name attribute.\n   * Also fires the destroyed event for the plugin, consolidating repetitive code.\n   * @param {Object} plugin - an instance of a plugin, usually `this` in context.\n   * @fires Plugin#destroyed\n   */\n  unregisterPlugin: function(plugin){\n    var pluginName = hyphenate(functionName(plugin.$element.data('zfPlugin').constructor));\n\n    this._uuids.splice(this._uuids.indexOf(plugin.uuid), 1);\n    plugin.$element.removeAttr(`data-${pluginName}`).removeData('zfPlugin')\n          /**\n           * Fires when the plugin has been destroyed.\n           * @event Plugin#destroyed\n           */\n          .trigger(`destroyed.zf.${pluginName}`);\n    for(var prop in plugin){\n      plugin[prop] = null;//clean up script to prep for garbage collection.\n    }\n    return;\n  },\n\n  /**\n   * @function\n   * Causes one or more active plugins to re-initialize, resetting event listeners, recalculating positions, etc.\n   * @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'`\n   * @default If no argument is passed, reflow all currently active plugins.\n   */\n   reInit: function(plugins){\n     var isJQ = plugins instanceof $;\n     try{\n       if(isJQ){\n         plugins.each(function(){\n           $(this).data('zfPlugin')._init();\n         });\n       }else{\n         var type = typeof plugins,\n         _this = this,\n         fns = {\n           'object': function(plgs){\n             plgs.forEach(function(p){\n               p = hyphenate(p);\n               $('[data-'+ p +']').foundation('_init');\n             });\n           },\n           'string': function(){\n             plugins = hyphenate(plugins);\n             $('[data-'+ plugins +']').foundation('_init');\n           },\n           'undefined': function(){\n             this['object'](Object.keys(_this._plugins));\n           }\n         };\n         fns[type](plugins);\n       }\n     }catch(err){\n       console.error(err);\n     }finally{\n       return plugins;\n     }\n   },\n\n  /**\n   * returns a random base-36 uid with namespacing\n   * @function\n   * @param {Number} length - number of random base-36 digits desired. Increase for more random strings.\n   * @param {String} namespace - name of plugin to be incorporated in uid, optional.\n   * @default {String} '' - if no plugin name is provided, nothing is appended to the uid.\n   * @returns {String} - unique id\n   */\n  GetYoDigits: function(length, namespace){\n    length = length || 6;\n    return Math.round((Math.pow(36, length + 1) - Math.random() * Math.pow(36, length))).toString(36).slice(1) + (namespace ? `-${namespace}` : '');\n  },\n  /**\n   * Initialize plugins on any elements within `elem` (and `elem` itself) that aren't already initialized.\n   * @param {Object} elem - jQuery object containing the element to check inside. Also checks the element itself, unless it's the `document` object.\n   * @param {String|Array} plugins - A list of plugins to initialize. Leave this out to initialize everything.\n   */\n  reflow: function(elem, plugins) {\n\n    // If plugins is undefined, just grab everything\n    if (typeof plugins === 'undefined') {\n      plugins = Object.keys(this._plugins);\n    }\n    // If plugins is a string, convert it to an array with one item\n    else if (typeof plugins === 'string') {\n      plugins = [plugins];\n    }\n\n    var _this = this;\n\n    // Iterate through each plugin\n    $.each(plugins, function(i, name) {\n      // Get the current plugin\n      var plugin = _this._plugins[name];\n\n      // Localize the search to all elements inside elem, as well as elem itself, unless elem === document\n      var $elem = $(elem).find('[data-'+name+']').addBack('[data-'+name+']');\n\n      // For each plugin found, initialize it\n      $elem.each(function() {\n        var $el = $(this),\n            opts = {};\n        // Don't double-dip on plugins\n        if ($el.data('zfPlugin')) {\n          console.warn(\"Tried to initialize \"+name+\" on an element that already has a Foundation plugin.\");\n          return;\n        }\n\n        if($el.attr('data-options')){\n          var thing = $el.attr('data-options').split(';').forEach(function(e, i){\n            var opt = e.split(':').map(function(el){ return el.trim(); });\n            if(opt[0]) opts[opt[0]] = parseValue(opt[1]);\n          });\n        }\n        try{\n          $el.data('zfPlugin', new plugin($(this), opts));\n        }catch(er){\n          console.error(er);\n        }finally{\n          return;\n        }\n      });\n    });\n  },\n  getFnName: functionName,\n  transitionend: function($elem){\n    var transitions = {\n      'transition': 'transitionend',\n      'WebkitTransition': 'webkitTransitionEnd',\n      'MozTransition': 'transitionend',\n      'OTransition': 'otransitionend'\n    };\n    var elem = document.createElement('div'),\n        end;\n\n    for (var t in transitions){\n      if (typeof elem.style[t] !== 'undefined'){\n        end = transitions[t];\n      }\n    }\n    if(end){\n      return end;\n    }else{\n      end = setTimeout(function(){\n        $elem.triggerHandler('transitionend', [$elem]);\n      }, 1);\n      return 'transitionend';\n    }\n  }\n};\n\nFoundation.util = {\n  /**\n   * Function for applying a debounce effect to a function call.\n   * @function\n   * @param {Function} func - Function to be called at end of timeout.\n   * @param {Number} delay - Time in ms to delay the call of `func`.\n   * @returns function\n   */\n  throttle: function (func, delay) {\n    var timer = null;\n\n    return function () {\n      var context = this, args = arguments;\n\n      if (timer === null) {\n        timer = setTimeout(function () {\n          func.apply(context, args);\n          timer = null;\n        }, delay);\n      }\n    };\n  }\n};\n\n// TODO: consider not making this a jQuery function\n// TODO: need way to reflow vs. re-initialize\n/**\n * The Foundation jQuery method.\n * @param {String|Array} method - An action to perform on the current jQuery object.\n */\nvar foundation = function(method) {\n  var type = typeof method,\n      $meta = $('meta.foundation-mq'),\n      $noJS = $('.no-js');\n\n  if(!$meta.length){\n    $('<meta class=\"foundation-mq\">').appendTo(document.head);\n  }\n  if($noJS.length){\n    $noJS.removeClass('no-js');\n  }\n\n  if(type === 'undefined'){//needs to initialize the Foundation object, or an individual plugin.\n    Foundation.MediaQuery._init();\n    Foundation.reflow(this);\n  }else if(type === 'string'){//an individual method to invoke on a plugin or group of plugins\n    var args = Array.prototype.slice.call(arguments, 1);//collect all the arguments, if necessary\n    var plugClass = this.data('zfPlugin');//determine the class of plugin\n\n    if(plugClass !== undefined && plugClass[method] !== undefined){//make sure both the class and method exist\n      if(this.length === 1){//if there's only one, call it directly.\n          plugClass[method].apply(plugClass, args);\n      }else{\n        this.each(function(i, el){//otherwise loop through the jQuery collection and invoke the method on each\n          plugClass[method].apply($(el).data('zfPlugin'), args);\n        });\n      }\n    }else{//error for no class or no method\n      throw new ReferenceError(\"We're sorry, '\" + method + \"' is not an available method for \" + (plugClass ? functionName(plugClass) : 'this element') + '.');\n    }\n  }else{//error for invalid argument type\n    throw new TypeError(`We're sorry, ${type} is not a valid parameter. You must use a string representing the method you wish to invoke.`);\n  }\n  return this;\n};\n\nwindow.Foundation = Foundation;\n$.fn.foundation = foundation;\n\n// Polyfill for requestAnimationFrame\n(function() {\n  if (!Date.now || !window.Date.now)\n    window.Date.now = Date.now = function() { return new Date().getTime(); };\n\n  var vendors = ['webkit', 'moz'];\n  for (var i = 0; i < vendors.length && !window.requestAnimationFrame; ++i) {\n      var vp = vendors[i];\n      window.requestAnimationFrame = window[vp+'RequestAnimationFrame'];\n      window.cancelAnimationFrame = (window[vp+'CancelAnimationFrame']\n                                 || window[vp+'CancelRequestAnimationFrame']);\n  }\n  if (/iP(ad|hone|od).*OS 6/.test(window.navigator.userAgent)\n    || !window.requestAnimationFrame || !window.cancelAnimationFrame) {\n    var lastTime = 0;\n    window.requestAnimationFrame = function(callback) {\n        var now = Date.now();\n        var nextTime = Math.max(lastTime + 16, now);\n        return setTimeout(function() { callback(lastTime = nextTime); },\n                          nextTime - now);\n    };\n    window.cancelAnimationFrame = clearTimeout;\n  }\n  /**\n   * Polyfill for performance.now, required by rAF\n   */\n  if(!window.performance || !window.performance.now){\n    window.performance = {\n      start: Date.now(),\n      now: function(){ return Date.now() - this.start; }\n    };\n  }\n})();\nif (!Function.prototype.bind) {\n  Function.prototype.bind = function(oThis) {\n    if (typeof this !== 'function') {\n      // closest thing possible to the ECMAScript 5\n      // internal IsCallable function\n      throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable');\n    }\n\n    var aArgs   = Array.prototype.slice.call(arguments, 1),\n        fToBind = this,\n        fNOP    = function() {},\n        fBound  = function() {\n          return fToBind.apply(this instanceof fNOP\n                 ? this\n                 : oThis,\n                 aArgs.concat(Array.prototype.slice.call(arguments)));\n        };\n\n    if (this.prototype) {\n      // native functions don't have a prototype\n      fNOP.prototype = this.prototype;\n    }\n    fBound.prototype = new fNOP();\n\n    return fBound;\n  };\n}\n// Polyfill to get the name of a function in IE9\nfunction functionName(fn) {\n  if (Function.prototype.name === undefined) {\n    var funcNameRegex = /function\\s([^(]{1,})\\(/;\n    var results = (funcNameRegex).exec((fn).toString());\n    return (results && results.length > 1) ? results[1].trim() : \"\";\n  }\n  else if (fn.prototype === undefined) {\n    return fn.constructor.name;\n  }\n  else {\n    return fn.prototype.constructor.name;\n  }\n}\nfunction parseValue(str){\n  if ('true' === str) return true;\n  else if ('false' === str) return false;\n  else if (!isNaN(str * 1)) return parseFloat(str);\n  return str;\n}\n// Convert PascalCase to kebab-case\n// Thank you: http://stackoverflow.com/a/8955580\nfunction hyphenate(str) {\n  return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();\n}\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\nFoundation.Box = {\n  ImNotTouchingYou: ImNotTouchingYou,\n  GetDimensions: GetDimensions,\n  GetOffsets: GetOffsets\n}\n\n/**\n * Compares the dimensions of an element to a container and determines collision events with container.\n * @function\n * @param {jQuery} element - jQuery object to test for collisions.\n * @param {jQuery} parent - jQuery object to use as bounding container.\n * @param {Boolean} lrOnly - set to true to check left and right values only.\n * @param {Boolean} tbOnly - set to true to check top and bottom values only.\n * @default if no parent object passed, detects collisions with `window`.\n * @returns {Boolean} - true if collision free, false if a collision in any direction.\n */\nfunction ImNotTouchingYou(element, parent, lrOnly, tbOnly) {\n  var eleDims = GetDimensions(element),\n      top, bottom, left, right;\n\n  if (parent) {\n    var parDims = GetDimensions(parent);\n\n    bottom = (eleDims.offset.top + eleDims.height <= parDims.height + parDims.offset.top);\n    top    = (eleDims.offset.top >= parDims.offset.top);\n    left   = (eleDims.offset.left >= parDims.offset.left);\n    right  = (eleDims.offset.left + eleDims.width <= parDims.width + parDims.offset.left);\n  }\n  else {\n    bottom = (eleDims.offset.top + eleDims.height <= eleDims.windowDims.height + eleDims.windowDims.offset.top);\n    top    = (eleDims.offset.top >= eleDims.windowDims.offset.top);\n    left   = (eleDims.offset.left >= eleDims.windowDims.offset.left);\n    right  = (eleDims.offset.left + eleDims.width <= eleDims.windowDims.width);\n  }\n\n  var allDirs = [bottom, top, left, right];\n\n  if (lrOnly) {\n    return left === right === true;\n  }\n\n  if (tbOnly) {\n    return top === bottom === true;\n  }\n\n  return allDirs.indexOf(false) === -1;\n};\n\n/**\n * Uses native methods to return an object of dimension values.\n * @function\n * @param {jQuery || HTML} element - jQuery object or DOM element for which to get the dimensions. Can be any element other that document or window.\n * @returns {Object} - nested object of integer pixel values\n * TODO - if element is window, return only those values.\n */\nfunction GetDimensions(elem, test){\n  elem = elem.length ? elem[0] : elem;\n\n  if (elem === window || elem === document) {\n    throw new Error(\"I'm sorry, Dave. I'm afraid I can't do that.\");\n  }\n\n  var rect = elem.getBoundingClientRect(),\n      parRect = elem.parentNode.getBoundingClientRect(),\n      winRect = document.body.getBoundingClientRect(),\n      winY = window.pageYOffset,\n      winX = window.pageXOffset;\n\n  return {\n    width: rect.width,\n    height: rect.height,\n    offset: {\n      top: rect.top + winY,\n      left: rect.left + winX\n    },\n    parentDims: {\n      width: parRect.width,\n      height: parRect.height,\n      offset: {\n        top: parRect.top + winY,\n        left: parRect.left + winX\n      }\n    },\n    windowDims: {\n      width: winRect.width,\n      height: winRect.height,\n      offset: {\n        top: winY,\n        left: winX\n      }\n    }\n  }\n}\n\n/**\n * Returns an object of top and left integer pixel values for dynamically rendered elements,\n * such as: Tooltip, Reveal, and Dropdown\n * @function\n * @param {jQuery} element - jQuery object for the element being positioned.\n * @param {jQuery} anchor - jQuery object for the element's anchor point.\n * @param {String} position - a string relating to the desired position of the element, relative to it's anchor\n * @param {Number} vOffset - integer pixel value of desired vertical separation between anchor and element.\n * @param {Number} hOffset - integer pixel value of desired horizontal separation between anchor and element.\n * @param {Boolean} isOverflow - if a collision event is detected, sets to true to default the element to full width - any desired offset.\n * TODO alter/rewrite to work with `em` values as well/instead of pixels\n */\nfunction GetOffsets(element, anchor, position, vOffset, hOffset, isOverflow) {\n  var $eleDims = GetDimensions(element),\n      $anchorDims = anchor ? GetDimensions(anchor) : null;\n\n  switch (position) {\n    case 'top':\n      return {\n        left: (Foundation.rtl() ? $anchorDims.offset.left - $eleDims.width + $anchorDims.width : $anchorDims.offset.left),\n        top: $anchorDims.offset.top - ($eleDims.height + vOffset)\n      }\n      break;\n    case 'left':\n      return {\n        left: $anchorDims.offset.left - ($eleDims.width + hOffset),\n        top: $anchorDims.offset.top\n      }\n      break;\n    case 'right':\n      return {\n        left: $anchorDims.offset.left + $anchorDims.width + hOffset,\n        top: $anchorDims.offset.top\n      }\n      break;\n    case 'center top':\n      return {\n        left: ($anchorDims.offset.left + ($anchorDims.width / 2)) - ($eleDims.width / 2),\n        top: $anchorDims.offset.top - ($eleDims.height + vOffset)\n      }\n      break;\n    case 'center bottom':\n      return {\n        left: isOverflow ? hOffset : (($anchorDims.offset.left + ($anchorDims.width / 2)) - ($eleDims.width / 2)),\n        top: $anchorDims.offset.top + $anchorDims.height + vOffset\n      }\n      break;\n    case 'center left':\n      return {\n        left: $anchorDims.offset.left - ($eleDims.width + hOffset),\n        top: ($anchorDims.offset.top + ($anchorDims.height / 2)) - ($eleDims.height / 2)\n      }\n      break;\n    case 'center right':\n      return {\n        left: $anchorDims.offset.left + $anchorDims.width + hOffset + 1,\n        top: ($anchorDims.offset.top + ($anchorDims.height / 2)) - ($eleDims.height / 2)\n      }\n      break;\n    case 'center':\n      return {\n        left: ($eleDims.windowDims.offset.left + ($eleDims.windowDims.width / 2)) - ($eleDims.width / 2),\n        top: ($eleDims.windowDims.offset.top + ($eleDims.windowDims.height / 2)) - ($eleDims.height / 2)\n      }\n      break;\n    case 'reveal':\n      return {\n        left: ($eleDims.windowDims.width - $eleDims.width) / 2,\n        top: $eleDims.windowDims.offset.top + vOffset\n      }\n    case 'reveal full':\n      return {\n        left: $eleDims.windowDims.offset.left,\n        top: $eleDims.windowDims.offset.top\n      }\n      break;\n    case 'left bottom':\n      return {\n        left: $anchorDims.offset.left,\n        top: $anchorDims.offset.top + $anchorDims.height + vOffset\n      };\n      break;\n    case 'right bottom':\n      return {\n        left: $anchorDims.offset.left + $anchorDims.width + hOffset - $eleDims.width,\n        top: $anchorDims.offset.top + $anchorDims.height + vOffset\n      };\n      break;\n    default:\n      return {\n        left: (Foundation.rtl() ? $anchorDims.offset.left - $eleDims.width + $anchorDims.width : $anchorDims.offset.left + hOffset),\n        top: $anchorDims.offset.top + $anchorDims.height + vOffset\n      }\n  }\n}\n\n}(jQuery);\n","/*******************************************\n *                                         *\n * This util was created by Marius Olbertz *\n * Please thank Marius on GitHub /owlbertz *\n * or the web http://www.mariusolbertz.de/ *\n *                                         *\n ******************************************/\n\n'use strict';\n\n!function($) {\n\nconst keyCodes = {\n  9: 'TAB',\n  13: 'ENTER',\n  27: 'ESCAPE',\n  32: 'SPACE',\n  37: 'ARROW_LEFT',\n  38: 'ARROW_UP',\n  39: 'ARROW_RIGHT',\n  40: 'ARROW_DOWN'\n}\n\nvar commands = {}\n\nvar Keyboard = {\n  keys: getKeyCodes(keyCodes),\n\n  /**\n   * Parses the (keyboard) event and returns a String that represents its key\n   * Can be used like Foundation.parseKey(event) === Foundation.keys.SPACE\n   * @param {Event} event - the event generated by the event handler\n   * @return String key - String that represents the key pressed\n   */\n  parseKey(event) {\n    var key = keyCodes[event.which || event.keyCode] || String.fromCharCode(event.which).toUpperCase();\n\n    // Remove un-printable characters, e.g. for `fromCharCode` calls for CTRL only events\n    key = key.replace(/\\W+/, '');\n\n    if (event.shiftKey) key = `SHIFT_${key}`;\n    if (event.ctrlKey) key = `CTRL_${key}`;\n    if (event.altKey) key = `ALT_${key}`;\n\n    // Remove trailing underscore, in case only modifiers were used (e.g. only `CTRL_ALT`)\n    key = key.replace(/_$/, '');\n\n    return key;\n  },\n\n  /**\n   * Handles the given (keyboard) event\n   * @param {Event} event - the event generated by the event handler\n   * @param {String} component - Foundation component's name, e.g. Slider or Reveal\n   * @param {Objects} functions - collection of functions that are to be executed\n   */\n  handleKey(event, component, functions) {\n    var commandList = commands[component],\n      keyCode = this.parseKey(event),\n      cmds,\n      command,\n      fn;\n\n    if (!commandList) return console.warn('Component not defined!');\n\n    if (typeof commandList.ltr === 'undefined') { // this component does not differentiate between ltr and rtl\n        cmds = commandList; // use plain list\n    } else { // merge ltr and rtl: if document is rtl, rtl overwrites ltr and vice versa\n        if (Foundation.rtl()) cmds = $.extend({}, commandList.ltr, commandList.rtl);\n\n        else cmds = $.extend({}, commandList.rtl, commandList.ltr);\n    }\n    command = cmds[keyCode];\n\n    fn = functions[command];\n    if (fn && typeof fn === 'function') { // execute function  if exists\n      var returnValue = fn.apply();\n      if (functions.handled || typeof functions.handled === 'function') { // execute function when event was handled\n          functions.handled(returnValue);\n      }\n    } else {\n      if (functions.unhandled || typeof functions.unhandled === 'function') { // execute function when event was not handled\n          functions.unhandled();\n      }\n    }\n  },\n\n  /**\n   * Finds all focusable elements within the given `$element`\n   * @param {jQuery} $element - jQuery object to search within\n   * @return {jQuery} $focusable - all focusable elements within `$element`\n   */\n  findFocusable($element) {\n    if(!$element) {return false; }\n    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() {\n      if (!$(this).is(':visible') || $(this).attr('tabindex') < 0) { return false; } //only have visible elements and those that have a tabindex greater or equal 0\n      return true;\n    });\n  },\n\n  /**\n   * Returns the component name name\n   * @param {Object} component - Foundation component, e.g. Slider or Reveal\n   * @return String componentName\n   */\n\n  register(componentName, cmds) {\n    commands[componentName] = cmds;\n  },  \n\n  /**\n   * Traps the focus in the given element.\n   * @param  {jQuery} $element  jQuery object to trap the foucs into.\n   */\n  trapFocus($element) {\n    var $focusable = Foundation.Keyboard.findFocusable($element),\n        $firstFocusable = $focusable.eq(0),\n        $lastFocusable = $focusable.eq(-1);\n\n    $element.on('keydown.zf.trapfocus', function(event) {\n      if (event.target === $lastFocusable[0] && Foundation.Keyboard.parseKey(event) === 'TAB') {\n        event.preventDefault();\n        $firstFocusable.focus();\n      }\n      else if (event.target === $firstFocusable[0] && Foundation.Keyboard.parseKey(event) === 'SHIFT_TAB') {\n        event.preventDefault();\n        $lastFocusable.focus();\n      }\n    });\n  },\n  /**\n   * Releases the trapped focus from the given element.\n   * @param  {jQuery} $element  jQuery object to release the focus for.\n   */\n  releaseFocus($element) {\n    $element.off('keydown.zf.trapfocus');\n  }\n}\n\n/*\n * Constants for easier comparing.\n * Can be used like Foundation.parseKey(event) === Foundation.keys.SPACE\n */\nfunction getKeyCodes(kcs) {\n  var k = {};\n  for (var kc in kcs) k[kcs[kc]] = kcs[kc];\n  return k;\n}\n\nFoundation.Keyboard = Keyboard;\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n// Default set of media queries\nconst defaultQueries = {\n  'default' : 'only screen',\n  landscape : 'only screen and (orientation: landscape)',\n  portrait : 'only screen and (orientation: portrait)',\n  retina : 'only screen and (-webkit-min-device-pixel-ratio: 2),' +\n    'only screen and (min--moz-device-pixel-ratio: 2),' +\n    'only screen and (-o-min-device-pixel-ratio: 2/1),' +\n    'only screen and (min-device-pixel-ratio: 2),' +\n    'only screen and (min-resolution: 192dpi),' +\n    'only screen and (min-resolution: 2dppx)'\n};\n\nvar MediaQuery = {\n  queries: [],\n\n  current: '',\n\n  /**\n   * Initializes the media query helper, by extracting the breakpoint list from the CSS and activating the breakpoint watcher.\n   * @function\n   * @private\n   */\n  _init() {\n    var self = this;\n    var extractedStyles = $('.foundation-mq').css('font-family');\n    var namedQueries;\n\n    namedQueries = parseStyleToObject(extractedStyles);\n\n    for (var key in namedQueries) {\n      if(namedQueries.hasOwnProperty(key)) {\n        self.queries.push({\n          name: key,\n          value: `only screen and (min-width: ${namedQueries[key]})`\n        });\n      }\n    }\n\n    this.current = this._getCurrentSize();\n\n    this._watcher();\n  },\n\n  /**\n   * Checks if the screen is at least as wide as a breakpoint.\n   * @function\n   * @param {String} size - Name of the breakpoint to check.\n   * @returns {Boolean} `true` if the breakpoint matches, `false` if it's smaller.\n   */\n  atLeast(size) {\n    var query = this.get(size);\n\n    if (query) {\n      return window.matchMedia(query).matches;\n    }\n\n    return false;\n  },\n\n  /**\n   * Checks if the screen matches to a breakpoint.\n   * @function\n   * @param {String} size - Name of the breakpoint to check, either 'small only' or 'small'. Omitting 'only' falls back to using atLeast() method.\n   * @returns {Boolean} `true` if the breakpoint matches, `false` if it does not.\n   */\n  is(size) {\n    size = size.trim().split(' ');\n    if(size.length > 1 && size[1] === 'only') {\n      if(size[0] === this._getCurrentSize()) return true;\n    } else {\n      return this.atLeast(size[0]);\n    }\n    return false;\n  },\n\n  /**\n   * Gets the media query of a breakpoint.\n   * @function\n   * @param {String} size - Name of the breakpoint to get.\n   * @returns {String|null} - The media query of the breakpoint, or `null` if the breakpoint doesn't exist.\n   */\n  get(size) {\n    for (var i in this.queries) {\n      if(this.queries.hasOwnProperty(i)) {\n        var query = this.queries[i];\n        if (size === query.name) return query.value;\n      }\n    }\n\n    return null;\n  },\n\n  /**\n   * Gets the current breakpoint name by testing every breakpoint and returning the last one to match (the biggest one).\n   * @function\n   * @private\n   * @returns {String} Name of the current breakpoint.\n   */\n  _getCurrentSize() {\n    var matched;\n\n    for (var i = 0; i < this.queries.length; i++) {\n      var query = this.queries[i];\n\n      if (window.matchMedia(query.value).matches) {\n        matched = query;\n      }\n    }\n\n    if (typeof matched === 'object') {\n      return matched.name;\n    } else {\n      return matched;\n    }\n  },\n\n  /**\n   * Activates the breakpoint watcher, which fires an event on the window whenever the breakpoint changes.\n   * @function\n   * @private\n   */\n  _watcher() {\n    $(window).on('resize.zf.mediaquery', () => {\n      var newSize = this._getCurrentSize(), currentSize = this.current;\n\n      if (newSize !== currentSize) {\n        // Change the current media query\n        this.current = newSize;\n\n        // Broadcast the media query change on the window\n        $(window).trigger('changed.zf.mediaquery', [newSize, currentSize]);\n      }\n    });\n  }\n};\n\nFoundation.MediaQuery = MediaQuery;\n\n// matchMedia() polyfill - Test a CSS media type/query in JS.\n// Authors & copyright (c) 2012: Scott Jehl, Paul Irish, Nicholas Zakas, David Knight. Dual MIT/BSD license\nwindow.matchMedia || (window.matchMedia = function() {\n  'use strict';\n\n  // For browsers that support matchMedium api such as IE 9 and webkit\n  var styleMedia = (window.styleMedia || window.media);\n\n  // For those that don't support matchMedium\n  if (!styleMedia) {\n    var style   = document.createElement('style'),\n    script      = document.getElementsByTagName('script')[0],\n    info        = null;\n\n    style.type  = 'text/css';\n    style.id    = 'matchmediajs-test';\n\n    script && script.parentNode && script.parentNode.insertBefore(style, script);\n\n    // 'style.currentStyle' is used by IE <= 8 and 'window.getComputedStyle' for all other browsers\n    info = ('getComputedStyle' in window) && window.getComputedStyle(style, null) || style.currentStyle;\n\n    styleMedia = {\n      matchMedium(media) {\n        var text = `@media ${media}{ #matchmediajs-test { width: 1px; } }`;\n\n        // 'style.styleSheet' is used by IE <= 8 and 'style.textContent' for all other browsers\n        if (style.styleSheet) {\n          style.styleSheet.cssText = text;\n        } else {\n          style.textContent = text;\n        }\n\n        // Test if media query is true or false\n        return info.width === '1px';\n      }\n    }\n  }\n\n  return function(media) {\n    return {\n      matches: styleMedia.matchMedium(media || 'all'),\n      media: media || 'all'\n    };\n  }\n}());\n\n// Thank you: https://github.com/sindresorhus/query-string\nfunction parseStyleToObject(str) {\n  var styleObject = {};\n\n  if (typeof str !== 'string') {\n    return styleObject;\n  }\n\n  str = str.trim().slice(1, -1); // browsers re-quote string style values\n\n  if (!str) {\n    return styleObject;\n  }\n\n  styleObject = str.split('&').reduce(function(ret, param) {\n    var parts = param.replace(/\\+/g, ' ').split('=');\n    var key = parts[0];\n    var val = parts[1];\n    key = decodeURIComponent(key);\n\n    // missing `=` should be `null`:\n    // http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters\n    val = val === undefined ? null : decodeURIComponent(val);\n\n    if (!ret.hasOwnProperty(key)) {\n      ret[key] = val;\n    } else if (Array.isArray(ret[key])) {\n      ret[key].push(val);\n    } else {\n      ret[key] = [ret[key], val];\n    }\n    return ret;\n  }, {});\n\n  return styleObject;\n}\n\nFoundation.MediaQuery = MediaQuery;\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * Motion module.\n * @module foundation.motion\n */\n\nconst initClasses   = ['mui-enter', 'mui-leave'];\nconst activeClasses = ['mui-enter-active', 'mui-leave-active'];\n\nconst Motion = {\n  animateIn: function(element, animation, cb) {\n    animate(true, element, animation, cb);\n  },\n\n  animateOut: function(element, animation, cb) {\n    animate(false, element, animation, cb);\n  }\n}\n\nfunction Move(duration, elem, fn){\n  var anim, prog, start = null;\n  // console.log('called');\n\n  if (duration === 0) {\n    fn.apply(elem);\n    elem.trigger('finished.zf.animate', [elem]).triggerHandler('finished.zf.animate', [elem]);\n    return;\n  }\n\n  function move(ts){\n    if(!start) start = ts;\n    // console.log(start, ts);\n    prog = ts - start;\n    fn.apply(elem);\n\n    if(prog < duration){ anim = window.requestAnimationFrame(move, elem); }\n    else{\n      window.cancelAnimationFrame(anim);\n      elem.trigger('finished.zf.animate', [elem]).triggerHandler('finished.zf.animate', [elem]);\n    }\n  }\n  anim = window.requestAnimationFrame(move);\n}\n\n/**\n * Animates an element in or out using a CSS transition class.\n * @function\n * @private\n * @param {Boolean} isIn - Defines if the animation is in or out.\n * @param {Object} element - jQuery or HTML object to animate.\n * @param {String} animation - CSS class to use.\n * @param {Function} cb - Callback to run when animation is finished.\n */\nfunction animate(isIn, element, animation, cb) {\n  element = $(element).eq(0);\n\n  if (!element.length) return;\n\n  var initClass = isIn ? initClasses[0] : initClasses[1];\n  var activeClass = isIn ? activeClasses[0] : activeClasses[1];\n\n  // Set up the animation\n  reset();\n\n  element\n    .addClass(animation)\n    .css('transition', 'none');\n\n  requestAnimationFrame(() => {\n    element.addClass(initClass);\n    if (isIn) element.show();\n  });\n\n  // Start the animation\n  requestAnimationFrame(() => {\n    element[0].offsetWidth;\n    element\n      .css('transition', '')\n      .addClass(activeClass);\n  });\n\n  // Clean up the animation when it finishes\n  element.one(Foundation.transitionend(element), finish);\n\n  // Hides the element (for out animations), resets the element, and runs a callback\n  function finish() {\n    if (!isIn) element.hide();\n    reset();\n    if (cb) cb.apply(element);\n  }\n\n  // Resets transitions and removes motion-specific classes\n  function reset() {\n    element[0].style.transitionDuration = 0;\n    element.removeClass(`${initClass} ${activeClass} ${animation}`);\n  }\n}\n\nFoundation.Move = Move;\nFoundation.Motion = Motion;\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\nconst Nest = {\n  Feather(menu, type = 'zf') {\n    menu.attr('role', 'menubar');\n\n    var items = menu.find('li').attr({'role': 'menuitem'}),\n        subMenuClass = `is-${type}-submenu`,\n        subItemClass = `${subMenuClass}-item`,\n        hasSubClass = `is-${type}-submenu-parent`;\n\n    items.each(function() {\n      var $item = $(this),\n          $sub = $item.children('ul');\n\n      if ($sub.length) {\n        $item\n          .addClass(hasSubClass)\n          .attr({\n            'aria-haspopup': true,\n            'aria-label': $item.children('a:first').text()\n          });\n          // Note:  Drilldowns behave differently in how they hide, and so need\n          // additional attributes.  We should look if this possibly over-generalized\n          // utility (Nest) is appropriate when we rework menus in 6.4\n          if(type === 'drilldown') {\n            $item.attr({'aria-expanded': false});\n          }\n\n        $sub\n          .addClass(`submenu ${subMenuClass}`)\n          .attr({\n            'data-submenu': '',\n            'role': 'menu'\n          });\n        if(type === 'drilldown') {\n          $sub.attr({'aria-hidden': true});\n        }\n      }\n\n      if ($item.parent('[data-submenu]').length) {\n        $item.addClass(`is-submenu-item ${subItemClass}`);\n      }\n    });\n\n    return;\n  },\n\n  Burn(menu, type) {\n    var //items = menu.find('li'),\n        subMenuClass = `is-${type}-submenu`,\n        subItemClass = `${subMenuClass}-item`,\n        hasSubClass = `is-${type}-submenu-parent`;\n\n    menu\n      .find('>li, .menu, .menu > li')\n      .removeClass(`${subMenuClass} ${subItemClass} ${hasSubClass} is-submenu-item submenu is-active`)\n      .removeAttr('data-submenu').css('display', '');\n\n    // console.log(      menu.find('.' + subMenuClass + ', .' + subItemClass + ', .has-submenu, .is-submenu-item, .submenu, [data-submenu]')\n    //           .removeClass(subMenuClass + ' ' + subItemClass + ' has-submenu is-submenu-item submenu')\n    //           .removeAttr('data-submenu'));\n    // items.each(function(){\n    //   var $item = $(this),\n    //       $sub = $item.children('ul');\n    //   if($item.parent('[data-submenu]').length){\n    //     $item.removeClass('is-submenu-item ' + subItemClass);\n    //   }\n    //   if($sub.length){\n    //     $item.removeClass('has-submenu');\n    //     $sub.removeClass('submenu ' + subMenuClass).removeAttr('data-submenu');\n    //   }\n    // });\n  }\n}\n\nFoundation.Nest = Nest;\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\nfunction Timer(elem, options, cb) {\n  var _this = this,\n      duration = options.duration,//options is an object for easily adding features later.\n      nameSpace = Object.keys(elem.data())[0] || 'timer',\n      remain = -1,\n      start,\n      timer;\n\n  this.isPaused = false;\n\n  this.restart = function() {\n    remain = -1;\n    clearTimeout(timer);\n    this.start();\n  }\n\n  this.start = function() {\n    this.isPaused = false;\n    // if(!elem.data('paused')){ return false; }//maybe implement this sanity check if used for other things.\n    clearTimeout(timer);\n    remain = remain <= 0 ? duration : remain;\n    elem.data('paused', false);\n    start = Date.now();\n    timer = setTimeout(function(){\n      if(options.infinite){\n        _this.restart();//rerun the timer.\n      }\n      if (cb && typeof cb === 'function') { cb(); }\n    }, remain);\n    elem.trigger(`timerstart.zf.${nameSpace}`);\n  }\n\n  this.pause = function() {\n    this.isPaused = true;\n    //if(elem.data('paused')){ return false; }//maybe implement this sanity check if used for other things.\n    clearTimeout(timer);\n    elem.data('paused', true);\n    var end = Date.now();\n    remain = remain - (end - start);\n    elem.trigger(`timerpaused.zf.${nameSpace}`);\n  }\n}\n\n/**\n * Runs a callback function when images are fully loaded.\n * @param {Object} images - Image(s) to check if loaded.\n * @param {Func} callback - Function to execute when image is fully loaded.\n */\nfunction onImagesLoaded(images, callback){\n  var self = this,\n      unloaded = images.length;\n\n  if (unloaded === 0) {\n    callback();\n  }\n\n  images.each(function() {\n    // Check if image is loaded\n    if (this.complete || (this.readyState === 4) || (this.readyState === 'complete')) {\n      singleImageLoaded();\n    }\n    // Force load the image\n    else {\n      // fix for IE. See https://css-tricks.com/snippets/jquery/fixing-load-in-ie-for-cached-images/\n      var src = $(this).attr('src');\n      $(this).attr('src', src + (src.indexOf('?') >= 0 ? '&' : '?') + (new Date().getTime()));\n      $(this).one('load', function() {\n        singleImageLoaded();\n      });\n    }\n  });\n\n  function singleImageLoaded() {\n    unloaded--;\n    if (unloaded === 0) {\n      callback();\n    }\n  }\n}\n\nFoundation.Timer = Timer;\nFoundation.onImagesLoaded = onImagesLoaded;\n\n}(jQuery);\n","//**************************************************\n//**Work inspired by multiple jquery swipe plugins**\n//**Done by Yohai Ararat ***************************\n//**************************************************\n(function($) {\n\n  $.spotSwipe = {\n    version: '1.0.0',\n    enabled: 'ontouchstart' in document.documentElement,\n    preventDefault: false,\n    moveThreshold: 75,\n    timeThreshold: 200\n  };\n\n  var   startPosX,\n        startPosY,\n        startTime,\n        elapsedTime,\n        isMoving = false;\n\n  function onTouchEnd() {\n    //  alert(this);\n    this.removeEventListener('touchmove', onTouchMove);\n    this.removeEventListener('touchend', onTouchEnd);\n    isMoving = false;\n  }\n\n  function onTouchMove(e) {\n    if ($.spotSwipe.preventDefault) { e.preventDefault(); }\n    if(isMoving) {\n      var x = e.touches[0].pageX;\n      var y = e.touches[0].pageY;\n      var dx = startPosX - x;\n      var dy = startPosY - y;\n      var dir;\n      elapsedTime = new Date().getTime() - startTime;\n      if(Math.abs(dx) >= $.spotSwipe.moveThreshold && elapsedTime <= $.spotSwipe.timeThreshold) {\n        dir = dx > 0 ? 'left' : 'right';\n      }\n      // else if(Math.abs(dy) >= $.spotSwipe.moveThreshold && elapsedTime <= $.spotSwipe.timeThreshold) {\n      //   dir = dy > 0 ? 'down' : 'up';\n      // }\n      if(dir) {\n        e.preventDefault();\n        onTouchEnd.call(this);\n        $(this).trigger('swipe', dir).trigger(`swipe${dir}`);\n      }\n    }\n  }\n\n  function onTouchStart(e) {\n    if (e.touches.length == 1) {\n      startPosX = e.touches[0].pageX;\n      startPosY = e.touches[0].pageY;\n      isMoving = true;\n      startTime = new Date().getTime();\n      this.addEventListener('touchmove', onTouchMove, false);\n      this.addEventListener('touchend', onTouchEnd, false);\n    }\n  }\n\n  function init() {\n    this.addEventListener && this.addEventListener('touchstart', onTouchStart, false);\n  }\n\n  function teardown() {\n    this.removeEventListener('touchstart', onTouchStart);\n  }\n\n  $.event.special.swipe = { setup: init };\n\n  $.each(['left', 'up', 'down', 'right'], function () {\n    $.event.special[`swipe${this}`] = { setup: function(){\n      $(this).on('swipe', $.noop);\n    } };\n  });\n})(jQuery);\n/****************************************************\n * Method for adding psuedo drag events to elements *\n ***************************************************/\n!function($){\n  $.fn.addTouch = function(){\n    this.each(function(i,el){\n      $(el).bind('touchstart touchmove touchend touchcancel',function(){\n        //we pass the original event object because the jQuery event\n        //object is normalized to w3c specs and does not provide the TouchList\n        handleTouch(event);\n      });\n    });\n\n    var handleTouch = function(event){\n      var touches = event.changedTouches,\n          first = touches[0],\n          eventTypes = {\n            touchstart: 'mousedown',\n            touchmove: 'mousemove',\n            touchend: 'mouseup'\n          },\n          type = eventTypes[event.type],\n          simulatedEvent\n        ;\n\n      if('MouseEvent' in window && typeof window.MouseEvent === 'function') {\n        simulatedEvent = new window.MouseEvent(type, {\n          'bubbles': true,\n          'cancelable': true,\n          'screenX': first.screenX,\n          'screenY': first.screenY,\n          'clientX': first.clientX,\n          'clientY': first.clientY\n        });\n      } else {\n        simulatedEvent = document.createEvent('MouseEvent');\n        simulatedEvent.initMouseEvent(type, true, true, window, 1, first.screenX, first.screenY, first.clientX, first.clientY, false, false, false, false, 0/*left*/, null);\n      }\n      first.target.dispatchEvent(simulatedEvent);\n    };\n  };\n}(jQuery);\n\n\n//**********************************\n//**From the jQuery Mobile Library**\n//**need to recreate functionality**\n//**and try to improve if possible**\n//**********************************\n\n/* Removing the jQuery function ****\n************************************\n\n(function( $, window, undefined ) {\n\n\tvar $document = $( document ),\n\t\t// supportTouch = $.mobile.support.touch,\n\t\ttouchStartEvent = 'touchstart'//supportTouch ? \"touchstart\" : \"mousedown\",\n\t\ttouchStopEvent = 'touchend'//supportTouch ? \"touchend\" : \"mouseup\",\n\t\ttouchMoveEvent = 'touchmove'//supportTouch ? \"touchmove\" : \"mousemove\";\n\n\t// setup new event shortcuts\n\t$.each( ( \"touchstart touchmove touchend \" +\n\t\t\"swipe swipeleft swiperight\" ).split( \" \" ), function( i, name ) {\n\n\t\t$.fn[ name ] = function( fn ) {\n\t\t\treturn fn ? this.bind( name, fn ) : this.trigger( name );\n\t\t};\n\n\t\t// jQuery < 1.8\n\t\tif ( $.attrFn ) {\n\t\t\t$.attrFn[ name ] = true;\n\t\t}\n\t});\n\n\tfunction triggerCustomEvent( obj, eventType, event, bubble ) {\n\t\tvar originalType = event.type;\n\t\tevent.type = eventType;\n\t\tif ( bubble ) {\n\t\t\t$.event.trigger( event, undefined, obj );\n\t\t} else {\n\t\t\t$.event.dispatch.call( obj, event );\n\t\t}\n\t\tevent.type = originalType;\n\t}\n\n\t// also handles taphold\n\n\t// Also handles swipeleft, swiperight\n\t$.event.special.swipe = {\n\n\t\t// More than this horizontal displacement, and we will suppress scrolling.\n\t\tscrollSupressionThreshold: 30,\n\n\t\t// More time than this, and it isn't a swipe.\n\t\tdurationThreshold: 1000,\n\n\t\t// Swipe horizontal displacement must be more than this.\n\t\thorizontalDistanceThreshold: window.devicePixelRatio >= 2 ? 15 : 30,\n\n\t\t// Swipe vertical displacement must be less than this.\n\t\tverticalDistanceThreshold: window.devicePixelRatio >= 2 ? 15 : 30,\n\n\t\tgetLocation: function ( event ) {\n\t\t\tvar winPageX = window.pageXOffset,\n\t\t\t\twinPageY = window.pageYOffset,\n\t\t\t\tx = event.clientX,\n\t\t\t\ty = event.clientY;\n\n\t\t\tif ( event.pageY === 0 && Math.floor( y ) > Math.floor( event.pageY ) ||\n\t\t\t\tevent.pageX === 0 && Math.floor( x ) > Math.floor( event.pageX ) ) {\n\n\t\t\t\t// iOS4 clientX/clientY have the value that should have been\n\t\t\t\t// in pageX/pageY. While pageX/page/ have the value 0\n\t\t\t\tx = x - winPageX;\n\t\t\t\ty = y - winPageY;\n\t\t\t} else if ( y < ( event.pageY - winPageY) || x < ( event.pageX - winPageX ) ) {\n\n\t\t\t\t// Some Android browsers have totally bogus values for clientX/Y\n\t\t\t\t// when scrolling/zooming a page. Detectable since clientX/clientY\n\t\t\t\t// should never be smaller than pageX/pageY minus page scroll\n\t\t\t\tx = event.pageX - winPageX;\n\t\t\t\ty = event.pageY - winPageY;\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\tx: x,\n\t\t\t\ty: y\n\t\t\t};\n\t\t},\n\n\t\tstart: function( event ) {\n\t\t\tvar data = event.originalEvent.touches ?\n\t\t\t\t\tevent.originalEvent.touches[ 0 ] : event,\n\t\t\t\tlocation = $.event.special.swipe.getLocation( data );\n\t\t\treturn {\n\t\t\t\t\t\ttime: ( new Date() ).getTime(),\n\t\t\t\t\t\tcoords: [ location.x, location.y ],\n\t\t\t\t\t\torigin: $( event.target )\n\t\t\t\t\t};\n\t\t},\n\n\t\tstop: function( event ) {\n\t\t\tvar data = event.originalEvent.touches ?\n\t\t\t\t\tevent.originalEvent.touches[ 0 ] : event,\n\t\t\t\tlocation = $.event.special.swipe.getLocation( data );\n\t\t\treturn {\n\t\t\t\t\t\ttime: ( new Date() ).getTime(),\n\t\t\t\t\t\tcoords: [ location.x, location.y ]\n\t\t\t\t\t};\n\t\t},\n\n\t\thandleSwipe: function( start, stop, thisObject, origTarget ) {\n\t\t\tif ( stop.time - start.time < $.event.special.swipe.durationThreshold &&\n\t\t\t\tMath.abs( start.coords[ 0 ] - stop.coords[ 0 ] ) > $.event.special.swipe.horizontalDistanceThreshold &&\n\t\t\t\tMath.abs( start.coords[ 1 ] - stop.coords[ 1 ] ) < $.event.special.swipe.verticalDistanceThreshold ) {\n\t\t\t\tvar direction = start.coords[0] > stop.coords[ 0 ] ? \"swipeleft\" : \"swiperight\";\n\n\t\t\t\ttriggerCustomEvent( thisObject, \"swipe\", $.Event( \"swipe\", { target: origTarget, swipestart: start, swipestop: stop }), true );\n\t\t\t\ttriggerCustomEvent( thisObject, direction,$.Event( direction, { target: origTarget, swipestart: start, swipestop: stop } ), true );\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\treturn false;\n\n\t\t},\n\n\t\t// This serves as a flag to ensure that at most one swipe event event is\n\t\t// in work at any given time\n\t\teventInProgress: false,\n\n\t\tsetup: function() {\n\t\t\tvar events,\n\t\t\t\tthisObject = this,\n\t\t\t\t$this = $( thisObject ),\n\t\t\t\tcontext = {};\n\n\t\t\t// Retrieve the events data for this element and add the swipe context\n\t\t\tevents = $.data( this, \"mobile-events\" );\n\t\t\tif ( !events ) {\n\t\t\t\tevents = { length: 0 };\n\t\t\t\t$.data( this, \"mobile-events\", events );\n\t\t\t}\n\t\t\tevents.length++;\n\t\t\tevents.swipe = context;\n\n\t\t\tcontext.start = function( event ) {\n\n\t\t\t\t// Bail if we're already working on a swipe event\n\t\t\t\tif ( $.event.special.swipe.eventInProgress ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\t$.event.special.swipe.eventInProgress = true;\n\n\t\t\t\tvar stop,\n\t\t\t\t\tstart = $.event.special.swipe.start( event ),\n\t\t\t\t\torigTarget = event.target,\n\t\t\t\t\temitted = false;\n\n\t\t\t\tcontext.move = function( event ) {\n\t\t\t\t\tif ( !start || event.isDefaultPrevented() ) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\n\t\t\t\t\tstop = $.event.special.swipe.stop( event );\n\t\t\t\t\tif ( !emitted ) {\n\t\t\t\t\t\temitted = $.event.special.swipe.handleSwipe( start, stop, thisObject, origTarget );\n\t\t\t\t\t\tif ( emitted ) {\n\n\t\t\t\t\t\t\t// Reset the context to make way for the next swipe event\n\t\t\t\t\t\t\t$.event.special.swipe.eventInProgress = false;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\t// prevent scrolling\n\t\t\t\t\tif ( Math.abs( start.coords[ 0 ] - stop.coords[ 0 ] ) > $.event.special.swipe.scrollSupressionThreshold ) {\n\t\t\t\t\t\tevent.preventDefault();\n\t\t\t\t\t}\n\t\t\t\t};\n\n\t\t\t\tcontext.stop = function() {\n\t\t\t\t\t\temitted = true;\n\n\t\t\t\t\t\t// Reset the context to make way for the next swipe event\n\t\t\t\t\t\t$.event.special.swipe.eventInProgress = false;\n\t\t\t\t\t\t$document.off( touchMoveEvent, context.move );\n\t\t\t\t\t\tcontext.move = null;\n\t\t\t\t};\n\n\t\t\t\t$document.on( touchMoveEvent, context.move )\n\t\t\t\t\t.one( touchStopEvent, context.stop );\n\t\t\t};\n\t\t\t$this.on( touchStartEvent, context.start );\n\t\t},\n\n\t\tteardown: function() {\n\t\t\tvar events, context;\n\n\t\t\tevents = $.data( this, \"mobile-events\" );\n\t\t\tif ( events ) {\n\t\t\t\tcontext = events.swipe;\n\t\t\t\tdelete events.swipe;\n\t\t\t\tevents.length--;\n\t\t\t\tif ( events.length === 0 ) {\n\t\t\t\t\t$.removeData( this, \"mobile-events\" );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif ( context ) {\n\t\t\t\tif ( context.start ) {\n\t\t\t\t\t$( this ).off( touchStartEvent, context.start );\n\t\t\t\t}\n\t\t\t\tif ( context.move ) {\n\t\t\t\t\t$document.off( touchMoveEvent, context.move );\n\t\t\t\t}\n\t\t\t\tif ( context.stop ) {\n\t\t\t\t\t$document.off( touchStopEvent, context.stop );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\t$.each({\n\t\tswipeleft: \"swipe.left\",\n\t\tswiperight: \"swipe.right\"\n\t}, function( event, sourceEvent ) {\n\n\t\t$.event.special[ event ] = {\n\t\t\tsetup: function() {\n\t\t\t\t$( this ).bind( sourceEvent, $.noop );\n\t\t\t},\n\t\t\tteardown: function() {\n\t\t\t\t$( this ).unbind( sourceEvent );\n\t\t\t}\n\t\t};\n\t});\n})( jQuery, this );\n*/\n","'use strict';\n\n!function($) {\n\nconst MutationObserver = (function () {\n  var prefixes = ['WebKit', 'Moz', 'O', 'Ms', ''];\n  for (var i=0; i < prefixes.length; i++) {\n    if (`${prefixes[i]}MutationObserver` in window) {\n      return window[`${prefixes[i]}MutationObserver`];\n    }\n  }\n  return false;\n}());\n\nconst triggers = (el, type) => {\n  el.data(type).split(' ').forEach(id => {\n    $(`#${id}`)[ type === 'close' ? 'trigger' : 'triggerHandler'](`${type}.zf.trigger`, [el]);\n  });\n};\n// Elements with [data-open] will reveal a plugin that supports it when clicked.\n$(document).on('click.zf.trigger', '[data-open]', function() {\n  triggers($(this), 'open');\n});\n\n// Elements with [data-close] will close a plugin that supports it when clicked.\n// If used without a value on [data-close], the event will bubble, allowing it to close a parent component.\n$(document).on('click.zf.trigger', '[data-close]', function() {\n  let id = $(this).data('close');\n  if (id) {\n    triggers($(this), 'close');\n  }\n  else {\n    $(this).trigger('close.zf.trigger');\n  }\n});\n\n// Elements with [data-toggle] will toggle a plugin that supports it when clicked.\n$(document).on('click.zf.trigger', '[data-toggle]', function() {\n  let id = $(this).data('toggle');\n  if (id) {\n    triggers($(this), 'toggle');\n  } else {\n    $(this).trigger('toggle.zf.trigger');\n  }\n});\n\n// Elements with [data-closable] will respond to close.zf.trigger events.\n$(document).on('close.zf.trigger', '[data-closable]', function(e){\n  e.stopPropagation();\n  let animation = $(this).data('closable');\n\n  if(animation !== ''){\n    Foundation.Motion.animateOut($(this), animation, function() {\n      $(this).trigger('closed.zf');\n    });\n  }else{\n    $(this).fadeOut().trigger('closed.zf');\n  }\n});\n\n$(document).on('focus.zf.trigger blur.zf.trigger', '[data-toggle-focus]', function() {\n  let id = $(this).data('toggle-focus');\n  $(`#${id}`).triggerHandler('toggle.zf.trigger', [$(this)]);\n});\n\n/**\n* Fires once after all other scripts have loaded\n* @function\n* @private\n*/\n$(window).on('load', () => {\n  checkListeners();\n});\n\nfunction checkListeners() {\n  eventsListener();\n  resizeListener();\n  scrollListener();\n  closemeListener();\n}\n\n//******** only fires this function once on load, if there's something to watch ********\nfunction closemeListener(pluginName) {\n  var yetiBoxes = $('[data-yeti-box]'),\n      plugNames = ['dropdown', 'tooltip', 'reveal'];\n\n  if(pluginName){\n    if(typeof pluginName === 'string'){\n      plugNames.push(pluginName);\n    }else if(typeof pluginName === 'object' && typeof pluginName[0] === 'string'){\n      plugNames.concat(pluginName);\n    }else{\n      console.error('Plugin names must be strings');\n    }\n  }\n  if(yetiBoxes.length){\n    let listeners = plugNames.map((name) => {\n      return `closeme.zf.${name}`;\n    }).join(' ');\n\n    $(window).off(listeners).on(listeners, function(e, pluginId){\n      let plugin = e.namespace.split('.')[0];\n      let plugins = $(`[data-${plugin}]`).not(`[data-yeti-box=\"${pluginId}\"]`);\n\n      plugins.each(function(){\n        let _this = $(this);\n\n        _this.triggerHandler('close.zf.trigger', [_this]);\n      });\n    });\n  }\n}\n\nfunction resizeListener(debounce){\n  let timer,\n      $nodes = $('[data-resize]');\n  if($nodes.length){\n    $(window).off('resize.zf.trigger')\n    .on('resize.zf.trigger', function(e) {\n      if (timer) { clearTimeout(timer); }\n\n      timer = setTimeout(function(){\n\n        if(!MutationObserver){//fallback for IE 9\n          $nodes.each(function(){\n            $(this).triggerHandler('resizeme.zf.trigger');\n          });\n        }\n        //trigger all listening elements and signal a resize event\n        $nodes.attr('data-events', \"resize\");\n      }, debounce || 10);//default time to emit resize event\n    });\n  }\n}\n\nfunction scrollListener(debounce){\n  let timer,\n      $nodes = $('[data-scroll]');\n  if($nodes.length){\n    $(window).off('scroll.zf.trigger')\n    .on('scroll.zf.trigger', function(e){\n      if(timer){ clearTimeout(timer); }\n\n      timer = setTimeout(function(){\n\n        if(!MutationObserver){//fallback for IE 9\n          $nodes.each(function(){\n            $(this).triggerHandler('scrollme.zf.trigger');\n          });\n        }\n        //trigger all listening elements and signal a scroll event\n        $nodes.attr('data-events', \"scroll\");\n      }, debounce || 10);//default time to emit scroll event\n    });\n  }\n}\n\nfunction eventsListener() {\n  if(!MutationObserver){ return false; }\n  let nodes = document.querySelectorAll('[data-resize], [data-scroll], [data-mutate]');\n\n  //element callback\n  var listeningElementsMutation = function (mutationRecordsList) {\n      var $target = $(mutationRecordsList[0].target);\n\n\t  //trigger the event handler for the element depending on type\n      switch (mutationRecordsList[0].type) {\n\n        case \"attributes\":\n          if ($target.attr(\"data-events\") === \"scroll\" && mutationRecordsList[0].attributeName === \"data-events\") {\n\t\t  \t$target.triggerHandler('scrollme.zf.trigger', [$target, window.pageYOffset]);\n\t\t  }\n\t\t  if ($target.attr(\"data-events\") === \"resize\" && mutationRecordsList[0].attributeName === \"data-events\") {\n\t\t  \t$target.triggerHandler('resizeme.zf.trigger', [$target]);\n\t\t   }\n\t\t  if (mutationRecordsList[0].attributeName === \"style\") {\n\t\t\t  $target.closest(\"[data-mutate]\").attr(\"data-events\",\"mutate\");\n\t\t\t  $target.closest(\"[data-mutate]\").triggerHandler('mutateme.zf.trigger', [$target.closest(\"[data-mutate]\")]);\n\t\t  }\n\t\t  break;\n\n        case \"childList\":\n\t\t  $target.closest(\"[data-mutate]\").attr(\"data-events\",\"mutate\");\n\t\t  $target.closest(\"[data-mutate]\").triggerHandler('mutateme.zf.trigger', [$target.closest(\"[data-mutate]\")]);\n          break;\n\n        default:\n          return false;\n        //nothing\n      }\n    };\n\n    if (nodes.length) {\n      //for each element that needs to listen for resizing, scrolling, or mutation add a single observer\n      for (var i = 0; i <= nodes.length - 1; i++) {\n        var elementObserver = new MutationObserver(listeningElementsMutation);\n        elementObserver.observe(nodes[i], { attributes: true, childList: true, characterData: false, subtree: true, attributeFilter: [\"data-events\", \"style\"] });\n      }\n    }\n  }\n\n// ------------------------------------\n\n// [PH]\n// Foundation.CheckWatchers = checkWatchers;\nFoundation.IHearYou = checkListeners;\n// Foundation.ISeeYou = scrollListener;\n// Foundation.IFeelYou = closemeListener;\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * Abide module.\n * @module foundation.abide\n */\n\nclass Abide {\n  /**\n   * Creates a new instance of Abide.\n   * @class\n   * @fires Abide#init\n   * @param {Object} element - jQuery object to add the trigger to.\n   * @param {Object} options - Overrides to the default plugin settings.\n   */\n  constructor(element, options = {}) {\n    this.$element = element;\n    this.options  = $.extend({}, Abide.defaults, this.$element.data(), options);\n\n    this._init();\n\n    Foundation.registerPlugin(this, 'Abide');\n  }\n\n  /**\n   * Initializes the Abide plugin and calls functions to get Abide functioning on load.\n   * @private\n   */\n  _init() {\n    this.$inputs = this.$element.find('input, textarea, select');\n\n    this._events();\n  }\n\n  /**\n   * Initializes events for Abide.\n   * @private\n   */\n  _events() {\n    this.$element.off('.abide')\n      .on('reset.zf.abide', () => {\n        this.resetForm();\n      })\n      .on('submit.zf.abide', () => {\n        return this.validateForm();\n      });\n\n    if (this.options.validateOn === 'fieldChange') {\n      this.$inputs\n        .off('change.zf.abide')\n        .on('change.zf.abide', (e) => {\n          this.validateInput($(e.target));\n        });\n    }\n\n    if (this.options.liveValidate) {\n      this.$inputs\n        .off('input.zf.abide')\n        .on('input.zf.abide', (e) => {\n          this.validateInput($(e.target));\n        });\n    }\n\n    if (this.options.validateOnBlur) {\n      this.$inputs\n        .off('blur.zf.abide')\n        .on('blur.zf.abide', (e) => {\n          this.validateInput($(e.target));\n        });\n    }\n  }\n\n  /**\n   * Calls necessary functions to update Abide upon DOM change\n   * @private\n   */\n  _reflow() {\n    this._init();\n  }\n\n  /**\n   * Checks whether or not a form element has the required attribute and if it's checked or not\n   * @param {Object} element - jQuery object to check for required attribute\n   * @returns {Boolean} Boolean value depends on whether or not attribute is checked or empty\n   */\n  requiredCheck($el) {\n    if (!$el.attr('required')) return true;\n\n    var isGood = true;\n\n    switch ($el[0].type) {\n      case 'checkbox':\n        isGood = $el[0].checked;\n        break;\n\n      case 'select':\n      case 'select-one':\n      case 'select-multiple':\n        var opt = $el.find('option:selected');\n        if (!opt.length || !opt.val()) isGood = false;\n        break;\n\n      default:\n        if(!$el.val() || !$el.val().length) isGood = false;\n    }\n\n    return isGood;\n  }\n\n  /**\n   * Get:\n   * - Based on $el, the first element(s) corresponding to `formErrorSelector` in this order:\n   *   1. The element's direct sibling('s).\n   *   2. The element's parent's children.\n   * - Element(s) with the attribute `[data-form-error-for]` set with the element's id.\n   *\n   * This allows for multiple form errors per input, though if none are found, no form errors will be shown.\n   *\n   * @param {Object} $el - jQuery object to use as reference to find the form error selector.\n   * @returns {Object} jQuery object with the selector.\n   */\n  findFormError($el) {\n    var id = $el[0].id;\n    var $error = $el.siblings(this.options.formErrorSelector);\n\n    if (!$error.length) {\n      $error = $el.parent().find(this.options.formErrorSelector);\n    }\n\n    $error = $error.add(this.$element.find(`[data-form-error-for=\"${id}\"]`));\n\n    return $error;\n  }\n\n  /**\n   * Get the first element in this order:\n   * 2. The <label> with the attribute `[for=\"someInputId\"]`\n   * 3. The `.closest()` <label>\n   *\n   * @param {Object} $el - jQuery object to check for required attribute\n   * @returns {Boolean} Boolean value depends on whether or not attribute is checked or empty\n   */\n  findLabel($el) {\n    var id = $el[0].id;\n    var $label = this.$element.find(`label[for=\"${id}\"]`);\n\n    if (!$label.length) {\n      return $el.closest('label');\n    }\n\n    return $label;\n  }\n\n  /**\n   * Get the set of labels associated with a set of radio els in this order\n   * 2. The <label> with the attribute `[for=\"someInputId\"]`\n   * 3. The `.closest()` <label>\n   *\n   * @param {Object} $el - jQuery object to check for required attribute\n   * @returns {Boolean} Boolean value depends on whether or not attribute is checked or empty\n   */\n  findRadioLabels($els) {\n    var labels = $els.map((i, el) => {\n      var id = el.id;\n      var $label = this.$element.find(`label[for=\"${id}\"]`);\n\n      if (!$label.length) {\n        $label = $(el).closest('label');\n      }\n      return $label[0];\n    });\n\n    return $(labels);\n  }\n\n  /**\n   * Adds the CSS error class as specified by the Abide settings to the label, input, and the form\n   * @param {Object} $el - jQuery object to add the class to\n   */\n  addErrorClasses($el) {\n    var $label = this.findLabel($el);\n    var $formError = this.findFormError($el);\n\n    if ($label.length) {\n      $label.addClass(this.options.labelErrorClass);\n    }\n\n    if ($formError.length) {\n      $formError.addClass(this.options.formErrorClass);\n    }\n\n    $el.addClass(this.options.inputErrorClass).attr('data-invalid', '');\n  }\n\n  /**\n   * Remove CSS error classes etc from an entire radio button group\n   * @param {String} groupName - A string that specifies the name of a radio button group\n   *\n   */\n\n  removeRadioErrorClasses(groupName) {\n    var $els = this.$element.find(`:radio[name=\"${groupName}\"]`);\n    var $labels = this.findRadioLabels($els);\n    var $formErrors = this.findFormError($els);\n\n    if ($labels.length) {\n      $labels.removeClass(this.options.labelErrorClass);\n    }\n\n    if ($formErrors.length) {\n      $formErrors.removeClass(this.options.formErrorClass);\n    }\n\n    $els.removeClass(this.options.inputErrorClass).removeAttr('data-invalid');\n\n  }\n\n  /**\n   * Removes CSS error class as specified by the Abide settings from the label, input, and the form\n   * @param {Object} $el - jQuery object to remove the class from\n   */\n  removeErrorClasses($el) {\n    // radios need to clear all of the els\n    if($el[0].type == 'radio') {\n      return this.removeRadioErrorClasses($el.attr('name'));\n    }\n\n    var $label = this.findLabel($el);\n    var $formError = this.findFormError($el);\n\n    if ($label.length) {\n      $label.removeClass(this.options.labelErrorClass);\n    }\n\n    if ($formError.length) {\n      $formError.removeClass(this.options.formErrorClass);\n    }\n\n    $el.removeClass(this.options.inputErrorClass).removeAttr('data-invalid');\n  }\n\n  /**\n   * Goes through a form to find inputs and proceeds to validate them in ways specific to their type. \n   * Ignores inputs with data-abide-ignore, type=\"hidden\" or disabled attributes set\n   * @fires Abide#invalid\n   * @fires Abide#valid\n   * @param {Object} element - jQuery object to validate, should be an HTML input\n   * @returns {Boolean} goodToGo - If the input is valid or not.\n   */\n  validateInput($el) {\n    var clearRequire = this.requiredCheck($el),\n        validated = false,\n        customValidator = true,\n        validator = $el.attr('data-validator'),\n        equalTo = true;\n\n    // don't validate ignored inputs or hidden inputs or disabled inputs\n    if ($el.is('[data-abide-ignore]') || $el.is('[type=\"hidden\"]') || $el.is('[disabled]')) {\n      return true;\n    }\n\n    switch ($el[0].type) {\n      case 'radio':\n        validated = this.validateRadio($el.attr('name'));\n        break;\n\n      case 'checkbox':\n        validated = clearRequire;\n        break;\n\n      case 'select':\n      case 'select-one':\n      case 'select-multiple':\n        validated = clearRequire;\n        break;\n\n      default:\n        validated = this.validateText($el);\n    }\n\n    if (validator) {\n      customValidator = this.matchValidation($el, validator, $el.attr('required'));\n    }\n\n    if ($el.attr('data-equalto')) {\n      equalTo = this.options.validators.equalTo($el);\n    }\n\n\n    var goodToGo = [clearRequire, validated, customValidator, equalTo].indexOf(false) === -1;\n    var message = (goodToGo ? 'valid' : 'invalid') + '.zf.abide';\n\n    if (goodToGo) {\n      // Re-validate inputs that depend on this one with equalto\n      const dependentElements = this.$element.find(`[data-equalto=\"${$el.attr('id')}\"]`);\n      if (dependentElements.length) {\n        let _this = this;\n        dependentElements.each(function() {\n          if ($(this).val()) {\n            _this.validateInput($(this));\n          }\n        });\n      }\n    }\n\n    this[goodToGo ? 'removeErrorClasses' : 'addErrorClasses']($el);\n\n    /**\n     * Fires when the input is done checking for validation. Event trigger is either `valid.zf.abide` or `invalid.zf.abide`\n     * Trigger includes the DOM element of the input.\n     * @event Abide#valid\n     * @event Abide#invalid\n     */\n    $el.trigger(message, [$el]);\n\n    return goodToGo;\n  }\n\n  /**\n   * Goes through a form and if there are any invalid inputs, it will display the form error element\n   * @returns {Boolean} noError - true if no errors were detected...\n   * @fires Abide#formvalid\n   * @fires Abide#forminvalid\n   */\n  validateForm() {\n    var acc = [];\n    var _this = this;\n\n    this.$inputs.each(function() {\n      acc.push(_this.validateInput($(this)));\n    });\n\n    var noError = acc.indexOf(false) === -1;\n\n    this.$element.find('[data-abide-error]').css('display', (noError ? 'none' : 'block'));\n\n    /**\n     * Fires when the form is finished validating. Event trigger is either `formvalid.zf.abide` or `forminvalid.zf.abide`.\n     * Trigger includes the element of the form.\n     * @event Abide#formvalid\n     * @event Abide#forminvalid\n     */\n    this.$element.trigger((noError ? 'formvalid' : 'forminvalid') + '.zf.abide', [this.$element]);\n\n    return noError;\n  }\n\n  /**\n   * 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.\n   * @param {Object} $el - jQuery object to validate, should be a text input HTML element\n   * @param {String} pattern - string value of one of the RegEx patterns in Abide.options.patterns\n   * @returns {Boolean} Boolean value depends on whether or not the input value matches the pattern specified\n   */\n  validateText($el, pattern) {\n    // A pattern can be passed to this function, or it will be infered from the input's \"pattern\" attribute, or it's \"type\" attribute\n    pattern = (pattern || $el.attr('pattern') || $el.attr('type'));\n    var inputText = $el.val();\n    var valid = false;\n\n    if (inputText.length) {\n      // If the pattern attribute on the element is in Abide's list of patterns, then test that regexp\n      if (this.options.patterns.hasOwnProperty(pattern)) {\n        valid = this.options.patterns[pattern].test(inputText);\n      }\n      // If the pattern name isn't also the type attribute of the field, then test it as a regexp\n      else if (pattern !== $el.attr('type')) {\n        valid = new RegExp(pattern).test(inputText);\n      }\n      else {\n        valid = true;\n      }\n    }\n    // An empty field is valid if it's not required\n    else if (!$el.prop('required')) {\n      valid = true;\n    }\n\n    return valid;\n   }\n\n  /**\n   * 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.\n   * @param {String} groupName - A string that specifies the name of a radio button group\n   * @returns {Boolean} Boolean value depends on whether or not at least one radio input has been selected (if it's required)\n   */\n  validateRadio(groupName) {\n    // If at least one radio in the group has the `required` attribute, the group is considered required\n    // Per W3C spec, all radio buttons in a group should have `required`, but we're being nice\n    var $group = this.$element.find(`:radio[name=\"${groupName}\"]`);\n    var valid = false, required = false;\n\n    // For the group to be required, at least one radio needs to be required\n    $group.each((i, e) => {\n      if ($(e).attr('required')) {\n        required = true;\n      }\n    });\n    if(!required) valid=true;\n\n    if (!valid) {\n      // For the group to be valid, at least one radio needs to be checked\n      $group.each((i, e) => {\n        if ($(e).prop('checked')) {\n          valid = true;\n        }\n      });\n    };\n\n    return valid;\n  }\n\n  /**\n   * 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.\n   * @param {Object} $el - jQuery input element.\n   * @param {String} validators - a string of function names matching functions in the Abide.options.validators object.\n   * @param {Boolean} required - self explanatory?\n   * @returns {Boolean} - true if validations passed.\n   */\n  matchValidation($el, validators, required) {\n    required = required ? true : false;\n\n    var clear = validators.split(' ').map((v) => {\n      return this.options.validators[v]($el, required, $el.parent());\n    });\n    return clear.indexOf(false) === -1;\n  }\n\n  /**\n   * Resets form inputs and styles\n   * @fires Abide#formreset\n   */\n  resetForm() {\n    var $form = this.$element,\n        opts = this.options;\n\n    $(`.${opts.labelErrorClass}`, $form).not('small').removeClass(opts.labelErrorClass);\n    $(`.${opts.inputErrorClass}`, $form).not('small').removeClass(opts.inputErrorClass);\n    $(`${opts.formErrorSelector}.${opts.formErrorClass}`).removeClass(opts.formErrorClass);\n    $form.find('[data-abide-error]').css('display', 'none');\n    $(':input', $form).not(':button, :submit, :reset, :hidden, :radio, :checkbox, [data-abide-ignore]').val('').removeAttr('data-invalid');\n    $(':input:radio', $form).not('[data-abide-ignore]').prop('checked',false).removeAttr('data-invalid');\n    $(':input:checkbox', $form).not('[data-abide-ignore]').prop('checked',false).removeAttr('data-invalid');\n    /**\n     * Fires when the form has been reset.\n     * @event Abide#formreset\n     */\n    $form.trigger('formreset.zf.abide', [$form]);\n  }\n\n  /**\n   * Destroys an instance of Abide.\n   * Removes error styles and classes from elements, without resetting their values.\n   */\n  destroy() {\n    var _this = this;\n    this.$element\n      .off('.abide')\n      .find('[data-abide-error]')\n        .css('display', 'none');\n\n    this.$inputs\n      .off('.abide')\n      .each(function() {\n        _this.removeErrorClasses($(this));\n      });\n\n    Foundation.unregisterPlugin(this);\n  }\n}\n\n/**\n * Default settings for plugin\n */\nAbide.defaults = {\n  /**\n   * The default event to validate inputs. Checkboxes and radios validate immediately.\n   * Remove or change this value for manual validation.\n   * @option\n   * @type {?string}\n   * @default 'fieldChange'\n   */\n  validateOn: 'fieldChange',\n\n  /**\n   * Class to be applied to input labels on failed validation.\n   * @option\n   * @type {string}\n   * @default 'is-invalid-label'\n   */\n  labelErrorClass: 'is-invalid-label',\n\n  /**\n   * Class to be applied to inputs on failed validation.\n   * @option\n   * @type {string}\n   * @default 'is-invalid-input'\n   */\n  inputErrorClass: 'is-invalid-input',\n\n  /**\n   * Class selector to use to target Form Errors for show/hide.\n   * @option\n   * @type {string}\n   * @default '.form-error'\n   */\n  formErrorSelector: '.form-error',\n\n  /**\n   * Class added to Form Errors on failed validation.\n   * @option\n   * @type {string}\n   * @default 'is-visible'\n   */\n  formErrorClass: 'is-visible',\n\n  /**\n   * Set to true to validate text inputs on any value change.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  liveValidate: false,\n\n  /**\n   * Set to true to validate inputs on blur.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  validateOnBlur: false,\n\n  patterns: {\n    alpha : /^[a-zA-Z]+$/,\n    alpha_numeric : /^[a-zA-Z0-9]+$/,\n    integer : /^[-+]?\\d+$/,\n    number : /^[-+]?\\d*(?:[\\.\\,]\\d+)?$/,\n\n    // amex, visa, diners\n    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})$/,\n    cvv : /^([0-9]){3,4}$/,\n\n    // http://www.whatwg.org/specs/web-apps/current-work/multipage/states-of-the-type-attribute.html#valid-e-mail-address\n    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])?)+$/,\n\n    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})|[!\\$&'\\(\\)\\*\\+,;=]|:|@)|\\/|\\?)*)?$/,\n    // abc.de\n    domain : /^([a-zA-Z0-9]([a-zA-Z0-9\\-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]{2,8}$/,\n\n    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))$/,\n    // YYYY-MM-DD\n    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))$/,\n    // HH:MM:SS\n    time : /^(0[0-9]|1[0-9]|2[0-3])(:[0-5][0-9]){2}$/,\n    dateISO : /^\\d{4}[\\/\\-]\\d{1,2}[\\/\\-]\\d{1,2}$/,\n    // MM/DD/YYYY\n    month_day_year : /^(0[1-9]|1[012])[- \\/.](0[1-9]|[12][0-9]|3[01])[- \\/.]\\d{4}$/,\n    // DD/MM/YYYY\n    day_month_year : /^(0[1-9]|[12][0-9]|3[01])[- \\/.](0[1-9]|1[012])[- \\/.]\\d{4}$/,\n\n    // #FFF or #FFFFFF\n    color : /^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/\n  },\n\n  /**\n   * Optional validation functions to be used. `equalTo` being the only default included function.\n   * Functions should return only a boolean if the input is valid or not. Functions are given the following arguments:\n   * el : The jQuery element to validate.\n   * required : Boolean value of the required attribute be present or not.\n   * parent : The direct parent of the input.\n   * @option\n   */\n  validators: {\n    equalTo: function (el, required, parent) {\n      return $(`#${el.attr('data-equalto')}`).val() === el.val();\n    }\n  }\n}\n\n// Window exports\nFoundation.plugin(Abide, 'Abide');\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * Accordion module.\n * @module foundation.accordion\n * @requires foundation.util.keyboard\n * @requires foundation.util.motion\n */\n\nclass Accordion {\n  /**\n   * Creates a new instance of an accordion.\n   * @class\n   * @fires Accordion#init\n   * @param {jQuery} element - jQuery object to make into an accordion.\n   * @param {Object} options - a plain object with settings to override the default options.\n   */\n  constructor(element, options) {\n    this.$element = element;\n    this.options = $.extend({}, Accordion.defaults, this.$element.data(), options);\n\n    this._init();\n\n    Foundation.registerPlugin(this, 'Accordion');\n    Foundation.Keyboard.register('Accordion', {\n      'ENTER': 'toggle',\n      'SPACE': 'toggle',\n      'ARROW_DOWN': 'next',\n      'ARROW_UP': 'previous'\n    });\n  }\n\n  /**\n   * Initializes the accordion by animating the preset active pane(s).\n   * @private\n   */\n  _init() {\n    this.$element.attr('role', 'tablist');\n    this.$tabs = this.$element.children('[data-accordion-item]');\n\n    this.$tabs.each(function(idx, el) {\n      var $el = $(el),\n          $content = $el.children('[data-tab-content]'),\n          id = $content[0].id || Foundation.GetYoDigits(6, 'accordion'),\n          linkId = el.id || `${id}-label`;\n\n      $el.find('a:first').attr({\n        'aria-controls': id,\n        'role': 'tab',\n        'id': linkId,\n        'aria-expanded': false,\n        'aria-selected': false\n      });\n\n      $content.attr({'role': 'tabpanel', 'aria-labelledby': linkId, 'aria-hidden': true, 'id': id});\n    });\n    var $initActive = this.$element.find('.is-active').children('[data-tab-content]');\n    this.firstTimeInit = true;\n    if($initActive.length){\n      this.down($initActive, this.firstTimeInit);\n      this.firstTimeInit = false;\n    }\n\n    this._checkDeepLink = () => {\n      var anchor = window.location.hash;\n      //need a hash and a relevant anchor in this tabset\n      if(anchor.length) {\n        var $link = this.$element.find('[href$=\"'+anchor+'\"]'),\n        $anchor = $(anchor);\n\n        if ($link.length && $anchor) {\n          if (!$link.parent('[data-accordion-item]').hasClass('is-active')) {\n            this.down($anchor, this.firstTimeInit);\n            this.firstTimeInit = false;\n          };\n\n          //roll up a little to show the titles\n          if (this.options.deepLinkSmudge) {\n            var _this = this;\n            $(window).load(function() {\n              var offset = _this.$element.offset();\n              $('html, body').animate({ scrollTop: offset.top }, _this.options.deepLinkSmudgeDelay);\n            });\n          }\n\n          /**\n            * Fires when the zplugin has deeplinked at pageload\n            * @event Accordion#deeplink\n            */\n          this.$element.trigger('deeplink.zf.accordion', [$link, $anchor]);\n        }\n      }\n    }\n\n    //use browser to open a tab, if it exists in this tabset\n    if (this.options.deepLink) {\n      this._checkDeepLink();\n    }\n\n    this._events();\n  }\n\n  /**\n   * Adds event handlers for items within the accordion.\n   * @private\n   */\n  _events() {\n    var _this = this;\n\n    this.$tabs.each(function() {\n      var $elem = $(this);\n      var $tabContent = $elem.children('[data-tab-content]');\n      if ($tabContent.length) {\n        $elem.children('a').off('click.zf.accordion keydown.zf.accordion')\n               .on('click.zf.accordion', function(e) {\n          e.preventDefault();\n          _this.toggle($tabContent);\n        }).on('keydown.zf.accordion', function(e){\n          Foundation.Keyboard.handleKey(e, 'Accordion', {\n            toggle: function() {\n              _this.toggle($tabContent);\n            },\n            next: function() {\n              var $a = $elem.next().find('a').focus();\n              if (!_this.options.multiExpand) {\n                $a.trigger('click.zf.accordion')\n              }\n            },\n            previous: function() {\n              var $a = $elem.prev().find('a').focus();\n              if (!_this.options.multiExpand) {\n                $a.trigger('click.zf.accordion')\n              }\n            },\n            handled: function() {\n              e.preventDefault();\n              e.stopPropagation();\n            }\n          });\n        });\n      }\n    });\n    if(this.options.deepLink) {\n      $(window).on('popstate', this._checkDeepLink);\n    }\n  }\n\n  /**\n   * Toggles the selected content pane's open/close state.\n   * @param {jQuery} $target - jQuery object of the pane to toggle (`.accordion-content`).\n   * @function\n   */\n  toggle($target) {\n    if($target.parent().hasClass('is-active')) {\n      this.up($target);\n    } else {\n      this.down($target);\n    }\n    //either replace or update browser history\n    if (this.options.deepLink) {\n      var anchor = $target.prev('a').attr('href');\n\n      if (this.options.updateHistory) {\n        history.pushState({}, '', anchor);\n      } else {\n        history.replaceState({}, '', anchor);\n      }\n    }\n  }\n\n  /**\n   * Opens the accordion tab defined by `$target`.\n   * @param {jQuery} $target - Accordion pane to open (`.accordion-content`).\n   * @param {Boolean} firstTime - flag to determine if reflow should happen.\n   * @fires Accordion#down\n   * @function\n   */\n  down($target, firstTime) {\n    $target\n      .attr('aria-hidden', false)\n      .parent('[data-tab-content]')\n      .addBack()\n      .parent().addClass('is-active');\n\n    if (!this.options.multiExpand && !firstTime) {\n      var $currentActive = this.$element.children('.is-active').children('[data-tab-content]');\n      if ($currentActive.length) {\n        this.up($currentActive.not($target));\n      }\n    }\n\n    $target.slideDown(this.options.slideSpeed, () => {\n      /**\n       * Fires when the tab is done opening.\n       * @event Accordion#down\n       */\n      this.$element.trigger('down.zf.accordion', [$target]);\n    });\n\n    $(`#${$target.attr('aria-labelledby')}`).attr({\n      'aria-expanded': true,\n      'aria-selected': true\n    });\n  }\n\n  /**\n   * Closes the tab defined by `$target`.\n   * @param {jQuery} $target - Accordion tab to close (`.accordion-content`).\n   * @fires Accordion#up\n   * @function\n   */\n  up($target) {\n    var $aunts = $target.parent().siblings(),\n        _this = this;\n\n    if((!this.options.allowAllClosed && !$aunts.hasClass('is-active')) || !$target.parent().hasClass('is-active')) {\n      return;\n    }\n\n    // Foundation.Move(this.options.slideSpeed, $target, function(){\n      $target.slideUp(_this.options.slideSpeed, function () {\n        /**\n         * Fires when the tab is done collapsing up.\n         * @event Accordion#up\n         */\n        _this.$element.trigger('up.zf.accordion', [$target]);\n      });\n    // });\n\n    $target.attr('aria-hidden', true)\n           .parent().removeClass('is-active');\n\n    $(`#${$target.attr('aria-labelledby')}`).attr({\n     'aria-expanded': false,\n     'aria-selected': false\n   });\n  }\n\n  /**\n   * Destroys an instance of an accordion.\n   * @fires Accordion#destroyed\n   * @function\n   */\n  destroy() {\n    this.$element.find('[data-tab-content]').stop(true).slideUp(0).css('display', '');\n    this.$element.find('a').off('.zf.accordion');\n    if(this.options.deepLink) {\n      $(window).off('popstate', this._checkDeepLink);\n    }\n\n    Foundation.unregisterPlugin(this);\n  }\n}\n\nAccordion.defaults = {\n  /**\n   * Amount of time to animate the opening of an accordion pane.\n   * @option\n   * @type {number}\n   * @default 250\n   */\n  slideSpeed: 250,\n  /**\n   * Allow the accordion to have multiple open panes.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  multiExpand: false,\n  /**\n   * Allow the accordion to close all panes.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  allowAllClosed: false,\n  /**\n   * Allows the window to scroll to content of pane specified by hash anchor\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  deepLink: false,\n\n  /**\n   * Adjust the deep link scroll to make sure the top of the accordion panel is visible\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  deepLinkSmudge: false,\n\n  /**\n   * Animation time (ms) for the deep link adjustment\n   * @option\n   * @type {number}\n   * @default 300\n   */\n  deepLinkSmudgeDelay: 300,\n\n  /**\n   * Update the browser history with the open accordion\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  updateHistory: false\n};\n\n// Window exports\nFoundation.plugin(Accordion, 'Accordion');\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * AccordionMenu module.\n * @module foundation.accordionMenu\n * @requires foundation.util.keyboard\n * @requires foundation.util.motion\n * @requires foundation.util.nest\n */\n\nclass AccordionMenu {\n  /**\n   * Creates a new instance of an accordion menu.\n   * @class\n   * @fires AccordionMenu#init\n   * @param {jQuery} element - jQuery object to make into an accordion menu.\n   * @param {Object} options - Overrides to the default plugin settings.\n   */\n  constructor(element, options) {\n    this.$element = element;\n    this.options = $.extend({}, AccordionMenu.defaults, this.$element.data(), options);\n\n    Foundation.Nest.Feather(this.$element, 'accordion');\n\n    this._init();\n\n    Foundation.registerPlugin(this, 'AccordionMenu');\n    Foundation.Keyboard.register('AccordionMenu', {\n      'ENTER': 'toggle',\n      'SPACE': 'toggle',\n      'ARROW_RIGHT': 'open',\n      'ARROW_UP': 'up',\n      'ARROW_DOWN': 'down',\n      'ARROW_LEFT': 'close',\n      'ESCAPE': 'closeAll'\n    });\n  }\n\n\n\n  /**\n   * Initializes the accordion menu by hiding all nested menus.\n   * @private\n   */\n  _init() {\n    this.$element.find('[data-submenu]').not('.is-active').slideUp(0);//.find('a').css('padding-left', '1rem');\n    this.$element.attr({\n      'role': 'menu',\n      'aria-multiselectable': this.options.multiOpen\n    });\n\n    this.$menuLinks = this.$element.find('.is-accordion-submenu-parent');\n    this.$menuLinks.each(function(){\n      var linkId = this.id || Foundation.GetYoDigits(6, 'acc-menu-link'),\n          $elem = $(this),\n          $sub = $elem.children('[data-submenu]'),\n          subId = $sub[0].id || Foundation.GetYoDigits(6, 'acc-menu'),\n          isActive = $sub.hasClass('is-active');\n      $elem.attr({\n        'aria-controls': subId,\n        'aria-expanded': isActive,\n        'role': 'menuitem',\n        'id': linkId\n      });\n      $sub.attr({\n        'aria-labelledby': linkId,\n        'aria-hidden': !isActive,\n        'role': 'menu',\n        'id': subId\n      });\n    });\n    var initPanes = this.$element.find('.is-active');\n    if(initPanes.length){\n      var _this = this;\n      initPanes.each(function(){\n        _this.down($(this));\n      });\n    }\n    this._events();\n  }\n\n  /**\n   * Adds event handlers for items within the menu.\n   * @private\n   */\n  _events() {\n    var _this = this;\n\n    this.$element.find('li').each(function() {\n      var $submenu = $(this).children('[data-submenu]');\n\n      if ($submenu.length) {\n        $(this).children('a').off('click.zf.accordionMenu').on('click.zf.accordionMenu', function(e) {\n          e.preventDefault();\n\n          _this.toggle($submenu);\n        });\n      }\n    }).on('keydown.zf.accordionmenu', function(e){\n      var $element = $(this),\n          $elements = $element.parent('ul').children('li'),\n          $prevElement,\n          $nextElement,\n          $target = $element.children('[data-submenu]');\n\n      $elements.each(function(i) {\n        if ($(this).is($element)) {\n          $prevElement = $elements.eq(Math.max(0, i-1)).find('a').first();\n          $nextElement = $elements.eq(Math.min(i+1, $elements.length-1)).find('a').first();\n\n          if ($(this).children('[data-submenu]:visible').length) { // has open sub menu\n            $nextElement = $element.find('li:first-child').find('a').first();\n          }\n          if ($(this).is(':first-child')) { // is first element of sub menu\n            $prevElement = $element.parents('li').first().find('a').first();\n          } else if ($prevElement.parents('li').first().children('[data-submenu]:visible').length) { // if previous element has open sub menu\n            $prevElement = $prevElement.parents('li').find('li:last-child').find('a').first();\n          }\n          if ($(this).is(':last-child')) { // is last element of sub menu\n            $nextElement = $element.parents('li').first().next('li').find('a').first();\n          }\n\n          return;\n        }\n      });\n\n      Foundation.Keyboard.handleKey(e, 'AccordionMenu', {\n        open: function() {\n          if ($target.is(':hidden')) {\n            _this.down($target);\n            $target.find('li').first().find('a').first().focus();\n          }\n        },\n        close: function() {\n          if ($target.length && !$target.is(':hidden')) { // close active sub of this item\n            _this.up($target);\n          } else if ($element.parent('[data-submenu]').length) { // close currently open sub\n            _this.up($element.parent('[data-submenu]'));\n            $element.parents('li').first().find('a').first().focus();\n          }\n        },\n        up: function() {\n          $prevElement.focus();\n          return true;\n        },\n        down: function() {\n          $nextElement.focus();\n          return true;\n        },\n        toggle: function() {\n          if ($element.children('[data-submenu]').length) {\n            _this.toggle($element.children('[data-submenu]'));\n          }\n        },\n        closeAll: function() {\n          _this.hideAll();\n        },\n        handled: function(preventDefault) {\n          if (preventDefault) {\n            e.preventDefault();\n          }\n          e.stopImmediatePropagation();\n        }\n      });\n    });//.attr('tabindex', 0);\n  }\n\n  /**\n   * Closes all panes of the menu.\n   * @function\n   */\n  hideAll() {\n    this.up(this.$element.find('[data-submenu]'));\n  }\n\n  /**\n   * Opens all panes of the menu.\n   * @function\n   */\n  showAll() {\n    this.down(this.$element.find('[data-submenu]'));\n  }\n\n  /**\n   * Toggles the open/close state of a submenu.\n   * @function\n   * @param {jQuery} $target - the submenu to toggle\n   */\n  toggle($target){\n    if(!$target.is(':animated')) {\n      if (!$target.is(':hidden')) {\n        this.up($target);\n      }\n      else {\n        this.down($target);\n      }\n    }\n  }\n\n  /**\n   * Opens the sub-menu defined by `$target`.\n   * @param {jQuery} $target - Sub-menu to open.\n   * @fires AccordionMenu#down\n   */\n  down($target) {\n    var _this = this;\n\n    if(!this.options.multiOpen) {\n      this.up(this.$element.find('.is-active').not($target.parentsUntil(this.$element).add($target)));\n    }\n\n    $target.addClass('is-active').attr({'aria-hidden': false})\n      .parent('.is-accordion-submenu-parent').attr({'aria-expanded': true});\n\n      //Foundation.Move(this.options.slideSpeed, $target, function() {\n        $target.slideDown(_this.options.slideSpeed, function () {\n          /**\n           * Fires when the menu is done opening.\n           * @event AccordionMenu#down\n           */\n          _this.$element.trigger('down.zf.accordionMenu', [$target]);\n        });\n      //});\n  }\n\n  /**\n   * Closes the sub-menu defined by `$target`. All sub-menus inside the target will be closed as well.\n   * @param {jQuery} $target - Sub-menu to close.\n   * @fires AccordionMenu#up\n   */\n  up($target) {\n    var _this = this;\n    //Foundation.Move(this.options.slideSpeed, $target, function(){\n      $target.slideUp(_this.options.slideSpeed, function () {\n        /**\n         * Fires when the menu is done collapsing up.\n         * @event AccordionMenu#up\n         */\n        _this.$element.trigger('up.zf.accordionMenu', [$target]);\n      });\n    //});\n\n    var $menus = $target.find('[data-submenu]').slideUp(0).addBack().attr('aria-hidden', true);\n\n    $menus.parent('.is-accordion-submenu-parent').attr('aria-expanded', false);\n  }\n\n  /**\n   * Destroys an instance of accordion menu.\n   * @fires AccordionMenu#destroyed\n   */\n  destroy() {\n    this.$element.find('[data-submenu]').slideDown(0).css('display', '');\n    this.$element.find('a').off('click.zf.accordionMenu');\n\n    Foundation.Nest.Burn(this.$element, 'accordion');\n    Foundation.unregisterPlugin(this);\n  }\n}\n\nAccordionMenu.defaults = {\n  /**\n   * Amount of time to animate the opening of a submenu in ms.\n   * @option\n   * @type {number}\n   * @default 250\n   */\n  slideSpeed: 250,\n  /**\n   * Allow the menu to have multiple open panes.\n   * @option\n   * @type {boolean}\n   * @default true\n   */\n  multiOpen: true\n};\n\n// Window exports\nFoundation.plugin(AccordionMenu, 'AccordionMenu');\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * Drilldown module.\n * @module foundation.drilldown\n * @requires foundation.util.keyboard\n * @requires foundation.util.motion\n * @requires foundation.util.nest\n */\n\nclass Drilldown {\n  /**\n   * Creates a new instance of a drilldown menu.\n   * @class\n   * @param {jQuery} element - jQuery object to make into an accordion menu.\n   * @param {Object} options - Overrides to the default plugin settings.\n   */\n  constructor(element, options) {\n    this.$element = element;\n    this.options = $.extend({}, Drilldown.defaults, this.$element.data(), options);\n\n    Foundation.Nest.Feather(this.$element, 'drilldown');\n\n    this._init();\n\n    Foundation.registerPlugin(this, 'Drilldown');\n    Foundation.Keyboard.register('Drilldown', {\n      'ENTER': 'open',\n      'SPACE': 'open',\n      'ARROW_RIGHT': 'next',\n      'ARROW_UP': 'up',\n      'ARROW_DOWN': 'down',\n      'ARROW_LEFT': 'previous',\n      'ESCAPE': 'close',\n      'TAB': 'down',\n      'SHIFT_TAB': 'up'\n    });\n  }\n\n  /**\n   * Initializes the drilldown by creating jQuery collections of elements\n   * @private\n   */\n  _init() {\n    this.$submenuAnchors = this.$element.find('li.is-drilldown-submenu-parent').children('a');\n    this.$submenus = this.$submenuAnchors.parent('li').children('[data-submenu]');\n    this.$menuItems = this.$element.find('li').not('.js-drilldown-back').attr('role', 'menuitem').find('a');\n    this.$element.attr('data-mutate', (this.$element.attr('data-drilldown') || Foundation.GetYoDigits(6, 'drilldown')));\n\n    this._prepareMenu();\n    this._registerEvents();\n\n    this._keyboardEvents();\n  }\n\n  /**\n   * prepares drilldown menu by setting attributes to links and elements\n   * sets a min height to prevent content jumping\n   * wraps the element if not already wrapped\n   * @private\n   * @function\n   */\n  _prepareMenu() {\n    var _this = this;\n    // if(!this.options.holdOpen){\n    //   this._menuLinkEvents();\n    // }\n    this.$submenuAnchors.each(function(){\n      var $link = $(this);\n      var $sub = $link.parent();\n      if(_this.options.parentLink){\n        $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>');\n      }\n      $link.data('savedHref', $link.attr('href')).removeAttr('href').attr('tabindex', 0);\n      $link.children('[data-submenu]')\n          .attr({\n            'aria-hidden': true,\n            'tabindex': 0,\n            'role': 'menu'\n          });\n      _this._events($link);\n    });\n    this.$submenus.each(function(){\n      var $menu = $(this),\n          $back = $menu.find('.js-drilldown-back');\n      if(!$back.length){\n        switch (_this.options.backButtonPosition) {\n          case \"bottom\":\n            $menu.append(_this.options.backButton);\n            break;\n          case \"top\":\n            $menu.prepend(_this.options.backButton);\n            break;\n          default:\n            console.error(\"Unsupported backButtonPosition value '\" + _this.options.backButtonPosition + \"'\");\n        }\n      }\n      _this._back($menu);\n    });\n\n    this.$submenus.addClass('invisible');\n    if(!this.options.autoHeight) {\n      this.$submenus.addClass('drilldown-submenu-cover-previous');\n    }\n\n    // create a wrapper on element if it doesn't exist.\n    if(!this.$element.parent().hasClass('is-drilldown')){\n      this.$wrapper = $(this.options.wrapper).addClass('is-drilldown');\n      if(this.options.animateHeight) this.$wrapper.addClass('animate-height');\n      this.$element.wrap(this.$wrapper);\n    }\n    // set wrapper\n    this.$wrapper = this.$element.parent();\n    this.$wrapper.css(this._getMaxDims());\n  }\n\n  _resize() {\n    this.$wrapper.css({'max-width': 'none', 'min-height': 'none'});\n    // _getMaxDims has side effects (boo) but calling it should update all other necessary heights & widths\n    this.$wrapper.css(this._getMaxDims());\n  }\n\n  /**\n   * Adds event handlers to elements in the menu.\n   * @function\n   * @private\n   * @param {jQuery} $elem - the current menu item to add handlers to.\n   */\n  _events($elem) {\n    var _this = this;\n\n    $elem.off('click.zf.drilldown')\n    .on('click.zf.drilldown', function(e){\n      if($(e.target).parentsUntil('ul', 'li').hasClass('is-drilldown-submenu-parent')){\n        e.stopImmediatePropagation();\n        e.preventDefault();\n      }\n\n      // if(e.target !== e.currentTarget.firstElementChild){\n      //   return false;\n      // }\n      _this._show($elem.parent('li'));\n\n      if(_this.options.closeOnClick){\n        var $body = $('body');\n        $body.off('.zf.drilldown').on('click.zf.drilldown', function(e){\n          if (e.target === _this.$element[0] || $.contains(_this.$element[0], e.target)) { return; }\n          e.preventDefault();\n          _this._hideAll();\n          $body.off('.zf.drilldown');\n        });\n      }\n    });\n\t  this.$element.on('mutateme.zf.trigger', this._resize.bind(this));\n  }\n\n  /**\n   * Adds event handlers to the menu element.\n   * @function\n   * @private\n   */\n  _registerEvents() {\n    if(this.options.scrollTop){\n      this._bindHandler = this._scrollTop.bind(this);\n      this.$element.on('open.zf.drilldown hide.zf.drilldown closed.zf.drilldown',this._bindHandler);\n    }\n  }\n\n  /**\n   * Scroll to Top of Element or data-scroll-top-element\n   * @function\n   * @fires Drilldown#scrollme\n   */\n  _scrollTop() {\n    var _this = this;\n    var $scrollTopElement = _this.options.scrollTopElement!=''?$(_this.options.scrollTopElement):_this.$element,\n        scrollPos = parseInt($scrollTopElement.offset().top+_this.options.scrollTopOffset);\n    $('html, body').stop(true).animate({ scrollTop: scrollPos }, _this.options.animationDuration, _this.options.animationEasing,function(){\n      /**\n        * Fires after the menu has scrolled\n        * @event Drilldown#scrollme\n        */\n      if(this===$('html')[0])_this.$element.trigger('scrollme.zf.drilldown');\n    });\n  }\n\n  /**\n   * Adds keydown event listener to `li`'s in the menu.\n   * @private\n   */\n  _keyboardEvents() {\n    var _this = this;\n\n    this.$menuItems.add(this.$element.find('.js-drilldown-back > a, .is-submenu-parent-item > a')).on('keydown.zf.drilldown', function(e){\n      var $element = $(this),\n          $elements = $element.parent('li').parent('ul').children('li').children('a'),\n          $prevElement,\n          $nextElement;\n\n      $elements.each(function(i) {\n        if ($(this).is($element)) {\n          $prevElement = $elements.eq(Math.max(0, i-1));\n          $nextElement = $elements.eq(Math.min(i+1, $elements.length-1));\n          return;\n        }\n      });\n\n      Foundation.Keyboard.handleKey(e, 'Drilldown', {\n        next: function() {\n          if ($element.is(_this.$submenuAnchors)) {\n            _this._show($element.parent('li'));\n            $element.parent('li').one(Foundation.transitionend($element), function(){\n              $element.parent('li').find('ul li a').filter(_this.$menuItems).first().focus();\n            });\n            return true;\n          }\n        },\n        previous: function() {\n          _this._hide($element.parent('li').parent('ul'));\n          $element.parent('li').parent('ul').one(Foundation.transitionend($element), function(){\n            setTimeout(function() {\n              $element.parent('li').parent('ul').parent('li').children('a').first().focus();\n            }, 1);\n          });\n          return true;\n        },\n        up: function() {\n          $prevElement.focus();\n          // Don't tap focus on first element in root ul\n          return !$element.is(_this.$element.find('> li:first-child > a'));\n        },\n        down: function() {\n          $nextElement.focus();\n          // Don't tap focus on last element in root ul\n          return !$element.is(_this.$element.find('> li:last-child > a'));\n        },\n        close: function() {\n          // Don't close on element in root ul\n          if (!$element.is(_this.$element.find('> li > a'))) {\n            _this._hide($element.parent().parent());\n            $element.parent().parent().siblings('a').focus();\n          }\n        },\n        open: function() {\n          if (!$element.is(_this.$menuItems)) { // not menu item means back button\n            _this._hide($element.parent('li').parent('ul'));\n            $element.parent('li').parent('ul').one(Foundation.transitionend($element), function(){\n              setTimeout(function() {\n                $element.parent('li').parent('ul').parent('li').children('a').first().focus();\n              }, 1);\n            });\n            return true;\n          } else if ($element.is(_this.$submenuAnchors)) {\n            _this._show($element.parent('li'));\n            $element.parent('li').one(Foundation.transitionend($element), function(){\n              $element.parent('li').find('ul li a').filter(_this.$menuItems).first().focus();\n            });\n            return true;\n          }\n        },\n        handled: function(preventDefault) {\n          if (preventDefault) {\n            e.preventDefault();\n          }\n          e.stopImmediatePropagation();\n        }\n      });\n    }); // end keyboardAccess\n  }\n\n  /**\n   * Closes all open elements, and returns to root menu.\n   * @function\n   * @fires Drilldown#closed\n   */\n  _hideAll() {\n    var $elem = this.$element.find('.is-drilldown-submenu.is-active').addClass('is-closing');\n    if(this.options.autoHeight) this.$wrapper.css({height:$elem.parent().closest('ul').data('calcHeight')});\n    $elem.one(Foundation.transitionend($elem), function(e){\n      $elem.removeClass('is-active is-closing');\n    });\n        /**\n         * Fires when the menu is fully closed.\n         * @event Drilldown#closed\n         */\n    this.$element.trigger('closed.zf.drilldown');\n  }\n\n  /**\n   * Adds event listener for each `back` button, and closes open menus.\n   * @function\n   * @fires Drilldown#back\n   * @param {jQuery} $elem - the current sub-menu to add `back` event.\n   */\n  _back($elem) {\n    var _this = this;\n    $elem.off('click.zf.drilldown');\n    $elem.children('.js-drilldown-back')\n      .on('click.zf.drilldown', function(e){\n        e.stopImmediatePropagation();\n        // console.log('mouseup on back');\n        _this._hide($elem);\n\n        // If there is a parent submenu, call show\n        let parentSubMenu = $elem.parent('li').parent('ul').parent('li');\n        if (parentSubMenu.length) {\n          _this._show(parentSubMenu);\n        }\n      });\n  }\n\n  /**\n   * Adds event listener to menu items w/o submenus to close open menus on click.\n   * @function\n   * @private\n   */\n  _menuLinkEvents() {\n    var _this = this;\n    this.$menuItems.not('.is-drilldown-submenu-parent')\n        .off('click.zf.drilldown')\n        .on('click.zf.drilldown', function(e){\n          // e.stopImmediatePropagation();\n          setTimeout(function(){\n            _this._hideAll();\n          }, 0);\n      });\n  }\n\n  /**\n   * Opens a submenu.\n   * @function\n   * @fires Drilldown#open\n   * @param {jQuery} $elem - the current element with a submenu to open, i.e. the `li` tag.\n   */\n  _show($elem) {\n    if(this.options.autoHeight) this.$wrapper.css({height:$elem.children('[data-submenu]').data('calcHeight')});\n    $elem.attr('aria-expanded', true);\n    $elem.children('[data-submenu]').addClass('is-active').removeClass('invisible').attr('aria-hidden', false);\n    /**\n     * Fires when the submenu has opened.\n     * @event Drilldown#open\n     */\n    this.$element.trigger('open.zf.drilldown', [$elem]);\n  };\n\n  /**\n   * Hides a submenu\n   * @function\n   * @fires Drilldown#hide\n   * @param {jQuery} $elem - the current sub-menu to hide, i.e. the `ul` tag.\n   */\n  _hide($elem) {\n    if(this.options.autoHeight) this.$wrapper.css({height:$elem.parent().closest('ul').data('calcHeight')});\n    var _this = this;\n    $elem.parent('li').attr('aria-expanded', false);\n    $elem.attr('aria-hidden', true).addClass('is-closing')\n    $elem.addClass('is-closing')\n         .one(Foundation.transitionend($elem), function(){\n           $elem.removeClass('is-active is-closing');\n           $elem.blur().addClass('invisible');\n         });\n    /**\n     * Fires when the submenu has closed.\n     * @event Drilldown#hide\n     */\n    $elem.trigger('hide.zf.drilldown', [$elem]);\n  }\n\n  /**\n   * Iterates through the nested menus to calculate the min-height, and max-width for the menu.\n   * Prevents content jumping.\n   * @function\n   * @private\n   */\n  _getMaxDims() {\n    var  maxHeight = 0, result = {}, _this = this;\n    this.$submenus.add(this.$element).each(function(){\n      var numOfElems = $(this).children('li').length;\n      var height = Foundation.Box.GetDimensions(this).height;\n      maxHeight = height > maxHeight ? height : maxHeight;\n      if(_this.options.autoHeight) {\n        $(this).data('calcHeight',height);\n        if (!$(this).hasClass('is-drilldown-submenu')) result['height'] = height;\n      }\n    });\n\n    if(!this.options.autoHeight) result['min-height'] = `${maxHeight}px`;\n\n    result['max-width'] = `${this.$element[0].getBoundingClientRect().width}px`;\n\n    return result;\n  }\n\n  /**\n   * Destroys the Drilldown Menu\n   * @function\n   */\n  destroy() {\n    if(this.options.scrollTop) this.$element.off('.zf.drilldown',this._bindHandler);\n    this._hideAll();\n\t  this.$element.off('mutateme.zf.trigger');\n    Foundation.Nest.Burn(this.$element, 'drilldown');\n    this.$element.unwrap()\n                 .find('.js-drilldown-back, .is-submenu-parent-item').remove()\n                 .end().find('.is-active, .is-closing, .is-drilldown-submenu').removeClass('is-active is-closing is-drilldown-submenu')\n                 .end().find('[data-submenu]').removeAttr('aria-hidden tabindex role');\n    this.$submenuAnchors.each(function() {\n      $(this).off('.zf.drilldown');\n    });\n\n    this.$submenus.removeClass('drilldown-submenu-cover-previous');\n\n    this.$element.find('a').each(function(){\n      var $link = $(this);\n      $link.removeAttr('tabindex');\n      if($link.data('savedHref')){\n        $link.attr('href', $link.data('savedHref')).removeData('savedHref');\n      }else{ return; }\n    });\n    Foundation.unregisterPlugin(this);\n  };\n}\n\nDrilldown.defaults = {\n  /**\n   * Markup used for JS generated back button. Prepended  or appended (see backButtonPosition) to submenu lists and deleted on `destroy` method, 'js-drilldown-back' class required. Remove the backslash (`\\`) if copy and pasting.\n   * @option\n   * @type {string}\n   * @default '<li class=\"js-drilldown-back\"><a tabindex=\"0\">Back</a></li>'\n   */\n  backButton: '<li class=\"js-drilldown-back\"><a tabindex=\"0\">Back</a></li>',\n  /**\n   * Position the back button either at the top or bottom of drilldown submenus. Can be `'left'` or `'bottom'`.\n   * @option\n   * @type {string}\n   * @default top\n   */\n  backButtonPosition: 'top',\n  /**\n   * 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.\n   * @option\n   * @type {string}\n   * @default '<div></div>'\n   */\n  wrapper: '<div></div>',\n  /**\n   * Adds the parent link to the submenu.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  parentLink: false,\n  /**\n   * Allow the menu to return to root list on body click.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  closeOnClick: false,\n  /**\n   * Allow the menu to auto adjust height.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  autoHeight: false,\n  /**\n   * Animate the auto adjust height.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  animateHeight: false,\n  /**\n   * Scroll to the top of the menu after opening a submenu or navigating back using the menu back button\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  scrollTop: false,\n  /**\n   * String jquery selector (for example 'body') of element to take offset().top from, if empty string the drilldown menu offset().top is taken\n   * @option\n   * @type {string}\n   * @default ''\n   */\n  scrollTopElement: '',\n  /**\n   * ScrollTop offset\n   * @option\n   * @type {number}\n   * @default 0\n   */\n  scrollTopOffset: 0,\n  /**\n   * Scroll animation duration\n   * @option\n   * @type {number}\n   * @default 500\n   */\n  animationDuration: 500,\n  /**\n   * Scroll animation easing. Can be `'swing'` or `'linear'`.\n   * @option\n   * @type {string}\n   * @see {@link https://api.jquery.com/animate|JQuery animate}\n   * @default 'swing'\n   */\n  animationEasing: 'swing'\n  // holdOpen: false\n};\n\n// Window exports\nFoundation.plugin(Drilldown, 'Drilldown');\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * Dropdown module.\n * @module foundation.dropdown\n * @requires foundation.util.keyboard\n * @requires foundation.util.box\n * @requires foundation.util.triggers\n */\n\nclass Dropdown {\n  /**\n   * Creates a new instance of a dropdown.\n   * @class\n   * @param {jQuery} element - jQuery object to make into a dropdown.\n   *        Object should be of the dropdown panel, rather than its anchor.\n   * @param {Object} options - Overrides to the default plugin settings.\n   */\n  constructor(element, options) {\n    this.$element = element;\n    this.options = $.extend({}, Dropdown.defaults, this.$element.data(), options);\n    this._init();\n\n    Foundation.registerPlugin(this, 'Dropdown');\n    Foundation.Keyboard.register('Dropdown', {\n      'ENTER': 'open',\n      'SPACE': 'open',\n      'ESCAPE': 'close'\n    });\n  }\n\n  /**\n   * Initializes the plugin by setting/checking options and attributes, adding helper variables, and saving the anchor.\n   * @function\n   * @private\n   */\n  _init() {\n    var $id = this.$element.attr('id');\n\n    this.$anchor = $(`[data-toggle=\"${$id}\"]`).length ? $(`[data-toggle=\"${$id}\"]`) : $(`[data-open=\"${$id}\"]`);\n    this.$anchor.attr({\n      'aria-controls': $id,\n      'data-is-focus': false,\n      'data-yeti-box': $id,\n      'aria-haspopup': true,\n      'aria-expanded': false\n\n    });\n\n    if(this.options.parentClass){\n      this.$parent = this.$element.parents('.' + this.options.parentClass);\n    }else{\n      this.$parent = null;\n    }\n    this.options.positionClass = this.getPositionClass();\n    this.counter = 4;\n    this.usedPositions = [];\n    this.$element.attr({\n      'aria-hidden': 'true',\n      'data-yeti-box': $id,\n      'data-resize': $id,\n      'aria-labelledby': this.$anchor[0].id || Foundation.GetYoDigits(6, 'dd-anchor')\n    });\n    this._events();\n  }\n\n  /**\n   * Helper function to determine current orientation of dropdown pane.\n   * @function\n   * @returns {String} position - string value of a position class.\n   */\n  getPositionClass() {\n    var verticalPosition = this.$element[0].className.match(/(top|left|right|bottom)/g);\n        verticalPosition = verticalPosition ? verticalPosition[0] : '';\n    var horizontalPosition = /float-(\\S+)/.exec(this.$anchor[0].className);\n        horizontalPosition = horizontalPosition ? horizontalPosition[1] : '';\n    var position = horizontalPosition ? horizontalPosition + ' ' + verticalPosition : verticalPosition;\n\n    return position;\n  }\n\n  /**\n   * Adjusts the dropdown panes orientation by adding/removing positioning classes.\n   * @function\n   * @private\n   * @param {String} position - position class to remove.\n   */\n  _reposition(position) {\n    this.usedPositions.push(position ? position : 'bottom');\n    //default, try switching to opposite side\n    if(!position && (this.usedPositions.indexOf('top') < 0)){\n      this.$element.addClass('top');\n    }else if(position === 'top' && (this.usedPositions.indexOf('bottom') < 0)){\n      this.$element.removeClass(position);\n    }else if(position === 'left' && (this.usedPositions.indexOf('right') < 0)){\n      this.$element.removeClass(position)\n          .addClass('right');\n    }else if(position === 'right' && (this.usedPositions.indexOf('left') < 0)){\n      this.$element.removeClass(position)\n          .addClass('left');\n    }\n\n    //if default change didn't work, try bottom or left first\n    else if(!position && (this.usedPositions.indexOf('top') > -1) && (this.usedPositions.indexOf('left') < 0)){\n      this.$element.addClass('left');\n    }else if(position === 'top' && (this.usedPositions.indexOf('bottom') > -1) && (this.usedPositions.indexOf('left') < 0)){\n      this.$element.removeClass(position)\n          .addClass('left');\n    }else if(position === 'left' && (this.usedPositions.indexOf('right') > -1) && (this.usedPositions.indexOf('bottom') < 0)){\n      this.$element.removeClass(position);\n    }else if(position === 'right' && (this.usedPositions.indexOf('left') > -1) && (this.usedPositions.indexOf('bottom') < 0)){\n      this.$element.removeClass(position);\n    }\n    //if nothing cleared, set to bottom\n    else{\n      this.$element.removeClass(position);\n    }\n    this.classChanged = true;\n    this.counter--;\n  }\n\n  /**\n   * Sets the position and orientation of the dropdown pane, checks for collisions.\n   * Recursively calls itself if a collision is detected, with a new position class.\n   * @function\n   * @private\n   */\n  _setPosition() {\n    if(this.$anchor.attr('aria-expanded') === 'false'){ return false; }\n    var position = this.getPositionClass(),\n        $eleDims = Foundation.Box.GetDimensions(this.$element),\n        $anchorDims = Foundation.Box.GetDimensions(this.$anchor),\n        _this = this,\n        direction = (position === 'left' ? 'left' : ((position === 'right') ? 'left' : 'top')),\n        param = (direction === 'top') ? 'height' : 'width',\n        offset = (param === 'height') ? this.options.vOffset : this.options.hOffset;\n\n    if(($eleDims.width >= $eleDims.windowDims.width) || (!this.counter && !Foundation.Box.ImNotTouchingYou(this.$element, this.$parent))){\n      var newWidth = $eleDims.windowDims.width,\n          parentHOffset = 0;\n      if(this.$parent){\n        var $parentDims = Foundation.Box.GetDimensions(this.$parent),\n            parentHOffset = $parentDims.offset.left;\n        if ($parentDims.width < newWidth){\n          newWidth = $parentDims.width;\n        }\n      }\n\n      this.$element.offset(Foundation.Box.GetOffsets(this.$element, this.$anchor, 'center bottom', this.options.vOffset, this.options.hOffset + parentHOffset, true)).css({\n        'width': newWidth - (this.options.hOffset * 2),\n        'height': 'auto'\n      });\n      this.classChanged = true;\n      return false;\n    }\n\n    this.$element.offset(Foundation.Box.GetOffsets(this.$element, this.$anchor, position, this.options.vOffset, this.options.hOffset));\n\n    while(!Foundation.Box.ImNotTouchingYou(this.$element, this.$parent, true) && this.counter){\n      this._reposition(position);\n      this._setPosition();\n    }\n  }\n\n  /**\n   * Adds event listeners to the element utilizing the triggers utility library.\n   * @function\n   * @private\n   */\n  _events() {\n    var _this = this;\n    this.$element.on({\n      'open.zf.trigger': this.open.bind(this),\n      'close.zf.trigger': this.close.bind(this),\n      'toggle.zf.trigger': this.toggle.bind(this),\n      'resizeme.zf.trigger': this._setPosition.bind(this)\n    });\n\n    if(this.options.hover){\n      this.$anchor.off('mouseenter.zf.dropdown mouseleave.zf.dropdown')\n      .on('mouseenter.zf.dropdown', function(){\n        var bodyData = $('body').data();\n        if(typeof(bodyData.whatinput) === 'undefined' || bodyData.whatinput === 'mouse') {\n          clearTimeout(_this.timeout);\n          _this.timeout = setTimeout(function(){\n            _this.open();\n            _this.$anchor.data('hover', true);\n          }, _this.options.hoverDelay);\n        }\n      }).on('mouseleave.zf.dropdown', function(){\n        clearTimeout(_this.timeout);\n        _this.timeout = setTimeout(function(){\n          _this.close();\n          _this.$anchor.data('hover', false);\n        }, _this.options.hoverDelay);\n      });\n      if(this.options.hoverPane){\n        this.$element.off('mouseenter.zf.dropdown mouseleave.zf.dropdown')\n            .on('mouseenter.zf.dropdown', function(){\n              clearTimeout(_this.timeout);\n            }).on('mouseleave.zf.dropdown', function(){\n              clearTimeout(_this.timeout);\n              _this.timeout = setTimeout(function(){\n                _this.close();\n                _this.$anchor.data('hover', false);\n              }, _this.options.hoverDelay);\n            });\n      }\n    }\n    this.$anchor.add(this.$element).on('keydown.zf.dropdown', function(e) {\n\n      var $target = $(this),\n        visibleFocusableElements = Foundation.Keyboard.findFocusable(_this.$element);\n\n      Foundation.Keyboard.handleKey(e, 'Dropdown', {\n        open: function() {\n          if ($target.is(_this.$anchor)) {\n            _this.open();\n            _this.$element.attr('tabindex', -1).focus();\n            e.preventDefault();\n          }\n        },\n        close: function() {\n          _this.close();\n          _this.$anchor.focus();\n        }\n      });\n    });\n  }\n\n  /**\n   * Adds an event handler to the body to close any dropdowns on a click.\n   * @function\n   * @private\n   */\n  _addBodyHandler() {\n     var $body = $(document.body).not(this.$element),\n         _this = this;\n     $body.off('click.zf.dropdown')\n          .on('click.zf.dropdown', function(e){\n            if(_this.$anchor.is(e.target) || _this.$anchor.find(e.target).length) {\n              return;\n            }\n            if(_this.$element.find(e.target).length) {\n              return;\n            }\n            _this.close();\n            $body.off('click.zf.dropdown');\n          });\n  }\n\n  /**\n   * Opens the dropdown pane, and fires a bubbling event to close other dropdowns.\n   * @function\n   * @fires Dropdown#closeme\n   * @fires Dropdown#show\n   */\n  open() {\n    // var _this = this;\n    /**\n     * Fires to close other open dropdowns, typically when dropdown is opening\n     * @event Dropdown#closeme\n     */\n    this.$element.trigger('closeme.zf.dropdown', this.$element.attr('id'));\n    this.$anchor.addClass('hover')\n        .attr({'aria-expanded': true});\n    // this.$element/*.show()*/;\n    this._setPosition();\n    this.$element.addClass('is-open')\n        .attr({'aria-hidden': false});\n\n    if(this.options.autoFocus){\n      var $focusable = Foundation.Keyboard.findFocusable(this.$element);\n      if($focusable.length){\n        $focusable.eq(0).focus();\n      }\n    }\n\n    if(this.options.closeOnClick){ this._addBodyHandler(); }\n\n    if (this.options.trapFocus) {\n      Foundation.Keyboard.trapFocus(this.$element);\n    }\n\n    /**\n     * Fires once the dropdown is visible.\n     * @event Dropdown#show\n     */\n    this.$element.trigger('show.zf.dropdown', [this.$element]);\n  }\n\n  /**\n   * Closes the open dropdown pane.\n   * @function\n   * @fires Dropdown#hide\n   */\n  close() {\n    if(!this.$element.hasClass('is-open')){\n      return false;\n    }\n    this.$element.removeClass('is-open')\n        .attr({'aria-hidden': true});\n\n    this.$anchor.removeClass('hover')\n        .attr('aria-expanded', false);\n\n    if(this.classChanged){\n      var curPositionClass = this.getPositionClass();\n      if(curPositionClass){\n        this.$element.removeClass(curPositionClass);\n      }\n      this.$element.addClass(this.options.positionClass)\n          /*.hide()*/.css({height: '', width: ''});\n      this.classChanged = false;\n      this.counter = 4;\n      this.usedPositions.length = 0;\n    }\n    /**\n     * Fires once the dropdown is no longer visible.\n     * @event Dropdown#hide\n     */\n    this.$element.trigger('hide.zf.dropdown', [this.$element]);\n\n    if (this.options.trapFocus) {\n      Foundation.Keyboard.releaseFocus(this.$element);\n    }\n  }\n\n  /**\n   * Toggles the dropdown pane's visibility.\n   * @function\n   */\n  toggle() {\n    if(this.$element.hasClass('is-open')){\n      if(this.$anchor.data('hover')) return;\n      this.close();\n    }else{\n      this.open();\n    }\n  }\n\n  /**\n   * Destroys the dropdown.\n   * @function\n   */\n  destroy() {\n    this.$element.off('.zf.trigger').hide();\n    this.$anchor.off('.zf.dropdown');\n\n    Foundation.unregisterPlugin(this);\n  }\n}\n\nDropdown.defaults = {\n  /**\n   * Class that designates bounding container of Dropdown (default: window)\n   * @option\n   * @type {?string}\n   * @default null\n   */\n  parentClass: null,\n  /**\n   * Amount of time to delay opening a submenu on hover event.\n   * @option\n   * @type {number}\n   * @default 250\n   */\n  hoverDelay: 250,\n  /**\n   * Allow submenus to open on hover events\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  hover: false,\n  /**\n   * Don't close dropdown when hovering over dropdown pane\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  hoverPane: false,\n  /**\n   * Number of pixels between the dropdown pane and the triggering element on open.\n   * @option\n   * @type {number}\n   * @default 1\n   */\n  vOffset: 1,\n  /**\n   * Number of pixels between the dropdown pane and the triggering element on open.\n   * @option\n   * @type {number}\n   * @default 1\n   */\n  hOffset: 1,\n  /**\n   * Class applied to adjust open position. JS will test and fill this in.\n   * @option\n   * @type {string}\n   * @default ''\n   */\n  positionClass: '',\n  /**\n   * Allow the plugin to trap focus to the dropdown pane if opened with keyboard commands.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  trapFocus: false,\n  /**\n   * Allow the plugin to set focus to the first focusable element within the pane, regardless of method of opening.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  autoFocus: false,\n  /**\n   * Allows a click on the body to close the dropdown.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  closeOnClick: false\n}\n\n// Window exports\nFoundation.plugin(Dropdown, 'Dropdown');\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * DropdownMenu module.\n * @module foundation.dropdown-menu\n * @requires foundation.util.keyboard\n * @requires foundation.util.box\n * @requires foundation.util.nest\n */\n\nclass DropdownMenu {\n  /**\n   * Creates a new instance of DropdownMenu.\n   * @class\n   * @fires DropdownMenu#init\n   * @param {jQuery} element - jQuery object to make into a dropdown menu.\n   * @param {Object} options - Overrides to the default plugin settings.\n   */\n  constructor(element, options) {\n    this.$element = element;\n    this.options = $.extend({}, DropdownMenu.defaults, this.$element.data(), options);\n\n    Foundation.Nest.Feather(this.$element, 'dropdown');\n    this._init();\n\n    Foundation.registerPlugin(this, 'DropdownMenu');\n    Foundation.Keyboard.register('DropdownMenu', {\n      'ENTER': 'open',\n      'SPACE': 'open',\n      'ARROW_RIGHT': 'next',\n      'ARROW_UP': 'up',\n      'ARROW_DOWN': 'down',\n      'ARROW_LEFT': 'previous',\n      'ESCAPE': 'close'\n    });\n  }\n\n  /**\n   * Initializes the plugin, and calls _prepareMenu\n   * @private\n   * @function\n   */\n  _init() {\n    var subs = this.$element.find('li.is-dropdown-submenu-parent');\n    this.$element.children('.is-dropdown-submenu-parent').children('.is-dropdown-submenu').addClass('first-sub');\n\n    this.$menuItems = this.$element.find('[role=\"menuitem\"]');\n    this.$tabs = this.$element.children('[role=\"menuitem\"]');\n    this.$tabs.find('ul.is-dropdown-submenu').addClass(this.options.verticalClass);\n\n    if (this.$element.hasClass(this.options.rightClass) || this.options.alignment === 'right' || Foundation.rtl() || this.$element.parents('.top-bar-right').is('*')) {\n      this.options.alignment = 'right';\n      subs.addClass('opens-left');\n    } else {\n      subs.addClass('opens-right');\n    }\n    this.changed = false;\n    this._events();\n  };\n\n  _isVertical() {\n    return this.$tabs.css('display') === 'block';\n  }\n\n  /**\n   * Adds event listeners to elements within the menu\n   * @private\n   * @function\n   */\n  _events() {\n    var _this = this,\n        hasTouch = 'ontouchstart' in window || (typeof window.ontouchstart !== 'undefined'),\n        parClass = 'is-dropdown-submenu-parent';\n\n    // used for onClick and in the keyboard handlers\n    var handleClickFn = function(e) {\n      var $elem = $(e.target).parentsUntil('ul', `.${parClass}`),\n          hasSub = $elem.hasClass(parClass),\n          hasClicked = $elem.attr('data-is-click') === 'true',\n          $sub = $elem.children('.is-dropdown-submenu');\n\n      if (hasSub) {\n        if (hasClicked) {\n          if (!_this.options.closeOnClick || (!_this.options.clickOpen && !hasTouch) || (_this.options.forceFollow && hasTouch)) { return; }\n          else {\n            e.stopImmediatePropagation();\n            e.preventDefault();\n            _this._hide($elem);\n          }\n        } else {\n          e.preventDefault();\n          e.stopImmediatePropagation();\n          _this._show($sub);\n          $elem.add($elem.parentsUntil(_this.$element, `.${parClass}`)).attr('data-is-click', true);\n        }\n      }\n    };\n\n    if (this.options.clickOpen || hasTouch) {\n      this.$menuItems.on('click.zf.dropdownmenu touchstart.zf.dropdownmenu', handleClickFn);\n    }\n\n    // Handle Leaf element Clicks\n    if(_this.options.closeOnClickInside){\n      this.$menuItems.on('click.zf.dropdownmenu', function(e) {\n        var $elem = $(this),\n            hasSub = $elem.hasClass(parClass);\n        if(!hasSub){\n          _this._hide();\n        }\n      });\n    }\n\n    if (!this.options.disableHover) {\n      this.$menuItems.on('mouseenter.zf.dropdownmenu', function(e) {\n        var $elem = $(this),\n            hasSub = $elem.hasClass(parClass);\n\n        if (hasSub) {\n          clearTimeout($elem.data('_delay'));\n          $elem.data('_delay', setTimeout(function() {\n            _this._show($elem.children('.is-dropdown-submenu'));\n          }, _this.options.hoverDelay));\n        }\n      }).on('mouseleave.zf.dropdownmenu', function(e) {\n        var $elem = $(this),\n            hasSub = $elem.hasClass(parClass);\n        if (hasSub && _this.options.autoclose) {\n          if ($elem.attr('data-is-click') === 'true' && _this.options.clickOpen) { return false; }\n\n          clearTimeout($elem.data('_delay'));\n          $elem.data('_delay', setTimeout(function() {\n            _this._hide($elem);\n          }, _this.options.closingTime));\n        }\n      });\n    }\n    this.$menuItems.on('keydown.zf.dropdownmenu', function(e) {\n      var $element = $(e.target).parentsUntil('ul', '[role=\"menuitem\"]'),\n          isTab = _this.$tabs.index($element) > -1,\n          $elements = isTab ? _this.$tabs : $element.siblings('li').add($element),\n          $prevElement,\n          $nextElement;\n\n      $elements.each(function(i) {\n        if ($(this).is($element)) {\n          $prevElement = $elements.eq(i-1);\n          $nextElement = $elements.eq(i+1);\n          return;\n        }\n      });\n\n      var nextSibling = function() {\n        if (!$element.is(':last-child')) {\n          $nextElement.children('a:first').focus();\n          e.preventDefault();\n        }\n      }, prevSibling = function() {\n        $prevElement.children('a:first').focus();\n        e.preventDefault();\n      }, openSub = function() {\n        var $sub = $element.children('ul.is-dropdown-submenu');\n        if ($sub.length) {\n          _this._show($sub);\n          $element.find('li > a:first').focus();\n          e.preventDefault();\n        } else { return; }\n      }, closeSub = function() {\n        //if ($element.is(':first-child')) {\n        var close = $element.parent('ul').parent('li');\n        close.children('a:first').focus();\n        _this._hide(close);\n        e.preventDefault();\n        //}\n      };\n      var functions = {\n        open: openSub,\n        close: function() {\n          _this._hide(_this.$element);\n          _this.$menuItems.find('a:first').focus(); // focus to first element\n          e.preventDefault();\n        },\n        handled: function() {\n          e.stopImmediatePropagation();\n        }\n      };\n\n      if (isTab) {\n        if (_this._isVertical()) { // vertical menu\n          if (Foundation.rtl()) { // right aligned\n            $.extend(functions, {\n              down: nextSibling,\n              up: prevSibling,\n              next: closeSub,\n              previous: openSub\n            });\n          } else { // left aligned\n            $.extend(functions, {\n              down: nextSibling,\n              up: prevSibling,\n              next: openSub,\n              previous: closeSub\n            });\n          }\n        } else { // horizontal menu\n          if (Foundation.rtl()) { // right aligned\n            $.extend(functions, {\n              next: prevSibling,\n              previous: nextSibling,\n              down: openSub,\n              up: closeSub\n            });\n          } else { // left aligned\n            $.extend(functions, {\n              next: nextSibling,\n              previous: prevSibling,\n              down: openSub,\n              up: closeSub\n            });\n          }\n        }\n      } else { // not tabs -> one sub\n        if (Foundation.rtl()) { // right aligned\n          $.extend(functions, {\n            next: closeSub,\n            previous: openSub,\n            down: nextSibling,\n            up: prevSibling\n          });\n        } else { // left aligned\n          $.extend(functions, {\n            next: openSub,\n            previous: closeSub,\n            down: nextSibling,\n            up: prevSibling\n          });\n        }\n      }\n      Foundation.Keyboard.handleKey(e, 'DropdownMenu', functions);\n\n    });\n  }\n\n  /**\n   * Adds an event handler to the body to close any dropdowns on a click.\n   * @function\n   * @private\n   */\n  _addBodyHandler() {\n    var $body = $(document.body),\n        _this = this;\n    $body.off('mouseup.zf.dropdownmenu touchend.zf.dropdownmenu')\n         .on('mouseup.zf.dropdownmenu touchend.zf.dropdownmenu', function(e) {\n           var $link = _this.$element.find(e.target);\n           if ($link.length) { return; }\n\n           _this._hide();\n           $body.off('mouseup.zf.dropdownmenu touchend.zf.dropdownmenu');\n         });\n  }\n\n  /**\n   * Opens a dropdown pane, and checks for collisions first.\n   * @param {jQuery} $sub - ul element that is a submenu to show\n   * @function\n   * @private\n   * @fires DropdownMenu#show\n   */\n  _show($sub) {\n    var idx = this.$tabs.index(this.$tabs.filter(function(i, el) {\n      return $(el).find($sub).length > 0;\n    }));\n    var $sibs = $sub.parent('li.is-dropdown-submenu-parent').siblings('li.is-dropdown-submenu-parent');\n    this._hide($sibs, idx);\n    $sub.css('visibility', 'hidden').addClass('js-dropdown-active')\n        .parent('li.is-dropdown-submenu-parent').addClass('is-active');\n    var clear = Foundation.Box.ImNotTouchingYou($sub, null, true);\n    if (!clear) {\n      var oldClass = this.options.alignment === 'left' ? '-right' : '-left',\n          $parentLi = $sub.parent('.is-dropdown-submenu-parent');\n      $parentLi.removeClass(`opens${oldClass}`).addClass(`opens-${this.options.alignment}`);\n      clear = Foundation.Box.ImNotTouchingYou($sub, null, true);\n      if (!clear) {\n        $parentLi.removeClass(`opens-${this.options.alignment}`).addClass('opens-inner');\n      }\n      this.changed = true;\n    }\n    $sub.css('visibility', '');\n    if (this.options.closeOnClick) { this._addBodyHandler(); }\n    /**\n     * Fires when the new dropdown pane is visible.\n     * @event DropdownMenu#show\n     */\n    this.$element.trigger('show.zf.dropdownmenu', [$sub]);\n  }\n\n  /**\n   * Hides a single, currently open dropdown pane, if passed a parameter, otherwise, hides everything.\n   * @function\n   * @param {jQuery} $elem - element with a submenu to hide\n   * @param {Number} idx - index of the $tabs collection to hide\n   * @private\n   */\n  _hide($elem, idx) {\n    var $toClose;\n    if ($elem && $elem.length) {\n      $toClose = $elem;\n    } else if (idx !== undefined) {\n      $toClose = this.$tabs.not(function(i, el) {\n        return i === idx;\n      });\n    }\n    else {\n      $toClose = this.$element;\n    }\n    var somethingToClose = $toClose.hasClass('is-active') || $toClose.find('.is-active').length > 0;\n\n    if (somethingToClose) {\n      $toClose.find('li.is-active').add($toClose).attr({\n        'data-is-click': false\n      }).removeClass('is-active');\n\n      $toClose.find('ul.js-dropdown-active').removeClass('js-dropdown-active');\n\n      if (this.changed || $toClose.find('opens-inner').length) {\n        var oldClass = this.options.alignment === 'left' ? 'right' : 'left';\n        $toClose.find('li.is-dropdown-submenu-parent').add($toClose)\n                .removeClass(`opens-inner opens-${this.options.alignment}`)\n                .addClass(`opens-${oldClass}`);\n        this.changed = false;\n      }\n      /**\n       * Fires when the open menus are closed.\n       * @event DropdownMenu#hide\n       */\n      this.$element.trigger('hide.zf.dropdownmenu', [$toClose]);\n    }\n  }\n\n  /**\n   * Destroys the plugin.\n   * @function\n   */\n  destroy() {\n    this.$menuItems.off('.zf.dropdownmenu').removeAttr('data-is-click')\n        .removeClass('is-right-arrow is-left-arrow is-down-arrow opens-right opens-left opens-inner');\n    $(document.body).off('.zf.dropdownmenu');\n    Foundation.Nest.Burn(this.$element, 'dropdown');\n    Foundation.unregisterPlugin(this);\n  }\n}\n\n/**\n * Default settings for plugin\n */\nDropdownMenu.defaults = {\n  /**\n   * Disallows hover events from opening submenus\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  disableHover: false,\n  /**\n   * Allow a submenu to automatically close on a mouseleave event, if not clicked open.\n   * @option\n   * @type {boolean}\n   * @default true\n   */\n  autoclose: true,\n  /**\n   * Amount of time to delay opening a submenu on hover event.\n   * @option\n   * @type {number}\n   * @default 50\n   */\n  hoverDelay: 50,\n  /**\n   * Allow a submenu to open/remain open on parent click event. Allows cursor to move away from menu.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  clickOpen: false,\n  /**\n   * Amount of time to delay closing a submenu on a mouseleave event.\n   * @option\n   * @type {number}\n   * @default 500\n   */\n\n  closingTime: 500,\n  /**\n   * Position of the menu relative to what direction the submenus should open. Handled by JS. Can be `'left'` or `'right'`.\n   * @option\n   * @type {string}\n   * @default 'left'\n   */\n  alignment: 'left',\n  /**\n   * Allow clicks on the body to close any open submenus.\n   * @option\n   * @type {boolean}\n   * @default true\n   */\n  closeOnClick: true,\n  /**\n   * Allow clicks on leaf anchor links to close any open submenus.\n   * @option\n   * @type {boolean}\n   * @default true\n   */\n  closeOnClickInside: true,\n  /**\n   * Class applied to vertical oriented menus, Foundation default is `vertical`. Update this if using your own class.\n   * @option\n   * @type {string}\n   * @default 'vertical'\n   */\n  verticalClass: 'vertical',\n  /**\n   * Class applied to right-side oriented menus, Foundation default is `align-right`. Update this if using your own class.\n   * @option\n   * @type {string}\n   * @default 'align-right'\n   */\n  rightClass: 'align-right',\n  /**\n   * Boolean to force overide the clicking of links to perform default action, on second touch event for mobile.\n   * @option\n   * @type {boolean}\n   * @default true\n   */\n  forceFollow: true\n};\n\n// Window exports\nFoundation.plugin(DropdownMenu, 'DropdownMenu');\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * Equalizer module.\n * @module foundation.equalizer\n * @requires foundation.util.mediaQuery\n * @requires foundation.util.timerAndImageLoader if equalizer contains images\n */\n\nclass Equalizer {\n  /**\n   * Creates a new instance of Equalizer.\n   * @class\n   * @fires Equalizer#init\n   * @param {Object} element - jQuery object to add the trigger to.\n   * @param {Object} options - Overrides to the default plugin settings.\n   */\n  constructor(element, options){\n    this.$element = element;\n    this.options  = $.extend({}, Equalizer.defaults, this.$element.data(), options);\n\n    this._init();\n\n    Foundation.registerPlugin(this, 'Equalizer');\n  }\n\n  /**\n   * Initializes the Equalizer plugin and calls functions to get equalizer functioning on load.\n   * @private\n   */\n  _init() {\n    var eqId = this.$element.attr('data-equalizer') || '';\n    var $watched = this.$element.find(`[data-equalizer-watch=\"${eqId}\"]`);\n\n    this.$watched = $watched.length ? $watched : this.$element.find('[data-equalizer-watch]');\n    this.$element.attr('data-resize', (eqId || Foundation.GetYoDigits(6, 'eq')));\n\tthis.$element.attr('data-mutate', (eqId || Foundation.GetYoDigits(6, 'eq')));\n\n    this.hasNested = this.$element.find('[data-equalizer]').length > 0;\n    this.isNested = this.$element.parentsUntil(document.body, '[data-equalizer]').length > 0;\n    this.isOn = false;\n    this._bindHandler = {\n      onResizeMeBound: this._onResizeMe.bind(this),\n      onPostEqualizedBound: this._onPostEqualized.bind(this)\n    };\n\n    var imgs = this.$element.find('img');\n    var tooSmall;\n    if(this.options.equalizeOn){\n      tooSmall = this._checkMQ();\n      $(window).on('changed.zf.mediaquery', this._checkMQ.bind(this));\n    }else{\n      this._events();\n    }\n    if((tooSmall !== undefined && tooSmall === false) || tooSmall === undefined){\n      if(imgs.length){\n        Foundation.onImagesLoaded(imgs, this._reflow.bind(this));\n      }else{\n        this._reflow();\n      }\n    }\n  }\n\n  /**\n   * Removes event listeners if the breakpoint is too small.\n   * @private\n   */\n  _pauseEvents() {\n    this.isOn = false;\n    this.$element.off({\n      '.zf.equalizer': this._bindHandler.onPostEqualizedBound,\n      'resizeme.zf.trigger': this._bindHandler.onResizeMeBound,\n\t  'mutateme.zf.trigger': this._bindHandler.onResizeMeBound\n    });\n  }\n\n  /**\n   * function to handle $elements resizeme.zf.trigger, with bound this on _bindHandler.onResizeMeBound\n   * @private\n   */\n  _onResizeMe(e) {\n    this._reflow();\n  }\n\n  /**\n   * function to handle $elements postequalized.zf.equalizer, with bound this on _bindHandler.onPostEqualizedBound\n   * @private\n   */\n  _onPostEqualized(e) {\n    if(e.target !== this.$element[0]){ this._reflow(); }\n  }\n\n  /**\n   * Initializes events for Equalizer.\n   * @private\n   */\n  _events() {\n    var _this = this;\n    this._pauseEvents();\n    if(this.hasNested){\n      this.$element.on('postequalized.zf.equalizer', this._bindHandler.onPostEqualizedBound);\n    }else{\n      this.$element.on('resizeme.zf.trigger', this._bindHandler.onResizeMeBound);\n\t  this.$element.on('mutateme.zf.trigger', this._bindHandler.onResizeMeBound);\n    }\n    this.isOn = true;\n  }\n\n  /**\n   * Checks the current breakpoint to the minimum required size.\n   * @private\n   */\n  _checkMQ() {\n    var tooSmall = !Foundation.MediaQuery.is(this.options.equalizeOn);\n    if(tooSmall){\n      if(this.isOn){\n        this._pauseEvents();\n        this.$watched.css('height', 'auto');\n      }\n    }else{\n      if(!this.isOn){\n        this._events();\n      }\n    }\n    return tooSmall;\n  }\n\n  /**\n   * A noop version for the plugin\n   * @private\n   */\n  _killswitch() {\n    return;\n  }\n\n  /**\n   * Calls necessary functions to update Equalizer upon DOM change\n   * @private\n   */\n  _reflow() {\n    if(!this.options.equalizeOnStack){\n      if(this._isStacked()){\n        this.$watched.css('height', 'auto');\n        return false;\n      }\n    }\n    if (this.options.equalizeByRow) {\n      this.getHeightsByRow(this.applyHeightByRow.bind(this));\n    }else{\n      this.getHeights(this.applyHeight.bind(this));\n    }\n  }\n\n  /**\n   * Manually determines if the first 2 elements are *NOT* stacked.\n   * @private\n   */\n  _isStacked() {\n    if (!this.$watched[0] || !this.$watched[1]) {\n      return true;\n    }\n    return this.$watched[0].getBoundingClientRect().top !== this.$watched[1].getBoundingClientRect().top;\n  }\n\n  /**\n   * Finds the outer heights of children contained within an Equalizer parent and returns them in an array\n   * @param {Function} cb - A non-optional callback to return the heights array to.\n   * @returns {Array} heights - An array of heights of children within Equalizer container\n   */\n  getHeights(cb) {\n    var heights = [];\n    for(var i = 0, len = this.$watched.length; i < len; i++){\n      this.$watched[i].style.height = 'auto';\n      heights.push(this.$watched[i].offsetHeight);\n    }\n    cb(heights);\n  }\n\n  /**\n   * Finds the outer heights of children contained within an Equalizer parent and returns them in an array\n   * @param {Function} cb - A non-optional callback to return the heights array to.\n   * @returns {Array} groups - An array of heights of children within Equalizer container grouped by row with element,height and max as last child\n   */\n  getHeightsByRow(cb) {\n    var lastElTopOffset = (this.$watched.length ? this.$watched.first().offset().top : 0),\n        groups = [],\n        group = 0;\n    //group by Row\n    groups[group] = [];\n    for(var i = 0, len = this.$watched.length; i < len; i++){\n      this.$watched[i].style.height = 'auto';\n      //maybe could use this.$watched[i].offsetTop\n      var elOffsetTop = $(this.$watched[i]).offset().top;\n      if (elOffsetTop!=lastElTopOffset) {\n        group++;\n        groups[group] = [];\n        lastElTopOffset=elOffsetTop;\n      }\n      groups[group].push([this.$watched[i],this.$watched[i].offsetHeight]);\n    }\n\n    for (var j = 0, ln = groups.length; j < ln; j++) {\n      var heights = $(groups[j]).map(function(){ return this[1]; }).get();\n      var max         = Math.max.apply(null, heights);\n      groups[j].push(max);\n    }\n    cb(groups);\n  }\n\n  /**\n   * Changes the CSS height property of each child in an Equalizer parent to match the tallest\n   * @param {array} heights - An array of heights of children within Equalizer container\n   * @fires Equalizer#preequalized\n   * @fires Equalizer#postequalized\n   */\n  applyHeight(heights) {\n    var max = Math.max.apply(null, heights);\n    /**\n     * Fires before the heights are applied\n     * @event Equalizer#preequalized\n     */\n    this.$element.trigger('preequalized.zf.equalizer');\n\n    this.$watched.css('height', max);\n\n    /**\n     * Fires when the heights have been applied\n     * @event Equalizer#postequalized\n     */\n     this.$element.trigger('postequalized.zf.equalizer');\n  }\n\n  /**\n   * Changes the CSS height property of each child in an Equalizer parent to match the tallest by row\n   * @param {array} groups - An array of heights of children within Equalizer container grouped by row with element,height and max as last child\n   * @fires Equalizer#preequalized\n   * @fires Equalizer#preequalizedrow\n   * @fires Equalizer#postequalizedrow\n   * @fires Equalizer#postequalized\n   */\n  applyHeightByRow(groups) {\n    /**\n     * Fires before the heights are applied\n     */\n    this.$element.trigger('preequalized.zf.equalizer');\n    for (var i = 0, len = groups.length; i < len ; i++) {\n      var groupsILength = groups[i].length,\n          max = groups[i][groupsILength - 1];\n      if (groupsILength<=2) {\n        $(groups[i][0][0]).css({'height':'auto'});\n        continue;\n      }\n      /**\n        * Fires before the heights per row are applied\n        * @event Equalizer#preequalizedrow\n        */\n      this.$element.trigger('preequalizedrow.zf.equalizer');\n      for (var j = 0, lenJ = (groupsILength-1); j < lenJ ; j++) {\n        $(groups[i][j][0]).css({'height':max});\n      }\n      /**\n        * Fires when the heights per row have been applied\n        * @event Equalizer#postequalizedrow\n        */\n      this.$element.trigger('postequalizedrow.zf.equalizer');\n    }\n    /**\n     * Fires when the heights have been applied\n     */\n     this.$element.trigger('postequalized.zf.equalizer');\n  }\n\n  /**\n   * Destroys an instance of Equalizer.\n   * @function\n   */\n  destroy() {\n    this._pauseEvents();\n    this.$watched.css('height', 'auto');\n\n    Foundation.unregisterPlugin(this);\n  }\n}\n\n/**\n * Default settings for plugin\n */\nEqualizer.defaults = {\n  /**\n   * Enable height equalization when stacked on smaller screens.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  equalizeOnStack: false,\n  /**\n   * Enable height equalization row by row.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  equalizeByRow: false,\n  /**\n   * String representing the minimum breakpoint size the plugin should equalize heights on.\n   * @option\n   * @type {string}\n   * @default ''\n   */\n  equalizeOn: ''\n};\n\n// Window exports\nFoundation.plugin(Equalizer, 'Equalizer');\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * Interchange module.\n * @module foundation.interchange\n * @requires foundation.util.mediaQuery\n * @requires foundation.util.timerAndImageLoader\n */\n\nclass Interchange {\n  /**\n   * Creates a new instance of Interchange.\n   * @class\n   * @fires Interchange#init\n   * @param {Object} element - jQuery object to add the trigger to.\n   * @param {Object} options - Overrides to the default plugin settings.\n   */\n  constructor(element, options) {\n    this.$element = element;\n    this.options = $.extend({}, Interchange.defaults, options);\n    this.rules = [];\n    this.currentPath = '';\n\n    this._init();\n    this._events();\n\n    Foundation.registerPlugin(this, 'Interchange');\n  }\n\n  /**\n   * Initializes the Interchange plugin and calls functions to get interchange functioning on load.\n   * @function\n   * @private\n   */\n  _init() {\n    this._addBreakpoints();\n    this._generateRules();\n    this._reflow();\n  }\n\n  /**\n   * Initializes events for Interchange.\n   * @function\n   * @private\n   */\n  _events() {\n    $(window).on('resize.zf.interchange', Foundation.util.throttle(() => {\n      this._reflow();\n    }, 50));\n  }\n\n  /**\n   * Calls necessary functions to update Interchange upon DOM change\n   * @function\n   * @private\n   */\n  _reflow() {\n    var match;\n\n    // Iterate through each rule, but only save the last match\n    for (var i in this.rules) {\n      if(this.rules.hasOwnProperty(i)) {\n        var rule = this.rules[i];\n        if (window.matchMedia(rule.query).matches) {\n          match = rule;\n        }\n      }\n    }\n\n    if (match) {\n      this.replace(match.path);\n    }\n  }\n\n  /**\n   * Gets the Foundation breakpoints and adds them to the Interchange.SPECIAL_QUERIES object.\n   * @function\n   * @private\n   */\n  _addBreakpoints() {\n    for (var i in Foundation.MediaQuery.queries) {\n      if (Foundation.MediaQuery.queries.hasOwnProperty(i)) {\n        var query = Foundation.MediaQuery.queries[i];\n        Interchange.SPECIAL_QUERIES[query.name] = query.value;\n      }\n    }\n  }\n\n  /**\n   * Checks the Interchange element for the provided media query + content pairings\n   * @function\n   * @private\n   * @param {Object} element - jQuery object that is an Interchange instance\n   * @returns {Array} scenarios - Array of objects that have 'mq' and 'path' keys with corresponding keys\n   */\n  _generateRules(element) {\n    var rulesList = [];\n    var rules;\n\n    if (this.options.rules) {\n      rules = this.options.rules;\n    }\n    else {\n      rules = this.$element.data('interchange');\n    }\n    \n    rules =  typeof rules === 'string' ? rules.match(/\\[.*?\\]/g) : rules;\n\n    for (var i in rules) {\n      if(rules.hasOwnProperty(i)) {\n        var rule = rules[i].slice(1, -1).split(', ');\n        var path = rule.slice(0, -1).join('');\n        var query = rule[rule.length - 1];\n\n        if (Interchange.SPECIAL_QUERIES[query]) {\n          query = Interchange.SPECIAL_QUERIES[query];\n        }\n\n        rulesList.push({\n          path: path,\n          query: query\n        });\n      }\n    }\n\n    this.rules = rulesList;\n  }\n\n  /**\n   * Update the `src` property of an image, or change the HTML of a container, to the specified path.\n   * @function\n   * @param {String} path - Path to the image or HTML partial.\n   * @fires Interchange#replaced\n   */\n  replace(path) {\n    if (this.currentPath === path) return;\n\n    var _this = this,\n        trigger = 'replaced.zf.interchange';\n\n    // Replacing images\n    if (this.$element[0].nodeName === 'IMG') {\n      this.$element.attr('src', path).on('load', function() {\n        _this.currentPath = path;\n      })\n      .trigger(trigger);\n    }\n    // Replacing background images\n    else if (path.match(/\\.(gif|jpg|jpeg|png|svg|tiff)([?#].*)?/i)) {\n      this.$element.css({ 'background-image': 'url('+path+')' })\n          .trigger(trigger);\n    }\n    // Replacing HTML\n    else {\n      $.get(path, function(response) {\n        _this.$element.html(response)\n             .trigger(trigger);\n        $(response).foundation();\n        _this.currentPath = path;\n      });\n    }\n\n    /**\n     * Fires when content in an Interchange element is done being loaded.\n     * @event Interchange#replaced\n     */\n    // this.$element.trigger('replaced.zf.interchange');\n  }\n\n  /**\n   * Destroys an instance of interchange.\n   * @function\n   */\n  destroy() {\n    //TODO this.\n  }\n}\n\n/**\n * Default settings for plugin\n */\nInterchange.defaults = {\n  /**\n   * Rules to be applied to Interchange elements. Set with the `data-interchange` array notation.\n   * @option\n   * @type {?array}\n   * @default null\n   */\n  rules: null\n};\n\nInterchange.SPECIAL_QUERIES = {\n  'landscape': 'screen and (orientation: landscape)',\n  'portrait': 'screen and (orientation: portrait)',\n  '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)'\n};\n\n// Window exports\nFoundation.plugin(Interchange, 'Interchange');\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * Magellan module.\n * @module foundation.magellan\n */\n\nclass Magellan {\n  /**\n   * Creates a new instance of Magellan.\n   * @class\n   * @fires Magellan#init\n   * @param {Object} element - jQuery object to add the trigger to.\n   * @param {Object} options - Overrides to the default plugin settings.\n   */\n  constructor(element, options) {\n    this.$element = element;\n    this.options  = $.extend({}, Magellan.defaults, this.$element.data(), options);\n\n    this._init();\n    this.calcPoints();\n\n    Foundation.registerPlugin(this, 'Magellan');\n  }\n\n  /**\n   * Initializes the Magellan plugin and calls functions to get equalizer functioning on load.\n   * @private\n   */\n  _init() {\n    var id = this.$element[0].id || Foundation.GetYoDigits(6, 'magellan');\n    var _this = this;\n    this.$targets = $('[data-magellan-target]');\n    this.$links = this.$element.find('a');\n    this.$element.attr({\n      'data-resize': id,\n      'data-scroll': id,\n      'id': id\n    });\n    this.$active = $();\n    this.scrollPos = parseInt(window.pageYOffset, 10);\n\n    this._events();\n  }\n\n  /**\n   * Calculates an array of pixel values that are the demarcation lines between locations on the page.\n   * Can be invoked if new elements are added or the size of a location changes.\n   * @function\n   */\n  calcPoints() {\n    var _this = this,\n        body = document.body,\n        html = document.documentElement;\n\n    this.points = [];\n    this.winHeight = Math.round(Math.max(window.innerHeight, html.clientHeight));\n    this.docHeight = Math.round(Math.max(body.scrollHeight, body.offsetHeight, html.clientHeight, html.scrollHeight, html.offsetHeight));\n\n    this.$targets.each(function(){\n      var $tar = $(this),\n          pt = Math.round($tar.offset().top - _this.options.threshold);\n      $tar.targetPoint = pt;\n      _this.points.push(pt);\n    });\n  }\n\n  /**\n   * Initializes events for Magellan.\n   * @private\n   */\n  _events() {\n    var _this = this,\n        $body = $('html, body'),\n        opts = {\n          duration: _this.options.animationDuration,\n          easing:   _this.options.animationEasing\n        };\n    $(window).one('load', function(){\n      if(_this.options.deepLinking){\n        if(location.hash){\n          _this.scrollToLoc(location.hash);\n        }\n      }\n      _this.calcPoints();\n      _this._updateActive();\n    });\n\n    this.$element.on({\n      'resizeme.zf.trigger': this.reflow.bind(this),\n      'scrollme.zf.trigger': this._updateActive.bind(this)\n    }).on('click.zf.magellan', 'a[href^=\"#\"]', function(e) {\n        e.preventDefault();\n        var arrival   = this.getAttribute('href');\n        _this.scrollToLoc(arrival);\n      });\n    $(window).on('popstate', function(e) {\n      if(_this.options.deepLinking) {\n        _this.scrollToLoc(window.location.hash);\n      }\n    });\n  }\n\n  /**\n   * Function to scroll to a given location on the page.\n   * @param {String} loc - a properly formatted jQuery id selector. Example: '#foo'\n   * @function\n   */\n  scrollToLoc(loc) {\n    // Do nothing if target does not exist to prevent errors\n    if (!$(loc).length) {return false;}\n    this._inTransition = true;\n    var _this = this,\n        scrollPos = Math.round($(loc).offset().top - this.options.threshold / 2 - this.options.barOffset);\n\n    $('html, body').stop(true).animate(\n      { scrollTop: scrollPos },\n      this.options.animationDuration,\n      this.options.animationEasing,\n      function() {_this._inTransition = false; _this._updateActive()}\n    );\n  }\n\n  /**\n   * Calls necessary functions to update Magellan upon DOM change\n   * @function\n   */\n  reflow() {\n    this.calcPoints();\n    this._updateActive();\n  }\n\n  /**\n   * Updates the visibility of an active location link, and updates the url hash for the page, if deepLinking enabled.\n   * @private\n   * @function\n   * @fires Magellan#update\n   */\n  _updateActive(/*evt, elem, scrollPos*/) {\n    if(this._inTransition) {return;}\n    var winPos = /*scrollPos ||*/ parseInt(window.pageYOffset, 10),\n        curIdx;\n\n    if(winPos + this.winHeight === this.docHeight){ curIdx = this.points.length - 1; }\n    else if(winPos < this.points[0]){ curIdx = undefined; }\n    else{\n      var isDown = this.scrollPos < winPos,\n          _this = this,\n          curVisible = this.points.filter(function(p, i){\n            return isDown ? p - _this.options.barOffset <= winPos : p - _this.options.barOffset - _this.options.threshold <= winPos;\n          });\n      curIdx = curVisible.length ? curVisible.length - 1 : 0;\n    }\n\n    this.$active.removeClass(this.options.activeClass);\n    this.$active = this.$links.filter('[href=\"#' + this.$targets.eq(curIdx).data('magellan-target') + '\"]').addClass(this.options.activeClass);\n\n    if(this.options.deepLinking){\n      var hash = \"\";\n      if(curIdx != undefined){\n        hash = this.$active[0].getAttribute('href');\n      }\n      if(hash !== window.location.hash) {\n        if(window.history.pushState){\n          window.history.pushState(null, null, hash);\n        }else{\n          window.location.hash = hash;\n        }\n      }\n    }\n\n    this.scrollPos = winPos;\n    /**\n     * Fires when magellan is finished updating to the new active element.\n     * @event Magellan#update\n     */\n    this.$element.trigger('update.zf.magellan', [this.$active]);\n  }\n\n  /**\n   * Destroys an instance of Magellan and resets the url of the window.\n   * @function\n   */\n  destroy() {\n    this.$element.off('.zf.trigger .zf.magellan')\n        .find(`.${this.options.activeClass}`).removeClass(this.options.activeClass);\n\n    if(this.options.deepLinking){\n      var hash = this.$active[0].getAttribute('href');\n      window.location.hash.replace(hash, '');\n    }\n\n    Foundation.unregisterPlugin(this);\n  }\n}\n\n/**\n * Default settings for plugin\n */\nMagellan.defaults = {\n  /**\n   * Amount of time, in ms, the animated scrolling should take between locations.\n   * @option\n   * @type {number}\n   * @default 500\n   */\n  animationDuration: 500,\n  /**\n   * Animation style to use when scrolling between locations. Can be `'swing'` or `'linear'`.\n   * @option\n   * @type {string}\n   * @default 'linear'\n   * @see {@link https://api.jquery.com/animate|Jquery animate}\n   */\n  animationEasing: 'linear',\n  /**\n   * Number of pixels to use as a marker for location changes.\n   * @option\n   * @type {number}\n   * @default 50\n   */\n  threshold: 50,\n  /**\n   * Class applied to the active locations link on the magellan container.\n   * @option\n   * @type {string}\n   * @default 'active'\n   */\n  activeClass: 'active',\n  /**\n   * Allows the script to manipulate the url of the current page, and if supported, alter the history.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  deepLinking: false,\n  /**\n   * Number of pixels to offset the scroll of the page on item click if using a sticky nav bar.\n   * @option\n   * @type {number}\n   * @default 0\n   */\n  barOffset: 0\n}\n\n// Window exports\nFoundation.plugin(Magellan, 'Magellan');\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * OffCanvas module.\n * @module foundation.offcanvas\n * @requires foundation.util.keyboard\n * @requires foundation.util.mediaQuery\n * @requires foundation.util.triggers\n * @requires foundation.util.motion\n */\n\nclass OffCanvas {\n  /**\n   * Creates a new instance of an off-canvas wrapper.\n   * @class\n   * @fires OffCanvas#init\n   * @param {Object} element - jQuery object to initialize.\n   * @param {Object} options - Overrides to the default plugin settings.\n   */\n  constructor(element, options) {\n    this.$element = element;\n    this.options = $.extend({}, OffCanvas.defaults, this.$element.data(), options);\n    this.$lastTrigger = $();\n    this.$triggers = $();\n\n    this._init();\n    this._events();\n\n    Foundation.registerPlugin(this, 'OffCanvas')\n    Foundation.Keyboard.register('OffCanvas', {\n      'ESCAPE': 'close'\n    });\n\n  }\n\n  /**\n   * Initializes the off-canvas wrapper by adding the exit overlay (if needed).\n   * @function\n   * @private\n   */\n  _init() {\n    var id = this.$element.attr('id');\n\n    this.$element.attr('aria-hidden', 'true');\n\n    this.$element.addClass(`is-transition-${this.options.transition}`);\n\n    // Find triggers that affect this element and add aria-expanded to them\n    this.$triggers = $(document)\n      .find('[data-open=\"'+id+'\"], [data-close=\"'+id+'\"], [data-toggle=\"'+id+'\"]')\n      .attr('aria-expanded', 'false')\n      .attr('aria-controls', id);\n\n    // Add an overlay over the content if necessary\n    if (this.options.contentOverlay === true) {\n      var overlay = document.createElement('div');\n      var overlayPosition = $(this.$element).css(\"position\") === 'fixed' ? 'is-overlay-fixed' : 'is-overlay-absolute';\n      overlay.setAttribute('class', 'js-off-canvas-overlay ' + overlayPosition);\n      this.$overlay = $(overlay);\n      if(overlayPosition === 'is-overlay-fixed') {\n        $('body').append(this.$overlay);\n      } else {\n        this.$element.siblings('[data-off-canvas-content]').append(this.$overlay);\n      }\n    }\n\n    this.options.isRevealed = this.options.isRevealed || new RegExp(this.options.revealClass, 'g').test(this.$element[0].className);\n\n    if (this.options.isRevealed === true) {\n      this.options.revealOn = this.options.revealOn || this.$element[0].className.match(/(reveal-for-medium|reveal-for-large)/g)[0].split('-')[2];\n      this._setMQChecker();\n    }\n    if (!this.options.transitionTime === true) {\n      this.options.transitionTime = parseFloat(window.getComputedStyle($('[data-off-canvas]')[0]).transitionDuration) * 1000;\n    }\n  }\n\n  /**\n   * Adds event handlers to the off-canvas wrapper and the exit overlay.\n   * @function\n   * @private\n   */\n  _events() {\n    this.$element.off('.zf.trigger .zf.offcanvas').on({\n      'open.zf.trigger': this.open.bind(this),\n      'close.zf.trigger': this.close.bind(this),\n      'toggle.zf.trigger': this.toggle.bind(this),\n      'keydown.zf.offcanvas': this._handleKeyboard.bind(this)\n    });\n\n    if (this.options.closeOnClick === true) {\n      var $target = this.options.contentOverlay ? this.$overlay : $('[data-off-canvas-content]');\n      $target.on({'click.zf.offcanvas': this.close.bind(this)});\n    }\n  }\n\n  /**\n   * Applies event listener for elements that will reveal at certain breakpoints.\n   * @private\n   */\n  _setMQChecker() {\n    var _this = this;\n\n    $(window).on('changed.zf.mediaquery', function() {\n      if (Foundation.MediaQuery.atLeast(_this.options.revealOn)) {\n        _this.reveal(true);\n      } else {\n        _this.reveal(false);\n      }\n    }).one('load.zf.offcanvas', function() {\n      if (Foundation.MediaQuery.atLeast(_this.options.revealOn)) {\n        _this.reveal(true);\n      }\n    });\n  }\n\n  /**\n   * Handles the revealing/hiding the off-canvas at breakpoints, not the same as open.\n   * @param {Boolean} isRevealed - true if element should be revealed.\n   * @function\n   */\n  reveal(isRevealed) {\n    var $closer = this.$element.find('[data-close]');\n    if (isRevealed) {\n      this.close();\n      this.isRevealed = true;\n      this.$element.attr('aria-hidden', 'false');\n      this.$element.off('open.zf.trigger toggle.zf.trigger');\n      if ($closer.length) { $closer.hide(); }\n    } else {\n      this.isRevealed = false;\n      this.$element.attr('aria-hidden', 'true');\n      this.$element.off('open.zf.trigger toggle.zf.trigger').on({\n        'open.zf.trigger': this.open.bind(this),\n        'toggle.zf.trigger': this.toggle.bind(this)\n      });\n      if ($closer.length) {\n        $closer.show();\n      }\n    }\n  }\n\n  /**\n   * Stops scrolling of the body when offcanvas is open on mobile Safari and other troublesome browsers.\n   * @private\n   */\n  _stopScrolling(event) {\n    return false;\n  }\n\n  // Taken and adapted from http://stackoverflow.com/questions/16889447/prevent-full-page-scrolling-ios\n  // Only really works for y, not sure how to extend to x or if we need to.\n  _recordScrollable(event) {\n    let elem = this; // called from event handler context with this as elem\n\n     // If the element is scrollable (content overflows), then...\n    if (elem.scrollHeight !== elem.clientHeight) {\n      // If we're at the top, scroll down one pixel to allow scrolling up\n      if (elem.scrollTop === 0) {\n        elem.scrollTop = 1;\n      }\n      // If we're at the bottom, scroll up one pixel to allow scrolling down\n      if (elem.scrollTop === elem.scrollHeight - elem.clientHeight) {\n        elem.scrollTop = elem.scrollHeight - elem.clientHeight - 1;\n      }\n    }\n    elem.allowUp = elem.scrollTop > 0;\n    elem.allowDown = elem.scrollTop < (elem.scrollHeight - elem.clientHeight);\n    elem.lastY = event.originalEvent.pageY;\n  }\n\n  _stopScrollPropagation(event) {\n    let elem = this; // called from event handler context with this as elem\n    let up = event.pageY < elem.lastY;\n    let down = !up;\n    elem.lastY = event.pageY;\n\n    if((up && elem.allowUp) || (down && elem.allowDown)) {\n      event.stopPropagation();\n    } else {\n      event.preventDefault();\n    }\n  }\n\n  /**\n   * Opens the off-canvas menu.\n   * @function\n   * @param {Object} event - Event object passed from listener.\n   * @param {jQuery} trigger - element that triggered the off-canvas to open.\n   * @fires OffCanvas#opened\n   */\n  open(event, trigger) {\n    if (this.$element.hasClass('is-open') || this.isRevealed) { return; }\n    var _this = this;\n\n    if (trigger) {\n      this.$lastTrigger = trigger;\n    }\n\n    if (this.options.forceTo === 'top') {\n      window.scrollTo(0, 0);\n    } else if (this.options.forceTo === 'bottom') {\n      window.scrollTo(0,document.body.scrollHeight);\n    }\n\n    /**\n     * Fires when the off-canvas menu opens.\n     * @event OffCanvas#opened\n     */\n    _this.$element.addClass('is-open')\n\n    this.$triggers.attr('aria-expanded', 'true');\n    this.$element.attr('aria-hidden', 'false')\n        .trigger('opened.zf.offcanvas');\n\n    // If `contentScroll` is set to false, add class and disable scrolling on touch devices.\n    if (this.options.contentScroll === false) {\n      $('body').addClass('is-off-canvas-open').on('touchmove', this._stopScrolling);\n      this.$element.on('touchstart', this._recordScrollable);\n      this.$element.on('touchmove', this._stopScrollPropagation);\n    }\n\n    if (this.options.contentOverlay === true) {\n      this.$overlay.addClass('is-visible');\n    }\n\n    if (this.options.closeOnClick === true && this.options.contentOverlay === true) {\n      this.$overlay.addClass('is-closable');\n    }\n\n    if (this.options.autoFocus === true) {\n      this.$element.one(Foundation.transitionend(this.$element), function() {\n        var canvasFocus = _this.$element.find('[data-autofocus]');\n        if (canvasFocus.length) {\n            canvasFocus.eq(0).focus();\n        } else {\n            _this.$element.find('a, button').eq(0).focus();\n        }\n      });\n    }\n\n    if (this.options.trapFocus === true) {\n      this.$element.siblings('[data-off-canvas-content]').attr('tabindex', '-1');\n      Foundation.Keyboard.trapFocus(this.$element);\n    }\n  }\n\n  /**\n   * Closes the off-canvas menu.\n   * @function\n   * @param {Function} cb - optional cb to fire after closure.\n   * @fires OffCanvas#closed\n   */\n  close(cb) {\n    if (!this.$element.hasClass('is-open') || this.isRevealed) { return; }\n\n    var _this = this;\n\n    _this.$element.removeClass('is-open');\n\n    this.$element.attr('aria-hidden', 'true')\n      /**\n       * Fires when the off-canvas menu opens.\n       * @event OffCanvas#closed\n       */\n        .trigger('closed.zf.offcanvas');\n\n    // If `contentScroll` is set to false, remove class and re-enable scrolling on touch devices.\n    if (this.options.contentScroll === false) {\n      $('body').removeClass('is-off-canvas-open').off('touchmove', this._stopScrolling);\n      this.$element.off('touchstart', this._recordScrollable);\n      this.$element.off('touchmove', this._stopScrollPropagation);\n    }\n\n    if (this.options.contentOverlay === true) {\n      this.$overlay.removeClass('is-visible');\n    }\n\n    if (this.options.closeOnClick === true && this.options.contentOverlay === true) {\n      this.$overlay.removeClass('is-closable');\n    }\n\n    this.$triggers.attr('aria-expanded', 'false');\n\n    if (this.options.trapFocus === true) {\n      this.$element.siblings('[data-off-canvas-content]').removeAttr('tabindex');\n      Foundation.Keyboard.releaseFocus(this.$element);\n    }\n  }\n\n  /**\n   * Toggles the off-canvas menu open or closed.\n   * @function\n   * @param {Object} event - Event object passed from listener.\n   * @param {jQuery} trigger - element that triggered the off-canvas to open.\n   */\n  toggle(event, trigger) {\n    if (this.$element.hasClass('is-open')) {\n      this.close(event, trigger);\n    }\n    else {\n      this.open(event, trigger);\n    }\n  }\n\n  /**\n   * 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.\n   * @function\n   * @private\n   */\n  _handleKeyboard(e) {\n    Foundation.Keyboard.handleKey(e, 'OffCanvas', {\n      close: () => {\n        this.close();\n        this.$lastTrigger.focus();\n        return true;\n      },\n      handled: () => {\n        e.stopPropagation();\n        e.preventDefault();\n      }\n    });\n  }\n\n  /**\n   * Destroys the offcanvas plugin.\n   * @function\n   */\n  destroy() {\n    this.close();\n    this.$element.off('.zf.trigger .zf.offcanvas');\n    this.$overlay.off('.zf.offcanvas');\n\n    Foundation.unregisterPlugin(this);\n  }\n}\n\nOffCanvas.defaults = {\n  /**\n   * Allow the user to click outside of the menu to close it.\n   * @option\n   * @type {boolean}\n   * @default true\n   */\n  closeOnClick: true,\n\n  /**\n   * Adds an overlay on top of `[data-off-canvas-content]`.\n   * @option\n   * @type {boolean}\n   * @default true\n   */\n  contentOverlay: true,\n\n  /**\n   * Enable/disable scrolling of the main content when an off canvas panel is open.\n   * @option\n   * @type {boolean}\n   * @default true\n   */\n  contentScroll: true,\n\n  /**\n   * Amount of time in ms the open and close transition requires. If none selected, pulls from body style.\n   * @option\n   * @type {number}\n   * @default 0\n   */\n  transitionTime: 0,\n\n  /**\n   * Type of transition for the offcanvas menu. Options are 'push', 'detached' or 'slide'.\n   * @option\n   * @type {string}\n   * @default push\n   */\n  transition: 'push',\n\n  /**\n   * Force the page to scroll to top or bottom on open.\n   * @option\n   * @type {?string}\n   * @default null\n   */\n  forceTo: null,\n\n  /**\n   * Allow the offcanvas to remain open for certain breakpoints.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  isRevealed: false,\n\n  /**\n   * Breakpoint at which to reveal. JS will use a RegExp to target standard classes, if changing classnames, pass your class with the `revealClass` option.\n   * @option\n   * @type {?string}\n   * @default null\n   */\n  revealOn: null,\n\n  /**\n   * Force focus to the offcanvas on open. If true, will focus the opening trigger on close.\n   * @option\n   * @type {boolean}\n   * @default true\n   */\n  autoFocus: true,\n\n  /**\n   * Class used to force an offcanvas to remain open. Foundation defaults for this are `reveal-for-large` & `reveal-for-medium`.\n   * @option\n   * @type {string}\n   * @default reveal-for-\n   * @todo improve the regex testing for this.\n   */\n  revealClass: 'reveal-for-',\n\n  /**\n   * Triggers optional focus trapping when opening an offcanvas. Sets tabindex of [data-off-canvas-content] to -1 for accessibility purposes.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  trapFocus: false\n}\n\n// Window exports\nFoundation.plugin(OffCanvas, 'OffCanvas');\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * Orbit module.\n * @module foundation.orbit\n * @requires foundation.util.keyboard\n * @requires foundation.util.motion\n * @requires foundation.util.timerAndImageLoader\n * @requires foundation.util.touch\n */\n\nclass Orbit {\n  /**\n  * Creates a new instance of an orbit carousel.\n  * @class\n  * @param {jQuery} element - jQuery object to make into an Orbit Carousel.\n  * @param {Object} options - Overrides to the default plugin settings.\n  */\n  constructor(element, options){\n    this.$element = element;\n    this.options = $.extend({}, Orbit.defaults, this.$element.data(), options);\n\n    this._init();\n\n    Foundation.registerPlugin(this, 'Orbit');\n    Foundation.Keyboard.register('Orbit', {\n      'ltr': {\n        'ARROW_RIGHT': 'next',\n        'ARROW_LEFT': 'previous'\n      },\n      'rtl': {\n        'ARROW_LEFT': 'next',\n        'ARROW_RIGHT': 'previous'\n      }\n    });\n  }\n\n  /**\n  * Initializes the plugin by creating jQuery collections, setting attributes, and starting the animation.\n  * @function\n  * @private\n  */\n  _init() {\n    // @TODO: consider discussion on PR #9278 about DOM pollution by changeSlide\n    this._reset();\n\n    this.$wrapper = this.$element.find(`.${this.options.containerClass}`);\n    this.$slides = this.$element.find(`.${this.options.slideClass}`);\n\n    var $images = this.$element.find('img'),\n        initActive = this.$slides.filter('.is-active'),\n        id = this.$element[0].id || Foundation.GetYoDigits(6, 'orbit');\n\n    this.$element.attr({\n      'data-resize': id,\n      'id': id\n    });\n\n    if (!initActive.length) {\n      this.$slides.eq(0).addClass('is-active');\n    }\n\n    if (!this.options.useMUI) {\n      this.$slides.addClass('no-motionui');\n    }\n\n    if ($images.length) {\n      Foundation.onImagesLoaded($images, this._prepareForOrbit.bind(this));\n    } else {\n      this._prepareForOrbit();//hehe\n    }\n\n    if (this.options.bullets) {\n      this._loadBullets();\n    }\n\n    this._events();\n\n    if (this.options.autoPlay && this.$slides.length > 1) {\n      this.geoSync();\n    }\n\n    if (this.options.accessible) { // allow wrapper to be focusable to enable arrow navigation\n      this.$wrapper.attr('tabindex', 0);\n    }\n  }\n\n  /**\n  * Creates a jQuery collection of bullets, if they are being used.\n  * @function\n  * @private\n  */\n  _loadBullets() {\n    this.$bullets = this.$element.find(`.${this.options.boxOfBullets}`).find('button');\n  }\n\n  /**\n  * Sets a `timer` object on the orbit, and starts the counter for the next slide.\n  * @function\n  */\n  geoSync() {\n    var _this = this;\n    this.timer = new Foundation.Timer(\n      this.$element,\n      {\n        duration: this.options.timerDelay,\n        infinite: false\n      },\n      function() {\n        _this.changeSlide(true);\n      });\n    this.timer.start();\n  }\n\n  /**\n  * Sets wrapper and slide heights for the orbit.\n  * @function\n  * @private\n  */\n  _prepareForOrbit() {\n    var _this = this;\n    this._setWrapperHeight();\n  }\n\n  /**\n  * Calulates the height of each slide in the collection, and uses the tallest one for the wrapper height.\n  * @function\n  * @private\n  * @param {Function} cb - a callback function to fire when complete.\n  */\n  _setWrapperHeight(cb) {//rewrite this to `for` loop\n    var max = 0, temp, counter = 0, _this = this;\n\n    this.$slides.each(function() {\n      temp = this.getBoundingClientRect().height;\n      $(this).attr('data-slide', counter);\n\n      if (_this.$slides.filter('.is-active')[0] !== _this.$slides.eq(counter)[0]) {//if not the active slide, set css position and display property\n        $(this).css({'position': 'relative', 'display': 'none'});\n      }\n      max = temp > max ? temp : max;\n      counter++;\n    });\n\n    if (counter === this.$slides.length) {\n      this.$wrapper.css({'height': max}); //only change the wrapper height property once.\n      if(cb) {cb(max);} //fire callback with max height dimension.\n    }\n  }\n\n  /**\n  * Sets the max-height of each slide.\n  * @function\n  * @private\n  */\n  _setSlideHeight(height) {\n    this.$slides.each(function() {\n      $(this).css('max-height', height);\n    });\n  }\n\n  /**\n  * Adds event listeners to basically everything within the element.\n  * @function\n  * @private\n  */\n  _events() {\n    var _this = this;\n\n    //***************************************\n    //**Now using custom event - thanks to:**\n    //**      Yohai Ararat of Toronto      **\n    //***************************************\n    //\n    this.$element.off('.resizeme.zf.trigger').on({\n      'resizeme.zf.trigger': this._prepareForOrbit.bind(this)\n    })\n    if (this.$slides.length > 1) {\n\n      if (this.options.swipe) {\n        this.$slides.off('swipeleft.zf.orbit swiperight.zf.orbit')\n        .on('swipeleft.zf.orbit', function(e){\n          e.preventDefault();\n          _this.changeSlide(true);\n        }).on('swiperight.zf.orbit', function(e){\n          e.preventDefault();\n          _this.changeSlide(false);\n        });\n      }\n      //***************************************\n\n      if (this.options.autoPlay) {\n        this.$slides.on('click.zf.orbit', function() {\n          _this.$element.data('clickedOn', _this.$element.data('clickedOn') ? false : true);\n          _this.timer[_this.$element.data('clickedOn') ? 'pause' : 'start']();\n        });\n\n        if (this.options.pauseOnHover) {\n          this.$element.on('mouseenter.zf.orbit', function() {\n            _this.timer.pause();\n          }).on('mouseleave.zf.orbit', function() {\n            if (!_this.$element.data('clickedOn')) {\n              _this.timer.start();\n            }\n          });\n        }\n      }\n\n      if (this.options.navButtons) {\n        var $controls = this.$element.find(`.${this.options.nextClass}, .${this.options.prevClass}`);\n        $controls.attr('tabindex', 0)\n        //also need to handle enter/return and spacebar key presses\n        .on('click.zf.orbit touchend.zf.orbit', function(e){\n\t  e.preventDefault();\n          _this.changeSlide($(this).hasClass(_this.options.nextClass));\n        });\n      }\n\n      if (this.options.bullets) {\n        this.$bullets.on('click.zf.orbit touchend.zf.orbit', function() {\n          if (/is-active/g.test(this.className)) { return false; }//if this is active, kick out of function.\n          var idx = $(this).data('slide'),\n          ltr = idx > _this.$slides.filter('.is-active').data('slide'),\n          $slide = _this.$slides.eq(idx);\n\n          _this.changeSlide(ltr, $slide, idx);\n        });\n      }\n\n      if (this.options.accessible) {\n        this.$wrapper.add(this.$bullets).on('keydown.zf.orbit', function(e) {\n          // handle keyboard event with keyboard util\n          Foundation.Keyboard.handleKey(e, 'Orbit', {\n            next: function() {\n              _this.changeSlide(true);\n            },\n            previous: function() {\n              _this.changeSlide(false);\n            },\n            handled: function() { // if bullet is focused, make sure focus moves\n              if ($(e.target).is(_this.$bullets)) {\n                _this.$bullets.filter('.is-active').focus();\n              }\n            }\n          });\n        });\n      }\n    }\n  }\n\n  /**\n   * Resets Orbit so it can be reinitialized\n   */\n  _reset() {\n    // Don't do anything if there are no slides (first run)\n    if (typeof this.$slides == 'undefined') {\n      return;\n    }\n\n    if (this.$slides.length > 1) {\n      // Remove old events\n      this.$element.off('.zf.orbit').find('*').off('.zf.orbit')\n\n      // Restart timer if autoPlay is enabled\n      if (this.options.autoPlay) {\n        this.timer.restart();\n      }\n\n      // Reset all sliddes\n      this.$slides.each(function(el) {\n        $(el).removeClass('is-active is-active is-in')\n          .removeAttr('aria-live')\n          .hide();\n      });\n\n      // Show the first slide\n      this.$slides.first().addClass('is-active').show();\n\n      // Triggers when the slide has finished animating\n      this.$element.trigger('slidechange.zf.orbit', [this.$slides.first()]);\n\n      // Select first bullet if bullets are present\n      if (this.options.bullets) {\n        this._updateBullets(0);\n      }\n    }\n  }\n\n  /**\n  * Changes the current slide to a new one.\n  * @function\n  * @param {Boolean} isLTR - flag if the slide should move left to right.\n  * @param {jQuery} chosenSlide - the jQuery element of the slide to show next, if one is selected.\n  * @param {Number} idx - the index of the new slide in its collection, if one chosen.\n  * @fires Orbit#slidechange\n  */\n  changeSlide(isLTR, chosenSlide, idx) {\n    if (!this.$slides) {return; } // Don't freak out if we're in the middle of cleanup\n    var $curSlide = this.$slides.filter('.is-active').eq(0);\n\n    if (/mui/g.test($curSlide[0].className)) { return false; } //if the slide is currently animating, kick out of the function\n\n    var $firstSlide = this.$slides.first(),\n    $lastSlide = this.$slides.last(),\n    dirIn = isLTR ? 'Right' : 'Left',\n    dirOut = isLTR ? 'Left' : 'Right',\n    _this = this,\n    $newSlide;\n\n    if (!chosenSlide) { //most of the time, this will be auto played or clicked from the navButtons.\n      $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!!!!!\n      (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\n      :\n      (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\n    } else {\n      $newSlide = chosenSlide;\n    }\n\n    if ($newSlide.length) {\n      /**\n      * Triggers before the next slide starts animating in and only if a next slide has been found.\n      * @event Orbit#beforeslidechange\n      */\n      this.$element.trigger('beforeslidechange.zf.orbit', [$curSlide, $newSlide]);\n\n      if (this.options.bullets) {\n        idx = idx || this.$slides.index($newSlide); //grab index to update bullets\n        this._updateBullets(idx);\n      }\n\n      if (this.options.useMUI && !this.$element.is(':hidden')) {\n        Foundation.Motion.animateIn(\n          $newSlide.addClass('is-active').css({'position': 'absolute', 'top': 0}),\n          this.options[`animInFrom${dirIn}`],\n          function(){\n            $newSlide.css({'position': 'relative', 'display': 'block'})\n            .attr('aria-live', 'polite');\n        });\n\n        Foundation.Motion.animateOut(\n          $curSlide.removeClass('is-active'),\n          this.options[`animOutTo${dirOut}`],\n          function(){\n            $curSlide.removeAttr('aria-live');\n            if(_this.options.autoPlay && !_this.timer.isPaused){\n              _this.timer.restart();\n            }\n            //do stuff?\n          });\n      } else {\n        $curSlide.removeClass('is-active is-in').removeAttr('aria-live').hide();\n        $newSlide.addClass('is-active is-in').attr('aria-live', 'polite').show();\n        if (this.options.autoPlay && !this.timer.isPaused) {\n          this.timer.restart();\n        }\n      }\n    /**\n    * Triggers when the slide has finished animating in.\n    * @event Orbit#slidechange\n    */\n      this.$element.trigger('slidechange.zf.orbit', [$newSlide]);\n    }\n  }\n\n  /**\n  * Updates the active state of the bullets, if displayed.\n  * @function\n  * @private\n  * @param {Number} idx - the index of the current slide.\n  */\n  _updateBullets(idx) {\n    var $oldBullet = this.$element.find(`.${this.options.boxOfBullets}`)\n    .find('.is-active').removeClass('is-active').blur(),\n    span = $oldBullet.find('span:last').detach(),\n    $newBullet = this.$bullets.eq(idx).addClass('is-active').append(span);\n  }\n\n  /**\n  * Destroys the carousel and hides the element.\n  * @function\n  */\n  destroy() {\n    this.$element.off('.zf.orbit').find('*').off('.zf.orbit').end().hide();\n    Foundation.unregisterPlugin(this);\n  }\n}\n\nOrbit.defaults = {\n  /**\n  * Tells the JS to look for and loadBullets.\n  * @option\n   * @type {boolean}\n  * @default true\n  */\n  bullets: true,\n  /**\n  * Tells the JS to apply event listeners to nav buttons\n  * @option\n   * @type {boolean}\n  * @default true\n  */\n  navButtons: true,\n  /**\n  * motion-ui animation class to apply\n  * @option\n   * @type {string}\n  * @default 'slide-in-right'\n  */\n  animInFromRight: 'slide-in-right',\n  /**\n  * motion-ui animation class to apply\n  * @option\n   * @type {string}\n  * @default 'slide-out-right'\n  */\n  animOutToRight: 'slide-out-right',\n  /**\n  * motion-ui animation class to apply\n  * @option\n   * @type {string}\n  * @default 'slide-in-left'\n  *\n  */\n  animInFromLeft: 'slide-in-left',\n  /**\n  * motion-ui animation class to apply\n  * @option\n   * @type {string}\n  * @default 'slide-out-left'\n  */\n  animOutToLeft: 'slide-out-left',\n  /**\n  * Allows Orbit to automatically animate on page load.\n  * @option\n   * @type {boolean}\n  * @default true\n  */\n  autoPlay: true,\n  /**\n  * Amount of time, in ms, between slide transitions\n  * @option\n   * @type {number}\n  * @default 5000\n  */\n  timerDelay: 5000,\n  /**\n  * Allows Orbit to infinitely loop through the slides\n  * @option\n   * @type {boolean}\n  * @default true\n  */\n  infiniteWrap: true,\n  /**\n  * Allows the Orbit slides to bind to swipe events for mobile, requires an additional util library\n  * @option\n   * @type {boolean}\n  * @default true\n  */\n  swipe: true,\n  /**\n  * Allows the timing function to pause animation on hover.\n  * @option\n   * @type {boolean}\n  * @default true\n  */\n  pauseOnHover: true,\n  /**\n  * Allows Orbit to bind keyboard events to the slider, to animate frames with arrow keys\n  * @option\n   * @type {boolean}\n  * @default true\n  */\n  accessible: true,\n  /**\n  * Class applied to the container of Orbit\n  * @option\n   * @type {string}\n  * @default 'orbit-container'\n  */\n  containerClass: 'orbit-container',\n  /**\n  * Class applied to individual slides.\n  * @option\n   * @type {string}\n  * @default 'orbit-slide'\n  */\n  slideClass: 'orbit-slide',\n  /**\n  * Class applied to the bullet container. You're welcome.\n  * @option\n   * @type {string}\n  * @default 'orbit-bullets'\n  */\n  boxOfBullets: 'orbit-bullets',\n  /**\n  * Class applied to the `next` navigation button.\n  * @option\n   * @type {string}\n  * @default 'orbit-next'\n  */\n  nextClass: 'orbit-next',\n  /**\n  * Class applied to the `previous` navigation button.\n  * @option\n   * @type {string}\n  * @default 'orbit-previous'\n  */\n  prevClass: 'orbit-previous',\n  /**\n  * Boolean to flag the js to use motion ui classes or not. Default to true for backwards compatability.\n  * @option\n   * @type {boolean}\n  * @default true\n  */\n  useMUI: true\n};\n\n// Window exports\nFoundation.plugin(Orbit, 'Orbit');\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * ResponsiveMenu module.\n * @module foundation.responsiveMenu\n * @requires foundation.util.triggers\n * @requires foundation.util.mediaQuery\n */\n\nclass ResponsiveMenu {\n  /**\n   * Creates a new instance of a responsive menu.\n   * @class\n   * @fires ResponsiveMenu#init\n   * @param {jQuery} element - jQuery object to make into a dropdown menu.\n   * @param {Object} options - Overrides to the default plugin settings.\n   */\n  constructor(element, options) {\n    this.$element = $(element);\n    this.rules = this.$element.data('responsive-menu');\n    this.currentMq = null;\n    this.currentPlugin = null;\n\n    this._init();\n    this._events();\n\n    Foundation.registerPlugin(this, 'ResponsiveMenu');\n  }\n\n  /**\n   * Initializes the Menu by parsing the classes from the 'data-ResponsiveMenu' attribute on the element.\n   * @function\n   * @private\n   */\n  _init() {\n    // The first time an Interchange plugin is initialized, this.rules is converted from a string of \"classes\" to an object of rules\n    if (typeof this.rules === 'string') {\n      let rulesTree = {};\n\n      // Parse rules from \"classes\" pulled from data attribute\n      let rules = this.rules.split(' ');\n\n      // Iterate through every rule found\n      for (let i = 0; i < rules.length; i++) {\n        let rule = rules[i].split('-');\n        let ruleSize = rule.length > 1 ? rule[0] : 'small';\n        let rulePlugin = rule.length > 1 ? rule[1] : rule[0];\n\n        if (MenuPlugins[rulePlugin] !== null) {\n          rulesTree[ruleSize] = MenuPlugins[rulePlugin];\n        }\n      }\n\n      this.rules = rulesTree;\n    }\n\n    if (!$.isEmptyObject(this.rules)) {\n      this._checkMediaQueries();\n    }\n    // Add data-mutate since children may need it.\n    this.$element.attr('data-mutate', (this.$element.attr('data-mutate') || Foundation.GetYoDigits(6, 'responsive-menu')));\n  }\n\n  /**\n   * Initializes events for the Menu.\n   * @function\n   * @private\n   */\n  _events() {\n    var _this = this;\n\n    $(window).on('changed.zf.mediaquery', function() {\n      _this._checkMediaQueries();\n    });\n    // $(window).on('resize.zf.ResponsiveMenu', function() {\n    //   _this._checkMediaQueries();\n    // });\n  }\n\n  /**\n   * 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.\n   * @function\n   * @private\n   */\n  _checkMediaQueries() {\n    var matchedMq, _this = this;\n    // Iterate through each rule and find the last matching rule\n    $.each(this.rules, function(key) {\n      if (Foundation.MediaQuery.atLeast(key)) {\n        matchedMq = key;\n      }\n    });\n\n    // No match? No dice\n    if (!matchedMq) return;\n\n    // Plugin already initialized? We good\n    if (this.currentPlugin instanceof this.rules[matchedMq].plugin) return;\n\n    // Remove existing plugin-specific CSS classes\n    $.each(MenuPlugins, function(key, value) {\n      _this.$element.removeClass(value.cssClass);\n    });\n\n    // Add the CSS class for the new plugin\n    this.$element.addClass(this.rules[matchedMq].cssClass);\n\n    // Create an instance of the new plugin\n    if (this.currentPlugin) this.currentPlugin.destroy();\n    this.currentPlugin = new this.rules[matchedMq].plugin(this.$element, {});\n  }\n\n  /**\n   * Destroys the instance of the current plugin on this element, as well as the window resize handler that switches the plugins out.\n   * @function\n   */\n  destroy() {\n    this.currentPlugin.destroy();\n    $(window).off('.zf.ResponsiveMenu');\n    Foundation.unregisterPlugin(this);\n  }\n}\n\nResponsiveMenu.defaults = {};\n\n// The plugin matches the plugin classes with these plugin instances.\nvar MenuPlugins = {\n  dropdown: {\n    cssClass: 'dropdown',\n    plugin: Foundation._plugins['dropdown-menu'] || null\n  },\n drilldown: {\n    cssClass: 'drilldown',\n    plugin: Foundation._plugins['drilldown'] || null\n  },\n  accordion: {\n    cssClass: 'accordion-menu',\n    plugin: Foundation._plugins['accordion-menu'] || null\n  }\n};\n\n// Window exports\nFoundation.plugin(ResponsiveMenu, 'ResponsiveMenu');\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * ResponsiveToggle module.\n * @module foundation.responsiveToggle\n * @requires foundation.util.mediaQuery\n */\n\nclass ResponsiveToggle {\n  /**\n   * Creates a new instance of Tab Bar.\n   * @class\n   * @fires ResponsiveToggle#init\n   * @param {jQuery} element - jQuery object to attach tab bar functionality to.\n   * @param {Object} options - Overrides to the default plugin settings.\n   */\n  constructor(element, options) {\n    this.$element = $(element);\n    this.options = $.extend({}, ResponsiveToggle.defaults, this.$element.data(), options);\n\n    this._init();\n    this._events();\n\n    Foundation.registerPlugin(this, 'ResponsiveToggle');\n  }\n\n  /**\n   * Initializes the tab bar by finding the target element, toggling element, and running update().\n   * @function\n   * @private\n   */\n  _init() {\n    var targetID = this.$element.data('responsive-toggle');\n    if (!targetID) {\n      console.error('Your tab bar needs an ID of a Menu as the value of data-tab-bar.');\n    }\n\n    this.$targetMenu = $(`#${targetID}`);\n    this.$toggler = this.$element.find('[data-toggle]').filter(function() {\n      var target = $(this).data('toggle');\n      return (target === targetID || target === \"\");\n    });\n    this.options = $.extend({}, this.options, this.$targetMenu.data());\n\n    // If they were set, parse the animation classes\n    if(this.options.animate) {\n      let input = this.options.animate.split(' ');\n\n      this.animationIn = input[0];\n      this.animationOut = input[1] || null;\n    }\n\n    this._update();\n  }\n\n  /**\n   * Adds necessary event handlers for the tab bar to work.\n   * @function\n   * @private\n   */\n  _events() {\n    var _this = this;\n\n    this._updateMqHandler = this._update.bind(this);\n\n    $(window).on('changed.zf.mediaquery', this._updateMqHandler);\n\n    this.$toggler.on('click.zf.responsiveToggle', this.toggleMenu.bind(this));\n  }\n\n  /**\n   * Checks the current media query to determine if the tab bar should be visible or hidden.\n   * @function\n   * @private\n   */\n  _update() {\n    // Mobile\n    if (!Foundation.MediaQuery.atLeast(this.options.hideFor)) {\n      this.$element.show();\n      this.$targetMenu.hide();\n    }\n\n    // Desktop\n    else {\n      this.$element.hide();\n      this.$targetMenu.show();\n    }\n  }\n\n  /**\n   * Toggles the element attached to the tab bar. The toggle only happens if the screen is small enough to allow it.\n   * @function\n   * @fires ResponsiveToggle#toggled\n   */\n  toggleMenu() {\n    if (!Foundation.MediaQuery.atLeast(this.options.hideFor)) {\n      /**\n       * Fires when the element attached to the tab bar toggles.\n       * @event ResponsiveToggle#toggled\n       */\n      if(this.options.animate) {\n        if (this.$targetMenu.is(':hidden')) {\n          Foundation.Motion.animateIn(this.$targetMenu, this.animationIn, () => {\n            this.$element.trigger('toggled.zf.responsiveToggle');\n            this.$targetMenu.find('[data-mutate]').triggerHandler('mutateme.zf.trigger');\n          });\n        }\n        else {\n          Foundation.Motion.animateOut(this.$targetMenu, this.animationOut, () => {\n            this.$element.trigger('toggled.zf.responsiveToggle');\n          });\n        }\n      }\n      else {\n        this.$targetMenu.toggle(0);\n        this.$targetMenu.find('[data-mutate]').trigger('mutateme.zf.trigger');\n        this.$element.trigger('toggled.zf.responsiveToggle');\n      }\n    }\n  };\n\n  destroy() {\n    this.$element.off('.zf.responsiveToggle');\n    this.$toggler.off('.zf.responsiveToggle');\n\n    $(window).off('changed.zf.mediaquery', this._updateMqHandler);\n\n    Foundation.unregisterPlugin(this);\n  }\n}\n\nResponsiveToggle.defaults = {\n  /**\n   * The breakpoint after which the menu is always shown, and the tab bar is hidden.\n   * @option\n   * @type {string}\n   * @default 'medium'\n   */\n  hideFor: 'medium',\n\n  /**\n   * To decide if the toggle should be animated or not.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  animate: false\n};\n\n// Window exports\nFoundation.plugin(ResponsiveToggle, 'ResponsiveToggle');\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * Reveal module.\n * @module foundation.reveal\n * @requires foundation.util.keyboard\n * @requires foundation.util.box\n * @requires foundation.util.triggers\n * @requires foundation.util.mediaQuery\n * @requires foundation.util.motion if using animations\n */\n\nclass Reveal {\n  /**\n   * Creates a new instance of Reveal.\n   * @class\n   * @param {jQuery} element - jQuery object to use for the modal.\n   * @param {Object} options - optional parameters.\n   */\n  constructor(element, options) {\n    this.$element = element;\n    this.options = $.extend({}, Reveal.defaults, this.$element.data(), options);\n    this._init();\n\n    Foundation.registerPlugin(this, 'Reveal');\n    Foundation.Keyboard.register('Reveal', {\n      'ENTER': 'open',\n      'SPACE': 'open',\n      'ESCAPE': 'close',\n    });\n  }\n\n  /**\n   * Initializes the modal by adding the overlay and close buttons, (if selected).\n   * @private\n   */\n  _init() {\n    this.id = this.$element.attr('id');\n    this.isActive = false;\n    this.cached = {mq: Foundation.MediaQuery.current};\n    this.isMobile = mobileSniff();\n\n    this.$anchor = $(`[data-open=\"${this.id}\"]`).length ? $(`[data-open=\"${this.id}\"]`) : $(`[data-toggle=\"${this.id}\"]`);\n    this.$anchor.attr({\n      'aria-controls': this.id,\n      'aria-haspopup': true,\n      'tabindex': 0\n    });\n\n    if (this.options.fullScreen || this.$element.hasClass('full')) {\n      this.options.fullScreen = true;\n      this.options.overlay = false;\n    }\n    if (this.options.overlay && !this.$overlay) {\n      this.$overlay = this._makeOverlay(this.id);\n    }\n\n    this.$element.attr({\n        'role': 'dialog',\n        'aria-hidden': true,\n        'data-yeti-box': this.id,\n        'data-resize': this.id\n    });\n\n    if(this.$overlay) {\n      this.$element.detach().appendTo(this.$overlay);\n    } else {\n      this.$element.detach().appendTo($(this.options.appendTo));\n      this.$element.addClass('without-overlay');\n    }\n    this._events();\n    if (this.options.deepLink && window.location.hash === ( `#${this.id}`)) {\n      $(window).one('load.zf.reveal', this.open.bind(this));\n    }\n  }\n\n  /**\n   * Creates an overlay div to display behind the modal.\n   * @private\n   */\n  _makeOverlay() {\n    return $('<div></div>')\n      .addClass('reveal-overlay')\n      .appendTo(this.options.appendTo);\n  }\n\n  /**\n   * Updates position of modal\n   * TODO:  Figure out if we actually need to cache these values or if it doesn't matter\n   * @private\n   */\n  _updatePosition() {\n    var width = this.$element.outerWidth();\n    var outerWidth = $(window).width();\n    var height = this.$element.outerHeight();\n    var outerHeight = $(window).height();\n    var left, top;\n    if (this.options.hOffset === 'auto') {\n      left = parseInt((outerWidth - width) / 2, 10);\n    } else {\n      left = parseInt(this.options.hOffset, 10);\n    }\n    if (this.options.vOffset === 'auto') {\n      if (height > outerHeight) {\n        top = parseInt(Math.min(100, outerHeight / 10), 10);\n      } else {\n        top = parseInt((outerHeight - height) / 4, 10);\n      }\n    } else {\n      top = parseInt(this.options.vOffset, 10);\n    }\n    this.$element.css({top: top + 'px'});\n    // only worry about left if we don't have an overlay or we havea  horizontal offset,\n    // otherwise we're perfectly in the middle\n    if(!this.$overlay || (this.options.hOffset !== 'auto')) {\n      this.$element.css({left: left + 'px'});\n      this.$element.css({margin: '0px'});\n    }\n\n  }\n\n  /**\n   * Adds event handlers for the modal.\n   * @private\n   */\n  _events() {\n    var _this = this;\n\n    this.$element.on({\n      'open.zf.trigger': this.open.bind(this),\n      'close.zf.trigger': (event, $element) => {\n        if ((event.target === _this.$element[0]) ||\n            ($(event.target).parents('[data-closable]')[0] === $element)) { // only close reveal when it's explicitly called\n          return this.close.apply(this);\n        }\n      },\n      'toggle.zf.trigger': this.toggle.bind(this),\n      'resizeme.zf.trigger': function() {\n        _this._updatePosition();\n      }\n    });\n\n    if (this.$anchor.length) {\n      this.$anchor.on('keydown.zf.reveal', function(e) {\n        if (e.which === 13 || e.which === 32) {\n          e.stopPropagation();\n          e.preventDefault();\n          _this.open();\n        }\n      });\n    }\n\n    if (this.options.closeOnClick && this.options.overlay) {\n      this.$overlay.off('.zf.reveal').on('click.zf.reveal', function(e) {\n        if (e.target === _this.$element[0] ||\n          $.contains(_this.$element[0], e.target) ||\n            !$.contains(document, e.target)) {\n              return;\n        }\n        _this.close();\n      });\n    }\n    if (this.options.deepLink) {\n      $(window).on(`popstate.zf.reveal:${this.id}`, this._handleState.bind(this));\n    }\n  }\n\n  /**\n   * Handles modal methods on back/forward button clicks or any other event that triggers popstate.\n   * @private\n   */\n  _handleState(e) {\n    if(window.location.hash === ( '#' + this.id) && !this.isActive){ this.open(); }\n    else{ this.close(); }\n  }\n\n\n  /**\n   * Opens the modal controlled by `this.$anchor`, and closes all others by default.\n   * @function\n   * @fires Reveal#closeme\n   * @fires Reveal#open\n   */\n  open() {\n    if (this.options.deepLink) {\n      var hash = `#${this.id}`;\n\n      if (window.history.pushState) {\n        window.history.pushState(null, null, hash);\n      } else {\n        window.location.hash = hash;\n      }\n    }\n\n    this.isActive = true;\n\n    // Make elements invisible, but remove display: none so we can get size and positioning\n    this.$element\n        .css({ 'visibility': 'hidden' })\n        .show()\n        .scrollTop(0);\n    if (this.options.overlay) {\n      this.$overlay.css({'visibility': 'hidden'}).show();\n    }\n\n    this._updatePosition();\n\n    this.$element\n      .hide()\n      .css({ 'visibility': '' });\n\n    if(this.$overlay) {\n      this.$overlay.css({'visibility': ''}).hide();\n      if(this.$element.hasClass('fast')) {\n        this.$overlay.addClass('fast');\n      } else if (this.$element.hasClass('slow')) {\n        this.$overlay.addClass('slow');\n      }\n    }\n\n\n    if (!this.options.multipleOpened) {\n      /**\n       * Fires immediately before the modal opens.\n       * Closes any other modals that are currently open\n       * @event Reveal#closeme\n       */\n      this.$element.trigger('closeme.zf.reveal', this.id);\n    }\n\n    var _this = this;\n\n    function addRevealOpenClasses() {\n      if (_this.isMobile) {\n        if(!_this.originalScrollPos) {\n          _this.originalScrollPos = window.pageYOffset;\n        }\n        $('html, body').addClass('is-reveal-open');\n      }\n      else {\n        $('body').addClass('is-reveal-open');\n      }\n    }\n    // Motion UI method of reveal\n    if (this.options.animationIn) {\n      function afterAnimation(){\n        _this.$element\n          .attr({\n            'aria-hidden': false,\n            'tabindex': -1\n          })\n          .focus();\n        addRevealOpenClasses();\n        Foundation.Keyboard.trapFocus(_this.$element);\n      }\n      if (this.options.overlay) {\n        Foundation.Motion.animateIn(this.$overlay, 'fade-in');\n      }\n      Foundation.Motion.animateIn(this.$element, this.options.animationIn, () => {\n        if(this.$element) { // protect against object having been removed\n          this.focusableElements = Foundation.Keyboard.findFocusable(this.$element);\n          afterAnimation();\n        }\n      });\n    }\n    // jQuery method of reveal\n    else {\n      if (this.options.overlay) {\n        this.$overlay.show(0);\n      }\n      this.$element.show(this.options.showDelay);\n    }\n\n    // handle accessibility\n    this.$element\n      .attr({\n        'aria-hidden': false,\n        'tabindex': -1\n      })\n      .focus();\n    Foundation.Keyboard.trapFocus(this.$element);\n\n    /**\n     * Fires when the modal has successfully opened.\n     * @event Reveal#open\n     */\n    this.$element.trigger('open.zf.reveal');\n\n    addRevealOpenClasses();\n\n    setTimeout(() => {\n      this._extraHandlers();\n    }, 0);\n  }\n\n  /**\n   * Adds extra event handlers for the body and window if necessary.\n   * @private\n   */\n  _extraHandlers() {\n    var _this = this;\n    if(!this.$element) { return; } // If we're in the middle of cleanup, don't freak out\n    this.focusableElements = Foundation.Keyboard.findFocusable(this.$element);\n\n    if (!this.options.overlay && this.options.closeOnClick && !this.options.fullScreen) {\n      $('body').on('click.zf.reveal', function(e) {\n        if (e.target === _this.$element[0] ||\n          $.contains(_this.$element[0], e.target) ||\n            !$.contains(document, e.target)) { return; }\n        _this.close();\n      });\n    }\n\n    if (this.options.closeOnEsc) {\n      $(window).on('keydown.zf.reveal', function(e) {\n        Foundation.Keyboard.handleKey(e, 'Reveal', {\n          close: function() {\n            if (_this.options.closeOnEsc) {\n              _this.close();\n              _this.$anchor.focus();\n            }\n          }\n        });\n      });\n    }\n\n    // lock focus within modal while tabbing\n    this.$element.on('keydown.zf.reveal', function(e) {\n      var $target = $(this);\n      // handle keyboard event with keyboard util\n      Foundation.Keyboard.handleKey(e, 'Reveal', {\n        open: function() {\n          if (_this.$element.find(':focus').is(_this.$element.find('[data-close]'))) {\n            setTimeout(function() { // set focus back to anchor if close button has been activated\n              _this.$anchor.focus();\n            }, 1);\n          } else if ($target.is(_this.focusableElements)) { // dont't trigger if acual element has focus (i.e. inputs, links, ...)\n            _this.open();\n          }\n        },\n        close: function() {\n          if (_this.options.closeOnEsc) {\n            _this.close();\n            _this.$anchor.focus();\n          }\n        },\n        handled: function(preventDefault) {\n          if (preventDefault) {\n            e.preventDefault();\n          }\n        }\n      });\n    });\n  }\n\n  /**\n   * Closes the modal.\n   * @function\n   * @fires Reveal#closed\n   */\n  close() {\n    if (!this.isActive || !this.$element.is(':visible')) {\n      return false;\n    }\n    var _this = this;\n\n    // Motion UI method of hiding\n    if (this.options.animationOut) {\n      if (this.options.overlay) {\n        Foundation.Motion.animateOut(this.$overlay, 'fade-out', finishUp);\n      }\n      else {\n        finishUp();\n      }\n\n      Foundation.Motion.animateOut(this.$element, this.options.animationOut);\n    }\n    // jQuery method of hiding\n    else {\n\n      this.$element.hide(this.options.hideDelay);\n\n      if (this.options.overlay) {\n        this.$overlay.hide(0, finishUp);\n      }\n      else {\n        finishUp();\n      }\n    }\n\n    // Conditionals to remove extra event listeners added on open\n    if (this.options.closeOnEsc) {\n      $(window).off('keydown.zf.reveal');\n    }\n\n    if (!this.options.overlay && this.options.closeOnClick) {\n      $('body').off('click.zf.reveal');\n    }\n\n    this.$element.off('keydown.zf.reveal');\n\n    function finishUp() {\n      if (_this.isMobile) {\n        if ($('.reveal:visible').length === 0) {\n          $('html, body').removeClass('is-reveal-open');\n        }\n        if(_this.originalScrollPos) {\n          $('body').scrollTop(_this.originalScrollPos);\n          _this.originalScrollPos = null;\n        }\n      }\n      else {\n        if ($('.reveal:visible').length  === 0) {\n          $('body').removeClass('is-reveal-open');\n        }\n      }\n\n\n      Foundation.Keyboard.releaseFocus(_this.$element);\n\n      _this.$element.attr('aria-hidden', true);\n\n      /**\n      * Fires when the modal is done closing.\n      * @event Reveal#closed\n      */\n      _this.$element.trigger('closed.zf.reveal');\n    }\n\n    /**\n    * Resets the modal content\n    * This prevents a running video to keep going in the background\n    */\n    if (this.options.resetOnClose) {\n      this.$element.html(this.$element.html());\n    }\n\n    this.isActive = false;\n     if (_this.options.deepLink) {\n       if (window.history.replaceState) {\n         window.history.replaceState('', document.title, window.location.href.replace(`#${this.id}`, ''));\n       } else {\n         window.location.hash = '';\n       }\n     }\n  }\n\n  /**\n   * Toggles the open/closed state of a modal.\n   * @function\n   */\n  toggle() {\n    if (this.isActive) {\n      this.close();\n    } else {\n      this.open();\n    }\n  };\n\n  /**\n   * Destroys an instance of a modal.\n   * @function\n   */\n  destroy() {\n    if (this.options.overlay) {\n      this.$element.appendTo($(this.options.appendTo)); // move $element outside of $overlay to prevent error unregisterPlugin()\n      this.$overlay.hide().off().remove();\n    }\n    this.$element.hide().off();\n    this.$anchor.off('.zf');\n    $(window).off(`.zf.reveal:${this.id}`);\n\n    Foundation.unregisterPlugin(this);\n  };\n}\n\nReveal.defaults = {\n  /**\n   * Motion-UI class to use for animated elements. If none used, defaults to simple show/hide.\n   * @option\n   * @type {string}\n   * @default ''\n   */\n  animationIn: '',\n  /**\n   * Motion-UI class to use for animated elements. If none used, defaults to simple show/hide.\n   * @option\n   * @type {string}\n   * @default ''\n   */\n  animationOut: '',\n  /**\n   * Time, in ms, to delay the opening of a modal after a click if no animation used.\n   * @option\n   * @type {number}\n   * @default 0\n   */\n  showDelay: 0,\n  /**\n   * Time, in ms, to delay the closing of a modal after a click if no animation used.\n   * @option\n   * @type {number}\n   * @default 0\n   */\n  hideDelay: 0,\n  /**\n   * Allows a click on the body/overlay to close the modal.\n   * @option\n   * @type {boolean}\n   * @default true\n   */\n  closeOnClick: true,\n  /**\n   * Allows the modal to close if the user presses the `ESCAPE` key.\n   * @option\n   * @type {boolean}\n   * @default true\n   */\n  closeOnEsc: true,\n  /**\n   * If true, allows multiple modals to be displayed at once.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  multipleOpened: false,\n  /**\n   * Distance, in pixels, the modal should push down from the top of the screen.\n   * @option\n   * @type {number|string}\n   * @default auto\n   */\n  vOffset: 'auto',\n  /**\n   * Distance, in pixels, the modal should push in from the side of the screen.\n   * @option\n   * @type {number|string}\n   * @default auto\n   */\n  hOffset: 'auto',\n  /**\n   * Allows the modal to be fullscreen, completely blocking out the rest of the view. JS checks for this as well.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  fullScreen: false,\n  /**\n   * Percentage of screen height the modal should push up from the bottom of the view.\n   * @option\n   * @type {number}\n   * @default 10\n   */\n  btmOffsetPct: 10,\n  /**\n   * Allows the modal to generate an overlay div, which will cover the view when modal opens.\n   * @option\n   * @type {boolean}\n   * @default true\n   */\n  overlay: true,\n  /**\n   * 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.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  resetOnClose: false,\n  /**\n   * 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.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  deepLink: false,\n    /**\n   * Allows the modal to append to custom div.\n   * @option\n   * @type {string}\n   * @default \"body\"\n   */\n  appendTo: \"body\"\n\n};\n\n// Window exports\nFoundation.plugin(Reveal, 'Reveal');\n\nfunction iPhoneSniff() {\n  return /iP(ad|hone|od).*OS/.test(window.navigator.userAgent);\n}\n\nfunction androidSniff() {\n  return /Android/.test(window.navigator.userAgent);\n}\n\nfunction mobileSniff() {\n  return iPhoneSniff() || androidSniff();\n}\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * Slider module.\n * @module foundation.slider\n * @requires foundation.util.motion\n * @requires foundation.util.triggers\n * @requires foundation.util.keyboard\n * @requires foundation.util.touch\n */\n\nclass Slider {\n  /**\n   * Creates a new instance of a slider control.\n   * @class\n   * @param {jQuery} element - jQuery object to make into a slider control.\n   * @param {Object} options - Overrides to the default plugin settings.\n   */\n  constructor(element, options) {\n    this.$element = element;\n    this.options = $.extend({}, Slider.defaults, this.$element.data(), options);\n\n    this._init();\n\n    Foundation.registerPlugin(this, 'Slider');\n    Foundation.Keyboard.register('Slider', {\n      'ltr': {\n        'ARROW_RIGHT': 'increase',\n        'ARROW_UP': 'increase',\n        'ARROW_DOWN': 'decrease',\n        'ARROW_LEFT': 'decrease',\n        'SHIFT_ARROW_RIGHT': 'increase_fast',\n        'SHIFT_ARROW_UP': 'increase_fast',\n        'SHIFT_ARROW_DOWN': 'decrease_fast',\n        'SHIFT_ARROW_LEFT': 'decrease_fast'\n      },\n      'rtl': {\n        'ARROW_LEFT': 'increase',\n        'ARROW_RIGHT': 'decrease',\n        'SHIFT_ARROW_LEFT': 'increase_fast',\n        'SHIFT_ARROW_RIGHT': 'decrease_fast'\n      }\n    });\n  }\n\n  /**\n   * Initilizes the plugin by reading/setting attributes, creating collections and setting the initial position of the handle(s).\n   * @function\n   * @private\n   */\n  _init() {\n    this.inputs = this.$element.find('input');\n    this.handles = this.$element.find('[data-slider-handle]');\n\n    this.$handle = this.handles.eq(0);\n    this.$input = this.inputs.length ? this.inputs.eq(0) : $(`#${this.$handle.attr('aria-controls')}`);\n    this.$fill = this.$element.find('[data-slider-fill]').css(this.options.vertical ? 'height' : 'width', 0);\n\n    var isDbl = false,\n        _this = this;\n    if (this.options.disabled || this.$element.hasClass(this.options.disabledClass)) {\n      this.options.disabled = true;\n      this.$element.addClass(this.options.disabledClass);\n    }\n    if (!this.inputs.length) {\n      this.inputs = $().add(this.$input);\n      this.options.binding = true;\n    }\n\n    this._setInitAttr(0);\n\n    if (this.handles[1]) {\n      this.options.doubleSided = true;\n      this.$handle2 = this.handles.eq(1);\n      this.$input2 = this.inputs.length > 1 ? this.inputs.eq(1) : $(`#${this.$handle2.attr('aria-controls')}`);\n\n      if (!this.inputs[1]) {\n        this.inputs = this.inputs.add(this.$input2);\n      }\n      isDbl = true;\n\n      // this.$handle.triggerHandler('click.zf.slider');\n      this._setInitAttr(1);\n    }\n\n    // Set handle positions\n    this.setHandles();\n\n    this._events();\n  }\n\n  setHandles() {\n    if(this.handles[1]) {\n      this._setHandlePos(this.$handle, this.inputs.eq(0).val(), true, () => {\n        this._setHandlePos(this.$handle2, this.inputs.eq(1).val(), true);\n      });\n    } else {\n      this._setHandlePos(this.$handle, this.inputs.eq(0).val(), true);\n    }\n  }\n\n  _reflow() {\n    this.setHandles();\n  }\n  /**\n  * @function\n  * @private\n  * @param {Number} value - floating point (the value) to be transformed using to a relative position on the slider (the inverse of _value)\n  */\n  _pctOfBar(value) {\n    var pctOfBar = percent(value - this.options.start, this.options.end - this.options.start)\n\n    switch(this.options.positionValueFunction) {\n    case \"pow\":\n      pctOfBar = this._logTransform(pctOfBar);\n      break;\n    case \"log\":\n      pctOfBar = this._powTransform(pctOfBar);\n      break;\n    }\n\n    return pctOfBar.toFixed(2)\n  }\n\n  /**\n  * @function\n  * @private\n  * @param {Number} pctOfBar - floating point, the relative position of the slider (typically between 0-1) to be transformed to a value\n  */\n  _value(pctOfBar) {\n    switch(this.options.positionValueFunction) {\n    case \"pow\":\n      pctOfBar = this._powTransform(pctOfBar);\n      break;\n    case \"log\":\n      pctOfBar = this._logTransform(pctOfBar);\n      break;\n    }\n    var value = (this.options.end - this.options.start) * pctOfBar + this.options.start;\n\n    return value\n  }\n\n  /**\n  * @function\n  * @private\n  * @param {Number} value - floating point (typically between 0-1) to be transformed using the log function\n  */\n  _logTransform(value) {\n    return baseLog(this.options.nonLinearBase, ((value*(this.options.nonLinearBase-1))+1))\n  }\n\n  /**\n  * @function\n  * @private\n  * @param {Number} value - floating point (typically between 0-1) to be transformed using the power function\n  */\n  _powTransform(value) {\n    return (Math.pow(this.options.nonLinearBase, value) - 1) / (this.options.nonLinearBase - 1)\n  }\n\n  /**\n   * Sets the position of the selected handle and fill bar.\n   * @function\n   * @private\n   * @param {jQuery} $hndl - the selected handle to move.\n   * @param {Number} location - floating point between the start and end values of the slider bar.\n   * @param {Function} cb - callback function to fire on completion.\n   * @fires Slider#moved\n   * @fires Slider#changed\n   */\n  _setHandlePos($hndl, location, noInvert, cb) {\n    // don't move if the slider has been disabled since its initialization\n    if (this.$element.hasClass(this.options.disabledClass)) {\n      return;\n    }\n    //might need to alter that slightly for bars that will have odd number selections.\n    location = parseFloat(location);//on input change events, convert string to number...grumble.\n\n    // prevent slider from running out of bounds, if value exceeds the limits set through options, override the value to min/max\n    if (location < this.options.start) { location = this.options.start; }\n    else if (location > this.options.end) { location = this.options.end; }\n\n    var isDbl = this.options.doubleSided;\n\n    if (isDbl) { //this block is to prevent 2 handles from crossing eachother. Could/should be improved.\n      if (this.handles.index($hndl) === 0) {\n        var h2Val = parseFloat(this.$handle2.attr('aria-valuenow'));\n        location = location >= h2Val ? h2Val - this.options.step : location;\n      } else {\n        var h1Val = parseFloat(this.$handle.attr('aria-valuenow'));\n        location = location <= h1Val ? h1Val + this.options.step : location;\n      }\n    }\n\n    //this is for single-handled vertical sliders, it adjusts the value to account for the slider being \"upside-down\"\n    //for click and drag events, it's weird due to the scale(-1, 1) css property\n    if (this.options.vertical && !noInvert) {\n      location = this.options.end - location;\n    }\n\n    var _this = this,\n        vert = this.options.vertical,\n        hOrW = vert ? 'height' : 'width',\n        lOrT = vert ? 'top' : 'left',\n        handleDim = $hndl[0].getBoundingClientRect()[hOrW],\n        elemDim = this.$element[0].getBoundingClientRect()[hOrW],\n        //percentage of bar min/max value based on click or drag point\n        pctOfBar = this._pctOfBar(location),\n        //number of actual pixels to shift the handle, based on the percentage obtained above\n        pxToMove = (elemDim - handleDim) * pctOfBar,\n        //percentage of bar to shift the handle\n        movement = (percent(pxToMove, elemDim) * 100).toFixed(this.options.decimal);\n        //fixing the decimal value for the location number, is passed to other methods as a fixed floating-point value\n        location = parseFloat(location.toFixed(this.options.decimal));\n        // declare empty object for css adjustments, only used with 2 handled-sliders\n    var css = {};\n\n    this._setValues($hndl, location);\n\n    // TODO update to calculate based on values set to respective inputs??\n    if (isDbl) {\n      var isLeftHndl = this.handles.index($hndl) === 0,\n          //empty variable, will be used for min-height/width for fill bar\n          dim,\n          //percentage w/h of the handle compared to the slider bar\n          handlePct =  ~~(percent(handleDim, elemDim) * 100);\n      //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\n      if (isLeftHndl) {\n        //left or top percentage value to apply to the fill bar.\n        css[lOrT] = `${movement}%`;\n        //calculate the new min-height/width for the fill bar.\n        dim = parseFloat(this.$handle2[0].style[lOrT]) - movement + handlePct;\n        //this callback is necessary to prevent errors and allow the proper placement and initialization of a 2-handled slider\n        //plus, it means we don't care if 'dim' isNaN on init, it won't be in the future.\n        if (cb && typeof cb === 'function') { cb(); }//this is only needed for the initialization of 2 handled sliders\n      } else {\n        //just caching the value of the left/bottom handle's left/top property\n        var handlePos = parseFloat(this.$handle[0].style[lOrT]);\n        //calculate the new min-height/width for the fill bar. Use isNaN to prevent false positives for numbers <= 0\n        //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\n        dim = movement - (isNaN(handlePos) ? (this.options.initialStart - this.options.start)/((this.options.end-this.options.start)/100) : handlePos) + handlePct;\n      }\n      // assign the min-height/width to our css object\n      css[`min-${hOrW}`] = `${dim}%`;\n    }\n\n    this.$element.one('finished.zf.animate', function() {\n                    /**\n                     * Fires when the handle is done moving.\n                     * @event Slider#moved\n                     */\n                    _this.$element.trigger('moved.zf.slider', [$hndl]);\n                });\n\n    //because we don't know exactly how the handle will be moved, check the amount of time it should take to move.\n    var moveTime = this.$element.data('dragging') ? 1000/60 : this.options.moveTime;\n\n    Foundation.Move(moveTime, $hndl, function() {\n      // adjusting the left/top property of the handle, based on the percentage calculated above\n      // if movement isNaN, that is because the slider is hidden and we cannot determine handle width,\n      // fall back to next best guess.\n      if (isNaN(movement)) {\n        $hndl.css(lOrT, `${pctOfBar * 100}%`);\n      }\n      else {\n        $hndl.css(lOrT, `${movement}%`);\n      }\n\n      if (!_this.options.doubleSided) {\n        //if single-handled, a simple method to expand the fill bar\n        _this.$fill.css(hOrW, `${pctOfBar * 100}%`);\n      } else {\n        //otherwise, use the css object we created above\n        _this.$fill.css(css);\n      }\n    });\n\n\n    /**\n     * Fires when the value has not been change for a given time.\n     * @event Slider#changed\n     */\n    clearTimeout(_this.timeout);\n    _this.timeout = setTimeout(function(){\n      _this.$element.trigger('changed.zf.slider', [$hndl]);\n    }, _this.options.changedDelay);\n  }\n\n  /**\n   * Sets the initial attribute for the slider element.\n   * @function\n   * @private\n   * @param {Number} idx - index of the current handle/input to use.\n   */\n  _setInitAttr(idx) {\n    var initVal = (idx === 0 ? this.options.initialStart : this.options.initialEnd)\n    var id = this.inputs.eq(idx).attr('id') || Foundation.GetYoDigits(6, 'slider');\n    this.inputs.eq(idx).attr({\n      'id': id,\n      'max': this.options.end,\n      'min': this.options.start,\n      'step': this.options.step\n    });\n    this.inputs.eq(idx).val(initVal);\n    this.handles.eq(idx).attr({\n      'role': 'slider',\n      'aria-controls': id,\n      'aria-valuemax': this.options.end,\n      'aria-valuemin': this.options.start,\n      'aria-valuenow': initVal,\n      'aria-orientation': this.options.vertical ? 'vertical' : 'horizontal',\n      'tabindex': 0\n    });\n  }\n\n  /**\n   * Sets the input and `aria-valuenow` values for the slider element.\n   * @function\n   * @private\n   * @param {jQuery} $handle - the currently selected handle.\n   * @param {Number} val - floating point of the new value.\n   */\n  _setValues($handle, val) {\n    var idx = this.options.doubleSided ? this.handles.index($handle) : 0;\n    this.inputs.eq(idx).val(val);\n    $handle.attr('aria-valuenow', val);\n  }\n\n  /**\n   * Handles events on the slider element.\n   * Calculates the new location of the current handle.\n   * If there are two handles and the bar was clicked, it determines which handle to move.\n   * @function\n   * @private\n   * @param {Object} e - the `event` object passed from the listener.\n   * @param {jQuery} $handle - the current handle to calculate for, if selected.\n   * @param {Number} val - floating point number for the new value of the slider.\n   * TODO clean this up, there's a lot of repeated code between this and the _setHandlePos fn.\n   */\n  _handleEvent(e, $handle, val) {\n    var value, hasVal;\n    if (!val) {//click or drag events\n      e.preventDefault();\n      var _this = this,\n          vertical = this.options.vertical,\n          param = vertical ? 'height' : 'width',\n          direction = vertical ? 'top' : 'left',\n          eventOffset = vertical ? e.pageY : e.pageX,\n          halfOfHandle = this.$handle[0].getBoundingClientRect()[param] / 2,\n          barDim = this.$element[0].getBoundingClientRect()[param],\n          windowScroll = vertical ? $(window).scrollTop() : $(window).scrollLeft();\n\n\n      var elemOffset = this.$element.offset()[direction];\n\n      // touch events emulated by the touch util give position relative to screen, add window.scroll to event coordinates...\n      // best way to guess this is simulated is if clientY == pageY\n      if (e.clientY === e.pageY) { eventOffset = eventOffset + windowScroll; }\n      var eventFromBar = eventOffset - elemOffset;\n      var barXY;\n      if (eventFromBar < 0) {\n        barXY = 0;\n      } else if (eventFromBar > barDim) {\n        barXY = barDim;\n      } else {\n        barXY = eventFromBar;\n      }\n      var offsetPct = percent(barXY, barDim);\n\n      value = this._value(offsetPct);\n\n      // turn everything around for RTL, yay math!\n      if (Foundation.rtl() && !this.options.vertical) {value = this.options.end - value;}\n\n      value = _this._adjustValue(null, value);\n      //boolean flag for the setHandlePos fn, specifically for vertical sliders\n      hasVal = false;\n\n      if (!$handle) {//figure out which handle it is, pass it to the next function.\n        var firstHndlPos = absPosition(this.$handle, direction, barXY, param),\n            secndHndlPos = absPosition(this.$handle2, direction, barXY, param);\n            $handle = firstHndlPos <= secndHndlPos ? this.$handle : this.$handle2;\n      }\n\n    } else {//change event on input\n      value = this._adjustValue(null, val);\n      hasVal = true;\n    }\n\n    this._setHandlePos($handle, value, hasVal);\n  }\n\n  /**\n   * Adjustes value for handle in regard to step value. returns adjusted value\n   * @function\n   * @private\n   * @param {jQuery} $handle - the selected handle.\n   * @param {Number} value - value to adjust. used if $handle is falsy\n   */\n  _adjustValue($handle, value) {\n    var val,\n      step = this.options.step,\n      div = parseFloat(step/2),\n      left, prev_val, next_val;\n    if (!!$handle) {\n      val = parseFloat($handle.attr('aria-valuenow'));\n    }\n    else {\n      val = value;\n    }\n    left = val % step;\n    prev_val = val - left;\n    next_val = prev_val + step;\n    if (left === 0) {\n      return val;\n    }\n    val = val >= prev_val + div ? next_val : prev_val;\n    return val;\n  }\n\n  /**\n   * Adds event listeners to the slider elements.\n   * @function\n   * @private\n   */\n  _events() {\n    this._eventsForHandle(this.$handle);\n    if(this.handles[1]) {\n      this._eventsForHandle(this.$handle2);\n    }\n  }\n\n\n  /**\n   * Adds event listeners a particular handle\n   * @function\n   * @private\n   * @param {jQuery} $handle - the current handle to apply listeners to.\n   */\n  _eventsForHandle($handle) {\n    var _this = this,\n        curHandle,\n        timer;\n\n      this.inputs.off('change.zf.slider').on('change.zf.slider', function(e) {\n        var idx = _this.inputs.index($(this));\n        _this._handleEvent(e, _this.handles.eq(idx), $(this).val());\n      });\n\n      if (this.options.clickSelect) {\n        this.$element.off('click.zf.slider').on('click.zf.slider', function(e) {\n          if (_this.$element.data('dragging')) { return false; }\n\n          if (!$(e.target).is('[data-slider-handle]')) {\n            if (_this.options.doubleSided) {\n              _this._handleEvent(e);\n            } else {\n              _this._handleEvent(e, _this.$handle);\n            }\n          }\n        });\n      }\n\n    if (this.options.draggable) {\n      this.handles.addTouch();\n\n      var $body = $('body');\n      $handle\n        .off('mousedown.zf.slider')\n        .on('mousedown.zf.slider', function(e) {\n          $handle.addClass('is-dragging');\n          _this.$fill.addClass('is-dragging');//\n          _this.$element.data('dragging', true);\n\n          curHandle = $(e.currentTarget);\n\n          $body.on('mousemove.zf.slider', function(e) {\n            e.preventDefault();\n            _this._handleEvent(e, curHandle);\n\n          }).on('mouseup.zf.slider', function(e) {\n            _this._handleEvent(e, curHandle);\n\n            $handle.removeClass('is-dragging');\n            _this.$fill.removeClass('is-dragging');\n            _this.$element.data('dragging', false);\n\n            $body.off('mousemove.zf.slider mouseup.zf.slider');\n          });\n      })\n      // prevent events triggered by touch\n      .on('selectstart.zf.slider touchmove.zf.slider', function(e) {\n        e.preventDefault();\n      });\n    }\n\n    $handle.off('keydown.zf.slider').on('keydown.zf.slider', function(e) {\n      var _$handle = $(this),\n          idx = _this.options.doubleSided ? _this.handles.index(_$handle) : 0,\n          oldValue = parseFloat(_this.inputs.eq(idx).val()),\n          newValue;\n\n      // handle keyboard event with keyboard util\n      Foundation.Keyboard.handleKey(e, 'Slider', {\n        decrease: function() {\n          newValue = oldValue - _this.options.step;\n        },\n        increase: function() {\n          newValue = oldValue + _this.options.step;\n        },\n        decrease_fast: function() {\n          newValue = oldValue - _this.options.step * 10;\n        },\n        increase_fast: function() {\n          newValue = oldValue + _this.options.step * 10;\n        },\n        handled: function() { // only set handle pos when event was handled specially\n          e.preventDefault();\n          _this._setHandlePos(_$handle, newValue, true);\n        }\n      });\n      /*if (newValue) { // if pressed key has special function, update value\n        e.preventDefault();\n        _this._setHandlePos(_$handle, newValue);\n      }*/\n    });\n  }\n\n  /**\n   * Destroys the slider plugin.\n   */\n  destroy() {\n    this.handles.off('.zf.slider');\n    this.inputs.off('.zf.slider');\n    this.$element.off('.zf.slider');\n\n    clearTimeout(this.timeout);\n\n    Foundation.unregisterPlugin(this);\n  }\n}\n\nSlider.defaults = {\n  /**\n   * Minimum value for the slider scale.\n   * @option\n   * @type {number}\n   * @default 0\n   */\n  start: 0,\n  /**\n   * Maximum value for the slider scale.\n   * @option\n   * @type {number}\n   * @default 100\n   */\n  end: 100,\n  /**\n   * Minimum value change per change event.\n   * @option\n   * @type {number}\n   * @default 1\n   */\n  step: 1,\n  /**\n   * Value at which the handle/input *(left handle/first input)* should be set to on initialization.\n   * @option\n   * @type {number}\n   * @default 0\n   */\n  initialStart: 0,\n  /**\n   * Value at which the right handle/second input should be set to on initialization.\n   * @option\n   * @type {number}\n   * @default 100\n   */\n  initialEnd: 100,\n  /**\n   * Allows the input to be located outside the container and visible. Set to by the JS\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  binding: false,\n  /**\n   * Allows the user to click/tap on the slider bar to select a value.\n   * @option\n   * @type {boolean}\n   * @default true\n   */\n  clickSelect: true,\n  /**\n   * Set to true and use the `vertical` class to change alignment to vertical.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  vertical: false,\n  /**\n   * Allows the user to drag the slider handle(s) to select a value.\n   * @option\n   * @type {boolean}\n   * @default true\n   */\n  draggable: true,\n  /**\n   * Disables the slider and prevents event listeners from being applied. Double checked by JS with `disabledClass`.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  disabled: false,\n  /**\n   * Allows the use of two handles. Double checked by the JS. Changes some logic handling.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  doubleSided: false,\n  /**\n   * Potential future feature.\n   */\n  // steps: 100,\n  /**\n   * Number of decimal places the plugin should go to for floating point precision.\n   * @option\n   * @type {number}\n   * @default 2\n   */\n  decimal: 2,\n  /**\n   * Time delay for dragged elements.\n   */\n  // dragDelay: 0,\n  /**\n   * 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.\n   * @option\n   * @type {number}\n   * @default 200\n   */\n  moveTime: 200,//update this if changing the transition time in the sass\n  /**\n   * Class applied to disabled sliders.\n   * @option\n   * @type {string}\n   * @default 'disabled'\n   */\n  disabledClass: 'disabled',\n  /**\n   * Will invert the default layout for a vertical<span data-tooltip title=\"who would do this???\"> </span>slider.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  invertVertical: false,\n  /**\n   * Milliseconds before the `changed.zf-slider` event is triggered after value change.\n   * @option\n   * @type {number}\n   * @default 500\n   */\n  changedDelay: 500,\n  /**\n  * Basevalue for non-linear sliders\n  * @option\n  * @type {number}\n  * @default 5\n  */\n  nonLinearBase: 5,\n  /**\n  * Basevalue for non-linear sliders, possible values are: `'linear'`, `'pow'` & `'log'`. Pow and Log use the nonLinearBase setting.\n  * @option\n  * @type {string}\n  * @default 'linear'\n  */\n  positionValueFunction: 'linear',\n};\n\nfunction percent(frac, num) {\n  return (frac / num);\n}\nfunction absPosition($handle, dir, clickPos, param) {\n  return Math.abs(($handle.position()[dir] + ($handle[param]() / 2)) - clickPos);\n}\nfunction baseLog(base, value) {\n  return Math.log(value)/Math.log(base)\n}\n\n// Window exports\nFoundation.plugin(Slider, 'Slider');\n\n}(jQuery);\n\n","'use strict';\n\n!function($) {\n\n/**\n * Sticky module.\n * @module foundation.sticky\n * @requires foundation.util.triggers\n * @requires foundation.util.mediaQuery\n */\n\nclass Sticky {\n  /**\n   * Creates a new instance of a sticky thing.\n   * @class\n   * @param {jQuery} element - jQuery object to make sticky.\n   * @param {Object} options - options object passed when creating the element programmatically.\n   */\n  constructor(element, options) {\n    this.$element = element;\n    this.options = $.extend({}, Sticky.defaults, this.$element.data(), options);\n\n    this._init();\n\n    Foundation.registerPlugin(this, 'Sticky');\n  }\n\n  /**\n   * Initializes the sticky element by adding classes, getting/setting dimensions, breakpoints and attributes\n   * @function\n   * @private\n   */\n  _init() {\n    var $parent = this.$element.parent('[data-sticky-container]'),\n        id = this.$element[0].id || Foundation.GetYoDigits(6, 'sticky'),\n        _this = this;\n\n    if (!$parent.length) {\n      this.wasWrapped = true;\n    }\n    this.$container = $parent.length ? $parent : $(this.options.container).wrapInner(this.$element);\n    this.$container.addClass(this.options.containerClass);\n\n    this.$element.addClass(this.options.stickyClass).attr({ 'data-resize': id, 'data-mutate': id });\n    if (this.options.anchor !== '') {\n        $('#' + _this.options.anchor).attr({ 'data-mutate': id });\n    }\n\n    this.scrollCount = this.options.checkEvery;\n    this.isStuck = false;\n    $(window).one('load.zf.sticky', function(){\n      //We calculate the container height to have correct values for anchor points offset calculation.\n      _this.containerHeight = _this.$element.css(\"display\") == \"none\" ? 0 : _this.$element[0].getBoundingClientRect().height;\n      _this.$container.css('height', _this.containerHeight);\n      _this.elemHeight = _this.containerHeight;\n      if(_this.options.anchor !== ''){\n        _this.$anchor = $('#' + _this.options.anchor);\n      }else{\n        _this._parsePoints();\n      }\n\n      _this._setSizes(function(){\n        var scroll = window.pageYOffset;\n        _this._calc(false, scroll);\n        //Unstick the element will ensure that proper classes are set.\n        if (!_this.isStuck) {\n          _this._removeSticky((scroll >= _this.topPoint) ? false : true);\n        }\n      });\n      _this._events(id.split('-').reverse().join('-'));\n    });\n  }\n\n  /**\n   * If using multiple elements as anchors, calculates the top and bottom pixel values the sticky thing should stick and unstick on.\n   * @function\n   * @private\n   */\n  _parsePoints() {\n    var top = this.options.topAnchor == \"\" ? 1 : this.options.topAnchor,\n        btm = this.options.btmAnchor== \"\" ? document.documentElement.scrollHeight : this.options.btmAnchor,\n        pts = [top, btm],\n        breaks = {};\n    for (var i = 0, len = pts.length; i < len && pts[i]; i++) {\n      var pt;\n      if (typeof pts[i] === 'number') {\n        pt = pts[i];\n      } else {\n        var place = pts[i].split(':'),\n            anchor = $(`#${place[0]}`);\n\n        pt = anchor.offset().top;\n        if (place[1] && place[1].toLowerCase() === 'bottom') {\n          pt += anchor[0].getBoundingClientRect().height;\n        }\n      }\n      breaks[i] = pt;\n    }\n\n\n    this.points = breaks;\n    return;\n  }\n\n  /**\n   * Adds event handlers for the scrolling element.\n   * @private\n   * @param {String} id - psuedo-random id for unique scroll event listener.\n   */\n  _events(id) {\n    var _this = this,\n        scrollListener = this.scrollListener = `scroll.zf.${id}`;\n    if (this.isOn) { return; }\n    if (this.canStick) {\n      this.isOn = true;\n      $(window).off(scrollListener)\n               .on(scrollListener, function(e) {\n                 if (_this.scrollCount === 0) {\n                   _this.scrollCount = _this.options.checkEvery;\n                   _this._setSizes(function() {\n                     _this._calc(false, window.pageYOffset);\n                   });\n                 } else {\n                   _this.scrollCount--;\n                   _this._calc(false, window.pageYOffset);\n                 }\n              });\n    }\n\n    this.$element.off('resizeme.zf.trigger')\n                 .on('resizeme.zf.trigger', function(e, el) {\n                    _this._eventsHandler(id);\n    });\n\n    this.$element.on('mutateme.zf.trigger', function (e, el) {\n        _this._eventsHandler(id);\n    });\n\n    if(this.$anchor) {\n      this.$anchor.on('mutateme.zf.trigger', function (e, el) {\n          _this._eventsHandler(id);\n      });\n    }\n  }\n\n  /**\n   * Handler for events.\n   * @private\n   * @param {String} id - psuedo-random id for unique scroll event listener.\n   */\n  _eventsHandler(id) {\n       var _this = this,\n        scrollListener = this.scrollListener = `scroll.zf.${id}`;\n\n       _this._setSizes(function() {\n       _this._calc(false);\n       if (_this.canStick) {\n         if (!_this.isOn) {\n           _this._events(id);\n         }\n       } else if (_this.isOn) {\n         _this._pauseListeners(scrollListener);\n       }\n     });\n  }\n\n  /**\n   * Removes event handlers for scroll and change events on anchor.\n   * @fires Sticky#pause\n   * @param {String} scrollListener - unique, namespaced scroll listener attached to `window`\n   */\n  _pauseListeners(scrollListener) {\n    this.isOn = false;\n    $(window).off(scrollListener);\n\n    /**\n     * Fires when the plugin is paused due to resize event shrinking the view.\n     * @event Sticky#pause\n     * @private\n     */\n     this.$element.trigger('pause.zf.sticky');\n  }\n\n  /**\n   * Called on every `scroll` event and on `_init`\n   * fires functions based on booleans and cached values\n   * @param {Boolean} checkSizes - true if plugin should recalculate sizes and breakpoints.\n   * @param {Number} scroll - current scroll position passed from scroll event cb function. If not passed, defaults to `window.pageYOffset`.\n   */\n  _calc(checkSizes, scroll) {\n    if (checkSizes) { this._setSizes(); }\n\n    if (!this.canStick) {\n      if (this.isStuck) {\n        this._removeSticky(true);\n      }\n      return false;\n    }\n\n    if (!scroll) { scroll = window.pageYOffset; }\n\n    if (scroll >= this.topPoint) {\n      if (scroll <= this.bottomPoint) {\n        if (!this.isStuck) {\n          this._setSticky();\n        }\n      } else {\n        if (this.isStuck) {\n          this._removeSticky(false);\n        }\n      }\n    } else {\n      if (this.isStuck) {\n        this._removeSticky(true);\n      }\n    }\n  }\n\n  /**\n   * Causes the $element to become stuck.\n   * Adds `position: fixed;`, and helper classes.\n   * @fires Sticky#stuckto\n   * @function\n   * @private\n   */\n  _setSticky() {\n    var _this = this,\n        stickTo = this.options.stickTo,\n        mrgn = stickTo === 'top' ? 'marginTop' : 'marginBottom',\n        notStuckTo = stickTo === 'top' ? 'bottom' : 'top',\n        css = {};\n\n    css[mrgn] = `${this.options[mrgn]}em`;\n    css[stickTo] = 0;\n    css[notStuckTo] = 'auto';\n    this.isStuck = true;\n    this.$element.removeClass(`is-anchored is-at-${notStuckTo}`)\n                 .addClass(`is-stuck is-at-${stickTo}`)\n                 .css(css)\n                 /**\n                  * Fires when the $element has become `position: fixed;`\n                  * Namespaced to `top` or `bottom`, e.g. `sticky.zf.stuckto:top`\n                  * @event Sticky#stuckto\n                  */\n                 .trigger(`sticky.zf.stuckto:${stickTo}`);\n    this.$element.on(\"transitionend webkitTransitionEnd oTransitionEnd otransitionend MSTransitionEnd\", function() {\n      _this._setSizes();\n    });\n  }\n\n  /**\n   * Causes the $element to become unstuck.\n   * Removes `position: fixed;`, and helper classes.\n   * Adds other helper classes.\n   * @param {Boolean} isTop - tells the function if the $element should anchor to the top or bottom of its $anchor element.\n   * @fires Sticky#unstuckfrom\n   * @private\n   */\n  _removeSticky(isTop) {\n    var stickTo = this.options.stickTo,\n        stickToTop = stickTo === 'top',\n        css = {},\n        anchorPt = (this.points ? this.points[1] - this.points[0] : this.anchorHeight) - this.elemHeight,\n        mrgn = stickToTop ? 'marginTop' : 'marginBottom',\n        notStuckTo = stickToTop ? 'bottom' : 'top',\n        topOrBottom = isTop ? 'top' : 'bottom';\n\n    css[mrgn] = 0;\n\n    css['bottom'] = 'auto';\n    if(isTop) {\n      css['top'] = 0;\n    } else {\n      css['top'] = anchorPt;\n    }\n\n    this.isStuck = false;\n    this.$element.removeClass(`is-stuck is-at-${stickTo}`)\n                 .addClass(`is-anchored is-at-${topOrBottom}`)\n                 .css(css)\n                 /**\n                  * Fires when the $element has become anchored.\n                  * Namespaced to `top` or `bottom`, e.g. `sticky.zf.unstuckfrom:bottom`\n                  * @event Sticky#unstuckfrom\n                  */\n                 .trigger(`sticky.zf.unstuckfrom:${topOrBottom}`);\n  }\n\n  /**\n   * Sets the $element and $container sizes for plugin.\n   * Calls `_setBreakPoints`.\n   * @param {Function} cb - optional callback function to fire on completion of `_setBreakPoints`.\n   * @private\n   */\n  _setSizes(cb) {\n    this.canStick = Foundation.MediaQuery.is(this.options.stickyOn);\n    if (!this.canStick) {\n      if (cb && typeof cb === 'function') { cb(); }\n    }\n    var _this = this,\n        newElemWidth = this.$container[0].getBoundingClientRect().width,\n        comp = window.getComputedStyle(this.$container[0]),\n        pdngl = parseInt(comp['padding-left'], 10),\n        pdngr = parseInt(comp['padding-right'], 10);\n\n    if (this.$anchor && this.$anchor.length) {\n      this.anchorHeight = this.$anchor[0].getBoundingClientRect().height;\n    } else {\n      this._parsePoints();\n    }\n\n    this.$element.css({\n      'max-width': `${newElemWidth - pdngl - pdngr}px`\n    });\n\n    var newContainerHeight = this.$element[0].getBoundingClientRect().height || this.containerHeight;\n    if (this.$element.css(\"display\") == \"none\") {\n      newContainerHeight = 0;\n    }\n    this.containerHeight = newContainerHeight;\n    this.$container.css({\n      height: newContainerHeight\n    });\n    this.elemHeight = newContainerHeight;\n\n    if (!this.isStuck) {\n      if (this.$element.hasClass('is-at-bottom')) {\n        var anchorPt = (this.points ? this.points[1] - this.$container.offset().top : this.anchorHeight) - this.elemHeight;\n        this.$element.css('top', anchorPt);\n      }\n    }\n\n    this._setBreakPoints(newContainerHeight, function() {\n      if (cb && typeof cb === 'function') { cb(); }\n    });\n  }\n\n  /**\n   * Sets the upper and lower breakpoints for the element to become sticky/unsticky.\n   * @param {Number} elemHeight - px value for sticky.$element height, calculated by `_setSizes`.\n   * @param {Function} cb - optional callback function to be called on completion.\n   * @private\n   */\n  _setBreakPoints(elemHeight, cb) {\n    if (!this.canStick) {\n      if (cb && typeof cb === 'function') { cb(); }\n      else { return false; }\n    }\n    var mTop = emCalc(this.options.marginTop),\n        mBtm = emCalc(this.options.marginBottom),\n        topPoint = this.points ? this.points[0] : this.$anchor.offset().top,\n        bottomPoint = this.points ? this.points[1] : topPoint + this.anchorHeight,\n        // topPoint = this.$anchor.offset().top || this.points[0],\n        // bottomPoint = topPoint + this.anchorHeight || this.points[1],\n        winHeight = window.innerHeight;\n\n    if (this.options.stickTo === 'top') {\n      topPoint -= mTop;\n      bottomPoint -= (elemHeight + mTop);\n    } else if (this.options.stickTo === 'bottom') {\n      topPoint -= (winHeight - (elemHeight + mBtm));\n      bottomPoint -= (winHeight - mBtm);\n    } else {\n      //this would be the stickTo: both option... tricky\n    }\n\n    this.topPoint = topPoint;\n    this.bottomPoint = bottomPoint;\n\n    if (cb && typeof cb === 'function') { cb(); }\n  }\n\n  /**\n   * Destroys the current sticky element.\n   * Resets the element to the top position first.\n   * Removes event listeners, JS-added css properties and classes, and unwraps the $element if the JS added the $container.\n   * @function\n   */\n  destroy() {\n    this._removeSticky(true);\n\n    this.$element.removeClass(`${this.options.stickyClass} is-anchored is-at-top`)\n                 .css({\n                   height: '',\n                   top: '',\n                   bottom: '',\n                   'max-width': ''\n                 })\n                 .off('resizeme.zf.trigger')\n                 .off('mutateme.zf.trigger');\n    if (this.$anchor && this.$anchor.length) {\n      this.$anchor.off('change.zf.sticky');\n    }\n    $(window).off(this.scrollListener);\n\n    if (this.wasWrapped) {\n      this.$element.unwrap();\n    } else {\n      this.$container.removeClass(this.options.containerClass)\n                     .css({\n                       height: ''\n                     });\n    }\n    Foundation.unregisterPlugin(this);\n  }\n}\n\nSticky.defaults = {\n  /**\n   * Customizable container template. Add your own classes for styling and sizing.\n   * @option\n   * @type {string}\n   * @default '&lt;div data-sticky-container&gt;&lt;/div&gt;'\n   */\n  container: '<div data-sticky-container></div>',\n  /**\n   * Location in the view the element sticks to. Can be `'top'` or `'bottom'`.\n   * @option\n   * @type {string}\n   * @default 'top'\n   */\n  stickTo: 'top',\n  /**\n   * If anchored to a single element, the id of that element.\n   * @option\n   * @type {string}\n   * @default ''\n   */\n  anchor: '',\n  /**\n   * If using more than one element as anchor points, the id of the top anchor.\n   * @option\n   * @type {string}\n   * @default ''\n   */\n  topAnchor: '',\n  /**\n   * If using more than one element as anchor points, the id of the bottom anchor.\n   * @option\n   * @type {string}\n   * @default ''\n   */\n  btmAnchor: '',\n  /**\n   * Margin, in `em`'s to apply to the top of the element when it becomes sticky.\n   * @option\n   * @type {number}\n   * @default 1\n   */\n  marginTop: 1,\n  /**\n   * Margin, in `em`'s to apply to the bottom of the element when it becomes sticky.\n   * @option\n   * @type {number}\n   * @default 1\n   */\n  marginBottom: 1,\n  /**\n   * Breakpoint string that is the minimum screen size an element should become sticky.\n   * @option\n   * @type {string}\n   * @default 'medium'\n   */\n  stickyOn: 'medium',\n  /**\n   * Class applied to sticky element, and removed on destruction. Foundation defaults to `sticky`.\n   * @option\n   * @type {string}\n   * @default 'sticky'\n   */\n  stickyClass: 'sticky',\n  /**\n   * Class applied to sticky container. Foundation defaults to `sticky-container`.\n   * @option\n   * @type {string}\n   * @default 'sticky-container'\n   */\n  containerClass: 'sticky-container',\n  /**\n   * 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.\n   * @option\n   * @type {number}\n   * @default -1\n   */\n  checkEvery: -1\n};\n\n/**\n * Helper function to calculate em values\n * @param Number {em} - number of em's to calculate into pixels\n */\nfunction emCalc(em) {\n  return parseInt(window.getComputedStyle(document.body, null).fontSize, 10) * em;\n}\n\n// Window exports\nFoundation.plugin(Sticky, 'Sticky');\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * Tabs module.\n * @module foundation.tabs\n * @requires foundation.util.keyboard\n * @requires foundation.util.timerAndImageLoader if tabs contain images\n */\n\nclass Tabs {\n  /**\n   * Creates a new instance of tabs.\n   * @class\n   * @fires Tabs#init\n   * @param {jQuery} element - jQuery object to make into tabs.\n   * @param {Object} options - Overrides to the default plugin settings.\n   */\n  constructor(element, options) {\n    this.$element = element;\n    this.options = $.extend({}, Tabs.defaults, this.$element.data(), options);\n\n    this._init();\n    Foundation.registerPlugin(this, 'Tabs');\n    Foundation.Keyboard.register('Tabs', {\n      'ENTER': 'open',\n      'SPACE': 'open',\n      'ARROW_RIGHT': 'next',\n      'ARROW_UP': 'previous',\n      'ARROW_DOWN': 'next',\n      'ARROW_LEFT': 'previous'\n      // 'TAB': 'next',\n      // 'SHIFT_TAB': 'previous'\n    });\n  }\n\n  /**\n   * Initializes the tabs by showing and focusing (if autoFocus=true) the preset active tab.\n   * @private\n   */\n  _init() {\n    var _this = this;\n\n    this.$element.attr({'role': 'tablist'});\n    this.$tabTitles = this.$element.find(`.${this.options.linkClass}`);\n    this.$tabContent = $(`[data-tabs-content=\"${this.$element[0].id}\"]`);\n\n    this.$tabTitles.each(function(){\n      var $elem = $(this),\n          $link = $elem.find('a'),\n          isActive = $elem.hasClass(`${_this.options.linkActiveClass}`),\n          hash = $link[0].hash.slice(1),\n          linkId = $link[0].id ? $link[0].id : `${hash}-label`,\n          $tabContent = $(`#${hash}`);\n\n      $elem.attr({'role': 'presentation'});\n\n      $link.attr({\n        'role': 'tab',\n        'aria-controls': hash,\n        'aria-selected': isActive,\n        'id': linkId\n      });\n\n      $tabContent.attr({\n        'role': 'tabpanel',\n        'aria-hidden': !isActive,\n        'aria-labelledby': linkId\n      });\n\n      if(isActive && _this.options.autoFocus){\n        $(window).load(function() {\n          $('html, body').animate({ scrollTop: $elem.offset().top }, _this.options.deepLinkSmudgeDelay, () => {\n            $link.focus();\n          });\n        });\n      }\n    });\n    if(this.options.matchHeight) {\n      var $images = this.$tabContent.find('img');\n\n      if ($images.length) {\n        Foundation.onImagesLoaded($images, this._setHeight.bind(this));\n      } else {\n        this._setHeight();\n      }\n    }\n\n     //current context-bound function to open tabs on page load or history popstate\n    this._checkDeepLink = () => {\n      var anchor = window.location.hash;\n      //need a hash and a relevant anchor in this tabset\n      if(anchor.length) {\n        var $link = this.$element.find('[href$=\"'+anchor+'\"]');\n        if ($link.length) {\n          this.selectTab($(anchor), true);\n\n          //roll up a little to show the titles\n          if (this.options.deepLinkSmudge) {\n            var offset = this.$element.offset();\n            $('html, body').animate({ scrollTop: offset.top }, this.options.deepLinkSmudgeDelay);\n          }\n\n          /**\n            * Fires when the zplugin has deeplinked at pageload\n            * @event Tabs#deeplink\n            */\n           this.$element.trigger('deeplink.zf.tabs', [$link, $(anchor)]);\n         }\n       }\n     }\n\n    //use browser to open a tab, if it exists in this tabset\n    if (this.options.deepLink) {\n      this._checkDeepLink();\n    }\n\n    this._events();\n  }\n\n  /**\n   * Adds event handlers for items within the tabs.\n   * @private\n   */\n  _events() {\n    this._addKeyHandler();\n    this._addClickHandler();\n    this._setHeightMqHandler = null;\n\n    if (this.options.matchHeight) {\n      this._setHeightMqHandler = this._setHeight.bind(this);\n\n      $(window).on('changed.zf.mediaquery', this._setHeightMqHandler);\n    }\n\n    if(this.options.deepLink) {\n      $(window).on('popstate', this._checkDeepLink);\n    }\n  }\n\n  /**\n   * Adds click handlers for items within the tabs.\n   * @private\n   */\n  _addClickHandler() {\n    var _this = this;\n\n    this.$element\n      .off('click.zf.tabs')\n      .on('click.zf.tabs', `.${this.options.linkClass}`, function(e){\n        e.preventDefault();\n        e.stopPropagation();\n        _this._handleTabChange($(this));\n      });\n  }\n\n  /**\n   * Adds keyboard event handlers for items within the tabs.\n   * @private\n   */\n  _addKeyHandler() {\n    var _this = this;\n\n    this.$tabTitles.off('keydown.zf.tabs').on('keydown.zf.tabs', function(e){\n      if (e.which === 9) return;\n\n\n      var $element = $(this),\n        $elements = $element.parent('ul').children('li'),\n        $prevElement,\n        $nextElement;\n\n      $elements.each(function(i) {\n        if ($(this).is($element)) {\n          if (_this.options.wrapOnKeys) {\n            $prevElement = i === 0 ? $elements.last() : $elements.eq(i-1);\n            $nextElement = i === $elements.length -1 ? $elements.first() : $elements.eq(i+1);\n          } else {\n            $prevElement = $elements.eq(Math.max(0, i-1));\n            $nextElement = $elements.eq(Math.min(i+1, $elements.length-1));\n          }\n          return;\n        }\n      });\n\n      // handle keyboard event with keyboard util\n      Foundation.Keyboard.handleKey(e, 'Tabs', {\n        open: function() {\n          $element.find('[role=\"tab\"]').focus();\n          _this._handleTabChange($element);\n        },\n        previous: function() {\n          $prevElement.find('[role=\"tab\"]').focus();\n          _this._handleTabChange($prevElement);\n        },\n        next: function() {\n          $nextElement.find('[role=\"tab\"]').focus();\n          _this._handleTabChange($nextElement);\n        },\n        handled: function() {\n          e.stopPropagation();\n          e.preventDefault();\n        }\n      });\n    });\n  }\n\n  /**\n   * Opens the tab `$targetContent` defined by `$target`. Collapses active tab.\n   * @param {jQuery} $target - Tab to open.\n   * @param {boolean} historyHandled - browser has already handled a history update\n   * @fires Tabs#change\n   * @function\n   */\n  _handleTabChange($target, historyHandled) {\n\n    /**\n     * Check for active class on target. Collapse if exists.\n     */\n    if ($target.hasClass(`${this.options.linkActiveClass}`)) {\n        if(this.options.activeCollapse) {\n            this._collapseTab($target);\n\n           /**\n            * Fires when the zplugin has successfully collapsed tabs.\n            * @event Tabs#collapse\n            */\n            this.$element.trigger('collapse.zf.tabs', [$target]);\n        }\n        return;\n    }\n\n    var $oldTab = this.$element.\n          find(`.${this.options.linkClass}.${this.options.linkActiveClass}`),\n          $tabLink = $target.find('[role=\"tab\"]'),\n          hash = $tabLink[0].hash,\n          $targetContent = this.$tabContent.find(hash);\n\n    //close old tab\n    this._collapseTab($oldTab);\n\n    //open new tab\n    this._openTab($target);\n\n    //either replace or update browser history\n    if (this.options.deepLink && !historyHandled) {\n      var anchor = $target.find('a').attr('href');\n\n      if (this.options.updateHistory) {\n        history.pushState({}, '', anchor);\n      } else {\n        history.replaceState({}, '', anchor);\n      }\n    }\n\n    /**\n     * Fires when the plugin has successfully changed tabs.\n     * @event Tabs#change\n     */\n    this.$element.trigger('change.zf.tabs', [$target, $targetContent]);\n\n    //fire to children a mutation event\n    $targetContent.find(\"[data-mutate]\").trigger(\"mutateme.zf.trigger\");\n  }\n\n  /**\n   * Opens the tab `$targetContent` defined by `$target`.\n   * @param {jQuery} $target - Tab to Open.\n   * @function\n   */\n  _openTab($target) {\n      var $tabLink = $target.find('[role=\"tab\"]'),\n          hash = $tabLink[0].hash,\n          $targetContent = this.$tabContent.find(hash);\n\n      $target.addClass(`${this.options.linkActiveClass}`);\n\n      $tabLink.attr({'aria-selected': 'true'});\n\n      $targetContent\n        .addClass(`${this.options.panelActiveClass}`)\n        .attr({'aria-hidden': 'false'});\n  }\n\n  /**\n   * Collapses `$targetContent` defined by `$target`.\n   * @param {jQuery} $target - Tab to Open.\n   * @function\n   */\n  _collapseTab($target) {\n    var $target_anchor = $target\n      .removeClass(`${this.options.linkActiveClass}`)\n      .find('[role=\"tab\"]')\n      .attr({ 'aria-selected': 'false' });\n\n    $(`#${$target_anchor.attr('aria-controls')}`)\n      .removeClass(`${this.options.panelActiveClass}`)\n      .attr({ 'aria-hidden': 'true' });\n  }\n\n  /**\n   * Public method for selecting a content pane to display.\n   * @param {jQuery | String} elem - jQuery object or string of the id of the pane to display.\n   * @param {boolean} historyHandled - browser has already handled a history update\n   * @function\n   */\n  selectTab(elem, historyHandled) {\n    var idStr;\n\n    if (typeof elem === 'object') {\n      idStr = elem[0].id;\n    } else {\n      idStr = elem;\n    }\n\n    if (idStr.indexOf('#') < 0) {\n      idStr = `#${idStr}`;\n    }\n\n    var $target = this.$tabTitles.find(`[href$=\"${idStr}\"]`).parent(`.${this.options.linkClass}`);\n\n    this._handleTabChange($target, historyHandled);\n  };\n  /**\n   * Sets the height of each panel to the height of the tallest panel.\n   * If enabled in options, gets called on media query change.\n   * If loading content via external source, can be called directly or with _reflow.\n   * If enabled with `data-match-height=\"true\"`, tabs sets to equal height\n   * @function\n   * @private\n   */\n  _setHeight() {\n    var max = 0,\n        _this = this; // Lock down the `this` value for the root tabs object\n\n    this.$tabContent\n      .find(`.${this.options.panelClass}`)\n      .css('height', '')\n      .each(function() {\n\n        var panel = $(this),\n            isActive = panel.hasClass(`${_this.options.panelActiveClass}`); // get the options from the parent instead of trying to get them from the child\n\n        if (!isActive) {\n          panel.css({'visibility': 'hidden', 'display': 'block'});\n        }\n\n        var temp = this.getBoundingClientRect().height;\n\n        if (!isActive) {\n          panel.css({\n            'visibility': '',\n            'display': ''\n          });\n        }\n\n        max = temp > max ? temp : max;\n      })\n      .css('height', `${max}px`);\n  }\n\n  /**\n   * Destroys an instance of an tabs.\n   * @fires Tabs#destroyed\n   */\n  destroy() {\n    this.$element\n      .find(`.${this.options.linkClass}`)\n      .off('.zf.tabs').hide().end()\n      .find(`.${this.options.panelClass}`)\n      .hide();\n\n    if (this.options.matchHeight) {\n      if (this._setHeightMqHandler != null) {\n         $(window).off('changed.zf.mediaquery', this._setHeightMqHandler);\n      }\n    }\n\n    if (this.options.deepLink) {\n      $(window).off('popstate', this._checkDeepLink);\n    }\n\n    Foundation.unregisterPlugin(this);\n  }\n}\n\nTabs.defaults = {\n  /**\n   * Allows the window to scroll to content of pane specified by hash anchor\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  deepLink: false,\n\n  /**\n   * Adjust the deep link scroll to make sure the top of the tab panel is visible\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  deepLinkSmudge: false,\n\n  /**\n   * Animation time (ms) for the deep link adjustment\n   * @option\n   * @type {number}\n   * @default 300\n   */\n  deepLinkSmudgeDelay: 300,\n\n  /**\n   * Update the browser history with the open tab\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  updateHistory: false,\n\n  /**\n   * Allows the window to scroll to content of active pane on load if set to true.\n   * Not recommended if more than one tab panel per page.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  autoFocus: false,\n\n  /**\n   * Allows keyboard input to 'wrap' around the tab links.\n   * @option\n   * @type {boolean}\n   * @default true\n   */\n  wrapOnKeys: true,\n\n  /**\n   * Allows the tab content panes to match heights if set to true.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  matchHeight: false,\n\n  /**\n   * Allows active tabs to collapse when clicked.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  activeCollapse: false,\n\n  /**\n   * Class applied to `li`'s in tab link list.\n   * @option\n   * @type {string}\n   * @default 'tabs-title'\n   */\n  linkClass: 'tabs-title',\n\n  /**\n   * Class applied to the active `li` in tab link list.\n   * @option\n   * @type {string}\n   * @default 'is-active'\n   */\n  linkActiveClass: 'is-active',\n\n  /**\n   * Class applied to the content containers.\n   * @option\n   * @type {string}\n   * @default 'tabs-panel'\n   */\n  panelClass: 'tabs-panel',\n\n  /**\n   * Class applied to the active content container.\n   * @option\n   * @type {string}\n   * @default 'is-active'\n   */\n  panelActiveClass: 'is-active'\n};\n\n// Window exports\nFoundation.plugin(Tabs, 'Tabs');\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * Toggler module.\n * @module foundation.toggler\n * @requires foundation.util.motion\n * @requires foundation.util.triggers\n */\n\nclass Toggler {\n  /**\n   * Creates a new instance of Toggler.\n   * @class\n   * @fires Toggler#init\n   * @param {Object} element - jQuery object to add the trigger to.\n   * @param {Object} options - Overrides to the default plugin settings.\n   */\n  constructor(element, options) {\n    this.$element = element;\n    this.options = $.extend({}, Toggler.defaults, element.data(), options);\n    this.className = '';\n\n    this._init();\n    this._events();\n\n    Foundation.registerPlugin(this, 'Toggler');\n  }\n\n  /**\n   * Initializes the Toggler plugin by parsing the toggle class from data-toggler, or animation classes from data-animate.\n   * @function\n   * @private\n   */\n  _init() {\n    var input;\n    // Parse animation classes if they were set\n    if (this.options.animate) {\n      input = this.options.animate.split(' ');\n\n      this.animationIn = input[0];\n      this.animationOut = input[1] || null;\n    }\n    // Otherwise, parse toggle class\n    else {\n      input = this.$element.data('toggler');\n      // Allow for a . at the beginning of the string\n      this.className = input[0] === '.' ? input.slice(1) : input;\n    }\n\n    // Add ARIA attributes to triggers\n    var id = this.$element[0].id;\n    $(`[data-open=\"${id}\"], [data-close=\"${id}\"], [data-toggle=\"${id}\"]`)\n      .attr('aria-controls', id);\n    // If the target is hidden, add aria-hidden\n    this.$element.attr('aria-expanded', this.$element.is(':hidden') ? false : true);\n  }\n\n  /**\n   * Initializes events for the toggle trigger.\n   * @function\n   * @private\n   */\n  _events() {\n    this.$element.off('toggle.zf.trigger').on('toggle.zf.trigger', this.toggle.bind(this));\n  }\n\n  /**\n   * 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\".\n   * @function\n   * @fires Toggler#on\n   * @fires Toggler#off\n   */\n  toggle() {\n    this[ this.options.animate ? '_toggleAnimate' : '_toggleClass']();\n  }\n\n  _toggleClass() {\n    this.$element.toggleClass(this.className);\n\n    var isOn = this.$element.hasClass(this.className);\n    if (isOn) {\n      /**\n       * Fires if the target element has the class after a toggle.\n       * @event Toggler#on\n       */\n      this.$element.trigger('on.zf.toggler');\n    }\n    else {\n      /**\n       * Fires if the target element does not have the class after a toggle.\n       * @event Toggler#off\n       */\n      this.$element.trigger('off.zf.toggler');\n    }\n\n    this._updateARIA(isOn);\n    this.$element.find('[data-mutate]').trigger('mutateme.zf.trigger');\n  }\n\n  _toggleAnimate() {\n    var _this = this;\n\n    if (this.$element.is(':hidden')) {\n      Foundation.Motion.animateIn(this.$element, this.animationIn, function() {\n        _this._updateARIA(true);\n        this.trigger('on.zf.toggler');\n        this.find('[data-mutate]').trigger('mutateme.zf.trigger');\n      });\n    }\n    else {\n      Foundation.Motion.animateOut(this.$element, this.animationOut, function() {\n        _this._updateARIA(false);\n        this.trigger('off.zf.toggler');\n        this.find('[data-mutate]').trigger('mutateme.zf.trigger');\n      });\n    }\n  }\n\n  _updateARIA(isOn) {\n    this.$element.attr('aria-expanded', isOn ? true : false);\n  }\n\n  /**\n   * Destroys the instance of Toggler on the element.\n   * @function\n   */\n  destroy() {\n    this.$element.off('.zf.toggler');\n    Foundation.unregisterPlugin(this);\n  }\n}\n\nToggler.defaults = {\n  /**\n   * Tells the plugin if the element should animated when toggled.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  animate: false\n};\n\n// Window exports\nFoundation.plugin(Toggler, 'Toggler');\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * Tooltip module.\n * @module foundation.tooltip\n * @requires foundation.util.box\n * @requires foundation.util.mediaQuery\n * @requires foundation.util.triggers\n */\n\nclass Tooltip {\n  /**\n   * Creates a new instance of a Tooltip.\n   * @class\n   * @fires Tooltip#init\n   * @param {jQuery} element - jQuery object to attach a tooltip to.\n   * @param {Object} options - object to extend the default configuration.\n   */\n  constructor(element, options) {\n    this.$element = element;\n    this.options = $.extend({}, Tooltip.defaults, this.$element.data(), options);\n\n    this.isActive = false;\n    this.isClick = false;\n    this._init();\n\n    Foundation.registerPlugin(this, 'Tooltip');\n  }\n\n  /**\n   * Initializes the tooltip by setting the creating the tip element, adding it's text, setting private variables and setting attributes on the anchor.\n   * @private\n   */\n  _init() {\n    var elemId = this.$element.attr('aria-describedby') || Foundation.GetYoDigits(6, 'tooltip');\n\n    this.options.positionClass = this.options.positionClass || this._getPositionClass(this.$element);\n    this.options.tipText = this.options.tipText || this.$element.attr('title');\n    this.template = this.options.template ? $(this.options.template) : this._buildTemplate(elemId);\n\n    if (this.options.allowHtml) {\n      this.template.appendTo(document.body)\n        .html(this.options.tipText)\n        .hide();\n    } else {\n      this.template.appendTo(document.body)\n        .text(this.options.tipText)\n        .hide();\n    }\n\n    this.$element.attr({\n      'title': '',\n      'aria-describedby': elemId,\n      'data-yeti-box': elemId,\n      'data-toggle': elemId,\n      'data-resize': elemId\n    }).addClass(this.options.triggerClass);\n\n    //helper variables to track movement on collisions\n    this.usedPositions = [];\n    this.counter = 4;\n    this.classChanged = false;\n\n    this._events();\n  }\n\n  /**\n   * Grabs the current positioning class, if present, and returns the value or an empty string.\n   * @private\n   */\n  _getPositionClass(element) {\n    if (!element) { return ''; }\n    // var position = element.attr('class').match(/top|left|right/g);\n    var position = element[0].className.match(/\\b(top|left|right)\\b/g);\n        position = position ? position[0] : '';\n    return position;\n  };\n  /**\n   * builds the tooltip element, adds attributes, and returns the template.\n   * @private\n   */\n  _buildTemplate(id) {\n    var templateClasses = (`${this.options.tooltipClass} ${this.options.positionClass} ${this.options.templateClasses}`).trim();\n    var $template =  $('<div></div>').addClass(templateClasses).attr({\n      'role': 'tooltip',\n      'aria-hidden': true,\n      'data-is-active': false,\n      'data-is-focus': false,\n      'id': id\n    });\n    return $template;\n  }\n\n  /**\n   * Function that gets called if a collision event is detected.\n   * @param {String} position - positioning class to try\n   * @private\n   */\n  _reposition(position) {\n    this.usedPositions.push(position ? position : 'bottom');\n\n    //default, try switching to opposite side\n    if (!position && (this.usedPositions.indexOf('top') < 0)) {\n      this.template.addClass('top');\n    } else if (position === 'top' && (this.usedPositions.indexOf('bottom') < 0)) {\n      this.template.removeClass(position);\n    } else if (position === 'left' && (this.usedPositions.indexOf('right') < 0)) {\n      this.template.removeClass(position)\n          .addClass('right');\n    } else if (position === 'right' && (this.usedPositions.indexOf('left') < 0)) {\n      this.template.removeClass(position)\n          .addClass('left');\n    }\n\n    //if default change didn't work, try bottom or left first\n    else if (!position && (this.usedPositions.indexOf('top') > -1) && (this.usedPositions.indexOf('left') < 0)) {\n      this.template.addClass('left');\n    } else if (position === 'top' && (this.usedPositions.indexOf('bottom') > -1) && (this.usedPositions.indexOf('left') < 0)) {\n      this.template.removeClass(position)\n          .addClass('left');\n    } else if (position === 'left' && (this.usedPositions.indexOf('right') > -1) && (this.usedPositions.indexOf('bottom') < 0)) {\n      this.template.removeClass(position);\n    } else if (position === 'right' && (this.usedPositions.indexOf('left') > -1) && (this.usedPositions.indexOf('bottom') < 0)) {\n      this.template.removeClass(position);\n    }\n    //if nothing cleared, set to bottom\n    else {\n      this.template.removeClass(position);\n    }\n    this.classChanged = true;\n    this.counter--;\n  }\n\n  /**\n   * 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.\n   * if the tooltip is larger than the screen width, default to full width - any user selected margin\n   * @private\n   */\n  _setPosition() {\n    var position = this._getPositionClass(this.template),\n        $tipDims = Foundation.Box.GetDimensions(this.template),\n        $anchorDims = Foundation.Box.GetDimensions(this.$element),\n        direction = (position === 'left' ? 'left' : ((position === 'right') ? 'left' : 'top')),\n        param = (direction === 'top') ? 'height' : 'width',\n        offset = (param === 'height') ? this.options.vOffset : this.options.hOffset,\n        _this = this;\n\n    if (($tipDims.width >= $tipDims.windowDims.width) || (!this.counter && !Foundation.Box.ImNotTouchingYou(this.template))) {\n      this.template.offset(Foundation.Box.GetOffsets(this.template, this.$element, 'center bottom', this.options.vOffset, this.options.hOffset, true)).css({\n      // this.$element.offset(Foundation.GetOffsets(this.template, this.$element, 'center bottom', this.options.vOffset, this.options.hOffset, true)).css({\n        'width': $anchorDims.windowDims.width - (this.options.hOffset * 2),\n        'height': 'auto'\n      });\n      return false;\n    }\n\n    this.template.offset(Foundation.Box.GetOffsets(this.template, this.$element,'center ' + (position || 'bottom'), this.options.vOffset, this.options.hOffset));\n\n    while(!Foundation.Box.ImNotTouchingYou(this.template) && this.counter) {\n      this._reposition(position);\n      this._setPosition();\n    }\n  }\n\n  /**\n   * reveals the tooltip, and fires an event to close any other open tooltips on the page\n   * @fires Tooltip#closeme\n   * @fires Tooltip#show\n   * @function\n   */\n  show() {\n    if (this.options.showOn !== 'all' && !Foundation.MediaQuery.is(this.options.showOn)) {\n      // console.error('The screen is too small to display this tooltip');\n      return false;\n    }\n\n    var _this = this;\n    this.template.css('visibility', 'hidden').show();\n    this._setPosition();\n\n    /**\n     * Fires to close all other open tooltips on the page\n     * @event Closeme#tooltip\n     */\n    this.$element.trigger('closeme.zf.tooltip', this.template.attr('id'));\n\n\n    this.template.attr({\n      'data-is-active': true,\n      'aria-hidden': false\n    });\n    _this.isActive = true;\n    // console.log(this.template);\n    this.template.stop().hide().css('visibility', '').fadeIn(this.options.fadeInDuration, function() {\n      //maybe do stuff?\n    });\n    /**\n     * Fires when the tooltip is shown\n     * @event Tooltip#show\n     */\n    this.$element.trigger('show.zf.tooltip');\n  }\n\n  /**\n   * Hides the current tooltip, and resets the positioning class if it was changed due to collision\n   * @fires Tooltip#hide\n   * @function\n   */\n  hide() {\n    // console.log('hiding', this.$element.data('yeti-box'));\n    var _this = this;\n    this.template.stop().attr({\n      'aria-hidden': true,\n      'data-is-active': false\n    }).fadeOut(this.options.fadeOutDuration, function() {\n      _this.isActive = false;\n      _this.isClick = false;\n      if (_this.classChanged) {\n        _this.template\n             .removeClass(_this._getPositionClass(_this.template))\n             .addClass(_this.options.positionClass);\n\n       _this.usedPositions = [];\n       _this.counter = 4;\n       _this.classChanged = false;\n      }\n    });\n    /**\n     * fires when the tooltip is hidden\n     * @event Tooltip#hide\n     */\n    this.$element.trigger('hide.zf.tooltip');\n  }\n\n  /**\n   * adds event listeners for the tooltip and its anchor\n   * TODO combine some of the listeners like focus and mouseenter, etc.\n   * @private\n   */\n  _events() {\n    var _this = this;\n    var $template = this.template;\n    var isFocus = false;\n\n    if (!this.options.disableHover) {\n\n      this.$element\n      .on('mouseenter.zf.tooltip', function(e) {\n        if (!_this.isActive) {\n          _this.timeout = setTimeout(function() {\n            _this.show();\n          }, _this.options.hoverDelay);\n        }\n      })\n      .on('mouseleave.zf.tooltip', function(e) {\n        clearTimeout(_this.timeout);\n        if (!isFocus || (_this.isClick && !_this.options.clickOpen)) {\n          _this.hide();\n        }\n      });\n    }\n\n    if (this.options.clickOpen) {\n      this.$element.on('mousedown.zf.tooltip', function(e) {\n        e.stopImmediatePropagation();\n        if (_this.isClick) {\n          //_this.hide();\n          // _this.isClick = false;\n        } else {\n          _this.isClick = true;\n          if ((_this.options.disableHover || !_this.$element.attr('tabindex')) && !_this.isActive) {\n            _this.show();\n          }\n        }\n      });\n    } else {\n      this.$element.on('mousedown.zf.tooltip', function(e) {\n        e.stopImmediatePropagation();\n        _this.isClick = true;\n      });\n    }\n\n    if (!this.options.disableForTouch) {\n      this.$element\n      .on('tap.zf.tooltip touchend.zf.tooltip', function(e) {\n        _this.isActive ? _this.hide() : _this.show();\n      });\n    }\n\n    this.$element.on({\n      // 'toggle.zf.trigger': this.toggle.bind(this),\n      // 'close.zf.trigger': this.hide.bind(this)\n      'close.zf.trigger': this.hide.bind(this)\n    });\n\n    this.$element\n      .on('focus.zf.tooltip', function(e) {\n        isFocus = true;\n        if (_this.isClick) {\n          // If we're not showing open on clicks, we need to pretend a click-launched focus isn't\n          // a real focus, otherwise on hover and come back we get bad behavior\n          if(!_this.options.clickOpen) { isFocus = false; }\n          return false;\n        } else {\n          _this.show();\n        }\n      })\n\n      .on('focusout.zf.tooltip', function(e) {\n        isFocus = false;\n        _this.isClick = false;\n        _this.hide();\n      })\n\n      .on('resizeme.zf.trigger', function() {\n        if (_this.isActive) {\n          _this._setPosition();\n        }\n      });\n  }\n\n  /**\n   * adds a toggle method, in addition to the static show() & hide() functions\n   * @function\n   */\n  toggle() {\n    if (this.isActive) {\n      this.hide();\n    } else {\n      this.show();\n    }\n  }\n\n  /**\n   * Destroys an instance of tooltip, removes template element from the view.\n   * @function\n   */\n  destroy() {\n    this.$element.attr('title', this.template.text())\n                 .off('.zf.trigger .zf.tooltip')\n                 .removeClass('has-tip top right left')\n                 .removeAttr('aria-describedby aria-haspopup data-disable-hover data-resize data-toggle data-tooltip data-yeti-box');\n\n    this.template.remove();\n\n    Foundation.unregisterPlugin(this);\n  }\n}\n\nTooltip.defaults = {\n  disableForTouch: false,\n  /**\n   * Time, in ms, before a tooltip should open on hover.\n   * @option\n   * @type {number}\n   * @default 200\n   */\n  hoverDelay: 200,\n  /**\n   * Time, in ms, a tooltip should take to fade into view.\n   * @option\n   * @type {number}\n   * @default 150\n   */\n  fadeInDuration: 150,\n  /**\n   * Time, in ms, a tooltip should take to fade out of view.\n   * @option\n   * @type {number}\n   * @default 150\n   */\n  fadeOutDuration: 150,\n  /**\n   * Disables hover events from opening the tooltip if set to true\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  disableHover: false,\n  /**\n   * Optional addtional classes to apply to the tooltip template on init.\n   * @option\n   * @type {string}\n   * @default ''\n   */\n  templateClasses: '',\n  /**\n   * Non-optional class added to tooltip templates. Foundation default is 'tooltip'.\n   * @option\n   * @type {string}\n   * @default 'tooltip'\n   */\n  tooltipClass: 'tooltip',\n  /**\n   * Class applied to the tooltip anchor element.\n   * @option\n   * @type {string}\n   * @default 'has-tip'\n   */\n  triggerClass: 'has-tip',\n  /**\n   * Minimum breakpoint size at which to open the tooltip.\n   * @option\n   * @type {string}\n   * @default 'small'\n   */\n  showOn: 'small',\n  /**\n   * Custom template to be used to generate markup for tooltip.\n   * @option\n   * @type {string}\n   * @default ''\n   */\n  template: '',\n  /**\n   * Text displayed in the tooltip template on open.\n   * @option\n   * @type {string}\n   * @default ''\n   */\n  tipText: '',\n  touchCloseText: 'Tap to close.',\n  /**\n   * Allows the tooltip to remain open if triggered with a click or touch event.\n   * @option\n   * @type {boolean}\n   * @default true\n   */\n  clickOpen: true,\n  /**\n   * Additional positioning classes, set by the JS\n   * @option\n   * @type {string}\n   * @default ''\n   */\n  positionClass: '',\n  /**\n   * Distance, in pixels, the template should push away from the anchor on the Y axis.\n   * @option\n   * @type {number}\n   * @default 10\n   */\n  vOffset: 10,\n  /**\n   * Distance, in pixels, the template should push away from the anchor on the X axis, if aligned to a side.\n   * @option\n   * @type {number}\n   * @default 12\n   */\n  hOffset: 12,\n    /**\n   * Allow HTML in tooltip. Warning: If you are loading user-generated content into tooltips,\n   * allowing HTML may open yourself up to XSS attacks.\n   * @option\n   * @type {boolean}\n   * @default false\n   */\n  allowHtml: false\n};\n\n/**\n * TODO utilize resize event trigger\n */\n\n// Window exports\nFoundation.plugin(Tooltip, 'Tooltip');\n\n}(jQuery);\n","'use strict';\n\n!function($) {\n\n/**\n * ResponsiveAccordionTabs module.\n * @module foundation.responsiveAccordionTabs\n * @requires foundation.util.keyboard\n * @requires foundation.util.timerAndImageLoader\n * @requires foundation.util.motion\n * @requires foundation.accordion\n * @requires foundation.tabs\n */\n\nclass ResponsiveAccordionTabs {\n  /**\n   * Creates a new instance of a responsive accordion tabs.\n   * @class\n   * @fires ResponsiveAccordionTabs#init\n   * @param {jQuery} element - jQuery object to make into a dropdown menu.\n   * @param {Object} options - Overrides to the default plugin settings.\n   */\n  constructor(element, options) {\n    this.$element = $(element);\n    this.options  = $.extend({}, this.$element.data(), options);\n    this.rules = this.$element.data('responsive-accordion-tabs');\n    this.currentMq = null;\n    this.currentPlugin = null;\n    if (!this.$element.attr('id')) {\n      this.$element.attr('id',Foundation.GetYoDigits(6, 'responsiveaccordiontabs'));\n    };\n\n    this._init();\n    this._events();\n\n    Foundation.registerPlugin(this, 'ResponsiveAccordionTabs');\n  }\n\n  /**\n   * Initializes the Menu by parsing the classes from the 'data-responsive-accordion-tabs' attribute on the element.\n   * @function\n   * @private\n   */\n  _init() {\n    // The first time an Interchange plugin is initialized, this.rules is converted from a string of \"classes\" to an object of rules\n    if (typeof this.rules === 'string') {\n      let rulesTree = {};\n\n      // Parse rules from \"classes\" pulled from data attribute\n      let rules = this.rules.split(' ');\n\n      // Iterate through every rule found\n      for (let i = 0; i < rules.length; i++) {\n        let rule = rules[i].split('-');\n        let ruleSize = rule.length > 1 ? rule[0] : 'small';\n        let rulePlugin = rule.length > 1 ? rule[1] : rule[0];\n\n        if (MenuPlugins[rulePlugin] !== null) {\n          rulesTree[ruleSize] = MenuPlugins[rulePlugin];\n        }\n      }\n\n      this.rules = rulesTree;\n    }\n\n    this._getAllOptions();\n\n    if (!$.isEmptyObject(this.rules)) {\n      this._checkMediaQueries();\n    }\n  }\n\n  _getAllOptions() {\n    //get all defaults and options\n    var _this = this;\n    _this.allOptions = {};\n    for (var key in MenuPlugins) {\n      if (MenuPlugins.hasOwnProperty(key)) {\n        var obj = MenuPlugins[key];\n        try {\n          var dummyPlugin = $('<ul></ul>');\n          var tmpPlugin = new obj.plugin(dummyPlugin,_this.options);\n          for (var keyKey in tmpPlugin.options) {\n            if (tmpPlugin.options.hasOwnProperty(keyKey) && keyKey !== 'zfPlugin') {\n              var objObj = tmpPlugin.options[keyKey];\n              _this.allOptions[keyKey] = objObj;\n            }\n          }\n          tmpPlugin.destroy();\n        }\n        catch(e) {\n        }\n      }\n    }\n  }\n\n  /**\n   * Initializes events for the Menu.\n   * @function\n   * @private\n   */\n  _events() {\n    var _this = this;\n\n    $(window).on('changed.zf.mediaquery', function() {\n      _this._checkMediaQueries();\n    });\n  }\n\n  /**\n   * 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.\n   * @function\n   * @private\n   */\n  _checkMediaQueries() {\n    var matchedMq, _this = this;\n    // Iterate through each rule and find the last matching rule\n    $.each(this.rules, function(key) {\n      if (Foundation.MediaQuery.atLeast(key)) {\n        matchedMq = key;\n      }\n    });\n\n    // No match? No dice\n    if (!matchedMq) return;\n\n    // Plugin already initialized? We good\n    if (this.currentPlugin instanceof this.rules[matchedMq].plugin) return;\n\n    // Remove existing plugin-specific CSS classes\n    $.each(MenuPlugins, function(key, value) {\n      _this.$element.removeClass(value.cssClass);\n    });\n\n    // Add the CSS class for the new plugin\n    this.$element.addClass(this.rules[matchedMq].cssClass);\n\n    // Create an instance of the new plugin\n    if (this.currentPlugin) {\n      //don't know why but on nested elements data zfPlugin get's lost\n      if (!this.currentPlugin.$element.data('zfPlugin') && this.storezfData) this.currentPlugin.$element.data('zfPlugin',this.storezfData);\n      this.currentPlugin.destroy();\n    }\n    this._handleMarkup(this.rules[matchedMq].cssClass);\n    this.currentPlugin = new this.rules[matchedMq].plugin(this.$element, {});\n    this.storezfData = this.currentPlugin.$element.data('zfPlugin');\n\n  }\n\n  _handleMarkup(toSet){\n    var _this = this, fromString = 'accordion';\n    var $panels = $('[data-tabs-content='+this.$element.attr('id')+']');\n    if ($panels.length) fromString = 'tabs';\n    if (fromString === toSet) {\n      return;\n    };\n\n    var tabsTitle = _this.allOptions.linkClass?_this.allOptions.linkClass:'tabs-title';\n    var tabsPanel = _this.allOptions.panelClass?_this.allOptions.panelClass:'tabs-panel';\n\n    this.$element.removeAttr('role');\n    var $liHeads = this.$element.children('.'+tabsTitle+',[data-accordion-item]').removeClass(tabsTitle).removeClass('accordion-item').removeAttr('data-accordion-item');\n    var $liHeadsA = $liHeads.children('a').removeClass('accordion-title');\n\n    if (fromString === 'tabs') {\n      $panels = $panels.children('.'+tabsPanel).removeClass(tabsPanel).removeAttr('role').removeAttr('aria-hidden').removeAttr('aria-labelledby');\n      $panels.children('a').removeAttr('role').removeAttr('aria-controls').removeAttr('aria-selected');\n    }else{\n      $panels = $liHeads.children('[data-tab-content]').removeClass('accordion-content');\n    };\n\n    $panels.css({display:'',visibility:''});\n    $liHeads.css({display:'',visibility:''});\n    if (toSet === 'accordion') {\n      $panels.each(function(key,value){\n        $(value).appendTo($liHeads.get(key)).addClass('accordion-content').attr('data-tab-content','').removeClass('is-active').css({height:''});\n        $('[data-tabs-content='+_this.$element.attr('id')+']').after('<div id=\"tabs-placeholder-'+_this.$element.attr('id')+'\"></div>').remove();\n        $liHeads.addClass('accordion-item').attr('data-accordion-item','');\n        $liHeadsA.addClass('accordion-title');\n      });\n    }else if (toSet === 'tabs'){\n      var $tabsContent = $('[data-tabs-content='+_this.$element.attr('id')+']');\n      var $placeholder = $('#tabs-placeholder-'+_this.$element.attr('id'));\n      if ($placeholder.length) {\n        $tabsContent = $('<div class=\"tabs-content\"></div>').insertAfter($placeholder).attr('data-tabs-content',_this.$element.attr('id'));\n        $placeholder.remove();\n      }else{\n        $tabsContent = $('<div class=\"tabs-content\"></div>').insertAfter(_this.$element).attr('data-tabs-content',_this.$element.attr('id'));\n      };\n      $panels.each(function(key,value){\n        var tempValue = $(value).appendTo($tabsContent).addClass(tabsPanel);\n        var hash = $liHeadsA.get(key).hash.slice(1);\n        var id = $(value).attr('id') || Foundation.GetYoDigits(6, 'accordion');\n        if (hash !== id) {\n          if (hash !== '') {\n            $(value).attr('id',hash);\n          }else{\n            hash = id;\n            $(value).attr('id',hash);\n            $($liHeadsA.get(key)).attr('href',$($liHeadsA.get(key)).attr('href').replace('#','')+'#'+hash);\n          };\n        };\n        var isActive = $($liHeads.get(key)).hasClass('is-active');\n        if (isActive) {\n          tempValue.addClass('is-active');\n        };\n      });\n      $liHeads.addClass(tabsTitle);\n    };\n  }\n\n  /**\n   * Destroys the instance of the current plugin on this element, as well as the window resize handler that switches the plugins out.\n   * @function\n   */\n  destroy() {\n    if (this.currentPlugin) this.currentPlugin.destroy();\n    $(window).off('.zf.ResponsiveAccordionTabs');\n    Foundation.unregisterPlugin(this);\n  }\n}\n\nResponsiveAccordionTabs.defaults = {};\n\n// The plugin matches the plugin classes with these plugin instances.\nvar MenuPlugins = {\n  tabs: {\n    cssClass: 'tabs',\n    plugin: Foundation._plugins.tabs || null\n  },\n  accordion: {\n    cssClass: 'accordion',\n    plugin: Foundation._plugins.accordion || null\n  }\n};\n\n// Window exports\nFoundation.plugin(ResponsiveAccordionTabs, 'ResponsiveAccordionTabs');\n\n}(jQuery);\n","(function ($) {\n\t//$('p').remove();\n\n  $(document).foundation();\n})(jQuery);\n"]}
|