diff --git a/ajax/libs/Sly/1.2.1/sly.js b/ajax/libs/Sly/1.2.1/sly.js
new file mode 100644
index 000000000..74ab12370
--- /dev/null
+++ b/ajax/libs/Sly/1.2.1/sly.js
@@ -0,0 +1,2068 @@
+/*!
+ * sly 1.2.1 - 12th Nov 2013
+ * https://github.com/Darsain/sly
+ *
+ * Licensed under the MIT license.
+ * http://opensource.org/licenses/MIT
+ */
+;(function ($, w, undefined) {
+	'use strict';
+
+	var pluginName = 'sly';
+	var className  = 'Sly';
+	var namespace  = pluginName;
+
+	// Local WindowAnimationTiming interface
+	var cAF = w.cancelAnimationFrame || w.cancelRequestAnimationFrame;
+	var rAF = w.requestAnimationFrame;
+
+	// Support indicators
+	var transform, gpuAcceleration;
+
+	// Other global values
+	var $doc = $(document);
+	var dragInitEvents = 'touchstart.' + namespace + ' mousedown.' + namespace;
+	var dragMouseEvents = 'mousemove.' + namespace + ' mouseup.' + namespace;
+	var dragTouchEvents = 'touchmove.' + namespace + ' touchend.' + namespace;
+	var clickEvent = 'click.' + namespace;
+	var mouseDownEvent = 'mousedown.' + namespace;
+	var interactiveElements = ['INPUT', 'SELECT', 'BUTTON', 'TEXTAREA'];
+	var tmpArray = [];
+	var time;
+
+	/**
+	 * Sly.
+	 *
+	 * @class
+	 *
+	 * @param {Element} frame       DOM element of sly container.
+	 * @param {Object}  options     Object with options.
+	 * @param {Object}  callbackMap Callbacks map.
+	 */
+	function Sly(frame, options, callbackMap) {
+		// Extend options
+		var o = $.extend({}, Sly.defaults, options);
+
+		// Private variables
+		var self = this;
+		var parallax = isNumber(frame);
+
+		// Frame
+		var $frame = $(frame);
+		var $slidee = $frame.children().eq(0);
+		var frameSize = 0;
+		var slideeSize = 0;
+		var pos = {
+			start: 0,
+			center: 0,
+			end: 0,
+			cur: 0,
+			dest: 0
+		};
+
+		// Scrollbar
+		var $sb = $(o.scrollBar).eq(0);
+		var $handle = $sb.children().eq(0);
+		var sbSize = 0;
+		var handleSize = 0;
+		var hPos = {
+			start: 0,
+			end: 0,
+			cur: 0
+		};
+
+		// Pagesbar
+		var $pb = $(o.pagesBar);
+		var $pages = 0;
+		var pages = [];
+
+		// Items
+		var $items = 0;
+		var items = [];
+		var rel = {
+			firstItem: 0,
+			lastItem: 0,
+			centerItem: 0,
+			activeItem: -1,
+			activePage: 0
+		};
+
+		// Navigation type booleans
+		var basicNav = o.itemNav === 'basic';
+		var forceCenteredNav = o.itemNav === 'forceCentered';
+		var centeredNav = o.itemNav === 'centered' || forceCenteredNav;
+		var itemNav = !parallax && (basicNav || centeredNav || forceCenteredNav);
+
+		// Miscellaneous
+		var $scrollSource = o.scrollSource ? $(o.scrollSource) : $frame;
+		var $dragSource = o.dragSource ? $(o.dragSource) : $frame;
+		var $forwardButton = $(o.forward);
+		var $backwardButton = $(o.backward);
+		var $prevButton = $(o.prev);
+		var $nextButton = $(o.next);
+		var $prevPageButton = $(o.prevPage);
+		var $nextPageButton = $(o.nextPage);
+		var callbacks = {};
+		var last = {};
+		var animation = {};
+		var move = {};
+		var dragging = {
+			released: 1
+		};
+		var scrolling = {
+			last: 0,
+			delta: 0,
+			resetTime: 200
+		};
+		var renderID = 0;
+		var historyID = 0;
+		var cycleID = 0;
+		var continuousID = 0;
+		var i, l;
+
+		// Normalizing frame
+		if (!parallax) {
+			frame = $frame[0];
+		}
+
+		// Expose properties
+		self.initialized = 0;
+		self.frame = frame;
+		self.slidee = $slidee[0];
+		self.pos = pos;
+		self.rel = rel;
+		self.items = items;
+		self.pages = pages;
+		self.isPaused = 0;
+		self.options = o;
+		self.dragging = dragging;
+
+		/**
+		 * (Re)Loading function.
+		 *
+		 * Populate arrays, set sizes, bind events, ...
+		 *
+		 * @return {Void}
+		 */
+		function load() {
+			// Local variables
+			var lastItemsCount = 0;
+			var lastPagesCount = pages.length;
+
+			// Save old position
+			pos.old = $.extend({}, pos);
+
+			// Reset global variables
+			frameSize = parallax ? 0 : $frame[o.horizontal ? 'width' : 'height']();
+			sbSize = $sb[o.horizontal ? 'width' : 'height']();
+			slideeSize = parallax ? frame : $slidee[o.horizontal ? 'outerWidth' : 'outerHeight']();
+			pages.length = 0;
+
+			// Set position limits & relatives
+			pos.start = 0;
+			pos.end = Math.max(slideeSize - frameSize, 0);
+
+			// Sizes & offsets for item based navigations
+			if (itemNav) {
+				// Save the number of current items
+				lastItemsCount = items.length;
+
+				// Reset itemNav related variables
+				$items = $slidee.children(o.itemSelector);
+				items.length = 0;
+
+				// Needed variables
+				var paddingStart = getPx($slidee, o.horizontal ? 'paddingLeft' : 'paddingTop');
+				var paddingEnd = getPx($slidee, o.horizontal ? 'paddingRight' : 'paddingBottom');
+				var borderBox = $($items).css('boxSizing') === 'border-box';
+				var areFloated = $items.css('float') !== 'none';
+				var ignoredMargin = 0;
+				var lastItemIndex = $items.length - 1;
+				var lastItem;
+
+				// Reset slideeSize
+				slideeSize = 0;
+
+				// Iterate through items
+				$items.each(function (i, element) {
+					// Item
+					var $item = $(element);
+					var itemSize = $item[o.horizontal ? 'outerWidth' : 'outerHeight']();
+					var itemMarginStart = getPx($item, o.horizontal ? 'marginLeft' : 'marginTop');
+					var itemMarginEnd = getPx($item, o.horizontal ? 'marginRight' : 'marginBottom');
+					var itemSizeFull = itemSize + itemMarginStart + itemMarginEnd;
+					var singleSpaced = !itemMarginStart || !itemMarginEnd;
+					var item = {};
+					item.el = element;
+					item.size = singleSpaced ? itemSize : itemSizeFull;
+					item.half = item.size / 2;
+					item.start = slideeSize + (singleSpaced ? itemMarginStart : 0);
+					item.center = item.start - Math.round(frameSize / 2 - item.size / 2);
+					item.end = item.start - frameSize + item.size;
+
+					// Account for slidee padding
+					if (!i) {
+						slideeSize += paddingStart;
+					}
+
+					// Increment slidee size for size of the active element
+					slideeSize += itemSizeFull;
+
+					// Try to account for vertical margin collapsing in vertical mode
+					// It's not bulletproof, but should work in 99% of cases
+					if (!o.horizontal && !areFloated) {
+						// Subtract smaller margin, but only when top margin is not 0, and this is not the first element
+						if (itemMarginEnd && itemMarginStart && i > 0) {
+							slideeSize -= Math.min(itemMarginStart, itemMarginEnd);
+						}
+					}
+
+					// Things to be done on last item
+					if (i === lastItemIndex) {
+						item.end += paddingEnd;
+						slideeSize += paddingEnd;
+						ignoredMargin = singleSpaced ? itemMarginEnd : 0;
+					}
+
+					// Add item object to items array
+					items.push(item);
+					lastItem = item;
+				});
+
+				// Resize SLIDEE to fit all items
+				$slidee[0].style[o.horizontal ? 'width' : 'height'] = (borderBox ? slideeSize: slideeSize - paddingStart - paddingEnd) + 'px';
+
+				// Adjust internal SLIDEE size for last margin
+				slideeSize -= ignoredMargin;
+
+				// Set limits
+				if (items.length) {
+					pos.start =  items[0][forceCenteredNav ? 'center' : 'start'];
+					pos.end = forceCenteredNav ? lastItem.center : frameSize < slideeSize ? lastItem.end : pos.start;
+				} else {
+					pos.start = pos.end = 0;
+				}
+			}
+
+			// Calculate SLIDEE center position
+			pos.center = Math.round(pos.end / 2 + pos.start / 2);
+
+			// Update relative positions
+			updateRelatives();
+
+			// Scrollbar
+			if ($handle.length && sbSize > 0) {
+				// Stretch scrollbar handle to represent the visible area
+				if (o.dynamicHandle) {
+					handleSize = pos.start === pos.end ? sbSize : Math.round(sbSize * frameSize / slideeSize);
+					handleSize = within(handleSize, o.minHandleSize, sbSize);
+					$handle[0].style[o.horizontal ? 'width' : 'height'] = handleSize + 'px';
+				} else {
+					handleSize = $handle[o.horizontal ? 'outerWidth' : 'outerHeight']();
+				}
+
+				hPos.end = sbSize - handleSize;
+
+				if (!renderID) {
+					syncScrollbar();
+				}
+			}
+
+			// Pages
+			if (!parallax && frameSize > 0) {
+				var tempPagePos = pos.start;
+				var pagesHtml = '';
+
+				// Populate pages array
+				if (itemNav) {
+					$.each(items, function (i, item) {
+						if (forceCenteredNav) {
+							pages.push(item.center);
+						} else if (item.start + item.size > tempPagePos && tempPagePos <= pos.end) {
+							tempPagePos = item.start;
+							pages.push(tempPagePos);
+							tempPagePos += frameSize;
+							if (tempPagePos > pos.end && tempPagePos < pos.end + frameSize) {
+								pages.push(pos.end);
+							}
+						}
+					});
+				} else {
+					while (tempPagePos - frameSize < pos.end) {
+						pages.push(tempPagePos);
+						tempPagePos += frameSize;
+					}
+				}
+
+				// Pages bar
+				if ($pb[0] && lastPagesCount !== pages.length) {
+					for (var i = 0; i < pages.length; i++) {
+						pagesHtml += o.pageBuilder.call(self, i);
+					}
+					$pages = $pb.html(pagesHtml).children();
+					$pages.eq(rel.activePage).addClass(o.activeClass);
+				}
+			}
+
+			// Extend relative variables object with some useful info
+			rel.slideeSize = slideeSize;
+			rel.frameSize = frameSize;
+			rel.sbSize = sbSize;
+			rel.handleSize = handleSize;
+
+			// Activate requested position
+			if (itemNav) {
+				if (!self.initialized) {
+					activate(o.startAt);
+					self[centeredNav ? 'toCenter' : 'toStart'](o.startAt);
+				} else if (rel.activeItem >= items.length || lastItemsCount === 0 && items.length > 0) {
+					// Activate last item if previous active has been removed, or first item
+					// when there were no items before, and new got appended.
+					activate(rel.activeItem >= items.length ? items.length - 1 : 0, !lastItemsCount);
+				}
+				// Fix possible overflowing
+				slideTo(centeredNav && items.length ? items[rel.activeItem].center : within(pos.dest, pos.start, pos.end));
+			} else {
+				if (!self.initialized) {
+					slideTo(o.startAt, 1);
+				} else {
+					// Fix possible overflowing
+					slideTo(within(pos.dest, pos.start, pos.end));
+				}
+			}
+
+			// Trigger load event
+			trigger('load');
+		}
+		self.reload = load;
+
+		/**
+		 * Animate to a position.
+		 *
+		 * @param {Int}  newPos    New position.
+		 * @param {Bool} immediate Reposition immediately without an animation.
+		 * @param {Bool} dontAlign Do not align items, use the raw position passed in first argument.
+		 *
+		 * @return {Void}
+		 */
+		function slideTo(newPos, immediate, dontAlign) {
+			// Align items
+			if (itemNav && dragging.released && !dontAlign) {
+				var tempRel = getRelatives(newPos);
+				var isNotBordering = newPos > pos.start && newPos < pos.end;
+
+				if (centeredNav) {
+					if (isNotBordering) {
+						newPos = items[tempRel.centerItem].center;
+					}
+					if (forceCenteredNav && o.activateMiddle) {
+						activate(tempRel.centerItem);
+					}
+				} else if (isNotBordering) {
+					newPos = items[tempRel.firstItem].start;
+				}
+			}
+
+			// Handle overflowing position limits
+			if (dragging.init && dragging.slidee && o.elasticBounds) {
+				if (newPos > pos.end) {
+					newPos = pos.end + (newPos - pos.end) / 6;
+				} else if (newPos < pos.start) {
+					newPos = pos.start + (newPos - pos.start) / 6;
+				}
+			} else {
+				newPos = within(newPos, pos.start, pos.end);
+			}
+
+			// Update the animation object
+			animation.start = +new Date();
+			animation.time = 0;
+			animation.from = pos.cur;
+			animation.to = newPos;
+			animation.delta = newPos - pos.cur;
+			animation.tweesing = dragging.tweese || dragging.init && !dragging.slidee;
+			animation.immediate = !animation.tweesing && (immediate || dragging.init && dragging.slidee || !o.speed);
+
+			// Reset dragging tweesing request
+			dragging.tweese = 0;
+
+			// Start animation rendering
+			if (newPos !== pos.dest) {
+				pos.dest = newPos;
+				trigger('change');
+				if (!renderID) {
+					render();
+				}
+			}
+
+			// Reset next cycle timeout
+			resetCycle();
+
+			// Synchronize states
+			updateRelatives();
+			updateButtonsState();
+			syncPagesbar();
+		}
+
+		/**
+		 * Render animation frame.
+		 *
+		 * @return {Void}
+		 */
+		function render() {
+			// If first render call, wait for next animationFrame
+			if (!renderID) {
+				renderID = rAF(render);
+				if (dragging.released) {
+					trigger('moveStart');
+				}
+				return;
+			}
+
+			// If immediate repositioning is requested, don't animate.
+			if (animation.immediate) {
+				pos.cur = animation.to;
+			}
+			// Use tweesing for animations without known end point
+			else if (animation.tweesing) {
+				animation.tweeseDelta = animation.to - pos.cur;
+				// Fuck Zeno's paradox
+				if (Math.abs(animation.tweeseDelta) < 0.1) {
+					pos.cur = animation.to;
+				} else {
+					pos.cur += animation.tweeseDelta * (dragging.released ? o.swingSpeed : o.syncSpeed);
+				}
+			}
+			// Use tweening for basic animations with known end point
+			else {
+				animation.time = Math.min(+new Date() - animation.start, o.speed);
+				pos.cur = animation.from + animation.delta * jQuery.easing[o.easing](animation.time/o.speed, animation.time, 0, 1, o.speed);
+			}
+
+			// If there is nothing more to render break the rendering loop, otherwise request new animation frame.
+			if (animation.to === pos.cur) {
+				pos.cur = animation.to;
+				dragging.tweese = renderID = 0;
+			} else {
+				renderID = rAF(render);
+			}
+
+			trigger('move');
+
+			// Update SLIDEE position
+			if (!parallax) {
+				if (transform) {
+					$slidee[0].style[transform] = gpuAcceleration + (o.horizontal ? 'translateX' : 'translateY') + '(' + (-pos.cur) + 'px)';
+				} else {
+					$slidee[0].style[o.horizontal ? 'left' : 'top'] = -Math.round(pos.cur) + 'px';
+				}
+			}
+
+			// When animation reached the end, and dragging is not active, trigger moveEnd
+			if (!renderID && dragging.released) {
+				trigger('moveEnd');
+			}
+
+			syncScrollbar();
+		}
+
+		/**
+		 * Synchronizes scrollbar with the SLIDEE.
+		 *
+		 * @return {Void}
+		 */
+		function syncScrollbar() {
+			if ($handle.length) {
+				hPos.cur = pos.start === pos.end ? 0 : (((dragging.init && !dragging.slidee) ? pos.dest : pos.cur) - pos.start) / (pos.end - pos.start) * hPos.end;
+				hPos.cur = within(Math.round(hPos.cur), hPos.start, hPos.end);
+				if (last.hPos !== hPos.cur) {
+					last.hPos = hPos.cur;
+					if (transform) {
+						$handle[0].style[transform] = gpuAcceleration + (o.horizontal ? 'translateX' : 'translateY') + '(' + hPos.cur + 'px)';
+					} else {
+						$handle[0].style[o.horizontal ? 'left' : 'top'] = hPos.cur + 'px';
+					}
+				}
+			}
+		}
+
+		/**
+		 * Synchronizes pagesbar with SLIDEE.
+		 *
+		 * @return {Void}
+		 */
+		function syncPagesbar() {
+			if ($pages[0] && last.page !== rel.activePage) {
+				last.page = rel.activePage;
+				$pages.removeClass(o.activeClass).eq(rel.activePage).addClass(o.activeClass);
+				trigger('activePage', last.page);
+			}
+		}
+
+		/**
+		 * Returns the position object.
+		 *
+		 * @param {Mixed} item
+		 *
+		 * @return {Object}
+		 */
+		self.getPos = function (item) {
+			if (itemNav) {
+				var index = getIndex(item);
+				return index !== -1 ? items[index] : false;
+			} else {
+				var $item = $slidee.find(item).eq(0);
+
+				if ($item[0]) {
+					var offset = o.horizontal ? $item.offset().left - $slidee.offset().left : $item.offset().top - $slidee.offset().top;
+					var size = $item[o.horizontal ? 'outerWidth' : 'outerHeight']();
+
+					return {
+						start: offset,
+						center: offset - frameSize / 2 + size / 2,
+						end: offset - frameSize + size,
+						size: size
+					};
+				} else {
+					return false;
+				}
+			}
+		};
+
+		/**
+		 * Continuous move in a specified direction.
+		 *
+		 * @param  {Bool} forward True for forward movement, otherwise it'll go backwards.
+		 * @param  {Int}  speed   Movement speed in pixels per frame. Overrides options.moveBy value.
+		 *
+		 * @return {Void}
+		 */
+		self.moveBy = function (speed) {
+			move.speed = speed;
+			// If already initiated, or there is nowhere to move, abort
+			if (dragging.init || !move.speed || pos.cur === (move.speed > 0 ? pos.end : pos.start)) {
+				return;
+			}
+			// Initiate move object
+			move.lastTime = +new Date();
+			move.startPos = pos.cur;
+			// Set dragging as initiated
+			continuousInit('button');
+			dragging.init = 1;
+			// Start movement
+			trigger('moveStart');
+			cAF(continuousID);
+			moveLoop();
+		};
+
+		/**
+		 * Continuous movement loop.
+		 *
+		 * @return {Void}
+		 */
+		function moveLoop() {
+			// If there is nowhere to move anymore, stop
+			if (!move.speed || pos.cur === (move.speed > 0 ? pos.end : pos.start)) {
+				self.stop();
+			}
+			// Request new move loop if it hasn't been stopped
+			continuousID = dragging.init ? rAF(moveLoop) : 0;
+			// Update move object
+			move.now = +new Date();
+			move.pos = pos.cur + (move.now - move.lastTime) / 1000 * move.speed;
+			// Slide
+			slideTo(dragging.init ? move.pos : Math.round(move.pos));
+			// Normally, this is triggered in render(), but if there
+			// is nothing to render, we have to do it manually here.
+			if (!dragging.init && pos.cur === pos.dest) {
+				trigger('moveEnd');
+			}
+			// Update times for future iteration
+			move.lastTime = move.now;
+		}
+
+		/**
+		 * Stops continuous movement.
+		 *
+		 * @return {Void}
+		 */
+		self.stop = function () {
+			if (dragging.source === 'button') {
+				dragging.init = 0;
+				dragging.released = 1;
+			}
+		};
+
+		/**
+		 * Activate previous item.
+		 *
+		 * @return {Void}
+		 */
+		self.prev = function () {
+			self.activate(rel.activeItem - 1);
+		};
+
+		/**
+		 * Activate next item.
+		 *
+		 * @return {Void}
+		 */
+		self.next = function () {
+			self.activate(rel.activeItem + 1);
+		};
+
+		/**
+		 * Activate previous page.
+		 *
+		 * @return {Void}
+		 */
+		self.prevPage = function () {
+			self.activatePage(rel.activePage - 1);
+		};
+
+		/**
+		 * Activate next page.
+		 *
+		 * @return {Void}
+		 */
+		self.nextPage = function () {
+			self.activatePage(rel.activePage + 1);
+		};
+
+		/**
+		 * Slide SLIDEE by amount of pixels.
+		 *
+		 * @param {Int}  delta     Pixels/Items. Positive means forward, negative means backward.
+		 * @param {Bool} immediate Reposition immediately without an animation.
+		 *
+		 * @return {Void}
+		 */
+		self.slideBy = function (delta, immediate) {
+			if (!delta) {
+				return;
+			}
+			if (itemNav) {
+				self[centeredNav ? 'toCenter' : 'toStart'](
+					within((centeredNav ? rel.centerItem : rel.firstItem) + o.scrollBy * delta, 0, items.length)
+				);
+			} else {
+				slideTo(pos.dest + delta, immediate);
+			}
+		};
+
+		/**
+		 * Animate SLIDEE to a specific position.
+		 *
+		 * @param {Int}  pos       New position.
+		 * @param {Bool} immediate Reposition immediately without an animation.
+		 *
+		 * @return {Void}
+		 */
+		self.slideTo = function (pos, immediate) {
+			slideTo(pos, immediate);
+		};
+
+		/**
+		 * Core method for handling `toLocation` methods.
+		 *
+		 * @param  {String} location
+		 * @param  {Mixed}  item
+		 * @param  {Bool}   immediate
+		 *
+		 * @return {Void}
+		 */
+		function to(location, item, immediate) {
+			// Optional arguments logic
+			if (type(item) === 'boolean') {
+				immediate = item;
+				item = undefined;
+			}
+
+			if (item === undefined) {
+				slideTo(pos[location], immediate);
+			} else {
+				// You can't align items to sides of the frame
+				// when centered navigation type is enabled
+				if (centeredNav && location !== 'center') {
+					return;
+				}
+
+				var itemPos = self.getPos(item);
+				if (itemPos) {
+					slideTo(itemPos[location], immediate, !centeredNav);
+				}
+			}
+		}
+
+		/**
+		 * Animate element or the whole SLIDEE to the start of the frame.
+		 *
+		 * @param {Mixed} item      Item DOM element, or index starting at 0. Omitting will animate SLIDEE.
+		 * @param {Bool}  immediate Reposition immediately without an animation.
+		 *
+		 * @return {Void}
+		 */
+		self.toStart = function (item, immediate) {
+			to('start', item, immediate);
+		};
+
+		/**
+		 * Animate element or the whole SLIDEE to the end of the frame.
+		 *
+		 * @param {Mixed} item      Item DOM element, or index starting at 0. Omitting will animate SLIDEE.
+		 * @param {Bool}  immediate Reposition immediately without an animation.
+		 *
+		 * @return {Void}
+		 */
+		self.toEnd = function (item, immediate) {
+			to('end', item, immediate);
+		};
+
+		/**
+		 * Animate element or the whole SLIDEE to the center of the frame.
+		 *
+		 * @param {Mixed} item      Item DOM element, or index starting at 0. Omitting will animate SLIDEE.
+		 * @param {Bool}  immediate Reposition immediately without an animation.
+		 *
+		 * @return {Void}
+		 */
+		self.toCenter = function (item, immediate) {
+			to('center', item, immediate);
+		};
+
+		/**
+		 * Get the index of an item in SLIDEE.
+		 *
+		 * @param {Mixed} item     Item DOM element.
+		 *
+		 * @return {Int}  Item index, or -1 if not found.
+		 */
+		function getIndex(item) {
+			return item != null ?
+					isNumber(item) ?
+						item >= 0 && item < items.length ? item : -1 :
+						$items.index(item) :
+					-1;
+		}
+		// Expose getIndex without lowering the compressibility of it,
+		// as it is used quite often throughout Sly.
+		self.getIndex = getIndex;
+
+		/**
+		 * Get index of an item in SLIDEE based on a variety of input types.
+		 *
+		 * @param  {Mixed} item DOM element, positive or negative integer.
+		 *
+		 * @return {Int}   Item index, or -1 if not found.
+		 */
+		function getRelativeIndex(item) {
+			return getIndex(isNumber(item) && item < 0 ? item + items.length : item);
+		}
+
+		/**
+		 * Activates an item.
+		 *
+		 * @param  {Mixed} item Item DOM element, or index starting at 0.
+		 *
+		 * @return {Mixed} Activated item index or false on fail.
+		 */
+		function activate(item, force) {
+			var index = getIndex(item);
+
+			if (!itemNav || index < 0) {
+				return false;
+			}
+
+			// Update classes, last active index, and trigger active event only when there
+			// has been a change. Otherwise just return the current active index.
+			if (last.active !== index || force) {
+				// Update classes
+				$items.eq(rel.activeItem).removeClass(o.activeClass);
+				$items.eq(index).addClass(o.activeClass);
+
+				last.active = rel.activeItem = index;
+
+				updateButtonsState();
+				trigger('active', index);
+			}
+
+			return index;
+		}
+
+		/**
+		 * Activates an item and helps with further navigation when o.smart is enabled.
+		 *
+		 * @param {Mixed} item      Item DOM element, or index starting at 0.
+		 * @param {Bool}  immediate Whether to reposition immediately in smart navigation.
+		 *
+		 * @return {Void}
+		 */
+		self.activate = function (item, immediate) {
+			var index = activate(item);
+
+			// Smart navigation
+			if (o.smart && index !== false) {
+				// When centeredNav is enabled, center the element.
+				// Otherwise, determine where to position the element based on its current position.
+				// If the element is currently on the far end side of the frame, assume that user is
+				// moving forward and animate it to the start of the visible frame, and vice versa.
+				if (centeredNav) {
+					self.toCenter(index, immediate);
+				} else if (index >= rel.lastItem) {
+					self.toStart(index, immediate);
+				} else if (index <= rel.firstItem) {
+					self.toEnd(index, immediate);
+				} else {
+					resetCycle();
+				}
+			}
+		};
+
+		/**
+		 * Activates a page.
+		 *
+		 * @param {Int}  index     Page index, starting from 0.
+		 * @param {Bool} immediate Whether to reposition immediately without animation.
+		 *
+		 * @return {Void}
+		 */
+		self.activatePage = function (index, immediate) {
+			if (isNumber(index)) {
+				slideTo(pages[within(index, 0, pages.length - 1)], immediate);
+			}
+		};
+
+		/**
+		 * Return relative positions of items based on their visibility within FRAME.
+		 *
+		 * @param {Int} slideePos Position of SLIDEE.
+		 *
+		 * @return {Void}
+		 */
+		function getRelatives(slideePos) {
+			slideePos = within(isNumber(slideePos) ? slideePos : pos.dest, pos.start, pos.end);
+
+			var relatives = {};
+			var centerOffset = forceCenteredNav ? 0 : frameSize / 2;
+
+			// Determine active page
+			if (!parallax) {
+				for (var p = 0, pl = pages.length; p < pl; p++) {
+					if (slideePos >= pos.end || p === pages.length - 1) {
+						relatives.activePage = pages.length - 1;
+						break;
+					}
+
+					if (slideePos <= pages[p] + centerOffset) {
+						relatives.activePage = p;
+						break;
+					}
+				}
+			}
+
+			// Relative item indexes
+			if (itemNav) {
+				var first = false;
+				var last = false;
+				var center = false;
+
+				// From start
+				for (var i = 0, il = items.length; i < il; i++) {
+					// First item
+					if (first === false && slideePos <= items[i].start + items[i].half) {
+						first = i;
+					}
+
+					// Center item
+					if (center === false && slideePos <= items[i].center + items[i].half) {
+						center = i;
+					}
+
+					// Last item
+					if (i === il - 1 || slideePos <= items[i].end + items[i].half) {
+						last = i;
+						break;
+					}
+				}
+
+				// Safe assignment, just to be sure the false won't be returned
+				relatives.firstItem = isNumber(first) ? first : 0;
+				relatives.centerItem = isNumber(center) ? center : relatives.firstItem;
+				relatives.lastItem = isNumber(last) ? last : relatives.centerItem;
+			}
+
+			return relatives;
+		}
+
+		/**
+		 * Update object with relative positions.
+		 *
+		 * @param {Int} newPos
+		 *
+		 * @return {Void}
+		 */
+		function updateRelatives(newPos) {
+			$.extend(rel, getRelatives(newPos));
+		}
+
+		/**
+		 * Disable navigation buttons when needed.
+		 *
+		 * Adds disabledClass, and when the button is <button> or <input>, activates :disabled state.
+		 *
+		 * @return {Void}
+		 */
+		function updateButtonsState() {
+			var isStart = pos.dest <= pos.start;
+			var isEnd = pos.dest >= pos.end;
+			var slideePosState = isStart ? 1 : isEnd ? 2 : 3;
+
+			// Update paging buttons only if there has been a change in SLIDEE position
+			if (last.slideePosState !== slideePosState) {
+				last.slideePosState = slideePosState;
+
+				if ($prevPageButton.is('button,input')) {
+					$prevPageButton.prop('disabled', isStart);
+				}
+
+				if ($nextPageButton.is('button,input')) {
+					$nextPageButton.prop('disabled', isEnd);
+				}
+
+				$prevPageButton.add($backwardButton)[isStart ? 'addClass' : 'removeClass'](o.disabledClass);
+				$nextPageButton.add($forwardButton)[isEnd ? 'addClass' : 'removeClass'](o.disabledClass);
+			}
+
+			// Forward & Backward buttons need a separate state caching because we cannot "property disable"
+			// them while they are being used, as disabled buttons stop emitting mouse events.
+			if (last.fwdbwdState !== slideePosState && dragging.released) {
+				last.fwdbwdState = slideePosState;
+
+				if ($backwardButton.is('button,input')) {
+					$backwardButton.prop('disabled', isStart);
+				}
+
+				if ($forwardButton.is('button,input')) {
+					$forwardButton.prop('disabled', isEnd);
+				}
+			}
+
+			// Item navigation
+			if (itemNav) {
+				var isFirst = rel.activeItem === 0;
+				var isLast = rel.activeItem >= items.length - 1;
+				var itemsButtonState = isFirst ? 1 : isLast ? 2 : 3;
+
+				if (last.itemsButtonState !== itemsButtonState) {
+					last.itemsButtonState = itemsButtonState;
+
+					if ($prevButton.is('button,input')) {
+						$prevButton.prop('disabled', isFirst);
+					}
+
+					if ($nextButton.is('button,input')) {
+						$nextButton.prop('disabled', isLast);
+					}
+
+					$prevButton[isFirst ? 'addClass' : 'removeClass'](o.disabledClass);
+					$nextButton[isLast ? 'addClass' : 'removeClass'](o.disabledClass);
+				}
+			}
+		}
+
+		/**
+		 * Resume cycling.
+		 *
+		 * @param {Int} priority Resume pause with priority lower or equal than this. Used internally for pauseOnHover.
+		 *
+		 * @return {Void}
+		 */
+		self.resume = function (priority) {
+			if (!o.cycleBy || !o.cycleInterval || o.cycleBy === 'items' && !items[0] || priority < self.isPaused) {
+				return;
+			}
+
+			self.isPaused = 0;
+
+			if (cycleID) {
+				cycleID = clearTimeout(cycleID);
+			} else {
+				trigger('resume');
+			}
+
+			cycleID = setTimeout(function () {
+				trigger('cycle');
+				switch (o.cycleBy) {
+					case 'items':
+						self.activate(rel.activeItem >= items.length - 1 ? 0 : rel.activeItem + 1);
+						break;
+
+					case 'pages':
+						self.activatePage(rel.activePage >= pages.length - 1 ? 0 : rel.activePage + 1);
+						break;
+				}
+			}, o.cycleInterval);
+		};
+
+		/**
+		 * Pause cycling.
+		 *
+		 * @param {Int} priority Pause priority. 100 is default. Used internally for pauseOnHover.
+		 *
+		 * @return {Void}
+		 */
+		self.pause = function (priority) {
+			if (priority < self.isPaused) {
+				return;
+			}
+
+			self.isPaused = priority || 100;
+
+			if (cycleID) {
+				cycleID = clearTimeout(cycleID);
+				trigger('pause');
+			}
+		};
+
+		/**
+		 * Toggle cycling.
+		 *
+		 * @return {Void}
+		 */
+		self.toggle = function () {
+			self[cycleID ? 'pause' : 'resume']();
+		};
+
+		/**
+		 * Updates a signle or multiple option values.
+		 *
+		 * @param {Mixed} name  Name of the option that should be updated, or object that will extend the options.
+		 * @param {Mixed} value New option value.
+		 *
+		 * @return {Void}
+		 */
+		self.set = function (name, value) {
+			if ($.isPlainObject(name)) {
+				$.extend(o, name);
+			} else if (o.hasOwnProperty(name)) {
+				o[name] = value;
+			}
+		};
+
+		/**
+		 * Add one or multiple items to the SLIDEE end, or a specified position index.
+		 *
+		 * @param {Mixed} element Node element, or HTML string.
+		 * @param {Int}   index   Index of a new item position. By default item is appended at the end.
+		 *
+		 * @return {Void}
+		 */
+		self.add = function (element, index) {
+			var $element = $(element);
+
+			if (itemNav) {
+				// Insert the element(s)
+				if (index == null || !items[0]) {
+					$element.appendTo($slidee);
+				} else if (items.length) {
+					$element.insertBefore(items[index].el);
+				}
+
+				// Adjust the activeItem index
+				if (index <= rel.activeItem) {
+					last.active = rel.activeItem += $element.length;
+				}
+			} else {
+				$slidee.append($element);
+			}
+
+			// Reload
+			load();
+		};
+
+		/**
+		 * Remove an item from SLIDEE.
+		 *
+		 * @param {Mixed} element Item index, or DOM element.
+		 * @param {Int}   index   Index of a new item position. By default item is appended at the end.
+		 *
+		 * @return {Void}
+		 */
+		self.remove = function (element) {
+			if (itemNav) {
+				var index = getRelativeIndex(element);
+
+				if (index > -1) {
+					// Remove the element
+					$items.eq(index).remove();
+
+					// If the current item is being removed, activate new one after reload
+					var reactivate = index === rel.activeItem;
+
+					// Adjust the activeItem index
+					if (index < rel.activeItem) {
+						last.active = --rel.activeItem;
+					}
+
+					// Reload
+					load();
+
+					// Activate new item at the removed position
+					if (reactivate) {
+						last.active = null;
+						self.activate(rel.activeItem);
+					}
+				}
+			} else {
+				$(element).remove();
+				load();
+			}
+		};
+
+		/**
+		 * Helps re-arranging items.
+		 *
+		 * @param  {Mixed} item     Item DOM element, or index starting at 0. Use negative numbers to select items from the end.
+		 * @param  {Mixed} position Item insertion anchor. Accepts same input types as item argument.
+		 * @param  {Bool}  after    Insert after instead of before the anchor.
+		 *
+		 * @return {Void}
+		 */
+		function moveItem(item, position, after) {
+			item = getRelativeIndex(item);
+			position = getRelativeIndex(position);
+
+			// Move only if there is an actual change requested
+			if (item > -1 && position > -1 && item !== position && (!after || position !== item - 1) && (after || position !== item + 1)) {
+				$items.eq(item)[after ? 'insertAfter' : 'insertBefore'](items[position].el);
+
+				var shiftStart = item < position ? item : (after ? position : position - 1);
+				var shiftEnd = item > position ? item : (after ? position + 1 : position);
+				var shiftsUp = item > position;
+
+				// Update activeItem index
+				if (item === rel.activeItem) {
+					last.active = rel.activeItem = after ? (shiftsUp ? position + 1 : position) : (shiftsUp ? position : position - 1);
+				} else if (rel.activeItem > shiftStart && rel.activeItem < shiftEnd) {
+					last.active = rel.activeItem += shiftsUp ? 1 : -1;
+				}
+
+				// Reload
+				load();
+			}
+		}
+
+		/**
+		 * Move item after the target anchor.
+		 *
+		 * @param  {Mixed} item     Item to be moved. Can be DOM element or item index.
+		 * @param  {Mixed} position Target position anchor. Can be DOM element or item index.
+		 *
+		 * @return {Void}
+		 */
+		self.moveAfter = function (item, position) {
+			moveItem(item, position, 1);
+		};
+
+		/**
+		 * Move item before the target anchor.
+		 *
+		 * @param  {Mixed} item     Item to be moved. Can be DOM element or item index.
+		 * @param  {Mixed} position Target position anchor. Can be DOM element or item index.
+		 *
+		 * @return {Void}
+		 */
+		self.moveBefore = function (item, position) {
+			moveItem(item, position);
+		};
+
+		/**
+		 * Registers callbacks.
+		 *
+		 * @param  {Mixed} name  Event name, or callbacks map.
+		 * @param  {Mixed} fn    Callback, or an array of callback functions.
+		 *
+		 * @return {Void}
+		 */
+		self.on = function (name, fn) {
+			// Callbacks map
+			if (type(name) === 'object') {
+				for (var key in name) {
+					if (name.hasOwnProperty(key)) {
+						self.on(key, name[key]);
+					}
+				}
+			// Callback
+			} else if (type(fn) === 'function') {
+				var names = name.split(' ');
+				for (var n = 0, nl = names.length; n < nl; n++) {
+					callbacks[names[n]] = callbacks[names[n]] || [];
+					if (callbackIndex(names[n], fn) === -1) {
+						callbacks[names[n]].push(fn);
+					}
+				}
+			// Callbacks array
+			} else if (type(fn) === 'array') {
+				for (var f = 0, fl = fn.length; f < fl; f++) {
+					self.on(name, fn[f]);
+				}
+			}
+		};
+
+		/**
+		 * Registers callbacks to be executed only once.
+		 *
+		 * @param  {Mixed} name  Event name, or callbacks map.
+		 * @param  {Mixed} fn    Callback, or an array of callback functions.
+		 *
+		 * @return {Void}
+		 */
+		self.one = function (name, fn) {
+			function proxy() {
+				fn.apply(self, arguments);
+				self.off(name, proxy);
+			}
+			self.on(name, proxy);
+		};
+
+		/**
+		 * Remove one or all callbacks.
+		 *
+		 * @param  {String} name Event name.
+		 * @param  {Mixed}  fn   Callback, or an array of callback functions. Omit to remove all callbacks.
+		 *
+		 * @return {Void}
+		 */
+		self.off = function (name, fn) {
+			if (fn instanceof Array) {
+				for (var f = 0, fl = fn.length; f < fl; f++) {
+					self.off(name, fn[f]);
+				}
+			} else {
+				var names = name.split(' ');
+				for (var n = 0, nl = names.length; n < nl; n++) {
+					callbacks[names[n]] = callbacks[names[n]] || [];
+					if (fn == null) {
+						callbacks[names[n]].length = 0;
+					} else {
+						var index = callbackIndex(names[n], fn);
+						if (index !== -1) {
+							callbacks[names[n]].splice(index, 1);
+						}
+					}
+				}
+			}
+		};
+
+		/**
+		 * Returns callback array index.
+		 *
+		 * @param  {String}   name Event name.
+		 * @param  {Function} fn   Function
+		 *
+		 * @return {Int} Callback array index, or -1 if isn't registered.
+		 */
+		function callbackIndex(name, fn) {
+			for (var i = 0, l = callbacks[name].length; i < l; i++) {
+				if (callbacks[name][i] === fn) {
+					return i;
+				}
+			}
+			return -1;
+		}
+
+		/**
+		 * Reset next cycle timeout.
+		 *
+		 * @return {Void}
+		 */
+		function resetCycle() {
+			if (dragging.released && !self.isPaused) {
+				self.resume();
+			}
+		}
+
+		/**
+		 * Calculate SLIDEE representation of handle position.
+		 *
+		 * @param  {Int} handlePos
+		 *
+		 * @return {Int}
+		 */
+		function handleToSlidee(handlePos) {
+			return Math.round(within(handlePos, hPos.start, hPos.end) / hPos.end * (pos.end - pos.start)) + pos.start;
+		}
+
+		/**
+		 * Keeps track of a dragging delta history.
+		 *
+		 * @return {Void}
+		 */
+		function draggingHistoryTick() {
+			// Looking at this, I know what you're thinking :) But as we need only 4 history states, doing it this way
+			// as opposed to a proper loop is ~25 bytes smaller (when minified with GCC), a lot faster, and doesn't
+			// generate garbage. The loop version would create 2 new variables on every tick. Unexaptable!
+			dragging.history[0] = dragging.history[1];
+			dragging.history[1] = dragging.history[2];
+			dragging.history[2] = dragging.history[3];
+			dragging.history[3] = dragging.delta;
+		}
+
+		/**
+		 * Initialize continuous movement.
+		 *
+		 * @return {Void}
+		 */
+		function continuousInit(source) {
+			dragging.released = 0;
+			dragging.source = source;
+			dragging.slidee = source === 'slidee';
+		}
+
+		/**
+		 * Dragging initiator.
+		 *
+		 * @param  {Event} event
+		 *
+		 * @return {Void}
+		 */
+		function dragInit(event) {
+			// Ignore when already in progress, or interactive element
+			if (dragging.init || isInteractive(event.target)) {
+				return;
+			}
+
+			var isTouch = event.type === 'touchstart';
+			var source = event.data.source;
+			var isSlidee = source === 'slidee';
+
+			// Handle dragging conditions
+			if (source === 'handle' && (!o.dragHandle || hPos.start === hPos.end)) {
+				return;
+			}
+
+			// SLIDEE dragging conditions
+			if (isSlidee && !(isTouch ? o.touchDragging : o.mouseDragging && event.which < 2)) {
+				return;
+			}
+
+			if (!isTouch) {
+				stopDefault(event, 1);
+			}
+
+			// Reset dragging object
+			continuousInit(source);
+
+			// Properties used in dragHandler
+			dragging.init = 1;
+			dragging.$source = $(event.target);
+			dragging.touch = isTouch;
+			dragging.pointer = isTouch ? event.originalEvent.touches[0] : event;
+			dragging.initX = dragging.pointer.pageX;
+			dragging.initY = dragging.pointer.pageY;
+			dragging.initPos = isSlidee ? pos.cur : hPos.cur;
+			dragging.start = +new Date();
+			dragging.time = 0;
+			dragging.path = 0;
+			dragging.delta = 0;
+			dragging.locked = 0;
+			dragging.history = [0, 0, 0, 0];
+			dragging.pathToLock = isSlidee ? isTouch ? 30 : 10 : 0;
+			dragging.initLoc = dragging[o.horizontal ? 'initX' : 'initY'];
+			dragging.deltaMin = isSlidee ? -dragging.initLoc : -hPos.cur;
+			dragging.deltaMax = isSlidee ? document[o.horizontal ? 'width' : 'height'] - dragging.initLoc : hPos.end - hPos.cur;
+
+			// Bind dragging events
+			$doc.on(isTouch ? dragTouchEvents : dragMouseEvents, dragHandler);
+
+			// Pause ongoing cycle
+			self.pause(1);
+
+			// Add dragging class
+			(isSlidee ? $slidee : $handle).addClass(o.draggedClass);
+
+			// Trigger moveStart event
+			trigger('moveStart');
+
+			// Keep track of a dragging path history. This is later used in the
+			// dragging release swing calculation when dragging SLIDEE.
+			if (isSlidee) {
+				historyID = setInterval(draggingHistoryTick, 10);
+			}
+		}
+
+		/**
+		 * Handler for dragging scrollbar handle or SLIDEE.
+		 *
+		 * @param  {Event} event
+		 *
+		 * @return {Void}
+		 */
+		function dragHandler(event) {
+			dragging.released = event.type === 'mouseup' || event.type === 'touchend';
+			dragging.pointer = dragging.touch ? event.originalEvent[dragging.released ? 'changedTouches' : 'touches'][0] : event;
+			dragging.pathX = dragging.pointer.pageX - dragging.initX;
+			dragging.pathY = dragging.pointer.pageY - dragging.initY;
+			dragging.path = Math.sqrt(Math.pow(dragging.pathX, 2) + Math.pow(dragging.pathY, 2));
+			dragging.delta = within(o.horizontal ? dragging.pathX : dragging.pathY, dragging.deltaMin, dragging.deltaMax);
+
+			if (!dragging.locked && dragging.path > dragging.pathToLock) {
+				dragging.locked = 1;
+				if (o.horizontal ? Math.abs(dragging.pathX) < Math.abs(dragging.pathY) : Math.abs(dragging.pathX) > Math.abs(dragging.pathY)) {
+					// If path has reached the pathToLock distance, but in a wrong direction, cancel dragging
+					dragging.released = 1;
+				} else if (dragging.slidee) {
+					// Disable click on a source element, as it is unwelcome when dragging SLIDEE
+					dragging.$source.on(clickEvent, disableOneEvent);
+				}
+			}
+
+			// Cancel dragging on release
+			if (dragging.released) {
+				if (!dragging.touch) {
+					stopDefault(event);
+				}
+
+				dragEnd();
+
+				// Adjust path with a swing on mouse release
+				if (o.releaseSwing && dragging.slidee) {
+					dragging.swing = (dragging.delta - dragging.history[0]) / 40 * 300;
+					dragging.delta += dragging.swing;
+					dragging.tweese = Math.abs(dragging.swing) > 10;
+				}
+			} else {
+				stopDefault(event);
+			}
+
+			slideTo(dragging.slidee ? Math.round(dragging.initPos - dragging.delta) : handleToSlidee(dragging.initPos + dragging.delta));
+
+		}
+
+		/**
+		 * Stops dragging and cleans up after it.
+		 *
+		 * @return {Void}
+		 */
+		function dragEnd() {
+			clearInterval(historyID);
+			$doc.off(dragging.touch ? dragTouchEvents : dragMouseEvents, dragHandler);
+			(dragging.slidee ? $slidee : $handle).removeClass(o.draggedClass);
+
+			// Resume ongoing cycle
+			self.resume(1);
+
+			// Normally, this is triggered in render(), but if there
+			// is nothing to render, we have to do it manually here.
+			if (pos.cur === pos.dest && dragging.init) {
+				trigger('moveEnd');
+			}
+
+			dragging.init = 0;
+		}
+
+		/**
+		 * Check whether element is interactive.
+		 *
+		 * @return {Boolean}
+		 */
+		function isInteractive(element) {
+			return ~$.inArray(element.nodeName, interactiveElements) || $(element).is(o.interactive);
+		}
+
+		/**
+		 * Continuous movement cleanup on mouseup.
+		 *
+		 * @return {Void}
+		 */
+		function movementReleaseHandler() {
+			self.stop();
+			$doc.off('mouseup', movementReleaseHandler);
+		}
+
+		/**
+		 * Buttons navigation handler.
+		 *
+		 * @param  {Event} event
+		 *
+		 * @return {Void}
+		 */
+		function buttonsHandler(event) {
+			/*jshint validthis:true */
+			stopDefault(event);
+			switch (this) {
+				case $forwardButton[0]:
+				case $backwardButton[0]:
+					self.moveBy($forwardButton.is(this) ? o.moveBy : -o.moveBy);
+					$doc.on('mouseup', movementReleaseHandler);
+					break;
+
+				case $prevButton[0]:
+					self.prev();
+					break;
+
+				case $nextButton[0]:
+					self.next();
+					break;
+
+				case $prevPageButton[0]:
+					self.prevPage();
+					break;
+
+				case $nextPageButton[0]:
+					self.nextPage();
+					break;
+			}
+		}
+
+		/**
+		 * Mouse wheel delta normalization.
+		 *
+		 * @param  {Event} event
+		 *
+		 * @return {Int}
+		 */
+		function normalizeWheelDelta(event) {
+			// event.deltaY needed only for compatibility with jQuery mousewheel plugin in FF & IE
+			scrolling.curDelta = event.wheelDelta ? -event.wheelDelta / 120 : (event.detail || event.deltaY) / 3;
+			if (!itemNav) {
+				return scrolling.curDelta;
+			}
+			time = +new Date();
+			if (scrolling.last < time - scrolling.resetTime) {
+				scrolling.delta = 0;
+			}
+			scrolling.last = time;
+			scrolling.delta += scrolling.curDelta;
+			if (Math.abs(scrolling.delta) < 1) {
+				scrolling.finalDelta = 0;
+			} else {
+				scrolling.finalDelta = Math.round(scrolling.delta / 1);
+				scrolling.delta %= 1;
+			}
+			return scrolling.finalDelta;
+		}
+
+		/**
+		 * Mouse scrolling handler.
+		 *
+		 * @param  {Event} event
+		 *
+		 * @return {Void}
+		 */
+		function scrollHandler(event) {
+			// Ignore if there is no scrolling to be done
+			if (!o.scrollBy || pos.start === pos.end) {
+				return;
+			}
+			stopDefault(event, 1);
+			self.slideBy(o.scrollBy * normalizeWheelDelta(event.originalEvent));
+		}
+
+		/**
+		 * Scrollbar click handler.
+		 *
+		 * @param  {Event} event
+		 *
+		 * @return {Void}
+		 */
+		function scrollbarHandler(event) {
+			// Only clicks on scroll bar. Ignore the handle.
+			if (o.clickBar && event.target === $sb[0]) {
+				stopDefault(event);
+				// Calculate new handle position and sync SLIDEE to it
+				slideTo(handleToSlidee((o.horizontal ? event.pageX - $sb.offset().left : event.pageY - $sb.offset().top) - handleSize / 2));
+			}
+		}
+
+		/**
+		 * Keyboard input handler.
+		 *
+		 * @param  {Event} event
+		 *
+		 * @return {Void}
+		 */
+		function keyboardHandler(event) {
+			if (!o.keyboardNavBy) {
+				return;
+			}
+
+			switch (event.which) {
+				// Left or Up
+				case o.horizontal ? 37 : 38:
+					stopDefault(event);
+					self[o.keyboardNavBy === 'pages' ? 'prevPage' : 'prev']();
+					break;
+
+				// Right or Down
+				case o.horizontal ? 39 : 40:
+					stopDefault(event);
+					self[o.keyboardNavBy === 'pages' ? 'nextPage' : 'next']();
+					break;
+			}
+		}
+
+		/**
+		 * Click on item activation handler.
+		 *
+		 * @param  {Event} event
+		 *
+		 * @return {Void}
+		 */
+		function activateHandler(event) {
+			/*jshint validthis:true */
+			// Ignore clicks on interactive elements.
+			if (isInteractive(this)) {
+				event.stopPropagation();
+				return;
+			}
+			// Accept only events from direct SLIDEE children.
+			if (this.parentNode === $slidee[0]) {
+				self.activate(this);
+			}
+		}
+
+		/**
+		 * Click on page button handler.
+		 *
+		 * @param {Event} event
+		 *
+		 * @return {Void}
+		 */
+		function activatePageHandler() {
+			/*jshint validthis:true */
+			// Accept only events from direct pages bar children.
+			if (this.parentNode === $pb[0]) {
+				self.activatePage($pages.index(this));
+			}
+		}
+
+		/**
+		 * Pause on hover handler.
+		 *
+		 * @param  {Event} event
+		 *
+		 * @return {Void}
+		 */
+		function pauseOnHoverHandler(event) {
+			if (o.pauseOnHover) {
+				self[event.type === 'mouseenter' ? 'pause' : 'resume'](2);
+			}
+		}
+
+		/**
+		 * Trigger callbacks for event.
+		 *
+		 * @param  {String} name Event name.
+		 * @param  {Mixed}  argX Arguments passed to callbacks.
+		 *
+		 * @return {Void}
+		 */
+		function trigger(name, arg1) {
+			if (callbacks[name]) {
+				l = callbacks[name].length;
+				// Callbacks will be stored and executed from a temporary array to not
+				// break the execution queue when one of the callbacks unbinds itself.
+				tmpArray.length = 0;
+				for (i = 0; i < l; i++) {
+					tmpArray.push(callbacks[name][i]);
+				}
+				// Execute the callbacks
+				for (i = 0; i < l; i++) {
+					tmpArray[i].call(self, name, arg1);
+				}
+			}
+		}
+
+		/**
+		 * Destroys instance and everything it created.
+		 *
+		 * @return {Void}
+		 */
+		self.destroy = function () {
+			// Unbind all events
+			$doc
+				.add($scrollSource)
+				.add($handle)
+				.add($sb)
+				.add($pb)
+				.add($forwardButton)
+				.add($backwardButton)
+				.add($prevButton)
+				.add($nextButton)
+				.add($prevPageButton)
+				.add($nextPageButton)
+				.unbind('.' + namespace);
+
+			// Remove classes
+			$prevButton
+				.add($nextButton)
+				.add($prevPageButton)
+				.add($nextPageButton)
+				.removeClass(o.disabledClass);
+
+			if ($items) {
+				$items.eq(rel.activeItem).removeClass(o.activeClass);
+			}
+
+			// Remove page items
+			$pb.empty();
+
+			if (!parallax) {
+				// Unbind events from frame
+				$frame.unbind('.' + namespace);
+				// Reset SLIDEE and handle positions
+				$slidee.add($handle).css(transform || (o.horizontal ? 'left' : 'top'), transform ? 'none' : 0);
+				// Remove the instance from element data storage
+				$.removeData(frame, namespace);
+			}
+
+			// Reset initialized status and return the instance
+			self.initialized = 0;
+			return self;
+		};
+
+		/**
+		 * Initialize.
+		 *
+		 * @return {Object}
+		 */
+		self.init = function () {
+			if (self.initialized) {
+				return;
+			}
+
+			// Register callbacks map
+			self.on(callbackMap);
+
+			// Set required styles
+			var $movables = $handle;
+			if (!parallax) {
+				$movables = $movables.add($slidee);
+				$frame.css('overflow', 'hidden');
+				if (!transform && $frame.css('position') === 'static') {
+					$frame.css('position', 'relative');
+				}
+			}
+			if (transform) {
+				if (gpuAcceleration) {
+					$movables.css(transform, gpuAcceleration);
+				}
+			} else {
+				if ($sb.css('position') === 'static') {
+					$sb.css('position', 'relative');
+				}
+				$movables.css({ position: 'absolute' });
+			}
+
+			// Navigation buttons
+			if (o.forward) {
+				$forwardButton.on(mouseDownEvent, buttonsHandler);
+			}
+			if (o.backward) {
+				$backwardButton.on(mouseDownEvent, buttonsHandler);
+			}
+			if (o.prev) {
+				$prevButton.on(clickEvent, buttonsHandler);
+			}
+			if (o.next) {
+				$nextButton.on(clickEvent, buttonsHandler);
+			}
+			if (o.prevPage) {
+				$prevPageButton.on(clickEvent, buttonsHandler);
+			}
+			if (o.nextPage) {
+				$nextPageButton.on(clickEvent, buttonsHandler);
+			}
+
+			// Scrolling navigation
+			$scrollSource.on('DOMMouseScroll.' + namespace + ' mousewheel.' + namespace, scrollHandler);
+
+			// Clicking on scrollbar navigation
+			if ($sb[0]) {
+				$sb.on(clickEvent, scrollbarHandler);
+			}
+
+			// Click on items navigation
+			if (itemNav && o.activateOn) {
+				$frame.on(o.activateOn + '.' + namespace, '*', activateHandler);
+			}
+
+			// Pages navigation
+			if ($pb[0] && o.activatePageOn) {
+				$pb.on(o.activatePageOn + '.' + namespace, '*', activatePageHandler);
+			}
+
+			// Dragging navigation
+			$dragSource.on(dragInitEvents, { source: 'slidee' }, dragInit);
+
+			// Scrollbar dragging navigation
+			if ($handle) {
+				$handle.on(dragInitEvents, { source: 'handle' }, dragInit);
+			}
+
+			// Keyboard navigation
+			$doc.bind('keydown.' + namespace, keyboardHandler);
+
+			if (!parallax) {
+				// Pause on hover
+				$frame.on('mouseenter.' + namespace + ' mouseleave.' + namespace, pauseOnHoverHandler);
+				// Reset native FRAME element scroll
+				$frame.on('scroll.' + namespace, resetScroll);
+			}
+
+			// Load
+			load();
+
+			// Initiate automatic cycling
+			if (o.cycleBy && !parallax) {
+				self[o.startPaused ? 'pause' : 'resume']();
+			}
+
+			// Mark instance as initialized
+			self.initialized = 1;
+
+			// Return instance
+			return self;
+		};
+	}
+
+	/**
+	 * Return type of the value.
+	 *
+	 * @param  {Mixed} value
+	 *
+	 * @return {String}
+	 */
+	function type(value) {
+		if (value == null) {
+			return String(value);
+		}
+
+		if (typeof value === 'object' || typeof value === 'function') {
+			return Object.prototype.toString.call(value).match(/\s([a-z]+)/i)[1].toLowerCase() || 'object';
+		}
+
+		return typeof value;
+	}
+
+	/**
+	 * Event preventDefault & stopPropagation helper.
+	 *
+	 * @param {Event} event     Event object.
+	 * @param {Bool}  noBubbles Cancel event bubbling.
+	 *
+	 * @return {Void}
+	 */
+	function stopDefault(event, noBubbles) {
+		event.preventDefault();
+		if (noBubbles) {
+			event.stopPropagation();
+		}
+	}
+
+	/**
+	 * Disables an event it was triggered on and unbinds itself.
+	 *
+	 * @param  {Event} event
+	 *
+	 * @return {Void}
+	 */
+	function disableOneEvent(event) {
+		/*jshint validthis:true */
+		stopDefault(event, 1);
+		$(this).off(event.type, disableOneEvent);
+	}
+
+	/**
+	 * Resets native element scroll values to 0.
+	 *
+	 * @return {Void}
+	 */
+	function resetScroll() {
+		/*jshint validthis:true */
+		this.scrollLeft = 0;
+		this.scrollTop = 0;
+	}
+
+	/**
+	 * Check if variable is a number.
+	 *
+	 * @param {Mixed} value
+	 *
+	 * @return {Boolean}
+	 */
+	function isNumber(value) {
+		return !isNaN(parseFloat(value)) && isFinite(value);
+	}
+
+	/**
+	 * Parse style to pixels.
+	 *
+	 * @param {Object}   $item    jQuery object with element.
+	 * @param {Property} property CSS property to get the pixels from.
+	 *
+	 * @return {Int}
+	 */
+	function getPx($item, property) {
+		return 0 | Math.round(String($item.css(property)).replace(/[^\-0-9.]/g, ''));
+	}
+
+	/**
+	 * Make sure that number is within the limits.
+	 *
+	 * @param {Number} number
+	 * @param {Number} min
+	 * @param {Number} max
+	 *
+	 * @return {Number}
+	 */
+	function within(number, min, max) {
+		return number < min ? min : number > max ? max : number;
+	}
+
+	// Local WindowAnimationTiming interface polyfill
+	(function (w) {
+		var vendors = ['moz', 'webkit', 'o'];
+		var lastTime = 0;
+
+		// For a more accurate WindowAnimationTiming interface implementation, ditch the native
+		// requestAnimationFrame when cancelAnimationFrame is not present (older versions of Firefox)
+		for(var i = 0, l = vendors.length; i < l && !cAF; ++i) {
+			cAF = w[vendors[i]+'CancelAnimationFrame'] || w[vendors[i]+'CancelRequestAnimationFrame'];
+			rAF = cAF && w[vendors[i]+'RequestAnimationFrame'];
+		}
+
+		if (!cAF) {
+			rAF = function (callback) {
+				var currTime = +new Date();
+				var timeToCall = Math.max(0, 16 - (currTime - lastTime));
+				lastTime = currTime + timeToCall;
+				return w.setTimeout(function () { callback(currTime + timeToCall); }, timeToCall);
+			};
+
+			cAF = function (id) {
+				clearTimeout(id);
+			};
+		}
+	}(window));
+
+	// Feature detects
+	(function () {
+		var prefixes = ['', 'webkit', 'moz', 'ms', 'o'];
+		var el = document.createElement('div');
+
+		function testProp(prop) {
+			for (var p = 0, pl = prefixes.length; p < pl; p++) {
+				var prefixedProp = prefixes[p] ? prefixes[p] + prop.charAt(0).toUpperCase() + prop.slice(1) : prop;
+				if (el.style[prefixedProp] != null) {
+					return prefixedProp;
+				}
+			}
+		}
+
+		// Global support indicators
+		transform = testProp('transform');
+		gpuAcceleration = testProp('perspective') ? 'translateZ(0) ' : '';
+	}());
+
+	// Expose class globally
+	w[className] = Sly;
+
+	// jQuery proxy
+	$.fn[pluginName] = function (options, callbackMap) {
+		var method, methodArgs;
+
+		// Attributes logic
+		if (!$.isPlainObject(options)) {
+			if (type(options) === 'string' || options === false) {
+				method = options === false ? 'destroy' : options;
+				methodArgs = Array.prototype.slice.call(arguments, 1);
+			}
+			options = {};
+		}
+
+		// Apply to all elements
+		return this.each(function (i, element) {
+			// Call with prevention against multiple instantiations
+			var plugin = $.data(element, namespace);
+
+			if (!plugin && !method) {
+				// Create a new object if it doesn't exist yet
+				plugin = $.data(element, namespace, new Sly(element, options, callbackMap).init());
+			} else if (plugin && method) {
+				// Call method
+				if (plugin[method]) {
+					plugin[method].apply(plugin, methodArgs);
+				}
+			}
+		});
+	};
+
+	// Default options
+	Sly.defaults = {
+		horizontal: 0, // Switch to horizontal mode.
+
+		// Item based navigation
+		itemNav:      null, // Item navigation type. Can be: 'basic', 'centered', 'forceCentered'.
+		itemSelector: null, // Select only items that match this selector.
+		smart:        0,    // Repositions the activated item to help with further navigation.
+		activateOn:   null, // Activate an item on this event. Can be: 'click', 'mouseenter', ...
+		activateMiddle: 0,  // Always activate the item in the middle of the FRAME. forceCentered only.
+
+		// Scrolling
+		scrollSource: null, // Element for catching the mouse wheel scrolling. Default is FRAME.
+		scrollBy:     0,    // Pixels or items to move per one mouse scroll. 0 to disable scrolling.
+
+		// Dragging
+		dragSource:    null, // Selector or DOM element for catching dragging events. Default is FRAME.
+		mouseDragging: 0,    // Enable navigation by dragging the SLIDEE with mouse cursor.
+		touchDragging: 0,    // Enable navigation by dragging the SLIDEE with touch events.
+		releaseSwing:  0,    // Ease out on dragging swing release.
+		swingSpeed:    0.2,  // Swing synchronization speed, where: 1 = instant, 0 = infinite.
+		elasticBounds: 0,    // Stretch SLIDEE position limits when dragging past FRAME boundaries.
+		interactive:   null, // Selector for special interactive elements.
+
+		// Scrollbar
+		scrollBar:     null, // Selector or DOM element for scrollbar container.
+		dragHandle:    0,    // Whether the scrollbar handle should be draggable.
+		dynamicHandle: 0,    // Scrollbar handle represents the ratio between hidden and visible content.
+		minHandleSize: 50,   // Minimal height or width (depends on sly direction) of a handle in pixels.
+		clickBar:      0,    // Enable navigation by clicking on scrollbar.
+		syncSpeed:     0.5,  // Handle => SLIDEE synchronization speed, where: 1 = instant, 0 = infinite.
+
+		// Pagesbar
+		pagesBar:       null, // Selector or DOM element for pages bar container.
+		activatePageOn: null, // Event used to activate page. Can be: click, mouseenter, ...
+		pageBuilder:          // Page item generator.
+			function (index) {
+				return '<li>' + (index + 1) + '</li>';
+			},
+
+		// Navigation buttons
+		forward:  null, // Selector or DOM element for "forward movement" button.
+		backward: null, // Selector or DOM element for "backward movement" button.
+		prev:     null, // Selector or DOM element for "previous item" button.
+		next:     null, // Selector or DOM element for "next item" button.
+		prevPage: null, // Selector or DOM element for "previous page" button.
+		nextPage: null, // Selector or DOM element for "next page" button.
+
+		// Automated cycling
+		cycleBy:       null, // Enable automatic cycling by 'items' or 'pages'.
+		cycleInterval: 5000, // Delay between cycles in milliseconds.
+		pauseOnHover:  0,    // Pause cycling when mouse hovers over the FRAME.
+		startPaused:   0,    // Whether to start in paused sate.
+
+		// Mixed options
+		moveBy:        300,     // Speed in pixels per second used by forward and backward buttons.
+		speed:         0,       // Animations speed in milliseconds. 0 to disable animations.
+		easing:        'swing', // Easing for duration based (tweening) animations.
+		startAt:       0,       // Starting offset in pixels or items.
+		keyboardNavBy: null,    // Enable keyboard navigation by 'items' or 'pages'.
+
+		// Classes
+		draggedClass:  'dragged',  // Class for dragged elements (like SLIDEE or scrollbar handle).
+		activeClass:   'active',   // Class for active items and pages.
+		disabledClass: 'disabled'  // Class for disabled navigation elements.
+	};
+}(jQuery, window));
\ No newline at end of file
diff --git a/ajax/libs/Sly/1.2.1/sly.min.js b/ajax/libs/Sly/1.2.1/sly.min.js
new file mode 100644
index 000000000..1556d7ba2
--- /dev/null
+++ b/ajax/libs/Sly/1.2.1/sly.min.js
@@ -0,0 +1,34 @@
+/*! sly 1.2.1 - 12th Nov 2013 | https://github.com/Darsain/sly */
+(function(l,B,Ba){function la(f,k,Va){var z,R,qa,s,ra,B,sa,ma;function aa(){var b=0,h=w.length;e.old=l.extend({},e);y=H?0:E[c.horizontal?"width":"height"]();S=K[c.horizontal?"width":"height"]();t=H?f:u[c.horizontal?"outerWidth":"outerHeight"]();w.length=0;e.start=0;e.end=Math.max(t-y,0);if(C){b=n.length;F=u.children(c.itemSelector);n.length=0;var a=na(u,c.horizontal?"paddingLeft":"paddingTop"),ta=na(u,c.horizontal?"paddingRight":"paddingBottom"),k="border-box"===l(F).css("boxSizing"),m="none"!==F.css("float"),
+s=0,r=F.length-1,z;t=0;F.each(function(b,h){var d=l(h),e=d[c.horizontal?"outerWidth":"outerHeight"](),f=na(d,c.horizontal?"marginLeft":"marginTop"),d=na(d,c.horizontal?"marginRight":"marginBottom"),g=e+f+d,p=!f||!d,k={};k.el=h;k.size=p?e:g;k.half=k.size/2;k.start=t+(p?f:0);k.center=k.start-Math.round(y/2-k.size/2);k.end=k.start-y+k.size;b||(t+=a);t+=g;c.horizontal||m||d&&(f&&0<b)&&(t-=Math.min(f,d));b===r&&(k.end+=ta,t+=ta,s=p?d:0);n.push(k);z=k});u[0].style[c.horizontal?"width":"height"]=(k?t:t-
+a-ta)+"px";t-=s;n.length?(e.start=n[0][T?"center":"start"],e.end=T?z.center:y<t?z.end:e.start):e.start=e.end=0}e.center=Math.round(e.end/2+e.start/2);l.extend(g,ua(void 0));D.length&&0<S&&(c.dynamicHandle?(N=e.start===e.end?S:Math.round(S*y/t),N=v(N,c.minHandleSize,S),D[0].style[c.horizontal?"width":"height"]=N+"px"):N=D[c.horizontal?"outerWidth":"outerHeight"](),q.end=S-N,U||Ca());if(!H&&0<y){var p=e.start,k="";if(C)l.each(n,function(b,h){T?w.push(h.center):h.start+h.size>p&&p<=e.end&&(p=h.start,
+w.push(p),p+=y,p>e.end&&p<e.end+y&&w.push(e.end))});else for(;p-y<e.end;)w.push(p),p+=y;if(V[0]&&h!==w.length){for(h=0;h<w.length;h++)k+=c.pageBuilder.call(d,h);ga=V.html(k).children();ga.eq(g.activePage).addClass(c.activeClass)}}g.slideeSize=t;g.frameSize=y;g.sbSize=S;g.handleSize=N;C?(d.initialized?(g.activeItem>=n.length||0===b&&0<n.length)&&oa(g.activeItem>=n.length?n.length-1:0,!b):(oa(c.startAt),d[L?"toCenter":"toStart"](c.startAt)),I(L&&n.length?n[g.activeItem].center:v(e.dest,e.start,e.end))):
+d.initialized?I(v(e.dest,e.start,e.end)):I(c.startAt,1);A("load")}function I(b,h,fa){if(C&&a.released&&!fa){fa=ua(b);var f=b>e.start&&b<e.end;L?(f&&(b=n[fa.centerItem].center),T&&c.activateMiddle&&oa(fa.centerItem)):f&&(b=n[fa.firstItem].start)}a.init&&a.slidee&&c.elasticBounds?b>e.end?b=e.end+(b-e.end)/6:b<e.start&&(b=e.start+(b-e.start)/6):b=v(b,e.start,e.end);z=+new Date;R=0;qa=e.cur;s=b;ra=b-e.cur;B=a.tweese||a.init&&!a.slidee;sa=!B&&(h||a.init&&a.slidee||!c.speed);a.tweese=0;b!==e.dest&&(e.dest=
+b,A("change"),U||va());a.released&&!d.isPaused&&d.resume();l.extend(g,ua(void 0));Da();ga[0]&&r.page!==g.activePage&&(r.page=g.activePage,ga.removeClass(c.activeClass).eq(g.activePage).addClass(c.activeClass),A("activePage",r.page))}function va(){U?(sa?e.cur=s:B?(ma=s-e.cur,0.1>Math.abs(ma)?e.cur=s:e.cur+=ma*(a.released?c.swingSpeed:c.syncSpeed)):(R=Math.min(+new Date-z,c.speed),e.cur=qa+ra*jQuery.easing[c.easing](R/c.speed,R,0,1,c.speed)),s===e.cur?(e.cur=s,a.tweese=U=0):U=ha(va),A("move"),H||(J?
+u[0].style[J]=ia+(c.horizontal?"translateX":"translateY")+"("+-e.cur+"px)":u[0].style[c.horizontal?"left":"top"]=-Math.round(e.cur)+"px"),!U&&a.released&&A("moveEnd"),Ca()):(U=ha(va),a.released&&A("moveStart"))}function Ca(){D.length&&(q.cur=e.start===e.end?0:((a.init&&!a.slidee?e.dest:e.cur)-e.start)/(e.end-e.start)*q.end,q.cur=v(Math.round(q.cur),q.start,q.end),r.hPos!==q.cur&&(r.hPos=q.cur,J?D[0].style[J]=ia+(c.horizontal?"translateX":"translateY")+"("+q.cur+"px)":D[0].style[c.horizontal?"left":
+"top"]=q.cur+"px"))}function Ea(){p.speed&&e.cur!==(0<p.speed?e.end:e.start)||d.stop();Fa=a.init?ha(Ea):0;p.now=+new Date;p.pos=e.cur+(p.now-p.lastTime)/1E3*p.speed;I(a.init?p.pos:Math.round(p.pos));a.init||e.cur!==e.dest||A("moveEnd");p.lastTime=p.now}function wa(b,h,a){"boolean"===ja(h)&&(a=h,h=Ba);h===Ba?I(e[b],a):L&&"center"!==b||(h=d.getPos(h))&&I(h[b],a,!L)}function pa(b){return null!=b?O(b)?0<=b&&b<n.length?b:-1:F.index(b):-1}function xa(b){return pa(O(b)&&0>b?b+n.length:b)}function oa(b,h){var a=
+pa(b);if(!C||0>a)return!1;if(r.active!==a||h)F.eq(g.activeItem).removeClass(c.activeClass),F.eq(a).addClass(c.activeClass),r.active=g.activeItem=a,Da(),A("active",a);return a}function ua(b){b=v(O(b)?b:e.dest,e.start,e.end);var h={},a=T?0:y/2;if(!H)for(var c=0,d=w.length;c<d;c++){if(b>=e.end||c===w.length-1){h.activePage=w.length-1;break}if(b<=w[c]+a){h.activePage=c;break}}if(C){for(var d=c=a=!1,f=0,g=n.length;f<g;f++)if(!1===a&&b<=n[f].start+n[f].half&&(a=f),!1===d&&b<=n[f].center+n[f].half&&(d=f),
+f===g-1||b<=n[f].end+n[f].half){c=f;break}h.firstItem=O(a)?a:0;h.centerItem=O(d)?d:h.firstItem;h.lastItem=O(c)?c:h.centerItem}return h}function Da(){var b=e.dest<=e.start,h=e.dest>=e.end,d=b?1:h?2:3;r.slideePosState!==d&&(r.slideePosState=d,W.is("button,input")&&W.prop("disabled",b),X.is("button,input")&&X.prop("disabled",h),W.add(ba)[b?"addClass":"removeClass"](c.disabledClass),X.add(Y)[h?"addClass":"removeClass"](c.disabledClass));r.fwdbwdState!==d&&a.released&&(r.fwdbwdState=d,ba.is("button,input")&&
+ba.prop("disabled",b),Y.is("button,input")&&Y.prop("disabled",h));C&&(b=0===g.activeItem,h=g.activeItem>=n.length-1,d=b?1:h?2:3,r.itemsButtonState!==d&&(r.itemsButtonState=d,Z.is("button,input")&&Z.prop("disabled",b),$.is("button,input")&&$.prop("disabled",h),Z[b?"addClass":"removeClass"](c.disabledClass),$[h?"addClass":"removeClass"](c.disabledClass)))}function Ga(b,a,c){b=xa(b);a=xa(a);if(-1<b&&-1<a&&b!==a&&!(c&&a===b-1||!c&&a===b+1)){F.eq(b)[c?"insertAfter":"insertBefore"](n[a].el);var d=b<a?b:
+c?a:a-1,e=b>a?b:c?a+1:a,f=b>a;b===g.activeItem?r.active=g.activeItem=c?f?a+1:a:f?a:a-1:g.activeItem>d&&g.activeItem<e&&(r.active=g.activeItem+=f?1:-1);aa()}}function Ha(b,a){for(var c=0,d=G[b].length;c<d;c++)if(G[b][c]===a)return c;return-1}function Ia(b){return Math.round(v(b,q.start,q.end)/q.end*(e.end-e.start))+e.start}function Wa(){a.history[0]=a.history[1];a.history[1]=a.history[2];a.history[2]=a.history[3];a.history[3]=a.delta}function Ja(b){a.released=0;a.source=b;a.slidee="slidee"===b}function Ka(b){if(!(a.init||
+~l.inArray(b.target.nodeName,La)||l(b.target).is(c.interactive))){var h="touchstart"===b.type,f=b.data.source,g="slidee"===f;if("handle"!==f||c.dragHandle&&q.start!==q.end)if(!g||(h?c.touchDragging:c.mouseDragging&&2>b.which))h||M(b,1),Ja(f),a.init=1,a.$source=l(b.target),a.touch=h,a.pointer=h?b.originalEvent.touches[0]:b,a.initX=a.pointer.pageX,a.initY=a.pointer.pageY,a.initPos=g?e.cur:q.cur,a.start=+new Date,a.time=0,a.path=0,a.delta=0,a.locked=0,a.history=[0,0,0,0],a.pathToLock=g?h?30:10:0,a.initLoc=
+a[c.horizontal?"initX":"initY"],a.deltaMin=g?-a.initLoc:-q.cur,a.deltaMax=g?document[c.horizontal?"width":"height"]-a.initLoc:q.end-q.cur,ca.on(h?Ma:Na,Oa),d.pause(1),(g?u:D).addClass(c.draggedClass),A("moveStart"),g&&(Pa=setInterval(Wa,10))}}function Oa(b){a.released="mouseup"===b.type||"touchend"===b.type;a.pointer=a.touch?b.originalEvent[a.released?"changedTouches":"touches"][0]:b;a.pathX=a.pointer.pageX-a.initX;a.pathY=a.pointer.pageY-a.initY;a.path=Math.sqrt(Math.pow(a.pathX,2)+Math.pow(a.pathY,
+2));a.delta=v(c.horizontal?a.pathX:a.pathY,a.deltaMin,a.deltaMax);if(!a.locked&&a.path>a.pathToLock)if(a.locked=1,c.horizontal?Math.abs(a.pathX)<Math.abs(a.pathY):Math.abs(a.pathX)>Math.abs(a.pathY))a.released=1;else if(a.slidee)a.$source.on(da,Qa);a.released?(a.touch||M(b),clearInterval(Pa),ca.off(a.touch?Ma:Na,Oa),(a.slidee?u:D).removeClass(c.draggedClass),d.resume(1),e.cur===e.dest&&a.init&&A("moveEnd"),a.init=0,c.releaseSwing&&a.slidee&&(a.swing=300*((a.delta-a.history[0])/40),a.delta+=a.swing,
+a.tweese=10<Math.abs(a.swing))):M(b);I(a.slidee?Math.round(a.initPos-a.delta):Ia(a.initPos+a.delta))}function Ra(){d.stop();ca.off("mouseup",Ra)}function ea(b){M(b);switch(this){case Y[0]:case ba[0]:d.moveBy(Y.is(this)?c.moveBy:-c.moveBy);ca.on("mouseup",Ra);break;case Z[0]:d.prev();break;case $[0]:d.next();break;case W[0]:d.prevPage();break;case X[0]:d.nextPage()}}function Xa(b){x.curDelta=b.wheelDelta?-b.wheelDelta/120:(b.detail||b.deltaY)/3;if(!C)return x.curDelta;ya=+new Date;x.last<ya-x.resetTime&&
+(x.delta=0);x.last=ya;x.delta+=x.curDelta;1>Math.abs(x.delta)?x.finalDelta=0:(x.finalDelta=Math.round(x.delta/1),x.delta%=1);return x.finalDelta}function Ya(b){c.scrollBy&&e.start!==e.end&&(M(b,1),d.slideBy(c.scrollBy*Xa(b.originalEvent)))}function Za(b){c.clickBar&&b.target===K[0]&&(M(b),I(Ia((c.horizontal?b.pageX-K.offset().left:b.pageY-K.offset().top)-N/2)))}function $a(b){if(c.keyboardNavBy)switch(b.which){case c.horizontal?37:38:M(b);d["pages"===c.keyboardNavBy?"prevPage":"prev"]();break;case c.horizontal?
+39:40:M(b),d["pages"===c.keyboardNavBy?"nextPage":"next"]()}}function ab(b){~l.inArray(this.nodeName,La)||l(this).is(c.interactive)?b.stopPropagation():this.parentNode===u[0]&&d.activate(this)}function bb(){this.parentNode===V[0]&&d.activatePage(ga.index(this))}function cb(b){if(c.pauseOnHover)d["mouseenter"===b.type?"pause":"resume"](2)}function A(b,a){if(G[b]){za=G[b].length;for(P=Aa.length=0;P<za;P++)Aa.push(G[b][P]);for(P=0;P<za;P++)Aa[P].call(d,b,a)}}var c=l.extend({},la.defaults,k),d=this,H=
+O(f),E=l(f),u=E.children().eq(0),y=0,t=0,e={start:0,center:0,end:0,cur:0,dest:0},K=l(c.scrollBar).eq(0),D=K.children().eq(0),S=0,N=0,q={start:0,end:0,cur:0},V=l(c.pagesBar),ga=0,w=[],F=0,n=[],g={firstItem:0,lastItem:0,centerItem:0,activeItem:-1,activePage:0};k="basic"===c.itemNav;var T="forceCentered"===c.itemNav,L="centered"===c.itemNav||T,C=!H&&(k||L||T),Sa=c.scrollSource?l(c.scrollSource):E,db=c.dragSource?l(c.dragSource):E,Y=l(c.forward),ba=l(c.backward),Z=l(c.prev),$=l(c.next),W=l(c.prevPage),
+X=l(c.nextPage),G={},r={};ma=sa=B=ra=s=qa=R=z=void 0;var p={},a={released:1},x={last:0,delta:0,resetTime:200},U=0,Pa=0,Q=0,Fa=0,P,za;H||(f=E[0]);d.initialized=0;d.frame=f;d.slidee=u[0];d.pos=e;d.rel=g;d.items=n;d.pages=w;d.isPaused=0;d.options=c;d.dragging=a;d.reload=aa;d.getPos=function(b){if(C)return b=pa(b),-1!==b?n[b]:!1;var a=u.find(b).eq(0);return a[0]?(b=c.horizontal?a.offset().left-u.offset().left:a.offset().top-u.offset().top,a=a[c.horizontal?"outerWidth":"outerHeight"](),{start:b,center:b-
+y/2+a/2,end:b-y+a,size:a}):!1};d.moveBy=function(b){p.speed=b;!a.init&&(p.speed&&e.cur!==(0<p.speed?e.end:e.start))&&(p.lastTime=+new Date,p.startPos=e.cur,Ja("button"),a.init=1,A("moveStart"),ka(Fa),Ea())};d.stop=function(){"button"===a.source&&(a.init=0,a.released=1)};d.prev=function(){d.activate(g.activeItem-1)};d.next=function(){d.activate(g.activeItem+1)};d.prevPage=function(){d.activatePage(g.activePage-1)};d.nextPage=function(){d.activatePage(g.activePage+1)};d.slideBy=function(b,a){if(b)if(C)d[L?
+"toCenter":"toStart"](v((L?g.centerItem:g.firstItem)+c.scrollBy*b,0,n.length));else I(e.dest+b,a)};d.slideTo=function(b,a){I(b,a)};d.toStart=function(b,a){wa("start",b,a)};d.toEnd=function(b,a){wa("end",b,a)};d.toCenter=function(b,a){wa("center",b,a)};d.getIndex=pa;d.activate=function(b,e){var f=oa(b);c.smart&&!1!==f&&(L?d.toCenter(f,e):f>=g.lastItem?d.toStart(f,e):f<=g.firstItem?d.toEnd(f,e):a.released&&!d.isPaused&&d.resume())};d.activatePage=function(b,a){O(b)&&I(w[v(b,0,w.length-1)],a)};d.resume=
+function(b){!c.cycleBy||(!c.cycleInterval||"items"===c.cycleBy&&!n[0]||b<d.isPaused)||(d.isPaused=0,Q?Q=clearTimeout(Q):A("resume"),Q=setTimeout(function(){A("cycle");switch(c.cycleBy){case "items":d.activate(g.activeItem>=n.length-1?0:g.activeItem+1);break;case "pages":d.activatePage(g.activePage>=w.length-1?0:g.activePage+1)}},c.cycleInterval))};d.pause=function(b){b<d.isPaused||(d.isPaused=b||100,Q&&(Q=clearTimeout(Q),A("pause")))};d.toggle=function(){d[Q?"pause":"resume"]()};d.set=function(b,
+a){l.isPlainObject(b)?l.extend(c,b):c.hasOwnProperty(b)&&(c[b]=a)};d.add=function(b,a){var c=l(b);C?(null!=a&&n[0]?n.length&&c.insertBefore(n[a].el):c.appendTo(u),a<=g.activeItem&&(r.active=g.activeItem+=c.length)):u.append(c);aa()};d.remove=function(b){if(C){if(b=xa(b),-1<b){F.eq(b).remove();var a=b===g.activeItem;b<g.activeItem&&(r.active=--g.activeItem);aa();a&&(r.active=null,d.activate(g.activeItem))}}else l(b).remove(),aa()};d.moveAfter=function(b,a){Ga(b,a,1)};d.moveBefore=function(b,a){Ga(b,
+a)};d.on=function(b,a){if("object"===ja(b))for(var c in b){if(b.hasOwnProperty(c))d.on(c,b[c])}else if("function"===ja(a)){c=b.split(" ");for(var e=0,f=c.length;e<f;e++)G[c[e]]=G[c[e]]||[],-1===Ha(c[e],a)&&G[c[e]].push(a)}else if("array"===ja(a))for(c=0,e=a.length;c<e;c++)d.on(b,a[c])};d.one=function(b,a){function c(){a.apply(d,arguments);d.off(b,c)}d.on(b,c)};d.off=function(b,a){if(a instanceof Array)for(var c=0,e=a.length;c<e;c++)d.off(b,a[c]);else for(var c=b.split(" "),e=0,f=c.length;e<f;e++)if(G[c[e]]=
+G[c[e]]||[],null==a)G[c[e]].length=0;else{var g=Ha(c[e],a);-1!==g&&G[c[e]].splice(g,1)}};d.destroy=function(){ca.add(Sa).add(D).add(K).add(V).add(Y).add(ba).add(Z).add($).add(W).add(X).unbind("."+m);Z.add($).add(W).add(X).removeClass(c.disabledClass);F&&F.eq(g.activeItem).removeClass(c.activeClass);V.empty();H||(E.unbind("."+m),u.add(D).css(J||(c.horizontal?"left":"top"),J?"none":0),l.removeData(f,m));d.initialized=0;return d};d.init=function(){if(!d.initialized){d.on(Va);var a=D;H||(a=a.add(u),E.css("overflow",
+"hidden"),J||"static"!==E.css("position")||E.css("position","relative"));J?ia&&a.css(J,ia):("static"===K.css("position")&&K.css("position","relative"),a.css({position:"absolute"}));if(c.forward)Y.on(Ta,ea);if(c.backward)ba.on(Ta,ea);if(c.prev)Z.on(da,ea);if(c.next)$.on(da,ea);if(c.prevPage)W.on(da,ea);if(c.nextPage)X.on(da,ea);Sa.on("DOMMouseScroll."+m+" mousewheel."+m,Ya);if(K[0])K.on(da,Za);if(C&&c.activateOn)E.on(c.activateOn+"."+m,"*",ab);if(V[0]&&c.activatePageOn)V.on(c.activatePageOn+"."+m,
+"*",bb);db.on(Ua,{source:"slidee"},Ka);if(D)D.on(Ua,{source:"handle"},Ka);ca.bind("keydown."+m,$a);H||(E.on("mouseenter."+m+" mouseleave."+m,cb),E.on("scroll."+m,eb));aa();if(c.cycleBy&&!H)d[c.startPaused?"pause":"resume"]();d.initialized=1;return d}}}function ja(f){return null==f?String(f):"object"===typeof f||"function"===typeof f?Object.prototype.toString.call(f).match(/\s([a-z]+)/i)[1].toLowerCase()||"object":typeof f}function M(f,k){f.preventDefault();k&&f.stopPropagation()}function Qa(f){M(f,
+1);l(this).off(f.type,Qa)}function eb(){this.scrollTop=this.scrollLeft=0}function O(f){return!isNaN(parseFloat(f))&&isFinite(f)}function na(f,k){return 0|Math.round(String(f.css(k)).replace(/[^\-0-9.]/g,""))}function v(f,k,l){return f<k?k:f>l?l:f}var m="sly",ka=B.cancelAnimationFrame||B.cancelRequestAnimationFrame,ha=B.requestAnimationFrame,J,ia,ca=l(document),Ua="touchstart."+m+" mousedown."+m,Na="mousemove."+m+" mouseup."+m,Ma="touchmove."+m+" touchend."+m,da="click."+m,Ta="mousedown."+m,La=["INPUT",
+"SELECT","BUTTON","TEXTAREA"],Aa=[],ya;(function(f){for(var k=["moz","webkit","o"],l=0,m=0,R=k.length;m<R&&!ka;++m)ha=(ka=f[k[m]+"CancelAnimationFrame"]||f[k[m]+"CancelRequestAnimationFrame"])&&f[k[m]+"RequestAnimationFrame"];ka||(ha=function(k){var m=+new Date,z=Math.max(0,16-(m-l));l=m+z;return f.setTimeout(function(){k(m+z)},z)},ka=function(f){clearTimeout(f)})})(window);(function(){function f(f){for(var m=0,v=k.length;m<v;m++){var s=k[m]?k[m]+f.charAt(0).toUpperCase()+f.slice(1):f;if(null!=l.style[s])return s}}
+var k=["","webkit","moz","ms","o"],l=document.createElement("div");J=f("transform");ia=f("perspective")?"translateZ(0) ":""})();B.Sly=la;l.fn.sly=function(f,k){var v,z;if(!l.isPlainObject(f)){if("string"===ja(f)||!1===f)v=!1===f?"destroy":f,z=Array.prototype.slice.call(arguments,1);f={}}return this.each(function(J,B){var s=l.data(B,m);s||v?s&&v&&s[v]&&s[v].apply(s,z):l.data(B,m,(new la(B,f,k)).init())})};la.defaults={horizontal:0,itemNav:null,itemSelector:null,smart:0,activateOn:null,activateMiddle:0,
+scrollSource:null,scrollBy:0,dragSource:null,mouseDragging:0,touchDragging:0,releaseSwing:0,swingSpeed:0.2,elasticBounds:0,interactive:null,scrollBar:null,dragHandle:0,dynamicHandle:0,minHandleSize:50,clickBar:0,syncSpeed:0.5,pagesBar:null,activatePageOn:null,pageBuilder:function(f){return"<li>"+(f+1)+"</li>"},forward:null,backward:null,prev:null,next:null,prevPage:null,nextPage:null,cycleBy:null,cycleInterval:5E3,pauseOnHover:0,startPaused:0,moveBy:300,speed:0,easing:"swing",startAt:0,keyboardNavBy:null,
+draggedClass:"dragged",activeClass:"active",disabledClass:"disabled"}})(jQuery,window);
diff --git a/ajax/libs/Sly/package.json b/ajax/libs/Sly/package.json
new file mode 100644
index 000000000..688bebcfd
--- /dev/null
+++ b/ajax/libs/Sly/package.json
@@ -0,0 +1,7 @@
+{
+    "filename": "sly.min.js",
+    "name": "Sly",
+    "version": "1.2.1",
+    "description": "JavaScript library for one-directional scrolling with item based navigation support",
+    "homepage": "http://darsa.in/sly/"
+}