blueprint-jekyll-theme 0.1.0

data/assets/js/cancel-notification.js

@@ -0,0 +1,5 @@
+document.getElementById("cancel-notification").addEventListener("click", hideNotification);
+
+function hideNotification() {
+	document.getElementById("notification-bar").style.display = "none";
+}

data/assets/js/common.js

@@ -0,0 +1,383 @@
+var BLUEPRINT;
+
+if (typeof BLUEPRINT !== "object") {
+    BLUEPRINT = {};
+}
+
+(function() {
+    var hashCode;
+    BLUEPRINT.hide = function(el) {
+        var display;
+        display = BLUEPRINT.isVisible(el);
+        if (display) {
+            el.style.display = 'none';
+        }
+    };
+    BLUEPRINT.show = function(el) {
+        var display;
+        display = BLUEPRINT.isVisible(el);
+        if (!display) {
+            el.style.display = 'block';
+        }
+    };
+    BLUEPRINT.toggle = function(el) {
+        var display;
+        display = BLUEPRINT.isVisible(el);
+        if (!display) {
+            el.style.display = 'block';
+        } else {
+            el.style.display = 'none';
+        }
+    };
+    BLUEPRINT.getElements = function(name) {
+        return document.querySelectorAll('[data-blueprint="' + name + '"]');
+    };
+    BLUEPRINT.isVisible = function(el) {
+        var display;
+        if (window.getComputedStyle) {
+            display = getComputedStyle(el, null).display;
+        } else {
+            display = el.currentStyle.display;
+        }
+        return display !== 'none';
+    };
+    BLUEPRINT.hasClass = function(el, className) {
+        if (el.classList) {
+            return el.classList.contains(className);
+        } else {
+            return new RegExp('\\b' + className + '\\b').test(el.className);
+        }
+    };
+    BLUEPRINT.addClass = function(el, className) {
+        if (el.classList) {
+            return el.classList.add(className);
+        } else if (!BLUEPRINT.hasClass(el, className)) {
+            return el.className += ' ' + className;
+        }
+    };
+    BLUEPRINT.removeClass = function(el, className) {
+        if (el.classList) {
+            return el.classList.remove(className);
+        } else {
+            return el.className = el.className.replace(new RegExp('\\b' + className + '\\b', 'g'), '');
+        }
+    };
+    BLUEPRINT.parseOptions = function(el) {
+        var j, len, option, options, opts;
+        opts = {};
+        options = el.getAttribute('data-options');
+        options = (options || '').replace(/\s/g, '').split(';');
+        for (j = 0, len = options.length; j < len; j++) {
+            option = options[j];
+            if (option) {
+                option = option.split(':');
+                opts[option[0]] = option[1];
+            }
+        }
+        return opts;
+    };
+    BLUEPRINT.click = function(el, handler) {
+        if (!el.eventListener) {
+            el.eventListener = true;
+            return el.addEventListener('click', handler);
+        }
+    };
+    BLUEPRINT.unclick = function(el, handler) {
+        if (el.eventListener) {
+            el.eventListener = false;
+            return el.removeEventListener('click', handler);
+        }
+    };
+    if (document.readyState !== 'loading') {
+        BLUEPRINT.isReady = true;
+        return;
+    } else if (document.addEventListener) {
+        document.addEventListener('DOMContentLoaded', function() {
+            BLUEPRINT.isReady = true;
+        });
+    } else {
+        document.attachEvent('onreadystatechange', function() {
+            if (document.readyState === 'complete') {
+                BLUEPRINT.isReady = true;
+            }
+        });
+    }
+    return hashCode = function(str) {
+        var hash, i, j, len, s;
+        hash = 0;
+        for (i = j = 0, len = str.length; j < len; i = ++j) {
+            s = str[i];
+            hash = ~~(((hash << 5) - hash) + str.charCodeAt(i));
+        }
+        return hash;
+    };
+
+
+
+})();
+;var i, j, len, len1, list, lists, menu, menuElems, options, subMenu;
+
+BLUEPRINT.toggleMenu = function(el, options) {
+    BLUEPRINT.collapseMenu(el, 'hide');
+    BLUEPRINT.click(el, function(e) {
+        var active, actives, i, len;
+        e.preventDefault();
+        e.stopPropagation();
+        if (options.single) {
+            actives = menu.querySelectorAll('.is-active');
+            for (i = 0, len = actives.length; i < len; i++) {
+                active = actives[i];
+                if (active !== e.target) {
+                    BLUEPRINT.removeClass(active, 'is-active');
+                    if (active.nextElementSibling.nodeName === 'UL') {
+                        BLUEPRINT.hide(active.nextElementSibling);
+                    }
+                }
+            }
+        }
+        BLUEPRINT.collapseMenu(e.target, 'toggle');
+    });
+};
+
+BLUEPRINT.collapseMenu = function(el, status) {
+    var smenu;
+    smenu = el.nextElementSibling;
+    if (status === 'show') {
+        BLUEPRINT.show(smenu);
+        if (BLUEPRINT.isVisible(smenu)) {
+            return BLUEPRINT.addClass(el, 'is-active');
+        }
+    } else if (status === 'hide') {
+        BLUEPRINT.hide(smenu);
+        if (!BLUEPRINT.isVisible(smenu)) {
+            return BLUEPRINT.removeClass(el, 'is-active');
+        }
+    } else if (status === 'toggle') {
+        BLUEPRINT.toggle(smenu);
+        if (BLUEPRINT.isVisible(smenu)) {
+            return BLUEPRINT.addClass(el, 'is-active');
+        } else {
+            return BLUEPRINT.removeClass(el, 'is-active');
+        }
+    }
+};
+
+if (!BLUEPRINT.isReady) {
+    menuElems = BLUEPRINT.getElements('menu');
+    if (menuElems && menuElems.length > 0) {
+        for (i = 0, len = menuElems.length; i < len; i++) {
+            menu = menuElems[i];
+            options = BLUEPRINT.parseOptions(menu);
+            lists = menu.querySelectorAll('.bp-menu-list');
+            for (j = 0, len1 = lists.length; j < len1; j++) {
+                list = lists[j];
+                subMenu = list.querySelector('ul');
+                if (subMenu) {
+                    BLUEPRINT.toggleMenu(subMenu.previousElementSibling, options);
+                }
+            }
+        }
+    }
+}
+
+;var i, len, modal, modals, options;
+
+BLUEPRINT.toggleModal = function(el, options) {
+    if (!options.target) {
+        throw new Error('Found [BLUEPRINT-MODAL] but there is no target defined!');
+    }
+    el.addEventListener('click', function(e) {
+
+        var backdrop, closeBtn, closeModal, modal;
+        e.preventDefault();
+        e.stopPropagation();
+        modal = document.getElementById(options.target);
+        backdrop = modal.querySelector('.bp-modal-background');
+        closeBtn = modal.querySelector('.bp-modal-close');
+        closeModal = function() {
+            if (BLUEPRINT.hasClass(modal, 'is-active')) {
+                BLUEPRINT.removeClass(modal, 'is-active');
+                return BLUEPRINT.unclick(this, closeModal);
+            }
+        };
+        if (options.closeByBackdrop === void 0 || options.closeByBackdrop) {
+            BLUEPRINT.click(backdrop, closeModal);
+        }
+        if (options.closeByButton === void 0 || options.closeByButton) {
+            BLUEPRINT.click(closeBtn, closeModal);
+        }
+        BLUEPRINT.addClass(modal, 'is-active');
+    });
+};
+
+if (!BLUEPRINT.isReady) {
+    modals = BLUEPRINT.getElements('bp-modal');
+    if (modals && modals.length > 0) {
+        for (i = 0, len = modals.length; i < len; i++) {
+            modal = modals[i];
+            options = BLUEPRINT.parseOptions(modal);
+            BLUEPRINT.toggleModal(modal, options);
+        }
+    }
+}
+;var i, len, notification, notifications, options;
+
+BLUEPRINT.notification = function(el, status, options) {
+    var deleteBtn, deleteNotification;
+    if (options.deletable === void 0 || options.deletable !== false) {
+        deleteBtn = el.querySelector('.delete');
+        deleteNotification = function(e) {
+            e.preventDefault();
+            e.stopPropagation();
+            el.parentNode.removeChild(el);
+        };
+    }
+    if (status === 'show') {
+        BLUEPRINT.removeClass(el, 'is-hidden');
+        BLUEPRINT.click(deleteBtn, deleteNotification);
+    } else if (status === 'hide') {
+        BLUEPRINT.addClass(el, 'is-hidden');
+    } else if (status === 'toggle') {
+        if (BLUEPRINT.isVisible(el)) {
+            BLUEPRINT.notification(el, 'hide', options);
+        } else {
+            BLUEPRINT.notification(el, 'show', options);
+        }
+        return;
+    }
+};
+
+if (!BLUEPRINT.isReady) {
+    notifications = BLUEPRINT.getElements('notification');
+    if (notifications && notifications.length > 0) {
+        for (i = 0, len = notifications.length; i < len; i++) {
+            notification = notifications[i];
+            options = BLUEPRINT.parseOptions(notification);
+            BLUEPRINT.notification(notification, 'hide', options);
+        }
+    }
+}
+;var i, j, len, len1, tab, tabs, target, targets;
+
+BLUEPRINT.toggleTab = function(el) {
+    var i, l, len, links;
+    links = el.target.parentNode.parentNode;
+    links = links.querySelectorAll('li');
+    for (i = 0, len = links.length; i < len; i++) {
+        l = links[i];
+        BLUEPRINT.removeClass(l, 'is-active');
+        BLUEPRINT.hide(document.querySelector(l.firstChild.getAttribute('data-tab')));
+    }
+    BLUEPRINT.addClass(el.target.parentNode, 'is-active');
+    BLUEPRINT.show(document.querySelector(el.target.getAttribute('data-tab')));
+};
+
+if (!BLUEPRINT.isReady) {
+    tabs = BLUEPRINT.getElements('tabs');
+    if (tabs && tabs.length > 0) {
+        for (i = 0, len = tabs.length; i < len; i++) {
+            tab = tabs[i];
+            targets = tab.querySelectorAll('[data-tab]');
+            for (j = 0, len1 = targets.length; j < len1; j++) {
+                target = targets[j];
+                tab = document.querySelector(target.getAttribute('data-tab'));
+                if (BLUEPRINT.hasClass(target.parentNode, 'is-active') === false) {
+                    BLUEPRINT.hide(tab);
+                }
+                BLUEPRINT.click(target, BLUEPRINT.toggleTab);
+            }
+        }
+    }
+}
+
+// Get all "navbar-burger" elements
+var $navbarBurgers = Array.prototype.slice.call(document.querySelectorAll('.navbar-burger'), 0);
+
+// Check if there are any navbar burgers
+if ($navbarBurgers.length > 0) {
+
+    // Add a click event on each of them
+    $navbarBurgers.forEach(function ($el) {
+        $el.addEventListener('click', function () {
+
+            // Get the target from the "data-target" attribute
+            var target = $el.dataset.target;
+            var $target = document.getElementById(target);
+
+            // Toggle the class on both the "navbar-burger" and the "navbar-menu"
+            $el.classList.toggle('is-active');
+            $target.classList.toggle('is-active');
+
+        });
+    });
+}
+
+// // Searchbar Activate
+// var $searchActivate = document.getElementById('search-activate');
+// var $searchDeactivate = document.getElementById('search-deactivate');
+// var $searchBar = document.getElementById('search-bar');
+// BLUEPRINT.hide($searchDeactivate);
+// BLUEPRINT.hide($searchBar);
+// BLUEPRINT.show($searchActivate);
+//
+// $searchActivate.addEventListener('click', function (event){
+//     BLUEPRINT.toggle($searchDeactivate);
+//     BLUEPRINT.toggle($searchBar);
+//     BLUEPRINT.toggle($searchActivate);
+// });
+//
+// $searchDeactivate.addEventListener('click', function (event){
+//     BLUEPRINT.toggle($searchDeactivate);
+//     BLUEPRINT.toggle($searchBar);
+//     BLUEPRINT.toggle($searchActivate);
+// });
+
+// Dropdowns
+var $dropdowns = getAll('.bp-dropdown:not(.is-hoverable)');
+
+if ($dropdowns.length > 0) {
+    $dropdowns.forEach(function ($el) {
+        $el.addEventListener('click', function (event) {
+            event.stopPropagation();
+            $el.classList.toggle('is-active');
+        });
+    });
+
+    document.addEventListener('click', function (event) {
+        closeDropdowns();
+    });
+}
+
+function closeDropdowns() {
+    $dropdowns.forEach(function ($el) {
+        $el.classList.remove('is-active');
+    });
+}
+
+// Close dropdowns if ESC pressed
+document.addEventListener('keydown', function (event) {
+    var e = event || window.event;
+    if (e.keyCode === 27) {
+        closeDropdowns();
+    }
+});
+
+// Functions
+function getAll(selector) {
+    return Array.prototype.slice.call(document.querySelectorAll(selector), 0);
+}
+
+$(document).ready(function(){
+    var masthead_container = $('.masthead-container');
+    var searchToggle = $('#search-activate');
+    var searchIcon = $('#search-activate span');
+    var searchBar = $('.search-bar');
+    var searchBar_input = $('.search-bar input');
+    searchToggle.on('click',function(e){
+        e.preventDefault();
+        searchIcon.toggleClass('bp-icon-search').toggleClass('bp-icon-cross');;
+        searchBar.toggleClass('hide');
+        searchBar_input.focus().val('');
+        masthead_container.toggleClass('is-opened');
+    });
+});

data/assets/js/home.js

@@ -0,0 +1,53 @@
+$( document ).ready(function() {
+
+    var carousel_setting = {
+        loop:true,
+        autoplay:true,
+        autoplayTimeout:7000,
+        margin:0,
+        nav:false,
+        mouseDrag:false,
+        items: 1,
+        dots:true,
+        animateOut: 'fadeOut',
+        responsive : {
+            // breakpoint from 0 up
+            0 : {
+                dots : true,
+                mouseDrag:true
+            },
+
+            // breakpoint from 768 up
+            768 : {
+                dots : false
+
+            }
+        }
+
+    };
+
+    var programme_carousel = $('.programme-carousel');
+    var programme_nav_left = $('.carousel-nav-container.programme-nav .carousel-nav.left');
+    var programme_nav_right = $('.carousel-nav-container.programme-nav .carousel-nav.right');
+
+    var career_carousel = $('.career-carousel');
+    var career_nav_left = $('.carousel-nav-container.career-nav .carousel-nav.left');
+    var career_nav_right = $('.carousel-nav-container.career-nav .carousel-nav.right');
+
+    programme_carousel.owlCarousel(carousel_setting);
+    programme_nav_left.click(function(){
+        programme_carousel.trigger('prev.owl.carousel',[1000])
+    });
+    programme_nav_right.click(function(){
+        programme_carousel.trigger('next.owl.carousel',[1000])
+    });
+
+    career_carousel.owlCarousel(carousel_setting);
+    career_nav_left.click(function(){
+        career_carousel.trigger('prev.owl.carousel',[1000])
+    });
+    career_nav_right.click(function(){
+        career_carousel.trigger('next.owl.carousel',[1000])
+    });
+
+});

data/assets/js/jquery.sticky-sidebar.js

@@ -0,0 +1,749 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+	typeof define === 'function' && define.amd ? define(factory) :
+	(global.StickySidebar = factory());
+}(this, (function () { 'use strict';
+
+var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+
+
+function unwrapExports (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function createCommonjsModule(fn, module) {
+	return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+var stickySidebar = createCommonjsModule(function (module, exports) {
+(function (global, factory) {
+  if (typeof undefined === "function" && undefined.amd) {
+    undefined(['exports'], factory);
+  } else {
+    factory(exports);
+  }
+})(commonjsGlobal, function (exports) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+
+  var _createClass = function () {
+    function defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+
+    return function (Constructor, protoProps, staticProps) {
+      if (protoProps) defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) defineProperties(Constructor, staticProps);
+      return Constructor;
+    };
+  }();
+
+  /**
+   * Sticky Sidebar JavaScript Plugin.
+   * @version 3.3.4
+   * @author Ahmed Bouhuolia <a.bouhuolia@gmail.com>
+   * @license The MIT License (MIT)
+   */
+  var StickySidebar = function () {
+
+    // ---------------------------------
+    // # Define Constants
+    // ---------------------------------
+    //
+    var EVENT_KEY = '.stickySidebar';
+    var DEFAULTS = {
+      /**
+       * Additional top spacing of the element when it becomes sticky.
+       * @type {Numeric|Function}
+       */
+      topSpacing: 0,
+
+      /**
+       * Additional bottom spacing of the element when it becomes sticky.
+       * @type {Numeric|Function}
+       */
+      bottomSpacing: 0,
+
+      /**
+       * Container sidebar selector to know what the beginning and end of sticky element.
+       * @type {String|False}
+       */
+      containerSelector: false,
+
+      /**
+       * Inner wrapper selector.
+       * @type {String}
+       */
+      innerWrapperSelector: '.inner-wrapper-sticky',
+
+      /**
+       * The name of CSS class to apply to elements when they have become stuck.
+       * @type {String|False}
+       */
+      stickyClass: 'is-affixed',
+
+      /**
+       * Detect when sidebar and its container change height so re-calculate their dimensions.
+       * @type {Boolean}
+       */
+      resizeSensor: true,
+
+      /**
+       * The sidebar returns to its normal position if its width below this value.
+       * @type {Numeric}
+       */
+      minWidth: false
+    };
+
+    // ---------------------------------
+    // # Class Definition
+    // ---------------------------------
+    //
+    /**
+     * Sticky Sidebar Class.
+     * @public
+     */
+
+    var StickySidebar = function () {
+
+      /**
+       * Sticky Sidebar Constructor.
+       * @constructor
+       * @param {HTMLElement|String} sidebar - The sidebar element or sidebar selector.
+       * @param {Object} options - The options of sticky sidebar.
+       */
+      function StickySidebar(sidebar) {
+        var _this = this;
+
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+        _classCallCheck(this, StickySidebar);
+
+        this.options = StickySidebar.extend(DEFAULTS, options);
+
+        // Sidebar element query if there's no one, throw error.
+        this.sidebar = 'string' === typeof sidebar ? document.querySelector(sidebar) : sidebar;
+        if ('undefined' === typeof this.sidebar) throw new Error("There is no specific sidebar element.");
+
+        this.sidebarInner = false;
+        this.container = this.sidebar.parentElement;
+
+        // Current Affix Type of sidebar element.
+        this.affixedType = 'STATIC';
+        this.direction = 'down';
+        this.support = {
+          transform: false,
+          transform3d: false
+        };
+
+        this._initialized = false;
+        this._reStyle = false;
+        this._breakpoint = false;
+
+        // Dimensions of sidebar, container and screen viewport.
+        this.dimensions = {
+          translateY: 0,
+          maxTranslateY: 0,
+          topSpacing: 0,
+          lastTopSpacing: 0,
+          bottomSpacing: 0,
+          lastBottomSpacing: 0,
+          sidebarHeight: 0,
+          sidebarWidth: 0,
+          containerTop: 0,
+          containerHeight: 0,
+          viewportHeight: 0,
+          viewportTop: 0,
+          lastViewportTop: 0
+        };
+
+        // Bind event handlers for referencability.
+        ['handleEvent'].forEach(function (method) {
+          _this[method] = _this[method].bind(_this);
+        });
+
+        // Initialize sticky sidebar for first time.
+        this.initialize();
+      }
+
+      /**
+       * Initializes the sticky sidebar by adding inner wrapper, define its container, 
+       * min-width breakpoint, calculating dimensions, adding helper classes and inline style.
+       * @private
+       */
+
+
+      _createClass(StickySidebar, [{
+        key: 'initialize',
+        value: function initialize() {
+          var _this2 = this;
+
+          this._setSupportFeatures();
+
+          // Get sticky sidebar inner wrapper, if not found, will create one.
+          if (this.options.innerWrapperSelector) {
+            this.sidebarInner = this.sidebar.querySelector(this.options.innerWrapperSelector);
+
+            if (null === this.sidebarInner) this.sidebarInner = false;
+          }
+
+          if (!this.sidebarInner) {
+            var wrapper = document.createElement('div');
+            wrapper.setAttribute('class', 'inner-wrapper-sticky');
+            this.sidebar.appendChild(wrapper);
+
+            while (this.sidebar.firstChild != wrapper) {
+              wrapper.appendChild(this.sidebar.firstChild);
+            }this.sidebarInner = this.sidebar.querySelector('.inner-wrapper-sticky');
+          }
+
+          // Container wrapper of the sidebar.
+          if (this.options.containerSelector) {
+            var containers = document.querySelectorAll(this.options.containerSelector);
+            containers = Array.prototype.slice.call(containers);
+
+            containers.forEach(function (container, item) {
+              if (!container.contains(_this2.sidebar)) return;
+              _this2.container = container;
+            });
+
+            if (!containers.length) throw new Error("The container does not contains on the sidebar.");
+          }
+
+          // If top/bottom spacing is not function parse value to integer.
+          if ('function' !== typeof this.options.topSpacing) this.options.topSpacing = parseInt(this.options.topSpacing) || 0;
+
+          if ('function' !== typeof this.options.bottomSpacing) this.options.bottomSpacing = parseInt(this.options.bottomSpacing) || 0;
+
+          // Breakdown sticky sidebar if screen width below `options.minWidth`.
+          this._widthBreakpoint();
+
+          // Calculate dimensions of sidebar, container and viewport.
+          this.calcDimensions();
+
+          // Affix sidebar in proper position.
+          this.stickyPosition();
+
+          // Bind all events.
+          this.bindEvents();
+
+          // Inform other properties the sticky sidebar is initialized.
+          this._initialized = true;
+        }
+      }, {
+        key: 'bindEvents',
+        value: function bindEvents() {
+          window.addEventListener('resize', this, { passive: true, capture: false });
+          window.addEventListener('scroll', this, { passive: true, capture: false });
+
+          this.sidebar.addEventListener('update' + EVENT_KEY, this);
+
+          if (this.options.resizeSensor && 'undefined' !== typeof ResizeSensor) {
+            new ResizeSensor(this.sidebarInner, this.handleEvent);
+            new ResizeSensor(this.container, this.handleEvent);
+          }
+        }
+      }, {
+        key: 'handleEvent',
+        value: function handleEvent(event) {
+          this.updateSticky(event);
+        }
+      }, {
+        key: 'calcDimensions',
+        value: function calcDimensions() {
+          if (this._breakpoint) return;
+          var dims = this.dimensions;
+
+          // Container of sticky sidebar dimensions.
+          dims.containerTop = StickySidebar.offsetRelative(this.container).top;
+          dims.containerHeight = this.container.clientHeight;
+          dims.containerBottom = dims.containerTop + dims.containerHeight;
+
+          // Sidebar dimensions.
+          dims.sidebarHeight = this.sidebarInner.offsetHeight;
+          dims.sidebarWidth = this.sidebarInner.offsetWidth;
+
+          // Screen viewport dimensions.
+          dims.viewportHeight = window.innerHeight;
+
+          // Maximum sidebar translate Y.
+          dims.maxTranslateY = dims.containerHeight - dims.sidebarHeight;
+
+          this._calcDimensionsWithScroll();
+        }
+      }, {
+        key: '_calcDimensionsWithScroll',
+        value: function _calcDimensionsWithScroll() {
+          var dims = this.dimensions;
+
+          dims.sidebarLeft = StickySidebar.offsetRelative(this.sidebar).left;
+
+          dims.viewportTop = document.documentElement.scrollTop || document.body.scrollTop;
+          dims.viewportBottom = dims.viewportTop + dims.viewportHeight;
+          dims.viewportLeft = document.documentElement.scrollLeft || document.body.scrollLeft;
+
+          dims.topSpacing = this.options.topSpacing;
+          dims.bottomSpacing = this.options.bottomSpacing;
+
+          if ('function' === typeof dims.topSpacing) dims.topSpacing = parseInt(dims.topSpacing(this.sidebar)) || 0;
+
+          if ('function' === typeof dims.bottomSpacing) dims.bottomSpacing = parseInt(dims.bottomSpacing(this.sidebar)) || 0;
+
+          if ('VIEWPORT-TOP' === this.affixedType) {
+            // Adjust translate Y in the case decrease top spacing value.
+            if (dims.topSpacing < dims.lastTopSpacing) {
+              dims.translateY += dims.lastTopSpacing - dims.topSpacing;
+              this._reStyle = true;
+            }
+          } else if ('VIEWPORT-BOTTOM' === this.affixedType) {
+            // Adjust translate Y in the case decrease bottom spacing value.
+            if (dims.bottomSpacing < dims.lastBottomSpacing) {
+              dims.translateY += dims.lastBottomSpacing - dims.bottomSpacing;
+              this._reStyle = true;
+            }
+          }
+
+          dims.lastTopSpacing = dims.topSpacing;
+          dims.lastBottomSpacing = dims.bottomSpacing;
+        }
+      }, {
+        key: 'isSidebarFitsViewport',
+        value: function isSidebarFitsViewport() {
+          var dims = this.dimensions;
+          var offset = this.scrollDirection === 'down' ? dims.lastBottomSpacing : dims.lastTopSpacing;
+          return this.dimensions.sidebarHeight + offset < this.dimensions.viewportHeight;
+        }
+      }, {
+        key: 'observeScrollDir',
+        value: function observeScrollDir() {
+          var dims = this.dimensions;
+          if (dims.lastViewportTop === dims.viewportTop) return;
+
+          var furthest = 'down' === this.direction ? Math.min : Math.max;
+
+          // If the browser is scrolling not in the same direction.
+          if (dims.viewportTop === furthest(dims.viewportTop, dims.lastViewportTop)) this.direction = 'down' === this.direction ? 'up' : 'down';
+        }
+      }, {
+        key: 'getAffixType',
+        value: function getAffixType() {
+          this._calcDimensionsWithScroll();
+          var dims = this.dimensions;
+          var colliderTop = dims.viewportTop + dims.topSpacing;
+          var affixType = this.affixedType;
+
+          if (colliderTop <= dims.containerTop || dims.containerHeight <= dims.sidebarHeight) {
+            dims.translateY = 0;
+            affixType = 'STATIC';
+          } else {
+            affixType = 'up' === this.direction ? this._getAffixTypeScrollingUp() : this._getAffixTypeScrollingDown();
+          }
+
+          // Make sure the translate Y is not bigger than container height.
+          dims.translateY = Math.max(0, dims.translateY);
+          dims.translateY = Math.min(dims.containerHeight, dims.translateY);
+          dims.translateY = Math.round(dims.translateY);
+
+          dims.lastViewportTop = dims.viewportTop;
+          return affixType;
+        }
+      }, {
+        key: '_getAffixTypeScrollingDown',
+        value: function _getAffixTypeScrollingDown() {
+          var dims = this.dimensions;
+          var sidebarBottom = dims.sidebarHeight + dims.containerTop;
+          var colliderTop = dims.viewportTop + dims.topSpacing;
+          var colliderBottom = dims.viewportBottom - dims.bottomSpacing;
+          var affixType = this.affixedType;
+
+          if (this.isSidebarFitsViewport()) {
+            if (dims.sidebarHeight + colliderTop >= dims.containerBottom) {
+              dims.translateY = dims.containerBottom - sidebarBottom;
+              affixType = 'CONTAINER-BOTTOM';
+            } else if (colliderTop >= dims.containerTop) {
+              dims.translateY = colliderTop - dims.containerTop;
+              affixType = 'VIEWPORT-TOP';
+            }
+          } else {
+            if (dims.containerBottom <= colliderBottom) {
+              dims.translateY = dims.containerBottom - sidebarBottom;
+              affixType = 'CONTAINER-BOTTOM';
+            } else if (sidebarBottom + dims.translateY <= colliderBottom) {
+              dims.translateY = colliderBottom - sidebarBottom;
+              affixType = 'VIEWPORT-BOTTOM';
+            } else if (dims.containerTop + dims.translateY <= colliderTop && 0 !== dims.translateY && dims.maxTranslateY !== dims.translateY) {
+              affixType = 'VIEWPORT-UNBOTTOM';
+            }
+          }
+
+          return affixType;
+        }
+      }, {
+        key: '_getAffixTypeScrollingUp',
+        value: function _getAffixTypeScrollingUp() {
+          var dims = this.dimensions;
+          var sidebarBottom = dims.sidebarHeight + dims.containerTop;
+          var colliderTop = dims.viewportTop + dims.topSpacing;
+          var colliderBottom = dims.viewportBottom - dims.bottomSpacing;
+          var affixType = this.affixedType;
+
+          if (colliderTop <= dims.translateY + dims.containerTop) {
+            dims.translateY = colliderTop - dims.containerTop;
+            affixType = 'VIEWPORT-TOP';
+          } else if (dims.containerBottom <= colliderBottom) {
+            dims.translateY = dims.containerBottom - sidebarBottom;
+            affixType = 'CONTAINER-BOTTOM';
+          } else if (!this.isSidebarFitsViewport()) {
+
+            if (dims.containerTop <= colliderTop && 0 !== dims.translateY && dims.maxTranslateY !== dims.translateY) {
+              affixType = 'VIEWPORT-UNBOTTOM';
+            }
+          }
+
+          return affixType;
+        }
+      }, {
+        key: '_getStyle',
+        value: function _getStyle(affixType) {
+          if ('undefined' === typeof affixType) return;
+
+          var style = { inner: {}, outer: {} };
+          var dims = this.dimensions;
+
+          switch (affixType) {
+            case 'VIEWPORT-TOP':
+              style.inner = { position: 'fixed', top: dims.topSpacing,
+                left: dims.sidebarLeft - dims.viewportLeft, width: dims.sidebarWidth };
+              break;
+            case 'VIEWPORT-BOTTOM':
+              style.inner = { position: 'fixed', top: 'auto', left: dims.sidebarLeft,
+                bottom: dims.bottomSpacing, width: dims.sidebarWidth };
+              break;
+            case 'CONTAINER-BOTTOM':
+            case 'VIEWPORT-UNBOTTOM':
+              var translate = this._getTranslate(0, dims.translateY + 'px');
+
+              if (translate) style.inner = { transform: translate };else style.inner = { position: 'absolute', top: dims.translateY, width: dims.sidebarWidth };
+              break;
+          }
+
+          switch (affixType) {
+            case 'VIEWPORT-TOP':
+            case 'VIEWPORT-BOTTOM':
+            case 'VIEWPORT-UNBOTTOM':
+            case 'CONTAINER-BOTTOM':
+              style.outer = { height: dims.sidebarHeight, position: 'relative' };
+              break;
+          }
+
+          style.outer = StickySidebar.extend({ height: '', position: '' }, style.outer);
+          style.inner = StickySidebar.extend({ position: 'relative', top: '', left: '',
+            bottom: '', width: '', transform: '' }, style.inner);
+
+          return style;
+        }
+      }, {
+        key: 'stickyPosition',
+        value: function stickyPosition(force) {
+          if (this._breakpoint) return;
+
+          force = this._reStyle || force || false;
+
+          var offsetTop = this.options.topSpacing;
+          var offsetBottom = this.options.bottomSpacing;
+
+          var affixType = this.getAffixType();
+          var style = this._getStyle(affixType);
+
+          if ((this.affixedType != affixType || force) && affixType) {
+            var affixEvent = 'affix.' + affixType.toLowerCase().replace('viewport-', '') + EVENT_KEY;
+            StickySidebar.eventTrigger(this.sidebar, affixEvent);
+
+            if ('STATIC' === affixType) StickySidebar.removeClass(this.sidebar, this.options.stickyClass);else StickySidebar.addClass(this.sidebar, this.options.stickyClass);
+
+            for (var key in style.outer) {
+              var unit = 'number' === typeof style.outer[key] ? 'px' : '';
+              this.sidebar.style[key] = style.outer[key] + unit;
+            }
+
+            for (var _key in style.inner) {
+              var _unit = 'number' === typeof style.inner[_key] ? 'px' : '';
+              this.sidebarInner.style[_key] = style.inner[_key] + _unit;
+            }
+
+            var affixedEvent = 'affixed.' + affixType.toLowerCase().replace('viewport-', '') + EVENT_KEY;
+            StickySidebar.eventTrigger(this.sidebar, affixedEvent);
+          } else {
+            if (this._initialized) this.sidebarInner.style.left = style.inner.left;
+          }
+
+          this.affixedType = affixType;
+        }
+      }, {
+        key: '_widthBreakpoint',
+        value: function _widthBreakpoint() {
+
+          if (window.innerWidth <= this.options.minWidth) {
+            this._breakpoint = true;
+            this.affixedType = 'STATIC';
+
+            this.sidebar.removeAttribute('style');
+            StickySidebar.removeClass(this.sidebar, this.options.stickyClass);
+            this.sidebarInner.removeAttribute('style');
+          } else {
+            this._breakpoint = false;
+          }
+        }
+      }, {
+        key: 'updateSticky',
+        value: function updateSticky() {
+          var _this3 = this;
+
+          var event = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+          if (this._running) return;
+          this._running = true;
+
+          (function (eventType) {
+            requestAnimationFrame(function () {
+              switch (eventType) {
+                // When browser is scrolling and re-calculate just dimensions
+                // within scroll. 
+                case 'scroll':
+                  _this3._calcDimensionsWithScroll();
+                  _this3.observeScrollDir();
+                  _this3.stickyPosition();
+                  break;
+
+                // When browser is resizing or there's no event, observe width
+                // breakpoint and re-calculate dimensions.
+                case 'resize':
+                default:
+                  _this3._widthBreakpoint();
+                  _this3.calcDimensions();
+                  _this3.stickyPosition(true);
+                  break;
+              }
+              _this3._running = false;
+            });
+          })(event.type);
+        }
+      }, {
+        key: '_setSupportFeatures',
+        value: function _setSupportFeatures() {
+          var support = this.support;
+
+          support.transform = StickySidebar.supportTransform();
+          support.transform3d = StickySidebar.supportTransform(true);
+        }
+      }, {
+        key: '_getTranslate',
+        value: function _getTranslate() {
+          var y = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+          var x = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+          var z = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+
+          if (this.support.transform3d) return 'translate3d(' + y + ', ' + x + ', ' + z + ')';else if (this.support.translate) return 'translate(' + y + ', ' + x + ')';else return false;
+        }
+      }, {
+        key: 'destroy',
+        value: function destroy() {
+          window.removeEventListener('resize', this, { capture: false });
+          window.removeEventListener('scroll', this, { capture: false });
+
+          this.sidebar.classList.remove(this.options.stickyClass);
+          this.sidebar.style.minHeight = '';
+
+          this.sidebar.removeEventListener('update' + EVENT_KEY, this);
+
+          var styleReset = { inner: {}, outer: {} };
+
+          styleReset.inner = { position: '', top: '', left: '', bottom: '', width: '', transform: '' };
+          styleReset.outer = { height: '', position: '' };
+
+          for (var key in styleReset.outer) {
+            this.sidebar.style[key] = styleReset.outer[key];
+          }for (var _key2 in styleReset.inner) {
+            this.sidebarInner.style[_key2] = styleReset.inner[_key2];
+          }if (this.options.resizeSensor && 'undefined' !== typeof ResizeSensor) {
+            ResizeSensor.detach(this.sidebarInner, this.handleEvent);
+            ResizeSensor.detach(this.container, this.handleEvent);
+          }
+        }
+      }], [{
+        key: 'supportTransform',
+        value: function supportTransform(transform3d) {
+          var result = false,
+              property = transform3d ? 'perspective' : 'transform',
+              upper = property.charAt(0).toUpperCase() + property.slice(1),
+              prefixes = ['Webkit', 'Moz', 'O', 'ms'],
+              support = document.createElement('support'),
+              style = support.style;
+
+          (property + ' ' + prefixes.join(upper + ' ') + upper).split(' ').forEach(function (property, i) {
+            if (style[property] !== undefined) {
+              result = property;
+              return false;
+            }
+          });
+          return result;
+        }
+      }, {
+        key: 'eventTrigger',
+        value: function eventTrigger(element, eventName, data) {
+          try {
+            var event = new CustomEvent(eventName, { detail: data });
+          } catch (e) {
+            var event = document.createEvent('CustomEvent');
+            event.initCustomEvent(eventName, true, true, data);
+          }
+          element.dispatchEvent(event);
+        }
+      }, {
+        key: 'extend',
+        value: function extend(defaults, options) {
+          var results = {};
+          for (var key in defaults) {
+            if ('undefined' !== typeof options[key]) results[key] = options[key];else results[key] = defaults[key];
+          }
+          return results;
+        }
+      }, {
+        key: 'offsetRelative',
+        value: function offsetRelative(element) {
+          var result = { left: 0, top: 0 };
+
+          do {
+            var offsetTop = element.offsetTop;
+            var offsetLeft = element.offsetLeft;
+
+            if (!isNaN(offsetTop)) result.top += offsetTop;
+
+            if (!isNaN(offsetLeft)) result.left += offsetLeft;
+
+            element = 'BODY' === element.tagName ? element.parentElement : element.offsetParent;
+          } while (element);
+          return result;
+        }
+      }, {
+        key: 'addClass',
+        value: function addClass(element, className) {
+          if (!StickySidebar.hasClass(element, className)) {
+            if (element.classList) element.classList.add(className);else element.className += ' ' + className;
+          }
+        }
+      }, {
+        key: 'removeClass',
+        value: function removeClass(element, className) {
+          if (StickySidebar.hasClass(element, className)) {
+            if (element.classList) element.classList.remove(className);else element.className = element.className.replace(new RegExp('(^|\\b)' + className.split(' ').join('|') + '(\\b|$)', 'gi'), ' ');
+          }
+        }
+      }, {
+        key: 'hasClass',
+        value: function hasClass(element, className) {
+          if (element.classList) return element.classList.contains(className);else return new RegExp('(^| )' + className + '( |$)', 'gi').test(element.className);
+        }
+      }, {
+        key: 'defaults',
+        get: function () {
+          return DEFAULTS;
+        }
+      }]);
+
+      return StickySidebar;
+    }();
+
+    return StickySidebar;
+  }();
+
+  exports.default = StickySidebar;
+
+
+  // Global
+  // -------------------------
+  window.StickySidebar = StickySidebar;
+});
+});
+
+unwrapExports(stickySidebar);
+
+var jquery_stickySidebar = createCommonjsModule(function (module, exports) {
+(function (global, factory) {
+  if (typeof undefined === "function" && undefined.amd) {
+    undefined(['./sticky-sidebar'], factory);
+  } else {
+    factory(stickySidebar);
+  }
+})(commonjsGlobal, function (_stickySidebar) {
+  var _stickySidebar2 = _interopRequireDefault(_stickySidebar);
+
+  function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+      default: obj
+    };
+  }
+
+  (function () {
+    if ('undefined' === typeof window) return;
+
+    var plugin = window.$ || window.jQuery || window.Zepto;
+    var DATA_NAMESPACE = 'stickySidebar';
+
+    // Make sure the site has jquery or zepto plugin.
+    if (plugin) {
+      var _jQueryPlugin = function (config) {
+        return this.each(function () {
+          var $this = plugin(this),
+              data = plugin(this).data(DATA_NAMESPACE);
+
+          if (!data) {
+            data = new _stickySidebar2.default(this, typeof config == 'object' && config);
+            $this.data(DATA_NAMESPACE, data);
+          }
+
+          if ('string' === typeof config) {
+            if (data[config] === undefined && ['destroy', 'updateSticky'].indexOf(config) === -1) throw new Error('No method named "' + config + '"');
+
+            data[config]();
+          }
+        });
+      };
+
+      plugin.fn.stickySidebar = _jQueryPlugin;
+      plugin.fn.stickySidebar.Constructor = _stickySidebar2.default;
+
+      var old = plugin.fn.stickySidebar;
+
+      /**
+       * Sticky Sidebar No Conflict.
+       */
+      plugin.fn.stickySidebar.noConflict = function () {
+        plugin.fn.stickySidebar = old;
+        return this;
+      };
+    }
+  })();
+});
+});
+
+var jquery_stickySidebar$1 = unwrapExports(jquery_stickySidebar);
+
+return jquery_stickySidebar$1;
+
+})));
+