+
>
+
+Ingredientes
+
+
+
+
+
+
+-
+ <% @recipe.ingredientLines.each do |line| %>
+
- + <%= line %> + + <% end %> +
Información Nutricional
+ +<% if @recipe.dietLabels == [] %> +Información nutricinal no suministrada.
+<% else %> + <% @recipe.dietLabels.each do |information| %> + <% if information == "balanced" %> +Balanceado
+ <% elsif information == "High-Protein"%> +Rico en Proteínas
+ <% elsif information == "High-Fiber"%> +Rico en Fibra
+ <% elsif information == "Low-Fat"%> +Bajo en grasas
+ <% elsif information == "Low-Carb"%> +Bajo en Carbohidratos
+ <% elsif information == "low-sodium"%> +Bajo en Sodio
+ <% end %> + <% end %> +<%end%> + +<%= link_to "Detalles de esta receta", @recipe.url, :target => "_blank" %>
+ +
+
+
+
diff --git a/public/422.html b/public/422.html
new file mode 100644
index 000000000..c08eac0d1
--- /dev/null
+++ b/public/422.html
@@ -0,0 +1,67 @@
+
+
+
+
+
+ The page you were looking for doesn't exist.
+You may have mistyped the address or the page may have moved.
+If you are the application owner check the logs for more information.
+
+
+
+
diff --git a/public/500.html b/public/500.html
new file mode 100644
index 000000000..78a030af2
--- /dev/null
+++ b/public/500.html
@@ -0,0 +1,66 @@
+
+
+
+
+
+ The change you wanted was rejected.
+Maybe you tried to change something you didn't have access to.
+If you are the application owner check the logs for more information.
+
+
+
+
diff --git a/public/apple-touch-icon-precomposed.png b/public/apple-touch-icon-precomposed.png
new file mode 100644
index 000000000..e69de29bb
diff --git a/public/apple-touch-icon.png b/public/apple-touch-icon.png
new file mode 100644
index 000000000..e69de29bb
diff --git a/public/assets/.sprockets-manifest-2df1fafdfccd91ce5d844b961f77dbf5.json b/public/assets/.sprockets-manifest-2df1fafdfccd91ce5d844b961f77dbf5.json
new file mode 100644
index 000000000..c48e25ac6
--- /dev/null
+++ b/public/assets/.sprockets-manifest-2df1fafdfccd91ce5d844b961f77dbf5.json
@@ -0,0 +1 @@
+{"files":{"application-be61024f54d75b70defb8f724de3d42b298d56ebae5e0521ff08fb13a7ff5772.js":{"logical_path":"application.js","mtime":"2017-11-01T11:10:52-07:00","size":732565,"digest":"be61024f54d75b70defb8f724de3d42b298d56ebae5e0521ff08fb13a7ff5772","integrity":"sha256-vmECT1TXW3De+49yTePUKymNVuuuXgUh/wj7E6f/V3I="},"application-ff26adcbb81289e4a75cea14726e5ca894eff2a9d2c2b60fd0dabbc4bdc4db80.css":{"logical_path":"application.css","mtime":"2017-11-01T14:02:41-07:00","size":239221,"digest":"ff26adcbb81289e4a75cea14726e5ca894eff2a9d2c2b60fd0dabbc4bdc4db80","integrity":"sha256-/yaty7gSieSnXOoUcm5cqJTv8qnSwrYP0Nq7xL3E24A="}},"assets":{"application.js":"application-be61024f54d75b70defb8f724de3d42b298d56ebae5e0521ff08fb13a7ff5772.js","application.css":"application-ff26adcbb81289e4a75cea14726e5ca894eff2a9d2c2b60fd0dabbc4bdc4db80.css"}}
\ No newline at end of file
diff --git a/public/assets/application-be61024f54d75b70defb8f724de3d42b298d56ebae5e0521ff08fb13a7ff5772.js b/public/assets/application-be61024f54d75b70defb8f724de3d42b298d56ebae5e0521ff08fb13a7ff5772.js
new file mode 100644
index 000000000..1a3c69406
--- /dev/null
+++ b/public/assets/application-be61024f54d75b70defb8f724de3d42b298d56ebae5e0521ff08fb13a7ff5772.js
@@ -0,0 +1,19836 @@
+/*
+Unobtrusive JavaScript
+https://github.com/rails/rails/blob/master/actionview/app/assets/javascripts
+Released under the MIT license
+ */
+
+
+(function() {
+ var context = this;
+
+ (function() {
+ (function() {
+ this.Rails = {
+ linkClickSelector: 'a[data-confirm], a[data-method], a[data-remote]:not([disabled]), a[data-disable-with], a[data-disable]',
+ buttonClickSelector: {
+ selector: 'button[data-remote]:not([form]), button[data-confirm]:not([form])',
+ exclude: 'form button'
+ },
+ inputChangeSelector: 'select[data-remote], input[data-remote], textarea[data-remote]',
+ formSubmitSelector: 'form',
+ formInputClickSelector: 'form input[type=submit], form input[type=image], form button[type=submit], form button:not([type]), input[type=submit][form], input[type=image][form], button[type=submit][form], button[form]:not([type])',
+ formDisableSelector: 'input[data-disable-with]:enabled, button[data-disable-with]:enabled, textarea[data-disable-with]:enabled, input[data-disable]:enabled, button[data-disable]:enabled, textarea[data-disable]:enabled',
+ formEnableSelector: 'input[data-disable-with]:disabled, button[data-disable-with]:disabled, textarea[data-disable-with]:disabled, input[data-disable]:disabled, button[data-disable]:disabled, textarea[data-disable]:disabled',
+ fileInputSelector: 'input[name][type=file]:not([disabled])',
+ linkDisableSelector: 'a[data-disable-with], a[data-disable]',
+ buttonDisableSelector: 'button[data-remote][data-disable-with], button[data-remote][data-disable]'
+ };
+
+ }).call(this);
+ }).call(context);
+
+ var Rails = context.Rails;
+
+ (function() {
+ (function() {
+ var expando, m;
+
+ m = Element.prototype.matches || Element.prototype.matchesSelector || Element.prototype.mozMatchesSelector || Element.prototype.msMatchesSelector || Element.prototype.oMatchesSelector || Element.prototype.webkitMatchesSelector;
+
+ Rails.matches = function(element, selector) {
+ if (selector.exclude != null) {
+ return m.call(element, selector.selector) && !m.call(element, selector.exclude);
+ } else {
+ return m.call(element, selector);
+ }
+ };
+
+ expando = '_ujsData';
+
+ Rails.getData = function(element, key) {
+ var ref;
+ return (ref = element[expando]) != null ? ref[key] : void 0;
+ };
+
+ Rails.setData = function(element, key, value) {
+ if (element[expando] == null) {
+ element[expando] = {};
+ }
+ return element[expando][key] = value;
+ };
+
+ Rails.$ = function(selector) {
+ return Array.prototype.slice.call(document.querySelectorAll(selector));
+ };
+
+ }).call(this);
+ (function() {
+ var $, csrfParam, csrfToken;
+
+ $ = Rails.$;
+
+ csrfToken = Rails.csrfToken = function() {
+ var meta;
+ meta = document.querySelector('meta[name=csrf-token]');
+ return meta && meta.content;
+ };
+
+ csrfParam = Rails.csrfParam = function() {
+ var meta;
+ meta = document.querySelector('meta[name=csrf-param]');
+ return meta && meta.content;
+ };
+
+ Rails.CSRFProtection = function(xhr) {
+ var token;
+ token = csrfToken();
+ if (token != null) {
+ return xhr.setRequestHeader('X-CSRF-Token', token);
+ }
+ };
+
+ Rails.refreshCSRFTokens = function() {
+ var param, token;
+ token = csrfToken();
+ param = csrfParam();
+ if ((token != null) && (param != null)) {
+ return $('form input[name="' + param + '"]').forEach(function(input) {
+ return input.value = token;
+ });
+ }
+ };
+
+ }).call(this);
+ (function() {
+ var CustomEvent, fire, matches;
+
+ matches = Rails.matches;
+
+ CustomEvent = window.CustomEvent;
+
+ if (typeof CustomEvent !== 'function') {
+ CustomEvent = function(event, params) {
+ var evt;
+ evt = document.createEvent('CustomEvent');
+ evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
+ return evt;
+ };
+ CustomEvent.prototype = window.Event.prototype;
+ }
+
+ fire = Rails.fire = function(obj, name, data) {
+ var event;
+ event = new CustomEvent(name, {
+ bubbles: true,
+ cancelable: true,
+ detail: data
+ });
+ obj.dispatchEvent(event);
+ return !event.defaultPrevented;
+ };
+
+ Rails.stopEverything = function(e) {
+ fire(e.target, 'ujs:everythingStopped');
+ e.preventDefault();
+ e.stopPropagation();
+ return e.stopImmediatePropagation();
+ };
+
+ Rails.delegate = function(element, selector, eventType, handler) {
+ return element.addEventListener(eventType, function(e) {
+ var target;
+ target = e.target;
+ while (!(!(target instanceof Element) || matches(target, selector))) {
+ target = target.parentNode;
+ }
+ if (target instanceof Element && handler.call(target, e) === false) {
+ e.preventDefault();
+ return e.stopPropagation();
+ }
+ });
+ };
+
+ }).call(this);
+ (function() {
+ var AcceptHeaders, CSRFProtection, createXHR, fire, prepareOptions, processResponse;
+
+ CSRFProtection = Rails.CSRFProtection, fire = Rails.fire;
+
+ AcceptHeaders = {
+ '*': '*/*',
+ text: 'text/plain',
+ html: 'text/html',
+ xml: 'application/xml, text/xml',
+ json: 'application/json, text/javascript',
+ script: 'text/javascript, application/javascript, application/ecmascript, application/x-ecmascript'
+ };
+
+ Rails.ajax = function(options) {
+ var xhr;
+ options = prepareOptions(options);
+ xhr = createXHR(options, function() {
+ var response;
+ response = processResponse(xhr.response, xhr.getResponseHeader('Content-Type'));
+ if (Math.floor(xhr.status / 100) === 2) {
+ if (typeof options.success === "function") {
+ options.success(response, xhr.statusText, xhr);
+ }
+ } else {
+ if (typeof options.error === "function") {
+ options.error(response, xhr.statusText, xhr);
+ }
+ }
+ return typeof options.complete === "function" ? options.complete(xhr, xhr.statusText) : void 0;
+ });
+ if (typeof options.beforeSend === "function") {
+ options.beforeSend(xhr, options);
+ }
+ if (xhr.readyState === XMLHttpRequest.OPENED) {
+ return xhr.send(options.data);
+ } else {
+ return fire(document, 'ajaxStop');
+ }
+ };
+
+ prepareOptions = function(options) {
+ options.url = options.url || location.href;
+ options.type = options.type.toUpperCase();
+ if (options.type === 'GET' && options.data) {
+ if (options.url.indexOf('?') < 0) {
+ options.url += '?' + options.data;
+ } else {
+ options.url += '&' + options.data;
+ }
+ }
+ if (AcceptHeaders[options.dataType] == null) {
+ options.dataType = '*';
+ }
+ options.accept = AcceptHeaders[options.dataType];
+ if (options.dataType !== '*') {
+ options.accept += ', */*; q=0.01';
+ }
+ return options;
+ };
+
+ createXHR = function(options, done) {
+ var xhr;
+ xhr = new XMLHttpRequest();
+ xhr.open(options.type, options.url, true);
+ xhr.setRequestHeader('Accept', options.accept);
+ if (typeof options.data === 'string') {
+ xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8');
+ }
+ if (!options.crossDomain) {
+ xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
+ }
+ CSRFProtection(xhr);
+ xhr.withCredentials = !!options.withCredentials;
+ xhr.onreadystatechange = function() {
+ if (xhr.readyState === XMLHttpRequest.DONE) {
+ return done(xhr);
+ }
+ };
+ return xhr;
+ };
+
+ processResponse = function(response, type) {
+ var parser, script;
+ if (typeof response === 'string' && typeof type === 'string') {
+ if (type.match(/\bjson\b/)) {
+ try {
+ response = JSON.parse(response);
+ } catch (error) {}
+ } else if (type.match(/\b(?:java|ecma)script\b/)) {
+ script = document.createElement('script');
+ script.text = response;
+ document.head.appendChild(script).parentNode.removeChild(script);
+ } else if (type.match(/\b(xml|html|svg)\b/)) {
+ parser = new DOMParser();
+ type = type.replace(/;.+/, '');
+ try {
+ response = parser.parseFromString(response, type);
+ } catch (error) {}
+ }
+ }
+ return response;
+ };
+
+ Rails.href = function(element) {
+ return element.href;
+ };
+
+ Rails.isCrossDomain = function(url) {
+ var e, originAnchor, urlAnchor;
+ originAnchor = document.createElement('a');
+ originAnchor.href = location.href;
+ urlAnchor = document.createElement('a');
+ try {
+ urlAnchor.href = url;
+ return !(((!urlAnchor.protocol || urlAnchor.protocol === ':') && !urlAnchor.host) || (originAnchor.protocol + '//' + originAnchor.host === urlAnchor.protocol + '//' + urlAnchor.host));
+ } catch (error) {
+ e = error;
+ return true;
+ }
+ };
+
+ }).call(this);
+ (function() {
+ var matches, toArray;
+
+ matches = Rails.matches;
+
+ toArray = function(e) {
+ return Array.prototype.slice.call(e);
+ };
+
+ Rails.serializeElement = function(element, additionalParam) {
+ var inputs, params;
+ inputs = [element];
+ if (matches(element, 'form')) {
+ inputs = toArray(element.elements);
+ }
+ params = [];
+ inputs.forEach(function(input) {
+ if (!input.name) {
+ return;
+ }
+ if (matches(input, 'select')) {
+ return toArray(input.options).forEach(function(option) {
+ if (option.selected) {
+ return params.push({
+ name: input.name,
+ value: option.value
+ });
+ }
+ });
+ } else if (input.checked || ['radio', 'checkbox', 'submit'].indexOf(input.type) === -1) {
+ return params.push({
+ name: input.name,
+ value: input.value
+ });
+ }
+ });
+ if (additionalParam) {
+ params.push(additionalParam);
+ }
+ return params.map(function(param) {
+ if (param.name != null) {
+ return (encodeURIComponent(param.name)) + "=" + (encodeURIComponent(param.value));
+ } else {
+ return param;
+ }
+ }).join('&');
+ };
+
+ Rails.formElements = function(form, selector) {
+ if (matches(form, 'form')) {
+ return toArray(form.elements).filter(function(el) {
+ return matches(el, selector);
+ });
+ } else {
+ return toArray(form.querySelectorAll(selector));
+ }
+ };
+
+ }).call(this);
+ (function() {
+ var allowAction, fire, stopEverything;
+
+ fire = Rails.fire, stopEverything = Rails.stopEverything;
+
+ Rails.handleConfirm = function(e) {
+ if (!allowAction(this)) {
+ return stopEverything(e);
+ }
+ };
+
+ allowAction = function(element) {
+ var answer, callback, message;
+ message = element.getAttribute('data-confirm');
+ if (!message) {
+ return true;
+ }
+ answer = false;
+ if (fire(element, 'confirm')) {
+ try {
+ answer = confirm(message);
+ } catch (error) {}
+ callback = fire(element, 'confirm:complete', [answer]);
+ }
+ return answer && callback;
+ };
+
+ }).call(this);
+ (function() {
+ var disableFormElement, disableFormElements, disableLinkElement, enableFormElement, enableFormElements, enableLinkElement, formElements, getData, matches, setData, stopEverything;
+
+ matches = Rails.matches, getData = Rails.getData, setData = Rails.setData, stopEverything = Rails.stopEverything, formElements = Rails.formElements;
+
+ Rails.handleDisabledElement = function(e) {
+ var element;
+ element = this;
+ if (element.disabled) {
+ return stopEverything(e);
+ }
+ };
+
+ Rails.enableElement = function(e) {
+ var element;
+ element = e instanceof Event ? e.target : e;
+ if (matches(element, Rails.linkDisableSelector)) {
+ return enableLinkElement(element);
+ } else if (matches(element, Rails.buttonDisableSelector) || matches(element, Rails.formEnableSelector)) {
+ return enableFormElement(element);
+ } else if (matches(element, Rails.formSubmitSelector)) {
+ return enableFormElements(element);
+ }
+ };
+
+ Rails.disableElement = function(e) {
+ var element;
+ element = e instanceof Event ? e.target : e;
+ if (matches(element, Rails.linkDisableSelector)) {
+ return disableLinkElement(element);
+ } else if (matches(element, Rails.buttonDisableSelector) || matches(element, Rails.formDisableSelector)) {
+ return disableFormElement(element);
+ } else if (matches(element, Rails.formSubmitSelector)) {
+ return disableFormElements(element);
+ }
+ };
+
+ disableLinkElement = function(element) {
+ var replacement;
+ replacement = element.getAttribute('data-disable-with');
+ if (replacement != null) {
+ setData(element, 'ujs:enable-with', element.innerHTML);
+ element.innerHTML = replacement;
+ }
+ element.addEventListener('click', stopEverything);
+ return setData(element, 'ujs:disabled', true);
+ };
+
+ enableLinkElement = function(element) {
+ var originalText;
+ originalText = getData(element, 'ujs:enable-with');
+ if (originalText != null) {
+ element.innerHTML = originalText;
+ setData(element, 'ujs:enable-with', null);
+ }
+ element.removeEventListener('click', stopEverything);
+ return setData(element, 'ujs:disabled', null);
+ };
+
+ disableFormElements = function(form) {
+ return formElements(form, Rails.formDisableSelector).forEach(disableFormElement);
+ };
+
+ disableFormElement = function(element) {
+ var replacement;
+ replacement = element.getAttribute('data-disable-with');
+ if (replacement != null) {
+ if (matches(element, 'button')) {
+ setData(element, 'ujs:enable-with', element.innerHTML);
+ element.innerHTML = replacement;
+ } else {
+ setData(element, 'ujs:enable-with', element.value);
+ element.value = replacement;
+ }
+ }
+ element.disabled = true;
+ return setData(element, 'ujs:disabled', true);
+ };
+
+ enableFormElements = function(form) {
+ return formElements(form, Rails.formEnableSelector).forEach(enableFormElement);
+ };
+
+ enableFormElement = function(element) {
+ var originalText;
+ originalText = getData(element, 'ujs:enable-with');
+ if (originalText != null) {
+ if (matches(element, 'button')) {
+ element.innerHTML = originalText;
+ } else {
+ element.value = originalText;
+ }
+ setData(element, 'ujs:enable-with', null);
+ }
+ element.disabled = false;
+ return setData(element, 'ujs:disabled', null);
+ };
+
+ }).call(this);
+ (function() {
+ var stopEverything;
+
+ stopEverything = Rails.stopEverything;
+
+ Rails.handleMethod = function(e) {
+ var csrfParam, csrfToken, form, formContent, href, link, method;
+ link = this;
+ method = link.getAttribute('data-method');
+ if (!method) {
+ return;
+ }
+ href = Rails.href(link);
+ csrfToken = Rails.csrfToken();
+ csrfParam = Rails.csrfParam();
+ form = document.createElement('form');
+ formContent = "";
+ if ((csrfParam != null) && (csrfToken != null) && !Rails.isCrossDomain(href)) {
+ formContent += "";
+ }
+ formContent += '';
+ form.method = 'post';
+ form.action = href;
+ form.target = link.target;
+ form.innerHTML = formContent;
+ form.style.display = 'none';
+ document.body.appendChild(form);
+ form.querySelector('[type="submit"]').click();
+ return stopEverything(e);
+ };
+
+ }).call(this);
+ (function() {
+ var ajax, fire, getData, isCrossDomain, isRemote, matches, serializeElement, setData, stopEverything,
+ slice = [].slice;
+
+ matches = Rails.matches, getData = Rails.getData, setData = Rails.setData, fire = Rails.fire, stopEverything = Rails.stopEverything, ajax = Rails.ajax, isCrossDomain = Rails.isCrossDomain, serializeElement = Rails.serializeElement;
+
+ isRemote = function(element) {
+ var value;
+ value = element.getAttribute('data-remote');
+ return (value != null) && value !== 'false';
+ };
+
+ Rails.handleRemote = function(e) {
+ var button, data, dataType, element, method, url, withCredentials;
+ element = this;
+ if (!isRemote(element)) {
+ return true;
+ }
+ if (!fire(element, 'ajax:before')) {
+ fire(element, 'ajax:stopped');
+ return false;
+ }
+ withCredentials = element.getAttribute('data-with-credentials');
+ dataType = element.getAttribute('data-type') || 'script';
+ if (matches(element, Rails.formSubmitSelector)) {
+ button = getData(element, 'ujs:submit-button');
+ method = getData(element, 'ujs:submit-button-formmethod') || element.method;
+ url = getData(element, 'ujs:submit-button-formaction') || element.getAttribute('action') || location.href;
+ if (method.toUpperCase() === 'GET') {
+ url = url.replace(/\?.*$/, '');
+ }
+ if (element.enctype === 'multipart/form-data') {
+ data = new FormData(element);
+ if (button != null) {
+ data.append(button.name, button.value);
+ }
+ } else {
+ data = serializeElement(element, button);
+ }
+ setData(element, 'ujs:submit-button', null);
+ setData(element, 'ujs:submit-button-formmethod', null);
+ setData(element, 'ujs:submit-button-formaction', null);
+ } else if (matches(element, Rails.buttonClickSelector) || matches(element, Rails.inputChangeSelector)) {
+ method = element.getAttribute('data-method');
+ url = element.getAttribute('data-url');
+ data = serializeElement(element, element.getAttribute('data-params'));
+ } else {
+ method = element.getAttribute('data-method');
+ url = Rails.href(element);
+ data = element.getAttribute('data-params');
+ }
+ ajax({
+ type: method || 'GET',
+ url: url,
+ data: data,
+ dataType: dataType,
+ beforeSend: function(xhr, options) {
+ if (fire(element, 'ajax:beforeSend', [xhr, options])) {
+ return fire(element, 'ajax:send', [xhr]);
+ } else {
+ fire(element, 'ajax:stopped');
+ return xhr.abort();
+ }
+ },
+ success: function() {
+ var args;
+ args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+ return fire(element, 'ajax:success', args);
+ },
+ error: function() {
+ var args;
+ args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+ return fire(element, 'ajax:error', args);
+ },
+ complete: function() {
+ var args;
+ args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+ return fire(element, 'ajax:complete', args);
+ },
+ crossDomain: isCrossDomain(url),
+ withCredentials: (withCredentials != null) && withCredentials !== 'false'
+ });
+ return stopEverything(e);
+ };
+
+ Rails.formSubmitButtonClick = function(e) {
+ var button, form;
+ button = this;
+ form = button.form;
+ if (!form) {
+ return;
+ }
+ if (button.name) {
+ setData(form, 'ujs:submit-button', {
+ name: button.name,
+ value: button.value
+ });
+ }
+ setData(form, 'ujs:formnovalidate-button', button.formNoValidate);
+ setData(form, 'ujs:submit-button-formaction', button.getAttribute('formaction'));
+ return setData(form, 'ujs:submit-button-formmethod', button.getAttribute('formmethod'));
+ };
+
+ Rails.handleMetaClick = function(e) {
+ var data, link, metaClick, method;
+ link = this;
+ method = (link.getAttribute('data-method') || 'GET').toUpperCase();
+ data = link.getAttribute('data-params');
+ metaClick = e.metaKey || e.ctrlKey;
+ if (metaClick && method === 'GET' && !data) {
+ return e.stopImmediatePropagation();
+ }
+ };
+
+ }).call(this);
+ (function() {
+ var $, CSRFProtection, delegate, disableElement, enableElement, fire, formSubmitButtonClick, getData, handleConfirm, handleDisabledElement, handleMetaClick, handleMethod, handleRemote, refreshCSRFTokens;
+
+ fire = Rails.fire, delegate = Rails.delegate, getData = Rails.getData, $ = Rails.$, refreshCSRFTokens = Rails.refreshCSRFTokens, CSRFProtection = Rails.CSRFProtection, enableElement = Rails.enableElement, disableElement = Rails.disableElement, handleDisabledElement = Rails.handleDisabledElement, handleConfirm = Rails.handleConfirm, handleRemote = Rails.handleRemote, formSubmitButtonClick = Rails.formSubmitButtonClick, handleMetaClick = Rails.handleMetaClick, handleMethod = Rails.handleMethod;
+
+ if ((typeof jQuery !== "undefined" && jQuery !== null) && (jQuery.ajax != null) && !jQuery.rails) {
+ jQuery.rails = Rails;
+ jQuery.ajaxPrefilter(function(options, originalOptions, xhr) {
+ if (!options.crossDomain) {
+ return CSRFProtection(xhr);
+ }
+ });
+ }
+
+ Rails.start = function() {
+ if (window._rails_loaded) {
+ throw new Error('rails-ujs has already been loaded!');
+ }
+ window.addEventListener('pageshow', function() {
+ $(Rails.formEnableSelector).forEach(function(el) {
+ if (getData(el, 'ujs:disabled')) {
+ return enableElement(el);
+ }
+ });
+ return $(Rails.linkDisableSelector).forEach(function(el) {
+ if (getData(el, 'ujs:disabled')) {
+ return enableElement(el);
+ }
+ });
+ });
+ delegate(document, Rails.linkDisableSelector, 'ajax:complete', enableElement);
+ delegate(document, Rails.linkDisableSelector, 'ajax:stopped', enableElement);
+ delegate(document, Rails.buttonDisableSelector, 'ajax:complete', enableElement);
+ delegate(document, Rails.buttonDisableSelector, 'ajax:stopped', enableElement);
+ delegate(document, Rails.linkClickSelector, 'click', handleDisabledElement);
+ delegate(document, Rails.linkClickSelector, 'click', handleConfirm);
+ delegate(document, Rails.linkClickSelector, 'click', handleMetaClick);
+ delegate(document, Rails.linkClickSelector, 'click', disableElement);
+ delegate(document, Rails.linkClickSelector, 'click', handleRemote);
+ delegate(document, Rails.linkClickSelector, 'click', handleMethod);
+ delegate(document, Rails.buttonClickSelector, 'click', handleDisabledElement);
+ delegate(document, Rails.buttonClickSelector, 'click', handleConfirm);
+ delegate(document, Rails.buttonClickSelector, 'click', disableElement);
+ delegate(document, Rails.buttonClickSelector, 'click', handleRemote);
+ delegate(document, Rails.inputChangeSelector, 'change', handleDisabledElement);
+ delegate(document, Rails.inputChangeSelector, 'change', handleConfirm);
+ delegate(document, Rails.inputChangeSelector, 'change', handleRemote);
+ delegate(document, Rails.formSubmitSelector, 'submit', handleDisabledElement);
+ delegate(document, Rails.formSubmitSelector, 'submit', handleConfirm);
+ delegate(document, Rails.formSubmitSelector, 'submit', handleRemote);
+ delegate(document, Rails.formSubmitSelector, 'submit', function(e) {
+ return setTimeout((function() {
+ return disableElement(e);
+ }), 13);
+ });
+ delegate(document, Rails.formSubmitSelector, 'ajax:send', disableElement);
+ delegate(document, Rails.formSubmitSelector, 'ajax:complete', enableElement);
+ delegate(document, Rails.formInputClickSelector, 'click', handleDisabledElement);
+ delegate(document, Rails.formInputClickSelector, 'click', handleConfirm);
+ delegate(document, Rails.formInputClickSelector, 'click', formSubmitButtonClick);
+ document.addEventListener('DOMContentLoaded', refreshCSRFTokens);
+ return window._rails_loaded = true;
+ };
+
+ if (window.Rails === Rails && fire(document, 'rails:attachBindings')) {
+ Rails.start();
+ }
+
+ }).call(this);
+ }).call(this);
+
+ if (typeof module === "object" && module.exports) {
+ module.exports = Rails;
+ } else if (typeof define === "function" && define.amd) {
+ define(Rails);
+ }
+}).call(this);
+/******/
+ (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] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = 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;
+/******/
+/******/ // identity function for calling harmony imports with the correct context
+/******/ __webpack_require__.i = function(value) { return value; };
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, {
+/******/ configurable: false,
+/******/ enumerable: true,
+/******/ get: getter
+/******/ });
+/******/ }
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 6);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports) {
+
+module.exports = jQuery;
+
+/***/ }),
+/* 1 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return rtl; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return GetYoDigits; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return transitionend; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery__ = __webpack_require__(0);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery__);
+
+
+
+
+// Core Foundation Utilities, utilized in a number of places.
+
+/**
+ * Returns a boolean for RTL support
+ */
+function rtl() {
+ return __WEBPACK_IMPORTED_MODULE_0_jquery___default()('html').attr('dir') === 'rtl';
+}
+
+/**
+ * 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
+ */
+function GetYoDigits(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 : '');
+}
+
+function transitionend($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';
+ }
+}
+
+
+
+/***/ }),
+/* 2 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery__ = __webpack_require__(0);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_core__ = __webpack_require__(3);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__foundation_util_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__foundation_plugin__ = __webpack_require__(4);
+
+
+
+__WEBPACK_IMPORTED_MODULE_1__foundation_core__["a" /* Foundation */].addToJquery(__WEBPACK_IMPORTED_MODULE_0_jquery___default.a);
+
+// These are now separated out, but historically were a part of this module,
+// and since this is here for backwards compatibility we include them in
+// this entry.
+
+__WEBPACK_IMPORTED_MODULE_1__foundation_core__["a" /* Foundation */].rtl = __WEBPACK_IMPORTED_MODULE_2__foundation_util_core__["a" /* rtl */];
+__WEBPACK_IMPORTED_MODULE_1__foundation_core__["a" /* Foundation */].GetYoDigits = __WEBPACK_IMPORTED_MODULE_2__foundation_util_core__["b" /* GetYoDigits */];
+__WEBPACK_IMPORTED_MODULE_1__foundation_core__["a" /* Foundation */].transitionend = __WEBPACK_IMPORTED_MODULE_2__foundation_util_core__["c" /* transitionend */];
+
+// Every plugin depends on plugin now, we can include that on the core for the
+// script inclusion path.
+
+
+__WEBPACK_IMPORTED_MODULE_1__foundation_core__["a" /* Foundation */].Plugin = __WEBPACK_IMPORTED_MODULE_3__foundation_plugin__["a" /* Plugin */];
+
+window.Foundation = __WEBPACK_IMPORTED_MODULE_1__foundation_core__["a" /* Foundation */];
+
+/***/ }),
+/* 3 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Foundation; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery__ = __webpack_require__(0);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__foundation_util_mediaQuery__ = __webpack_require__(5);
+
+
+
+
+
+
+var FOUNDATION_VERSION = '6.4.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: [],
+
+ /**
+ * 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 = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__foundation_util_core__["b" /* 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 __WEBPACK_IMPORTED_MODULE_0_jquery___default.a;
+ try {
+ if (isJQ) {
+ plugins.each(function () {
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).data('zfPlugin')._init();
+ });
+ } else {
+ var type = typeof plugins,
+ _this = this,
+ fns = {
+ 'object': function (plgs) {
+ plgs.forEach(function (p) {
+ p = hyphenate(p);
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()('[data-' + p + ']').foundation('_init');
+ });
+ },
+ 'string': function () {
+ plugins = hyphenate(plugins);
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()('[data-' + plugins + ']').foundation('_init');
+ },
+ 'undefined': function () {
+ this['object'](Object.keys(_this._plugins));
+ }
+ };
+ fns[type](plugins);
+ }
+ } catch (err) {
+ console.error(err);
+ } finally {
+ return plugins;
+ }
+ },
+
+ /**
+ * 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
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default.a.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 = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(elem).find('[data-' + name + ']').addBack('[data-' + name + ']');
+
+ // For each plugin found, initialize it
+ $elem.each(function () {
+ var $el = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(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(__WEBPACK_IMPORTED_MODULE_0_jquery___default()(this), opts));
+ } catch (er) {
+ console.error(er);
+ } finally {
+ return;
+ }
+ });
+ });
+ },
+ getFnName: functionName,
+
+ addToJquery: function ($) {
+ // 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,
+ $noJS = $('.no-js');
+
+ if ($noJS.length) {
+ $noJS.removeClass('no-js');
+ }
+
+ if (type === 'undefined') {
+ //needs to initialize the Foundation object, or an individual plugin.
+ __WEBPACK_IMPORTED_MODULE_2__foundation_util_mediaQuery__["a" /* 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;
+ };
+ $.fn.foundation = foundation;
+ return $;
+ }
+};
+
+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);
+ }
+ };
+ }
+};
+
+window.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();
+}
+
+
+
+/***/ }),
+/* 4 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Plugin; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery__ = __webpack_require__(0);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_core__ = __webpack_require__(1);
+
+
+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"); } }
+
+
+
+
+// Abstract class for providing lifecycle hooks. Expect plugins to define AT LEAST
+// {function} _setup (replaces previous constructor),
+// {function} _destroy (replaces previous destroy)
+
+var Plugin = function () {
+ function Plugin(element, options) {
+ _classCallCheck(this, Plugin);
+
+ this._setup(element, options);
+ var pluginName = getPluginName(this);
+ this.uuid = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__foundation_util_core__["b" /* GetYoDigits */])(6, pluginName);
+
+ if (!this.$element.attr('data-' + pluginName)) {
+ this.$element.attr('data-' + pluginName, this.uuid);
+ }
+ if (!this.$element.data('zfPlugin')) {
+ this.$element.data('zfPlugin', this);
+ }
+ /**
+ * Fires when the plugin has initialized.
+ * @event Plugin#init
+ */
+ this.$element.trigger('init.zf.' + pluginName);
+ }
+
+ _createClass(Plugin, [{
+ key: 'destroy',
+ value: function destroy() {
+ this._destroy();
+ var pluginName = getPluginName(this);
+ this.$element.removeAttr('data-' + pluginName).removeData('zfPlugin')
+ /**
+ * Fires when the plugin has been destroyed.
+ * @event Plugin#destroyed
+ */
+ .trigger('destroyed.zf.' + pluginName);
+ for (var prop in this) {
+ this[prop] = null; //clean up script to prep for garbage collection.
+ }
+ }
+ }]);
+
+ return Plugin;
+}();
+
+// 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();
+}
+
+function getPluginName(obj) {
+ if (typeof obj.constructor.name !== 'undefined') {
+ return hyphenate(obj.constructor.name);
+ } else {
+ return hyphenate(obj.className);
+ }
+}
+
+
+
+/***/ }),
+/* 5 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return MediaQuery; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery__ = __webpack_require__(0);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery__);
+
+
+
+
+// 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)'
+};
+
+// 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
+var 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'
+ };
+ };
+}();
+
+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 $meta = __WEBPACK_IMPORTED_MODULE_0_jquery___default()('meta.foundation-mq');
+ if (!$meta.length) {
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()('').appendTo(document.head);
+ }
+
+ var extractedStyles = __WEBPACK_IMPORTED_MODULE_0_jquery___default()('.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 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 (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;
+
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()(window).off('resize.zf.mediaquery').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
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()(window).trigger('changed.zf.mediaquery', [newSize, currentSize]);
+ }
+ });
+ }
+};
+
+// 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;
+}
+
+
+
+/***/ }),
+/* 6 */
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = __webpack_require__(2);
+
+
+/***/ })
+/******/ ]);
+/******/
+ (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] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = 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;
+/******/
+/******/ // identity function for calling harmony imports with the correct context
+/******/ __webpack_require__.i = function(value) { return value; };
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, {
+/******/ configurable: false,
+/******/ enumerable: true,
+/******/ get: getter
+/******/ });
+/******/ }
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 100);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 1:
+/***/ (function(module, exports) {
+
+module.exports = {Foundation: window.Foundation};
+
+/***/ }),
+
+/***/ 100:
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = __webpack_require__(34);
+
+
+/***/ }),
+
+/***/ 3:
+/***/ (function(module, exports) {
+
+module.exports = {rtl: window.Foundation.rtl, GetYoDigits: window.Foundation.GetYoDigits, transitionend: window.Foundation.transitionend};
+
+/***/ }),
+
+/***/ 34:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__foundation_core__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_box__ = __webpack_require__(64);
+
+
+
+__WEBPACK_IMPORTED_MODULE_0__foundation_core__["Foundation"].Box = __WEBPACK_IMPORTED_MODULE_1__foundation_util_box__["a" /* Box */];
+
+/***/ }),
+
+/***/ 64:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Box; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_util_core__ = __webpack_require__(3);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_util_core___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__foundation_util_core__);
+
+
+
+
+var Box = {
+ ImNotTouchingYou: ImNotTouchingYou,
+ OverlapArea: OverlapArea,
+ GetDimensions: GetDimensions,
+ GetOffsets: GetOffsets,
+ GetExplicitOffsets: GetExplicitOffsets
+};
+
+/**
+ * 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, ignoreBottom) {
+ return OverlapArea(element, parent, lrOnly, tbOnly, ignoreBottom) === 0;
+};
+
+function OverlapArea(element, parent, lrOnly, tbOnly, ignoreBottom) {
+ var eleDims = GetDimensions(element),
+ topOver,
+ bottomOver,
+ leftOver,
+ rightOver;
+ if (parent) {
+ var parDims = GetDimensions(parent);
+
+ bottomOver = parDims.height + parDims.offset.top - (eleDims.offset.top + eleDims.height);
+ topOver = eleDims.offset.top - parDims.offset.top;
+ leftOver = eleDims.offset.left - parDims.offset.left;
+ rightOver = parDims.width + parDims.offset.left - (eleDims.offset.left + eleDims.width);
+ } else {
+ bottomOver = eleDims.windowDims.height + eleDims.windowDims.offset.top - (eleDims.offset.top + eleDims.height);
+ topOver = eleDims.offset.top - eleDims.windowDims.offset.top;
+ leftOver = eleDims.offset.left - eleDims.windowDims.offset.left;
+ rightOver = eleDims.windowDims.width - (eleDims.offset.left + eleDims.width);
+ }
+
+ bottomOver = ignoreBottom ? 0 : Math.min(bottomOver, 0);
+ topOver = Math.min(topOver, 0);
+ leftOver = Math.min(leftOver, 0);
+ rightOver = Math.min(rightOver, 0);
+
+ if (lrOnly) {
+ return leftOver + rightOver;
+ }
+ if (tbOnly) {
+ return topOver + bottomOver;
+ }
+
+ // use sum of squares b/c we care about overlap area.
+ return Math.sqrt(topOver * topOver + bottomOver * bottomOver + leftOver * leftOver + rightOver * rightOver);
+}
+
+/**
+ * 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. Maintained for backwards compatibility, and where
+ * you don't know alignment, but generally from
+ * 6.4 forward you should use GetExplicitOffsets, as GetOffsets conflates position and alignment.
+ * @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) {
+ console.log("NOTE: GetOffsets is deprecated in favor of GetExplicitOffsets and will be removed in 6.5");
+ switch (position) {
+ case 'top':
+ return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__foundation_util_core__["rtl"])() ? GetExplicitOffsets(element, anchor, 'top', 'left', vOffset, hOffset, isOverflow) : GetExplicitOffsets(element, anchor, 'top', 'right', vOffset, hOffset, isOverflow);
+ case 'bottom':
+ return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__foundation_util_core__["rtl"])() ? GetExplicitOffsets(element, anchor, 'bottom', 'left', vOffset, hOffset, isOverflow) : GetExplicitOffsets(element, anchor, 'bottom', 'right', vOffset, hOffset, isOverflow);
+ case 'center top':
+ return GetExplicitOffsets(element, anchor, 'top', 'center', vOffset, hOffset, isOverflow);
+ case 'center bottom':
+ return GetExplicitOffsets(element, anchor, 'bottom', 'center', vOffset, hOffset, isOverflow);
+ case 'center left':
+ return GetExplicitOffsets(element, anchor, 'left', 'center', vOffset, hOffset, isOverflow);
+ case 'center right':
+ return GetExplicitOffsets(element, anchor, 'right', 'center', vOffset, hOffset, isOverflow);
+ case 'left bottom':
+ return GetExplicitOffsets(element, anchor, 'bottom', 'left', vOffset, hOffset, isOverflow);
+ case 'right bottom':
+ return GetExplicitOffsets(element, anchor, 'bottom', 'right', vOffset, hOffset, isOverflow);
+ // Backwards compatibility... this along with the reveal and reveal full
+ // classes are the only ones that didn't reference anchor
+ case 'center':
+ return {
+ left: $eleDims.windowDims.offset.left + $eleDims.windowDims.width / 2 - $eleDims.width / 2 + hOffset,
+ top: $eleDims.windowDims.offset.top + $eleDims.windowDims.height / 2 - ($eleDims.height / 2 + vOffset)
+ };
+ case 'reveal':
+ return {
+ left: ($eleDims.windowDims.width - $eleDims.width) / 2 + hOffset,
+ top: $eleDims.windowDims.offset.top + vOffset
+ };
+ case 'reveal full':
+ return {
+ left: $eleDims.windowDims.offset.left,
+ top: $eleDims.windowDims.offset.top
+ };
+ break;
+ default:
+ return {
+ left: __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__foundation_util_core__["rtl"])() ? $anchorDims.offset.left - $eleDims.width + $anchorDims.width - hOffset : $anchorDims.offset.left + hOffset,
+ top: $anchorDims.offset.top + $anchorDims.height + vOffset
+ };
+
+ }
+}
+
+function GetExplicitOffsets(element, anchor, position, alignment, vOffset, hOffset, isOverflow) {
+ var $eleDims = GetDimensions(element),
+ $anchorDims = anchor ? GetDimensions(anchor) : null;
+
+ var topVal, leftVal;
+
+ // set position related attribute
+
+ switch (position) {
+ case 'top':
+ topVal = $anchorDims.offset.top - ($eleDims.height + vOffset);
+ break;
+ case 'bottom':
+ topVal = $anchorDims.offset.top + $anchorDims.height + vOffset;
+ break;
+ case 'left':
+ leftVal = $anchorDims.offset.left - ($eleDims.width + hOffset);
+ break;
+ case 'right':
+ leftVal = $anchorDims.offset.left + $anchorDims.width + hOffset;
+ break;
+ }
+
+ // set alignment related attribute
+ switch (position) {
+ case 'top':
+ case 'bottom':
+ switch (alignment) {
+ case 'left':
+ leftVal = $anchorDims.offset.left + hOffset;
+ break;
+ case 'right':
+ leftVal = $anchorDims.offset.left - $eleDims.width + $anchorDims.width - hOffset;
+ break;
+ case 'center':
+ leftVal = isOverflow ? hOffset : $anchorDims.offset.left + $anchorDims.width / 2 - $eleDims.width / 2 + hOffset;
+ break;
+ }
+ break;
+ case 'right':
+ case 'left':
+ switch (alignment) {
+ case 'bottom':
+ topVal = $anchorDims.offset.top - vOffset + $anchorDims.height - $eleDims.height;
+ break;
+ case 'top':
+ topVal = $anchorDims.offset.top + vOffset;
+ break;
+ case 'center':
+ topVal = $anchorDims.offset.top + vOffset + $anchorDims.height / 2 - $eleDims.height / 2;
+ break;
+ }
+ break;
+ }
+ return { top: topVal, left: leftVal };
+}
+
+
+
+/***/ })
+
+/******/ });
+/******/
+ (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] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = 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;
+/******/
+/******/ // identity function for calling harmony imports with the correct context
+/******/ __webpack_require__.i = function(value) { return value; };
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, {
+/******/ configurable: false,
+/******/ enumerable: true,
+/******/ get: getter
+/******/ });
+/******/ }
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 101);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 0:
+/***/ (function(module, exports) {
+
+module.exports = jQuery;
+
+/***/ }),
+
+/***/ 1:
+/***/ (function(module, exports) {
+
+module.exports = {Foundation: window.Foundation};
+
+/***/ }),
+
+/***/ 101:
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = __webpack_require__(35);
+
+
+/***/ }),
+
+/***/ 35:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__foundation_core__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_imageLoader__ = __webpack_require__(65);
+
+
+
+
+__WEBPACK_IMPORTED_MODULE_0__foundation_core__["Foundation"].onImagesLoaded = __WEBPACK_IMPORTED_MODULE_1__foundation_util_imageLoader__["a" /* onImagesLoaded */];
+
+/***/ }),
+
+/***/ 65:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return onImagesLoaded; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery__ = __webpack_require__(0);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery__);
+
+
+
+
+/**
+ * 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.naturalWidth !== undefined) {
+ singleImageLoaded();
+ } else {
+ // If the above check failed, simulate loading on detached element.
+ var image = new Image();
+ // Still count image as loaded if it finalizes with an error.
+ var events = "load.zf.images error.zf.images";
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()(image).one(events, function me(event) {
+ // Unbind the event listeners. We're using 'one' but only one of the two events will have fired.
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).off(events, me);
+ singleImageLoaded();
+ });
+ image.src = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).attr('src');
+ }
+ });
+
+ function singleImageLoaded() {
+ unloaded--;
+ if (unloaded === 0) {
+ callback();
+ }
+ }
+}
+
+
+
+/***/ })
+
+/******/ });
+/******/
+ (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] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = 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;
+/******/
+/******/ // identity function for calling harmony imports with the correct context
+/******/ __webpack_require__.i = function(value) { return value; };
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, {
+/******/ configurable: false,
+/******/ enumerable: true,
+/******/ get: getter
+/******/ });
+/******/ }
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 102);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 0:
+/***/ (function(module, exports) {
+
+module.exports = jQuery;
+
+/***/ }),
+
+/***/ 1:
+/***/ (function(module, exports) {
+
+module.exports = {Foundation: window.Foundation};
+
+/***/ }),
+
+/***/ 102:
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = __webpack_require__(36);
+
+
+/***/ }),
+
+/***/ 3:
+/***/ (function(module, exports) {
+
+module.exports = {rtl: window.Foundation.rtl, GetYoDigits: window.Foundation.GetYoDigits, transitionend: window.Foundation.transitionend};
+
+/***/ }),
+
+/***/ 36:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__foundation_core__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_keyboard__ = __webpack_require__(66);
+
+
+
+__WEBPACK_IMPORTED_MODULE_0__foundation_core__["Foundation"].Keyboard = __WEBPACK_IMPORTED_MODULE_1__foundation_util_keyboard__["a" /* Keyboard */];
+
+/***/ }),
+
+/***/ 66:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Keyboard; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery__ = __webpack_require__(0);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_core__ = __webpack_require__(3);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_core___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__foundation_util_core__);
+/*******************************************
+ * *
+ * This util was created by Marius Olbertz *
+ * Please thank Marius on GitHub /owlbertz *
+ * or the web http://www.mariusolbertz.de/ *
+ * *
+ ******************************************/
+
+
+
+
+
+
+var keyCodes = {
+ 9: 'TAB',
+ 13: 'ENTER',
+ 27: 'ESCAPE',
+ 32: 'SPACE',
+ 35: 'END',
+ 36: 'HOME',
+ 37: 'ARROW_LEFT',
+ 38: 'ARROW_UP',
+ 39: 'ARROW_RIGHT',
+ 40: 'ARROW_DOWN'
+};
+
+var commands = {};
+
+// Functions pulled out to be referenceable from internals
+function findFocusable($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 (!__WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).is(':visible') || __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).attr('tabindex') < 0) {
+ return false;
+ } //only have visible elements and those that have a tabindex greater or equal 0
+ return true;
+ });
+}
+
+function parseKey(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;
+}
+
+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: parseKey,
+
+ /**
+ * 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 (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__foundation_util_core__["rtl"])()) cmds = __WEBPACK_IMPORTED_MODULE_0_jquery___default.a.extend({}, commandList.ltr, commandList.rtl);else cmds = __WEBPACK_IMPORTED_MODULE_0_jquery___default.a.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: findFocusable,
+
+ /**
+ * 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;
+ },
+
+
+ // TODO9438: These references to Keyboard need to not require global. Will 'this' work in this context?
+ //
+ /**
+ * Traps the focus in the given element.
+ * @param {jQuery} $element jQuery object to trap the foucs into.
+ */
+ trapFocus: function ($element) {
+ var $focusable = findFocusable($element),
+ $firstFocusable = $focusable.eq(0),
+ $lastFocusable = $focusable.eq(-1);
+
+ $element.on('keydown.zf.trapfocus', function (event) {
+ if (event.target === $lastFocusable[0] && parseKey(event) === 'TAB') {
+ event.preventDefault();
+ $firstFocusable.focus();
+ } else if (event.target === $firstFocusable[0] && 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;
+}
+
+
+
+/***/ })
+
+/******/ });
+/******/
+ (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] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = 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;
+/******/
+/******/ // identity function for calling harmony imports with the correct context
+/******/ __webpack_require__.i = function(value) { return value; };
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, {
+/******/ configurable: false,
+/******/ enumerable: true,
+/******/ get: getter
+/******/ });
+/******/ }
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 103);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 0:
+/***/ (function(module, exports) {
+
+module.exports = jQuery;
+
+/***/ }),
+
+/***/ 1:
+/***/ (function(module, exports) {
+
+module.exports = {Foundation: window.Foundation};
+
+/***/ }),
+
+/***/ 103:
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = __webpack_require__(37);
+
+
+/***/ }),
+
+/***/ 37:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__foundation_core__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_mediaQuery__ = __webpack_require__(67);
+
+
+
+__WEBPACK_IMPORTED_MODULE_0__foundation_core__["Foundation"].MediaQuery = __WEBPACK_IMPORTED_MODULE_1__foundation_util_mediaQuery__["a" /* MediaQuery */];
+
+/***/ }),
+
+/***/ 67:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return MediaQuery; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery__ = __webpack_require__(0);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery__);
+
+
+
+
+// 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)'
+};
+
+// 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
+var 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'
+ };
+ };
+}();
+
+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 $meta = __WEBPACK_IMPORTED_MODULE_0_jquery___default()('meta.foundation-mq');
+ if (!$meta.length) {
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()('').appendTo(document.head);
+ }
+
+ var extractedStyles = __WEBPACK_IMPORTED_MODULE_0_jquery___default()('.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 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 (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;
+
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()(window).off('resize.zf.mediaquery').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
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()(window).trigger('changed.zf.mediaquery', [newSize, currentSize]);
+ }
+ });
+ }
+};
+
+// 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;
+}
+
+
+
+/***/ })
+
+/******/ });
+/******/
+ (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] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = 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;
+/******/
+/******/ // identity function for calling harmony imports with the correct context
+/******/ __webpack_require__.i = function(value) { return value; };
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, {
+/******/ configurable: false,
+/******/ enumerable: true,
+/******/ get: getter
+/******/ });
+/******/ }
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 104);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 0:
+/***/ (function(module, exports) {
+
+module.exports = jQuery;
+
+/***/ }),
+
+/***/ 1:
+/***/ (function(module, exports) {
+
+module.exports = {Foundation: window.Foundation};
+
+/***/ }),
+
+/***/ 104:
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = __webpack_require__(38);
+
+
+/***/ }),
+
+/***/ 3:
+/***/ (function(module, exports) {
+
+module.exports = {rtl: window.Foundation.rtl, GetYoDigits: window.Foundation.GetYoDigits, transitionend: window.Foundation.transitionend};
+
+/***/ }),
+
+/***/ 38:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__foundation_core__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_motion__ = __webpack_require__(68);
+
+
+
+__WEBPACK_IMPORTED_MODULE_0__foundation_core__["Foundation"].Motion = __WEBPACK_IMPORTED_MODULE_1__foundation_util_motion__["a" /* Motion */];
+__WEBPACK_IMPORTED_MODULE_0__foundation_core__["Foundation"].Move = __WEBPACK_IMPORTED_MODULE_1__foundation_util_motion__["b" /* Move */];
+
+/***/ }),
+
+/***/ 68:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return Move; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Motion; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery__ = __webpack_require__(0);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_core__ = __webpack_require__(3);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_core___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__foundation_util_core__);
+
+
+
+
+
+/**
+ * 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 = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(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(__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__foundation_util_core__["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);
+ }
+}
+
+
+
+/***/ })
+
+/******/ });
+/******/
+ (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] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = 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;
+/******/
+/******/ // identity function for calling harmony imports with the correct context
+/******/ __webpack_require__.i = function(value) { return value; };
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, {
+/******/ configurable: false,
+/******/ enumerable: true,
+/******/ get: getter
+/******/ });
+/******/ }
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 105);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 0:
+/***/ (function(module, exports) {
+
+module.exports = jQuery;
+
+/***/ }),
+
+/***/ 1:
+/***/ (function(module, exports) {
+
+module.exports = {Foundation: window.Foundation};
+
+/***/ }),
+
+/***/ 105:
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = __webpack_require__(39);
+
+
+/***/ }),
+
+/***/ 39:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__foundation_core__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_nest__ = __webpack_require__(69);
+
+
+
+
+__WEBPACK_IMPORTED_MODULE_0__foundation_core__["Foundation"].Nest = __WEBPACK_IMPORTED_MODULE_1__foundation_util_nest__["a" /* Nest */];
+
+/***/ }),
+
+/***/ 69:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Nest; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery__ = __webpack_require__(0);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery__);
+
+
+
+
+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',
+ applyAria = type !== 'accordion'; // Accordions handle their own ARIA attriutes.
+
+ items.each(function () {
+ var $item = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this),
+ $sub = $item.children('ul');
+
+ if ($sub.length) {
+ $item.addClass(hasSubClass);
+ $sub.addClass('submenu ' + subMenuClass).attr({ 'data-submenu': '' });
+ if (applyAria) {
+ $item.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', '');
+ }
+};
+
+
+
+/***/ })
+
+/******/ });
+/******/
+ (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] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = 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;
+/******/
+/******/ // identity function for calling harmony imports with the correct context
+/******/ __webpack_require__.i = function(value) { return value; };
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, {
+/******/ configurable: false,
+/******/ enumerable: true,
+/******/ get: getter
+/******/ });
+/******/ }
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 106);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 0:
+/***/ (function(module, exports) {
+
+module.exports = jQuery;
+
+/***/ }),
+
+/***/ 1:
+/***/ (function(module, exports) {
+
+module.exports = {Foundation: window.Foundation};
+
+/***/ }),
+
+/***/ 106:
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = __webpack_require__(40);
+
+
+/***/ }),
+
+/***/ 40:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__foundation_core__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_timer__ = __webpack_require__(70);
+
+
+
+
+__WEBPACK_IMPORTED_MODULE_0__foundation_core__["Foundation"].Timer = __WEBPACK_IMPORTED_MODULE_1__foundation_util_timer__["a" /* Timer */];
+
+/***/ }),
+
+/***/ 70:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Timer; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery__ = __webpack_require__(0);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery__);
+
+
+
+
+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);
+ };
+}
+
+
+
+/***/ })
+
+/******/ });
+'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);
+/******/
+ (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] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = 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;
+/******/
+/******/ // identity function for calling harmony imports with the correct context
+/******/ __webpack_require__.i = function(value) { return value; };
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, {
+/******/ configurable: false,
+/******/ enumerable: true,
+/******/ get: getter
+/******/ });
+/******/ }
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 107);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 0:
+/***/ (function(module, exports) {
+
+module.exports = jQuery;
+
+/***/ }),
+
+/***/ 107:
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = __webpack_require__(41);
+
+
+/***/ }),
+
+/***/ 41:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery__ = __webpack_require__(0);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_touch__ = __webpack_require__(71);
+
+
+
+
+__WEBPACK_IMPORTED_MODULE_1__foundation_util_touch__["a" /* Touch */].init(__WEBPACK_IMPORTED_MODULE_0_jquery___default.a);
+
+window.Foundation.Touch = __WEBPACK_IMPORTED_MODULE_1__foundation_util_touch__["a" /* Touch */];
+
+/***/ }),
+
+/***/ 71:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Touch; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery__ = __webpack_require__(0);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery__);
+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"); } }
+
+//**************************************************
+//**Work inspired by multiple jquery swipe plugins**
+//**Done by Yohai Ararat ***************************
+//**************************************************
+
+
+
+var Touch = {};
+
+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 (__WEBPACK_IMPORTED_MODULE_0_jquery___default.a.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) >= __WEBPACK_IMPORTED_MODULE_0_jquery___default.a.spotSwipe.moveThreshold && elapsedTime <= __WEBPACK_IMPORTED_MODULE_0_jquery___default.a.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);
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()(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);
+}
+
+var SpotSwipe = function () {
+ function SpotSwipe($) {
+ _classCallCheck(this, SpotSwipe);
+
+ this.version = '1.0.0';
+ this.enabled = 'ontouchstart' in document.documentElement;
+ this.preventDefault = false;
+ this.moveThreshold = 75;
+ this.timeThreshold = 200;
+ this.$ = $;
+ this._init();
+ }
+
+ _createClass(SpotSwipe, [{
+ key: '_init',
+ value: function _init() {
+ var $ = this.$;
+ $.event.special.swipe = { setup: init };
+
+ $.each(['left', 'up', 'down', 'right'], function () {
+ $.event.special['swipe' + this] = { setup: function () {
+ $(this).on('swipe', $.noop);
+ } };
+ });
+ }
+ }]);
+
+ return SpotSwipe;
+}();
+
+/****************************************************
+ * As far as I can tell, both setupSpotSwipe and *
+ * setupTouchHandler should be idempotent, *
+ * because they directly replace functions & *
+ * values, and do not add event handlers directly. *
+ ****************************************************/
+
+Touch.setupSpotSwipe = function ($) {
+ $.spotSwipe = new SpotSwipe($);
+};
+
+/****************************************************
+ * Method for adding pseudo drag events to elements *
+ ***************************************************/
+Touch.setupTouchHandler = 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);
+ };
+ };
+};
+
+Touch.init = function ($) {
+ if (typeof $.spotSwipe === 'undefined') {
+ Touch.setupSpotSwipe($);
+ Touch.setupTouchHandler($);
+ }
+};
+
+
+
+/***/ })
+
+/******/ });
+/******/
+ (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] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = 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;
+/******/
+/******/ // identity function for calling harmony imports with the correct context
+/******/ __webpack_require__.i = function(value) { return value; };
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, {
+/******/ configurable: false,
+/******/ enumerable: true,
+/******/ get: getter
+/******/ });
+/******/ }
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 108);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 0:
+/***/ (function(module, exports) {
+
+module.exports = jQuery;
+
+/***/ }),
+
+/***/ 1:
+/***/ (function(module, exports) {
+
+module.exports = {Foundation: window.Foundation};
+
+/***/ }),
+
+/***/ 108:
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = __webpack_require__(42);
+
+
+/***/ }),
+
+/***/ 4:
+/***/ (function(module, exports) {
+
+module.exports = {Motion: window.Foundation.Motion, Move: window.Foundation.Move};
+
+/***/ }),
+
+/***/ 42:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__foundation_core__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_jquery__ = __webpack_require__(0);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_jquery__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__foundation_util_triggers__ = __webpack_require__(7);
+
+
+
+
+__WEBPACK_IMPORTED_MODULE_2__foundation_util_triggers__["a" /* Triggers */].init(__WEBPACK_IMPORTED_MODULE_1_jquery___default.a, __WEBPACK_IMPORTED_MODULE_0__foundation_core__["Foundation"]);
+
+/***/ }),
+
+/***/ 7:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Triggers; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery__ = __webpack_require__(0);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_motion__ = __webpack_require__(4);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_motion___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__foundation_util_motion__);
+
+
+
+
+
+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) {
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()('#' + id)[type === 'close' ? 'trigger' : 'triggerHandler'](type + '.zf.trigger', [el]);
+ });
+};
+
+var Triggers = {
+ Listeners: {
+ Basic: {},
+ Global: {}
+ },
+ Initializers: {}
+};
+
+Triggers.Listeners.Basic = {
+ openListener: function () {
+ triggers(__WEBPACK_IMPORTED_MODULE_0_jquery___default()(this), 'open');
+ },
+ closeListener: function () {
+ var id = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).data('close');
+ if (id) {
+ triggers(__WEBPACK_IMPORTED_MODULE_0_jquery___default()(this), 'close');
+ } else {
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).trigger('close.zf.trigger');
+ }
+ },
+ toggleListener: function () {
+ var id = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).data('toggle');
+ if (id) {
+ triggers(__WEBPACK_IMPORTED_MODULE_0_jquery___default()(this), 'toggle');
+ } else {
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).trigger('toggle.zf.trigger');
+ }
+ },
+ closeableListener: function (e) {
+ e.stopPropagation();
+ var animation = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).data('closable');
+
+ if (animation !== '') {
+ __WEBPACK_IMPORTED_MODULE_1__foundation_util_motion__["Motion"].animateOut(__WEBPACK_IMPORTED_MODULE_0_jquery___default()(this), animation, function () {
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).trigger('closed.zf');
+ });
+ } else {
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).fadeOut().trigger('closed.zf');
+ }
+ },
+ toggleFocusListener: function () {
+ var id = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).data('toggle-focus');
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()('#' + id).triggerHandler('toggle.zf.trigger', [__WEBPACK_IMPORTED_MODULE_0_jquery___default()(this)]);
+ }
+};
+
+// Elements with [data-open] will reveal a plugin that supports it when clicked.
+Triggers.Initializers.addOpenListener = function ($elem) {
+ $elem.off('click.zf.trigger', Triggers.Listeners.Basic.openListener);
+ $elem.on('click.zf.trigger', '[data-open]', Triggers.Listeners.Basic.openListener);
+};
+
+// 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.
+Triggers.Initializers.addCloseListener = function ($elem) {
+ $elem.off('click.zf.trigger', Triggers.Listeners.Basic.closeListener);
+ $elem.on('click.zf.trigger', '[data-close]', Triggers.Listeners.Basic.closeListener);
+};
+
+// Elements with [data-toggle] will toggle a plugin that supports it when clicked.
+Triggers.Initializers.addToggleListener = function ($elem) {
+ $elem.off('click.zf.trigger', Triggers.Listeners.Basic.toggleListener);
+ $elem.on('click.zf.trigger', '[data-toggle]', Triggers.Listeners.Basic.toggleListener);
+};
+
+// Elements with [data-closable] will respond to close.zf.trigger events.
+Triggers.Initializers.addCloseableListener = function ($elem) {
+ $elem.off('close.zf.trigger', Triggers.Listeners.Basic.closeableListener);
+ $elem.on('close.zf.trigger', '[data-closeable], [data-closable]', Triggers.Listeners.Basic.closeableListener);
+};
+
+// Elements with [data-toggle-focus] will respond to coming in and out of focus
+Triggers.Initializers.addToggleFocusListener = function ($elem) {
+ $elem.off('focus.zf.trigger blur.zf.trigger', Triggers.Listeners.Basic.toggleFocusListener);
+ $elem.on('focus.zf.trigger blur.zf.trigger', '[data-toggle-focus]', Triggers.Listeners.Basic.toggleFocusListener);
+};
+
+// More Global/complex listeners and triggers
+Triggers.Listeners.Global = {
+ resizeListener: function ($nodes) {
+ if (!MutationObserver) {
+ //fallback for IE 9
+ $nodes.each(function () {
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).triggerHandler('resizeme.zf.trigger');
+ });
+ }
+ //trigger all listening elements and signal a resize event
+ $nodes.attr('data-events', "resize");
+ },
+ scrollListener: function ($nodes) {
+ if (!MutationObserver) {
+ //fallback for IE 9
+ $nodes.each(function () {
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).triggerHandler('scrollme.zf.trigger');
+ });
+ }
+ //trigger all listening elements and signal a scroll event
+ $nodes.attr('data-events', "scroll");
+ },
+ closeMeListener: function (e, pluginId) {
+ var plugin = e.namespace.split('.')[0];
+ var plugins = __WEBPACK_IMPORTED_MODULE_0_jquery___default()('[data-' + plugin + ']').not('[data-yeti-box="' + pluginId + '"]');
+
+ plugins.each(function () {
+ var _this = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this);
+ _this.triggerHandler('close.zf.trigger', [_this]);
+ });
+ }
+};
+
+// Global, parses whole document.
+Triggers.Initializers.addClosemeListener = function (pluginName) {
+ var yetiBoxes = __WEBPACK_IMPORTED_MODULE_0_jquery___default()('[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(' ');
+
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()(window).off(listeners).on(listeners, Triggers.Listeners.Global.closeMeListener);
+ }
+};
+
+function debounceGlobalListener(debounce, trigger, listener) {
+ var timer = void 0,
+ args = Array.prototype.slice.call(arguments, 3);
+ __WEBPACK_IMPORTED_MODULE_0_jquery___default()(window).off(trigger).on(trigger, function (e) {
+ if (timer) {
+ clearTimeout(timer);
+ }
+ timer = setTimeout(function () {
+ listener.apply(null, args);
+ }, debounce || 10); //default time to emit scroll event
+ });
+}
+
+Triggers.Initializers.addResizeListener = function (debounce) {
+ var $nodes = __WEBPACK_IMPORTED_MODULE_0_jquery___default()('[data-resize]');
+ if ($nodes.length) {
+ debounceGlobalListener(debounce, 'resize.zf.trigger', Triggers.Listeners.Global.resizeListener, $nodes);
+ }
+};
+
+Triggers.Initializers.addScrollListener = function (debounce) {
+ var $nodes = __WEBPACK_IMPORTED_MODULE_0_jquery___default()('[data-scroll]');
+ if ($nodes.length) {
+ debounceGlobalListener(debounce, 'scroll.zf.trigger', Triggers.Listeners.Global.scrollListener, $nodes);
+ }
+};
+
+Triggers.Initializers.addMutationEventsListener = function ($elem) {
+ if (!MutationObserver) {
+ return false;
+ }
+ var $nodes = $elem.find('[data-resize], [data-scroll], [data-mutate]');
+
+ //element callback
+ var listeningElementsMutation = function (mutationRecordsList) {
+ var $target = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(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"] });
+ }
+ }
+};
+
+Triggers.Initializers.addSimpleListeners = function () {
+ var $document = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(document);
+
+ Triggers.Initializers.addOpenListener($document);
+ Triggers.Initializers.addCloseListener($document);
+ Triggers.Initializers.addToggleListener($document);
+ Triggers.Initializers.addCloseableListener($document);
+ Triggers.Initializers.addToggleFocusListener($document);
+};
+
+Triggers.Initializers.addGlobalListeners = function () {
+ var $document = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(document);
+ Triggers.Initializers.addMutationEventsListener($document);
+ Triggers.Initializers.addResizeListener();
+ Triggers.Initializers.addScrollListener();
+ Triggers.Initializers.addClosemeListener();
+};
+
+Triggers.init = function ($, Foundation) {
+ if (typeof $.triggersInitialized === 'undefined') {
+ var $document = $(document);
+
+ if (document.readyState === "complete") {
+ Triggers.Initializers.addSimpleListeners();
+ Triggers.Initializers.addGlobalListeners();
+ } else {
+ $(window).on('load', function () {
+ Triggers.Initializers.addSimpleListeners();
+ Triggers.Initializers.addGlobalListeners();
+ });
+ }
+
+ $.triggersInitialized = true;
+ }
+
+ if (Foundation) {
+ Foundation.Triggers = Triggers;
+ // Legacy included to be backwards compatible for now.
+ Foundation.IHearYou = Triggers.Initializers.addGlobalListeners;
+ }
+};
+
+
+
+/***/ })
+
+/******/ });
+/******/
+ (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] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = 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;
+/******/
+/******/ // identity function for calling harmony imports with the correct context
+/******/ __webpack_require__.i = function(value) { return value; };
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, {
+/******/ configurable: false,
+/******/ enumerable: true,
+/******/ get: getter
+/******/ });
+/******/ }
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 79);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 0:
+/***/ (function(module, exports) {
+
+module.exports = jQuery;
+
+/***/ }),
+
+/***/ 1:
+/***/ (function(module, exports) {
+
+module.exports = {Foundation: window.Foundation};
+
+/***/ }),
+
+/***/ 13:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__foundation_core__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_abide__ = __webpack_require__(43);
+
+
+
+__WEBPACK_IMPORTED_MODULE_0__foundation_core__["Foundation"].plugin(__WEBPACK_IMPORTED_MODULE_1__foundation_abide__["a" /* Abide */], 'Abide');
+
+/***/ }),
+
+/***/ 2:
+/***/ (function(module, exports) {
+
+module.exports = {Plugin: window.Foundation.Plugin};
+
+/***/ }),
+
+/***/ 43:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Abide; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery__ = __webpack_require__(0);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_plugin__ = __webpack_require__(2);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_plugin___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__foundation_plugin__);
+
+
+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 _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+
+
+
+/**
+ * Abide module.
+ * @module foundation.abide
+ */
+
+var Abide = function (_Plugin) {
+ _inherits(Abide, _Plugin);
+
+ function Abide() {
+ _classCallCheck(this, Abide);
+
+ return _possibleConstructorReturn(this, (Abide.__proto__ || Object.getPrototypeOf(Abide)).apply(this, arguments));
+ }
+
+ _createClass(Abide, [{
+ key: '_setup',
+
+ /**
+ * Creates a new instance of Abide.
+ * @class
+ * @name Abide
+ * @fires Abide#init
+ * @param {Object} element - jQuery object to add the trigger to.
+ * @param {Object} options - Overrides to the default plugin settings.
+ */
+ value: function _setup(element) {
+ var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+ this.$element = element;
+ this.options = __WEBPACK_IMPORTED_MODULE_0_jquery___default.a.extend({}, Abide.defaults, this.$element.data(), options);
+
+ this.className = 'Abide'; // ie9 back compat
+ this._init();
+ }
+
+ /**
+ * Initializes the Abide plugin and calls functions to get Abide functioning on load.
+ * @private
+ */
+
+ }, {
+ 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 _this3 = this;
+
+ this.$element.off('.abide').on('reset.zf.abide', function () {
+ _this3.resetForm();
+ }).on('submit.zf.abide', function () {
+ return _this3.validateForm();
+ });
+
+ if (this.options.validateOn === 'fieldChange') {
+ this.$inputs.off('change.zf.abide').on('change.zf.abide', function (e) {
+ _this3.validateInput(__WEBPACK_IMPORTED_MODULE_0_jquery___default()(e.target));
+ });
+ }
+
+ if (this.options.liveValidate) {
+ this.$inputs.off('input.zf.abide').on('input.zf.abide', function (e) {
+ _this3.validateInput(__WEBPACK_IMPORTED_MODULE_0_jquery___default()(e.target));
+ });
+ }
+
+ if (this.options.validateOnBlur) {
+ this.$inputs.off('blur.zf.abide').on('blur.zf.abide', function (e) {
+ _this3.validateInput(__WEBPACK_IMPORTED_MODULE_0_jquery___default()(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
+
+ We're sorry, but something went wrong.
+If you are the application owner check the logs for more information.
+