aacinfo-theme 0.2.0 → 2.0.1

data/_sass/foundation-sites/dist/js/plugins/foundation.reveal.min.js

@@ -0,0 +1 @@
+"use strict";function _classCallCheck(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}var _createClass=function(){function e(e,t){for(var i=0;i<t.length;i++){var o=t[i];o.enumerable=o.enumerable||!1,o.configurable=!0,"value"in o&&(o.writable=!0),Object.defineProperty(e,o.key,o)}}return function(t,i,o){return i&&e(t.prototype,i),o&&e(t,o),t}}();!function(e){function t(){return/iP(ad|hone|od).*OS/.test(window.navigator.userAgent)}function i(){return/Android/.test(window.navigator.userAgent)}function o(){return t()||i()}var n=function(){function t(i,o){_classCallCheck(this,t),this.$element=i,this.options=e.extend({},t.defaults,this.$element.data(),o),this._init(),Foundation.registerPlugin(this,"Reveal"),Foundation.Keyboard.register("Reveal",{ENTER:"open",SPACE:"open",ESCAPE:"close"})}return _createClass(t,[{key:"_init",value:function(){this.id=this.$element.attr("id"),this.isActive=!1,this.cached={mq:Foundation.MediaQuery.current},this.isMobile=o(),this.$anchor=e(e('[data-open="'+this.id+'"]').length?'[data-open="'+this.id+'"]':'[data-toggle="'+this.id+'"]'),this.$anchor.attr({"aria-controls":this.id,"aria-haspopup":!0,tabindex:0}),(this.options.fullScreen||this.$element.hasClass("full"))&&(this.options.fullScreen=!0,this.options.overlay=!1),this.options.overlay&&!this.$overlay&&(this.$overlay=this._makeOverlay(this.id)),this.$element.attr({role:"dialog","aria-hidden":!0,"data-yeti-box":this.id,"data-resize":this.id}),this.$overlay?this.$element.detach().appendTo(this.$overlay):(this.$element.detach().appendTo(e(this.options.appendTo)),this.$element.addClass("without-overlay")),this._events(),this.options.deepLink&&window.location.hash==="#"+this.id&&e(window).one("load.zf.reveal",this.open.bind(this))}},{key:"_makeOverlay",value:function(){return e("<div></div>").addClass("reveal-overlay").appendTo(this.options.appendTo)}},{key:"_updatePosition",value:function(){var t,i,o=this.$element.outerWidth(),n=e(window).width(),s=this.$element.outerHeight(),a=e(window).height();t="auto"===this.options.hOffset?parseInt((n-o)/2,10):parseInt(this.options.hOffset,10),i="auto"===this.options.vOffset?s>a?parseInt(Math.min(100,a/10),10):parseInt((a-s)/4,10):parseInt(this.options.vOffset,10),this.$element.css({top:i+"px"}),this.$overlay&&"auto"===this.options.hOffset||(this.$element.css({left:t+"px"}),this.$element.css({margin:"0px"}))}},{key:"_events",value:function(){var t=this,i=this;this.$element.on({"open.zf.trigger":this.open.bind(this),"close.zf.trigger":function(o,n){if(o.target===i.$element[0]||e(o.target).parents("[data-closable]")[0]===n)return t.close.apply(t)},"toggle.zf.trigger":this.toggle.bind(this),"resizeme.zf.trigger":function(){i._updatePosition()}}),this.$anchor.length&&this.$anchor.on("keydown.zf.reveal",function(e){13!==e.which&&32!==e.which||(e.stopPropagation(),e.preventDefault(),i.open())}),this.options.closeOnClick&&this.options.overlay&&this.$overlay.off(".zf.reveal").on("click.zf.reveal",function(t){t.target!==i.$element[0]&&!e.contains(i.$element[0],t.target)&&e.contains(document,t.target)&&i.close()}),this.options.deepLink&&e(window).on("popstate.zf.reveal:"+this.id,this._handleState.bind(this))}},{key:"_handleState",value:function(e){window.location.hash!=="#"+this.id||this.isActive?this.close():this.open()}},{key:"open",value:function(){function t(){n.isMobile?(n.originalScrollPos||(n.originalScrollPos=window.pageYOffset),e("html, body").addClass("is-reveal-open")):e("body").addClass("is-reveal-open")}var i=this;if(this.options.deepLink){var o="#"+this.id;window.history.pushState?window.history.pushState(null,null,o):window.location.hash=o}this.isActive=!0,this.$element.css({visibility:"hidden"}).show().scrollTop(0),this.options.overlay&&this.$overlay.css({visibility:"hidden"}).show(),this._updatePosition(),this.$element.hide().css({visibility:""}),this.$overlay&&(this.$overlay.css({visibility:""}).hide(),this.$element.hasClass("fast")?this.$overlay.addClass("fast"):this.$element.hasClass("slow")&&this.$overlay.addClass("slow")),this.options.multipleOpened||this.$element.trigger("closeme.zf.reveal",this.id);var n=this;this.options.animationIn?!function(){var e=function(){n.$element.attr({"aria-hidden":!1,tabindex:-1}).focus(),t(),Foundation.Keyboard.trapFocus(n.$element)};i.options.overlay&&Foundation.Motion.animateIn(i.$overlay,"fade-in"),Foundation.Motion.animateIn(i.$element,i.options.animationIn,function(){i.$element&&(i.focusableElements=Foundation.Keyboard.findFocusable(i.$element),e())})}():(this.options.overlay&&this.$overlay.show(0),this.$element.show(this.options.showDelay)),this.$element.attr({"aria-hidden":!1,tabindex:-1}).focus(),Foundation.Keyboard.trapFocus(this.$element),this.$element.trigger("open.zf.reveal"),t(),setTimeout(function(){i._extraHandlers()},0)}},{key:"_extraHandlers",value:function(){var t=this;this.$element&&(this.focusableElements=Foundation.Keyboard.findFocusable(this.$element),this.options.overlay||!this.options.closeOnClick||this.options.fullScreen||e("body").on("click.zf.reveal",function(i){i.target!==t.$element[0]&&!e.contains(t.$element[0],i.target)&&e.contains(document,i.target)&&t.close()}),this.options.closeOnEsc&&e(window).on("keydown.zf.reveal",function(e){Foundation.Keyboard.handleKey(e,"Reveal",{close:function(){t.options.closeOnEsc&&(t.close(),t.$anchor.focus())}})}),this.$element.on("keydown.zf.reveal",function(i){var o=e(this);Foundation.Keyboard.handleKey(i,"Reveal",{open:function(){t.$element.find(":focus").is(t.$element.find("[data-close]"))?setTimeout(function(){t.$anchor.focus()},1):o.is(t.focusableElements)&&t.open()},close:function(){t.options.closeOnEsc&&(t.close(),t.$anchor.focus())},handled:function(e){e&&i.preventDefault()}})}))}},{key:"close",value:function(){function t(){i.isMobile?(e("html, body").removeClass("is-reveal-open"),i.originalScrollPos&&(e("body").scrollTop(i.originalScrollPos),i.originalScrollPos=null)):e("body").removeClass("is-reveal-open"),Foundation.Keyboard.releaseFocus(i.$element),i.$element.attr("aria-hidden",!0),i.$element.trigger("closed.zf.reveal")}if(!this.isActive||!this.$element.is(":visible"))return!1;var i=this;this.options.animationOut?(this.options.overlay?Foundation.Motion.animateOut(this.$overlay,"fade-out",t):t(),Foundation.Motion.animateOut(this.$element,this.options.animationOut)):(this.options.overlay?this.$overlay.hide(0,t):t(),this.$element.hide(this.options.hideDelay)),this.options.closeOnEsc&&e(window).off("keydown.zf.reveal"),!this.options.overlay&&this.options.closeOnClick&&e("body").off("click.zf.reveal"),this.$element.off("keydown.zf.reveal"),this.options.resetOnClose&&this.$element.html(this.$element.html()),this.isActive=!1,i.options.deepLink&&(window.history.replaceState?window.history.replaceState("",document.title,window.location.href.replace("#"+this.id,"")):window.location.hash="")}},{key:"toggle",value:function(){this.isActive?this.close():this.open()}},{key:"destroy",value:function(){this.options.overlay&&(this.$element.appendTo(e(this.options.appendTo)),this.$overlay.hide().off().remove()),this.$element.hide().off(),this.$anchor.off(".zf"),e(window).off(".zf.reveal:"+this.id),Foundation.unregisterPlugin(this)}}]),t}();n.defaults={animationIn:"",animationOut:"",showDelay:0,hideDelay:0,closeOnClick:!0,closeOnEsc:!0,multipleOpened:!1,vOffset:"auto",hOffset:"auto",fullScreen:!1,btmOffsetPct:10,overlay:!0,resetOnClose:!1,deepLink:!1,appendTo:"body"},Foundation.plugin(n,"Reveal")}(jQuery);

data/_sass/foundation-sites/dist/js/plugins/foundation.slider.js

@@ -0,0 +1,762 @@
+'use strict';
+
+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; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+!function ($) {
+
+  /**
+   * Slider module.
+   * @module foundation.slider
+   * @requires foundation.util.motion
+   * @requires foundation.util.triggers
+   * @requires foundation.util.keyboard
+   * @requires foundation.util.touch
+   */
+
+  var Slider = function () {
+    /**
+     * Creates a new instance of a slider control.
+     * @class
+     * @param {jQuery} element - jQuery object to make into a slider control.
+     * @param {Object} options - Overrides to the default plugin settings.
+     */
+    function Slider(element, options) {
+      _classCallCheck(this, Slider);
+
+      this.$element = element;
+      this.options = $.extend({}, Slider.defaults, this.$element.data(), options);
+
+      this._init();
+
+      Foundation.registerPlugin(this, 'Slider');
+      Foundation.Keyboard.register('Slider', {
+        'ltr': {
+          'ARROW_RIGHT': 'increase',
+          'ARROW_UP': 'increase',
+          'ARROW_DOWN': 'decrease',
+          'ARROW_LEFT': 'decrease',
+          'SHIFT_ARROW_RIGHT': 'increase_fast',
+          'SHIFT_ARROW_UP': 'increase_fast',
+          'SHIFT_ARROW_DOWN': 'decrease_fast',
+          'SHIFT_ARROW_LEFT': 'decrease_fast'
+        },
+        'rtl': {
+          'ARROW_LEFT': 'increase',
+          'ARROW_RIGHT': 'decrease',
+          'SHIFT_ARROW_LEFT': 'increase_fast',
+          'SHIFT_ARROW_RIGHT': 'decrease_fast'
+        }
+      });
+    }
+
+    /**
+     * Initilizes the plugin by reading/setting attributes, creating collections and setting the initial position of the handle(s).
+     * @function
+     * @private
+     */
+
+
+    _createClass(Slider, [{
+      key: '_init',
+      value: function _init() {
+        this.inputs = this.$element.find('input');
+        this.handles = this.$element.find('[data-slider-handle]');
+
+        this.$handle = this.handles.eq(0);
+        this.$input = this.inputs.length ? this.inputs.eq(0) : $('#' + this.$handle.attr('aria-controls'));
+        this.$fill = this.$element.find('[data-slider-fill]').css(this.options.vertical ? 'height' : 'width', 0);
+
+        var isDbl = false,
+            _this = this;
+        if (this.options.disabled || this.$element.hasClass(this.options.disabledClass)) {
+          this.options.disabled = true;
+          this.$element.addClass(this.options.disabledClass);
+        }
+        if (!this.inputs.length) {
+          this.inputs = $().add(this.$input);
+          this.options.binding = true;
+        }
+
+        this._setInitAttr(0);
+
+        if (this.handles[1]) {
+          this.options.doubleSided = true;
+          this.$handle2 = this.handles.eq(1);
+          this.$input2 = this.inputs.length > 1 ? this.inputs.eq(1) : $('#' + this.$handle2.attr('aria-controls'));
+
+          if (!this.inputs[1]) {
+            this.inputs = this.inputs.add(this.$input2);
+          }
+          isDbl = true;
+
+          // this.$handle.triggerHandler('click.zf.slider');
+          this._setInitAttr(1);
+        }
+
+        // Set handle positions
+        this.setHandles();
+
+        this._events();
+      }
+    }, {
+      key: 'setHandles',
+      value: function setHandles() {
+        var _this2 = this;
+
+        if (this.handles[1]) {
+          this._setHandlePos(this.$handle, this.inputs.eq(0).val(), true, function () {
+            _this2._setHandlePos(_this2.$handle2, _this2.inputs.eq(1).val(), true);
+          });
+        } else {
+          this._setHandlePos(this.$handle, this.inputs.eq(0).val(), true);
+        }
+      }
+    }, {
+      key: '_reflow',
+      value: function _reflow() {
+        this.setHandles();
+      }
+      /**
+      * @function
+      * @private
+      * @param {Number} value - floating point (the value) to be transformed using to a relative position on the slider (the inverse of _value)
+      */
+
+    }, {
+      key: '_pctOfBar',
+      value: function _pctOfBar(value) {
+        var pctOfBar = percent(value - this.options.start, this.options.end - this.options.start);
+
+        switch (this.options.positionValueFunction) {
+          case "pow":
+            pctOfBar = this._logTransform(pctOfBar);
+            break;
+          case "log":
+            pctOfBar = this._powTransform(pctOfBar);
+            break;
+        }
+
+        return pctOfBar.toFixed(2);
+      }
+
+      /**
+      * @function
+      * @private
+      * @param {Number} pctOfBar - floating point, the relative position of the slider (typically between 0-1) to be transformed to a value
+      */
+
+    }, {
+      key: '_value',
+      value: function _value(pctOfBar) {
+        switch (this.options.positionValueFunction) {
+          case "pow":
+            pctOfBar = this._powTransform(pctOfBar);
+            break;
+          case "log":
+            pctOfBar = this._logTransform(pctOfBar);
+            break;
+        }
+        var value = (this.options.end - this.options.start) * pctOfBar + this.options.start;
+
+        return value;
+      }
+
+      /**
+      * @function
+      * @private
+      * @param {Number} value - floating point (typically between 0-1) to be transformed using the log function
+      */
+
+    }, {
+      key: '_logTransform',
+      value: function _logTransform(value) {
+        return baseLog(this.options.nonLinearBase, value * (this.options.nonLinearBase - 1) + 1);
+      }
+
+      /**
+      * @function
+      * @private
+      * @param {Number} value - floating point (typically between 0-1) to be transformed using the power function
+      */
+
+    }, {
+      key: '_powTransform',
+      value: function _powTransform(value) {
+        return (Math.pow(this.options.nonLinearBase, value) - 1) / (this.options.nonLinearBase - 1);
+      }
+
+      /**
+       * Sets the position of the selected handle and fill bar.
+       * @function
+       * @private
+       * @param {jQuery} $hndl - the selected handle to move.
+       * @param {Number} location - floating point between the start and end values of the slider bar.
+       * @param {Function} cb - callback function to fire on completion.
+       * @fires Slider#moved
+       * @fires Slider#changed
+       */
+
+    }, {
+      key: '_setHandlePos',
+      value: function _setHandlePos($hndl, location, noInvert, cb) {
+        // don't move if the slider has been disabled since its initialization
+        if (this.$element.hasClass(this.options.disabledClass)) {
+          return;
+        }
+        //might need to alter that slightly for bars that will have odd number selections.
+        location = parseFloat(location); //on input change events, convert string to number...grumble.
+
+        // prevent slider from running out of bounds, if value exceeds the limits set through options, override the value to min/max
+        if (location < this.options.start) {
+          location = this.options.start;
+        } else if (location > this.options.end) {
+          location = this.options.end;
+        }
+
+        var isDbl = this.options.doubleSided;
+
+        if (isDbl) {
+          //this block is to prevent 2 handles from crossing eachother. Could/should be improved.
+          if (this.handles.index($hndl) === 0) {
+            var h2Val = parseFloat(this.$handle2.attr('aria-valuenow'));
+            location = location >= h2Val ? h2Val - this.options.step : location;
+          } else {
+            var h1Val = parseFloat(this.$handle.attr('aria-valuenow'));
+            location = location <= h1Val ? h1Val + this.options.step : location;
+          }
+        }
+
+        //this is for single-handled vertical sliders, it adjusts the value to account for the slider being "upside-down"
+        //for click and drag events, it's weird due to the scale(-1, 1) css property
+        if (this.options.vertical && !noInvert) {
+          location = this.options.end - location;
+        }
+
+        var _this = this,
+            vert = this.options.vertical,
+            hOrW = vert ? 'height' : 'width',
+            lOrT = vert ? 'top' : 'left',
+            handleDim = $hndl[0].getBoundingClientRect()[hOrW],
+            elemDim = this.$element[0].getBoundingClientRect()[hOrW],
+
+        //percentage of bar min/max value based on click or drag point
+        pctOfBar = this._pctOfBar(location),
+
+        //number of actual pixels to shift the handle, based on the percentage obtained above
+        pxToMove = (elemDim - handleDim) * pctOfBar,
+
+        //percentage of bar to shift the handle
+        movement = (percent(pxToMove, elemDim) * 100).toFixed(this.options.decimal);
+        //fixing the decimal value for the location number, is passed to other methods as a fixed floating-point value
+        location = parseFloat(location.toFixed(this.options.decimal));
+        // declare empty object for css adjustments, only used with 2 handled-sliders
+        var css = {};
+
+        this._setValues($hndl, location);
+
+        // TODO update to calculate based on values set to respective inputs??
+        if (isDbl) {
+          var isLeftHndl = this.handles.index($hndl) === 0,
+
+          //empty variable, will be used for min-height/width for fill bar
+          dim,
+
+          //percentage w/h of the handle compared to the slider bar
+          handlePct = ~~(percent(handleDim, elemDim) * 100);
+          //if left handle, the math is slightly different than if it's the right handle, and the left/top property needs to be changed for the fill bar
+          if (isLeftHndl) {
+            //left or top percentage value to apply to the fill bar.
+            css[lOrT] = movement + '%';
+            //calculate the new min-height/width for the fill bar.
+            dim = parseFloat(this.$handle2[0].style[lOrT]) - movement + handlePct;
+            //this callback is necessary to prevent errors and allow the proper placement and initialization of a 2-handled slider
+            //plus, it means we don't care if 'dim' isNaN on init, it won't be in the future.
+            if (cb && typeof cb === 'function') {
+              cb();
+            } //this is only needed for the initialization of 2 handled sliders
+          } else {
+            //just caching the value of the left/bottom handle's left/top property
+            var handlePos = parseFloat(this.$handle[0].style[lOrT]);
+            //calculate the new min-height/width for the fill bar. Use isNaN to prevent false positives for numbers <= 0
+            //based on the percentage of movement of the handle being manipulated, less the opposing handle's left/top position, plus the percentage w/h of the handle itself
+            dim = movement - (isNaN(handlePos) ? (this.options.initialStart - this.options.start) / ((this.options.end - this.options.start) / 100) : handlePos) + handlePct;
+          }
+          // assign the min-height/width to our css object
+          css['min-' + hOrW] = dim + '%';
+        }
+
+        this.$element.one('finished.zf.animate', function () {
+          /**
+           * Fires when the handle is done moving.
+           * @event Slider#moved
+           */
+          _this.$element.trigger('moved.zf.slider', [$hndl]);
+        });
+
+        //because we don't know exactly how the handle will be moved, check the amount of time it should take to move.
+        var moveTime = this.$element.data('dragging') ? 1000 / 60 : this.options.moveTime;
+
+        Foundation.Move(moveTime, $hndl, function () {
+          // adjusting the left/top property of the handle, based on the percentage calculated above
+          // if movement isNaN, that is because the slider is hidden and we cannot determine handle width,
+          // fall back to next best guess.
+          if (isNaN(movement)) {
+            $hndl.css(lOrT, pctOfBar * 100 + '%');
+          } else {
+            $hndl.css(lOrT, movement + '%');
+          }
+
+          if (!_this.options.doubleSided) {
+            //if single-handled, a simple method to expand the fill bar
+            _this.$fill.css(hOrW, pctOfBar * 100 + '%');
+          } else {
+            //otherwise, use the css object we created above
+            _this.$fill.css(css);
+          }
+        });
+
+        /**
+         * Fires when the value has not been change for a given time.
+         * @event Slider#changed
+         */
+        clearTimeout(_this.timeout);
+        _this.timeout = setTimeout(function () {
+          _this.$element.trigger('changed.zf.slider', [$hndl]);
+        }, _this.options.changedDelay);
+      }
+
+      /**
+       * Sets the initial attribute for the slider element.
+       * @function
+       * @private
+       * @param {Number} idx - index of the current handle/input to use.
+       */
+
+    }, {
+      key: '_setInitAttr',
+      value: function _setInitAttr(idx) {
+        var initVal = idx === 0 ? this.options.initialStart : this.options.initialEnd;
+        var id = this.inputs.eq(idx).attr('id') || Foundation.GetYoDigits(6, 'slider');
+        this.inputs.eq(idx).attr({
+          'id': id,
+          'max': this.options.end,
+          'min': this.options.start,
+          'step': this.options.step
+        });
+        this.inputs.eq(idx).val(initVal);
+        this.handles.eq(idx).attr({
+          'role': 'slider',
+          'aria-controls': id,
+          'aria-valuemax': this.options.end,
+          'aria-valuemin': this.options.start,
+          'aria-valuenow': initVal,
+          'aria-orientation': this.options.vertical ? 'vertical' : 'horizontal',
+          'tabindex': 0
+        });
+      }
+
+      /**
+       * Sets the input and `aria-valuenow` values for the slider element.
+       * @function
+       * @private
+       * @param {jQuery} $handle - the currently selected handle.
+       * @param {Number} val - floating point of the new value.
+       */
+
+    }, {
+      key: '_setValues',
+      value: function _setValues($handle, val) {
+        var idx = this.options.doubleSided ? this.handles.index($handle) : 0;
+        this.inputs.eq(idx).val(val);
+        $handle.attr('aria-valuenow', val);
+      }
+
+      /**
+       * Handles events on the slider element.
+       * Calculates the new location of the current handle.
+       * If there are two handles and the bar was clicked, it determines which handle to move.
+       * @function
+       * @private
+       * @param {Object} e - the `event` object passed from the listener.
+       * @param {jQuery} $handle - the current handle to calculate for, if selected.
+       * @param {Number} val - floating point number for the new value of the slider.
+       * TODO clean this up, there's a lot of repeated code between this and the _setHandlePos fn.
+       */
+
+    }, {
+      key: '_handleEvent',
+      value: function _handleEvent(e, $handle, val) {
+        var value, hasVal;
+        if (!val) {
+          //click or drag events
+          e.preventDefault();
+          var _this = this,
+              vertical = this.options.vertical,
+              param = vertical ? 'height' : 'width',
+              direction = vertical ? 'top' : 'left',
+              eventOffset = vertical ? e.pageY : e.pageX,
+              halfOfHandle = this.$handle[0].getBoundingClientRect()[param] / 2,
+              barDim = this.$element[0].getBoundingClientRect()[param],
+              windowScroll = vertical ? $(window).scrollTop() : $(window).scrollLeft();
+
+          var elemOffset = this.$element.offset()[direction];
+
+          // touch events emulated by the touch util give position relative to screen, add window.scroll to event coordinates...
+          // best way to guess this is simulated is if clientY == pageY
+          if (e.clientY === e.pageY) {
+            eventOffset = eventOffset + windowScroll;
+          }
+          var eventFromBar = eventOffset - elemOffset;
+          var barXY;
+          if (eventFromBar < 0) {
+            barXY = 0;
+          } else if (eventFromBar > barDim) {
+            barXY = barDim;
+          } else {
+            barXY = eventFromBar;
+          }
+          var offsetPct = percent(barXY, barDim);
+
+          value = this._value(offsetPct);
+
+          // turn everything around for RTL, yay math!
+          if (Foundation.rtl() && !this.options.vertical) {
+            value = this.options.end - value;
+          }
+
+          value = _this._adjustValue(null, value);
+          //boolean flag for the setHandlePos fn, specifically for vertical sliders
+          hasVal = false;
+
+          if (!$handle) {
+            //figure out which handle it is, pass it to the next function.
+            var firstHndlPos = absPosition(this.$handle, direction, barXY, param),
+                secndHndlPos = absPosition(this.$handle2, direction, barXY, param);
+            $handle = firstHndlPos <= secndHndlPos ? this.$handle : this.$handle2;
+          }
+        } else {
+          //change event on input
+          value = this._adjustValue(null, val);
+          hasVal = true;
+        }
+
+        this._setHandlePos($handle, value, hasVal);
+      }
+
+      /**
+       * Adjustes value for handle in regard to step value. returns adjusted value
+       * @function
+       * @private
+       * @param {jQuery} $handle - the selected handle.
+       * @param {Number} value - value to adjust. used if $handle is falsy
+       */
+
+    }, {
+      key: '_adjustValue',
+      value: function _adjustValue($handle, value) {
+        var val,
+            step = this.options.step,
+            div = parseFloat(step / 2),
+            left,
+            prev_val,
+            next_val;
+        if (!!$handle) {
+          val = parseFloat($handle.attr('aria-valuenow'));
+        } else {
+          val = value;
+        }
+        left = val % step;
+        prev_val = val - left;
+        next_val = prev_val + step;
+        if (left === 0) {
+          return val;
+        }
+        val = val >= prev_val + div ? next_val : prev_val;
+        return val;
+      }
+
+      /**
+       * Adds event listeners to the slider elements.
+       * @function
+       * @private
+       */
+
+    }, {
+      key: '_events',
+      value: function _events() {
+        this._eventsForHandle(this.$handle);
+        if (this.handles[1]) {
+          this._eventsForHandle(this.$handle2);
+        }
+      }
+
+      /**
+       * Adds event listeners a particular handle
+       * @function
+       * @private
+       * @param {jQuery} $handle - the current handle to apply listeners to.
+       */
+
+    }, {
+      key: '_eventsForHandle',
+      value: function _eventsForHandle($handle) {
+        var _this = this,
+            curHandle,
+            timer;
+
+        this.inputs.off('change.zf.slider').on('change.zf.slider', function (e) {
+          var idx = _this.inputs.index($(this));
+          _this._handleEvent(e, _this.handles.eq(idx), $(this).val());
+        });
+
+        if (this.options.clickSelect) {
+          this.$element.off('click.zf.slider').on('click.zf.slider', function (e) {
+            if (_this.$element.data('dragging')) {
+              return false;
+            }
+
+            if (!$(e.target).is('[data-slider-handle]')) {
+              if (_this.options.doubleSided) {
+                _this._handleEvent(e);
+              } else {
+                _this._handleEvent(e, _this.$handle);
+              }
+            }
+          });
+        }
+
+        if (this.options.draggable) {
+          this.handles.addTouch();
+
+          var $body = $('body');
+          $handle.off('mousedown.zf.slider').on('mousedown.zf.slider', function (e) {
+            $handle.addClass('is-dragging');
+            _this.$fill.addClass('is-dragging'); //
+            _this.$element.data('dragging', true);
+
+            curHandle = $(e.currentTarget);
+
+            $body.on('mousemove.zf.slider', function (e) {
+              e.preventDefault();
+              _this._handleEvent(e, curHandle);
+            }).on('mouseup.zf.slider', function (e) {
+              _this._handleEvent(e, curHandle);
+
+              $handle.removeClass('is-dragging');
+              _this.$fill.removeClass('is-dragging');
+              _this.$element.data('dragging', false);
+
+              $body.off('mousemove.zf.slider mouseup.zf.slider');
+            });
+          })
+          // prevent events triggered by touch
+          .on('selectstart.zf.slider touchmove.zf.slider', function (e) {
+            e.preventDefault();
+          });
+        }
+
+        $handle.off('keydown.zf.slider').on('keydown.zf.slider', function (e) {
+          var _$handle = $(this),
+              idx = _this.options.doubleSided ? _this.handles.index(_$handle) : 0,
+              oldValue = parseFloat(_this.inputs.eq(idx).val()),
+              newValue;
+
+          // handle keyboard event with keyboard util
+          Foundation.Keyboard.handleKey(e, 'Slider', {
+            decrease: function () {
+              newValue = oldValue - _this.options.step;
+            },
+            increase: function () {
+              newValue = oldValue + _this.options.step;
+            },
+            decrease_fast: function () {
+              newValue = oldValue - _this.options.step * 10;
+            },
+            increase_fast: function () {
+              newValue = oldValue + _this.options.step * 10;
+            },
+            handled: function () {
+              // only set handle pos when event was handled specially
+              e.preventDefault();
+              _this._setHandlePos(_$handle, newValue, true);
+            }
+          });
+          /*if (newValue) { // if pressed key has special function, update value
+            e.preventDefault();
+            _this._setHandlePos(_$handle, newValue);
+          }*/
+        });
+      }
+
+      /**
+       * Destroys the slider plugin.
+       */
+
+    }, {
+      key: 'destroy',
+      value: function destroy() {
+        this.handles.off('.zf.slider');
+        this.inputs.off('.zf.slider');
+        this.$element.off('.zf.slider');
+
+        clearTimeout(this.timeout);
+
+        Foundation.unregisterPlugin(this);
+      }
+    }]);
+
+    return Slider;
+  }();
+
+  Slider.defaults = {
+    /**
+     * Minimum value for the slider scale.
+     * @option
+     * @type {number}
+     * @default 0
+     */
+    start: 0,
+    /**
+     * Maximum value for the slider scale.
+     * @option
+     * @type {number}
+     * @default 100
+     */
+    end: 100,
+    /**
+     * Minimum value change per change event.
+     * @option
+     * @type {number}
+     * @default 1
+     */
+    step: 1,
+    /**
+     * Value at which the handle/input *(left handle/first input)* should be set to on initialization.
+     * @option
+     * @type {number}
+     * @default 0
+     */
+    initialStart: 0,
+    /**
+     * Value at which the right handle/second input should be set to on initialization.
+     * @option
+     * @type {number}
+     * @default 100
+     */
+    initialEnd: 100,
+    /**
+     * Allows the input to be located outside the container and visible. Set to by the JS
+     * @option
+     * @type {boolean}
+     * @default false
+     */
+    binding: false,
+    /**
+     * Allows the user to click/tap on the slider bar to select a value.
+     * @option
+     * @type {boolean}
+     * @default true
+     */
+    clickSelect: true,
+    /**
+     * Set to true and use the `vertical` class to change alignment to vertical.
+     * @option
+     * @type {boolean}
+     * @default false
+     */
+    vertical: false,
+    /**
+     * Allows the user to drag the slider handle(s) to select a value.
+     * @option
+     * @type {boolean}
+     * @default true
+     */
+    draggable: true,
+    /**
+     * Disables the slider and prevents event listeners from being applied. Double checked by JS with `disabledClass`.
+     * @option
+     * @type {boolean}
+     * @default false
+     */
+    disabled: false,
+    /**
+     * Allows the use of two handles. Double checked by the JS. Changes some logic handling.
+     * @option
+     * @type {boolean}
+     * @default false
+     */
+    doubleSided: false,
+    /**
+     * Potential future feature.
+     */
+    // steps: 100,
+    /**
+     * Number of decimal places the plugin should go to for floating point precision.
+     * @option
+     * @type {number}
+     * @default 2
+     */
+    decimal: 2,
+    /**
+     * Time delay for dragged elements.
+     */
+    // dragDelay: 0,
+    /**
+     * Time, in ms, to animate the movement of a slider handle if user clicks/taps on the bar. Needs to be manually set if updating the transition time in the Sass settings.
+     * @option
+     * @type {number}
+     * @default 200
+     */
+    moveTime: 200, //update this if changing the transition time in the sass
+    /**
+     * Class applied to disabled sliders.
+     * @option
+     * @type {string}
+     * @default 'disabled'
+     */
+    disabledClass: 'disabled',
+    /**
+     * Will invert the default layout for a vertical<span data-tooltip title="who would do this???"> </span>slider.
+     * @option
+     * @type {boolean}
+     * @default false
+     */
+    invertVertical: false,
+    /**
+     * Milliseconds before the `changed.zf-slider` event is triggered after value change.
+     * @option
+     * @type {number}
+     * @default 500
+     */
+    changedDelay: 500,
+    /**
+    * Basevalue for non-linear sliders
+    * @option
+    * @type {number}
+    * @default 5
+    */
+    nonLinearBase: 5,
+    /**
+    * Basevalue for non-linear sliders, possible values are: `'linear'`, `'pow'` & `'log'`. Pow and Log use the nonLinearBase setting.
+    * @option
+    * @type {string}
+    * @default 'linear'
+    */
+    positionValueFunction: 'linear'
+  };
+
+  function percent(frac, num) {
+    return frac / num;
+  }
+  function absPosition($handle, dir, clickPos, param) {
+    return Math.abs($handle.position()[dir] + $handle[param]() / 2 - clickPos);
+  }
+  function baseLog(base, value) {
+    return Math.log(value) / Math.log(base);
+  }
+
+  // Window exports
+  Foundation.plugin(Slider, 'Slider');
+}(jQuery);