text: /*jslint unparam: true, browser: true, indent: 2 */
  
  ;(function ($, window, document, undefined) {
    'use strict';
  
    Foundation.libs.joyride = {
      name: 'joyride',
  
      version : '4.1.2',
  
      defaults : {
        expose               : false,      // turn on or off the expose feature
        modal                : false,      // Whether to cover page with modal during the tour
        tipLocation          : 'bottom',  // 'top' or 'bottom' in relation to parent
        nubPosition          : 'auto',    // override on a per tooltip bases
        scrollSpeed          : 300,       // Page scrolling speed in milliseconds, 0 = no scroll animation
        timer                : 0,         // 0 = no timer , all other numbers = timer in milliseconds
        startTimerOnClick    : true,      // true or false - true requires clicking the first button start the timer
        startOffset          : 0,         // the index of the tooltip you want to start on (index of the li)
        nextButton           : true,      // true or false to control whether a next button is used
        tipAnimation         : 'fade',    // 'pop' or 'fade' in each tip
        pauseAfter           : [],        // array of indexes where to pause the tour after
        exposed              : [],        // array of expose elements
        tipAnimationFadeSpeed: 300,       // when tipAnimation = 'fade' this is speed in milliseconds for the transition
        cookieMonster        : false,     // true or false to control whether cookies are used
        cookieName           : 'joyride', // Name the cookie you'll use
        cookieDomain         : false,     // Will this cookie be attached to a domain, ie. '.notableapp.com'
        cookieExpires        : 365,       // set when you would like the cookie to expire.
        tipContainer         : 'body',    // Where will the tip be attached
        postRideCallback     : function (){},    // A method to call once the tour closes (canceled or complete)
        postStepCallback     : function (){},    // A method to call after each step
        preStepCallback      : function (){},    // A method to call before each step
        preRideCallback      : function (){},    // A method to call before the tour starts (passed index, tip, and cloned exposed element)
        postExposeCallback   : function (){},    // A method to call after an element has been exposed
        template : { // HTML segments for tip layout
          link    : '<a href="#close" class="joyride-close-tip">&times;</a>',
          timer   : '<div class="joyride-timer-indicator-wrap"><span class="joyride-timer-indicator"></span></div>',
          tip     : '<div class="joyride-tip-guide"><span class="joyride-nub"></span></div>',
          wrapper : '<div class="joyride-content-wrapper"></div>',
          button  : '<a href="#" class="small button joyride-next-tip"></a>',
          modal   : '<div class="joyride-modal-bg"></div>',
          expose  : '<div class="joyride-expose-wrapper"></div>',
          exposeCover: '<div class="joyride-expose-cover"></div>'
        }
      },
  
      settings : {},
  
      init : function (scope, method, options) {
        this.scope = scope || this.scope;
        Foundation.inherit(this, 'throttle data_options scrollTo scrollLeft delay');
  
        if (typeof method === 'object') {
          $.extend(true, this.settings, this.defaults, method);
        } else {
          $.extend(true, this.settings, this.defaults, options);
        }
  
        if (typeof method != 'string') {
          if (!this.settings.init) this.events();
  
          return this.settings.init;
        } else {
          return this[method].call(this, options);
        }
      },
  
      events : function () {
        var self = this;
  
        $(this.scope)
          .on('click.joyride', '.joyride-next-tip, .joyride-modal-bg', function (e) {
            e.preventDefault();
  
            if (this.settings.$li.next().length < 1) {
              this.end();
            } else if (this.settings.timer > 0) {
              clearTimeout(this.settings.automate);
              this.hide();
              this.show();
              this.startTimer();
            } else {
              this.hide();
              this.show();
            }
  
          }.bind(this))
  
          .on('click.joyride', '.joyride-close-tip', function (e) {
            e.preventDefault();
            this.end();
          }.bind(this));
  
        $(window).on('resize.fndtn.joyride', self.throttle(function () {
          if ($('[data-joyride]').length > 0 && self.settings.$next_tip) {
            if (self.settings.exposed.length > 0) {
              var $els = $(self.settings.exposed);
  
              $els.each(function () {
                var $this = $(this);
                self.un_expose($this);
                self.expose($this);
              });
            }
  
            if (self.is_phone()) {
              self.pos_phone();
            } else {
              self.pos_default(false, true);
            }
          }
        }, 100));
  
        this.settings.init = true;
      },
  
      start : function () {
        var self = this,
            $this = $(this.scope).find('[data-joyride]'),
            integer_settings = ['timer', 'scrollSpeed', 'startOffset', 'tipAnimationFadeSpeed', 'cookieExpires'],
            int_settings_count = integer_settings.length;
  
        if (!this.settings.init) this.init();
        
        // non configureable settings
        this.settings.$content_el = $this;
        this.settings.$body = $(this.settings.tipContainer);
        this.settings.body_offset = $(this.settings.tipContainer).position();
        this.settings.$tip_content = this.settings.$content_el.find('> li');
        this.settings.paused = false;
        this.settings.attempts = 0;
  
        this.settings.tipLocationPatterns = {
          top: ['bottom'],
          bottom: [], // bottom should not need to be repositioned
          left: ['right', 'top', 'bottom'],
          right: ['left', 'top', 'bottom']
        };
  
        // can we create cookies?
        if (typeof $.cookie !== 'function') {
          this.settings.cookieMonster = false;
        }
  
        // generate the tips and insert into dom.
        if (!this.settings.cookieMonster || this.settings.cookieMonster && $.cookie(this.settings.cookieName) === null) {
          this.settings.$tip_content.each(function (index) {
            var $this = $(this);
            $.extend(true, self.settings, self.data_options($this));
            // Make sure that settings parsed from data_options are integers where necessary
            for (var i = int_settings_count - 1; i >= 0; i--) {
              self.settings[integer_settings[i]] = parseInt(self.settings[integer_settings[i]], 10);
            }
            self.create({$li : $this, index : index});
          });
  
          // show first tip
          if (!this.settings.startTimerOnClick && this.settings.timer > 0) {
            this.show('init');
            this.startTimer();
          } else {
            this.show('init');
          }
  
        }
      },
  
      resume : function () {
        this.set_li();
        this.show();
      },
  
      tip_template : function (opts) {
        var $blank, content;
  
        opts.tip_class = opts.tip_class || '';
  
        $blank = $(this.settings.template.tip).addClass(opts.tip_class);
        content = $.trim($(opts.li).html()) +
          this.button_text(opts.button_text) +
          this.settings.template.link +
          this.timer_instance(opts.index);
  
        $blank.append($(this.settings.template.wrapper));
        $blank.first().attr('data-index', opts.index);
        $('.joyride-content-wrapper', $blank).append(content);
  
        return $blank[0];
      },
  
      timer_instance : function (index) {
        var txt;
  
        if ((index === 0 && this.settings.startTimerOnClick && this.settings.timer > 0) || this.settings.timer === 0) {
          txt = '';
        } else {
          txt = this.outerHTML($(this.settings.template.timer)[0]);
        }
        return txt;
      },
  
      button_text : function (txt) {
        if (this.settings.nextButton) {
          txt = $.trim(txt) || 'Next';
          txt = this.outerHTML($(this.settings.template.button).append(txt)[0]);
        } else {
          txt = '';
        }
        return txt;
      },
  
      create : function (opts) {
        var buttonText = opts.$li.attr('data-button') || opts.$li.attr('data-text'),
          tipClass = opts.$li.attr('class'),
          $tip_content = $(this.tip_template({
            tip_class : tipClass,
            index : opts.index,
            button_text : buttonText,
            li : opts.$li
          }));
  
        $(this.settings.tipContainer).append($tip_content);
      },
  
      show : function (init) {
        var $timer = null;
  
        // are we paused?
        if (this.settings.$li === undefined
          || ($.inArray(this.settings.$li.index(), this.settings.pauseAfter) === -1)) {
  
          // don't go to the next li if the tour was paused
          if (this.settings.paused) {
            this.settings.paused = false;
          } else {
            this.set_li(init);
          }
  
          this.settings.attempts = 0;
  
          if (this.settings.$li.length && this.settings.$target.length > 0) {
            if (init) { //run when we first start
              this.settings.preRideCallback(this.settings.$li.index(), this.settings.$next_tip);
              if (this.settings.modal) {
                this.show_modal();
              }
            }
  
            this.settings.preStepCallback(this.settings.$li.index(), this.settings.$next_tip);
  
            if (this.settings.modal && this.settings.expose) {
              this.expose();
            }
  
            this.settings.tipSettings = $.extend(this.settings, this.data_options(this.settings.$li));
  
            this.settings.timer = parseInt(this.settings.timer, 10);
  
            this.settings.tipSettings.tipLocationPattern = this.settings.tipLocationPatterns[this.settings.tipSettings.tipLocation];
  
            // scroll if not modal
            if (!/body/i.test(this.settings.$target.selector)) {
              this.scroll_to();
            }
  
            if (this.is_phone()) {
              this.pos_phone(true);
            } else {
              this.pos_default(true);
            }
  
            $timer = this.settings.$next_tip.find('.joyride-timer-indicator');
  
            if (/pop/i.test(this.settings.tipAnimation)) {
  
              $timer.width(0);
  
              if (this.settings.timer > 0) {
  
                this.settings.$next_tip.show();
  
                this.delay(function () {
                  $timer.animate({
                    width: $timer.parent().width()
                  }, this.settings.timer, 'linear');
                }.bind(this), this.settings.tipAnimationFadeSpeed);
  
              } else {
                this.settings.$next_tip.show();
  
              }
  
  
            } else if (/fade/i.test(this.settings.tipAnimation)) {
  
              $timer.width(0);
  
              if (this.settings.timer > 0) {
  
                this.settings.$next_tip
                  .fadeIn(this.settings.tipAnimationFadeSpeed)
                  .show();
  
                this.delay(function () {
                  $timer.animate({
                    width: $timer.parent().width()
                  }, this.settings.timer, 'linear');
                }.bind(this), this.settings.tipAnimationFadeSpeed);
  
              } else {
                this.settings.$next_tip.fadeIn(this.settings.tipAnimationFadeSpeed);
  
              }
            }
  
            this.settings.$current_tip = this.settings.$next_tip;
  
          // skip non-existant targets
          } else if (this.settings.$li && this.settings.$target.length < 1) {
  
            this.show();
  
          } else {
  
            this.end();
  
          }
        } else {
  
          this.settings.paused = true;
  
        }
  
      },
  
      is_phone : function () {
        if (Modernizr) {
          return Modernizr.mq('only screen and (max-width: 767px)') || $('.lt-ie9').length > 0;
        }
  
        return (this.settings.$window.width() < 767);
      },
  
      hide : function () {
        if (this.settings.modal && this.settings.expose) {
          this.un_expose();
        }
  
        if (!this.settings.modal) {
          $('.joyride-modal-bg').hide();
        }
        this.settings.$current_tip.hide();
        this.settings.postStepCallback(this.settings.$li.index(),
          this.settings.$current_tip);
      },
  
      set_li : function (init) {
        if (init) {
          this.settings.$li = this.settings.$tip_content.eq(this.settings.startOffset);
          this.set_next_tip();
          this.settings.$current_tip = this.settings.$next_tip;
        } else {
          this.settings.$li = this.settings.$li.next();
          this.set_next_tip();
        }
  
        this.set_target();
      },
  
      set_next_tip : function () {
        this.settings.$next_tip = $(".joyride-tip-guide[data-index='" + this.settings.$li.index() + "']");
        this.settings.$next_tip.data('closed', '');
      },
  
      set_target : function () {
        var cl = this.settings.$li.attr('data-class'),
            id = this.settings.$li.attr('data-id'),
            $sel = function () {
              if (id) {
                return $(document.getElementById(id));
              } else if (cl) {
                return $('.' + cl).first();
              } else {
                return $('body');
              }
            };
  
        this.settings.$target = $sel();
      },
  
      scroll_to : function () {
        var window_half, tipOffset;
  
        window_half = $(window).height() / 2;
        tipOffset = Math.ceil(this.settings.$target.offset().top - window_half + this.outerHeight(this.settings.$next_tip));
        if (tipOffset > 0) {
          this.scrollTo($('html, body'), tipOffset, this.settings.scrollSpeed);
        }
      },
  
      paused : function () {
        return ($.inArray((this.settings.$li.index() + 1), this.settings.pauseAfter) === -1);
      },
  
      restart : function () {
        this.hide();
        this.settings.$li = undefined;
        this.show('init');
      },
  
      pos_default : function (init, resizing) {
        var half_fold = Math.ceil($(window).height() / 2),
            tip_position = this.settings.$next_tip.offset(),
            $nub = this.settings.$next_tip.find('.joyride-nub'),
            nub_width = Math.ceil(this.outerWidth($nub) / 2),
            nub_height = Math.ceil(this.outerHeight($nub) / 2),
            toggle = init || false;
  
        // tip must not be "display: none" to calculate position
        if (toggle) {
          this.settings.$next_tip.css('visibility', 'hidden');
          this.settings.$next_tip.show();
        }
  
        if (typeof resizing === 'undefined') {
          resizing = false;
        }
  
        if (!/body/i.test(this.settings.$target.selector)) {
  
            if (this.bottom()) {
              var leftOffset = this.settings.$target.offset().left;
              if (Foundation.rtl) {
                leftOffset = this.settings.$target.offset().width - this.settings.$next_tip.width() + leftOffset;
              }
              this.settings.$next_tip.css({
                top: (this.settings.$target.offset().top + nub_height + this.outerHeight(this.settings.$target)),
                left: leftOffset});
  
              this.nub_position($nub, this.settings.tipSettings.nubPosition, 'top');
  
            } else if (this.top()) {
              var leftOffset = this.settings.$target.offset().left;
              if (Foundation.rtl) {
                leftOffset = this.settings.$target.offset().width - this.settings.$next_tip.width() + leftOffset;
              }
              this.settings.$next_tip.css({
                top: (this.settings.$target.offset().top - this.outerHeight(this.settings.$next_tip) - nub_height),
                left: leftOffset});
  
              this.nub_position($nub, this.settings.tipSettings.nubPosition, 'bottom');
  
            } else if (this.right()) {
  
              this.settings.$next_tip.css({
                top: this.settings.$target.offset().top,
                left: (this.outerWidth(this.settings.$target) + this.settings.$target.offset().left + nub_width)});
  
              this.nub_position($nub, this.settings.tipSettings.nubPosition, 'left');
  
            } else if (this.left()) {
  
              this.settings.$next_tip.css({
                top: this.settings.$target.offset().top,
                left: (this.settings.$target.offset().left - this.outerWidth(this.settings.$next_tip) - nub_width)});
  
              this.nub_position($nub, this.settings.tipSettings.nubPosition, 'right');
  
            }
  
            if (!this.visible(this.corners(this.settings.$next_tip)) && this.settings.attempts < this.settings.tipSettings.tipLocationPattern.length) {
  
              $nub.removeClass('bottom')
                .removeClass('top')
                .removeClass('right')
                .removeClass('left');
  
              this.settings.tipSettings.tipLocation = this.settings.tipSettings.tipLocationPattern[this.settings.attempts];
  
              this.settings.attempts++;
  
              this.pos_default();
  
            }
  
        } else if (this.settings.$li.length) {
  
          this.pos_modal($nub);
  
        }
  
        if (toggle) {
          this.settings.$next_tip.hide();
          this.settings.$next_tip.css('visibility', 'visible');
        }
  
      },
  
      pos_phone : function (init) {
        var tip_height = this.outerHeight(this.settings.$next_tip),
            tip_offset = this.settings.$next_tip.offset(),
            target_height = this.outerHeight(this.settings.$target),
            $nub = $('.joyride-nub', this.settings.$next_tip),
            nub_height = Math.ceil(this.outerHeight($nub) / 2),
            toggle = init || false;
  
        $nub.removeClass('bottom')
          .removeClass('top')
          .removeClass('right')
          .removeClass('left');
  
        if (toggle) {
          this.settings.$next_tip.css('visibility', 'hidden');
          this.settings.$next_tip.show();
        }
  
        if (!/body/i.test(this.settings.$target.selector)) {
  
          if (this.top()) {
  
              this.settings.$next_tip.offset({top: this.settings.$target.offset().top - tip_height - nub_height});
              $nub.addClass('bottom');
  
          } else {
  
            this.settings.$next_tip.offset({top: this.settings.$target.offset().top + target_height + nub_height});
            $nub.addClass('top');
  
          }
  
        } else if (this.settings.$li.length) {
          this.pos_modal($nub);
        }
  
        if (toggle) {
          this.settings.$next_tip.hide();
          this.settings.$next_tip.css('visibility', 'visible');
        }
      },
  
      pos_modal : function ($nub) {
        this.center();
        $nub.hide();
  
        this.show_modal();
      },
  
      show_modal : function () {
        if (!this.settings.$next_tip.data('closed')) {
          if ($('.joyride-modal-bg').length < 1) {
            $('body').append(this.settings.template.modal).show();
          }
  
          if (/pop/i.test(this.settings.tipAnimation)) {
            $('.joyride-modal-bg').show();
          } else {
            $('.joyride-modal-bg').fadeIn(this.settings.tipAnimationFadeSpeed);
          }
        }
      },
  
      expose : function () {
        var expose,
            exposeCover,
            el,
            origCSS,
            randId = 'expose-'+Math.floor(Math.random()*10000);
  
        if (arguments.length > 0 && arguments[0] instanceof $) {
          el = arguments[0];
        } else if(this.settings.$target && !/body/i.test(this.settings.$target.selector)){
          el = this.settings.$target;
        }  else {
          return false;
        }
  
        if(el.length < 1){
          if(window.console){
            console.error('element not valid', el);
          }
          return false;
        }
  
        expose = $(this.settings.template.expose);
        this.settings.$body.append(expose);
        expose.css({
          top: el.offset().top,
          left: el.offset().left,
          width: this.outerWidth(el, true),
          height: this.outerHeight(el, true)
        });
        
        exposeCover = $(this.settings.template.exposeCover);
  
        origCSS = {
          zIndex: el.css('z-index'),
          position: el.css('position')
        };
  
        el.css('z-index',expose.css('z-index')*1+1);
  
        if (origCSS.position == 'static') {
          el.css('position','relative');
        }
  
        el.data('expose-css',origCSS);
  
        exposeCover.css({
          top: el.offset().top,
          left: el.offset().left,
          width: this.outerWidth(el, true),
          height: this.outerHeight(el, true)
        });
  
        this.settings.$body.append(exposeCover);
        expose.addClass(randId);
        exposeCover.addClass(randId);
        el.data('expose', randId);
        this.settings.postExposeCallback(this.settings.$li.index(), this.settings.$next_tip, el);
        this.add_exposed(el);
      },
  
      un_expose : function () {
        var exposeId,
            el,
            expose ,
            origCSS,
            clearAll = false;
  
        if (arguments.length > 0 && arguments[0] instanceof $) {
          el = arguments[0];
        } else if(this.settings.$target && !/body/i.test(this.settings.$target.selector)){
          el = this.settings.$target;
        }  else {
          return false;
        }
  
        if(el.length < 1){
          if (window.console) {
            console.error('element not valid', el);
          }
          return false;
        }
  
        exposeId = el.data('expose');
        expose = $('.' + exposeId);
  
        if (arguments.length > 1) {
          clearAll = arguments[1];
        }
  
        if (clearAll === true) {
          $('.joyride-expose-wrapper,.joyride-expose-cover').remove();
        } else {
          expose.remove();
        }
  
        origCSS = el.data('expose-css');
  
        if (origCSS.zIndex == 'auto') {
          el.css('z-index', '');
        } else {
          el.css('z-index', origCSS.zIndex);
        }
  
        if (origCSS.position != el.css('position')) {
          if(origCSS.position == 'static') {// this is default, no need to set it.
            el.css('position', '');
          } else {
            el.css('position', origCSS.position);
          }
        }
  
        el.removeData('expose');
        el.removeData('expose-z-index');
        this.remove_exposed(el);
      },
  
      add_exposed: function(el){
        this.settings.exposed = this.settings.exposed || [];
        if (el instanceof $ || typeof el === 'object') {
          this.settings.exposed.push(el[0]);
        } else if (typeof el == 'string') {
          this.settings.exposed.push(el);
        }
      },
  
      remove_exposed: function(el){
        var search, count;
        if (el instanceof $) {
          search = el[0]
        } else if (typeof el == 'string'){
          search = el;
        }
  
        this.settings.exposed = this.settings.exposed || [];
        count = this.settings.exposed.length;
  
        for (var i=0; i < count; i++) {
          if (this.settings.exposed[i] == search) {
            this.settings.exposed.splice(i, 1);
            return;
          }
        }
      },
  
      center : function () {
        var $w = $(window);
  
        this.settings.$next_tip.css({
          top : ((($w.height() - this.outerHeight(this.settings.$next_tip)) / 2) + $w.scrollTop()),
          left : ((($w.width() - this.outerWidth(this.settings.$next_tip)) / 2) + this.scrollLeft($w))
        });
  
        return true;
      },
  
      bottom : function () {
        return /bottom/i.test(this.settings.tipSettings.tipLocation);
      },
  
      top : function () {
        return /top/i.test(this.settings.tipSettings.tipLocation);
      },
  
      right : function () {
        return /right/i.test(this.settings.tipSettings.tipLocation);
      },
  
      left : function () {
        return /left/i.test(this.settings.tipSettings.tipLocation);
      },
  
      corners : function (el) {
        var w = $(window),
            window_half = w.height() / 2,
            //using this to calculate since scroll may not have finished yet.
            tipOffset = Math.ceil(this.settings.$target.offset().top - window_half + this.settings.$next_tip.outerHeight()),
            right = w.width() + this.scrollLeft(w),
            offsetBottom =  w.height() + tipOffset,
            bottom = w.height() + w.scrollTop(),
            top = w.scrollTop();
  
        if (tipOffset < top) {
          if (tipOffset < 0) {
            top = 0;
          } else {
            top = tipOffset;
          }
        }
  
        if (offsetBottom > bottom) {
          bottom = offsetBottom;
        }
  
        return [
          el.offset().top < top,
          right < el.offset().left + el.outerWidth(),
          bottom < el.offset().top + el.outerHeight(),
          this.scrollLeft(w) > el.offset().left
        ];
      },
  
      visible : function (hidden_corners) {
        var i = hidden_corners.length;
  
        while (i--) {
          if (hidden_corners[i]) return false;
        }
  
        return true;
      },
  
      nub_position : function (nub, pos, def) {
        if (pos === 'auto') {
          nub.addClass(def);
        } else {
          nub.addClass(pos);
        }
      },
  
      startTimer : function () {
        if (this.settings.$li.length) {
          this.settings.automate = setTimeout(function () {
            this.hide();
            this.show();
            this.startTimer();
          }.bind(this), this.settings.timer);
        } else {
          clearTimeout(this.settings.automate);
        }
      },
  
      end : function () {
        if (this.settings.cookieMonster) {
          $.cookie(this.settings.cookieName, 'ridden', { expires: this.settings.cookieExpires, domain: this.settings.cookieDomain });
        }
  
        if (this.settings.timer > 0) {
          clearTimeout(this.settings.automate);
        }
  
        if (this.settings.modal && this.settings.expose) {
          this.un_expose();
        }
  
        this.settings.$next_tip.data('closed', true);
  
        $('.joyride-modal-bg').hide();
        this.settings.$current_tip.hide();
        this.settings.postStepCallback(this.settings.$li.index(), this.settings.$current_tip);
        this.settings.postRideCallback(this.settings.$li.index(), this.settings.$current_tip);
      },
  
      outerHTML : function (el) {
        // support FireFox < 11
        return el.outerHTML || new XMLSerializer().serializeToString(el);
      },
  
      off : function () {
        $(this.scope).off('.joyride');
        $(window).off('.joyride');
        $('.joyride-close-tip, .joyride-next-tip, .joyride-modal-bg').off('.joyride');
        $('.joyride-tip-guide, .joyride-modal-bg').remove();
        clearTimeout(this.settings.automate);
        this.settings = {};
      }
    };
  }(Foundation.zj, this, this.document));