docs-cambiocds-com-jekyll-theme 0.0.4 → 0.0.5

data/assets/js/foundation/foundation.magellan.js

@@ -0,0 +1,199 @@
+;
+(function ($, window, document, undefined) {
+    'use strict';
+
+    Foundation.libs['magellan-expedition'] = {
+        name: 'magellan-expedition',
+
+        version: '5.5.0',
+
+        settings: {
+            active_class: 'active',
+            threshold: 0, // pixels from the top of the expedition for it to become fixes
+            destination_threshold: 20, // pixels from the top of destination for it to be considered active
+            throttle_delay: 30, // calculation throttling to increase framerate
+            fixed_top: 0, // top distance in pixels assigend to the fixed element on scroll
+            offset_by_height: true,  // whether to offset the destination by the expedition height. Usually you want this to be true, unless your expedition is on the side.
+            duration: 700, // animation duration time
+            easing: 'swing' // animation easing
+        },
+
+        init: function (scope, method, options) {
+            Foundation.inherit(this, 'throttle');
+            this.bindings(method, options);
+        },
+
+        events: function () {
+            var self = this,
+                S = self.S,
+                settings = self.settings;
+
+            // initialize expedition offset
+            self.set_expedition_position();
+
+            S(self.scope)
+                .off('.magellan')
+                .on('click.fndtn.magellan', '[' + self.add_namespace('data-magellan-arrival') + '] a[href^="#"]', function (e) {
+                    e.preventDefault();
+                    var expedition = $(this).closest('[' + self.attr_name() + ']'),
+                        settings = expedition.data('magellan-expedition-init'),
+                        hash = this.hash.split('#').join(''),
+                        target = $('a[name="' + hash + '"]');
+
+                    if (target.length === 0) {
+                        target = $('#' + hash);
+
+                    }
+
+
+                    // Account for expedition height if fixed position
+                    var scroll_top = target.offset().top - settings.destination_threshold + 1;
+                    if (settings.offset_by_height) {
+                        scroll_top = scroll_top - expedition.outerHeight();
+                    }
+
+                    $('html, body').stop().animate({
+                        'scrollTop': scroll_top
+                    }, settings.duration, settings.easing, function () {
+                        if (history.pushState) {
+                            history.pushState(null, null, '#' + hash);
+                        }
+                        else {
+                            location.hash = '#' + hash;
+                        }
+                    });
+                })
+                .on('scroll.fndtn.magellan', self.throttle(this.check_for_arrivals.bind(this), settings.throttle_delay));
+
+            $(window)
+                .on('resize.fndtn.magellan', self.throttle(this.set_expedition_position.bind(this), settings.throttle_delay));
+        },
+
+        check_for_arrivals: function () {
+            var self = this;
+            self.update_arrivals();
+            self.update_expedition_positions();
+        },
+
+        set_expedition_position: function () {
+            var self = this;
+            $('[' + this.attr_name() + '=fixed]', self.scope).each(function (idx, el) {
+                var expedition = $(this),
+                    settings = expedition.data('magellan-expedition-init'),
+                    styles = expedition.attr('styles'), // save styles
+                    top_offset, fixed_top;
+
+                expedition.attr('style', '');
+                top_offset = expedition.offset().top + settings.threshold;
+
+                //set fixed-top by attribute
+                fixed_top = parseInt(expedition.data('magellan-fixed-top'));
+                if (!isNaN(fixed_top))
+                    self.settings.fixed_top = fixed_top;
+
+                expedition.data(self.data_attr('magellan-top-offset'), top_offset);
+                expedition.attr('style', styles);
+            });
+        },
+
+        update_expedition_positions: function () {
+            var self = this,
+                window_top_offset = $(window).scrollTop();
+
+            $('[' + this.attr_name() + '=fixed]', self.scope).each(function () {
+                var expedition = $(this),
+                    settings = expedition.data('magellan-expedition-init'),
+                    styles = expedition.attr('style'), // save styles
+                    top_offset = expedition.data('magellan-top-offset');
+
+                //scroll to the top distance
+                if (window_top_offset + self.settings.fixed_top >= top_offset) {
+                    // Placeholder allows height calculations to be consistent even when
+                    // appearing to switch between fixed/non-fixed placement
+                    var placeholder = expedition.prev('[' + self.add_namespace('data-magellan-expedition-clone') + ']');
+                    if (placeholder.length === 0) {
+                        placeholder = expedition.clone();
+                        placeholder.removeAttr(self.attr_name());
+                        placeholder.attr(self.add_namespace('data-magellan-expedition-clone'), '');
+                        expedition.before(placeholder);
+                    }
+                    expedition.css({position: 'fixed', top: settings.fixed_top}).addClass('fixed');
+                } else {
+                    expedition.prev('[' + self.add_namespace('data-magellan-expedition-clone') + ']').remove();
+                    expedition.attr('style', styles).css('position', '').css('top', '').removeClass('fixed');
+                }
+            });
+        },
+
+        update_arrivals: function () {
+            var self = this,
+                window_top_offset = $(window).scrollTop();
+
+            $('[' + this.attr_name() + ']', self.scope).each(function () {
+                var expedition = $(this),
+                    settings = expedition.data(self.attr_name(true) + '-init'),
+                    offsets = self.offsets(expedition, window_top_offset),
+                    arrivals = expedition.find('[' + self.add_namespace('data-magellan-arrival') + ']'),
+                    active_item = false;
+                offsets.each(function (idx, item) {
+                    if (item.viewport_offset >= item.top_offset) {
+                        var arrivals = expedition.find('[' + self.add_namespace('data-magellan-arrival') + ']');
+                        arrivals.not(item.arrival).removeClass(settings.active_class);
+                        item.arrival.addClass(settings.active_class);
+                        active_item = true;
+                        return true;
+                    }
+                });
+
+                if (!active_item) arrivals.removeClass(settings.active_class);
+            });
+        },
+
+        offsets: function (expedition, window_offset) {
+            var self = this,
+                settings = expedition.data(self.attr_name(true) + '-init'),
+                viewport_offset = window_offset;
+
+            return expedition.find('[' + self.add_namespace('data-magellan-arrival') + ']').map(function (idx, el) {
+                var name = $(this).data(self.data_attr('magellan-arrival')),
+                    dest = $('[' + self.add_namespace('data-magellan-destination') + '=' + name + ']');
+                if (dest.length > 0) {
+                    var top_offset = dest.offset().top - settings.destination_threshold;
+                    if (settings.offset_by_height) {
+                        top_offset = top_offset - expedition.outerHeight();
+                    }
+                    top_offset = Math.floor(top_offset);
+                    return {
+                        destination: dest,
+                        arrival: $(this),
+                        top_offset: top_offset,
+                        viewport_offset: viewport_offset
+                    }
+                }
+            }).sort(function (a, b) {
+                if (a.top_offset < b.top_offset) return -1;
+                if (a.top_offset > b.top_offset) return 1;
+                return 0;
+            });
+        },
+
+        data_attr: function (str) {
+            if (this.namespace.length > 0) {
+                return this.namespace + '-' + str;
+            }
+
+            return str;
+        },
+
+        off: function () {
+            this.S(this.scope).off('.magellan');
+            this.S(window).off('.magellan');
+        },
+
+        reflow: function () {
+            var self = this;
+            // remove placeholder expeditions used for height calculation purposes
+            $('[' + self.add_namespace('data-magellan-expedition-clone') + ']', self.scope).remove();
+        }
+    };
+}(jQuery, window, window.document));

data/assets/js/foundation/foundation.offcanvas.js

@@ -0,0 +1,154 @@
+;
+(function ($, window, document, undefined) {
+    'use strict';
+
+    Foundation.libs.offcanvas = {
+        name: 'offcanvas',
+
+        version: '5.5.0',
+
+        settings: {
+            open_method: 'move',
+            close_on_click: false
+        },
+
+        init: function (scope, method, options) {
+            this.bindings(method, options);
+        },
+
+        events: function () {
+            var self = this,
+                S = self.S,
+                move_class = '',
+                right_postfix = '',
+                left_postfix = '';
+
+            if (this.settings.open_method === 'move') {
+                move_class = 'move-';
+                right_postfix = 'right';
+                left_postfix = 'left';
+            } else if (this.settings.open_method === 'overlap_single') {
+                move_class = 'offcanvas-overlap-';
+                right_postfix = 'right';
+                left_postfix = 'left';
+            } else if (this.settings.open_method === 'overlap') {
+                move_class = 'offcanvas-overlap';
+            }
+
+            S(this.scope).off('.offcanvas')
+                .on('click.fndtn.offcanvas', '.left-off-canvas-toggle', function (e) {
+                    self.click_toggle_class(e, move_class + right_postfix);
+                    if (self.settings.open_method !== 'overlap') {
+                        S('.left-submenu').removeClass(move_class + right_postfix);
+                    }
+                    $('.left-off-canvas-toggle').attr('aria-expanded', 'true');
+                })
+                .on('click.fndtn.offcanvas', '.left-off-canvas-menu a', function (e) {
+                    var settings = self.get_settings(e);
+                    var parent = S(this).parent();
+
+                    if (settings.close_on_click && !parent.hasClass('has-submenu') && !parent.hasClass('back')) {
+                        self.hide.call(self, move_class + right_postfix, self.get_wrapper(e));
+                        parent.parent().removeClass(move_class + right_postfix);
+                    } else if (S(this).parent().hasClass('has-submenu')) {
+                        e.preventDefault();
+                        S(this).siblings('.left-submenu').toggleClass(move_class + right_postfix);
+                    } else if (parent.hasClass('back')) {
+                        e.preventDefault();
+                        parent.parent().removeClass(move_class + right_postfix);
+                    }
+                    $('.left-off-canvas-toggle').attr('aria-expanded', 'true');
+                })
+                .on('click.fndtn.offcanvas', '.right-off-canvas-toggle', function (e) {
+                    self.click_toggle_class(e, move_class + left_postfix);
+                    if (self.settings.open_method !== 'overlap') {
+                        S('.right-submenu').removeClass(move_class + left_postfix);
+                    }
+                    $('.right-off-canvas-toggle').attr('aria-expanded', 'true');
+                })
+                .on('click.fndtn.offcanvas', '.right-off-canvas-menu a', function (e) {
+                    var settings = self.get_settings(e);
+                    var parent = S(this).parent();
+
+                    if (settings.close_on_click && !parent.hasClass('has-submenu') && !parent.hasClass('back')) {
+                        self.hide.call(self, move_class + left_postfix, self.get_wrapper(e));
+                        parent.parent().removeClass(move_class + left_postfix);
+                    } else if (S(this).parent().hasClass('has-submenu')) {
+                        e.preventDefault();
+                        S(this).siblings('.right-submenu').toggleClass(move_class + left_postfix);
+                    } else if (parent.hasClass('back')) {
+                        e.preventDefault();
+                        parent.parent().removeClass(move_class + left_postfix);
+                    }
+                    $('.right-off-canvas-toggle').attr('aria-expanded', 'true');
+                })
+                .on('click.fndtn.offcanvas', '.exit-off-canvas', function (e) {
+                    self.click_remove_class(e, move_class + left_postfix);
+                    S('.right-submenu').removeClass(move_class + left_postfix);
+                    if (right_postfix) {
+                        self.click_remove_class(e, move_class + right_postfix);
+                        S('.left-submenu').removeClass(move_class + left_postfix);
+                    }
+                    $('.right-off-canvas-toggle').attr('aria-expanded', 'true');
+                })
+                .on('click.fndtn.offcanvas', '.exit-off-canvas', function (e) {
+                    self.click_remove_class(e, move_class + left_postfix);
+                    $('.left-off-canvas-toggle').attr('aria-expanded', 'false');
+                    if (right_postfix) {
+                        self.click_remove_class(e, move_class + right_postfix);
+                        $('.right-off-canvas-toggle').attr('aria-expanded', 'false');
+                    }
+                });
+        },
+
+        toggle: function (class_name, $off_canvas) {
+            $off_canvas = $off_canvas || this.get_wrapper();
+            if ($off_canvas.is('.' + class_name)) {
+                this.hide(class_name, $off_canvas);
+            } else {
+                this.show(class_name, $off_canvas);
+            }
+        },
+
+        show: function (class_name, $off_canvas) {
+            $off_canvas = $off_canvas || this.get_wrapper();
+            $off_canvas.trigger('open').trigger('open.fndtn.offcanvas');
+            $off_canvas.addClass(class_name);
+        },
+
+        hide: function (class_name, $off_canvas) {
+            $off_canvas = $off_canvas || this.get_wrapper();
+            $off_canvas.trigger('close').trigger('close.fndtn.offcanvas');
+            $off_canvas.removeClass(class_name);
+        },
+
+        click_toggle_class: function (e, class_name) {
+            e.preventDefault();
+            var $off_canvas = this.get_wrapper(e);
+            this.toggle(class_name, $off_canvas);
+        },
+
+        click_remove_class: function (e, class_name) {
+            e.preventDefault();
+            var $off_canvas = this.get_wrapper(e);
+            this.hide(class_name, $off_canvas);
+        },
+
+        get_settings: function (e) {
+            var offcanvas = this.S(e.target).closest('[' + this.attr_name() + ']');
+            return offcanvas.data(this.attr_name(true) + '-init') || this.settings;
+        },
+
+        get_wrapper: function (e) {
+            var $off_canvas = this.S(e ? e.target : this.scope).closest('.off-canvas-wrap');
+
+            if ($off_canvas.length === 0) {
+                $off_canvas = this.S('.off-canvas-wrap');
+            }
+            return $off_canvas;
+        },
+
+        reflow: function () {
+        }
+    };
+}(jQuery, window, window.document));

data/assets/js/foundation/foundation.orbit.js

@@ -0,0 +1,512 @@
+;
+(function ($, window, document, undefined) {
+    'use strict';
+
+    var noop = function () {
+    };
+
+    var Orbit = function (el, settings) {
+        // Don't reinitialize plugin
+        if (el.hasClass(settings.slides_container_class)) {
+            return this;
+        }
+
+        var self = this,
+            container,
+            slides_container = el,
+            number_container,
+            bullets_container,
+            timer_container,
+            idx = 0,
+            animate,
+            timer,
+            locked = false,
+            adjust_height_after = false;
+
+
+        self.slides = function () {
+            return slides_container.children(settings.slide_selector);
+        };
+
+        self.slides().first().addClass(settings.active_slide_class);
+
+        self.update_slide_number = function (index) {
+            if (settings.slide_number) {
+                number_container.find('span:first').text(parseInt(index) + 1);
+                number_container.find('span:last').text(self.slides().length);
+            }
+            if (settings.bullets) {
+                bullets_container.children().removeClass(settings.bullets_active_class);
+                $(bullets_container.children().get(index)).addClass(settings.bullets_active_class);
+            }
+        };
+
+        self.update_active_link = function (index) {
+            var link = $('[data-orbit-link="' + self.slides().eq(index).attr('data-orbit-slide') + '"]');
+            link.siblings().removeClass(settings.bullets_active_class);
+            link.addClass(settings.bullets_active_class);
+        };
+
+        self.build_markup = function () {
+            slides_container.wrap('<div class="' + settings.container_class + '"></div>');
+            container = slides_container.parent();
+            slides_container.addClass(settings.slides_container_class);
+
+            if (settings.stack_on_small) {
+                container.addClass(settings.stack_on_small_class);
+            }
+
+            if (settings.navigation_arrows) {
+                container.append($('<a href="#"><span></span></a>').addClass(settings.prev_class));
+                container.append($('<a href="#"><span></span></a>').addClass(settings.next_class));
+            }
+
+            if (settings.timer) {
+                timer_container = $('<div>').addClass(settings.timer_container_class);
+                timer_container.append('<span>');
+                timer_container.append($('<div>').addClass(settings.timer_progress_class));
+                timer_container.addClass(settings.timer_paused_class);
+                container.append(timer_container);
+            }
+
+            if (settings.slide_number) {
+                number_container = $('<div>').addClass(settings.slide_number_class);
+                number_container.append('<span></span> ' + settings.slide_number_text + ' <span></span>');
+                container.append(number_container);
+            }
+
+            if (settings.bullets) {
+                bullets_container = $('<ol>').addClass(settings.bullets_container_class);
+                container.append(bullets_container);
+                bullets_container.wrap('<div class="orbit-bullets-container"></div>');
+                self.slides().each(function (idx, el) {
+                    var bullet = $('<li>').attr('data-orbit-slide', idx).on('click', self.link_bullet);
+                    ;
+                    bullets_container.append(bullet);
+                });
+            }
+
+        };
+
+        self._goto = function (next_idx, start_timer) {
+            // if (locked) {return false;}
+            if (next_idx === idx) {
+                return false;
+            }
+            if (typeof timer === 'object') {
+                timer.restart();
+            }
+            var slides = self.slides();
+
+            var dir = 'next';
+            locked = true;
+            if (next_idx < idx) {
+                dir = 'prev';
+            }
+            if (next_idx >= slides.length) {
+                if (!settings.circular) return false;
+                next_idx = 0;
+            } else if (next_idx < 0) {
+                if (!settings.circular) return false;
+                next_idx = slides.length - 1;
+            }
+
+            var current = $(slides.get(idx));
+            var next = $(slides.get(next_idx));
+
+            current.css('zIndex', 2);
+            current.removeClass(settings.active_slide_class);
+            next.css('zIndex', 4).addClass(settings.active_slide_class);
+
+            slides_container.trigger('before-slide-change.fndtn.orbit');
+            settings.before_slide_change();
+            self.update_active_link(next_idx);
+
+            var callback = function () {
+                var unlock = function () {
+                    idx = next_idx;
+                    locked = false;
+                    if (start_timer === true) {
+                        timer = self.create_timer();
+                        timer.start();
+                    }
+                    self.update_slide_number(idx);
+                    slides_container.trigger('after-slide-change.fndtn.orbit', [{
+                        slide_number: idx,
+                        total_slides: slides.length
+                    }]);
+                    settings.after_slide_change(idx, slides.length);
+                };
+                if (slides_container.height() != next.height() && settings.variable_height) {
+                    slides_container.animate({'height': next.height()}, 250, 'linear', unlock);
+                } else {
+                    unlock();
+                }
+            };
+
+            if (slides.length === 1) {
+                callback();
+                return false;
+            }
+
+            var start_animation = function () {
+                if (dir === 'next') {
+                    animate.next(current, next, callback);
+                }
+                if (dir === 'prev') {
+                    animate.prev(current, next, callback);
+                }
+            };
+
+            if (next.height() > slides_container.height() && settings.variable_height) {
+                slides_container.animate({'height': next.height()}, 250, 'linear', start_animation);
+            } else {
+                start_animation();
+            }
+        };
+
+        self.next = function (e) {
+            e.stopImmediatePropagation();
+            e.preventDefault();
+            self._goto(idx + 1);
+        };
+
+        self.prev = function (e) {
+            e.stopImmediatePropagation();
+            e.preventDefault();
+            self._goto(idx - 1);
+        };
+
+        self.link_custom = function (e) {
+            e.preventDefault();
+            var link = $(this).attr('data-orbit-link');
+            if ((typeof link === 'string') && (link = $.trim(link)) != '') {
+                var slide = container.find('[data-orbit-slide=' + link + ']');
+                if (slide.index() != -1) {
+                    self._goto(slide.index());
+                }
+            }
+        };
+
+        self.link_bullet = function (e) {
+            var index = $(this).attr('data-orbit-slide');
+            if ((typeof index === 'string') && (index = $.trim(index)) != '') {
+                if (isNaN(parseInt(index))) {
+                    var slide = container.find('[data-orbit-slide=' + index + ']');
+                    if (slide.index() != -1) {
+                        self._goto(slide.index() + 1);
+                    }
+                }
+                else {
+                    self._goto(parseInt(index));
+                }
+            }
+
+        }
+
+        self.timer_callback = function () {
+            self._goto(idx + 1, true);
+        }
+
+        self.compute_dimensions = function () {
+            var current = $(self.slides().get(idx));
+            var h = current.height();
+            if (!settings.variable_height) {
+                self.slides().each(function () {
+                    if ($(this).height() > h) {
+                        h = $(this).height();
+                    }
+                });
+            }
+            slides_container.height(h);
+        };
+
+        self.create_timer = function () {
+            var t = new Timer(
+                container.find('.' + settings.timer_container_class),
+                settings,
+                self.timer_callback
+            );
+            return t;
+        };
+
+        self.stop_timer = function () {
+            if (typeof timer === 'object') timer.stop();
+        };
+
+        self.toggle_timer = function () {
+            var t = container.find('.' + settings.timer_container_class);
+            if (t.hasClass(settings.timer_paused_class)) {
+                if (typeof timer === 'undefined') {
+                    timer = self.create_timer();
+                }
+                timer.start();
+            }
+            else {
+                if (typeof timer === 'object') {
+                    timer.stop();
+                }
+            }
+        };
+
+        self.init = function () {
+            self.build_markup();
+            if (settings.timer) {
+                timer = self.create_timer();
+                Foundation.utils.image_loaded(this.slides().children('img'), timer.start);
+            }
+            animate = new FadeAnimation(settings, slides_container);
+            if (settings.animation === 'slide')
+                animate = new SlideAnimation(settings, slides_container);
+
+            container.on('click', '.' + settings.next_class, self.next);
+            container.on('click', '.' + settings.prev_class, self.prev);
+
+            if (settings.next_on_click) {
+                container.on('click', '.' + settings.slides_container_class + ' [data-orbit-slide]', self.link_bullet);
+            }
+
+            container.on('click', self.toggle_timer);
+            if (settings.swipe) {
+                container.on('touchstart.fndtn.orbit', function (e) {
+                    if (!e.touches) {
+                        e = e.originalEvent;
+                    }
+                    var data = {
+                        start_page_x: e.touches[0].pageX,
+                        start_page_y: e.touches[0].pageY,
+                        start_time: (new Date()).getTime(),
+                        delta_x: 0,
+                        is_scrolling: undefined
+                    };
+                    container.data('swipe-transition', data);
+                    e.stopPropagation();
+                })
+                    .on('touchmove.fndtn.orbit', function (e) {
+                        if (!e.touches) {
+                            e = e.originalEvent;
+                        }
+                        // Ignore pinch/zoom events
+                        if (e.touches.length > 1 || e.scale && e.scale !== 1) return;
+
+                        var data = container.data('swipe-transition');
+                        if (typeof data === 'undefined') {
+                            data = {};
+                        }
+
+                        data.delta_x = e.touches[0].pageX - data.start_page_x;
+
+                        if (typeof data.is_scrolling === 'undefined') {
+                            data.is_scrolling = !!( data.is_scrolling || Math.abs(data.delta_x) < Math.abs(e.touches[0].pageY - data.start_page_y) );
+                        }
+
+                        if (!data.is_scrolling && !data.active) {
+                            e.preventDefault();
+                            var direction = (data.delta_x < 0) ? (idx + 1) : (idx - 1);
+                            data.active = true;
+                            self._goto(direction);
+                        }
+                    })
+                    .on('touchend.fndtn.orbit', function (e) {
+                        container.data('swipe-transition', {});
+                        e.stopPropagation();
+                    })
+            }
+            container.on('mouseenter.fndtn.orbit', function (e) {
+                if (settings.timer && settings.pause_on_hover) {
+                    self.stop_timer();
+                }
+            })
+                .on('mouseleave.fndtn.orbit', function (e) {
+                    if (settings.timer && settings.resume_on_mouseout) {
+                        timer.start();
+                    }
+                });
+
+            $(document).on('click', '[data-orbit-link]', self.link_custom);
+            $(window).on('load resize', self.compute_dimensions);
+            Foundation.utils.image_loaded(this.slides().children('img'), self.compute_dimensions);
+            Foundation.utils.image_loaded(this.slides().children('img'), function () {
+                container.prev('.' + settings.preloader_class).css('display', 'none');
+                self.update_slide_number(0);
+                self.update_active_link(0);
+                slides_container.trigger('ready.fndtn.orbit');
+            });
+        };
+
+        self.init();
+    };
+
+    var Timer = function (el, settings, callback) {
+        var self = this,
+            duration = settings.timer_speed,
+            progress = el.find('.' + settings.timer_progress_class),
+            start,
+            timeout,
+            left = -1;
+
+        this.update_progress = function (w) {
+            var new_progress = progress.clone();
+            new_progress.attr('style', '');
+            new_progress.css('width', w + '%');
+            progress.replaceWith(new_progress);
+            progress = new_progress;
+        };
+
+        this.restart = function () {
+            clearTimeout(timeout);
+            el.addClass(settings.timer_paused_class);
+            left = -1;
+            self.update_progress(0);
+        };
+
+        this.start = function () {
+            if (!el.hasClass(settings.timer_paused_class)) {
+                return true;
+            }
+            left = (left === -1) ? duration : left;
+            el.removeClass(settings.timer_paused_class);
+            start = new Date().getTime();
+            progress.animate({'width': '100%'}, left, 'linear');
+            timeout = setTimeout(function () {
+                self.restart();
+                callback();
+            }, left);
+            el.trigger('timer-started.fndtn.orbit')
+        };
+
+        this.stop = function () {
+            if (el.hasClass(settings.timer_paused_class)) {
+                return true;
+            }
+            clearTimeout(timeout);
+            el.addClass(settings.timer_paused_class);
+            var end = new Date().getTime();
+            left = left - (end - start);
+            var w = 100 - ((left / duration) * 100);
+            self.update_progress(w);
+            el.trigger('timer-stopped.fndtn.orbit');
+        };
+    };
+
+    var SlideAnimation = function (settings, container) {
+        var duration = settings.animation_speed;
+        var is_rtl = ($('html[dir=rtl]').length === 1);
+        var margin = is_rtl ? 'marginRight' : 'marginLeft';
+        var animMargin = {};
+        animMargin[margin] = '0%';
+
+        this.next = function (current, next, callback) {
+            current.animate({marginLeft: '-100%'}, duration);
+            next.animate(animMargin, duration, function () {
+                current.css(margin, '100%');
+                callback();
+            });
+        };
+
+        this.prev = function (current, prev, callback) {
+            current.animate({marginLeft: '100%'}, duration);
+            prev.css(margin, '-100%');
+            prev.animate(animMargin, duration, function () {
+                current.css(margin, '100%');
+                callback();
+            });
+        };
+    };
+
+    var FadeAnimation = function (settings, container) {
+        var duration = settings.animation_speed;
+        var is_rtl = ($('html[dir=rtl]').length === 1);
+        var margin = is_rtl ? 'marginRight' : 'marginLeft';
+
+        this.next = function (current, next, callback) {
+            next.css({'margin': '0%', 'opacity': '0.01'});
+            next.animate({'opacity': '1'}, duration, 'linear', function () {
+                current.css('margin', '100%');
+                callback();
+            });
+        };
+
+        this.prev = function (current, prev, callback) {
+            prev.css({'margin': '0%', 'opacity': '0.01'});
+            prev.animate({'opacity': '1'}, duration, 'linear', function () {
+                current.css('margin', '100%');
+                callback();
+            });
+        };
+    };
+
+
+    Foundation.libs = Foundation.libs || {};
+
+    Foundation.libs.orbit = {
+        name: 'orbit',
+
+        version: '5.5.0',
+
+        settings: {
+            animation: 'slide',
+            timer_speed: 10000,
+            pause_on_hover: true,
+            resume_on_mouseout: false,
+            next_on_click: true,
+            animation_speed: 500,
+            stack_on_small: false,
+            navigation_arrows: true,
+            slide_number: true,
+            slide_number_text: 'of',
+            container_class: 'orbit-container',
+            stack_on_small_class: 'orbit-stack-on-small',
+            next_class: 'orbit-next',
+            prev_class: 'orbit-prev',
+            timer_container_class: 'orbit-timer',
+            timer_paused_class: 'paused',
+            timer_progress_class: 'orbit-progress',
+            slides_container_class: 'orbit-slides-container',
+            preloader_class: 'preloader',
+            slide_selector: '*',
+            bullets_container_class: 'orbit-bullets',
+            bullets_active_class: 'active',
+            slide_number_class: 'orbit-slide-number',
+            caption_class: 'orbit-caption',
+            active_slide_class: 'active',
+            orbit_transition_class: 'orbit-transitioning',
+            bullets: true,
+            circular: true,
+            timer: true,
+            variable_height: false,
+            swipe: true,
+            before_slide_change: noop,
+            after_slide_change: noop
+        },
+
+        init: function (scope, method, options) {
+            var self = this;
+            this.bindings(method, options);
+        },
+
+        events: function (instance) {
+            var orbit_instance = new Orbit(this.S(instance), this.S(instance).data('orbit-init'));
+            this.S(instance).data(this.name + '-instance', orbit_instance);
+        },
+
+        reflow: function () {
+            var self = this;
+
+            if (self.S(self.scope).is('[data-orbit]')) {
+                var $el = self.S(self.scope);
+                var instance = $el.data(self.name + '-instance');
+                instance.compute_dimensions();
+            } else {
+                self.S('[data-orbit]', self.scope).each(function (idx, el) {
+                    var $el = self.S(el);
+                    var opts = self.data_options($el);
+                    var instance = $el.data(self.name + '-instance');
+                    instance.compute_dimensions();
+                });
+            }
+        }
+    };
+
+
+}(jQuery, window, window.document));