// Utility function
function Util () {};

/* 
	class manipulation functions
*/
Util.hasClass = function(el, className) {
	if (el.classList) return el.classList.contains(className);
	else return !!el.className.match(new RegExp('(\\s|^)' + className + '(\\s|$)'));
};

Util.addClass = function(el, className) {
	var classList = className.split(' ');
 	if (el.classList) el.classList.add(classList[0]);
 	else if (!Util.hasClass(el, classList[0])) el.className += " " + classList[0];
 	if (classList.length > 1) Util.addClass(el, classList.slice(1).join(' '));
};

Util.removeClass = function(el, className) {
	var classList = className.split(' ');
	if (el.classList) el.classList.remove(classList[0]);	
	else if(Util.hasClass(el, classList[0])) {
		var reg = new RegExp('(\\s|^)' + classList[0] + '(\\s|$)');
		el.className=el.className.replace(reg, ' ');
	}
	if (classList.length > 1) Util.removeClass(el, classList.slice(1).join(' '));
};

Util.toggleClass = function(el, className, bool) {
	if(bool) Util.addClass(el, className);
	else Util.removeClass(el, className);
};

Util.setAttributes = function(el, attrs) {
  for(var key in attrs) {
    el.setAttribute(key, attrs[key]);
  }
};

/* 
  DOM manipulation
*/
Util.getChildrenByClassName = function(el, className) {
  var children = el.children,
    childrenByClass = [];
  for (var i = 0; i < el.children.length; i++) {
    if (Util.hasClass(el.children[i], className)) childrenByClass.push(el.children[i]);
  }
  return childrenByClass;
};

Util.is = function(elem, selector) {
  if(selector.nodeType){
    return elem === selector;
  }

  var qa = (typeof(selector) === 'string' ? document.querySelectorAll(selector) : selector),
    length = qa.length,
    returnArr = [];

  while(length--){
    if(qa[length] === elem){
      return true;
    }
  }

  return false;
};

/* 
	Animate height of an element
*/
Util.setHeight = function(start, to, element, duration, cb) {
	var change = to - start,
	    currentTime = null;

  var animateHeight = function(timestamp){  
    if (!currentTime) currentTime = timestamp;         
    var progress = timestamp - currentTime;
    var val = parseInt((progress/duration)*change + start);
    element.style.height = val+"px";
    if(progress < duration) {
        window.requestAnimationFrame(animateHeight);
    } else {
    	cb();
    }
  };
  
  //set the height of the element before starting animation -> fix bug on Safari
  element.style.height = start+"px";
  window.requestAnimationFrame(animateHeight);
};

/* 
	Smooth Scroll
*/

Util.scrollTo = function(final, duration, cb, scrollEl) {
  var element = scrollEl || window;
  var start = element.scrollTop || document.documentElement.scrollTop,
    currentTime = null;

  if(!scrollEl) start = window.scrollY || document.documentElement.scrollTop;
      
  var animateScroll = function(timestamp){
  	if (!currentTime) currentTime = timestamp;        
    var progress = timestamp - currentTime;
    if(progress > duration) progress = duration;
    var val = Math.easeInOutQuad(progress, start, final-start, duration);
    element.scrollTo(0, val);
    if(progress < duration) {
        window.requestAnimationFrame(animateScroll);
    } else {
      cb && cb();
    }
  };

  window.requestAnimationFrame(animateScroll);
};

/* 
  Focus utility classes
*/

//Move focus to an element
Util.moveFocus = function (element) {
  if( !element ) element = document.getElementsByTagName("body")[0];
  element.focus();
  if (document.activeElement !== element) {
    element.setAttribute('tabindex','-1');
    element.focus();
  }
};

/* 
  Misc
*/

Util.getIndexInArray = function(array, el) {
  return Array.prototype.indexOf.call(array, el);
};

Util.cssSupports = function(property, value) {
  if('CSS' in window) {
    return CSS.supports(property, value);
  } else {
    var jsProperty = property.replace(/-([a-z])/g, function (g) { return g[1].toUpperCase();});
    return jsProperty in document.body.style;
  }
};

// merge a set of user options into plugin defaults
// https://gomakethings.com/vanilla-javascript-version-of-jquery-extend/
Util.extend = function() {
  // Variables
  var extended = {};
  var deep = false;
  var i = 0;
  var length = arguments.length;

  // Check if a deep merge
  if ( Object.prototype.toString.call( arguments[0] ) === '[object Boolean]' ) {
    deep = arguments[0];
    i++;
  }

  // Merge the object into the extended object
  var merge = function (obj) {
    for ( var prop in obj ) {
      if ( Object.prototype.hasOwnProperty.call( obj, prop ) ) {
        // If deep merge and property is an object, merge properties
        if ( deep && Object.prototype.toString.call(obj[prop]) === '[object Object]' ) {
          extended[prop] = extend( true, extended[prop], obj[prop] );
        } else {
          extended[prop] = obj[prop];
        }
      }
    }
  };

  // Loop through each object and conduct a merge
  for ( ; i < length; i++ ) {
    var obj = arguments[i];
    merge(obj);
  }

  return extended;
};

// Check if Reduced Motion is enabled
Util.osHasReducedMotion = function() {
  if(!window.matchMedia) return false;
  var matchMediaObj = window.matchMedia('(prefers-reduced-motion: reduce)');
  if(matchMediaObj) return matchMediaObj.matches;
  return false; // return false if not supported
}; 

/* 
	Polyfills
*/
//Closest() method
if (!Element.prototype.matches) {
	Element.prototype.matches = Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
}

if (!Element.prototype.closest) {
	Element.prototype.closest = function(s) {
		var el = this;
		if (!document.documentElement.contains(el)) return null;
		do {
			if (el.matches(s)) return el;
			el = el.parentElement || el.parentNode;
		} while (el !== null && el.nodeType === 1); 
		return null;
	};
}

//Custom Event() constructor
if ( typeof window.CustomEvent !== "function" ) {

  function CustomEvent ( event, params ) {
    params = params || { bubbles: false, cancelable: false, detail: undefined };
    var evt = document.createEvent( 'CustomEvent' );
    evt.initCustomEvent( event, params.bubbles, params.cancelable, params.detail );
    return evt;
   }

  CustomEvent.prototype = window.Event.prototype;

  window.CustomEvent = CustomEvent;
}

/* 
	Animation curves
*/
Math.easeInOutQuad = function (t, b, c, d) {
	t /= d/2;
	if (t < 1) return c/2*t*t + b;
	t--;
	return -c/2 * (t*(t-2) - 1) + b;
};

Math.easeInQuart = function (t, b, c, d) {
	t /= d;
	return c*t*t*t*t + b;
};

Math.easeOutQuart = function (t, b, c, d) { 
  t /= d;
	t--;
	return -c * (t*t*t*t - 1) + b;
};

Math.easeInOutQuart = function (t, b, c, d) {
	t /= d/2;
	if (t < 1) return c/2*t*t*t*t + b;
	t -= 2;
	return -c/2 * (t*t*t*t - 2) + b;
};

Math.easeOutElastic = function (t, b, c, d) {
  var s=1.70158;var p=d*0.7;var a=c;
  if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
  if (a < Math.abs(c)) { a=c; var s=p/4; }
  else var s = p/(2*Math.PI) * Math.asin (c/a);
  return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b;
};


/* JS Utility Classes */
(function() {
  // make focus ring visible only for keyboard navigation (i.e., tab key) 
  var focusTab = document.getElementsByClassName('js-tab-focus');
  function detectClick() {
    if(focusTab.length > 0) {
      resetFocusTabs(false);
      window.addEventListener('keydown', detectTab);
    }
    window.removeEventListener('mousedown', detectClick);
  };

  function detectTab(event) {
    if(event.keyCode !== 9) return;
    resetFocusTabs(true);
    window.removeEventListener('keydown', detectTab);
    window.addEventListener('mousedown', detectClick);
  };

  function resetFocusTabs(bool) {
    var outlineStyle = bool ? '' : 'none';
    for(var i = 0; i < focusTab.length; i++) {
      focusTab[i].style.setProperty('outline', outlineStyle);
    }
  };
  window.addEventListener('mousedown', detectClick);
}());
// File#: _1_anim-menu-btn
// Usage: codyhouse.co/license
(function() {
    var menuBtns = document.getElementsByClassName('js-anim-menu-btn');
    if( menuBtns.length > 0 ) {
      for(var i = 0; i < menuBtns.length; i++) {(function(i){
        initMenuBtn(menuBtns[i]);
      })(i);}
  
      function initMenuBtn(btn) {
        btn.addEventListener('click', function(event){	
          event.preventDefault();
          var status = !Util.hasClass(btn, 'anim-menu-btn--state-b');
          Util.toggleClass(btn, 'anim-menu-btn--state-b', status);
          // emit custom event
          var event = new CustomEvent('anim-menu-btn-clicked', {detail: status});
          btn.dispatchEvent(event);
        });
      };
    }
  }());
// File#: _1_choice-buttons
// Usage: codyhouse.co/license
(function() {
    var ChoiceButton = function(element) {
      this.element = element;
      this.btns = this.element.getElementsByClassName('js-choice-btn');
      this.inputs = getChoiceInput(this);
      this.isRadio = this.inputs[0].type.toString() == 'radio';
      resetCheckedStatus(this); // set initial classes
      initChoiceButtonEvent(this); // add listeners
    };
  
    function getChoiceInput(element) { // store input elements in an object property
      var inputs = [];
      for(var i = 0; i < element.btns.length; i++) {
        inputs.push(element.btns[i].getElementsByTagName('input')[0]);
      }
      return inputs;
    };
  
    function initChoiceButtonEvent(choiceBtn) {
      choiceBtn.element.addEventListener('click', function(event){ // update status on click
        if(Util.getIndexInArray(choiceBtn.inputs, event.target) > -1) return; // triggered by change in input element -> will be detected by the 'change' event
  
        var selectedBtn = event.target.closest('.js-choice-btn');
        if(!selectedBtn) return;
        var index = Util.getIndexInArray(choiceBtn.btns, selectedBtn);
        if(choiceBtn.isRadio && choiceBtn.inputs[index].checked) { // radio input already checked
          choiceBtn.inputs[index].focus(); // move focus to input element
          return; 
        }
  
        choiceBtn.inputs[index].checked = !choiceBtn.inputs[index].checked;
        choiceBtn.inputs[index].dispatchEvent(new CustomEvent('change')); // trigger change event
        choiceBtn.inputs[index].focus(); // move focus to input element
      });
  
      for(var i = 0; i < choiceBtn.btns.length; i++) {(function(i){ // change + focus events
        choiceBtn.inputs[i].addEventListener('change', function(event){
          choiceBtn.isRadio ? resetCheckedStatus(choiceBtn) : resetSingleStatus(choiceBtn, i);
        });
  
        choiceBtn.inputs[i].addEventListener('focus', function(event){
          resetFocusStatus(choiceBtn, i, true);
        });
  
        choiceBtn.inputs[i].addEventListener('blur', function(event){
          resetFocusStatus(choiceBtn, i, false);
        });
      })(i);}
    };
  
    function resetCheckedStatus(choiceBtn) {
      for(var i = 0; i < choiceBtn.btns.length; i++) {
        resetSingleStatus(choiceBtn, i);
      }
    };
  
    function resetSingleStatus(choiceBtn, index) { // toggle .choice-btn--checked class
      Util.toggleClass(choiceBtn.btns[index], 'choice-btn--checked', choiceBtn.inputs[index].checked);
    };
  
    function resetFocusStatus(choiceBtn, index, bool) { // toggle .choice-btn--focus class
      Util.toggleClass(choiceBtn.btns[index], 'choice-btn--focus', bool);
    };
  
    //initialize the ChoiceButtons objects
    window.choiceButtonInit = function(){
      var choiceButton = document.getElementsByClassName('js-choice-btns');
      if( choiceButton.length > 0 ) {
        for( var i = 0; i < choiceButton.length; i++) {
          (function(i){new ChoiceButton(choiceButton[i]);})(i);
        }
      };
    }    
}());
// File#: _1_date-picker
// Usage: codyhouse.co/license
(function() {
    var DatePicker = function(opts) {
      this.options = Util.extend(DatePicker.defaults , opts);
      this.element = this.options.element;
      this.input = this.element.getElementsByClassName('js-date-input__text')[0];
      this.trigger = this.element.getElementsByClassName('js-date-input__trigger')[0];
      this.triggerLabel = this.trigger.getAttribute('aria-label');
      this.datePicker = this.element.getElementsByClassName('js-date-picker')[0];
      this.body = this.datePicker.getElementsByClassName('js-date-picker__dates')[0];
      this.navigation = this.datePicker.getElementsByClassName('js-date-picker__month-nav')[0];
      this.heading = this.datePicker.getElementsByClassName('js-date-picker__month-label')[0];
      this.pickerVisible = false;
      // date format
      this.dateIndexes = getDateIndexes(this); // store indexes of date parts (d, m, y)
      // set initial date
      resetCalendar(this);
      // selected date
      this.dateSelected = false;
      this.selectedDay = false;
      this.selectedMonth = false;
      this.selectedYear = false;
      // focus trap
      this.firstFocusable = false;
      this.lastFocusable = false;
      // date value - for custom control variation
      this.dateValueEl = this.element.getElementsByClassName('js-date-input__value');
      if(this.dateValueEl.length > 0) {
        this.dateValueLabelInit = this.dateValueEl[0].textContent; // initial input value
      }
      initCalendarAria(this);
      initCalendarEvents(this);
      // place picker according to available space
      placeCalendar(this);
    };
  
    DatePicker.prototype.showCalendar = function() {
      showCalendar(this);
    };
  
    DatePicker.prototype.showNextMonth = function() {
      showNext(this, true);
    };
  
    DatePicker.prototype.showPrevMonth = function() {
      showPrev(this, true);
    };
  
    function initCalendarAria(datePicker) {
      // reset calendar button label
      resetLabelCalendarTrigger(datePicker);
      if(datePicker.dateValueEl.length > 0) {
        resetCalendar(datePicker);
        resetLabelCalendarValue(datePicker);
      }
      // create a live region used to announce new month selection to SR
      var srLiveReagion = document.createElement('div');
      srLiveReagion.setAttribute('aria-live', 'polite');
      Util.addClass(srLiveReagion, 'sr-only js-date-input__sr-live');
      datePicker.element.appendChild(srLiveReagion);
      datePicker.srLiveReagion = datePicker.element.getElementsByClassName('js-date-input__sr-live')[0];
    };
  
    function initCalendarEvents(datePicker) {
      datePicker.input.addEventListener('focus', function(event){
        toggleCalendar(datePicker, true); // toggle calendar when focus is on input
      });
      if(datePicker.trigger) {
        datePicker.trigger.addEventListener('click', function(event){ // open calendar when clicking on calendar button
          event.preventDefault();
          datePicker.pickerVisible = false;
          toggleCalendar(datePicker);
          datePicker.trigger.setAttribute('aria-expanded', 'true');
        });
      }
  
      // select a date inside the date picker
      datePicker.body.addEventListener('click', function(event){
        event.preventDefault();
        var day = event.target.closest('button');
        if(day) {
          datePicker.dateSelected = true;
          datePicker.selectedDay = day.innerText;
          datePicker.selectedMonth = datePicker.currentMonth;
          datePicker.selectedYear = datePicker.currentYear;
          setInputValue(datePicker);
          datePicker.input.focus(); // focus on the input element and close picker
          resetLabelCalendarTrigger(datePicker);
          resetLabelCalendarValue(datePicker);
        }
      });
  
      // navigate using month nav
      datePicker.navigation.addEventListener('click', function(event){
        event.preventDefault();
        var btn = event.target.closest('.js-date-picker__month-nav-btn');
        if(btn) {
          Util.hasClass(btn, 'js-date-picker__month-nav-btn--prev') ? showPrev(datePicker, true) : showNext(datePicker, true);
        }
      });
  
      // hide calendar
      window.addEventListener('keydown', function(event){ // close calendar on esc
        if(event.keyCode && event.keyCode == 27 || event.key && event.key.toLowerCase() == 'escape') {
          if(document.activeElement.closest('.js-date-picker')) {
            datePicker.input.focus(); //if focus is inside the calendar -> move the focus to the input element 
          } else { // do not move focus -> only close calendar
            hideCalendar(datePicker); 
          }
        }
      });
      window.addEventListener('click', function(event){
        if(!event.target.closest('.js-date-picker') && !event.target.closest('.js-date-input') && datePicker.pickerVisible) {
          hideCalendar(datePicker);
        }
      });
  
      // navigate through days of calendar
      datePicker.body.addEventListener('keydown', function(event){
        var day = datePicker.currentDay;
        if(event.keyCode && event.keyCode == 40 || event.key && event.key.toLowerCase() == 'arrowdown') {
          day = day + 7;
          resetDayValue(day, datePicker);
        } else if(event.keyCode && event.keyCode == 39 || event.key && event.key.toLowerCase() == 'arrowright') {
          day = day + 1;
          resetDayValue(day, datePicker);
        } else if(event.keyCode && event.keyCode == 37 || event.key && event.key.toLowerCase() == 'arrowleft') {
          day = day - 1;
          resetDayValue(day, datePicker);
        } else if(event.keyCode && event.keyCode == 38 || event.key && event.key.toLowerCase() == 'arrowup') {
          day = day - 7;
          resetDayValue(day, datePicker);
        } else if(event.keyCode && event.keyCode == 35 || event.key && event.key.toLowerCase() == 'end') { // move focus to last day of week
          event.preventDefault();
          day = day + 6 - getDayOfWeek(datePicker.currentYear, datePicker.currentMonth, day);
          resetDayValue(day, datePicker);
        } else if(event.keyCode && event.keyCode == 36 || event.key && event.key.toLowerCase() == 'home') { // move focus to first day of week
          event.preventDefault();
          day = day - getDayOfWeek(datePicker.currentYear, datePicker.currentMonth, day);
          resetDayValue(day, datePicker);
        } else if(event.keyCode && event.keyCode == 34 || event.key && event.key.toLowerCase() == 'pagedown') {
          event.preventDefault();
          showNext(datePicker); // show next month
        } else if(event.keyCode && event.keyCode == 33 || event.key && event.key.toLowerCase() == 'pageup') {
          event.preventDefault();
          showPrev(datePicker); // show prev month
        }
      });
  
      // trap focus inside calendar
      datePicker.datePicker.addEventListener('keydown', function(event){
        if( event.keyCode && event.keyCode == 9 || event.key && event.key == 'Tab' ) {
          //trap focus inside modal
          trapFocus(event, datePicker);
        }
      });
  
      datePicker.input.addEventListener('keydown', function(event){
        if(event.keyCode && event.keyCode == 13 || event.key && event.key.toLowerCase() == 'enter') {
          // update calendar on input enter
          resetCalendar(datePicker);
          resetLabelCalendarTrigger(datePicker);
          resetLabelCalendarValue(datePicker);
          hideCalendar(datePicker);
        } else if(event.keyCode && event.keyCode == 40 || event.key && event.key.toLowerCase() == 'arrowdown' && datePicker.pickerVisible) { // move focus to calendar using arrow down
          datePicker.body.querySelector('button[tabindex="0"]').focus();
        };
      });
    };
  
    function getCurrentDay(date) {
      return (date) 
        ? getDayFromDate(date)
        : new Date().getDate();
    };
  
    function getCurrentMonth(date) {
      return (date) 
        ? getMonthFromDate(date)
        : new Date().getMonth();
    };
  
    function getCurrentYear(date) {
      return (date) 
        ? getYearFromDate(date)
        : new Date().getFullYear();
    };
  
    function getDayFromDate(date) {
      var day = parseInt(date.split('-')[2]);
      return isNaN(day) ? getCurrentDay(false) : day;
    };
  
    function getMonthFromDate(date) {
      var month = parseInt(date.split('-')[1]) - 1;
      return isNaN(month) ? getCurrentMonth(false) : month;
    };
  
    function getYearFromDate(date) {
      var year = parseInt(date.split('-')[0]);
      return isNaN(year) ? getCurrentYear(false) : year;
    };
  
    function showNext(datePicker, bool) {
      // show next month
      datePicker.currentYear = (datePicker.currentMonth === 11) ? datePicker.currentYear + 1 : datePicker.currentYear;
      datePicker.currentMonth = (datePicker.currentMonth + 1) % 12;
      datePicker.currentDay = checkDayInMonth(datePicker);
      showCalendar(datePicker, bool);
      datePicker.srLiveReagion.textContent = datePicker.options.months[datePicker.currentMonth] + ' ' + datePicker.currentYear;
    };
  
    function showPrev(datePicker, bool) {
      // show prev month
      datePicker.currentYear = (datePicker.currentMonth === 0) ? datePicker.currentYear - 1 : datePicker.currentYear;
      datePicker.currentMonth = (datePicker.currentMonth === 0) ? 11 : datePicker.currentMonth - 1;
      datePicker.currentDay = checkDayInMonth(datePicker);
      showCalendar(datePicker, bool);
      datePicker.srLiveReagion.textContent = datePicker.options.months[datePicker.currentMonth] + ' ' + datePicker.currentYear;
    };
  
    function checkDayInMonth(datePicker) {
      return (datePicker.currentDay > daysInMonth(datePicker.currentYear, datePicker.currentMonth)) ? 1 : datePicker.currentDay;
    };
  
    function daysInMonth(year, month) {
      return 32 - new Date(year, month, 32).getDate();
    };
  
    function resetCalendar(datePicker) {
      var currentDate = false,
        selectedDate = datePicker.input.value;
  
      datePicker.dateSelected = false;
      if( selectedDate != '') {
        var date = getDateFromInput(datePicker);
        datePicker.dateSelected = true;
        currentDate = date;
      } 
      datePicker.currentDay = getCurrentDay(currentDate);
      datePicker.currentMonth = getCurrentMonth(currentDate); 
      datePicker.currentYear = getCurrentYear(currentDate); 
      
      datePicker.selectedDay = datePicker.dateSelected ? datePicker.currentDay : false;
      datePicker.selectedMonth = datePicker.dateSelected ? datePicker.currentMonth : false;
      datePicker.selectedYear = datePicker.dateSelected ? datePicker.currentYear : false;
    };
  
    function showCalendar(datePicker, bool) {
      // show calendar element
      var firstDay = getDayOfWeek(datePicker.currentYear, datePicker.currentMonth, '01');
      datePicker.body.innerHTML = '';
      datePicker.heading.innerHTML = datePicker.options.months[datePicker.currentMonth] + ' ' + datePicker.currentYear;
  
      // creating all cells
      var date = 1,
        calendar = '';
      for (var i = 0; i < 6; i++) {
        for (var j = 0; j < 7; j++) {
          if (i === 0 && j < firstDay) {
            calendar = calendar + '<li></li>';
          } else if (date > daysInMonth(datePicker.currentYear, datePicker.currentMonth)) {
            break;
          } else {
            var classListDate = '',
              tabindexValue = '-1';
            if (date === datePicker.currentDay) {
              tabindexValue = '0';
            } 
            if(!datePicker.dateSelected && getCurrentMonth() == datePicker.currentMonth && getCurrentYear() == datePicker.currentYear && date == getCurrentDay()){
              classListDate = classListDate+' date-picker__date--today'
            }
            if (datePicker.dateSelected && date === datePicker.selectedDay && datePicker.currentYear === datePicker.selectedYear && datePicker.currentMonth === datePicker.selectedMonth) {
              classListDate = classListDate+'  date-picker__date--selected';
            }
            calendar = calendar + '<li><button class="date-picker__date'+classListDate+'" tabindex="'+tabindexValue+'">'+date+'</button></li>';
            date++;
          }
        }
      }
      datePicker.body.innerHTML = calendar; // appending days into calendar body
      
      // show calendar
      if(!datePicker.pickerVisible) Util.addClass(datePicker.datePicker, 'date-picker--is-visible');
      datePicker.pickerVisible = true;
  
      //  if bool is false, move focus to calendar day
      if(!bool) datePicker.body.querySelector('button[tabindex="0"]').focus();
  
      // store first/last focusable elements
      getFocusableElements(datePicker);
  
      //place calendar
      placeCalendar(datePicker);
    };
  
    function hideCalendar(datePicker) {
      Util.removeClass(datePicker.datePicker, 'date-picker--is-visible');
      datePicker.pickerVisible = false;
  
      // reset first/last focusable
      datePicker.firstFocusable = false;
      datePicker.lastFocusable = false;
  
      // reset trigger aria-expanded attribute
      if(datePicker.trigger) datePicker.trigger.setAttribute('aria-expanded', 'false');
    };
  
    function toggleCalendar(datePicker, bool) {
      if(!datePicker.pickerVisible) {
        resetCalendar(datePicker);
        showCalendar(datePicker, bool);
      } else {
        hideCalendar(datePicker);
      }
    };
  
    function getDayOfWeek(year, month, day) {
      var weekDay = (new Date(year, month, day)).getDay() - 1;
      if(weekDay < 0) weekDay = 6;
      return weekDay;
    };
  
    function getDateIndexes(datePicker) {
      var dateFormat = datePicker.options.dateFormat.toLowerCase().replace(/-/g, '');
      return [dateFormat.indexOf('d'), dateFormat.indexOf('m'), dateFormat.indexOf('y')];
    };
  
    function setInputValue(datePicker) {
      datePicker.input.value = getDateForInput(datePicker);
    };
  
    function getDateForInput(datePicker) {
      var dateArray = [];
      dateArray[datePicker.dateIndexes[0]] = getReadableDate(datePicker.selectedDay);
      dateArray[datePicker.dateIndexes[1]] = getReadableDate(datePicker.selectedMonth+1);
      dateArray[datePicker.dateIndexes[2]] = datePicker.selectedYear;
      return dateArray[0]+datePicker.options.dateSeparator+dateArray[1]+datePicker.options.dateSeparator+dateArray[2];
    };
  
    function getDateFromInput(datePicker) {
      var dateArray = datePicker.input.value.split(datePicker.options.dateSeparator);
      return dateArray[datePicker.dateIndexes[2]]+'-'+dateArray[datePicker.dateIndexes[1]]+'-'+dateArray[datePicker.dateIndexes[0]];
    };
  
    function getReadableDate(date) {
      return (date < 10) ? '0'+date : date;
    };
  
    function resetDayValue(day, datePicker) {
      var totDays = daysInMonth(datePicker.currentYear, datePicker.currentMonth);
      if( day > totDays) {
        datePicker.currentDay = day - totDays;
        showNext(datePicker, false);
      } else if(day < 1) {
        var newMonth = datePicker.currentMonth == 0 ? 11 : datePicker.currentMonth - 1;
        datePicker.currentDay = daysInMonth(datePicker.currentYear, newMonth) + day;
        showPrev(datePicker, false);
      } else {
        datePicker.currentDay = day;
        datePicker.body.querySelector('button[tabindex="0"]').setAttribute('tabindex', '-1');
        // set new tabindex to selected item
        var buttons = datePicker.body.getElementsByTagName("button");
        for (var i = 0; i < buttons.length; i++) {
          if (buttons[i].textContent == datePicker.currentDay) {
            buttons[i].setAttribute('tabindex', '0');
            buttons[i].focus();
            break;
          }
        }
        getFocusableElements(datePicker); // update first focusable/last focusable element
      }
    };
  
    function resetLabelCalendarTrigger(datePicker) {
      if(!datePicker.trigger) return;
      // reset accessible label of the calendar trigger
      (datePicker.selectedYear && datePicker.selectedMonth && datePicker.selectedDay) 
        ? datePicker.trigger.setAttribute('aria-label', datePicker.triggerLabel+', selected date is '+ new Date(datePicker.selectedYear, datePicker.selectedMonth, datePicker.selectedDay).toDateString())
        : datePicker.trigger.setAttribute('aria-label', datePicker.triggerLabel);
    };
  
    function resetLabelCalendarValue(datePicker) {
      // this is used for the --custom-control variation -> there's a label that should be updated with the selected date
      if(datePicker.dateValueEl.length < 1) return;
      (datePicker.selectedYear && datePicker.selectedMonth && datePicker.selectedDay) 
        ? datePicker.dateValueEl[0].textContent = getDateForInput(datePicker)
        : datePicker.dateValueEl[0].textContent = datePicker.dateValueLabelInit;
    };
  
    function getFocusableElements(datePicker) {
      var allFocusable = datePicker.datePicker.querySelectorAll('[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, [tabindex]:not([tabindex="-1"]), [contenteditable], audio[controls], video[controls], summary');
      getFirstFocusable(allFocusable, datePicker);
      getLastFocusable(allFocusable, datePicker);
    }
  
    function getFirstFocusable(elements, datePicker) {
      for(var i = 0; i < elements.length; i++) {
        if( (elements[i].offsetWidth || elements[i].offsetHeight || elements[i].getClientRects().length) &&  elements[i].getAttribute('tabindex') != '-1') {
          datePicker.firstFocusable = elements[i];
          return true;
        }
      }
    };
  
    function getLastFocusable(elements, datePicker) {
      //get last visible focusable element inside the modal
      for(var i = elements.length - 1; i >= 0; i--) {
        if( (elements[i].offsetWidth || elements[i].offsetHeight || elements[i].getClientRects().length) &&  elements[i].getAttribute('tabindex') != '-1' ) {
          datePicker.lastFocusable = elements[i];
          return true;
        }
      }
    };
  
    function trapFocus(event, datePicker) {
      if( datePicker.firstFocusable == document.activeElement && event.shiftKey) {
        //on Shift+Tab -> focus last focusable element when focus moves out of calendar
        event.preventDefault();
        datePicker.lastFocusable.focus();
      }
      if( datePicker.lastFocusable == document.activeElement && !event.shiftKey) {
        //on Tab -> focus first focusable element when focus moves out of calendar
        event.preventDefault();
        datePicker.firstFocusable.focus();
      }
    };
  
    function placeCalendar(datePicker) {
      // reset position
      datePicker.datePicker.style.left = '0px';
      datePicker.datePicker.style.right = 'auto';
      
      //check if you need to modify the calendar postion
      var pickerBoundingRect = datePicker.datePicker.getBoundingClientRect();
  
      if(pickerBoundingRect.right > window.innerWidth) {
        datePicker.datePicker.style.left = 'auto';
        datePicker.datePicker.style.right = '0px';
      }
    };
  
    DatePicker.defaults = {
      element : '',
      months: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
      dateFormat: 'd-m-y',
      dateSeparator: '/'
    };
  
    window.DatePicker = DatePicker;
  
    var datePicker = document.getElementsByClassName('js-date-input'),
      flexSupported = Util.cssSupports('align-items', 'stretch');
    if( datePicker.length > 0 ) {
      for( var i = 0; i < datePicker.length; i++) {(function(i){
        if(!flexSupported) {
          Util.addClass(datePicker[i], 'date-input--hide-calendar');
          return;
        }
        var opts = {element: datePicker[i]};
        if(datePicker[i].getAttribute('data-date-format')) {
          opts.dateFormat = datePicker[i].getAttribute('data-date-format');
        }
        if(datePicker[i].getAttribute('data-date-separator')) {
          opts.dateSeparator = datePicker[i].getAttribute('data-date-separator');
        }
        if(datePicker[i].getAttribute('data-months')) {
          opts.months = datePicker[i].getAttribute('data-months').split(',').map(function(item) {return item.trim();});
        }
        new DatePicker(opts);
      })(i);}
    }
  }());
  
  
// File#: _1_diagonal-movement
// Usage: codyhouse.co/license
/*
  Modified version of the jQuery-menu-aim plugin
  https://github.com/kamens/jQuery-menu-aim
  - Replaced jQuery with Vanilla JS
  - Minor changes
*/
(function() {
    var menuAim = function(opts) {
      init(opts);
    };
  
    window.menuAim = menuAim;
  
    function init(opts) {
      var activeRow = null,
        mouseLocs = [],
        lastDelayLoc = null,
        timeoutId = null,
        options = Util.extend({
          menu: '',
          rows: false, //if false, get direct children - otherwise pass nodes list 
          submenuSelector: "*",
          submenuDirection: "right",
          tolerance: 75,  // bigger = more forgivey when entering submenu
          enter: function(){},
          exit: function(){},
          activate: function(){},
          deactivate: function(){},
          exitMenu: function(){}
        }, opts),
        menu = options.menu;
  
      var MOUSE_LOCS_TRACKED = 3,  // number of past mouse locations to track
        DELAY = 300;  // ms delay when user appears to be entering submenu
  
      /**
       * Keep track of the last few locations of the mouse.
       */
      var mousemoveDocument = function(e) {
        mouseLocs.push({x: e.pageX, y: e.pageY});
  
        if (mouseLocs.length > MOUSE_LOCS_TRACKED) {
          mouseLocs.shift();
        }
      };
  
      /**
       * Cancel possible row activations when leaving the menu entirely
       */
      var mouseleaveMenu = function() {
        if (timeoutId) {
          clearTimeout(timeoutId);
        }
  
        // If exitMenu is supplied and returns true, deactivate the
        // currently active row on menu exit.
        if (options.exitMenu(this)) {
          if (activeRow) {
            options.deactivate(activeRow);
          }
  
          activeRow = null;
        }
      };
  
      /**
       * Trigger a possible row activation whenever entering a new row.
       */
      var mouseenterRow = function() {
        if (timeoutId) {
          // Cancel any previous activation delays
          clearTimeout(timeoutId);
        }
  
        options.enter(this);
        possiblyActivate(this);
      },
      mouseleaveRow = function() {
        options.exit(this);
      };
  
      /*
       * Immediately activate a row if the user clicks on it.
       */
      var clickRow = function() {
        activate(this);
      };  
  
      /**
       * Activate a menu row.
       */
      var activate = function(row) {
        if (row == activeRow) {
          return;
        }
  
        if (activeRow) {
          options.deactivate(activeRow);
        }
  
        options.activate(row);
        activeRow = row;
      };
  
      /**
       * Possibly activate a menu row. If mouse movement indicates that we
       * shouldn't activate yet because user may be trying to enter
       * a submenu's content, then delay and check again later.
       */
      var possiblyActivate = function(row) {
        var delay = activationDelay();
  
        if (delay) {
          timeoutId = setTimeout(function() {
            possiblyActivate(row);
          }, delay);
        } else {
          activate(row);
        }
      };
  
      /**
       * Return the amount of time that should be used as a delay before the
       * currently hovered row is activated.
       *
       * Returns 0 if the activation should happen immediately. Otherwise,
       * returns the number of milliseconds that should be delayed before
       * checking again to see if the row should be activated.
       */
      var activationDelay = function() {
        if (!activeRow || !Util.is(activeRow, options.submenuSelector)) {
          // If there is no other submenu row already active, then
          // go ahead and activate immediately.
          return 0;
        }
  
        function getOffset(element) {
          var rect = element.getBoundingClientRect();
          return { top: rect.top + window.pageYOffset, left: rect.left + window.pageXOffset };
        };
  
        var offset = getOffset(menu),
            upperLeft = {
                x: offset.left,
                y: offset.top - options.tolerance
            },
            upperRight = {
                x: offset.left + menu.offsetWidth,
                y: upperLeft.y
            },
            lowerLeft = {
                x: offset.left,
                y: offset.top + menu.offsetHeight + options.tolerance
            },
            lowerRight = {
                x: offset.left + menu.offsetWidth,
                y: lowerLeft.y
            },
            loc = mouseLocs[mouseLocs.length - 1],
            prevLoc = mouseLocs[0];
  
        if (!loc) {
          return 0;
        }
  
        if (!prevLoc) {
          prevLoc = loc;
        }
  
        if (prevLoc.x < offset.left || prevLoc.x > lowerRight.x || prevLoc.y < offset.top || prevLoc.y > lowerRight.y) {
          // If the previous mouse location was outside of the entire
          // menu's bounds, immediately activate.
          return 0;
        }
  
        if (lastDelayLoc && loc.x == lastDelayLoc.x && loc.y == lastDelayLoc.y) {
          // If the mouse hasn't moved since the last time we checked
          // for activation status, immediately activate.
          return 0;
        }
  
        // Detect if the user is moving towards the currently activated
        // submenu.
        //
        // If the mouse is heading relatively clearly towards
        // the submenu's content, we should wait and give the user more
        // time before activating a new row. If the mouse is heading
        // elsewhere, we can immediately activate a new row.
        //
        // We detect this by calculating the slope formed between the
        // current mouse location and the upper/lower right points of
        // the menu. We do the same for the previous mouse location.
        // If the current mouse location's slopes are
        // increasing/decreasing appropriately compared to the
        // previous's, we know the user is moving toward the submenu.
        //
        // Note that since the y-axis increases as the cursor moves
        // down the screen, we are looking for the slope between the
        // cursor and the upper right corner to decrease over time, not
        // increase (somewhat counterintuitively).
        function slope(a, b) {
          return (b.y - a.y) / (b.x - a.x);
        };
  
        var decreasingCorner = upperRight,
          increasingCorner = lowerRight;
  
        // Our expectations for decreasing or increasing slope values
        // depends on which direction the submenu opens relative to the
        // main menu. By default, if the menu opens on the right, we
        // expect the slope between the cursor and the upper right
        // corner to decrease over time, as explained above. If the
        // submenu opens in a different direction, we change our slope
        // expectations.
        if (options.submenuDirection == "left") {
          decreasingCorner = lowerLeft;
          increasingCorner = upperLeft;
        } else if (options.submenuDirection == "below") {
          decreasingCorner = lowerRight;
          increasingCorner = lowerLeft;
        } else if (options.submenuDirection == "above") {
          decreasingCorner = upperLeft;
          increasingCorner = upperRight;
        }
  
        var decreasingSlope = slope(loc, decreasingCorner),
          increasingSlope = slope(loc, increasingCorner),
          prevDecreasingSlope = slope(prevLoc, decreasingCorner),
          prevIncreasingSlope = slope(prevLoc, increasingCorner);
  
        if (decreasingSlope < prevDecreasingSlope && increasingSlope > prevIncreasingSlope) {
          // Mouse is moving from previous location towards the
          // currently activated submenu. Delay before activating a
          // new menu row, because user may be moving into submenu.
          lastDelayLoc = loc;
          return DELAY;
        }
  
        lastDelayLoc = null;
        return 0;
      };
  
      /**
       * Hook up initial menu events
       */
      menu.addEventListener('mouseleave', mouseleaveMenu);  
      var rows = (options.rows) ? options.rows : menu.children;
      if(rows.length > 0) {
        for(var i = 0; i < rows.length; i++) {(function(i){
          rows[i].addEventListener('mouseenter', mouseenterRow);  
          rows[i].addEventListener('mouseleave', mouseleaveRow);
          rows[i].addEventListener('click', clickRow);  
        })(i);}
      }
  
      document.addEventListener('mousemove', function(event){
      (!window.requestAnimationFrame) ? mousemoveDocument(event) : window.requestAnimationFrame(function(){mousemoveDocument(event);});
      });
    };
  }());
  
  
// File#: _1_filter-navigation
// Usage: codyhouse.co/license
(function() {
    var FilterNav = function(element) {
      this.element = element;
      this.wrapper = this.element.getElementsByClassName('js-filter-nav__wrapper')[0];
      this.nav = this.element.getElementsByClassName('js-filter-nav__nav')[0];
      this.list = this.nav.getElementsByClassName('js-filter-nav__list')[0];
      this.control = this.element.getElementsByClassName('js-filter-nav__control')[0];
      this.modalClose = this.element.getElementsByClassName('js-filter-nav__close-btn')[0];
      this.placeholder = this.element.getElementsByClassName('js-filter-nav__placeholder')[0];
      this.marker = this.element.getElementsByClassName('js-filter-nav__marker');
      this.layout = 'expanded';
      initFilterNav(this);
    };
  
    function initFilterNav(element) {
      checkLayout(element); // init layout
      if(element.layout == 'expanded') placeMarker(element);
      element.element.addEventListener('update-layout', function(event){ // on resize - modify layout
        checkLayout(element);
      });
  
      // update selected item
      element.wrapper.addEventListener('click', function(event){
        var newItem = event.target.closest('.js-filter-nav__btn');
        if(newItem) {
          updateCurrentItem(element, newItem);
          return;
        }
        // close modal list - mobile version only
        if(Util.hasClass(event.target, 'js-filter-nav__wrapper') || event.target.closest('.js-filter-nav__close-btn')) toggleModalList(element, false);
      });
  
      // open modal list - mobile version only
      element.control.addEventListener('click', function(event){
        toggleModalList(element, true);
      });
      
      // listen for key events
      window.addEventListener('keyup', function(event){
        // listen for esc key
        if( (event.keyCode && event.keyCode == 27) || (event.key && event.key.toLowerCase() == 'escape' )) {
          // close navigation on mobile if open
          if(element.control.getAttribute('aria-expanded') == 'true' && isVisible(element.control)) {
            toggleModalList(element, false);
          }
        }
        // listen for tab key
        if( (event.keyCode && event.keyCode == 9) || (event.key && event.key.toLowerCase() == 'tab' )) {
          // close navigation on mobile if open when nav loses focus
          if(element.control.getAttribute('aria-expanded') == 'true' && isVisible(element.control) && !document.activeElement.closest('.js-filter-nav__wrapper')) toggleModalList(element, false);
        }
      });
    };
  
    function updateCurrentItem(element, btn) {
      if(btn.getAttribute('aria-current') == 'true') {
        toggleModalList(element, false);
        return;
      }
      var activeBtn = element.wrapper.querySelector('[aria-current]');
      if(activeBtn) activeBtn.removeAttribute('aria-current');
      btn.setAttribute('aria-current', 'true');
      // update trigger label on selection (visible on mobile only)
      element.placeholder.textContent = btn.textContent;
      toggleModalList(element, false);
      if(element.layout == 'expanded') placeMarker(element);
    };
  
    function toggleModalList(element, bool) {
      element.control.setAttribute('aria-expanded', bool);
      Util.toggleClass(element.wrapper, 'filter-nav__wrapper--is-visible', bool);
      if(bool) {
        element.nav.querySelectorAll('[href], button:not([disabled])')[0].focus();
      } else if(isVisible(element.control)) {
        element.control.focus();
      }
    };
  
    function isVisible(element) {
      return (element.offsetWidth || element.offsetHeight || element.getClientRects().length);
    };
  
    function checkLayout(element) {
      if(element.layout == 'expanded' && switchToCollapsed(element)) { // check if there's enough space 
        element.layout = 'collapsed';
        Util.removeClass(element.element, 'filter-nav--expanded');
        Util.addClass(element.element, 'filter-nav--collapsed');
        Util.removeClass(element.modalClose, 'is-hidden');
        Util.removeClass(element.control, 'is-hidden');
      } else if(element.layout == 'collapsed' && switchToExpanded(element)) {
        element.layout = 'expanded';
        Util.addClass(element.element, 'filter-nav--expanded');
        Util.removeClass(element.element, 'filter-nav--collapsed');
        Util.addClass(element.modalClose, 'is-hidden');
        Util.addClass(element.control, 'is-hidden');
      }
      // place background element
      if(element.layout == 'expanded') placeMarker(element);
    };
  
    function switchToCollapsed(element) {
      return element.nav.scrollWidth > element.nav.offsetWidth;
    };
  
    function switchToExpanded(element) {
      element.element.style.visibility = 'hidden';
      Util.addClass(element.element, 'filter-nav--expanded');
      Util.removeClass(element.element, 'filter-nav--collapsed');
      var switchLayout = element.nav.scrollWidth <= element.nav.offsetWidth;
      Util.removeClass(element.element, 'filter-nav--expanded');
      Util.addClass(element.element, 'filter-nav--collapsed');
      element.element.style.visibility = 'visible';
      return switchLayout;
    };
  
    function placeMarker(element) {
      var activeElement = element.wrapper.querySelector('.js-filter-nav__btn[aria-current="true"]');
      if(element.marker.length == 0 || !activeElement ) return;
      element.marker[0].style.width = activeElement.offsetWidth+'px';
      element.marker[0].style.transform = 'translateX('+(activeElement.getBoundingClientRect().left - element.list.getBoundingClientRect().left)+'px)';
    };
  
    var filterNav = document.getElementsByClassName('js-filter-nav');
    if(filterNav.length > 0) {
      var filterNavArray = [];
      for(var i = 0; i < filterNav.length; i++) {
        filterNavArray.push(new FilterNav(filterNav[i]));
      }
  
      var resizingId = false,
        customEvent = new CustomEvent('update-layout');
  
      window.addEventListener('resize', function() {
        clearTimeout(resizingId);
        resizingId = setTimeout(doneResizing, 100);
      });
  
      // wait for font to be loaded
      document.fonts.onloadingdone = function (fontFaceSetEvent) {
        doneResizing();
      };
  
      function doneResizing() {
        for( var i = 0; i < filterNavArray.length; i++) {
          (function(i){filterNavArray[i].element.dispatchEvent(customEvent)})(i);
        };
      };
    }
  }());
// File#: _1_filter
// Usage: codyhouse.co/license

(function() {
    var Filter = function(opts) {
      this.options = Util.extend(Filter.defaults , opts); // used to store custom filter/sort functions
      this.element = this.options.element;
      this.elementId = this.element.getAttribute('id');
      this.items = this.element.querySelectorAll('.js-filter__item');
      this.controllers = document.querySelectorAll('[aria-controls="'+this.elementId+'"]'); // controllers wrappers
      this.fallbackMessage = document.querySelector('[data-fallback-gallery-id="'+this.elementId+'"]');
      this.filterString = []; // combination of different filter values
      this.sortingString = '';  // sort value - will include order and type of argument (e.g., number or string)
      // store info about sorted/filtered items
      this.filterList = []; // list of boolean for each this.item -> true if still visible , otherwise false
      this.sortingList = []; // list of new ordered this.item -> each element is [item, originalIndex]
      
      // store grid info for animation
      this.itemsGrid = []; // grid coordinates
      this.itemsInitPosition = []; // used to store coordinates of this.items before animation
      this.itemsIterPosition = []; // used to store coordinates of this.items before animation - intermediate state
      this.itemsFinalPosition = []; // used to store coordinates of this.items after filtering
      
      // animation off
      this.animateOff = this.element.getAttribute('data-filter-animation') == 'off';
      // used to update this.itemsGrid on resize
      this.resizingId = false;
      // default acceleration style - improve animation
      this.accelerateStyle = 'will-change: transform, opacity; transform: translateZ(0); backface-visibility: hidden;';
  
      // handle multiple changes
      this.animating = false;
      this.reanimate = false;
  
      initFilter(this);
    };
  
    function initFilter(filter) {
      resetFilterSortArray(filter, true, true); // init array filter.filterList/filter.sortingList
      createGridInfo(filter); // store grid coordinates in filter.itemsGrid
      initItemsOrder(filter); // add data-orders so that we can reset the sorting
  
      // events handling - filter update
      for(var i = 0; i < filter.controllers.length; i++) {
        filter.filterString[i] = ''; // reset filtering
  
        // get proper filter/sorting string based on selected controllers
        (function(i){
          filter.controllers[i].addEventListener('change', function(event) {  
            if(event.target.tagName.toLowerCase() == 'select') { // select elements
              (!event.target.getAttribute('data-filter'))
                ? setSortingString(filter, event.target.value, event.target.options[event.target.selectedIndex])
                : setFilterString(filter, i, 'select');
            } else if(event.target.tagName.toLowerCase() == 'input' && (event.target.getAttribute('type') == 'radio' || event.target.getAttribute('type') == 'checkbox') ) { // input (radio/checkboxed) elements
              (!event.target.getAttribute('data-filter'))
                ? setSortingString(filter, event.target.getAttribute('data-sort'), event.target)
                : setFilterString(filter, i, 'input');
            } else {
              // generic inout element
              (!filter.controllers[i].getAttribute('data-filter'))
                ? setSortingString(filter, filter.controllers[i].getAttribute('data-sort'), filter.controllers[i])
                : setFilterString(filter, i, 'custom');
            }
  
            updateFilterArray(filter);
          });
  
          filter.controllers[i].addEventListener('click', function(event) { // retunr if target is select/input elements
            var filterEl = event.target.closest('[data-filter]');
            var sortEl = event.target.closest('[data-sort]');
            if(!filterEl && !sortEl) return;
            if(filterEl && ( filterEl.tagName.toLowerCase() == 'input' || filterEl.tagName.toLowerCase() == 'select')) return;
            if(sortEl && (sortEl.tagName.toLowerCase() == 'input' || sortEl.tagName.toLowerCase() == 'select')) return;
            if(sortEl && Util.hasClass(sortEl, 'js-filter__custom-control')) return;
            if(filterEl && Util.hasClass(filterEl, 'js-filter__custom-control')) return;
            // this will be executed only for a list of buttons -> no inputs
            event.preventDefault();
            resetControllersList(filter, i, filterEl, sortEl);
            sortEl 
              ? setSortingString(filter, sortEl.getAttribute('data-sort'), sortEl)
              : setFilterString(filter, i, 'button');
            updateFilterArray(filter);
          });
        })(i);
      }
  
      // handle resize - update grid coordinates in filter.itemsGrid
      window.addEventListener('resize', function() {
        clearTimeout(filter.resizingId);
        filter.resizingId = setTimeout(function(){createGridInfo(filter)}, 300);
      });
  
      // check if there are filters/sorting values already set
      checkInitialFiltering(filter);
  
      // reset filtering results if filter selection was changed by an external control (e.g., form reset) 
      filter.element.addEventListener('update-filter-results', function(event){
        // reset filters first
        for(var i = 0; i < filter.controllers.length; i++) filter.filterString[i] = '';
        filter.sortingString = '';
        checkInitialFiltering(filter);
      });
    };
  
    function checkInitialFiltering(filter) {
      for(var i = 0; i < filter.controllers.length; i++) { // check if there's a selected option
        // buttons list
        var selectedButton = filter.controllers[i].getElementsByClassName('js-filter-selected');
        if(selectedButton.length > 0) {
          var sort = selectedButton[0].getAttribute('data-sort');
          sort
            ? setSortingString(filter, selectedButton[0].getAttribute('data-sort'), selectedButton[0])
            : setFilterString(filter, i, 'button');
          continue;
        }
  
        // input list
        var selectedInput = filter.controllers[i].querySelectorAll('input:checked');
        if(selectedInput.length > 0) {
          var sort = selectedInput[0].getAttribute('data-sort');
          sort
            ? setSortingString(filter, sort, selectedInput[0])
            : setFilterString(filter, i, 'input');
          continue;
        }
        // select item
        if(filter.controllers[i].tagName.toLowerCase() == 'select') {
          var sort = filter.controllers[i].getAttribute('data-sort');
          sort
            ? setSortingString(filter, filter.controllers[i].value, filter.controllers[i].options[filter.controllers[i].selectedIndex])
            : setFilterString(filter, i, 'select');
           continue;
        }
        // check if there's a generic custom input
        var radioInput = filter.controllers[i].querySelector('input[type="radio"]'),
          checkboxInput = filter.controllers[i].querySelector('input[type="checkbox"]');
        if(!radioInput && !checkboxInput) {
          var sort = filter.controllers[i].getAttribute('data-sort');
          var filterString = filter.controllers[i].getAttribute('data-filter');
          if(sort) setSortingString(filter, sort, filter.controllers[i]);
          else if(filterString) setFilterString(filter, i, 'custom');
        }
      }
  
      updateFilterArray(filter);
    };
  
    function setSortingString(filter, value, item) { 
      // get sorting string value-> sortName:order:type
      var order = item.getAttribute('data-sort-order') ? 'desc' : 'asc';
      var type = item.getAttribute('data-sort-number') ? 'number' : 'string';
      filter.sortingString = value+':'+order+':'+type;
    };
  
    function setFilterString(filter, index, type) { 
      // get filtering array -> [filter1:filter2, filter3, filter4:filter5]
      if(type == 'input') {
        var checkedInputs = filter.controllers[index].querySelectorAll('input:checked');
        filter.filterString[index] = '';
        for(var i = 0; i < checkedInputs.length; i++) {
          filter.filterString[index] = filter.filterString[index] + checkedInputs[i].getAttribute('data-filter') + ':';
        }
      } else if(type == 'select') {
        if(filter.controllers[index].multiple) { // select with multiple options
          filter.filterString[index] = getMultipleSelectValues(filter.controllers[index]);
        } else { // select with single option
          filter.filterString[index] = filter.controllers[index].value;
        }
      } else if(type == 'button') {
        var selectedButtons = filter.controllers[index].querySelectorAll('.js-filter-selected');
        filter.filterString[index] = '';
        for(var i = 0; i < selectedButtons.length; i++) {
          filter.filterString[index] = filter.filterString[index] + selectedButtons[i].getAttribute('data-filter') + ':';
        }
      } else if(type == 'custom') {
        filter.filterString[index] = filter.controllers[index].getAttribute('data-filter');
      }
    };
  
    function resetControllersList(filter, index, target1, target2) {
      // for a <button>s list -> toggle js-filter-selected + custom classes
      var multi = filter.controllers[index].getAttribute('data-filter-checkbox'),
        customClass = filter.controllers[index].getAttribute('data-selected-class');
      
      customClass = (customClass) ? 'js-filter-selected '+ customClass : 'js-filter-selected';
      if(multi == 'true') { // multiple options can be on
        (target1) 
          ? Util.toggleClass(target1, customClass, !Util.hasClass(target1, 'js-filter-selected'))
          : Util.toggleClass(target2, customClass, !Util.hasClass(target2, 'js-filter-selected'));
      } else { // only one element at the time
        // remove the class from all siblings
        var selectedOption = filter.controllers[index].querySelector('.js-filter-selected');
        if(selectedOption) Util.removeClass(selectedOption, customClass);
        (target1) 
          ? Util.addClass(target1, customClass)
          : Util.addClass(target2, customClass);
      }
    };
  
    function updateFilterArray(filter) { // sort/filter strings have been updated -> so you can update the gallery
      if(filter.animating) {
        filter.reanimate = true;
        return;
      }
      filter.animating = true;
      filter.reanimate = false;
      createGridInfo(filter); // get new grid coordinates
      sortingGallery(filter); // update sorting list 
      filteringGallery(filter); // update filter list
      resetFallbackMessage(filter, true); // toggle fallback message
      if(reducedMotion || filter.animateOff) {
        resetItems(filter);
      } else {
        updateItemsAttributes(filter);
      }
    };
  
    function sortingGallery(filter) {
      // use sorting string to reorder gallery
      var sortOptions = filter.sortingString.split(':');
      if(sortOptions[0] == '' || sortOptions[0] == '*') {
        // no sorting needed
        restoreSortOrder(filter);
      } else { // need to sort
        if(filter.options[sortOptions[0]]) { // custom sort function -> user takes care of it
          filter.sortingList = filter.options[sortOptions[0]](filter.sortingList);
        } else {
          filter.sortingList.sort(function(left, right) {
            var leftVal = left[0].getAttribute('data-sort-'+sortOptions[0]),
            rightVal = right[0].getAttribute('data-sort-'+sortOptions[0]);
            if(sortOptions[2] == 'number') {
              leftVal = parseFloat(leftVal);
              rightVal = parseFloat(rightVal);
            }
            if(sortOptions[1] == 'desc') return leftVal <= rightVal ? 1 : -1;
            else return leftVal >= rightVal ? 1 : -1;
          });
        }
      }
    };
  
    function filteringGallery(filter) {
      // use filtering string to reorder gallery
      resetFilterSortArray(filter, true, false);
      // we can have multiple filters
      for(var i = 0; i < filter.filterString.length; i++) {
        //check if multiple filters inside the same controller
        if(filter.filterString[i] != '' && filter.filterString[i] != '*' && filter.filterString[i] != ' ') {
          singleFilterGallery(filter, filter.filterString[i].split(':'));
        }
      }
    };
  
    function singleFilterGallery(filter, subfilter) {
      if(!subfilter || subfilter == '' || subfilter == '*') return;
      // check if we have custom options
      var customFilterArray = [];
      for(var j = 0; j < subfilter.length; j++) {
        if(filter.options[subfilter[j]]) { // custom function
          customFilterArray[subfilter[j]] = filter.options[subfilter[j]](filter.items);
        }
      }
  
      for(var i = 0; i < filter.items.length; i++) {
        var filterValues = filter.items[i].getAttribute('data-filter').split(' ');
        var present = false;
        for(var j = 0; j < subfilter.length; j++) {
          if(filter.options[subfilter[j]] && customFilterArray[subfilter[j]][i]) { // custom function
            present = true;
            break;
          } else if(subfilter[j] == '*' || filterValues.indexOf(subfilter[j]) > -1) {
            present = true;
            break;
          }
        }
        filter.filterList[i] = !present ? false : filter.filterList[i];
      }
    };
  
    function updateItemsAttributes(filter) { // set items before triggering the update animation
      // get offset of all elements before animation
      storeOffset(filter, filter.itemsInitPosition);
      // set height of container
      filter.element.setAttribute('style', 'height: '+parseFloat(filter.element.offsetHeight)+'px; width: '+parseFloat(filter.element.offsetWidth)+'px;');
  
      for(var i = 0; i < filter.items.length; i++) { // remove is-hidden class from items now visible and scale to zero
        if( Util.hasClass(filter.items[i], 'is-hidden') && filter.filterList[i]) {
          filter.items[i].setAttribute('data-scale', 'on');
          filter.items[i].setAttribute('style', filter.accelerateStyle+'transform: scale(0.5); opacity: 0;')
          Util.removeClass(filter.items[i], 'is-hidden');
        }
      }
      // get new elements offset
      storeOffset(filter, filter.itemsIterPosition);
      // translate items so that they are in the right initial position
      for(var i = 0; i < filter.items.length; i++) {
        if( filter.items[i].getAttribute('data-scale') != 'on') {
          filter.items[i].setAttribute('style', filter.accelerateStyle+'transform: translateX('+parseInt(filter.itemsInitPosition[i][0] - filter.itemsIterPosition[i][0])+'px) translateY('+parseInt(filter.itemsInitPosition[i][1] - filter.itemsIterPosition[i][1])+'px);');
        }
      }
  
      animateItems(filter)
    };
  
    function animateItems(filter) {
      var transitionValue = 'transform '+filter.options.duration+'ms cubic-bezier(0.455, 0.03, 0.515, 0.955), opacity '+filter.options.duration+'ms';
  
      // get new index of items in the list
      var j = 0;
      for(var i = 0; i < filter.sortingList.length; i++) {
        var item = filter.items[filter.sortingList[i][1]];
          
        if(Util.hasClass(item, 'is-hidden') || !filter.filterList[filter.sortingList[i][1]]) {
          // item is hidden or was previously hidden -> final position equal to first one
          filter.itemsFinalPosition[filter.sortingList[i][1]] = filter.itemsIterPosition[filter.sortingList[i][1]];
          if(item.getAttribute('data-scale') == 'on') j = j + 1; 
        } else {
          filter.itemsFinalPosition[filter.sortingList[i][1]] = [filter.itemsGrid[j][0], filter.itemsGrid[j][1]]; // left/top
          j = j + 1; 
        }
      } 
  
      setTimeout(function(){
        for(var i = 0; i < filter.items.length; i++) {
          if(filter.filterList[i] && filter.items[i].getAttribute('data-scale') == 'on') { // scale up item
            filter.items[i].setAttribute('style', filter.accelerateStyle+'transition: '+transitionValue+'; transform: translateX('+parseInt(filter.itemsFinalPosition[i][0] - filter.itemsIterPosition[i][0])+'px) translateY('+parseInt(filter.itemsFinalPosition[i][1] - filter.itemsIterPosition[i][1])+'px) scale(1); opacity: 1;');
          } else if(filter.filterList[i]) { // translate item
            filter.items[i].setAttribute('style', filter.accelerateStyle+'transition: '+transitionValue+'; transform: translateX('+parseInt(filter.itemsFinalPosition[i][0] - filter.itemsIterPosition[i][0])+'px) translateY('+parseInt(filter.itemsFinalPosition[i][1] - filter.itemsIterPosition[i][1])+'px);');
          } else { // scale down item
            filter.items[i].setAttribute('style', filter.accelerateStyle+'transition: '+transitionValue+'; transform: scale(0.5); opacity: 0;');
          }
        };
      }, 50);  
      
      // wait for the end of transition of visible elements
      setTimeout(function(){
        resetItems(filter);
      }, (filter.options.duration + 100));
    };
  
    function resetItems(filter) {
      // animation was off or animation is over -> reset attributes
      for(var i = 0; i < filter.items.length; i++) {
        filter.items[i].removeAttribute('style');
        Util.toggleClass(filter.items[i], 'is-hidden', !filter.filterList[i]);
        filter.items[i].removeAttribute('data-scale');
      }
      
      for(var i = 0; i < filter.items.length; i++) {// reorder
        filter.element.appendChild(filter.items[filter.sortingList[i][1]]);
      }
  
      filter.items = [];
      filter.items = filter.element.querySelectorAll('.js-filter__item');
      resetFilterSortArray(filter, false, true);
      filter.element.removeAttribute('style');
      filter.animating = false;
      if(filter.reanimate) {
        updateFilterArray(filter);
      }
  
      resetFallbackMessage(filter, false); // toggle fallback message
  
      // emit custom event - end of filtering
      filter.element.dispatchEvent(new CustomEvent('filter-selection-updated'));
    };
  
    function resetFilterSortArray(filter, filtering, sorting) {
      for(var i = 0; i < filter.items.length; i++) {
        if(filtering) filter.filterList[i] = true;
        if(sorting) filter.sortingList[i] = [filter.items[i], i];
      }
    };
  
    function createGridInfo(filter) {
      var containerWidth = parseFloat(window.getComputedStyle(filter.element).getPropertyValue('width')),
        itemStyle, itemWidth, itemHeight, marginX, marginY, colNumber;
  
      // get offset first visible element
      for(var i = 0; i < filter.items.length; i++) {
        if( !Util.hasClass(filter.items[i], 'is-hidden') ) {
          itemStyle = window.getComputedStyle(filter.items[i]),
          itemWidth = parseFloat(itemStyle.getPropertyValue('width')),
          itemHeight = parseFloat(itemStyle.getPropertyValue('height')),
          marginX = parseFloat(itemStyle.getPropertyValue('margin-left')) + parseFloat(itemStyle.getPropertyValue('margin-right')),
          marginY = parseFloat(itemStyle.getPropertyValue('margin-bottom')) + parseFloat(itemStyle.getPropertyValue('margin-top')),
          colNumber = parseInt((containerWidth + marginX)/(itemWidth+marginX));
          filter.itemsGrid[0] = [filter.items[i].offsetLeft, filter.items[i].offsetTop]; // left, top
          break;
        }
      }
  
      for(var i = 1; i < filter.items.length; i++) {
        var x = i < colNumber ? i : i % colNumber,
          y = i < colNumber ? 0 : Math.floor(i/colNumber);
        filter.itemsGrid[i] = [filter.itemsGrid[0][0] + x*(itemWidth+marginX), filter.itemsGrid[0][1] + y*(itemHeight+marginY)];
      }
    };
  
    function storeOffset(filter, array) {
      for(var i = 0; i < filter.items.length; i++) {
        array[i] = [filter.items[i].offsetLeft, filter.items[i].offsetTop];
      }
    };
  
    function initItemsOrder(filter) {
      for(var i = 0; i < filter.items.length; i++) {
        filter.items[i].setAttribute('data-init-sort-order', i);
      }
    };
  
    function restoreSortOrder(filter) {
      for(var i = 0; i < filter.items.length; i++) {
        filter.sortingList[parseInt(filter.items[i].getAttribute('data-init-sort-order'))] = [filter.items[i], i];
      }
    };
  
    function resetFallbackMessage(filter, bool) {
      if(!filter.fallbackMessage) return;
      var show = true;
      for(var i = 0; i < filter.filterList.length; i++) {
        if(filter.filterList[i]) {
          show = false;
          break;
        }
      };
      if(bool) { // reset visibility before animation is triggered
        if(!show) Util.addClass(filter.fallbackMessage, 'is-hidden');
        return;
      }
      Util.toggleClass(filter.fallbackMessage, 'is-hidden', !show);
    };
  
    function getMultipleSelectValues(multipleSelect) {
      // get selected options of a <select multiple> element
      var options = multipleSelect.options,
        value = '';
      for(var i = 0; i < options.length; i++) {
        if(options[i].selected) {
          if(value != '') value = value + ':';
          value = value + options[i].value;
        }
      }
      return value;
    };
  
    Filter.defaults = {
      element : false,
      duration: 400
    };
  
    window.Filter = Filter;
  
    // init Filter object
    var filterGallery = document.getElementsByClassName('js-filter'),
      reducedMotion = Util.osHasReducedMotion();
    if( filterGallery.length > 0 ) {
      for( var i = 0; i < filterGallery.length; i++) {
        var duration = filterGallery[i].getAttribute('data-filter-duration');
        if(!duration) duration = Filter.defaults.duration;
        new Filter({element: filterGallery[i], duration: duration});
      }
    }
  }());
// File#: _1_header
// Usage: codyhouse.co/license
(function() {
    var mainHeader = document.getElementsByClassName('js-header');
    if( mainHeader.length > 0 ) {
      var trigger = mainHeader[0].getElementsByClassName('js-header__trigger')[0],
        nav = mainHeader[0].getElementsByClassName('js-header__nav')[0];
  
      // we'll use these to store the node that needs to receive focus when the mobile menu is closed 
      var focusMenu = false;
  
      //detect click on nav trigger
      trigger.addEventListener("click", function(event) {
        event.preventDefault();
        toggleNavigation(!Util.hasClass(nav, 'header__nav--is-visible'));
      });
  
      // listen for key events
      window.addEventListener('keyup', function(event){
        // listen for esc key
        if( (event.keyCode && event.keyCode == 27) || (event.key && event.key.toLowerCase() == 'escape' )) {
          // close navigation on mobile if open
          if(trigger.getAttribute('aria-expanded') == 'true' && isVisible(trigger)) {
            focusMenu = trigger; // move focus to menu trigger when menu is close
            trigger.click();
          }
        }
        // listen for tab key
        if( (event.keyCode && event.keyCode == 9) || (event.key && event.key.toLowerCase() == 'tab' )) {
          // close navigation on mobile if open when nav loses focus
          if(trigger.getAttribute('aria-expanded') == 'true' && isVisible(trigger) && !document.activeElement.closest('.js-header')) trigger.click();
        }
      });
  
      // listen for resize
      var resizingId = false;
      window.addEventListener('resize', function() {
        clearTimeout(resizingId);
        resizingId = setTimeout(doneResizing, 500);
      });
  
      function doneResizing() {
        if( !isVisible(trigger) && Util.hasClass(mainHeader[0], 'header--expanded')) toggleNavigation(false); 
      };
    }
  
    function isVisible(element) {
      return (element.offsetWidth || element.offsetHeight || element.getClientRects().length);
    };
  
    function toggleNavigation(bool) { // toggle navigation visibility on small device
      Util.toggleClass(nav, 'header__nav--is-visible', bool);
      Util.toggleClass(mainHeader[0], 'header--expanded', bool);
      trigger.setAttribute('aria-expanded', bool);
      if(bool) { //opening menu -> move focus to first element inside nav
        nav.querySelectorAll('[href], input:not([disabled]), button:not([disabled])')[0].focus();
      } else if(focusMenu) {
        focusMenu.focus();
        focusMenu = false;
      }
    };
  }());
// File#: _1_masonry
// Usage: codyhouse.co/license

(function() {
    var Masonry = function(element) {
      this.element = element;
      this.list = this.element.getElementsByClassName('js-masonry__list')[0];
      this.items = this.element.getElementsByClassName('js-masonry__item');
      this.activeColumns = 0;
      this.colStartWidth = 0; // col min-width (defined in CSS using --masonry-col-auto-size variable)
      this.colWidth = 0; // effective column width
      this.colGap = 0;
      // store col heights and items
      this.colHeights = [];
      this.colItems = [];
      // flex full support
      this.flexSupported = checkFlexSupported(this.items[0]);
      getGridLayout(this); // get initial grid params
      setGridLayout(this); // set grid params (width of elements)
      initMasonryLayout(this); // init gallery layout
    };
  
    function checkFlexSupported(item) {
      var itemStyle = window.getComputedStyle(item);
      return itemStyle.getPropertyValue('flex-basis') != 'auto';
    };
  
    function getGridLayout(grid) { // this is used to get initial grid details (width/grid gap)
      var itemStyle = window.getComputedStyle(grid.items[0]);
      if( grid.colStartWidth == 0) {
        grid.colStartWidth = parseFloat(itemStyle.getPropertyValue('width'));
      }
      grid.colGap = parseFloat(itemStyle.getPropertyValue('margin-right'));
    };
  
    function setGridLayout(grid) { // set width of items in the grid
      var contanerWidth = parseFloat(window.getComputedStyle(grid.element).getPropertyValue('width'));
      grid.activeColumns = parseInt((contanerWidth + grid.colGap)/(grid.colStartWidth+grid.colGap));
      if(grid.activeColumns == 0) grid.activeColumns = 1;
      grid.colWidth = parseFloat((contanerWidth - (grid.activeColumns - 1)*grid.colGap)/grid.activeColumns);
      for(var i = 0; i < grid.items.length; i++) {
        grid.items[i].style.width = grid.colWidth+'px'; // reset items width
      }
    };
  
    function initMasonryLayout(grid) {
      if(grid.flexSupported) {
        checkImgLoaded(grid); // reset layout when images are loaded
      } else {
        Util.addClass(grid.element, 'masonry--loaded'); // make sure the gallery is visible
      }
  
      grid.element.addEventListener('masonry-resize', function(){ // window has been resized -> reset masonry layout
        getGridLayout(grid);
        setGridLayout(grid);
        if(grid.flexSupported) layItems(grid); 
      });
  
      grid.element.addEventListener('masonry-reset', function(event){ // reset layout (e.g., new items added to the gallery)
        if(grid.flexSupported) checkImgLoaded(grid); 
      });
    };
  
    function layItems(grid) {
      Util.addClass(grid.element, 'masonry--loaded'); // make sure the gallery is visible
      grid.colHeights = [];
      grid.colItems = [];
  
      // grid layout has already been set -> update container height and order of items
      for(var j = 0; j < grid.activeColumns; j++) {
        grid.colHeights.push(0); // reset col heights
        grid.colItems[j] = []; // reset items order
      }
      
      for(var i = 0; i < grid.items.length; i++) {
        var minHeight = Math.min.apply( Math, grid.colHeights ),
          index = grid.colHeights.indexOf(minHeight);
        grid.colItems[index].push(i);
        grid.items[i].style.flexBasis = 0; // reset flex basis before getting height
        var itemHeight = grid.items[i].getBoundingClientRect().height || grid.items[i].offsetHeight || 1;
        grid.colHeights[index] = grid.colHeights[index] + grid.colGap + itemHeight;
      }
  
      // reset height of container
      var masonryHeight = Math.max.apply( Math, grid.colHeights ) + 5;
      grid.list.style.cssText = 'height: '+ masonryHeight + 'px;';
  
      // go through elements and set flex order
      var order = 0;
      for(var i = 0; i < grid.colItems.length; i++) {
        for(var j = 0; j < grid.colItems[i].length; j++) {
          grid.items[grid.colItems[i][j]].style.order = order;
          order = order + 1;
        }
        // change flex-basis of last element of each column, so that next element shifts to next col
        var lastItemCol = grid.items[grid.colItems[i][grid.colItems[i].length - 1]];
        lastItemCol.style.flexBasis = masonryHeight - grid.colHeights[i] + lastItemCol.getBoundingClientRect().height - 5 + 'px';
      }
  
      // emit custom event when grid has been reset
      grid.element.dispatchEvent(new CustomEvent('masonry-laid'));
    };
  
    function checkImgLoaded(grid) {
      var imgs = grid.list.getElementsByTagName('img');
  
      function countLoaded() {
        var count = 0;
        for(var i = 0; i < imgs.length; i++) {
          if (typeof imgs[i].naturalHeight !== "undefined" && imgs[i].naturalHeight == 0) {
            break;
          }
          count = count+1;
        }
  
        if(count == imgs.length) {
          layItems(grid);
        } else {
          setTimeout(function(){
            countLoaded();
          }, 100);
        }
      };
  
      if(imgs.length == 0) {
        layItems(grid); // no need to wait -> no img available
      } else {
        countLoaded();
      }
    };
  
    //initialize the Masonry objects
    var masonries = document.getElementsByClassName('js-masonry'), 
      flexSupported = Util.cssSupports('flex-basis', 'auto'),
      masonriesArray = [];
  
    if( masonries.length > 0) {
      for( var i = 0; i < masonries.length; i++) {
        if(!flexSupported) {
          Util.addClass(masonries[i], 'masonry--loaded'); // reveal gallery
        } else {
          (function(i){masonriesArray.push(new Masonry(masonries[i]));})(i); // init Masonry Layout
        }
      }
  
      if(!flexSupported) return;
  
      // listen to window resize -> reorganize items in gallery
      var resizingId = false,
        customEvent = new CustomEvent('masonry-resize');
        
      window.addEventListener('resize', function() {
        clearTimeout(resizingId);
        resizingId = setTimeout(doneResizing, 500);
      });
  
      function doneResizing() {
        for( var i = 0; i < masonriesArray.length; i++) {
          (function(i){masonriesArray[i].element.dispatchEvent(customEvent)})(i);
        };
      };
    };
  }());
// File#: _1_menu
// Usage: codyhouse.co/license
(function() {
    var Menu = function(element) {
      this.element = element;
      this.elementId = this.element.getAttribute('id');
      this.menuItems = this.element.getElementsByClassName('js-menu__content');
      this.trigger = document.querySelectorAll('[aria-controls="'+this.elementId+'"]');
      this.selectedTrigger = false;
      this.menuIsOpen = false;
      this.initMenu();
      this.initMenuEvents();
    };	
  
    Menu.prototype.initMenu = function() {
      // init aria-labels
      for(var i = 0; i < this.trigger.length; i++) {
        Util.setAttributes(this.trigger[i], {'aria-expanded': 'false', 'aria-haspopup': 'true'});
      }
      // init tabindex
      for(var i = 0; i < this.menuItems.length; i++) {
        this.menuItems[i].setAttribute('tabindex', '0');
      }
    };
  
    Menu.prototype.initMenuEvents = function() {
      var self = this;
      for(var i = 0; i < this.trigger.length; i++) {(function(i){
        self.trigger[i].addEventListener('click', function(event){
          event.preventDefault();
          // if the menu had been previously opened by another trigger element -> close it first and reopen in the right position
          if(Util.hasClass(self.element, 'menu--is-visible') && self.selectedTrigger !=  self.trigger[i]) {
            self.toggleMenu(false, false); // close menu
          }
          // toggle menu
          self.selectedTrigger = self.trigger[i];
          self.toggleMenu(!Util.hasClass(self.element, 'menu--is-visible'), true);
        });
      })(i);}
      
      // keyboard events
      this.element.addEventListener('keydown', function(event) {
        // use up/down arrow to navigate list of menu items
        if( !Util.hasClass(event.target, 'js-menu__content') ) return;
        if( (event.keyCode && event.keyCode == 40) || (event.key && event.key.toLowerCase() == 'arrowdown') ) {
          self.navigateItems(event, 'next');
        } else if( (event.keyCode && event.keyCode == 38) || (event.key && event.key.toLowerCase() == 'arrowup') ) {
          self.navigateItems(event, 'prev');
        }
      });
    };
  
    Menu.prototype.toggleMenu = function(bool, moveFocus) {
      var self = this;
      // toggle menu visibility
      Util.toggleClass(this.element, 'menu--is-visible', bool);
      this.menuIsOpen = bool;
      if(bool) {
        this.selectedTrigger.setAttribute('aria-expanded', 'true');
        Util.moveFocus(this.menuItems[0]);
        this.element.addEventListener("transitionend", function(event) {Util.moveFocus(self.menuItems[0]);}, {once: true});
        // position the menu element
        this.positionMenu();
        // add class to menu trigger
        Util.addClass(this.selectedTrigger, 'menu-control--active');
      } else if(this.selectedTrigger) {
        this.selectedTrigger.setAttribute('aria-expanded', 'false');
        if(moveFocus) Util.moveFocus(this.selectedTrigger);
        // remove class from menu trigger
        Util.removeClass(this.selectedTrigger, 'menu-control--active');
        this.selectedTrigger = false;
      }
    };
  
    Menu.prototype.positionMenu = function(event, direction) {
      var selectedTriggerPosition = this.selectedTrigger.getBoundingClientRect(),
        menuOnTop = (window.innerHeight - selectedTriggerPosition.bottom) < selectedTriggerPosition.top;
        // menuOnTop = window.innerHeight < selectedTriggerPosition.bottom + this.element.offsetHeight;
        
      var left = selectedTriggerPosition.left,
        right = (window.innerWidth - selectedTriggerPosition.right),
        isRight = (window.innerWidth < selectedTriggerPosition.left + this.element.offsetWidth);
  
      var horizontal = isRight ? 'right: '+right+'px;' : 'left: '+left+'px;',
        vertical = menuOnTop
          ? 'bottom: '+(window.innerHeight - selectedTriggerPosition.top)+'px;'
          : 'top: '+selectedTriggerPosition.bottom+'px;';
      // check right position is correct -> otherwise set left to 0
      if( isRight && (right + this.element.offsetWidth) > window.innerWidth) horizontal = 'left: '+ parseInt((window.innerWidth - this.element.offsetWidth)/2)+'px;';
      var maxHeight = menuOnTop ? selectedTriggerPosition.top - 20 : window.innerHeight - selectedTriggerPosition.bottom - 20;
      this.element.setAttribute('style', horizontal + vertical +'max-height:'+Math.floor(maxHeight)+'px;');
    };
  
    Menu.prototype.navigateItems = function(event, direction) {
      event.preventDefault();
      var index = Util.getIndexInArray(this.menuItems, event.target),
        nextIndex = direction == 'next' ? index + 1 : index - 1;
      if(nextIndex < 0) nextIndex = this.menuItems.length - 1;
      if(nextIndex > this.menuItems.length - 1) nextIndex = 0;
      Util.moveFocus(this.menuItems[nextIndex]);
    };
  
    Menu.prototype.checkMenuFocus = function() {
      var menuParent = document.activeElement.closest('.js-menu');
      if (!menuParent || !this.element.contains(menuParent)) this.toggleMenu(false, false);
    };
  
    Menu.prototype.checkMenuClick = function(target) {
      if( !this.element.contains(target) && !target.closest('[aria-controls="'+this.elementId+'"]')) this.toggleMenu(false);
    };
  
    window.Menu = Menu;
  
    //initialize the Menu objects
    var menus = document.getElementsByClassName('js-menu');
    if( menus.length > 0 ) {
      var menusArray = [];
      var scrollingContainers = [];
      for( var i = 0; i < menus.length; i++) {
        (function(i){
          menusArray.push(new Menu(menus[i]));
          var scrollableElement = menus[i].getAttribute('data-scrollable-element');
          if(scrollableElement && !scrollingContainers.includes(scrollableElement)) scrollingContainers.push(scrollableElement);
        })(i);
      }
  
      // listen for key events
      window.addEventListener('keyup', function(event){
        if( event.keyCode && event.keyCode == 9 || event.key && event.key.toLowerCase() == 'tab' ) {
          //close menu if focus is outside menu element
          menusArray.forEach(function(element){
            element.checkMenuFocus();
          });
        } else if( event.keyCode && event.keyCode == 27 || event.key && event.key.toLowerCase() == 'escape' ) {
          // close menu on 'Esc'
          menusArray.forEach(function(element){
            element.toggleMenu(false, false);
          });
        } 
      });
      // close menu when clicking outside it
      window.addEventListener('click', function(event){
        menusArray.forEach(function(element){
          element.checkMenuClick(event.target);
        });
      });
      // on resize -> close all menu elements
      window.addEventListener('resize', function(event){
        menusArray.forEach(function(element){
          element.toggleMenu(false, false);
        });
      });
      // on scroll -> close all menu elements
      window.addEventListener('scroll', function(event){
        menusArray.forEach(function(element){
          if(element.menuIsOpen) element.toggleMenu(false, false);
        });
      });
      // take into account additinal scrollable containers
      for(var j = 0; j < scrollingContainers.length; j++) {
        var scrollingContainer = document.querySelector(scrollingContainers[j]);
        if(scrollingContainer) {
          scrollingContainer.addEventListener('scroll', function(event){
            menusArray.forEach(function(element){
              if(element.menuIsOpen) element.toggleMenu(false, false);
            });
          });
        }
      }
    }
  }());
// File#: _1_modal-window
// Usage: codyhouse.co/license
(function() {
  var Modal = function(element) {
    this.element = element;
    this.triggers = document.querySelectorAll('[aria-controls="'+this.element.getAttribute('id')+'"]');
    this.firstFocusable = null;
    this.lastFocusable = null;
    this.moveFocusEl = null; // focus will be moved to this element when modal is open
    this.modalFocus = this.element.getAttribute('data-modal-first-focus') ? this.element.querySelector(this.element.getAttribute('data-modal-first-focus')) : null;
    this.selectedTrigger = null;
    this.showClass = "modal--is-visible";
    this.initModal();
  };

  Modal.prototype.initModal = function() {
    var self = this;
    //open modal when clicking on trigger buttons
    if ( this.triggers ) {
      for(var i = 0; i < this.triggers.length; i++) {
        this.triggers[i].addEventListener('click', function(event) {
          event.preventDefault();
          if(Util.hasClass(self.element, self.showClass)) {
            self.closeModal();
            return;
          }
          self.selectedTrigger = event.target;
          self.showModal();
          self.initModalEvents();
        });
      }
    }

    // listen to the openModal event -> open modal without a trigger button
    this.element.addEventListener('openModal', function(event){
      if(event.detail) self.selectedTrigger = event.detail;
      self.showModal();
      self.initModalEvents();
    });

    // listen to the closeModal event -> close modal without a trigger button
    this.element.addEventListener('closeModal', function(event){
      if(event.detail) self.selectedTrigger = event.detail;
      self.closeModal();
    });

    // if modal is open by default -> initialise modal events
    if(Util.hasClass(this.element, this.showClass)) this.initModalEvents();
  };

  Modal.prototype.showModal = function() {
    var self = this;
    Util.addClass(this.element, this.showClass);
    this.getFocusableElements();
    this.moveFocusEl.focus();
    // wait for the end of transitions before moving focus
    this.element.addEventListener("transitionend", function cb(event) {
      self.moveFocusEl.focus();
      self.element.removeEventListener("transitionend", cb);
    });
    this.emitModalEvents('modalIsOpen');
  };

  Modal.prototype.closeModal = function() {
    if(!Util.hasClass(this.element, this.showClass)) return;
    Util.removeClass(this.element, this.showClass);
    this.firstFocusable = null;
    this.lastFocusable = null;
    this.moveFocusEl = null;
    if(this.selectedTrigger) this.selectedTrigger.focus();
    //remove listeners
    this.cancelModalEvents();
    this.emitModalEvents('modalIsClose');
  };

  Modal.prototype.initModalEvents = function() {
    //add event listeners
    this.element.addEventListener('keydown', this);
    this.element.addEventListener('click', this);
  };

  Modal.prototype.cancelModalEvents = function() {
    //remove event listeners
    this.element.removeEventListener('keydown', this);
    this.element.removeEventListener('click', this);
  };

  Modal.prototype.handleEvent = function (event) {
    switch(event.type) {
      case 'click': {
        this.initClick(event);
      }
      case 'keydown': {
        this.initKeyDown(event);
      }
    }
  };

  Modal.prototype.initKeyDown = function(event) {
    if( event.keyCode && event.keyCode == 9 || event.key && event.key == 'Tab' ) {
      //trap focus inside modal
      this.trapFocus(event);
    } else if( (event.keyCode && event.keyCode == 13 || event.key && event.key == 'Enter') && event.target.closest('.js-modal__close')) {
      event.preventDefault();
      this.closeModal(); // close modal when pressing Enter on close button
    }	
  };

  Modal.prototype.initClick = function(event) {
    //close modal when clicking on close button or modal bg layer 
    if( !event.target.closest('.js-modal__close') && !Util.hasClass(event.target, 'js-modal') ) return;
    event.preventDefault();
    this.closeModal();
  };

  Modal.prototype.trapFocus = function(event) {
    if( this.firstFocusable == document.activeElement && event.shiftKey) {
      //on Shift+Tab -> focus last focusable element when focus moves out of modal
      event.preventDefault();
      this.lastFocusable.focus();
    }
    if( this.lastFocusable == document.activeElement && !event.shiftKey) {
      //on Tab -> focus first focusable element when focus moves out of modal
      event.preventDefault();
      this.firstFocusable.focus();
    }
  }

  Modal.prototype.getFocusableElements = function() {
    //get all focusable elements inside the modal
    var allFocusable = this.element.querySelectorAll(focusableElString);
    this.getFirstVisible(allFocusable);
    this.getLastVisible(allFocusable);
    this.getFirstFocusable();
  };

  Modal.prototype.getFirstVisible = function(elements) {
    //get first visible focusable element inside the modal
    for(var i = 0; i < elements.length; i++) {
      if( isVisible(elements[i]) ) {
        this.firstFocusable = elements[i];
        break;
      }
    }
  };

  Modal.prototype.getLastVisible = function(elements) {
    //get last visible focusable element inside the modal
    for(var i = elements.length - 1; i >= 0; i--) {
      if( isVisible(elements[i]) ) {
        this.lastFocusable = elements[i];
        break;
      }
    }
  };

  Modal.prototype.getFirstFocusable = function() {
    if(!this.modalFocus || !Element.prototype.matches) {
      this.moveFocusEl = this.firstFocusable;
      return;
    }
    var containerIsFocusable = this.modalFocus.matches(focusableElString);
    if(containerIsFocusable) {
      this.moveFocusEl = this.modalFocus;
    } else {
      this.moveFocusEl = false;
      var elements = this.modalFocus.querySelectorAll(focusableElString);
      for(var i = 0; i < elements.length; i++) {
        if( isVisible(elements[i]) ) {
          this.moveFocusEl = elements[i];
          break;
        }
      }
      if(!this.moveFocusEl) this.moveFocusEl = this.firstFocusable;
    }
  };

  Modal.prototype.emitModalEvents = function(eventName) {
    var event = new CustomEvent(eventName, {detail: this.selectedTrigger});
    this.element.dispatchEvent(event);
  };

  function isVisible(element) {
    return element.offsetWidth || element.offsetHeight || element.getClientRects().length;
  };

  //initialize the Modal objects
  var modals = document.getElementsByClassName('js-modal');
  // generic focusable elements string selector
  var focusableElString = '[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, [tabindex]:not([tabindex="-1"]), [contenteditable], audio[controls], video[controls], summary';
  if( modals.length > 0 ) {
    var modalArrays = [];
    for( var i = 0; i < modals.length; i++) {
      (function(i){modalArrays.push(new Modal(modals[i]));})(i);
    }

    window.addEventListener('keydown', function(event){ //close modal window on esc
      if(event.keyCode && event.keyCode == 27 || event.key && event.key.toLowerCase() == 'escape') {
        for( var i = 0; i < modalArrays.length; i++) {
          (function(i){modalArrays[i].closeModal();})(i);
        };
      }
    });
  }
}());
// File#: _1_number-input
// Usage: codyhouse.co/license
(function() {
    var InputNumber = function(element) {
      this.element = element;
      this.input = this.element.getElementsByClassName('js-number-input__value')[0];
      this.min = parseFloat(this.input.getAttribute('min'));
      this.max = parseFloat(this.input.getAttribute('max'));
      this.step = parseFloat(this.input.getAttribute('step'));
      if(isNaN(this.step)) this.step = 1;
      this.precision = getStepPrecision(this.step);
      initInputNumberEvents(this);
    };
  
    function initInputNumberEvents(input) {
      // listen to the click event on the custom increment buttons
      input.element.addEventListener('click', function(event){ 
        var increment = event.target.closest('.js-number-input__btn');
        if(increment) {
          event.preventDefault();
          updateInputNumber(input, increment);
        }
      });
  
      // when input changes, make sure the new value is acceptable
      input.input.addEventListener('focusout', function(event){
        var value = parseFloat(input.input.value);
        if( value < input.min ) value = input.min;
        if( value > input.max ) value = input.max;
        // check value is multiple of step
        value = checkIsMultipleStep(input, value);
        if( value != parseFloat(input.input.value)) input.input.value = value;
  
      });
    };
  
    function getStepPrecision(step) {
      // if step is a floating number, return its precision
      return (step.toString().length - Math.floor(step).toString().length - 1);
    };
  
    function updateInputNumber(input, btn) {
      var value = ( Util.hasClass(btn, 'number-input__btn--plus') ) ? parseFloat(input.input.value) + input.step : parseFloat(input.input.value) - input.step;
      if( input.precision > 0 ) value = value.toFixed(input.precision);
      if( value < input.min ) value = input.min;
      if( value > input.max ) value = input.max;
      input.input.value = value;
      input.input.dispatchEvent(new CustomEvent('change', {bubbles: true})); // trigger change event
    };
  
    function checkIsMultipleStep(input, value) {
      // check if the number inserted is a multiple of the step value
      var remain = (value*10*input.precision)%(input.step*10*input.precision);
      if( remain != 0) value = value - remain;
      if( input.precision > 0 ) value = value.toFixed(input.precision);
      return value;
    };
  
    //initialize the InputNumber objects
    var inputNumbers = document.getElementsByClassName('js-number-input');
    if( inputNumbers.length > 0 ) {
      for( var i = 0; i < inputNumbers.length; i++) {
        (function(i){new InputNumber(inputNumbers[i]);})(i);
      }
    }
  }());
// File#: _1_rating
// Usage: codyhouse.co/license
(function() {
    var Rating = function(element) {
      this.element = element;
      this.icons = this.element.getElementsByClassName('js-rating__control')[0];
      this.iconCode = this.icons.children[0].parentNode.innerHTML;
      this.initialRating = [];
      this.initialRatingElement = this.element.getElementsByClassName('js-rating__value')[0];
      this.ratingItems;
      this.selectedRatingItem;
      this.readOnly = Util.hasClass(this.element, 'js-rating--read-only');
      this.ratingMaxValue = 5;
      this.getInitialRating();
      this.initRatingHtml();
    };
  
    Rating.prototype.getInitialRating = function() {
      // get the rating of the product
      if(!this.initialRatingElement || !this.readOnly) {
        this.initialRating = [0, false];
        return;
      }
  
      var initialValue = Number(this.initialRatingElement.textContent);
      if(isNaN(initialValue)) {
        this.initialRating = [0, false];
        return;
      }
  
      var floorNumber = Math.floor(initialValue);
      this.initialRating[0] = (floorNumber < initialValue) ? floorNumber + 1 : floorNumber;
      this.initialRating[1] = (floorNumber < initialValue) ? Math.round((initialValue - floorNumber)*100) : false;
    };
  
    Rating.prototype.initRatingHtml = function() {
      //create the star elements
      var iconsList = this.readOnly ? '<ul>' : '<ul role="radiogroup">';
      
      //if initial rating value is zero -> add a 'zero' item 
      if(this.initialRating[0] == 0 && !this.initialRating[1]) {
        iconsList = iconsList+ '<li class="rating__item--zero rating__item--checked"></li>';
      }
  
      // create the stars list 
      for(var i = 0; i < this.ratingMaxValue; i++) { 
        iconsList = iconsList + this.getStarHtml(i);
      }
      iconsList = iconsList + '</ul>';
  
      // --default variation only - improve SR accessibility including a legend element 
      if(!this.readOnly) {
        var labelElement = this.element.getElementsByTagName('label');
        if(labelElement.length > 0) {
          var legendElement = '<legend class="'+labelElement[0].getAttribute('class')+'">'+labelElement[0].textContent+'</legend>';
          iconsList = '<fieldset>'+legendElement+iconsList+'</fieldset>';
          Util.addClass(labelElement[0], 'is-hidden');
        }
      }
  
      this.icons.innerHTML = iconsList;
      
      //init object properties
      this.ratingItems = this.icons.getElementsByClassName('js-rating__item');
      this.selectedRatingItem = this.icons.getElementsByClassName('rating__item--checked')[0];
  
      //show the stars
      Util.removeClass(this.icons, 'rating__control--is-hidden');
  
      //event listener
      !this.readOnly && this.initRatingEvents();// rating vote enabled
    };
  
    Rating.prototype.getStarHtml = function(index) {
      var listItem = '';
      var checked = (index+1 == this.initialRating[0]) ? true : false,
        itemClass = checked ? ' rating__item--checked' : '',
        tabIndex = (checked || (this.initialRating[0] == 0 && !this.initialRating[1] && index == 0) ) ? 0 : -1,
        showHalf = checked && this.initialRating[1] ? true : false,
        iconWidth = showHalf ? ' rating__item--half': '';
      if(!this.readOnly) {
        listItem = '<li class="js-rating__item'+itemClass+iconWidth+'" role="radio" aria-label="'+(index+1)+'" aria-checked="'+checked+'" tabindex="'+tabIndex+'"><div class="rating__icon">'+this.iconCode+'</div></li>';
      } else {
        var starInner = showHalf ? '<div class="rating__icon">'+this.iconCode+'</div><div class="rating__icon rating__icon--inactive">'+this.iconCode+'</div>': '<div class="rating__icon">'+this.iconCode+'</div>';
        listItem = '<li class="js-rating__item'+itemClass+iconWidth+'">'+starInner+'</li>';
      }
      return listItem;
    };
  
    Rating.prototype.initRatingEvents = function() {
      var self = this;
  
      //click on a star
      this.icons.addEventListener('click', function(event){
        var trigger = event.target.closest('.js-rating__item');
        self.resetSelectedIcon(trigger);
      });
  
      //keyboard navigation -> select new star
      this.icons.addEventListener('keydown', function(event){
        if( event.keyCode && (event.keyCode == 39 || event.keyCode == 40 ) || event.key && (event.key.toLowerCase() == 'arrowright' || event.key.toLowerCase() == 'arrowdown') ) {
          self.selectNewIcon('next'); //select next star on arrow right/down
        } else if(event.keyCode && (event.keyCode == 37 || event.keyCode == 38 ) || event.key && (event.key.toLowerCase() == 'arrowleft' || event.key.toLowerCase() == 'arrowup')) {
          self.selectNewIcon('prev'); //select prev star on arrow left/up
        } else if(event.keyCode && event.keyCode == 32 || event.key && event.key == ' ') {
          self.selectFocusIcon(); // select focused star on Space
        }
      });
    };
  
    Rating.prototype.selectNewIcon = function(direction) {
      var index = Util.getIndexInArray(this.ratingItems, this.selectedRatingItem);
      index = (direction == 'next') ? index + 1 : index - 1;
      if(index < 0) index = this.ratingItems.length - 1;
      if(index >= this.ratingItems.length) index = 0;	
      this.resetSelectedIcon(this.ratingItems[index]);
      this.ratingItems[index].focus();
    };
  
    Rating.prototype.selectFocusIcon = function(direction) {
      this.resetSelectedIcon(document.activeElement);
    };
  
    Rating.prototype.resetSelectedIcon = function(trigger) {
      if(!trigger) return;
      Util.removeClass(this.selectedRatingItem, 'rating__item--checked');
      Util.setAttributes(this.selectedRatingItem, {'aria-checked': false, 'tabindex': -1});
      Util.addClass(trigger, 'rating__item--checked');
      Util.setAttributes(trigger, {'aria-checked': true, 'tabindex': 0});
      this.selectedRatingItem = trigger; 
      // update select input value
      var select = this.element.getElementsByTagName('select');
      if(select.length > 0) {
        select[0].value = trigger.getAttribute('aria-label');
      }
    };
    
    //initialize the Rating objects
    var ratings = document.getElementsByClassName('js-rating');
    if( ratings.length > 0 ) {
      for( var i = 0; i < ratings.length; i++) {
        (function(i){new Rating(ratings[i]);})(i);
      }
    };
  }());
// File#: _1_swipe-content
(function() {
    var SwipeContent = function(element) {
      this.element = element;
      this.delta = [false, false];
      this.dragging = false;
      this.intervalId = false;
      initSwipeContent(this);
    };
  
    function initSwipeContent(content) {
      content.element.addEventListener('mousedown', handleEvent.bind(content));
      content.element.addEventListener('touchstart', handleEvent.bind(content));
    };
  
    function initDragging(content) {
      //add event listeners
      content.element.addEventListener('mousemove', handleEvent.bind(content));
      content.element.addEventListener('touchmove', handleEvent.bind(content));
      content.element.addEventListener('mouseup', handleEvent.bind(content));
      content.element.addEventListener('mouseleave', handleEvent.bind(content));
      content.element.addEventListener('touchend', handleEvent.bind(content));
    };
  
    function cancelDragging(content) {
      //remove event listeners
      if(content.intervalId) {
        (!window.requestAnimationFrame) ? clearInterval(content.intervalId) : window.cancelAnimationFrame(content.intervalId);
        content.intervalId = false;
      }
      content.element.removeEventListener('mousemove', handleEvent.bind(content));
      content.element.removeEventListener('touchmove', handleEvent.bind(content));
      content.element.removeEventListener('mouseup', handleEvent.bind(content));
      content.element.removeEventListener('mouseleave', handleEvent.bind(content));
      content.element.removeEventListener('touchend', handleEvent.bind(content));
    };
  
    function handleEvent(event) {
      switch(event.type) {
        case 'mousedown':
        case 'touchstart':
          startDrag(this, event);
          break;
        case 'mousemove':
        case 'touchmove':
          drag(this, event);
          break;
        case 'mouseup':
        case 'mouseleave':
        case 'touchend':
          endDrag(this, event);
          break;
      }
    };
  
    function startDrag(content, event) {
      content.dragging = true;
      // listen to drag movements
      initDragging(content);
      content.delta = [parseInt(unify(event).clientX), parseInt(unify(event).clientY)];
      // emit drag start event
      emitSwipeEvents(content, 'dragStart', content.delta, event.target);
    };
  
    function endDrag(content, event) {
      cancelDragging(content);
      // credits: https://css-tricks.com/simple-swipe-with-vanilla-javascript/
      var dx = parseInt(unify(event).clientX), 
        dy = parseInt(unify(event).clientY);
      
      // check if there was a left/right swipe
      if(content.delta && (content.delta[0] || content.delta[0] === 0)) {
        var s = getSign(dx - content.delta[0]);
        
        if(Math.abs(dx - content.delta[0]) > 30) {
          (s < 0) ? emitSwipeEvents(content, 'swipeLeft', [dx, dy]) : emitSwipeEvents(content, 'swipeRight', [dx, dy]);	
        }
        
        content.delta[0] = false;
      }
      // check if there was a top/bottom swipe
      if(content.delta && (content.delta[1] || content.delta[1] === 0)) {
          var y = getSign(dy - content.delta[1]);
  
          if(Math.abs(dy - content.delta[1]) > 30) {
            (y < 0) ? emitSwipeEvents(content, 'swipeUp', [dx, dy]) : emitSwipeEvents(content, 'swipeDown', [dx, dy]);
        }
  
        content.delta[1] = false;
      }
      // emit drag end event
      emitSwipeEvents(content, 'dragEnd', [dx, dy]);
      content.dragging = false;
    };
  
    function drag(content, event) {
      if(!content.dragging) return;
      // emit dragging event with coordinates
      (!window.requestAnimationFrame) 
        ? content.intervalId = setTimeout(function(){emitDrag.bind(content, event);}, 250) 
        : content.intervalId = window.requestAnimationFrame(emitDrag.bind(content, event));
    };
  
    function emitDrag(event) {
      emitSwipeEvents(this, 'dragging', [parseInt(unify(event).clientX), parseInt(unify(event).clientY)]);
    };
  
    function unify(event) { 
      // unify mouse and touch events
      return event.changedTouches ? event.changedTouches[0] : event; 
    };
  
    function emitSwipeEvents(content, eventName, detail, el) {
      var trigger = false;
      if(el) trigger = el;
      // emit event with coordinates
      var event = new CustomEvent(eventName, {detail: {x: detail[0], y: detail[1], origin: trigger}});
      content.element.dispatchEvent(event);
    };
  
    function getSign(x) {
      if(!Math.sign) {
        return ((x > 0) - (x < 0)) || +x;
      } else {
        return Math.sign(x);
      }
    };
  
    window.SwipeContent = SwipeContent;
    
    //initialize the SwipeContent objects
    var swipe = document.getElementsByClassName('js-swipe-content');
    if( swipe.length > 0 ) {
      for( var i = 0; i < swipe.length; i++) {
        (function(i){new SwipeContent(swipe[i]);})(i);
      }
    }
  }());
// File#: _1_table
// Usage: codyhouse.co/license
(function() {
    function initTable(table) {
      checkTableLayour(table); // switch from a collapsed to an expanded layout
      Util.addClass(table, 'table--loaded'); // show table
  
      // custom event emitted when window is resized
      table.addEventListener('update-table', function(event){
        checkTableLayour(table);
      });
    };
  
    function checkTableLayour(table) {
      var layout = getComputedStyle(table, ':before').getPropertyValue('content').replace(/\'|"/g, '');
      Util.toggleClass(table, tableExpandedLayoutClass, layout != 'collapsed');
    };
  
    var tables = document.getElementsByClassName('js-table'),
      tableExpandedLayoutClass = 'table--expanded';
    if( tables.length > 0 ) {
      var j = 0;
      for( var i = 0; i < tables.length; i++) {
        var beforeContent = getComputedStyle(tables[i], ':before').getPropertyValue('content');
        if(beforeContent && beforeContent !='' && beforeContent !='none') {
          (function(i){initTable(tables[i]);})(i);
          j = j + 1;
        } else {
          Util.addClass(tables[i], 'table--loaded');
        }
      }
      
      if(j > 0) {
        var resizingId = false,
          customEvent = new CustomEvent('update-table');
        window.addEventListener('resize', function(event){
          clearTimeout(resizingId);
          resizingId = setTimeout(doneResizing, 300);
        });
  
        function doneResizing() {
          for( var i = 0; i < tables.length; i++) {
            (function(i){tables[i].dispatchEvent(customEvent)})(i);
          };
        };
  
        (window.requestAnimationFrame) // init table layout
          ? window.requestAnimationFrame(doneResizing)
          : doneResizing();
      }
    }
  }());
// File#: _1_tabs
// Usage: codyhouse.co/license
(function() {
    var Tab = function(element) {
      this.element = element;
      this.tabList = this.element.getElementsByClassName('js-tabs__controls')[0];
      this.listItems = this.tabList.getElementsByTagName('li');
      this.triggers = this.tabList.getElementsByTagName('a');
      this.panelsList = this.element.getElementsByClassName('js-tabs__panels')[0];
      this.panels = Util.getChildrenByClassName(this.panelsList, 'js-tabs__panel');
      this.hideClass = 'is-hidden';
      this.customShowClass = this.element.getAttribute('data-show-panel-class') ? this.element.getAttribute('data-show-panel-class') : false;
      this.initTab();
    };
  
    Tab.prototype.initTab = function() {
      //set initial aria attributes
      this.tabList.setAttribute('role', 'tablist');
      for( var i = 0; i < this.triggers.length; i++) {
        var bool = (i == 0),
          panelId = this.panels[i].getAttribute('id');
        this.listItems[i].setAttribute('role', 'presentation');
        Util.setAttributes(this.triggers[i], {'role': 'tab', 'aria-selected': bool, 'aria-controls': panelId, 'id': 'tab-'+panelId});
        Util.addClass(this.triggers[i], 'js-tabs__trigger'); 
        Util.setAttributes(this.panels[i], {'role': 'tabpanel', 'aria-labelledby': 'tab-'+panelId});
        Util.toggleClass(this.panels[i], this.hideClass, !bool);
  
        if(!bool) this.triggers[i].setAttribute('tabindex', '-1'); 
      }
  
      //listen for Tab events
      this.initTabEvents();
    };
  
    Tab.prototype.initTabEvents = function() {
      var self = this;
      //click on a new tab -> select content
      this.tabList.addEventListener('click', function(event) {
        if( event.target.closest('.js-tabs__trigger') ) self.triggerTab(event.target.closest('.js-tabs__trigger'), event);
      });
      //arrow keys to navigate through tabs 
      this.tabList.addEventListener('keydown', function(event) {
        if( !event.target.closest('.js-tabs__trigger') ) return;
        if( event.keyCode && event.keyCode == 39 || event.key && event.key == 'ArrowRight' ) {
          self.selectNewTab('next');
        } else if( event.keyCode && event.keyCode == 37 || event.key && event.key == 'ArrowLeft' ) {
          self.selectNewTab('prev');
        }
      });
    };
  
    Tab.prototype.selectNewTab = function(direction) {
      var selectedTab = this.tabList.querySelector('[aria-selected="true"]'),
        index = Util.getIndexInArray(this.triggers, selectedTab);
      index = (direction == 'next') ? index + 1 : index - 1;
      //make sure index is in the correct interval 
      //-> from last element go to first using the right arrow, from first element go to last using the left arrow
      if(index < 0) index = this.listItems.length - 1;
      if(index >= this.listItems.length) index = 0;	
      this.triggerTab(this.triggers[index]);
      this.triggers[index].focus();
    };
  
    Tab.prototype.triggerTab = function(tabTrigger, event) {
      var self = this;
      event && event.preventDefault();	
      var index = Util.getIndexInArray(this.triggers, tabTrigger);
      //no need to do anything if tab was already selected
      if(this.triggers[index].getAttribute('aria-selected') == 'true') return;
      
      for( var i = 0; i < this.triggers.length; i++) {
        var bool = (i == index);
        Util.toggleClass(this.panels[i], this.hideClass, !bool);
        if(this.customShowClass) Util.toggleClass(this.panels[i], this.customShowClass, bool);
        this.triggers[i].setAttribute('aria-selected', bool);
        bool ? this.triggers[i].setAttribute('tabindex', '0') : this.triggers[i].setAttribute('tabindex', '-1');
      }
    };
    
    //initialize the Tab objects
    var tabs = document.getElementsByClassName('js-tabs');
    if( tabs.length > 0 ) {
      for( var i = 0; i < tabs.length; i++) {
        (function(i){new Tab(tabs[i]);})(i);
      }
    }
  }());
// File#: _2_carousel
// Usage: codyhouse.co/license
(function() {
    var Carousel = function(opts) {
      this.options = Util.extend(Carousel.defaults , opts);
      this.element = this.options.element;
      this.listWrapper = this.element.getElementsByClassName('carousel__wrapper')[0];
      this.list = this.element.getElementsByClassName('carousel__list')[0];
      this.items = this.element.getElementsByClassName('carousel__item');
      this.initItems = []; // store only the original elements - will need this for cloning
      this.itemsNb = this.items.length; //original number of items
      this.visibItemsNb = 1; // tot number of visible items
      this.itemsWidth = 1; // this will be updated with the right width of items
      this.itemOriginalWidth = false; // store the initial width to use it on resize
      this.selectedItem = 0; // index of first visible item 
      this.translateContainer = 0; // this will be the amount the container has to be translated each time a new group has to be shown (negative)
      this.containerWidth = 0; // this will be used to store the total width of the carousel (including the overflowing part)
      this.ariaLive = false;
      // navigation
      this.controls = this.element.getElementsByClassName('js-carousel__control');
      this.animating = false;
      // autoplay
      this.autoplayId = false;
      this.autoplayPaused = false;
      //drag
      this.dragStart = false;
      // resize
      this.resizeId = false;
      // used to re-initialize js
      this.cloneList = [];
      // store items min-width
      this.itemAutoSize = false;
      // store translate value (loop = off)
      this.totTranslate = 0;
      // modify loop option if navigation is on
      if(this.options.nav) this.options.loop = false;
      // store counter elements (if present)
      this.counter = this.element.getElementsByClassName('js-carousel__counter');
      this.counterTor = this.element.getElementsByClassName('js-carousel__counter-tot');
      initCarouselLayout(this); // get number visible items + width items
      setItemsWidth(this, true); 
      insertBefore(this, this.visibItemsNb); // insert clones before visible elements
      updateCarouselClones(this); // insert clones after visible elements
      resetItemsTabIndex(this); // make sure not visible items are not focusable
      initAriaLive(this); // set aria-live region for SR
      initCarouselEvents(this); // listen to events
      initCarouselCounter(this);
      Util.addClass(this.element, 'carousel--loaded');
    };
    
    //public carousel functions
    Carousel.prototype.showNext = function() {
      showNextItems(this);
    };
  
    Carousel.prototype.showPrev = function() {
      showPrevItems(this);
    };
  
    Carousel.prototype.startAutoplay = function() {
      startAutoplay(this);
    };
  
    Carousel.prototype.pauseAutoplay = function() {
      pauseAutoplay(this);
    };
    
    //private carousel functions
    function initCarouselLayout(carousel) {
      // evaluate size of single elements + number of visible elements
      var itemStyle = window.getComputedStyle(carousel.items[0]),
        containerStyle = window.getComputedStyle(carousel.listWrapper),
        itemWidth = parseFloat(itemStyle.getPropertyValue('width')),
        itemMargin = parseFloat(itemStyle.getPropertyValue('margin-right')),
        containerPadding = parseFloat(containerStyle.getPropertyValue('padding-left')),
        containerWidth = parseFloat(containerStyle.getPropertyValue('width'));
  
      if(!carousel.itemAutoSize) {
        carousel.itemAutoSize = itemWidth;
      }
  
      // if carousel.listWrapper is hidden -> make sure to retrieve the proper width
      containerWidth = getCarouselWidth(carousel, containerWidth);
  
      if( !carousel.itemOriginalWidth) { // on resize -> use initial width of items to recalculate 
        carousel.itemOriginalWidth = itemWidth;
      } else {
        itemWidth = carousel.itemOriginalWidth;
      }
  
      if(carousel.itemAutoSize) {
        carousel.itemOriginalWidth = parseInt(carousel.itemAutoSize);
        itemWidth = carousel.itemOriginalWidth;
      }
      // make sure itemWidth is smaller than container width
      if(containerWidth < itemWidth) {
        carousel.itemOriginalWidth = containerWidth
        itemWidth = carousel.itemOriginalWidth;
      }
      // get proper width of elements
      carousel.visibItemsNb = parseInt((containerWidth - 2*containerPadding + itemMargin)/(itemWidth+itemMargin));
      carousel.itemsWidth = parseFloat( (((containerWidth - 2*containerPadding + itemMargin)/carousel.visibItemsNb) - itemMargin).toFixed(1));
      carousel.containerWidth = (carousel.itemsWidth+itemMargin)* carousel.items.length;
      carousel.translateContainer = 0 - ((carousel.itemsWidth+itemMargin)* carousel.visibItemsNb);
      // flexbox fallback
      if(!flexSupported) carousel.list.style.width = (carousel.itemsWidth + itemMargin)*carousel.visibItemsNb*3+'px';
      
      // this is used when loop == off
      carousel.totTranslate = 0 - carousel.selectedItem*(carousel.itemsWidth+itemMargin);
      if(carousel.items.length <= carousel.visibItemsNb) carousel.totTranslate = 0;
  
      centerItems(carousel); // center items if carousel.items.length < visibItemsNb
      alignControls(carousel); // check if controls need to be aligned to a different element
    };
  
    function setItemsWidth(carousel, bool) {
      for(var i = 0; i < carousel.items.length; i++) {
        carousel.items[i].style.width = carousel.itemsWidth+"px";
        if(bool) carousel.initItems.push(carousel.items[i]);
      }
    };
  
    function updateCarouselClones(carousel) { 
      if(!carousel.options.loop) return;
      // take care of clones after visible items (needs to run after the update of clones before visible items)
      if(carousel.items.length < carousel.visibItemsNb*3) {
        insertAfter(carousel, carousel.visibItemsNb*3 - carousel.items.length, carousel.items.length - carousel.visibItemsNb*2);
      } else if(carousel.items.length > carousel.visibItemsNb*3 ) {
        removeClones(carousel, carousel.visibItemsNb*3, carousel.items.length - carousel.visibItemsNb*3);
      }
      // set proper translate value for the container
      setTranslate(carousel, 'translateX('+carousel.translateContainer+'px)');
    };
  
    function initCarouselEvents(carousel) {
      // listen for click on previous/next arrow
      // dots navigation
      if(carousel.options.nav) {
        carouselCreateNavigation(carousel);
        carouselInitNavigationEvents(carousel);
      }
  
      if(carousel.controls.length > 0) {
        carousel.controls[0].addEventListener('click', function(event){
          event.preventDefault();
          showPrevItems(carousel);
          updateAriaLive(carousel);
        });
        carousel.controls[1].addEventListener('click', function(event){
          event.preventDefault();
          showNextItems(carousel);
          updateAriaLive(carousel);
        });
  
        // update arrow visility -> loop == off only
        resetCarouselControls(carousel);
      }
      // autoplay
      if(carousel.options.autoplay) {
        startAutoplay(carousel);
        // pause autoplay if user is interacting with the carousel
        carousel.element.addEventListener('mouseenter', function(event){
          pauseAutoplay(carousel);
          carousel.autoplayPaused = true;
        });
        carousel.element.addEventListener('focusin', function(event){
          pauseAutoplay(carousel);
          carousel.autoplayPaused = true;
        });
        carousel.element.addEventListener('mouseleave', function(event){
          carousel.autoplayPaused = false;
          startAutoplay(carousel);
        });
        carousel.element.addEventListener('focusout', function(event){
          carousel.autoplayPaused = false;
          startAutoplay(carousel);
        });
      }
      // drag events
      if(carousel.options.drag && window.requestAnimationFrame) {
        //init dragging
        new SwipeContent(carousel.element);
        carousel.element.addEventListener('dragStart', function(event){
          if(event.detail.origin && event.detail.origin.closest('.js-carousel__control')) return;
          if(event.detail.origin && event.detail.origin.closest('.js-carousel__navigation')) return;
          if(event.detail.origin && !event.detail.origin.closest('.carousel__wrapper')) return;
          Util.addClass(carousel.element, 'carousel--is-dragging');
          pauseAutoplay(carousel);
          carousel.dragStart = event.detail.x;
          animateDragEnd(carousel);
        });
        carousel.element.addEventListener('dragging', function(event){
          if(!carousel.dragStart) return;
          if(carousel.animating || Math.abs(event.detail.x - carousel.dragStart) < 10) return;
          var translate = event.detail.x - carousel.dragStart + carousel.translateContainer;
          if(!carousel.options.loop) {
            translate = event.detail.x - carousel.dragStart + carousel.totTranslate; 
          }
          setTranslate(carousel, 'translateX('+translate+'px)');
        });
      }
      // reset on resize
      window.addEventListener('resize', function(event){
        pauseAutoplay(carousel);
        clearTimeout(carousel.resizeId);
        carousel.resizeId = setTimeout(function(){
          resetCarouselResize(carousel);
          // reset dots navigation
          resetDotsNavigation(carousel);
          resetCarouselControls(carousel);
          setCounterItem(carousel);
          startAutoplay(carousel);
          centerItems(carousel); // center items if carousel.items.length < visibItemsNb
          alignControls(carousel);
        }, 250)
      });
    };
  
    function showPrevItems(carousel) {
      if(carousel.animating) return;
      carousel.animating = true;
      carousel.selectedItem = getIndex(carousel, carousel.selectedItem - carousel.visibItemsNb);
      animateList(carousel, '0', 'prev');
    };
  
    function showNextItems(carousel) {
      if(carousel.animating) return;
      carousel.animating = true;
      carousel.selectedItem = getIndex(carousel, carousel.selectedItem + carousel.visibItemsNb);
      animateList(carousel, carousel.translateContainer*2+'px', 'next');
    };
  
    function animateDragEnd(carousel) { // end-of-dragging animation
      carousel.element.addEventListener('dragEnd', function cb(event){
        carousel.element.removeEventListener('dragEnd', cb);
        Util.removeClass(carousel.element, 'carousel--is-dragging');
        if(event.detail.x - carousel.dragStart < -40) {
          carousel.animating = false;
          showNextItems(carousel);
        } else if(event.detail.x - carousel.dragStart > 40) {
          carousel.animating = false;
          showPrevItems(carousel);
        } else if(event.detail.x - carousel.dragStart == 0) { // this is just a click -> no dragging
          return;
        } else { // not dragged enought -> do not update carousel, just reset
          carousel.animating = true;
          animateList(carousel, carousel.translateContainer+'px', false);
        }
        carousel.dragStart = false;
      });
    };
  
    function animateList(carousel, translate, direction) { // takes care of changing visible items
      pauseAutoplay(carousel);
      Util.addClass(carousel.list, 'carousel__list--animating');
      var initTranslate = carousel.totTranslate;
      if(!carousel.options.loop) {
        translate = noLoopTranslateValue(carousel, direction);
      }
      setTranslate(carousel, 'translateX('+translate+')');
      if(transitionSupported) {
        carousel.list.addEventListener('transitionend', function cb(event){
          if(event.propertyName && event.propertyName != 'transform') return;
          Util.removeClass(carousel.list, 'carousel__list--animating');
          carousel.list.removeEventListener('transitionend', cb);
          animateListCb(carousel, direction);
        });
      } else {
        animateListCb(carousel, direction);
      }
      if(!carousel.options.loop && (initTranslate == carousel.totTranslate)) {
        // translate value was not updated -> trigger transitionend event to restart carousel
        carousel.list.dispatchEvent(new CustomEvent('transitionend'));
      }
      resetCarouselControls(carousel);
      setCounterItem(carousel);
    };
  
    function noLoopTranslateValue(carousel, direction) {
      var translate = carousel.totTranslate;
      if(direction == 'next') {
        translate = carousel.totTranslate + carousel.translateContainer;
      } else if(direction == 'prev') {
        translate = carousel.totTranslate - carousel.translateContainer;
      } else if(direction == 'click') {
        translate = carousel.selectedDotIndex*carousel.translateContainer;
      }
      if(translate > 0)  {
        translate = 0;
        carousel.selectedItem = 0;
      }
      if(translate < - carousel.translateContainer - carousel.containerWidth) {
        translate = - carousel.translateContainer - carousel.containerWidth;
        carousel.selectedItem = carousel.items.length - carousel.visibItemsNb;
      }
      if(carousel.visibItemsNb > carousel.items.length) translate = 0;
      carousel.totTranslate = translate;
      return translate + 'px';
    };
  
    function animateListCb(carousel, direction) { // reset actions after carousel has been updated
      if(direction) updateClones(carousel, direction);
      carousel.animating = false;
      // reset autoplay
      startAutoplay(carousel);
      // reset tab index
      resetItemsTabIndex(carousel);
    };
  
    function updateClones(carousel, direction) {
      if(!carousel.options.loop) return;
      // at the end of each animation, we need to update the clones before and after the visible items
      var index = (direction == 'next') ? 0 : carousel.items.length - carousel.visibItemsNb;
      // remove clones you do not need anymore
      removeClones(carousel, index, false);
      // add new clones 
      (direction == 'next') ? insertAfter(carousel, carousel.visibItemsNb, 0) : insertBefore(carousel, carousel.visibItemsNb);
      //reset transform
      setTranslate(carousel, 'translateX('+carousel.translateContainer+'px)');
    };
  
    function insertBefore(carousel, nb, delta) {
      if(!carousel.options.loop) return;
      var clones = document.createDocumentFragment();
      var start = 0;
      if(delta) start = delta;
      for(var i = start; i < nb; i++) {
        var index = getIndex(carousel, carousel.selectedItem - i - 1),
          clone = carousel.initItems[index].cloneNode(true);
        Util.addClass(clone, 'js-clone');
        clones.insertBefore(clone, clones.firstChild);
      }
      carousel.list.insertBefore(clones, carousel.list.firstChild);
      emitCarouselUpdateEvent(carousel);
    };
  
    function insertAfter(carousel, nb, init) {
      if(!carousel.options.loop) return;
      var clones = document.createDocumentFragment();
      for(var i = init; i < nb + init; i++) {
        var index = getIndex(carousel, carousel.selectedItem + carousel.visibItemsNb + i),
          clone = carousel.initItems[index].cloneNode(true);
        Util.addClass(clone, 'js-clone');
        clones.appendChild(clone);
      }
      carousel.list.appendChild(clones);
      emitCarouselUpdateEvent(carousel);
    };
  
    function removeClones(carousel, index, bool) {
      if(!carousel.options.loop) return;
      if( !bool) {
        bool = carousel.visibItemsNb;
      }
      for(var i = 0; i < bool; i++) {
        if(carousel.items[index]) carousel.list.removeChild(carousel.items[index]);
      }
    };
  
    function resetCarouselResize(carousel) { // reset carousel on resize
      var visibleItems = carousel.visibItemsNb;
      initCarouselLayout(carousel); 
      setItemsWidth(carousel, false);
      resetItemsWidth(carousel); // update the array of original items -> array used to create clones
      if(carousel.options.loop) {
        if(visibleItems > carousel.visibItemsNb) {
          removeClones(carousel, 0, visibleItems - carousel.visibItemsNb);
        } else if(visibleItems < carousel.visibItemsNb) {
          insertBefore(carousel, carousel.visibItemsNb, visibleItems);
        }
        updateCarouselClones(carousel); // this will take care of translate + after elements
      } else {
        // reset default translate to a multiple value of (itemWidth + margin)
        var translate = noLoopTranslateValue(carousel);
        setTranslate(carousel, 'translateX('+translate+')');
      }
      resetItemsTabIndex(carousel); // reset focusable elements
    };
  
    function resetItemsWidth(carousel) {
      for(var i = 0; i < carousel.initItems.length; i++) {
        carousel.initItems[i].style.width = carousel.itemsWidth+"px";
      }
    };
  
    function resetItemsTabIndex(carousel) {
      var carouselActive = carousel.items.length > carousel.visibItemsNb;
      var j = carousel.items.length;
      for(var i = 0; i < carousel.items.length; i++) {
        if(carousel.options.loop) {
          if(i < carousel.visibItemsNb || i >= 2*carousel.visibItemsNb ) {
            carousel.items[i].setAttribute('tabindex', '-1');
          } else {
            if(i < j) j = i;
            carousel.items[i].removeAttribute('tabindex');
          }
        } else {
          if( (i < carousel.selectedItem || i >= carousel.selectedItem + carousel.visibItemsNb) && carouselActive) {
            carousel.items[i].setAttribute('tabindex', '-1');
          } else {
            if(i < j) j = i;
            carousel.items[i].removeAttribute('tabindex');
          }
        }
      }
      resetVisibilityOverflowItems(carousel, j);
    };
  
    function startAutoplay(carousel) {
      if(carousel.options.autoplay && !carousel.autoplayId && !carousel.autoplayPaused) {
        carousel.autoplayId = setInterval(function(){
          showNextItems(carousel);
        }, carousel.options.autoplayInterval);
      }
    };
  
    function pauseAutoplay(carousel) {
      if(carousel.options.autoplay) {
        clearInterval(carousel.autoplayId);
        carousel.autoplayId = false;
      }
    };
  
    function initAriaLive(carousel) { // create an aria-live region for SR
      if(!carousel.options.ariaLive) return;
      // create an element that will be used to announce the new visible slide to SR
      var srLiveArea = document.createElement('div');
      Util.setAttributes(srLiveArea, {'class': 'sr-only js-carousel__aria-live', 'aria-live': 'polite', 'aria-atomic': 'true'});
      carousel.element.appendChild(srLiveArea);
      carousel.ariaLive = srLiveArea;
    };
  
    function updateAriaLive(carousel) { // announce to SR which items are now visible
      if(!carousel.options.ariaLive) return;
      carousel.ariaLive.innerHTML = 'Item '+(carousel.selectedItem + 1)+' selected. '+carousel.visibItemsNb+' items of '+carousel.initItems.length+' visible';
    };
  
    function getIndex(carousel, index) {
      if(index < 0) index = getPositiveValue(index, carousel.itemsNb);
      if(index >= carousel.itemsNb) index = index % carousel.itemsNb;
      return index;
    };
  
    function getPositiveValue(value, add) {
      value = value + add;
      if(value > 0) return value;
      else return getPositiveValue(value, add);
    };
  
    function setTranslate(carousel, translate) {
      carousel.list.style.transform = translate;
      carousel.list.style.msTransform = translate;
    };
  
    function getCarouselWidth(carousel, computedWidth) { // retrieve carousel width if carousel is initially hidden
      var closestHidden = carousel.listWrapper.closest('.sr-only');
      if(closestHidden) { // carousel is inside an .sr-only (visually hidden) element
        Util.removeClass(closestHidden, 'sr-only');
        computedWidth = carousel.listWrapper.offsetWidth;
        Util.addClass(closestHidden, 'sr-only');
      }
      return computedWidth;
    };
  
    function resetCarouselControls(carousel) {
      if(carousel.options.loop) return;
      // update arrows status
      if(carousel.controls.length > 0) {
        (carousel.totTranslate == 0) 
          ? carousel.controls[0].setAttribute('disabled', true) 
          : carousel.controls[0].removeAttribute('disabled');
        (carousel.totTranslate == (- carousel.translateContainer - carousel.containerWidth) || carousel.items.length <= carousel.visibItemsNb) 
          ? carousel.controls[1].setAttribute('disabled', true) 
          : carousel.controls[1].removeAttribute('disabled');
      }
      // update carousel dots
      if(carousel.options.nav) {
        var selectedDot = carousel.navigation.getElementsByClassName(carousel.options.navigationItemClass+'--selected');
        if(selectedDot.length > 0) Util.removeClass(selectedDot[0], carousel.options.navigationItemClass+'--selected');
  
        var newSelectedIndex = getSelectedDot(carousel);
        if(carousel.totTranslate == (- carousel.translateContainer - carousel.containerWidth)) {
          newSelectedIndex = carousel.navDots.length - 1;
        }
        Util.addClass(carousel.navDots[newSelectedIndex], carousel.options.navigationItemClass+'--selected');
      }
    };
  
    function emitCarouselUpdateEvent(carousel) {
      carousel.cloneList = [];
      var clones = carousel.element.querySelectorAll('.js-clone');
      for(var i = 0; i < clones.length; i++) {
        Util.removeClass(clones[i], 'js-clone');
        carousel.cloneList.push(clones[i]);
      }
      emitCarouselEvents(carousel, 'carousel-updated', carousel.cloneList);
    };
  
    function carouselCreateNavigation(carousel) {
      if(carousel.element.getElementsByClassName('js-carousel__navigation').length > 0) return;
    
      var navigation = document.createElement('ol'),
        navChildren = '';
  
      var navClasses = carousel.options.navigationClass+' js-carousel__navigation';
      if(carousel.items.length <= carousel.visibItemsNb) {
        navClasses = navClasses + ' is-hidden';
      }
      navigation.setAttribute('class', navClasses);
  
      var dotsNr = Math.ceil(carousel.items.length/carousel.visibItemsNb),
        selectedDot = getSelectedDot(carousel),
        indexClass = carousel.options.navigationPagination ? '' : 'sr-only'
      for(var i = 0; i < dotsNr; i++) {
        var className = (i == selectedDot) ? 'class="'+carousel.options.navigationItemClass+' '+carousel.options.navigationItemClass+'--selected js-carousel__nav-item"' :  'class="'+carousel.options.navigationItemClass+' js-carousel__nav-item"';
        navChildren = navChildren + '<li '+className+'><button class="reset js-tab-focus" style="outline: none;"><span class="'+indexClass+'">'+ (i+1) + '</span></button></li>';
      }
      navigation.innerHTML = navChildren;
      carousel.element.appendChild(navigation);
    };
  
    function carouselInitNavigationEvents(carousel) {
      carousel.navigation = carousel.element.getElementsByClassName('js-carousel__navigation')[0];
      carousel.navDots = carousel.element.getElementsByClassName('js-carousel__nav-item');
      carousel.navIdEvent = carouselNavigationClick.bind(carousel);
      carousel.navigation.addEventListener('click', carousel.navIdEvent);
    };
  
    function carouselRemoveNavigation(carousel) {
      if(carousel.navigation) carousel.element.removeChild(carousel.navigation);
      if(carousel.navIdEvent) carousel.navigation.removeEventListener('click', carousel.navIdEvent);
    };
  
    function resetDotsNavigation(carousel) {
      if(!carousel.options.nav) return;
      carouselRemoveNavigation(carousel);
      carouselCreateNavigation(carousel);
      carouselInitNavigationEvents(carousel);
    };
  
    function carouselNavigationClick(event) {
      var dot = event.target.closest('.js-carousel__nav-item');
      if(!dot) return;
      if(this.animating) return;
      this.animating = true;
      var index = Util.getIndexInArray(this.navDots, dot);
      this.selectedDotIndex = index;
      this.selectedItem = index*this.visibItemsNb;
      animateList(this, false, 'click');
    };
  
    function getSelectedDot(carousel) {
      return Math.ceil(carousel.selectedItem/carousel.visibItemsNb);
    };
  
    function initCarouselCounter(carousel) {
      if(carousel.counterTor.length > 0) carousel.counterTor[0].textContent = carousel.itemsNb;
      setCounterItem(carousel);
    };
  
    function setCounterItem(carousel) {
      if(carousel.counter.length == 0) return;
      var totalItems = carousel.selectedItem + carousel.visibItemsNb;
      if(totalItems > carousel.items.length) totalItems = carousel.items.length;
      carousel.counter[0].textContent = totalItems;
    };
  
    function centerItems(carousel) {
      if(!carousel.options.justifyContent) return;
      Util.toggleClass(carousel.list, 'justify-center', carousel.items.length < carousel.visibItemsNb);
    };
  
    function alignControls(carousel) {
      if(carousel.controls.length < 1 || !carousel.options.alignControls) return;
      if(!carousel.controlsAlignEl) {
        carousel.controlsAlignEl = carousel.element.querySelector(carousel.options.alignControls);
      }
      if(!carousel.controlsAlignEl) return;
      var translate = (carousel.element.offsetHeight - carousel.controlsAlignEl.offsetHeight);
      for(var i = 0; i < carousel.controls.length; i++) {
        carousel.controls[i].style.marginBottom = translate + 'px';
      }
    };
  
    function emitCarouselEvents(carousel, eventName, eventDetail) {
      var event = new CustomEvent(eventName, {detail: eventDetail});
      carousel.element.dispatchEvent(event);
    };
  
    function resetVisibilityOverflowItems(carousel, j) {
      if(!carousel.options.overflowItems) return;
      var itemWidth = carousel.containerWidth/carousel.items.length,
        delta = (window.innerWidth - itemWidth*carousel.visibItemsNb)/2,
        overflowItems = Math.ceil(delta/itemWidth);
  
      for(var i = 0; i < overflowItems; i++) {
        var indexPrev = j - 1 - i; // prev element
        if(indexPrev >= 0 ) carousel.items[indexPrev].removeAttribute('tabindex');
        var indexNext = j + carousel.visibItemsNb + i; // next element
        if(indexNext < carousel.items.length) carousel.items[indexNext].removeAttribute('tabindex');
      }
    };
  
    Carousel.defaults = {
      element : '',
      autoplay : false,
      autoplayInterval: 5000,
      loop: true,
      nav: false,
      navigationItemClass: 'carousel__nav-item',
      navigationClass: 'carousel__navigation',
      navigationPagination: false,
      drag: false,
      justifyContent: false,
      alignControls: false,
      overflowItems: false
    };
  
    window.Carousel = Carousel;
  
    //initialize the Carousel objects
    var carousels = document.getElementsByClassName('js-carousel'),
      flexSupported = Util.cssSupports('align-items', 'stretch'),
      transitionSupported = Util.cssSupports('transition');
  
    if( carousels.length > 0) {
      for( var i = 0; i < carousels.length; i++) {
        (function(i){
          var autoplay = (carousels[i].getAttribute('data-autoplay') && carousels[i].getAttribute('data-autoplay') == 'on') ? true : false,
            autoplayInterval = (carousels[i].getAttribute('data-autoplay-interval')) ? carousels[i].getAttribute('data-autoplay-interval') : 5000,
            drag = (carousels[i].getAttribute('data-drag') && carousels[i].getAttribute('data-drag') == 'on') ? true : false,
            loop = (carousels[i].getAttribute('data-loop') && carousels[i].getAttribute('data-loop') == 'off') ? false : true,
            nav = (carousels[i].getAttribute('data-navigation') && carousels[i].getAttribute('data-navigation') == 'on') ? true : false,
            navigationItemClass = carousels[i].getAttribute('data-navigation-item-class') ? carousels[i].getAttribute('data-navigation-item-class') : 'carousel__nav-item',
            navigationClass = carousels[i].getAttribute('data-navigation-class') ? carousels[i].getAttribute('data-navigation-class') : 'carousel__navigation',
            navigationPagination = (carousels[i].getAttribute('data-navigation-pagination') && carousels[i].getAttribute('data-navigation-pagination') == 'on') ? true : false,
            overflowItems = (carousels[i].getAttribute('data-overflow-items') && carousels[i].getAttribute('data-overflow-items') == 'on') ? true : false,
            alignControls = carousels[i].getAttribute('data-align-controls') ? carousels[i].getAttribute('data-align-controls') : false,
            justifyContent = (carousels[i].getAttribute('data-justify-content') && carousels[i].getAttribute('data-justify-content') == 'on') ? true : false;
          new Carousel({element: carousels[i], autoplay : autoplay, autoplayInterval : autoplayInterval, drag: drag, ariaLive: true, loop: loop, nav: nav, navigationItemClass: navigationItemClass, navigationPagination: navigationPagination, navigationClass: navigationClass, overflowItems: overflowItems, justifyContent: justifyContent, alignControls: alignControls});
        })(i);
      }
    };
  }());
// File#: _2_dropdown
// Usage: codyhouse.co/license
(function() {
    var Dropdown = function(element) {
      this.element = element;
      this.trigger = this.element.getElementsByClassName('dropdown__trigger')[0];
      this.dropdown = this.element.getElementsByClassName('dropdown__menu')[0];
      this.triggerFocus = false;
      this.dropdownFocus = false;
      this.hideInterval = false;
      // sublevels
      this.dropdownSubElements = this.element.getElementsByClassName('dropdown__sub-wrapperu');
      this.prevFocus = false; // store element that was in focus before focus changed
      this.addDropdownEvents();
    };
    
    Dropdown.prototype.addDropdownEvents = function(){
      //place dropdown
      var self = this;
      this.placeElement();
      this.element.addEventListener('placeDropdown', function(event){
        self.placeElement();
      });
      // init dropdown
      this.initElementEvents(this.trigger, this.triggerFocus); // this is used to trigger the primary dropdown
      this.initElementEvents(this.dropdown, this.dropdownFocus); // this is used to trigger the primary dropdown
      // init sublevels
      this.initSublevels(); // if there are additional sublevels -> bind hover/focus events
    };
  
    Dropdown.prototype.placeElement = function() {
      var triggerPosition = this.trigger.getBoundingClientRect(),
        isRight = (window.innerWidth < triggerPosition.left + parseInt(getComputedStyle(this.dropdown).getPropertyValue('width')));
  
      var xPosition = isRight ? 'right: 0px; left: auto;' : 'left: 0px; right: auto;';
      this.dropdown.setAttribute('style', xPosition);
    };
  
    Dropdown.prototype.initElementEvents = function(element, bool) {
      var self = this;
      element.addEventListener('mouseenter', function(){
        bool = true;
        self.showDropdown();
      });
      element.addEventListener('focus', function(){
        self.showDropdown();
      });
      element.addEventListener('mouseleave', function(){
        bool = false;
        self.hideDropdown();
      });
      element.addEventListener('focusout', function(){
        self.hideDropdown();
      });
    };
  
    Dropdown.prototype.showDropdown = function(){
      if(this.hideInterval) clearInterval(this.hideInterval);
      this.showLevel(this.dropdown, true);
    };
  
    Dropdown.prototype.hideDropdown = function(){
      var self = this;
      if(this.hideInterval) clearInterval(this.hideInterval);
      this.hideInterval = setTimeout(function(){
        var dropDownFocus = document.activeElement.closest('.js-dropdown'),
          inFocus = dropDownFocus && (dropDownFocus == self.element);
        // if not in focus and not hover -> hide
        if(!self.triggerFocus && !self.dropdownFocus && !inFocus) {
          self.hideLevel(self.dropdown);
          // make sure to hide sub/dropdown
          self.hideSubLevels();
          self.prevFocus = false;
        }
      }, 300);
    };
  
    Dropdown.prototype.initSublevels = function(){
      var self = this;
      var dropdownMenu = this.element.getElementsByClassName('dropdown__menu');
      for(var i = 0; i < dropdownMenu.length; i++) {
        var listItems = dropdownMenu[i].children;
        // bind hover
        new menuAim({
          menu: dropdownMenu[i],
          activate: function(row) {
              var subList = row.getElementsByClassName('dropdown__menu')[0];
              if(!subList) return;
              Util.addClass(row.querySelector('a'), 'dropdown__item--hover');
              self.showLevel(subList);
          },
          deactivate: function(row) {
              var subList = row.getElementsByClassName('dropdown__menu')[0];
              if(!subList) return;
              Util.removeClass(row.querySelector('a'), 'dropdown__item--hover');
              self.hideLevel(subList);
          },
          submenuSelector: '.dropdown__sub-wrapper',
        });
      }
      // store focus element before change in focus
      this.element.addEventListener('keydown', function(event) { 
        if( event.keyCode && event.keyCode == 9 || event.key && event.key == 'Tab' ) {
          self.prevFocus = document.activeElement;
        }
      });
      // make sure that sublevel are visible when their items are in focus
      this.element.addEventListener('keyup', function(event) {
        if( event.keyCode && event.keyCode == 9 || event.key && event.key == 'Tab' ) {
          // focus has been moved -> make sure the proper classes are added to subnavigation
          var focusElement = document.activeElement,
            focusElementParent = focusElement.closest('.dropdown__menu'),
            focusElementSibling = focusElement.nextElementSibling;
  
          // if item in focus is inside submenu -> make sure it is visible
          if(focusElementParent && !Util.hasClass(focusElementParent, 'dropdown__menu--is-visible')) {
            self.showLevel(focusElementParent);
          }
          // if item in focus triggers a submenu -> make sure it is visible
          if(focusElementSibling && !Util.hasClass(focusElementSibling, 'dropdown__menu--is-visible')) {
            self.showLevel(focusElementSibling);
          }
  
          // check previous element in focus -> hide sublevel if required 
          if( !self.prevFocus) return;
          var prevFocusElementParent = self.prevFocus.closest('.dropdown__menu'),
            prevFocusElementSibling = self.prevFocus.nextElementSibling;
          
          if( !prevFocusElementParent ) return;
          
          // element in focus and element prev in focus are siblings
          if( focusElementParent && focusElementParent == prevFocusElementParent) {
            if(prevFocusElementSibling) self.hideLevel(prevFocusElementSibling);
            return;
          }
  
          // element in focus is inside submenu triggered by element prev in focus
          if( prevFocusElementSibling && focusElementParent && focusElementParent == prevFocusElementSibling) return;
          
          // shift tab -> element in focus triggers the submenu of the element prev in focus
          if( focusElementSibling && prevFocusElementParent && focusElementSibling == prevFocusElementParent) return;
          
          var focusElementParentParent = focusElementParent.parentNode.closest('.dropdown__menu');
          
          // shift tab -> element in focus is inside the dropdown triggered by a siblings of the element prev in focus
          if(focusElementParentParent && focusElementParentParent == prevFocusElementParent) {
            if(prevFocusElementSibling) self.hideLevel(prevFocusElementSibling);
            return;
          }
          
          if(prevFocusElementParent && Util.hasClass(prevFocusElementParent, 'dropdown__menu--is-visible')) {
            self.hideLevel(prevFocusElementParent);
          }
        }
      });
    };
  
    Dropdown.prototype.hideSubLevels = function(){
      var visibleSubLevels = this.dropdown.getElementsByClassName('dropdown__menu--is-visible');
      if(visibleSubLevels.length == 0) return;
      while (visibleSubLevels[0]) {
        this.hideLevel(visibleSubLevels[0]);
         }
         var hoveredItems = this.dropdown.getElementsByClassName('dropdown__item--hover');
         while (hoveredItems[0]) {
        Util.removeClass(hoveredItems[0], 'dropdown__item--hover');
         }
    };
  
    Dropdown.prototype.showLevel = function(level, bool){
      if(bool == undefined) {
        //check if the sublevel needs to be open to the left
        Util.removeClass(level, 'dropdown__menu--left');
        var boundingRect = level.getBoundingClientRect();
        if(window.innerWidth - boundingRect.right < 5 && boundingRect.left + window.scrollX > 2*boundingRect.width) Util.addClass(level, 'dropdown__menu--left');
      }
      Util.addClass(level, 'dropdown__menu--is-visible');
      Util.removeClass(level, 'dropdown__menu--is-hidden');
    };
  
    Dropdown.prototype.hideLevel = function(level){
      if(!Util.hasClass(level, 'dropdown__menu--is-visible')) return;
      Util.removeClass(level, 'dropdown__menu--is-visible');
      Util.addClass(level, 'dropdown__menu--is-hidden');
      
      level.addEventListener('animationend', function cb(){
        level.removeEventListener('animationend', cb);
        Util.removeClass(level, 'dropdown__menu--is-hidden dropdown__menu--left');
      });
    };
  
  
    var dropdown = document.getElementsByClassName('js-dropdown');
    if( dropdown.length > 0 ) { // init Dropdown objects
      for( var i = 0; i < dropdown.length; i++) {
        (function(i){new Dropdown(dropdown[i]);})(i);
      }
    }
  }());
// File#: _2_flexi-header
// Usage: codyhouse.co/license
(function() {
    var flexHeader = document.getElementsByClassName('js-f-header');
    if(flexHeader.length > 0) {
      var menuTrigger = flexHeader[0].getElementsByClassName('js-anim-menu-btn')[0],
        firstFocusableElement = getMenuFirstFocusable();
  
      // we'll use these to store the node that needs to receive focus when the mobile menu is closed 
      var focusMenu = false;
  
      menuTrigger.addEventListener('anim-menu-btn-clicked', function(event){
        toggleMenuNavigation(event.detail);
      });
  
      // listen for key events
      window.addEventListener('keyup', function(event){
        // listen for esc key
        if( (event.keyCode && event.keyCode == 27) || (event.key && event.key.toLowerCase() == 'escape' )) {
          // close navigation on mobile if open
          if(menuTrigger.getAttribute('aria-expanded') == 'true' && isVisible(menuTrigger)) {
            focusMenu = menuTrigger; // move focus to menu trigger when menu is close
            menuTrigger.click();
          }
        }
        // listen for tab key
        if( (event.keyCode && event.keyCode == 9) || (event.key && event.key.toLowerCase() == 'tab' )) {
          // close navigation on mobile if open when nav loses focus
          if(menuTrigger.getAttribute('aria-expanded') == 'true' && isVisible(menuTrigger) && !document.activeElement.closest('.js-f-header')) menuTrigger.click();
        }
      });
  
      // listen for resize
      var resizingId = false;
      window.addEventListener('resize', function() {
        clearTimeout(resizingId);
        resizingId = setTimeout(doneResizing, 500);
      });
  
      function getMenuFirstFocusable() {
        var focusableEle = flexHeader[0].getElementsByClassName('f-header__nav')[0].querySelectorAll('[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, [tabindex]:not([tabindex="-1"]), [contenteditable], audio[controls], video[controls], summary'),
          firstFocusable = false;
        for(var i = 0; i < focusableEle.length; i++) {
          if( focusableEle[i].offsetWidth || focusableEle[i].offsetHeight || focusableEle[i].getClientRects().length ) {
            firstFocusable = focusableEle[i];
            break;
          }
        }
  
        return firstFocusable;
      };
      
      function isVisible(element) {
        return (element.offsetWidth || element.offsetHeight || element.getClientRects().length);
      };
  
      function doneResizing() {
        if( !isVisible(menuTrigger) && Util.hasClass(flexHeader[0], 'f-header--expanded')) {
          menuTrigger.click();
        }
      };
      
      function toggleMenuNavigation(bool) { // toggle menu visibility on small devices
        Util.toggleClass(document.getElementsByClassName('f-header__nav')[0], 'f-header__nav--is-visible', bool);
        Util.toggleClass(flexHeader[0], 'f-header--expanded', bool);
        menuTrigger.setAttribute('aria-expanded', bool);
        if(bool) firstFocusableElement.focus(); // move focus to first focusable element
        else if(focusMenu) {
          focusMenu.focus();
          focusMenu = false;
        }
      };
    }
  }());
// File#: _2_menu-bar
// Usage: codyhouse.co/license
(function() {
    var MenuBar = function(element) {
      this.element = element;
      this.items = Util.getChildrenByClassName(this.element, 'menu-bar__item');
      this.mobHideItems = this.element.getElementsByClassName('menu-bar__item--hide');
      this.moreItemsTrigger = this.element.getElementsByClassName('js-menu-bar__trigger');
      initMenuBar(this);
    };
  
    function initMenuBar(menu) {
      setMenuTabIndex(menu); // set correct tabindexes for menu item
      initMenuBarMarkup(menu); // create additional markup
      checkMenuLayout(menu); // set menu layout
      Util.addClass(menu.element, 'menu-bar--loaded'); // reveal menu
  
      // custom event emitted when window is resized
      menu.element.addEventListener('update-menu-bar', function(event){
        checkMenuLayout(menu);
        if(menu.menuInstance) menu.menuInstance.toggleMenu(false, false); // close dropdown
      });
  
      // keyboard events 
      // open dropdown when pressing Enter on trigger element
      if(menu.moreItemsTrigger.length > 0) {
        menu.moreItemsTrigger[0].addEventListener('keydown', function(event) {
          if( (event.keyCode && event.keyCode == 13) || (event.key && event.key.toLowerCase() == 'enter') ) {
            if(!menu.menuInstance) return;
            menu.menuInstance.selectedTrigger = menu.moreItemsTrigger[0];
            menu.menuInstance.toggleMenu(!Util.hasClass(menu.subMenu, 'menu--is-visible'), true);
          }
        });
  
        // close dropdown on esc
        menu.subMenu.addEventListener('keydown', function(event) {
          if((event.keyCode && event.keyCode == 27) || (event.key && event.key.toLowerCase() == 'escape')) { // close submenu on esc
            if(menu.menuInstance) menu.menuInstance.toggleMenu(false, true);
          }
        });
      }
      
      // navigate menu items using left/right arrows
      menu.element.addEventListener('keydown', function(event) {
        if( (event.keyCode && event.keyCode == 39) || (event.key && event.key.toLowerCase() == 'arrowright') ) {
          navigateItems(menu.items, event, 'next');
        } else if( (event.keyCode && event.keyCode == 37) || (event.key && event.key.toLowerCase() == 'arrowleft') ) {
          navigateItems(menu.items, event, 'prev');
        }
      });
    };
  
    function setMenuTabIndex(menu) { // set tabindexes for the menu items to allow keyboard navigation
      var nextItem = false;
      for(var i = 0; i < menu.items.length; i++ ) {
        if(i == 0 || nextItem) menu.items[i].setAttribute('tabindex', '0');
        else menu.items[i].setAttribute('tabindex', '-1');
        if(i == 0 && menu.moreItemsTrigger.length > 0) nextItem = true;
        else nextItem = false;
      }
    };
  
    function initMenuBarMarkup(menu) {
      if(menu.mobHideItems.length == 0 ) { // no items to hide on mobile - remove trigger
        if(menu.moreItemsTrigger.length > 0) menu.element.removeChild(menu.moreItemsTrigger[0]);
        return;
      }
  
      if(menu.moreItemsTrigger.length == 0) return;
  
      // create the markup for the Menu element
      var content = '';
      menu.menuControlId = 'submenu-bar-'+Date.now();
      for(var i = 0; i < menu.mobHideItems.length; i++) {
        var item = menu.mobHideItems[i].cloneNode(true),
          svg = item.getElementsByTagName('svg')[0],
          label = item.getElementsByClassName('menu-bar__label')[0];
  
        svg.setAttribute('class', 'icon menu__icon');
        content = content + '<li role="menuitem"><span class="menu__content js-menu__content">'+svg.outerHTML+'<span>'+label.innerHTML+'</span></span></li>';
      }
  
      Util.setAttributes(menu.moreItemsTrigger[0], {'role': 'button', 'aria-expanded': 'false', 'aria-controls': menu.menuControlId, 'aria-haspopup': 'true'});
  
      var subMenu = document.createElement('menu'),
        customClass = menu.element.getAttribute('data-menu-class');
      Util.setAttributes(subMenu, {'id': menu.menuControlId, 'class': 'menu js-menu '+customClass});
      subMenu.innerHTML = content;
      document.body.appendChild(subMenu);
  
      menu.subMenu = subMenu;
      menu.subItems = subMenu.getElementsByTagName('li');
  
      menu.menuInstance = new Menu(menu.subMenu); // this will handle the dropdown behaviour
    };
  
    function checkMenuLayout(menu) { // switch from compressed to expanded layout and viceversa
      var layout = getComputedStyle(menu.element, ':before').getPropertyValue('content').replace(/\'|"/g, '');
      Util.toggleClass(menu.element, 'menu-bar--collapsed', layout == 'collapsed');
    };
  
    function navigateItems(list, event, direction, prevIndex) { // keyboard navigation among menu items
      event.preventDefault();
      var index = (typeof prevIndex !== 'undefined') ? prevIndex : Util.getIndexInArray(list, event.target),
        nextIndex = direction == 'next' ? index + 1 : index - 1;
      if(nextIndex < 0) nextIndex = list.length - 1;
      if(nextIndex > list.length - 1) nextIndex = 0;
      // check if element is visible before moving focus
      (list[nextIndex].offsetParent === null) ? navigateItems(list, event, direction, nextIndex) : Util.moveFocus(list[nextIndex]);
    };
  
    function checkMenuClick(menu, target) { // close dropdown when clicking outside the menu element
      if(menu.menuInstance && !menu.moreItemsTrigger[0].contains(target) && !menu.subMenu.contains(target)) menu.menuInstance.toggleMenu(false, false);
    };
  
    // init MenuBars objects
    var menuBars = document.getElementsByClassName('js-menu-bar');
    if( menuBars.length > 0 ) {
      var j = 0,
        menuBarArray = [];
      for( var i = 0; i < menuBars.length; i++) {
        var beforeContent = getComputedStyle(menuBars[i], ':before').getPropertyValue('content');
        if(beforeContent && beforeContent !='' && beforeContent !='none') {
          (function(i){menuBarArray.push(new MenuBar(menuBars[i]));})(i);
          j = j + 1;
        }
      }
      
      if(j > 0) {
        var resizingId = false,
          customEvent = new CustomEvent('update-menu-bar');
        // update Menu Bar layout on resize  
        window.addEventListener('resize', function(event){
          clearTimeout(resizingId);
          resizingId = setTimeout(doneResizing, 150);
        });
  
        // close menu when clicking outside it
        window.addEventListener('click', function(event){
          menuBarArray.forEach(function(element){
            checkMenuClick(element, event.target);
          });
        });
  
        function doneResizing() {
          for( var i = 0; i < menuBars.length; i++) {
            (function(i){menuBars[i].dispatchEvent(customEvent)})(i);
          };
        };
      }
    }
  }());
// File#: _2_pricing-table
// Usage: codyhouse.co/license
(function() {
    // NOTE: you need the js code only when using the --has-switch variation of the pricing table
    // default version does not require js
    var pTable = document.getElementsByClassName('js-p-table--has-switch');
    if(pTable.length > 0) {
      for(var i = 0; i < pTable.length; i++) {
        (function(i){ addPTableEvent(pTable[i]);})(i);
      }
  
      function addPTableEvent(element) {
        var pSwitch = element.getElementsByClassName('js-p-table__switch')[0];
        if(pSwitch) {
          pSwitch.addEventListener('change', function(event) {
            Util.toggleClass(element, 'p-table--yearly', (event.target.value == 'yearly'));
          });
        }
      }
    }
  }());
// File#: _2_slideshow
// Usage: codyhouse.co/license
(function() {
    var Slideshow = function(opts) {
      this.options = slideshowAssignOptions(Slideshow.defaults , opts);
      this.element = this.options.element;
      this.items = this.element.getElementsByClassName('js-slideshow__item');
      this.controls = this.element.getElementsByClassName('js-slideshow__control'); 
      this.selectedSlide = 0;
      this.autoplayId = false;
      this.autoplayPaused = false;
      this.navigation = false;
      this.navCurrentLabel = false;
      this.ariaLive = false;
      this.moveFocus = false;
      this.animating = false;
      this.supportAnimation = Util.cssSupports('transition');
      this.animationOff = (!Util.hasClass(this.element, 'slideshow--transition-fade') && !Util.hasClass(this.element, 'slideshow--transition-slide') && !Util.hasClass(this.element, 'slideshow--transition-prx'));
      this.animationType = Util.hasClass(this.element, 'slideshow--transition-prx') ? 'prx' : 'slide';
      this.animatingClass = 'slideshow--is-animating';
      initSlideshow(this);
      initSlideshowEvents(this);
      initAnimationEndEvents(this);
    };
  
    Slideshow.prototype.showNext = function() {
      showNewItem(this, this.selectedSlide + 1, 'next');
    };
  
    Slideshow.prototype.showPrev = function() {
      showNewItem(this, this.selectedSlide - 1, 'prev');
    };
  
    Slideshow.prototype.showItem = function(index) {
      showNewItem(this, index, false);
    };
  
    Slideshow.prototype.startAutoplay = function() {
      var self = this;
      if(this.options.autoplay && !this.autoplayId && !this.autoplayPaused) {
        self.autoplayId = setInterval(function(){
          self.showNext();
        }, self.options.autoplayInterval);
      }
    };
  
    Slideshow.prototype.pauseAutoplay = function() {
      var self = this;
      if(this.options.autoplay) {
        clearInterval(self.autoplayId);
        self.autoplayId = false;
      }
    };
  
    function slideshowAssignOptions(defaults, opts) {
      // initialize the object options
      var mergeOpts = {};
      mergeOpts.element = (typeof opts.element !== "undefined") ? opts.element : defaults.element;
      mergeOpts.navigation = (typeof opts.navigation !== "undefined") ? opts.navigation : defaults.navigation;
      mergeOpts.autoplay = (typeof opts.autoplay !== "undefined") ? opts.autoplay : defaults.autoplay;
      mergeOpts.autoplayInterval = (typeof opts.autoplayInterval !== "undefined") ? opts.autoplayInterval : defaults.autoplayInterval;
      mergeOpts.swipe = (typeof opts.swipe !== "undefined") ? opts.swipe : defaults.swipe;
      return mergeOpts;
    };
  
    function initSlideshow(slideshow) { // basic slideshow settings
      // if no slide has been selected -> select the first one
      if(slideshow.element.getElementsByClassName('slideshow__item--selected').length < 1) Util.addClass(slideshow.items[0], 'slideshow__item--selected');
      slideshow.selectedSlide = Util.getIndexInArray(slideshow.items, slideshow.element.getElementsByClassName('slideshow__item--selected')[0]);
      // create an element that will be used to announce the new visible slide to SR
      var srLiveArea = document.createElement('div');
      Util.setAttributes(srLiveArea, {'class': 'sr-only js-slideshow__aria-live', 'aria-live': 'polite', 'aria-atomic': 'true'});
      slideshow.element.appendChild(srLiveArea);
      slideshow.ariaLive = srLiveArea;
    };
  
    function initSlideshowEvents(slideshow) {
      // if slideshow navigation is on -> create navigation HTML and add event listeners
      if(slideshow.options.navigation) {
        // check if navigation has already been included
        if(slideshow.element.getElementsByClassName('js-slideshow__navigation').length == 0) {
          var navigation = document.createElement('ol'),
            navChildren = '';
  
          var navClasses = 'slideshow__navigation js-slideshow__navigation';
          if(slideshow.items.length <= 1) {
            navClasses = navClasses + ' is-hidden';
          } 
          
          navigation.setAttribute('class', navClasses);
          for(var i = 0; i < slideshow.items.length; i++) {
            var className = (i == slideshow.selectedSlide) ? 'class="slideshow__nav-item slideshow__nav-item--selected js-slideshow__nav-item"' :  'class="slideshow__nav-item js-slideshow__nav-item"',
              navCurrentLabel = (i == slideshow.selectedSlide) ? '<span class="sr-only js-slideshow__nav-current-label">Current Item</span>' : '';
            navChildren = navChildren + '<li '+className+'><button class="reset"><span class="sr-only">'+ (i+1) + '</span>'+navCurrentLabel+'</button></li>';
          }
          navigation.innerHTML = navChildren;
          slideshow.element.appendChild(navigation);
        }
        
        slideshow.navCurrentLabel = slideshow.element.getElementsByClassName('js-slideshow__nav-current-label')[0]; 
        slideshow.navigation = slideshow.element.getElementsByClassName('js-slideshow__nav-item');
  
        var dotsNavigation = slideshow.element.getElementsByClassName('js-slideshow__navigation')[0];
  
        dotsNavigation.addEventListener('click', function(event){
          navigateSlide(slideshow, event, true);
        });
        dotsNavigation.addEventListener('keyup', function(event){
          navigateSlide(slideshow, event, (event.key.toLowerCase() == 'enter'));
        });
      }
      // slideshow arrow controls
      if(slideshow.controls.length > 0) {
        // hide controls if one item available
        if(slideshow.items.length <= 1) {
          Util.addClass(slideshow.controls[0], 'is-hidden');
          Util.addClass(slideshow.controls[1], 'is-hidden');
        }
        slideshow.controls[0].addEventListener('click', function(event){
          event.preventDefault();
          slideshow.showPrev();
          updateAriaLive(slideshow);
        });
        slideshow.controls[1].addEventListener('click', function(event){
          event.preventDefault();
          slideshow.showNext();
          updateAriaLive(slideshow);
        });
      }
      // swipe events
      if(slideshow.options.swipe) {
        //init swipe
        new SwipeContent(slideshow.element);
        slideshow.element.addEventListener('swipeLeft', function(event){
          slideshow.showNext();
        });
        slideshow.element.addEventListener('swipeRight', function(event){
          slideshow.showPrev();
        });
      }
      // autoplay
      if(slideshow.options.autoplay) {
        slideshow.startAutoplay();
        // pause autoplay if user is interacting with the slideshow
        slideshow.element.addEventListener('mouseenter', function(event){
          slideshow.pauseAutoplay();
          slideshow.autoplayPaused = true;
        });
        slideshow.element.addEventListener('focusin', function(event){
          slideshow.pauseAutoplay();
          slideshow.autoplayPaused = true;
        });
        slideshow.element.addEventListener('mouseleave', function(event){
          slideshow.autoplayPaused = false;
          slideshow.startAutoplay();
        });
        slideshow.element.addEventListener('focusout', function(event){
          slideshow.autoplayPaused = false;
          slideshow.startAutoplay();
        });
      }
      // detect if external buttons control the slideshow
      var slideshowId = slideshow.element.getAttribute('id');
      if(slideshowId) {
        var externalControls = document.querySelectorAll('[data-controls="'+slideshowId+'"]');
        for(var i = 0; i < externalControls.length; i++) {
          (function(i){externalControlSlide(slideshow, externalControls[i]);})(i);
        }
      }
      // custom event to trigger selection of a new slide element
      slideshow.element.addEventListener('selectNewItem', function(event){
        // check if slide is already selected
        if(event.detail) {
          if(event.detail - 1 == slideshow.selectedSlide) return;
          showNewItem(slideshow, event.detail - 1, false);
        }
      });
    };
  
    function navigateSlide(slideshow, event, keyNav) { 
      // user has interacted with the slideshow navigation -> update visible slide
      var target = ( Util.hasClass(event.target, 'js-slideshow__nav-item') ) ? event.target : event.target.closest('.js-slideshow__nav-item');
      if(keyNav && target && !Util.hasClass(target, 'slideshow__nav-item--selected')) {
        slideshow.showItem(Util.getIndexInArray(slideshow.navigation, target));
        slideshow.moveFocus = true;
        updateAriaLive(slideshow);
      }
    };
  
    function initAnimationEndEvents(slideshow) {
      // remove animation classes at the end of a slide transition
      for( var i = 0; i < slideshow.items.length; i++) {
        (function(i){
          slideshow.items[i].addEventListener('animationend', function(){resetAnimationEnd(slideshow, slideshow.items[i]);});
          slideshow.items[i].addEventListener('transitionend', function(){resetAnimationEnd(slideshow, slideshow.items[i]);});
        })(i);
      }
    };
  
    function resetAnimationEnd(slideshow, item) {
      setTimeout(function(){ // add a delay between the end of animation and slideshow reset - improve animation performance
        if(Util.hasClass(item,'slideshow__item--selected')) {
          if(slideshow.moveFocus) Util.moveFocus(item);
          emitSlideshowEvent(slideshow, 'newItemVisible', slideshow.selectedSlide);
          slideshow.moveFocus = false;
        }
        Util.removeClass(item, 'slideshow__item--'+slideshow.animationType+'-out-left slideshow__item--'+slideshow.animationType+'-out-right slideshow__item--'+slideshow.animationType+'-in-left slideshow__item--'+slideshow.animationType+'-in-right');
        item.removeAttribute('aria-hidden');
        slideshow.animating = false;
        Util.removeClass(slideshow.element, slideshow.animatingClass); 
      }, 100);
    };
  
    function showNewItem(slideshow, index, bool) {
      if(slideshow.items.length <= 1) return;
      if(slideshow.animating && slideshow.supportAnimation) return;
      slideshow.animating = true;
      Util.addClass(slideshow.element, slideshow.animatingClass); 
      if(index < 0) index = slideshow.items.length - 1;
      else if(index >= slideshow.items.length) index = 0;
      var exitItemClass = getExitItemClass(slideshow, bool, slideshow.selectedSlide, index);
      var enterItemClass = getEnterItemClass(slideshow, bool, slideshow.selectedSlide, index);
      // transition between slides
      if(!slideshow.animationOff) Util.addClass(slideshow.items[slideshow.selectedSlide], exitItemClass);
      Util.removeClass(slideshow.items[slideshow.selectedSlide], 'slideshow__item--selected');
      slideshow.items[slideshow.selectedSlide].setAttribute('aria-hidden', 'true'); //hide to sr element that is exiting the viewport
      if(slideshow.animationOff) {
        Util.addClass(slideshow.items[index], 'slideshow__item--selected');
      } else {
        Util.addClass(slideshow.items[index], enterItemClass+' slideshow__item--selected');
      }
      // reset slider navigation appearance
      resetSlideshowNav(slideshow, index, slideshow.selectedSlide);
      slideshow.selectedSlide = index;
      // reset autoplay
      slideshow.pauseAutoplay();
      slideshow.startAutoplay();
      // reset controls/navigation color themes
      resetSlideshowTheme(slideshow, index);
      // emit event
      emitSlideshowEvent(slideshow, 'newItemSelected', slideshow.selectedSlide);
      if(slideshow.animationOff) {
        slideshow.animating = false;
        Util.removeClass(slideshow.element, slideshow.animatingClass);
      }
    };
  
    function getExitItemClass(slideshow, bool, oldIndex, newIndex) {
      var className = '';
      if(bool) {
        className = (bool == 'next') ? 'slideshow__item--'+slideshow.animationType+'-out-right' : 'slideshow__item--'+slideshow.animationType+'-out-left'; 
      } else {
        className = (newIndex < oldIndex) ? 'slideshow__item--'+slideshow.animationType+'-out-left' : 'slideshow__item--'+slideshow.animationType+'-out-right';
      }
      return className;
    };
  
    function getEnterItemClass(slideshow, bool, oldIndex, newIndex) {
      var className = '';
      if(bool) {
        className = (bool == 'next') ? 'slideshow__item--'+slideshow.animationType+'-in-right' : 'slideshow__item--'+slideshow.animationType+'-in-left'; 
      } else {
        className = (newIndex < oldIndex) ? 'slideshow__item--'+slideshow.animationType+'-in-left' : 'slideshow__item--'+slideshow.animationType+'-in-right';
      }
      return className;
    };
  
    function resetSlideshowNav(slideshow, newIndex, oldIndex) {
      if(slideshow.navigation) {
        Util.removeClass(slideshow.navigation[oldIndex], 'slideshow__nav-item--selected');
        Util.addClass(slideshow.navigation[newIndex], 'slideshow__nav-item--selected');
        slideshow.navCurrentLabel.parentElement.removeChild(slideshow.navCurrentLabel);
        slideshow.navigation[newIndex].getElementsByTagName('button')[0].appendChild(slideshow.navCurrentLabel);
      }
    };
  
    function resetSlideshowTheme(slideshow, newIndex) {
      var dataTheme = slideshow.items[newIndex].getAttribute('data-theme');
      if(dataTheme) {
        if(slideshow.navigation) slideshow.navigation[0].parentElement.setAttribute('data-theme', dataTheme);
        if(slideshow.controls[0]) slideshow.controls[0].parentElement.setAttribute('data-theme', dataTheme);
      } else {
        if(slideshow.navigation) slideshow.navigation[0].parentElement.removeAttribute('data-theme');
        if(slideshow.controls[0]) slideshow.controls[0].parentElement.removeAttribute('data-theme');
      }
    };
  
    function emitSlideshowEvent(slideshow, eventName, detail) {
      var event = new CustomEvent(eventName, {detail: detail});
      slideshow.element.dispatchEvent(event);
    };
  
    function updateAriaLive(slideshow) {
      slideshow.ariaLive.innerHTML = 'Item '+(slideshow.selectedSlide + 1)+' of '+slideshow.items.length;
    };
  
    function externalControlSlide(slideshow, button) { // control slideshow using external element
      button.addEventListener('click', function(event){
        var index = button.getAttribute('data-index');
        if(!index || index == slideshow.selectedSlide + 1) return;
        event.preventDefault();
        showNewItem(slideshow, index - 1, false);
      });
    };
  
    Slideshow.defaults = {
      element : '',
      navigation : true,
      autoplay : false,
      autoplayInterval: 5000,
      swipe: false
    };
  
    window.Slideshow = Slideshow;
    
    //initialize the Slideshow objects
    var slideshows = document.getElementsByClassName('js-slideshow');
    if( slideshows.length > 0 ) {
      for( var i = 0; i < slideshows.length; i++) {
        (function(i){
          var navigation = (slideshows[i].getAttribute('data-navigation') && slideshows[i].getAttribute('data-navigation') == 'off') ? false : true,
            autoplay = (slideshows[i].getAttribute('data-autoplay') && slideshows[i].getAttribute('data-autoplay') == 'on') ? true : false,
            autoplayInterval = (slideshows[i].getAttribute('data-autoplay-interval')) ? slideshows[i].getAttribute('data-autoplay-interval') : 5000,
            swipe = (slideshows[i].getAttribute('data-swipe') && slideshows[i].getAttribute('data-swipe') == 'on') ? true : false;
          new Slideshow({element: slideshows[i], navigation: navigation, autoplay : autoplay, autoplayInterval : autoplayInterval, swipe : swipe});
        })(i);
      }
    }
  }());
// File#: _3_expandable-img-gallery
// Usage: codyhouse.co/license

(function() {
    var ExpGallery = function(element) {
      this.element = element;
      this.slideshow = this.element.getElementsByClassName('js-exp-lightbox__body')[0];
      this.slideshowList = this.element.getElementsByClassName('js-exp-lightbox__slideshow')[0];
      this.slideshowId = this.element.getAttribute('id')
      this.gallery = document.querySelector('[data-controls="'+this.slideshowId+'"]');
      this.galleryItems = this.gallery.getElementsByClassName('js-exp-gallery__item');
      this.lazyload = this.gallery.getAttribute('data-placeholder');
      this.animationRunning = false;
      // menu bar
      this.menuBar = this.element.getElementsByClassName('js-menu-bar');
      initLightboxMarkup(this);
      lazyLoadLightbox(this);
      initSlideshow(this);
      initModal(this);
      initModalEvents(this);
    };
  
    function initLightboxMarkup(gallery) {
      // create items inside lightbox - modal slideshow
      var slideshowContent = '';
      for(var i = 0; i < gallery.galleryItems.length; i++) {
        var caption = gallery.galleryItems[i].getElementsByClassName('js-exp-gallery__caption'),
          image = gallery.galleryItems[i].getElementsByTagName('img')[0],
          caption = gallery.galleryItems[i].getElementsByClassName('js-exp-gallery__caption');
        // details
        var src = image.getAttribute('data-modal-src');
        if(!src) src = image.getAttribute('data-src');
        if(!src) src = image.getAttribute('src');
        var altAttr = image.getAttribute('alt')
        altAttr = altAttr ? 'alt="'+altAttr+'"' : '';
        var draggable = gallery.slideshow.getAttribute('data-swipe') == 'on' ? 'draggable="false" ondragstart="return false;"' : '';
        var imgBlock = gallery.lazyload 
          ? '<img data-src="'+src+'" data-loading="lazy" src="'+gallery.lazyload+'" '+altAttr+' '+draggable+'>'
          : '<img src="'+src+'" data-loading="lazy" '+draggable+'>';
  
        var captionBlock = caption.length > 0
          ? '<figcaption class="exp-lightbox__caption">'+caption[0].textContent+'</figcaption>'
          : '';
  
        slideshowContent = slideshowContent + '<li class="slideshow__item js-slideshow__item"><figure class="exp-lightbox__media"><div class="exp-lightbox__media-outer"><div class="exp-lightbox__media-inner">'+imgBlock+'</div></div>'+captionBlock+'</li>';
      }
      gallery.slideshowList.innerHTML = slideshowContent;
      gallery.slides = gallery.slideshowList.getElementsByClassName('js-slideshow__item');
  
      // append the morphing image - we will animate it from the selected slide to the final position (and viceversa)
      var imgMorph = document.createElement("div");
      Util.setAttributes(imgMorph, {'aria-hidden': 'true', 'class': 'exp-lightbox__clone-img-wrapper js-exp-lightbox__clone-img-wrapper', 'data-exp-morph': gallery.slideshowId});
      imgMorph.innerHTML = '<svg><defs><clipPath id="'+gallery.slideshowId+'-clip"><rect/></clipPath></defs><image height="100%" width="100%" clip-path="url(#'+gallery.slideshowId+'-clip)"></image></svg>';
      document.body.appendChild(imgMorph);
      gallery.imgMorph = document.querySelector('.js-exp-lightbox__clone-img-wrapper[data-exp-morph="'+gallery.slideshowId+'"]');
      gallery.imgMorphSVG = gallery.imgMorph.getElementsByTagName('svg')[0];
      gallery.imgMorphRect = gallery.imgMorph.getElementsByTagName('rect')[0];
      gallery.imgMorphImg = gallery.imgMorph.getElementsByTagName('image')[0];
      
      // append image for zoom in effect
      if(gallery.slideshow.getAttribute('data-zoom') == 'on') {
        var zoomImg = document.createElement("div");
        Util.setAttributes(zoomImg, {'aria-hidden': 'true', 'class': 'exp-lightbox__zoom exp-lightbox__zoom--no-transition js-exp-lightbox__zoom'});
        zoomImg.innerHTML = '<img>';
        gallery.element.appendChild(zoomImg);
        gallery.zoomImg = gallery.element.getElementsByClassName('js-exp-lightbox__zoom')[0];
      }
    };
  
    function lazyLoadLightbox(gallery) {
      // lazyload media of selected slide/prev slide/next slide
      gallery.slideshow.addEventListener('newItemSelected', function(event){
        // 'newItemSelected' is emitted by the Slideshow object when a new slide is selected
        gallery.selectedSlide = event.detail;
        lazyLoadSlide(gallery);
        // menu element - trigger new slide event
        triggerMenuEvent(gallery);
      });
    };
  
    function lazyLoadSlide(gallery) {
      setSlideMedia(gallery, gallery.selectedSlide);
      setSlideMedia(gallery, gallery.selectedSlide + 1);
      setSlideMedia(gallery, gallery.selectedSlide - 1);
    };
  
    function setSlideMedia(gallery, index) {
      if(index < 0) index = gallery.slides.length - 1;
      if(index > gallery.slides.length - 1) index = 0;
      var imgs = gallery.slides[index].querySelectorAll('img[data-src]');
      for(var i = 0; i < imgs.length; i++) {
        imgs[i].src = imgs[i].getAttribute('data-src');
      }
    };
  
    function initSlideshow(gallery) { 
      if(gallery.slides.length <= 1) {
        hideSlideshowElements(gallery);
        return;
      } 
      var swipe = (gallery.slideshow.getAttribute('data-swipe') && gallery.slideshow.getAttribute('data-swipe') == 'on') ? true : false;
      gallery.slideshowObj = new Slideshow({element: gallery.slideshow, navigation: false, autoplay : false, swipe : swipe});
    };
  
    function hideSlideshowElements(gallery) { // hide slideshow controls if gallery is composed by one item only
      var slideshowNav = gallery.element.getElementsByClassName('js-slideshow__control');
      if(slideshowNav.length > 0) {
        for(var i = 0; i < slideshowNav.length; i++) Util.addClass(slideshowNav[i], 'is-hidden');
      }
    };
  
    function initModal(gallery) {
      Util.addClass(gallery.element, 'exp-lightbox--no-transition'); // add no-transition class to lightbox - used to select the first visible slide
      gallery.element.addEventListener('modalIsClose', function(event){ // add no-transition class
        Util.addClass(gallery.element, 'exp-lightbox--no-transition');
        gallery.imgMorph.style = '';
      });
      // trigger modal lightbox
      gallery.gallery.addEventListener('click', function(event){
        openModalLightbox(gallery, event);
      });
    };
  
    function initModalEvents(gallery) {
      if(gallery.zoomImg) { // image zoom
        gallery.slideshow.addEventListener('click', function(event){
          if(event.target.tagName.toLowerCase() == 'img' && event.target.closest('.js-slideshow__item') && !gallery.modalSwiping) modalZoomImg(gallery, event.target);
        });
  
        gallery.zoomImg.addEventListener('click', function(event){
          modalZoomImg(gallery, false);
        });
  
        gallery.element.addEventListener('modalIsClose', function(event){
          modalZoomImg(gallery, false); // close zoom-in image if open
          closeModalAnimation(gallery);
        });
      }
  
      if(!gallery.slideshowObj) return;
  
      if(gallery.slideshowObj.options.swipe) { // close gallery when you swipeUp/SwipeDown
        gallery.slideshowObj.element.addEventListener('swipeUp', function(event){
          closeModal(gallery);
        });
        gallery.slideshowObj.element.addEventListener('swipeDown', function(event){
          closeModal(gallery);
        });
      }
      
      if(gallery.zoomImg && gallery.slideshowObj.options.swipe) {
        gallery.slideshowObj.element.addEventListener('swipeLeft', function(event){
          gallery.modalSwiping = true;
        });
        gallery.slideshowObj.element.addEventListener('swipeRight', function(event){
          gallery.modalSwiping = true;
        });
        gallery.slideshowObj.element.addEventListener('newItemVisible', function(event){
          gallery.modalSwiping = false;
        });
      }
    };
  
    function openModalLightbox(gallery, event) {
      var item = event.target.closest('.js-exp-gallery__item');
      if(!item) return;
      gallery.selectedSlide = Util.getIndexInArray(gallery.galleryItems, item);
      setSelectedItem(gallery);
      lazyLoadSlide(gallery);
      if(animationSupported) { // start expanding animation
        window.requestAnimationFrame(function(){
          animateSelectedImage(gallery);
          openModal(gallery, item);
        });
      } else { // no expanding animation -> show modal
        openModal(gallery, item);
        Util.removeClass(gallery.element, 'exp-lightbox--no-transition');
      }
      // menu element - trigger new slide event
      triggerMenuEvent(gallery);
    };
  
    function setSelectedItem(gallery) {
      // if a specific slide was selected -> make sure to show that item first
      var lastSelected = gallery.slideshow.getElementsByClassName('slideshow__item--selected');
      if(lastSelected.length > 0 ) Util.removeClass(lastSelected[0], 'slideshow__item--selected');
      Util.addClass(gallery.slides[gallery.selectedSlide], 'slideshow__item--selected');
      if(gallery.slideshowObj) gallery.slideshowObj.selectedSlide = gallery.selectedSlide;
    };
  
    function openModal(gallery, item) {
      gallery.element.dispatchEvent(new CustomEvent('openModal', {detail: item}));
      gallery.modalSwiping = false;
    };
  
    function closeModal(gallery) {
      gallery.modalSwiping = true;
      modalZoomImg(gallery, false);
      gallery.element.dispatchEvent(new CustomEvent('closeModal'));
    };
  
    function closeModalAnimation(gallery) { // modal is already closing -> start image closing animation
      gallery.selectedSlide = gallery.slideshowObj ? gallery.slideshowObj.selectedSlide : 0;
      // on close - make sure last selected image (of the gallery) is in the viewport
      var boundingRect = gallery.galleryItems[gallery.selectedSlide].getBoundingClientRect();
      if(boundingRect.top < 0 || boundingRect.top > window.innerHeight) {
        var windowScrollTop = window.scrollY || document.documentElement.scrollTop;
        window.scrollTo(0, boundingRect.top + windowScrollTop);
      }
      // animate on close
      animateSelectedImage(gallery, true);
    };
  
    function modalZoomImg(gallery, img) { // toggle zoom-in image
      if(!gallery.zoomImg) return;
      var bool = false;
      if(img) { // open zoom-in image
        gallery.originImg = img;
        gallery.zoomImg.children[0].setAttribute('src', img.getAttribute('src'));
        bool = true;
      }
      (animationSupported) 
        ? requestAnimationFrame(function(){animateZoomImg(gallery, bool)})
        : Util.toggleClass(gallery.zoomImg, 'exp-lightbox__zoom--is-visible', bool);
    };
  
    function animateZoomImg(gallery, bool) {
      if(!gallery.originImg) return;
      
      var originImgPosition = gallery.originImg.getBoundingClientRect(),
        originStyle = 'translateX('+originImgPosition.left+'px) translateY('+(originImgPosition.top + gallery.zoomImg.scrollTop)+'px) scale('+ originImgPosition.width/gallery.zoomImg.scrollWidth+')',
        finalStyle = 'scale(1)';
  
      if(bool) {
        gallery.zoomImg.children[0].style.transform = originStyle;
      } else {
        gallery.zoomImg.addEventListener('transitionend', function cb(){
          Util.addClass(gallery.zoomImg, 'exp-lightbox__zoom--no-transition');
          gallery.zoomImg.scrollTop = 0;
          gallery.zoomImg.removeEventListener('transitionend', cb);
        });
      }
      setTimeout(function(){
        Util.removeClass(gallery.zoomImg, 'exp-lightbox__zoom--no-transition');
        Util.toggleClass(gallery.zoomImg, 'exp-lightbox__zoom--is-visible', bool);
        gallery.zoomImg.children[0].style.transform = (bool) ? finalStyle : originStyle;
      }, 50);
    };
  
    function animateSelectedImage(gallery, bool) { // create morphing image effect
      var imgInit = gallery.galleryItems[gallery.selectedSlide].getElementsByTagName('img')[0],
        imgInitPosition = imgInit.getBoundingClientRect(),
        imgFinal = gallery.slides[gallery.selectedSlide].getElementsByTagName('img')[0],
        imgFinalPosition = imgFinal.getBoundingClientRect();
  
      if(bool) {
        runAnimation(gallery, imgInit, imgInitPosition, imgFinal, imgFinalPosition, bool);
      } else {
        imgFinal.style.visibility = 'hidden';
        gallery.animationRunning = false;
        var image = new Image();
        image.onload = function () {
          if(gallery.animationRunning) return;
          imgFinalPosition = imgFinal.getBoundingClientRect();
          runAnimation(gallery, imgInit, imgInitPosition, imgFinal, imgFinalPosition, bool);
        }
        image.src = imgFinal.getAttribute('data-src') ? imgFinal.getAttribute('data-src') : imgFinal.getAttribute('src');
        if(image.complete) {
          gallery.animationRunning = true;
          imgFinalPosition = imgFinal.getBoundingClientRect();
          runAnimation(gallery, imgInit, imgInitPosition, imgFinal, imgFinalPosition, bool);
        }
      }
    };
  
    function runAnimation(gallery, imgInit, imgInitPosition, imgFinal, imgFinalPosition, bool) {
      // retrieve all animation params
      var scale = imgFinalPosition.width > imgFinalPosition.height ? imgFinalPosition.height/imgInitPosition.height : imgFinalPosition.width/imgInitPosition.width;
      var initHeight = imgFinalPosition.width > imgFinalPosition.height ? imgInitPosition.height : imgFinalPosition.height/scale,
        initWidth = imgFinalPosition.width > imgFinalPosition.height ? imgFinalPosition.width/scale : imgInitPosition.width;
  
      var initTranslateY = (imgInitPosition.height - initHeight)/2,
        initTranslateX = (imgInitPosition.width - initWidth)/2,
        initTop = imgInitPosition.top + initTranslateY,
        initLeft = imgInitPosition.left + initTranslateX;
  
      // get final states
      var translateX = imgFinalPosition.left - imgInitPosition.left,
        translateY = imgFinalPosition.top - imgInitPosition.top;
  
      var finTranslateX = translateX - initTranslateX,
      finTranslateY = translateY - initTranslateY;
  
      var initScaleX = imgInitPosition.width/initWidth,
        initScaleY = imgInitPosition.height/initHeight,
        finScaleX = 1,
        finScaleY = 1;
  
      if(bool) { // update params if this is a closing animation
        scale = 1/scale;
        finScaleX = initScaleX;
        finScaleY = initScaleY;
        initScaleX = 1;
        initScaleY = 1;
        finTranslateX = -1*finTranslateX;
        finTranslateY = -1*finTranslateY;
        initTop = imgFinalPosition.top;
        initLeft = imgFinalPosition.left;
        initHeight = imgFinalPosition.height;
        initWidth = imgFinalPosition.width;
      }
      
      if(!bool) {
        imgFinal.style.visibility = ''; // reset visibility
      }
  
      // set initial status
      gallery.imgMorph.setAttribute('style', 'height: '+initHeight+'px; width: '+initWidth+'px; top: '+initTop+'px; left: '+initLeft+'px;');
      gallery.imgMorphSVG.setAttribute('viewbox', '0 0 '+initWidth+' '+initHeight);
      Util.setAttributes(gallery.imgMorphImg, {'xlink:href': imgInit.getAttribute('src'), 'href': imgInit.getAttribute('src')});
      Util.setAttributes(gallery.imgMorphRect, {'style': 'height: '+initHeight+'px; width: '+initWidth+'px;', 'transform': 'translate('+(initWidth/2)*(1 - initScaleX)+' '+(initHeight/2)*(1 - initScaleY)+') scale('+initScaleX+','+initScaleY+')'});
  
      // reveal image and start animation
      Util.addClass(gallery.imgMorph, 'exp-lightbox__clone-img-wrapper--is-visible');
      Util.addClass(gallery.slideshowList, 'slideshow__content--is-hidden');
      Util.addClass(gallery.galleryItems[gallery.selectedSlide], 'exp-gallery-item-hidden');
  
      gallery.imgMorph.addEventListener('transitionend', function cb(event){ // reset elements once animation is over
        if(event.propertyName.indexOf('transform') < 0) return;
        Util.removeClass(gallery.element, 'exp-lightbox--no-transition');
        Util.removeClass(gallery.imgMorph, 'exp-lightbox__clone-img-wrapper--is-visible');
        Util.removeClass(gallery.slideshowList, 'slideshow__content--is-hidden');
        gallery.imgMorph.removeAttribute('style');
        gallery.imgMorphRect.removeAttribute('style');
        gallery.imgMorphRect.removeAttribute('transform');
        gallery.imgMorphImg.removeAttribute('href');
        gallery.imgMorphImg.removeAttribute('xlink:href');
        Util.removeClass(gallery.galleryItems[gallery.selectedSlide], 'exp-gallery-item-hidden');
        gallery.imgMorph.removeEventListener('transitionend', cb);
      });
  
      // trigger expanding/closing animation
      gallery.imgMorph.style.transform = 'translateX('+finTranslateX+'px) translateY('+finTranslateY+'px) scale('+scale+')';
      animateRectScale(gallery.imgMorphRect, initScaleX, initScaleY, finScaleX, finScaleY, initWidth, initHeight);
    };
  
    function animateRectScale(rect, scaleX, scaleY, finScaleX, finScaleY, width, height) {
      var currentTime = null,
        duration =  parseFloat(getComputedStyle(document.documentElement).getPropertyValue('--exp-gallery-animation-duration'))*1000 || 300;
  
      var animateScale = function(timestamp){  
        if (!currentTime) currentTime = timestamp;         
        var progress = timestamp - currentTime;
        if(progress > duration) progress = duration;
  
        var valX = easeOutQuad(progress, scaleX, finScaleX-scaleX, duration),
          valY = easeOutQuad(progress, scaleY, finScaleY-scaleY, duration);
  
        rect.setAttribute('transform', 'translate('+(width/2)*(1 - valX)+' '+(height/2)*(1 - valY)+') scale('+valX+','+valY+')');
        if(progress < duration) {
          window.requestAnimationFrame(animateScale);
        }
      };
  
      function easeOutQuad(t, b, c, d) {
        t /= d;
        return -c * t*(t-2) + b;
      };
      
      window.requestAnimationFrame(animateScale);
    };
  
    function keyboardNavigateLightbox(gallery, direction) {
      if(!Util.hasClass(gallery.element, 'modal--is-visible')) return;
      if(!document.activeElement.closest('.js-exp-lightbox__body') && document.activeElement.closest('.js-modal')) return;
      if(!gallery.slideshowObj) return;
      (direction == 'next') ? gallery.slideshowObj.showNext() : gallery.slideshowObj.showPrev();
    };
  
    function triggerMenuEvent(gallery) {
      if(gallery.menuBar.length < 1) return;
      var event = new CustomEvent('update-menu', 
        {detail: {
          index: gallery.selectedSlide,
          item: gallery.slides[gallery.selectedSlide]
        }});
      gallery.menuBar[0].dispatchEvent(event);
    };
  
    window.ExpGallery = ExpGallery;
  
    // init ExpGallery objects
    var expGalleries = document.getElementsByClassName('js-exp-lightbox'),
      animationSupported = window.requestAnimationFrame && !Util.osHasReducedMotion();
    if( expGalleries.length > 0 ) {
      var expGalleriesArray = [];
      for( var i = 0; i < expGalleries.length; i++) {
        (function(i){ expGalleriesArray.push(new ExpGallery(expGalleries[i]));})(i);
  
        // Lightbox gallery navigation with keyboard
        window.addEventListener('keydown', function(event){
          if(event.keyCode && event.keyCode == 39 || event.key && event.key.toLowerCase() == 'arrowright') {
            updateLightbox('next');
          } else if(event.keyCode && event.keyCode == 37 || event.key && event.key.toLowerCase() == 'arrowleft') {
            updateLightbox('prev');
          }
        });
  
        function updateLightbox(direction) {
          for( var i = 0; i < expGalleriesArray.length; i++) {
            (function(i){keyboardNavigateLightbox(expGalleriesArray[i], direction);})(i);
          };
        };
      }
    }
  }());
// File#: _3_looping-slideshow
// Usage: codyhouse.co/license
(function() {
    var LoopSlideshow = function(element) {
      this.element = element;
      this.slideshowObj = false;
      this.navItems = this.element.getElementsByClassName('js-slideshow__nav-item');
      this.autoplayInterval = 5000;
      this.autoplayPaused = false;
      this.fillingCSS = '--loop-slideshow-filling';
      this.pauseBtnClass = 'js-loop-slideshow__pause-btn';
      this.pauseBtn = this.element.getElementsByClassName(this.pauseBtnClass);
      this.animating = false;
      this.currentTime = false;
  
      initLoopSlideshow(this);
      initEvents(this);
    };
  
    function initLoopSlideshow(obj) {
      var autoplay = true,
        autoplayInterval = (obj.element.getAttribute('data-autoplay-interval')) ? obj.element.getAttribute('data-autoplay-interval') : obj.autoplayInterval,
        swipe = (obj.element.getAttribute('data-swipe') && obj.element.getAttribute('data-swipe') == 'on') ? true : false;
      obj.slideshowObj = new Slideshow({element: obj.element, navigation: true, autoplay : autoplay, autoplayInterval : autoplayInterval, swipe : swipe, navigationClass: 'loop-slideshow__navigation', navigationItemClass: 'loop-slideshow__nav-item', autoplayOnHover: true, autoplayOnFocus: true});
      // update autoplay interval
      obj.autoplayInterval = autoplayInterval;
      // filling effect for first item
      initFilling(obj, obj.slideshowObj.selectedSlide);
    };
  
    function initEvents(obj) {
      obj.element.addEventListener('newItemSelected', function(event){
        // new slide has been selected
        initFilling(obj, event.detail);
        toggleAutoplay(obj, false);
      });
  
      // custom click on image -> animate slideshow
      obj.element.addEventListener('click', function(event){
        if(event.target.closest('.js-loop-slideshow__pause-btn')) {
          toggleAutoplay(obj, !obj.autoplayPaused); // pause/play autoplay
        } else if(event.target.closest('.js-slideshow__item')) {
          showNewSlide(obj, event);
        }
      });
    };
  
    function initFilling(obj, index) {
      cancelFilling(obj);
  
      for(var i = 0; i < obj.navItems.length; i++) {
        setFilling(obj.navItems[i], obj.fillingCSS, 0);
      }
      // trigger animation
      obj.currentTime = false;
      animateFilling(obj, index);
    };
  
    function cancelFilling(obj) {
      if(obj.animating) { // clear previous animation
        window.cancelAnimationFrame(obj.animating);
        obj.animating = false;
      }
    };
  
    function animateFilling(obj, index) {
      obj.animating = window.requestAnimationFrame(function(timestamp){
        if(!obj.currentTime) obj.currentTime = timestamp;
        var progress = timestamp - obj.currentTime;
        if(progress > obj.autoplayInterval) progress = obj.autoplayInterval;
        setFilling(obj.navItems[index], obj.fillingCSS, (progress/obj.autoplayInterval).toFixed(3));
        
        if(progress < obj.autoplayInterval) {
          animateFilling(obj, index);
        } else {
          // animation is over
          obj.animating = false;
          obj.currentTime = false;
        }
      });
    };
  
    function setFilling(element, property, value) {
      element.style.setProperty(property, value);
    };
  
    function showNewSlide(obj, event) {
      // check if we should go next or prev
      var boundingRect = obj.element.getBoundingClientRect(),
        isNext = event.clientX > boundingRect.left + boundingRect.width/2;
  
      isNext ? obj.slideshowObj.showNext() : obj.slideshowObj.showPrev();
    };
  
    function toggleAutoplay(obj, bool) {
      obj.autoplayPaused = bool;
      if(obj.autoplayPaused) {
        cancelFilling(obj);
        obj.slideshowObj.pauseAutoplay();
      } else {
        obj.slideshowObj.startAutoplay();
        initFilling(obj, obj.slideshowObj.selectedSlide);
      }
      if(obj.pauseBtn.length > 0) {
        // update btn appearance
        Util.toggleClass(obj.pauseBtn[0], 'btn-states--state-b', obj.autoplayPaused);
        // update pressed status 
        obj.autoplayPaused ? obj.pauseBtn[0].setAttribute('aria-pressed', 'true'): obj.pauseBtn[0].setAttribute('aria-pressed', 'false');
      }
    };
  
    //initialize the ThumbSlideshow objects
    var slideshow = document.getElementsByClassName('js-loop-slideshow');
    if( slideshow.length > 0 ) {
      for( var i = 0; i < slideshow.length; i++) {
        (function(i){
          new LoopSlideshow(slideshow[i]);
        })(i);
      }
    }
  }());
// File#: _3_mega-site-navigation
// Usage: codyhouse.co/license
(function() {
    var MegaNav = function(element) {
      this.element = element;
      this.search = this.element.getElementsByClassName('js-mega-nav__search');
      this.searchActiveController = false;
      this.menu = this.element.getElementsByClassName('js-mega-nav__nav');
      this.menuItems = this.menu[0].getElementsByClassName('js-mega-nav__item');
      this.menuActiveController = false;
      this.itemExpClass = 'mega-nav__item--expanded';
      this.classIconBtn = 'mega-nav__icon-btn--state-b';
      this.classSearchVisible = 'mega-nav__search--is-visible';
      this.classNavVisible = 'mega-nav__nav--is-visible';
      this.classMobileLayout = 'mega-nav--mobile';
      this.classDesktopLayout = 'mega-nav--desktop';
      this.layout = 'mobile';
      // store dropdown elements (if present)
      this.dropdown = this.element.getElementsByClassName('js-dropdown');
      // expanded class - added to header when subnav is open
      this.expandedClass = 'mega-nav--expanded';
      initMegaNav(this);
    };
  
    function initMegaNav(megaNav) {
      setMegaNavLayout(megaNav); // switch between mobile/desktop layout
      initSearch(megaNav); // controll search navigation
      initMenu(megaNav); // control main menu nav - mobile only
      initSubNav(megaNav); // toggle sub navigation visibility
      
      megaNav.element.addEventListener('update-menu-layout', function(event){
        setMegaNavLayout(megaNav); // window resize - update layout
      });
    };
  
    function setMegaNavLayout(megaNav) {
      var layout = getComputedStyle(megaNav.element, ':before').getPropertyValue('content').replace(/\'|"/g, '');
      if(layout == megaNav.layout) return;
      megaNav.layout = layout;
      Util.toggleClass(megaNav.element, megaNav.classDesktopLayout, megaNav.layout == 'desktop');
      Util.toggleClass(megaNav.element, megaNav.classMobileLayout, megaNav.layout != 'desktop');
      if(megaNav.layout == 'desktop') {
        closeSubNav(megaNav, false);
        // if the mega navigation has dropdown elements -> make sure they are in the right position (viewport awareness)
        triggerDropdownPosition(megaNav);
      } 
      closeSearch(megaNav, false);
      resetMegaNavOffset(megaNav); // reset header offset top value
      resetNavAppearance(megaNav); // reset nav expanded appearance
    };
  
    function resetMegaNavOffset(megaNav) {
      document.documentElement.style.setProperty('--mega-nav-offset-y', megaNav.element.getBoundingClientRect().top+'px');
    };
  
    function closeNavigation(megaNav) { // triggered by Esc key press
      // close search
      closeSearch(megaNav);
      // close nav
      if(Util.hasClass(megaNav.menu[0], megaNav.classNavVisible)) {
        toggleMenu(megaNav, megaNav.menu[0], 'menuActiveController', megaNav.classNavVisible, megaNav.menuActiveController, true);
      }
      //close subnav 
      closeSubNav(megaNav, false);
      resetNavAppearance(megaNav); // reset nav expanded appearance
    };
  
    function closeFocusNavigation(megaNav) { // triggered by Tab key pressed
      // close search when focus is lost
      if(Util.hasClass(megaNav.search[0], megaNav.classSearchVisible) && !document.activeElement.closest('.js-mega-nav__search')) {
        toggleMenu(megaNav, megaNav.search[0], 'searchActiveController', megaNav.classSearchVisible, megaNav.searchActiveController, true);
      }
      // close nav when focus is lost
      if(Util.hasClass(megaNav.menu[0], megaNav.classNavVisible) && !document.activeElement.closest('.js-mega-nav__nav')) {
        toggleMenu(megaNav, megaNav.menu[0], 'menuActiveController', megaNav.classNavVisible, megaNav.menuActiveController, true);
      }
      // close subnav when focus is lost
      for(var i = 0; i < megaNav.menuItems.length; i++) {
        if(!Util.hasClass(megaNav.menuItems[i], megaNav.itemExpClass)) continue;
        var parentItem = document.activeElement.closest('.js-mega-nav__item');
        if(parentItem && parentItem == megaNav.menuItems[i]) continue;
        closeSingleSubnav(megaNav, i);
      }
      resetNavAppearance(megaNav); // reset nav expanded appearance
    };
  
    function closeSearch(megaNav, bool) {
      if(Util.hasClass(megaNav.search[0], megaNav.classSearchVisible)) {
        toggleMenu(megaNav, megaNav.search[0], 'searchActiveController', megaNav.classSearchVisible, megaNav.searchActiveController, bool);
      }
    } ;
  
    function initSearch(megaNav) {
      if(megaNav.search.length == 0) return;
      // toggle search
      megaNav.searchToggles = document.querySelectorAll('[aria-controls="'+megaNav.search[0].getAttribute('id')+'"]');
      for(var i = 0; i < megaNav.searchToggles.length; i++) {(function(i){
        megaNav.searchToggles[i].addEventListener('click', function(event){
          // toggle search
          toggleMenu(megaNav, megaNav.search[0], 'searchActiveController', megaNav.classSearchVisible, megaNav.searchToggles[i], true);
          // close nav if it was open
          if(Util.hasClass(megaNav.menu[0], megaNav.classNavVisible)) {
            toggleMenu(megaNav, megaNav.menu[0], 'menuActiveController', megaNav.classNavVisible, megaNav.menuActiveController, false);
          }
          // close subnavigation if open
          closeSubNav(megaNav, false);
          resetNavAppearance(megaNav); // reset nav expanded appearance
        });
      })(i);}
    };
  
    function initMenu(megaNav) {
      if(megaNav.menu.length == 0) return;
      // toggle nav
      megaNav.menuToggles = document.querySelectorAll('[aria-controls="'+megaNav.menu[0].getAttribute('id')+'"]');
      for(var i = 0; i < megaNav.menuToggles.length; i++) {(function(i){
        megaNav.menuToggles[i].addEventListener('click', function(event){
          // toggle nav
          toggleMenu(megaNav, megaNav.menu[0], 'menuActiveController', megaNav.classNavVisible, megaNav.menuToggles[i], true);
          // close search if it was open
          if(Util.hasClass(megaNav.search[0], megaNav.classSearchVisible)) {
            toggleMenu(megaNav, megaNav.search[0], 'searchActiveController', megaNav.classSearchVisible, megaNav.searchActiveController, false);
          }
          resetNavAppearance(megaNav); // reset nav expanded appearance
        });
      })(i);}
    };
  
    function toggleMenu(megaNav, element, controller, visibleClass, toggle, moveFocus) {
      var menuIsVisible = Util.hasClass(element, visibleClass);
      Util.toggleClass(element, visibleClass, !menuIsVisible);
      Util.toggleClass(toggle, megaNav.classIconBtn, !menuIsVisible);
      menuIsVisible ? toggle.removeAttribute('aria-expanded') : toggle.setAttribute('aria-expanded', 'true');
      if(menuIsVisible) {
        if(toggle && moveFocus) toggle.focus();
        megaNav[controller] = false;
      } else {
        if(toggle) megaNav[controller] = toggle;
        getFirstFocusable(element).focus(); // move focus to first focusable element
      }
    };
  
    function getFirstFocusable(element) {
      var focusableEle = element.querySelectorAll('[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, [tabindex]:not([tabindex="-1"]), [contenteditable], audio[controls], video[controls], summary'),
        firstFocusable = false;
      for(var i = 0; i < focusableEle.length; i++) {
        if( focusableEle[i].offsetWidth || focusableEle[i].offsetHeight || focusableEle[i].getClientRects().length ) {
          firstFocusable = focusableEle[i];
          break;
        }
      }
      return firstFocusable;
    };
  
    function initSubNav(megaNav) {
      // toggle subnavigation visibility
      megaNav.element.addEventListener('click', function(event){
        var triggerBtn = event.target.closest('.js-mega-nav__control');
        if(!triggerBtn) return;
        var mainItem = triggerBtn.closest('.js-mega-nav__item');
        if(!mainItem) return;
        var itemExpanded = Util.hasClass(mainItem, megaNav.itemExpClass);
        Util.toggleClass(mainItem, megaNav.itemExpClass, !itemExpanded);
        itemExpanded ? triggerBtn.removeAttribute('aria-expanded') : triggerBtn.setAttribute('aria-expanded', 'true');
        if(megaNav.layout == 'desktop' && !itemExpanded) closeSubNav(megaNav, mainItem);
        // close search if open
        closeSearch(megaNav, false);
        resetNavAppearance(megaNav); // reset nav expanded appearance
      });
    };
  
    function closeSubNav(megaNav, selectedItem) {
      // close subnav when a new sub nav element is open
      if(megaNav.menuItems.length == 0 ) return;
      for(var i = 0; i < megaNav.menuItems.length; i++) {
        if(megaNav.menuItems[i] != selectedItem) closeSingleSubnav(megaNav, i);
      }
    };
  
    function closeSingleSubnav(megaNav, index) {
      Util.removeClass(megaNav.menuItems[index], megaNav.itemExpClass);
      var triggerBtn = megaNav.menuItems[index].getElementsByClassName('js-mega-nav__control');
      if(triggerBtn.length > 0) triggerBtn[0].removeAttribute('aria-expanded');
    };
  
    function triggerDropdownPosition(megaNav) {
      // emit custom event to properly place dropdown elements - viewport awarness
      if(megaNav.dropdown.length == 0) return;
      for(var i = 0; i < megaNav.dropdown.length; i++) {
        megaNav.dropdown[i].dispatchEvent(new CustomEvent('placeDropdown'));
      }
    };
  
    function resetNavAppearance(megaNav) {
      ( (megaNav.element.getElementsByClassName(megaNav.itemExpClass).length > 0 && megaNav.layout == 'desktop') || megaNav.element.getElementsByClassName(megaNav.classSearchVisible).length > 0 ||(megaNav.element.getElementsByClassName(megaNav.classNavVisible).length > 0 && megaNav.layout == 'mobile'))
        ? Util.addClass(megaNav.element, megaNav.expandedClass)
        : Util.removeClass(megaNav.element, megaNav.expandedClass);
    };
  
    //initialize the MegaNav objects
    var megaNav = document.getElementsByClassName('js-mega-nav');
    if(megaNav.length > 0) {
      var megaNavArray = [];
      for(var i = 0; i < megaNav.length; i++) {
        (function(i){megaNavArray.push(new MegaNav(megaNav[i]));})(i);
      }
  
      // key events
      window.addEventListener('keyup', function(event){
        if( (event.keyCode && event.keyCode == 27) || (event.key && event.key.toLowerCase() == 'escape' )) { // listen for esc key events
          for(var i = 0; i < megaNavArray.length; i++) {(function(i){
            closeNavigation(megaNavArray[i]);
          })(i);}
        }
        // listen for tab key
        if( (event.keyCode && event.keyCode == 9) || (event.key && event.key.toLowerCase() == 'tab' )) { // close search or nav if it looses focus
          for(var i = 0; i < megaNavArray.length; i++) {(function(i){
            closeFocusNavigation(megaNavArray[i]);
          })(i);}
        }
      });
  
      window.addEventListener('click', function(event){
        if(!event.target.closest('.js-mega-nav')) closeNavigation(megaNavArray[0]);
      });
      
      // resize - update menu layout
      var resizingId = false,
        customEvent = new CustomEvent('update-menu-layout');
      window.addEventListener('resize', function(event){
        clearTimeout(resizingId);
        resizingId = setTimeout(doneResizing, 200);
      });
  
      function doneResizing() {
        for( var i = 0; i < megaNavArray.length; i++) {
          (function(i){megaNavArray[i].element.dispatchEvent(customEvent)})(i);
        };
      };
    }
  }());
/**
 * @preserve
 */
;
(function($) {

	var defaults = {
		reCalcOnWindowResize: true,
		throttleDuration: 17 //ms - set to 0 to disable throttling
	};

	//Setup a container instance
	var setupContainer = function($el) {
		var imageSrc = $el.find('img').attr('src');
		$el.data('imageSrc', imageSrc);

		resolveImageSize(imageSrc, function(err, dim) {
			$el.data({
				imageW: dim.width,
				imageH: dim.height
			});
			adjustFocus($el);
		});
	};

	//Get the width and the height of an image
	//by creating a new temporary image
	var resolveImageSize = function(src, cb) {
		//Create a new image and set a
		//handler which listens to the first
		//call of the 'load' event.
		$('<img />').one('load', function() {
			//'this' references to the new
			//created image
			cb(null, {
				width: this.width,
				height: this.height
			});
		}).attr('src', src);
	};

	//Create a throttled version of a function
	var throttle = function(fn, ms) {
		var isRunning = false;
		return function() {
			var args = Array.prototype.slice.call(arguments, 0);
			if (isRunning) return false;
			isRunning = true;
			setTimeout(function() {
				isRunning = false;
				fn.apply(null, args);
			}, ms);
		};
	};

	//Calculate the new left/top values of an image
	var calcShift = function(conToImageRatio, containerSize, imageSize, focusSize, toMinus) {
		var containerCenter = Math.floor(containerSize / 2); //Container center in px
		var focusFactor = (focusSize + 1) / 2; //Focus point of resize image in px
		var scaledImage = Math.floor(imageSize / conToImageRatio); //Can't use width() as images may be display:none
		var focus =  Math.floor(focusFactor * scaledImage);
		if (toMinus) focus = scaledImage - focus;
		var focusOffset = focus - containerCenter; //Calculate difference between focus point and center
		var remainder = scaledImage - focus; //Reduce offset if necessary so image remains filled
		var containerRemainder = containerSize - containerCenter;
		if (remainder < containerRemainder) focusOffset -= containerRemainder - remainder;
		if (focusOffset < 0) focusOffset = 0;

		return (focusOffset * -100 / containerSize)  + '%';
	};

	//Re-adjust the focus
	var adjustFocus = function($el) {
		var imageW = $el.data('imageW');
		var imageH = $el.data('imageH');
		var imageSrc = $el.data('imageSrc');

		if (!imageW && !imageH && !imageSrc) {
			return setupContainer($el); //Setup the container first
		}

		var containerW = $el.width();
		var containerH = $el.height();
		var focusX = parseFloat($el.data('focusX'));
		var focusY = parseFloat($el.data('focusY'));
		var $image = $el.find('img').first();

		//Amount position will be shifted
		var hShift = 0;
		var vShift = 0;

		if (!(containerW > 0 && containerH > 0 && imageW > 0 && imageH > 0)) {
			return false; //Need dimensions to proceed
		}

		//Which is over by more?
		var wR = imageW / containerW;
		var hR = imageH / containerH;

		//Reset max-width and -height
		$image.css({
			'max-width': '',
			'max-height': ''
		});

		//Minimize image while still filling space
		if (imageW > containerW && imageH > containerH) {
			$image.css((wR > hR) ? 'max-height' : 'max-width', '100%');
		}

		if (wR > hR) {
			hShift = calcShift(hR, containerW, imageW, focusX);
		} else if (wR < hR) {
			vShift = calcShift(wR, containerH, imageH, focusY, true);
		}

		$image.css({
			top: vShift,
			left: hShift
		});
	};

	var $window = $(window);

	var focusPoint = function($el, settings) {
		var thrAdjustFocus = settings.throttleDuration ?
			throttle(function(){adjustFocus($el);}, settings.throttleDuration)
			: function(){adjustFocus($el);};//Only throttle when desired
		var isListening = false;

		adjustFocus($el); //Focus image in container

		//Expose a public API
		return {

			adjustFocus: function() {
				return adjustFocus($el);
			},

			windowOn: function() {
				if (isListening) return;
				//Recalculate each time the window is resized
				$window.on('resize', thrAdjustFocus);
				return isListening = true;
			},

			windowOff: function() {
				if (!isListening) return;
				//Stop listening to the resize event
				$window.off('resize', thrAdjustFocus);
				isListening = false;
				return true;
			}

		};
	};

	$.fn.focusPoint = function(optionsOrMethod) {
		//Shortcut to functions - if string passed assume method name and execute
		if (typeof optionsOrMethod === 'string') {
			return this.each(function() {
				var $el = $(this);
				$el.data('focusPoint')[optionsOrMethod]();
			});
		}
		//Otherwise assume options being passed and setup
		var settings = $.extend({}, defaults, optionsOrMethod);
		return this.each(function() {
			var $el = $(this);
			var fp = focusPoint($el, settings);
			//Stop the resize event of any previous attached
			//focusPoint instances
			if ($el.data('focusPoint')) $el.data('focusPoint').windowOff();
			$el.data('focusPoint', fp);
			if (settings.reCalcOnWindowResize) fp.windowOn();
		});

	};

	$.fn.adjustFocus = function() {
		//Deprecated v1.2
		return this.each(function() {
			adjustFocus($(this));
		});
	};

})(jQuery);
// File#: _1_filter-navigation
// Usage: codyhouse.co/license
(function() {
  var FilterNav = function(element) {
    this.element = element;
    this.wrapper = this.element.getElementsByClassName('js-filter-nav__wrapper')[0];
    this.nav = this.element.getElementsByClassName('js-filter-nav__nav')[0];
    this.list = this.nav.getElementsByClassName('js-filter-nav__list')[0];
    this.control = this.element.getElementsByClassName('js-filter-nav__control')[0];
    this.modalClose = this.element.getElementsByClassName('js-filter-nav__close-btn')[0];
    this.placeholder = this.element.getElementsByClassName('js-filter-nav__placeholder')[0];
    this.marker = this.element.getElementsByClassName('js-filter-nav__marker');
    this.layout = 'expanded';
    initFilterNav(this);
  };

  function initFilterNav(element) {
    checkLayout(element); // init layout
    if(element.layout == 'expanded') placeMarker(element);
    element.element.addEventListener('update-layout', function(event){ // on resize - modify layout
      checkLayout(element);
    });

    // update selected item
    element.wrapper.addEventListener('click', function(event){
      var newItem = event.target.closest('.js-filter-nav__btn');
      if(newItem) {
        updateCurrentItem(element, newItem);
        return;
      }
      // close modal list - mobile version only
      if(Util.hasClass(event.target, 'js-filter-nav__wrapper') || event.target.closest('.js-filter-nav__close-btn')) toggleModalList(element, false);
    });

    // open modal list - mobile version only
    element.control.addEventListener('click', function(event){
      toggleModalList(element, true);
    });
    
    // listen for key events
		window.addEventListener('keyup', function(event){
			// listen for esc key
			if( (event.keyCode && event.keyCode == 27) || (event.key && event.key.toLowerCase() == 'escape' )) {
				// close navigation on mobile if open
				if(element.control.getAttribute('aria-expanded') == 'true' && isVisible(element.control)) {
					toggleModalList(element, false);
				}
			}
			// listen for tab key
			if( (event.keyCode && event.keyCode == 9) || (event.key && event.key.toLowerCase() == 'tab' )) {
				// close navigation on mobile if open when nav loses focus
				if(element.control.getAttribute('aria-expanded') == 'true' && isVisible(element.control) && !document.activeElement.closest('.js-filter-nav__wrapper')) toggleModalList(element, false);
			}
		});
  };

  function updateCurrentItem(element, btn) {
    if(btn.getAttribute('aria-current') == 'true') {
      toggleModalList(element, false);
      return;
    }
    var activeBtn = element.wrapper.querySelector('[aria-current]');
    if(activeBtn) activeBtn.removeAttribute('aria-current');
    btn.setAttribute('aria-current', 'true');
    // update trigger label on selection (visible on mobile only)
    element.placeholder.textContent = btn.textContent;
    toggleModalList(element, false);
    if(element.layout == 'expanded') placeMarker(element);
  };

  function toggleModalList(element, bool) {
    element.control.setAttribute('aria-expanded', bool);
    Util.toggleClass(element.wrapper, 'filter-nav__wrapper--is-visible', bool);
    if(bool) {
      element.nav.querySelectorAll('[href], button:not([disabled])')[0].focus();
    } else if(isVisible(element.control)) {
      element.control.focus();
    }
  };

  function isVisible(element) {
		return (element.offsetWidth || element.offsetHeight || element.getClientRects().length);
	};

  function checkLayout(element) {
    if(element.layout == 'expanded' && switchToCollapsed(element)) { // check if there's enough space 
      element.layout = 'collapsed';
      Util.removeClass(element.element, 'filter-nav--expanded');
      Util.addClass(element.element, 'filter-nav--collapsed');
      Util.removeClass(element.modalClose, 'is-hidden');
      Util.removeClass(element.control, 'is-hidden');
    } else if(element.layout == 'collapsed' && switchToExpanded(element)) {
      element.layout = 'expanded';
      Util.addClass(element.element, 'filter-nav--expanded');
      Util.removeClass(element.element, 'filter-nav--collapsed');
      Util.addClass(element.modalClose, 'is-hidden');
      Util.addClass(element.control, 'is-hidden');
    }
    // place background element
    if(element.layout == 'expanded') placeMarker(element);
  };

  function switchToCollapsed(element) {
    return element.nav.scrollWidth > element.nav.offsetWidth;
  };

  function switchToExpanded(element) {
    element.element.style.visibility = 'hidden';
    Util.addClass(element.element, 'filter-nav--expanded');
    Util.removeClass(element.element, 'filter-nav--collapsed');
    var switchLayout = element.nav.scrollWidth <= element.nav.offsetWidth;
    Util.removeClass(element.element, 'filter-nav--expanded');
    Util.addClass(element.element, 'filter-nav--collapsed');
    element.element.style.visibility = 'visible';
    return switchLayout;
  };

  function placeMarker(element) {
    var activeElement = element.wrapper.querySelector('.js-filter-nav__btn[aria-current="true"]');
    if(element.marker.length == 0 || !activeElement ) return;
    element.marker[0].style.width = activeElement.offsetWidth+'px';
    element.marker[0].style.transform = 'translateX('+(activeElement.getBoundingClientRect().left - element.list.getBoundingClientRect().left)+'px)';
  };

  var filterNav = document.getElementsByClassName('js-filter-nav');
  if(filterNav.length > 0) {
    var filterNavArray = [];
    for(var i = 0; i < filterNav.length; i++) {
      filterNavArray.push(new FilterNav(filterNav[i]));
    }

    var resizingId = false,
      customEvent = new CustomEvent('update-layout');

    window.addEventListener('resize', function() {
      clearTimeout(resizingId);
      resizingId = setTimeout(doneResizing, 100);
    });

    // wait for font to be loaded
    document.fonts.onloadingdone = function (fontFaceSetEvent) {
      doneResizing();
    };

    function doneResizing() {
      for( var i = 0; i < filterNavArray.length; i++) {
        (function(i){filterNavArray[i].element.dispatchEvent(customEvent)})(i);
      };
    };
  }
}());
$jQ(document).ready(function () {
    $jQ('.ques').on('click', function() {
        $jQ(this).closest('.ques').siblings('.ans').first().slideToggle();
        $jQ(this).find('.toggle-plus').toggle();
        $jQ(this).find('.toggle-minus').toggle();
    });
    $jQ('.feature-image-section .feature-img').hide().first().show();
    $jQ('.feature-image-section .benefitsTab .doc-text').hide().first().show();
    $jQ('.feature-image-section .benefitsTab').first().addClass("selected");
    $jQ('.feature-image-section .benefitsTab').on('click', function(){
        var id = $jQ(this).attr("data-attr");
        $jQ('.feature-image-section .feature-img').hide();
        $jQ('.feature-image-section .benefitsTab .doc-text').hide();
        $jQ('.feature-image-section .benefitsTab').removeClass("selected");
        $jQ(this).addClass("selected");
        $jQ(this).find('.doc-text').show();
        $jQ(this).closest('.feature-image-section').find('.'+id).show();
    });
});