add luxe template

web/travel/luxe/js/classie.js

@@ -0,0 +1,80 @@
+/*!
+ * classie - class helper functions
+ * from bonzo https://github.com/ded/bonzo
+ * 
+ * classie.has( elem, 'my-class' ) -> true/false
+ * classie.add( elem, 'my-new-class' )
+ * classie.remove( elem, 'my-unwanted-class' )
+ * classie.toggle( elem, 'my-class' )
+ */
+
+/*jshint browser: true, strict: true, undef: true */
+/*global define: false */
+
+( function( window ) {
+
+'use strict';
+
+// class helper functions from bonzo https://github.com/ded/bonzo
+
+function classReg( className ) {
+  return new RegExp("(^|\\s+)" + className + "(\\s+|$)");
+}
+
+// classList support for class management
+// altho to be fair, the api sucks because it won't accept multiple classes at once
+var hasClass, addClass, removeClass;
+
+if ( 'classList' in document.documentElement ) {
+  hasClass = function( elem, c ) {
+    return elem.classList.contains( c );
+  };
+  addClass = function( elem, c ) {
+    elem.classList.add( c );
+  };
+  removeClass = function( elem, c ) {
+    elem.classList.remove( c );
+  };
+}
+else {
+  hasClass = function( elem, c ) {
+    return classReg( c ).test( elem.className );
+  };
+  addClass = function( elem, c ) {
+    if ( !hasClass( elem, c ) ) {
+      elem.className = elem.className + ' ' + c;
+    }
+  };
+  removeClass = function( elem, c ) {
+    elem.className = elem.className.replace( classReg( c ), ' ' );
+  };
+}
+
+function toggleClass( elem, c ) {
+  var fn = hasClass( elem, c ) ? removeClass : addClass;
+  fn( elem, c );
+}
+
+var classie = {
+  // full names
+  hasClass: hasClass,
+  addClass: addClass,
+  removeClass: removeClass,
+  toggleClass: toggleClass,
+  // short names
+  has: hasClass,
+  add: addClass,
+  remove: removeClass,
+  toggle: toggleClass
+};
+
+// transport
+if ( typeof define === 'function' && define.amd ) {
+  // AMD
+  define( classie );
+} else {
+  // browser global
+  window.classie = classie;
+}
+
+})( window );

web/travel/luxe/js/custom.js

@@ -0,0 +1,236 @@
+$(function(){
+
+   'use strict';
+
+   var isMobile = {
+      Android: function() {
+         return navigator.userAgent.match(/Android/i);
+      },
+         BlackBerry: function() {
+         return navigator.userAgent.match(/BlackBerry/i);
+      },
+         iOS: function() {
+         return navigator.userAgent.match(/iPhone|iPad|iPod/i);
+      },
+         Opera: function() {
+         return navigator.userAgent.match(/Opera Mini/i);
+      },
+         Windows: function() {
+         return navigator.userAgent.match(/IEMobile/i);
+      },
+         any: function() {
+         return (isMobile.Android() || isMobile.BlackBerry() || isMobile.iOS() || isMobile.Opera() || isMobile.Windows());
+      }
+   };
+
+	// Main Menu Superfish
+   var mainMenu = function() {
+
+      $('#fh5co-primary-menu').superfish({
+         delay: 0,
+         animation: {
+            opacity: 'show'
+         },
+         speed: 'fast',
+         cssArrows: true,
+         disableHI: true
+      });
+
+   };
+
+   // Offcanvas and cloning of the main menu
+   var offcanvas = function() {
+
+      var $clone = $('#fh5co-menu-wrap').clone();
+      $clone.attr({
+         'id' : 'offcanvas-menu'
+      });
+      $clone.find('> ul').attr({
+         'class' : '',
+         'id' : ''
+      });
+
+      $('#fh5co-page').prepend($clone);
+
+      // click the burger
+      $('.js-fh5co-nav-toggle').on('click', function(){
+
+         if ( $('body').hasClass('fh5co-offcanvas') ) {
+            $('body').removeClass('fh5co-offcanvas');
+            $(this).removeClass('active');
+         } else {
+            $('body').addClass('fh5co-offcanvas');
+            $(this).addClass('active');
+         }
+         // $('body').toggleClass('fh5co-offcanvas');
+
+      });
+
+      $('#offcanvas-menu').css('height', $(window).height());
+
+      $(window).resize(function(){
+         var w = $(window);
+
+
+         $('#offcanvas-menu').css('height', w.height());
+
+         if ( w.width() > 769 ) {
+            if ( $('body').hasClass('fh5co-offcanvas') ) {
+               $('body').removeClass('fh5co-offcanvas');
+            }
+         }
+
+      });   
+
+   }
+   
+
+   // Click outside of the Mobile Menu
+   var mobileMenuOutsideClick = function() {
+      $(document).click(function (e) {
+       var container = $("#offcanvas-menu, .js-fh5co-nav-toggle");
+       if (!container.is(e.target) && container.has(e.target).length === 0) {
+         if ( $('body').hasClass('fh5co-offcanvas') ) {
+            $('body').removeClass('fh5co-offcanvas');
+         }
+       }
+      });
+   };
+
+   var counter = function() {
+      $('.js-counter').countTo({
+         formatter: function (value, options) {
+         return value.toFixed(options.decimals);
+       },
+      });
+   };
+
+   var contentWayPoint = function() {
+      var i = 0;
+      $('.animate-box').waypoint( function( direction ) {
+
+         if( direction === 'down' && !$(this.element).hasClass('animated') ) {
+            
+            i++;
+
+            $(this.element).addClass('item-animate');
+            setTimeout(function(){
+
+               $('body .animate-box.item-animate').each(function(k){
+                  var el = $(this);
+                  setTimeout( function () {
+                     el.addClass('fadeInUp animated');
+                     el.removeClass('item-animate');
+                  },  k * 200, 'easeInOutExpo' );
+               });
+               
+            }, 100);
+            
+         }
+
+      } , { offset: '85%' } );
+   };
+
+
+   var fullHeight = function() {
+
+      if ( !isMobile.any() ) {
+         $('.js-fullheight').css('height', $(window).height() - $('#fh5co-header').height());
+         $(window).resize(function(){
+            $('.js-fullheight').css('height', $(window).height() - $('#fh5co-header').height());
+         });
+      }
+
+   };
+
+
+   //Date Picker
+
+   $('#date-start, #date-end').datepicker();
+
+   [].slice.call( document.querySelectorAll( 'select.cs-select' ) ).forEach( function(el) {  
+      new SelectFx(el);
+   } );
+
+
+   
+   // Tabs
+
+   var tabs = function() {
+      $('#hotel-facilities').css('height', $('.tab-content.active').height() + 600);
+
+      $(window).resize(function(){
+         $('#hotel-facilities').css('height', $('.tab-content.active').height() + 600);
+      });
+
+      $('.tabs-nav > a').on('click', function(e){
+         
+         var tab = $(this).data('tab');
+
+         $('.tabs-nav > a').removeClass('active');
+         $(this).addClass('active');
+
+         $('.tab-content').removeClass('active show');
+         
+         setTimeout(function(){
+            $('.tab-content[data-tab-content="'+tab+'"]').addClass('active');
+            $('#hotel-facilities').css('height', $('.tab-content.active').height() + 600);
+         }, 200);
+         setTimeout(function(){
+            $('.tab-content[data-tab-content="'+tab+'"]').addClass('show');
+         }, 400);
+         
+
+         e.preventDefault();
+      });
+   };
+
+   var sliderMain = function() {
+      
+      $('#fh5co-hero .flexslider').flexslider({
+         animation: "fade",
+         slideshowSpeed: 5000,
+         directionNav: true,
+         start: function(){
+            setTimeout(function(){
+               $('.slider-text').removeClass('animated fadeInUp');
+               $('.flex-active-slide').find('.slider-text').addClass('animated fadeInUp');
+            }, 500);
+         },
+         before: function(){
+            setTimeout(function(){
+               $('.slider-text').removeClass('animated fadeInUp');
+               $('.flex-active-slide').find('.slider-text').addClass('animated fadeInUp');
+            }, 500);
+         }
+
+      });
+
+      $('#fh5co-hero .flexslider .slides > li').css('height', $(window).height());  
+      $(window).resize(function(){
+         $('#fh5co-hero .flexslider .slides > li').css('height', $(window).height());  
+      });
+
+   };
+
+   // Parallax
+   var parallax = function() {
+      $(window).stellar();
+   };
+
+
+   $(function(){
+      sliderMain();
+      tabs();
+      mainMenu();
+      offcanvas();
+      contentWayPoint();
+      mobileMenuOutsideClick();
+      parallax();
+      fullHeight();
+      counter();
+   });
+
+});
+	
+	

web/travel/luxe/js/google_map.js

@@ -0,0 +1,49 @@
+
+var google;
+
+function init() {
+    // Basic options for a simple Google Map
+    // For more options see: https://developers.google.com/maps/documentation/javascript/reference#MapOptions
+    // var myLatlng = new google.maps.LatLng(40.71751, -73.990922);
+    var myLatlng = new google.maps.LatLng(40.69847032728747, -73.9514422416687);
+    // 39.399872
+    // -8.224454
+    
+    var mapOptions = {
+        // How zoomed in you want the map to start at (always required)
+        zoom: 7,
+
+        // The latitude and longitude to center the map (always required)
+        center: myLatlng,
+
+        // How you would like to style the map. 
+        scrollwheel: false,
+        styles: [{"featureType":"administrative.land_parcel","elementType":"all","stylers":[{"visibility":"off"}]},{"featureType":"landscape.man_made","elementType":"all","stylers":[{"visibility":"off"}]},{"featureType":"poi","elementType":"labels","stylers":[{"visibility":"off"}]},{"featureType":"road","elementType":"labels","stylers":[{"visibility":"simplified"},{"lightness":20}]},{"featureType":"road.highway","elementType":"geometry","stylers":[{"hue":"#f49935"}]},{"featureType":"road.highway","elementType":"labels","stylers":[{"visibility":"simplified"}]},{"featureType":"road.arterial","elementType":"geometry","stylers":[{"hue":"#fad959"}]},{"featureType":"road.arterial","elementType":"labels","stylers":[{"visibility":"off"}]},{"featureType":"road.local","elementType":"geometry","stylers":[{"visibility":"simplified"}]},{"featureType":"road.local","elementType":"labels","stylers":[{"visibility":"simplified"}]},{"featureType":"transit","elementType":"all","stylers":[{"visibility":"off"}]},{"featureType":"water","elementType":"all","stylers":[{"hue":"#a1cdfc"},{"saturation":30},{"lightness":49}]}]
+    };
+
+    
+
+    // Get the HTML DOM element that will contain your map 
+    // We are using a div with id="map" seen below in the <body>
+    var mapElement = document.getElementById('map');
+
+    // Create the Google Map using out element and options defined above
+    var map = new google.maps.Map(mapElement, mapOptions);
+    
+    var addresses = ['Brooklyn'];
+
+    for (var x = 0; x < addresses.length; x++) {
+        $.getJSON('http://maps.googleapis.com/maps/api/geocode/json?address='+addresses[x]+'&sensor=false', null, function (data) {
+            var p = data.results[0].geometry.location
+            var latlng = new google.maps.LatLng(p.lat, p.lng);
+            new google.maps.Marker({
+                position: latlng,
+                map: map,
+                icon: 'images/loc.png'
+            });
+
+        });
+    }
+    
+}
+google.maps.event.addDomListener(window, 'load', init);

web/travel/luxe/js/hoverIntent.js

@@ -0,0 +1,114 @@
+/**
+ * hoverIntent is similar to jQuery's built-in "hover" method except that
+ * instead of firing the handlerIn function immediately, hoverIntent checks
+ * to see if the user's mouse has slowed down (beneath the sensitivity
+ * threshold) before firing the event. The handlerOut function is only
+ * called after a matching handlerIn.
+ *
+ * hoverIntent r7 // 2013.03.11 // jQuery 1.9.1+
+ * http://cherne.net/brian/resources/jquery.hoverIntent.html
+ *
+ * You may use hoverIntent under the terms of the MIT license. Basically that
+ * means you are free to use hoverIntent as long as this header is left intact.
+ * Copyright 2007, 2013 Brian Cherne
+ *
+ * // basic usage ... just like .hover()
+ * .hoverIntent( handlerIn, handlerOut )
+ * .hoverIntent( handlerInOut )
+ *
+ * // basic usage ... with event delegation!
+ * .hoverIntent( handlerIn, handlerOut, selector )
+ * .hoverIntent( handlerInOut, selector )
+ *
+ * // using a basic configuration object
+ * .hoverIntent( config )
+ *
+ * @param  handlerIn   function OR configuration object
+ * @param  handlerOut  function OR selector for delegation OR undefined
+ * @param  selector    selector OR undefined
+ * @author Brian Cherne <brian(at)cherne(dot)net>
+ **/
+(function($) {
+    $.fn.hoverIntent = function(handlerIn,handlerOut,selector) {
+
+        // default configuration values
+        var cfg = {
+            interval: 100,
+            sensitivity: 7,
+            timeout: 0
+        };
+
+        if ( typeof handlerIn === "object" ) {
+            cfg = $.extend(cfg, handlerIn );
+        } else if ($.isFunction(handlerOut)) {
+            cfg = $.extend(cfg, { over: handlerIn, out: handlerOut, selector: selector } );
+        } else {
+            cfg = $.extend(cfg, { over: handlerIn, out: handlerIn, selector: handlerOut } );
+        }
+
+        // instantiate variables
+        // cX, cY = current X and Y position of mouse, updated by mousemove event
+        // pX, pY = previous X and Y position of mouse, set by mouseover and polling interval
+        var cX, cY, pX, pY;
+
+        // A private function for getting mouse position
+        var track = function(ev) {
+            cX = ev.pageX;
+            cY = ev.pageY;
+        };
+
+        // A private function for comparing current and previous mouse position
+        var compare = function(ev,ob) {
+            ob.hoverIntent_t = clearTimeout(ob.hoverIntent_t);
+            // compare mouse positions to see if they've crossed the threshold
+            if ( ( Math.abs(pX-cX) + Math.abs(pY-cY) ) < cfg.sensitivity ) {
+                $(ob).off("mousemove.hoverIntent",track);
+                // set hoverIntent state to true (so mouseOut can be called)
+                ob.hoverIntent_s = 1;
+                return cfg.over.apply(ob,[ev]);
+            } else {
+                // set previous coordinates for next time
+                pX = cX; pY = cY;
+                // use self-calling timeout, guarantees intervals are spaced out properly (avoids JavaScript timer bugs)
+                ob.hoverIntent_t = setTimeout( function(){compare(ev, ob);} , cfg.interval );
+            }
+        };
+
+        // A private function for delaying the mouseOut function
+        var delay = function(ev,ob) {
+            ob.hoverIntent_t = clearTimeout(ob.hoverIntent_t);
+            ob.hoverIntent_s = 0;
+            return cfg.out.apply(ob,[ev]);
+        };
+
+        // A private function for handling mouse 'hovering'
+        var handleHover = function(e) {
+            // copy objects to be passed into t (required for event object to be passed in IE)
+            var ev = jQuery.extend({},e);
+            var ob = this;
+
+            // cancel hoverIntent timer if it exists
+            if (ob.hoverIntent_t) { ob.hoverIntent_t = clearTimeout(ob.hoverIntent_t); }
+
+            // if e.type == "mouseenter"
+            if (e.type == "mouseenter") {
+                // set "previous" X and Y position based on initial entry point
+                pX = ev.pageX; pY = ev.pageY;
+                // update "current" X and Y position based on mousemove
+                $(ob).on("mousemove.hoverIntent",track);
+                // start polling interval (self-calling timeout) to compare mouse coordinates over time
+                if (ob.hoverIntent_s != 1) { ob.hoverIntent_t = setTimeout( function(){compare(ev,ob);} , cfg.interval );}
+
+                // else e.type == "mouseleave"
+            } else {
+                // unbind expensive mousemove event
+                $(ob).off("mousemove.hoverIntent",track);
+                // if hoverIntent state is true, then call the mouseOut function after the specified delay
+                if (ob.hoverIntent_s == 1) { ob.hoverIntent_t = setTimeout( function(){delay(ev,ob);} , cfg.timeout );}
+            }
+        };
+
+        // listen for mouseenter and mouseleave
+        return this.on({'mouseenter.hoverIntent':handleHover,'mouseleave.hoverIntent':handleHover}, cfg.selector);
+    };
+})(jQuery);

web/travel/luxe/js/jquery.countTo.js

@@ -0,0 +1,130 @@
+(function (factory) {
+    if (typeof define === 'function' && define.amd) {
+        // AMD
+        define(['jquery'], factory);
+    } else if (typeof exports === 'object') {
+        // CommonJS
+        factory(require('jquery'));
+    } else {
+        // Browser globals
+        factory(jQuery);
+    }
+}(function ($) {
+  var CountTo = function (element, options) {
+    this.$element = $(element);
+    this.options  = $.extend({}, CountTo.DEFAULTS, this.dataOptions(), options);
+    this.init();
+  };
+
+  CountTo.DEFAULTS = {
+    from: 0,               // the number the element should start at
+    to: 0,                 // the number the element should end at
+    speed: 1000,           // how long it should take to count between the target numbers
+    refreshInterval: 100,  // how often the element should be updated
+    decimals: 0,           // the number of decimal places to show
+    formatter: formatter,  // handler for formatting the value before rendering
+    onUpdate: null,        // callback method for every time the element is updated
+    onComplete: null       // callback method for when the element finishes updating
+  };
+
+  CountTo.prototype.init = function () {
+    this.value     = this.options.from;
+    this.loops     = Math.ceil(this.options.speed / this.options.refreshInterval);
+    this.loopCount = 0;
+    this.increment = (this.options.to - this.options.from) / this.loops;
+  };
+
+  CountTo.prototype.dataOptions = function () {
+    var options = {
+      from:            this.$element.data('from'),
+      to:              this.$element.data('to'),
+      speed:           this.$element.data('speed'),
+      refreshInterval: this.$element.data('refresh-interval'),
+      decimals:        this.$element.data('decimals')
+    };
+
+    var keys = Object.keys(options);
+
+    for (var i in keys) {
+      var key = keys[i];
+
+      if (typeof(options[key]) === 'undefined') {
+        delete options[key];
+      }
+    }
+
+    return options;
+  };
+
+  CountTo.prototype.update = function () {
+    this.value += this.increment;
+    this.loopCount++;
+
+    this.render();
+
+    if (typeof(this.options.onUpdate) == 'function') {
+      this.options.onUpdate.call(this.$element, this.value);
+    }
+
+    if (this.loopCount >= this.loops) {
+      clearInterval(this.interval);
+      this.value = this.options.to;
+
+      if (typeof(this.options.onComplete) == 'function') {
+        this.options.onComplete.call(this.$element, this.value);
+      }
+    }
+  };
+
+  CountTo.prototype.render = function () {
+    var formattedValue = this.options.formatter.call(this.$element, this.value, this.options);
+    this.$element.text(formattedValue);
+  };
+
+  CountTo.prototype.restart = function () {
+    this.stop();
+    this.init();
+    this.start();
+  };
+
+  CountTo.prototype.start = function () {
+    this.stop();
+    this.render();
+    this.interval = setInterval(this.update.bind(this), this.options.refreshInterval);
+  };
+
+  CountTo.prototype.stop = function () {
+    if (this.interval) {
+      clearInterval(this.interval);
+    }
+  };
+
+  CountTo.prototype.toggle = function () {
+    if (this.interval) {
+      this.stop();
+    } else {
+      this.start();
+    }
+  };
+
+  function formatter(value, options) {
+    return value.toFixed(options.decimals);
+  }
+
+  $.fn.countTo = function (option) {
+    return this.each(function () {
+      var $this   = $(this);
+      var data    = $this.data('countTo');
+      var init    = !data || typeof(option) === 'object';
+      var options = typeof(option) === 'object' ? option : {};
+      var method  = typeof(option) === 'string' ? option : 'start';
+
+      if (init) {
+        if (data) data.stop();
+        $this.data('countTo', data = new CountTo(this, options));
+      }
+
+      data[method].call(data);
+    });
+  };
+}));

web/travel/luxe/js/selectFx.js

@@ -0,0 +1,325 @@
+/**
+ * selectFx.js v1.0.0
+ * http://www.codrops.com
+ *
+ * Licensed under the MIT license.
+ * http://www.opensource.org/licenses/mit-license.php
+ * 
+ * Copyright 2014, Codrops
+ * http://www.codrops.com
+ */
+;( function( window ) {
+	
+	'use strict';
+
+	/**
+	 * based on from https://github.com/inuyaksa/jquery.nicescroll/blob/master/jquery.nicescroll.js
+	 */
+	function hasParent( e, p ) {
+		if (!e) return false;
+		var el = e.target||e.srcElement||e||false;
+		while (el && el != p) {
+			el = el.parentNode||false;
+		}
+		return (el!==false);
+	};
+	
+	/**
+	 * extend obj function
+	 */
+	function extend( a, b ) {
+		for( var key in b ) { 
+			if( b.hasOwnProperty( key ) ) {
+				a[key] = b[key];
+			}
+		}
+		return a;
+	}
+
+	/**
+	 * SelectFx function
+	 */
+	function SelectFx( el, options ) {	
+		this.el = el;
+		this.options = extend( {}, this.options );
+		extend( this.options, options );
+		this._init();
+	}
+
+	/**
+	 * SelectFx options
+	 */
+	SelectFx.prototype.options = {
+		// if true all the links will open in a new tab.
+		// if we want to be redirected when we click an option, we need to define a data-link attr on the option of the native select element
+		newTab : true,
+		// when opening the select element, the default placeholder (if any) is shown
+		stickyPlaceholder : true,
+		// callback when changing the value
+		onChange : function( val ) { return false; }
+	}
+
+	/**
+	 * init function
+	 * initialize and cache some vars
+	 */
+	SelectFx.prototype._init = function() {
+		// check if we are using a placeholder for the native select box
+		// we assume the placeholder is disabled and selected by default
+		var selectedOpt = this.el.querySelector( 'option[selected]' );
+		this.hasDefaultPlaceholder = selectedOpt && selectedOpt.disabled;
+
+		// get selected option (either the first option with attr selected or just the first option)
+		this.selectedOpt = selectedOpt || this.el.querySelector( 'option' );
+
+		// create structure
+		this._createSelectEl();
+
+		// all options
+		this.selOpts = [].slice.call( this.selEl.querySelectorAll( 'li[data-option]' ) );
+		
+		// total options
+		this.selOptsCount = this.selOpts.length;
+		
+		// current index
+		this.current = this.selOpts.indexOf( this.selEl.querySelector( 'li.cs-selected' ) ) || -1;
+		
+		// placeholder elem
+		this.selPlaceholder = this.selEl.querySelector( 'span.cs-placeholder' );
+
+		// init events
+		this._initEvents();
+	}
+
+	/**
+	 * creates the structure for the select element
+	 */
+	SelectFx.prototype._createSelectEl = function() {
+		var self = this, options = '', createOptionHTML = function(el) {
+			var optclass = '', classes = '', link = '';
+
+			if( el.selectedOpt && !this.foundSelected && !this.hasDefaultPlaceholder ) {
+				classes += 'cs-selected ';
+				this.foundSelected = true;
+			}
+			// extra classes
+			if( el.getAttribute( 'data-class' ) ) {
+				classes += el.getAttribute( 'data-class' );
+			}
+			// link options
+			if( el.getAttribute( 'data-link' ) ) {
+				link = 'data-link=' + el.getAttribute( 'data-link' );
+			}
+
+			if( classes !== '' ) {
+				optclass = 'class="' + classes + '" ';
+			}
+
+			return '<li ' + optclass + link + ' data-option data-value="' + el.value + '"><span>' + el.textContent + '</span></li>';
+		};
+
+		[].slice.call( this.el.children ).forEach( function(el) {
+			if( el.disabled ) { return; }
+
+			var tag = el.tagName.toLowerCase();
+
+			if( tag === 'option' ) {
+				options += createOptionHTML(el);
+			}
+			else if( tag === 'optgroup' ) {
+				options += '<li class="cs-optgroup"><span>' + el.label + '</span><ul>';
+				[].slice.call( el.children ).forEach( function(opt) {
+					options += createOptionHTML(opt);
+				} );
+				options += '</ul></li>';
+			}
+		} );
+
+		var opts_el = '<div class="cs-options"><ul>' + options + '</ul></div>';
+		this.selEl = document.createElement( 'div' );
+		this.selEl.className = this.el.className;
+		this.selEl.tabIndex = this.el.tabIndex;
+		this.selEl.innerHTML = '<span class="cs-placeholder">' + this.selectedOpt.textContent + '</span>' + opts_el;
+		this.el.parentNode.appendChild( this.selEl );
+		this.selEl.appendChild( this.el );
+	}
+
+	/**
+	 * initialize the events
+	 */
+	SelectFx.prototype._initEvents = function() {
+		var self = this;
+
+		// open/close select
+		this.selPlaceholder.addEventListener( 'click', function() {
+			self._toggleSelect();
+		} );
+
+		// clicking the options
+		this.selOpts.forEach( function(opt, idx) {
+			opt.addEventListener( 'click', function() {
+				self.current = idx;
+				self._changeOption();
+				// close select elem
+				self._toggleSelect();
+			} );
+		} );
+
+		// close the select element if the target it´s not the select element or one of its descendants..
+		document.addEventListener( 'click', function(ev) {
+			var target = ev.target;
+			if( self._isOpen() && target !== self.selEl && !hasParent( target, self.selEl ) ) {
+				self._toggleSelect();
+			}
+		} );
+
+		// keyboard navigation events
+		this.selEl.addEventListener( 'keydown', function( ev ) {
+			var keyCode = ev.keyCode || ev.which;
+
+			switch (keyCode) {
+				// up key
+				case 38:
+					ev.preventDefault();
+					self._navigateOpts('prev');
+					break;
+				// down key
+				case 40:
+					ev.preventDefault();
+					self._navigateOpts('next');
+					break;
+				// space key
+				case 32:
+					ev.preventDefault();
+					if( self._isOpen() && typeof self.preSelCurrent != 'undefined' && self.preSelCurrent !== -1 ) {
+						self._changeOption();
+					}
+					self._toggleSelect();
+					break;
+				// enter key
+				case 13:
+					ev.preventDefault();
+					if( self._isOpen() && typeof self.preSelCurrent != 'undefined' && self.preSelCurrent !== -1 ) {
+						self._changeOption();
+						self._toggleSelect();
+					}
+					break;
+				// esc key
+				case 27:
+					ev.preventDefault();
+					if( self._isOpen() ) {
+						self._toggleSelect();
+					}
+					break;
+			}
+		} );
+	}
+
+	/**
+	 * navigate with up/dpwn keys
+	 */
+	SelectFx.prototype._navigateOpts = function(dir) {
+		if( !this._isOpen() ) {
+			this._toggleSelect();
+		}
+
+		var tmpcurrent = typeof this.preSelCurrent != 'undefined' && this.preSelCurrent !== -1 ? this.preSelCurrent : this.current;
+		
+		if( dir === 'prev' && tmpcurrent > 0 || dir === 'next' && tmpcurrent < this.selOptsCount - 1 ) {
+			// save pre selected current - if we click on option, or press enter, or press space this is going to be the index of the current option
+			this.preSelCurrent = dir === 'next' ? tmpcurrent + 1 : tmpcurrent - 1;
+			// remove focus class if any..
+			this._removeFocus();
+			// add class focus - track which option we are navigating
+			classie.add( this.selOpts[this.preSelCurrent], 'cs-focus' );
+		}
+	}
+
+	/**
+	 * open/close select
+	 * when opened show the default placeholder if any
+	 */
+	SelectFx.prototype._toggleSelect = function() {
+		// remove focus class if any..
+		this._removeFocus();
+		
+		if( this._isOpen() ) {
+			if( this.current !== -1 ) {
+				// update placeholder text
+				this.selPlaceholder.textContent = this.selOpts[ this.current ].textContent;
+			}
+			classie.remove( this.selEl, 'cs-active' );
+		}
+		else {
+			if( this.hasDefaultPlaceholder && this.options.stickyPlaceholder ) {
+				// everytime we open we wanna see the default placeholder text
+				this.selPlaceholder.textContent = this.selectedOpt.textContent;
+			}
+			classie.add( this.selEl, 'cs-active' );
+		}
+	}
+
+	/**
+	 * change option - the new value is set
+	 */
+	SelectFx.prototype._changeOption = function() {
+		// if pre selected current (if we navigate with the keyboard)...
+		if( typeof this.preSelCurrent != 'undefined' && this.preSelCurrent !== -1 ) {
+			this.current = this.preSelCurrent;
+			this.preSelCurrent = -1;
+		}
+
+		// current option
+		var opt = this.selOpts[ this.current ];
+
+		// update current selected value
+		this.selPlaceholder.textContent = opt.textContent;
+		
+		// change native select element´s value
+		this.el.value = opt.getAttribute( 'data-value' );
+
+		// remove class cs-selected from old selected option and add it to current selected option
+		var oldOpt = this.selEl.querySelector( 'li.cs-selected' );
+		if( oldOpt ) {
+			classie.remove( oldOpt, 'cs-selected' );
+		}
+		classie.add( opt, 'cs-selected' );
+
+		// if there´s a link defined
+		if( opt.getAttribute( 'data-link' ) ) {
+			// open in new tab?
+			if( this.options.newTab ) {
+				window.open( opt.getAttribute( 'data-link' ), '_blank' );
+			}
+			else {
+				window.location = opt.getAttribute( 'data-link' );
+			}
+		}
+
+		// callback
+		this.options.onChange( this.el.value );
+	}
+
+	/**
+	 * returns true if select element is opened
+	 */
+	SelectFx.prototype._isOpen = function(opt) {
+		return classie.has( this.selEl, 'cs-active' );
+	}
+
+	/**
+	 * removes the focus class from the option
+	 */
+	SelectFx.prototype._removeFocus = function(opt) {
+		var focusEl = this.selEl.querySelector( 'li.cs-focus' )
+		if( focusEl ) {
+			classie.remove( focusEl, 'cs-focus' );
+		}
+	}
+
+	/**
+	 * add to global namespace
+	 */
+	window.SelectFx = SelectFx;
+
+} )( window );

web/travel/luxe/js/superfish.js

@@ -0,0 +1,275 @@
+/*
+ * jQuery Superfish Menu Plugin
+ * Copyright (c) 2013 Joel Birch
+ *
+ * Dual licensed under the MIT and GPL licenses:
+ *	http://www.opensource.org/licenses/mit-license.php
+ *	http://www.gnu.org/licenses/gpl.html
+ */
+
+(function ($, w) {
+	"use strict";
+
+	var methods = (function () {
+		// private properties and methods go here
+		var c = {
+				bcClass: 'sf-breadcrumb',
+				menuClass: 'sf-js-enabled',
+				anchorClass: 'sf-with-ul',
+				menuArrowClass: 'sf-arrows'
+			},
+			ios = (function () {
+				var ios = /iPhone|iPad|iPod/i.test(navigator.userAgent);
+				if (ios) {
+					// iOS clicks only bubble as far as body children
+					$(w).load(function () {
+						$('body').children().on('click', $.noop);
+					});
+				}
+				return ios;
+			})(),
+			wp7 = (function () {
+				var style = document.documentElement.style;
+				return ('behavior' in style && 'fill' in style && /iemobile/i.test(navigator.userAgent));
+			})(),
+			unprefixedPointerEvents = (function () {
+				return (!!w.PointerEvent);
+			})(),
+			toggleMenuClasses = function ($menu, o) {
+				var classes = c.menuClass;
+				if (o.cssArrows) {
+					classes += ' ' + c.menuArrowClass;
+				}
+				$menu.toggleClass(classes);
+			},
+			setPathToCurrent = function ($menu, o) {
+				return $menu.find('li.' + o.pathClass).slice(0, o.pathLevels)
+					.addClass(o.hoverClass + ' ' + c.bcClass)
+						.filter(function () {
+							return ($(this).children(o.popUpSelector).hide().show().length);
+						}).removeClass(o.pathClass);
+			},
+			toggleAnchorClass = function ($li) {
+				$li.children('a').toggleClass(c.anchorClass);
+			},
+			toggleTouchAction = function ($menu) {
+				var msTouchAction = $menu.css('ms-touch-action');
+				var touchAction = $menu.css('touch-action');
+				touchAction = touchAction || msTouchAction;
+				touchAction = (touchAction === 'pan-y') ? 'auto' : 'pan-y';
+				$menu.css({
+					'ms-touch-action': touchAction,
+					'touch-action': touchAction
+				});
+			},
+			applyHandlers = function ($menu, o) {
+				var targets = 'li:has(' + o.popUpSelector + ')';
+				if ($.fn.hoverIntent && !o.disableHI) {
+					$menu.hoverIntent(over, out, targets);
+				}
+				else {
+					$menu
+						.on('mouseenter.superfish', targets, over)
+						.on('mouseleave.superfish', targets, out);
+				}
+				var touchevent = 'MSPointerDown.superfish';
+				if (unprefixedPointerEvents) {
+					touchevent = 'pointerdown.superfish';
+				}
+				if (!ios) {
+					touchevent += ' touchend.superfish';
+				}
+				if (wp7) {
+					touchevent += ' mousedown.superfish';
+				}
+				$menu
+					.on('focusin.superfish', 'li', over)
+					.on('focusout.superfish', 'li', out)
+					.on(touchevent, 'a', o, touchHandler);
+			},
+			touchHandler = function (e) {
+				var $this = $(this),
+					o = getOptions($this),
+					$ul = $this.siblings(e.data.popUpSelector);
+
+				if (o.onHandleTouch.call($ul) === false) {
+					return this;
+				}
+
+				if ($ul.length > 0 && $ul.is(':hidden')) {
+					$this.one('click.superfish', false);
+					if (e.type === 'MSPointerDown' || e.type === 'pointerdown') {
+						$this.trigger('focus');
+					} else {
+						$.proxy(over, $this.parent('li'))();
+					}
+				}
+			},
+			over = function () {
+				var $this = $(this),
+					o = getOptions($this);
+				clearTimeout(o.sfTimer);
+				$this.siblings().superfish('hide').end().superfish('show');
+			},
+			out = function () {
+				var $this = $(this),
+					o = getOptions($this);
+				if (ios) {
+					$.proxy(close, $this, o)();
+				}
+				else {
+					clearTimeout(o.sfTimer);
+					o.sfTimer = setTimeout($.proxy(close, $this, o), o.delay);
+				}
+			},
+			close = function (o) {
+				o.retainPath = ($.inArray(this[0], o.$path) > -1);
+				this.superfish('hide');
+
+				if (!this.parents('.' + o.hoverClass).length) {
+					o.onIdle.call(getMenu(this));
+					if (o.$path.length) {
+						$.proxy(over, o.$path)();
+					}
+				}
+			},
+			getMenu = function ($el) {
+				return $el.closest('.' + c.menuClass);
+			},
+			getOptions = function ($el) {
+				return getMenu($el).data('sf-options');
+			};
+
+		return {
+			// public methods
+			hide: function (instant) {
+				if (this.length) {
+					var $this = this,
+						o = getOptions($this);
+					if (!o) {
+						return this;
+					}
+					var not = (o.retainPath === true) ? o.$path : '',
+						$ul = $this.find('li.' + o.hoverClass).add(this).not(not).removeClass(o.hoverClass).children(o.popUpSelector),
+						speed = o.speedOut;
+
+					if (instant) {
+						$ul.show();
+						speed = 0;
+					}
+					o.retainPath = false;
+
+					if (o.onBeforeHide.call($ul) === false) {
+						return this;
+					}
+
+					$ul.stop(true, true).animate(o.animationOut, speed, function () {
+						var $this = $(this);
+						o.onHide.call($this);
+					});
+				}
+				return this;
+			},
+			show: function () {
+				var o = getOptions(this);
+				if (!o) {
+					return this;
+				}
+				var $this = this.addClass(o.hoverClass),
+					$ul = $this.children(o.popUpSelector);
+
+				if (o.onBeforeShow.call($ul) === false) {
+					return this;
+				}
+
+				$ul.stop(true, true).animate(o.animation, o.speed, function () {
+					o.onShow.call($ul);
+				});
+				return this;
+			},
+			destroy: function () {
+				return this.each(function () {
+					var $this = $(this),
+						o = $this.data('sf-options'),
+						$hasPopUp;
+					if (!o) {
+						return false;
+					}
+					$hasPopUp = $this.find(o.popUpSelector).parent('li');
+					clearTimeout(o.sfTimer);
+					toggleMenuClasses($this, o);
+					toggleAnchorClass($hasPopUp);
+					toggleTouchAction($this);
+					// remove event handlers
+					$this.off('.superfish').off('.hoverIntent');
+					// clear animation's inline display style
+					$hasPopUp.children(o.popUpSelector).attr('style', function (i, style) {
+						return style.replace(/display[^;]+;?/g, '');
+					});
+					// reset 'current' path classes
+					o.$path.removeClass(o.hoverClass + ' ' + c.bcClass).addClass(o.pathClass);
+					$this.find('.' + o.hoverClass).removeClass(o.hoverClass);
+					o.onDestroy.call($this);
+					$this.removeData('sf-options');
+				});
+			},
+			init: function (op) {
+				return this.each(function () {
+					var $this = $(this);
+					if ($this.data('sf-options')) {
+						return false;
+					}
+					var o = $.extend({}, $.fn.superfish.defaults, op),
+						$hasPopUp = $this.find(o.popUpSelector).parent('li');
+					o.$path = setPathToCurrent($this, o);
+
+					$this.data('sf-options', o);
+
+					toggleMenuClasses($this, o);
+					toggleAnchorClass($hasPopUp);
+					toggleTouchAction($this);
+					applyHandlers($this, o);
+
+					$hasPopUp.not('.' + c.bcClass).superfish('hide', true);
+
+					o.onInit.call(this);
+				});
+			}
+		};
+	})();
+
+	$.fn.superfish = function (method, args) {
+		if (methods[method]) {
+			return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
+		}
+		else if (typeof method === 'object' || ! method) {
+			return methods.init.apply(this, arguments);
+		}
+		else {
+			return $.error('Method ' +  method + ' does not exist on jQuery.fn.superfish');
+		}
+	};
+
+	$.fn.superfish.defaults = {
+		popUpSelector: 'ul,.sf-mega', // within menu context
+		hoverClass: 'sfHover',
+		pathClass: 'overrideThisToUse',
+		pathLevels: 1,
+		delay: 800,
+		animation: {opacity: 'show'},
+		animationOut: {opacity: 'hide'},
+		speed: 'normal',
+		speedOut: 'fast',
+		cssArrows: true,
+		disableHI: false,
+		onInit: $.noop,
+		onBeforeShow: $.noop,
+		onShow: $.noop,
+		onBeforeHide: $.noop,
+		onHide: $.noop,
+		onIdle: $.noop,
+		onDestroy: $.noop,
+		onHandleTouch: $.noop
+	};
+
+})(jQuery, window);