active_frontend 8.0.0 → 8.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ac143feaeb62f76569d97990f3df16ed6115fb7
-  data.tar.gz: dfd577b2a93717315f1151c48daf1a3b578ff421
+  metadata.gz: 696b9e32a78a0fa88311d85c73dd311894c37a4e
+  data.tar.gz: 93fd537ac023ae4f4424628a7acd6574b4a2abc3
 SHA512:
-  metadata.gz: 01db75bfe686b7e8d7a9be5034b85a6ec38d115b8e69929a8b9240318d0f4d2b4f7221deb4418b5f69f2da2cc59c7c847ceb3664ac4a561f40e77fca345e7aa2
-  data.tar.gz: ef3bda595a1e62c9ca1c861df4b52060ce39f1caa7740cce3ffc3715d57ce7bf3c5a74e8712ab219965d37ecdfe22c3567bbf11f770440421e9196d94ac532d4
+  metadata.gz: 89d9cd1c90a402f4fdf02eda68960aac0ec6e52d22b28de06e526a1f4081fb16dc9be4dce9cdf70a4df3c23d95035993bc469decf8f99f63c4485eb4fa1cc8aa
+  data.tar.gz: bb95641a19c7a5ba770af159df68640aa7355c7fcb4088964def0e696aa36d4735504fb74459b463d46b8d4ec8ee6bda20887afb177e4740d6d8b564593b8c62

data/README.md

@@ -60,6 +60,7 @@ Add the CSS files you want to include:
 *= require placeholder.css
 *= require progress.css
 *= require sidebar.css
+*= require slider.css
 *= require spinner.css
 *= require swoggle.css
 *= require table.css
@@ -87,10 +88,12 @@ Add the JS files you want to include:
 //= require dropdown.js
 //= require file_input.js
 //= require hoverdown.js
+//= require inputmask.js
 //= require loader.js
 //= require map.js
 //= require modal.js
 //= require scrollspy.js
+//= require slider.js
 //= require sort.js
 //= require swoggle.js
 //= require tab.js

data/lib/active_frontend/version.rb

@@ -1,3 +1,3 @@
 module ActiveFrontend
-  VERSION = "8.0.0"
+  VERSION = "8.0.1"
 end

data/vendor/assets/javascripts/inputmask.js

@@ -0,0 +1,339 @@
++function ($) { "use strict";
+
+  var isIphone = (window.orientation !== undefined)
+  var isAndroid = navigator.userAgent.toLowerCase().indexOf("android") > -1
+  var isIE = window.navigator.appName == 'Microsoft Internet Explorer'
+
+  // INPUTMASK PUBLIC CLASS DEFINITION
+  // =================================
+
+  var Inputmask = function (element, options) {
+    if (isAndroid) return // No support because caret positioning doesn't work on Android
+
+    this.$element = $(element)
+    this.options = $.extend({}, Inputmask.DEFAULTS, options)
+    this.mask = String(this.options.mask)
+
+    this.init()
+    this.listen()
+
+    this.checkVal() //Perform initial check for existing values
+  }
+
+  Inputmask.DEFAULTS = {
+    mask: "",
+    placeholder: "_",
+    definitions: {
+      '9': "[0-9]",
+      'a': "[A-Za-z]",
+      'w': "[A-Za-z0-9]",
+      '*': "."
+    }
+  }
+
+  Inputmask.prototype.init = function() {
+    var defs = this.options.definitions
+    var len = this.mask.length
+
+    this.tests = []
+    this.partialPosition = this.mask.length
+    this.firstNonMaskPos = null
+
+    $.each(this.mask.split(""), $.proxy(function(i, c) {
+      if (c == '?') {
+        len--
+        this.partialPosition = i
+      } else if (defs[c]) {
+        this.tests.push(new RegExp(defs[c]))
+        if (this.firstNonMaskPos === null)
+          this.firstNonMaskPos =  this.tests.length - 1
+      } else {
+        this.tests.push(null)
+      }
+    }, this))
+
+    this.buffer = $.map(this.mask.split(""), $.proxy(function(c, i) {
+      if (c != '?') return defs[c] ? this.options.placeholder : c
+    }, this))
+
+    this.focusText = this.$element.val()
+
+    this.$element.data("rawMaskFn", $.proxy(function() {
+      return $.map(this.buffer, function(c, i) {
+        return this.tests[i] && c != this.options.placeholder ? c : null
+      }).join('')
+    }, this))
+  }
+
+  Inputmask.prototype.listen = function() {
+    if (this.$element.attr("readonly")) return
+
+    var pasteEventName = (isIE ? 'paste' : 'input') + ".mask"
+
+    this.$element
+      .on("unmask.bs.inputmask", $.proxy(this.unmask, this))
+
+      .on("focus.bs.inputmask", $.proxy(this.focusEvent, this))
+      .on("blur.bs.inputmask", $.proxy(this.blurEvent, this))
+
+      .on("keydown.bs.inputmask", $.proxy(this.keydownEvent, this))
+      .on("keypress.bs.inputmask", $.proxy(this.keypressEvent, this))
+
+      .on(pasteEventName, $.proxy(this.pasteEvent, this))
+  }
+
+  //Helper Function for Caret positioning
+  Inputmask.prototype.caret = function(begin, end) {
+    if (this.$element.length === 0) return
+    if (typeof begin == 'number') {
+      end = (typeof end == 'number') ? end : begin
+      return this.$element.each(function() {
+        if (this.setSelectionRange) {
+          this.setSelectionRange(begin, end)
+        } else if (this.createTextRange) {
+          var range = this.createTextRange()
+          range.collapse(true)
+          range.moveEnd('character', end)
+          range.moveStart('character', begin)
+          range.select()
+        }
+      })
+    } else {
+      if (this.$element[0].setSelectionRange) {
+        begin = this.$element[0].selectionStart
+        end = this.$element[0].selectionEnd
+      } else if (document.selection && document.selection.createRange) {
+        var range = document.selection.createRange()
+        begin = 0 - range.duplicate().moveStart('character', -100000)
+        end = begin + range.text.length
+      }
+      return {
+        begin: begin,
+        end: end
+      }
+    }
+  }
+
+  Inputmask.prototype.seekNext = function(pos) {
+    var len = this.mask.length
+    while (++pos <= len && !this.tests[pos]);
+
+    return pos
+  }
+
+  Inputmask.prototype.seekPrev = function(pos) {
+    while (--pos >= 0 && !this.tests[pos]);
+
+    return pos
+  }
+
+  Inputmask.prototype.shiftL = function(begin,end) {
+    var len = this.mask.length
+
+    if (begin < 0) return
+
+    for (var i = begin, j = this.seekNext(end); i < len; i++) {
+      if (this.tests[i]) {
+        if (j < len && this.tests[i].test(this.buffer[j])) {
+          this.buffer[i] = this.buffer[j]
+          this.buffer[j] = this.options.placeholder
+        } else
+          break
+        j = this.seekNext(j)
+      }
+    }
+    this.writeBuffer()
+    this.caret(Math.max(this.firstNonMaskPos, begin))
+  }
+
+  Inputmask.prototype.shiftR = function(pos) {
+    var len = this.mask.length
+
+    for (var i = pos, c = this.options.placeholder; i < len; i++) {
+      if (this.tests[i]) {
+        var j = this.seekNext(i)
+        var t = this.buffer[i]
+        this.buffer[i] = c
+        if (j < len && this.tests[j].test(t))
+          c = t
+        else
+          break
+      }
+    }
+  },
+
+  Inputmask.prototype.unmask = function() {
+    this.$element
+      .unbind(".mask")
+      .removeData("inputmask")
+  }
+
+  Inputmask.prototype.focusEvent = function() {
+    this.focusText = this.$element.val()
+    var len = this.mask.length
+    var pos = this.checkVal()
+    this.writeBuffer()
+
+    var that = this
+    var moveCaret = function() {
+      if (pos == len)
+        that.caret(0, pos)
+      else
+        that.caret(pos)
+    }
+
+    moveCaret()
+    setTimeout(moveCaret, 50)
+  }
+
+  Inputmask.prototype.blurEvent = function() {
+    this.checkVal()
+    if (this.$element.val() !== this.focusText)
+      this.$element.trigger('change')
+  }
+
+  Inputmask.prototype.keydownEvent = function(e) {
+    var k = e.which
+
+    //backspace, delete, and escape get special treatment
+    if (k == 8 || k == 46 || (isIphone && k == 127)) {
+      var pos = this.caret(),
+      begin = pos.begin,
+      end = pos.end
+
+      if (end - begin === 0) {
+        begin = k != 46 ? this.seekPrev(begin) : (end = this.seekNext(begin - 1))
+        end = k == 46 ? this.seekNext(end) : end
+      }
+      this.clearBuffer(begin, end)
+      this.shiftL(begin, end - 1)
+
+      return false
+    } else if (k == 27) {//escape
+      this.$element.val(this.focusText)
+      this.caret(0, this.checkVal())
+      return false
+    }
+  }
+
+  Inputmask.prototype.keypressEvent = function(e) {
+    var len = this.mask.length
+
+    var k = e.which,
+    pos = this.caret()
+
+    if (e.ctrlKey || e.altKey || e.metaKey || k < 32)  {//Ignore
+      return true
+    } else if (k) {
+      if (pos.end - pos.begin !== 0) {
+        this.clearBuffer(pos.begin, pos.end)
+        this.shiftL(pos.begin, pos.end - 1)
+      }
+
+      var p = this.seekNext(pos.begin - 1)
+      if (p < len) {
+        var c = String.fromCharCode(k)
+        if (this.tests[p].test(c)) {
+          this.shiftR(p)
+          this.buffer[p] = c
+          this.writeBuffer()
+          var next = this.seekNext(p)
+          this.caret(next)
+        }
+      }
+      return false
+    }
+  }
+
+  Inputmask.prototype.pasteEvent = function() {
+    var that = this
+
+    setTimeout(function() {
+      that.caret(that.checkVal(true))
+    }, 0)
+  }
+
+  Inputmask.prototype.clearBuffer = function(start, end) {
+    var len = this.mask.length
+
+    for (var i = start; i < end && i < len; i++) {
+      if (this.tests[i])
+        this.buffer[i] = this.options.placeholder
+    }
+  }
+
+  Inputmask.prototype.writeBuffer = function() {
+    return this.$element.val(this.buffer.join('')).val()
+  }
+
+  Inputmask.prototype.checkVal = function(allow) {
+    var len = this.mask.length
+    //try to place characters where they belong
+    var test = this.$element.val()
+    var lastMatch = -1
+
+    for (var i = 0, pos = 0; i < len; i++) {
+      if (this.tests[i]) {
+        this.buffer[i] = this.options.placeholder
+        while (pos++ < test.length) {
+          var c = test.charAt(pos - 1)
+          if (this.tests[i].test(c)) {
+            this.buffer[i] = c
+            lastMatch = i
+            break
+          }
+        }
+        if (pos > test.length)
+          break
+      } else if (this.buffer[i] == test.charAt(pos) && i != this.partialPosition) {
+        pos++
+        lastMatch = i
+      }
+    }
+    if (!allow && lastMatch + 1 < this.partialPosition) {
+      this.$element.val("")
+      this.clearBuffer(0, len)
+    } else if (allow || lastMatch + 1 >= this.partialPosition) {
+      this.writeBuffer()
+      if (!allow) this.$element.val(this.$element.val().substring(0, lastMatch + 1))
+    }
+    return (this.partialPosition ? i : this.firstNonMaskPos)
+  }
+
+
+  // INPUTMASK PLUGIN DEFINITION
+  // ===========================
+
+  var old = $.fn.inputmask
+
+  $.fn.inputmask = function (options) {
+    return this.each(function () {
+      var $this = $(this)
+      var data = $this.data('bs.inputmask')
+
+      if (!data) $this.data('bs.inputmask', (data = new Inputmask(this, options)))
+    })
+  }
+
+  $.fn.inputmask.Constructor = Inputmask
+
+
+  // INPUTMASK NO CONFLICT
+  // ====================
+
+  $.fn.inputmask.noConflict = function () {
+    $.fn.inputmask = old
+    return this
+  }
+
+
+  // INPUTMASK DATA-API
+  // ==================
+
+  $(document).on('focus.bs.inputmask.data-api', '[data-mask]', function (e) {
+    var $this = $(this)
+    if ($this.data('bs.inputmask')) return
+    $this.inputmask($this.data())
+  })
+
+}(window.jQuery);

data/vendor/assets/javascripts/slider.js

@@ -0,0 +1,1478 @@
+(function(root, factory) {
+  if(typeof define === "function" && define.amd) {
+    define(["jquery"], factory);
+  }
+  else if(typeof module === "object" && module.exports) {
+    var jQuery;
+    try {
+      jQuery = require("jquery");
+    }
+    catch (err) {
+      jQuery = null;
+    }
+    module.exports = factory(jQuery);
+  }
+  else {
+    root.Slider = factory(root.jQuery);
+  }
+}(this, function($) {
+  // Reference to Slider constructor
+  var Slider;
+
+
+  (function( $ ) {
+
+    'use strict';
+
+    // -------------------------- utils -------------------------- //
+
+    var slice = Array.prototype.slice;
+
+    function noop() {}
+
+    // -------------------------- definition -------------------------- //
+
+    function defineBridget( $ ) {
+
+      // bail if no jQuery
+      if ( !$ ) {
+        return;
+      }
+
+      // -------------------------- addOptionMethod -------------------------- //
+
+      /**
+       * adds option method -> $().plugin('option', {...})
+       * @param {Function} PluginClass - constructor class
+       */
+      function addOptionMethod( PluginClass ) {
+        // don't overwrite original option method
+        if ( PluginClass.prototype.option ) {
+          return;
+        }
+
+        // option setter
+        PluginClass.prototype.option = function( opts ) {
+          // bail out if not an object
+          if ( !$.isPlainObject( opts ) ){
+            return;
+          }
+          this.options = $.extend( true, this.options, opts );
+        };
+      }
+
+
+      // -------------------------- plugin bridge -------------------------- //
+
+      // helper function for logging errors
+      // $.error breaks jQuery chaining
+      var logError = typeof console === 'undefined' ? noop :
+        function( message ) {
+          console.error( message );
+        };
+
+      /**
+       * jQuery plugin bridge, access methods like $elem.plugin('method')
+       * @param {String} namespace - plugin name
+       * @param {Function} PluginClass - constructor class
+       */
+      function bridge( namespace, PluginClass ) {
+        // add to jQuery fn namespace
+        $.fn[ namespace ] = function( options ) {
+          if ( typeof options === 'string' ) {
+            // call plugin method when first argument is a string
+            // get arguments for method
+            var args = slice.call( arguments, 1 );
+
+            for ( var i=0, len = this.length; i < len; i++ ) {
+              var elem = this[i];
+              var instance = $.data( elem, namespace );
+              if ( !instance ) {
+                logError( "cannot call methods on " + namespace + " prior to initialization; " +
+                  "attempted to call '" + options + "'" );
+                continue;
+              }
+              if ( !$.isFunction( instance[options] ) || options.charAt(0) === '_' ) {
+                logError( "no such method '" + options + "' for " + namespace + " instance" );
+                continue;
+              }
+
+              // trigger method with arguments
+              var returnValue = instance[ options ].apply( instance, args);
+
+              // break look and return first value if provided
+              if ( returnValue !== undefined && returnValue !== instance) {
+                return returnValue;
+              }
+            }
+            // return this if no return value
+            return this;
+          } else {
+            var objects = this.map( function() {
+              var instance = $.data( this, namespace );
+              if ( instance ) {
+                // apply options & init
+                instance.option( options );
+                instance._init();
+              } else {
+                // initialize new instance
+                instance = new PluginClass( this, options );
+                $.data( this, namespace, instance );
+              }
+              return $(this);
+            });
+
+            if(!objects || objects.length > 1) {
+              return objects;
+            } else {
+              return objects[0];
+            }
+          }
+        };
+
+      }
+
+      // -------------------------- bridget -------------------------- //
+
+      /**
+       * converts a Prototypical class into a proper jQuery plugin
+       *   the class must have a ._init method
+       * @param {String} namespace - plugin name, used in $().pluginName
+       * @param {Function} PluginClass - constructor class
+       */
+      $.bridget = function( namespace, PluginClass ) {
+        addOptionMethod( PluginClass );
+        bridge( namespace, PluginClass );
+      };
+
+      return $.bridget;
+
+    }
+
+      // get jquery from browser global
+      defineBridget( $ );
+
+  })( $ );
+
+
+  /*************************************************
+
+      BOOTSTRAP-SLIDER SOURCE CODE
+
+  **************************************************/
+
+  (function($) {
+
+    var ErrorMsgs = {
+      formatInvalidInputErrorMsg : function(input) {
+        return "Invalid input value '" + input + "' passed in";
+      },
+      callingContextNotSliderInstance : "Calling context element does not have instance of Slider bound to it. Check your code to make sure the JQuery object returned from the call to the slider() initializer is calling the method"
+    };
+
+    var SliderScale = {
+      linear: {
+        toValue: function(percentage) {
+          var rawValue = percentage/100 * (this.options.max - this.options.min);
+          if (this.options.ticks_positions.length > 0) {
+            var minv, maxv, minp, maxp = 0;
+            for (var i = 0; i < this.options.ticks_positions.length; i++) {
+              if (percentage <= this.options.ticks_positions[i]) {
+                minv = (i > 0) ? this.options.ticks[i-1] : 0;
+                minp = (i > 0) ? this.options.ticks_positions[i-1] : 0;
+                maxv = this.options.ticks[i];
+                maxp = this.options.ticks_positions[i];
+
+                break;
+              }
+            }
+            if (i > 0) {
+              var partialPercentage = (percentage - minp) / (maxp - minp);
+              rawValue = minv + partialPercentage * (maxv - minv);
+            }
+          }
+
+          var value = this.options.min + Math.round(rawValue / this.options.step) * this.options.step;
+          if (value < this.options.min) {
+            return this.options.min;
+          } else if (value > this.options.max) {
+            return this.options.max;
+          } else {
+            return value;
+          }
+        },
+        toPercentage: function(value) {
+          if (this.options.max === this.options.min) {
+            return 0;
+          }
+
+          if (this.options.ticks_positions.length > 0) {
+            var minv, maxv, minp, maxp = 0;
+            for (var i = 0; i < this.options.ticks.length; i++) {
+              if (value  <= this.options.ticks[i]) {
+                minv = (i > 0) ? this.options.ticks[i-1] : 0;
+                minp = (i > 0) ? this.options.ticks_positions[i-1] : 0;
+                maxv = this.options.ticks[i];
+                maxp = this.options.ticks_positions[i];
+
+                break;
+              }
+            }
+            if (i > 0) {
+              var partialPercentage = (value - minv) / (maxv - minv);
+              return minp + partialPercentage * (maxp - minp);
+            }
+          }
+
+          return 100 * (value - this.options.min) / (this.options.max - this.options.min);
+        }
+      },
+
+      logarithmic: {
+        /* Based on http://stackoverflow.com/questions/846221/logarithmic-slider */
+        toValue: function(percentage) {
+          var min = (this.options.min === 0) ? 0 : Math.log(this.options.min);
+          var max = Math.log(this.options.max);
+          var value = Math.exp(min + (max - min) * percentage / 100);
+          value = this.options.min + Math.round((value - this.options.min) / this.options.step) * this.options.step;
+          /* Rounding to the nearest step could exceed the min or
+           * max, so clip to those values. */
+          if (value < this.options.min) {
+            return this.options.min;
+          } else if (value > this.options.max) {
+            return this.options.max;
+          } else {
+            return value;
+          }
+        },
+        toPercentage: function(value) {
+          if (this.options.max === this.options.min) {
+            return 0;
+          } else {
+            var max = Math.log(this.options.max);
+            var min = this.options.min === 0 ? 0 : Math.log(this.options.min);
+            var v = value === 0 ? 0 : Math.log(value);
+            return 100 * (v - min) / (max - min);
+          }
+        }
+      }
+    };
+
+
+    /*************************************************
+
+              CONSTRUCTOR
+
+    **************************************************/
+    Slider = function(element, options) {
+      createNewSlider.call(this, element, options);
+      return this;
+    };
+
+    function createNewSlider(element, options) {
+
+      if(typeof element === "string") {
+        this.element = document.querySelector(element);
+      } else if(element instanceof HTMLElement) {
+        this.element = element;
+      }
+
+      /*************************************************
+
+              Process Options
+
+      **************************************************/
+      options = options ? options : {};
+      var optionTypes = Object.keys(this.defaultOptions);
+
+      for(var i = 0; i < optionTypes.length; i++) {
+        var optName = optionTypes[i];
+
+        // First check if an option was passed in via the constructor
+        var val = options[optName];
+        // If no data attrib, then check data atrributes
+        val = (typeof val !== 'undefined') ? val : getDataAttrib(this.element, optName);
+        // Finally, if nothing was specified, use the defaults
+        val = (val !== null) ? val : this.defaultOptions[optName];
+
+        // Set all options on the instance of the Slider
+        if(!this.options) {
+          this.options = {};
+        }
+        this.options[optName] = val;
+      }
+
+      /*
+        Validate `tooltip_position` against 'orientation`
+        - if `tooltip_position` is incompatible with orientation, swith it to a default compatible with specified `orientation`
+          -- default for "vertical" -> "right"
+          -- default for "horizontal" -> "left"
+      */
+      if(this.options.orientation === "vertical" && (this.options.tooltip_position === "top" || this.options.tooltip_position === "bottom")) {
+
+        this.options.tooltip_position = "right";
+
+      }
+      else if(this.options.orientation === "horizontal" && (this.options.tooltip_position === "left" || this.options.tooltip_position === "right")) {
+
+        this.options.tooltip_position = "top";
+
+      }
+
+      function getDataAttrib(element, optName) {
+        var dataName = "data-slider-" + optName.replace(/_/g, '-');
+        var dataValString = element.getAttribute(dataName);
+
+        try {
+          return JSON.parse(dataValString);
+        }
+        catch(err) {
+          return dataValString;
+        }
+      }
+
+      /*************************************************
+
+              Create Markup
+
+      **************************************************/
+
+      var origWidth = this.element.style.width;
+      var updateSlider = false;
+      var parent = this.element.parentNode;
+      var sliderTrackSelection;
+      var sliderTrackLow, sliderTrackHigh;
+      var sliderMinHandle;
+      var sliderMaxHandle;
+
+      if (this.sliderElem) {
+        updateSlider = true;
+      } else {
+        /* Create elements needed for slider */
+        this.sliderElem = document.createElement("div");
+        this.sliderElem.className = "slider";
+
+        /* Create slider track elements */
+        var sliderTrack = document.createElement("div");
+        sliderTrack.className = "slider-track";
+
+        sliderTrackLow = document.createElement("div");
+        sliderTrackLow.className = "slider-track-low";
+
+        sliderTrackSelection = document.createElement("div");
+        sliderTrackSelection.className = "slider-selection";
+
+        sliderTrackHigh = document.createElement("div");
+        sliderTrackHigh.className = "slider-track-high";
+
+        sliderMinHandle = document.createElement("div");
+        sliderMinHandle.className = "slider-handle min-slider-handle";
+
+        sliderMaxHandle = document.createElement("div");
+        sliderMaxHandle.className = "slider-handle max-slider-handle";
+
+        sliderTrack.appendChild(sliderTrackLow);
+        sliderTrack.appendChild(sliderTrackSelection);
+        sliderTrack.appendChild(sliderTrackHigh);
+
+        /* Create ticks */
+        this.ticks = [];
+        if (Array.isArray(this.options.ticks) && this.options.ticks.length > 0) {
+          for (i = 0; i < this.options.ticks.length; i++) {
+            var tick = document.createElement('div');
+            tick.className = 'slider-tick';
+
+            this.ticks.push(tick);
+            sliderTrack.appendChild(tick);
+          }
+
+          sliderTrackSelection.className += " tick-slider-selection";
+        }
+
+        sliderTrack.appendChild(sliderMinHandle);
+        sliderTrack.appendChild(sliderMaxHandle);
+
+        this.tickLabels = [];
+        if (Array.isArray(this.options.ticks_labels) && this.options.ticks_labels.length > 0) {
+          this.tickLabelContainer = document.createElement('div');
+          this.tickLabelContainer.className = 'slider-tick-label-container';
+
+          for (i = 0; i < this.options.ticks_labels.length; i++) {
+            var label = document.createElement('div');
+            label.className = 'slider-tick-label';
+            label.innerHTML = this.options.ticks_labels[i];
+
+            this.tickLabels.push(label);
+            this.tickLabelContainer.appendChild(label);
+          }
+        }
+
+
+        var createAndAppendTooltipSubElements = function(tooltipElem) {
+          var arrow = document.createElement("div");
+          arrow.className = "tooltip-arrow";
+
+          var inner = document.createElement("div");
+          inner.className = "tooltip-inner";
+
+          tooltipElem.appendChild(arrow);
+          tooltipElem.appendChild(inner);
+
+        };
+
+        /* Create tooltip elements */
+        var sliderTooltip = document.createElement("div");
+        sliderTooltip.className = "tooltip tooltip-main";
+        createAndAppendTooltipSubElements(sliderTooltip);
+
+        var sliderTooltipMin = document.createElement("div");
+        sliderTooltipMin.className = "tooltip tooltip-min";
+        createAndAppendTooltipSubElements(sliderTooltipMin);
+
+        var sliderTooltipMax = document.createElement("div");
+        sliderTooltipMax.className = "tooltip tooltip-max";
+        createAndAppendTooltipSubElements(sliderTooltipMax);
+
+
+        /* Append components to sliderElem */
+        this.sliderElem.appendChild(sliderTrack);
+        this.sliderElem.appendChild(sliderTooltip);
+        this.sliderElem.appendChild(sliderTooltipMin);
+        this.sliderElem.appendChild(sliderTooltipMax);
+
+        if (this.tickLabelContainer) {
+          this.sliderElem.appendChild(this.tickLabelContainer);
+        }
+
+        /* Append slider element to parent container, right before the original <input> element */
+        parent.insertBefore(this.sliderElem, this.element);
+
+        /* Hide original <input> element */
+        this.element.style.display = "none";
+      }
+      /* If JQuery exists, cache JQ references */
+      if($) {
+        this.$element = $(this.element);
+        this.$sliderElem = $(this.sliderElem);
+      }
+
+      /*************************************************
+
+                Setup
+
+      **************************************************/
+      this.eventToCallbackMap = {};
+      this.sliderElem.id = this.options.id;
+
+      this.touchCapable = 'ontouchstart' in window || (window.DocumentTouch && document instanceof window.DocumentTouch);
+
+      this.tooltip = this.sliderElem.querySelector('.tooltip-main');
+      this.tooltipInner = this.tooltip.querySelector('.tooltip-inner');
+
+      this.tooltip_min = this.sliderElem.querySelector('.tooltip-min');
+      this.tooltipInner_min = this.tooltip_min.querySelector('.tooltip-inner');
+
+      this.tooltip_max = this.sliderElem.querySelector('.tooltip-max');
+      this.tooltipInner_max= this.tooltip_max.querySelector('.tooltip-inner');
+
+      if (SliderScale[this.options.scale]) {
+        this.options.scale = SliderScale[this.options.scale];
+      }
+
+      if (updateSlider === true) {
+        // Reset classes
+        this._removeClass(this.sliderElem, 'slider-horizontal');
+        this._removeClass(this.sliderElem, 'slider-vertical');
+        this._removeClass(this.tooltip, 'hide');
+        this._removeClass(this.tooltip_min, 'hide');
+        this._removeClass(this.tooltip_max, 'hide');
+
+        // Undo existing inline styles for track
+        ["left", "top", "width", "height"].forEach(function(prop) {
+          this._removeProperty(this.trackLow, prop);
+          this._removeProperty(this.trackSelection, prop);
+          this._removeProperty(this.trackHigh, prop);
+        }, this);
+
+        // Undo inline styles on handles
+        [this.handle1, this.handle2].forEach(function(handle) {
+          this._removeProperty(handle, 'left');
+          this._removeProperty(handle, 'top');
+        }, this);
+
+        // Undo inline styles and classes on tooltips
+        [this.tooltip, this.tooltip_min, this.tooltip_max].forEach(function(tooltip) {
+          this._removeProperty(tooltip, 'left');
+          this._removeProperty(tooltip, 'top');
+          this._removeProperty(tooltip, 'margin-left');
+          this._removeProperty(tooltip, 'margin-top');
+
+          this._removeClass(tooltip, 'right');
+          this._removeClass(tooltip, 'top');
+        }, this);
+      }
+
+      if(this.options.orientation === 'vertical') {
+        this._addClass(this.sliderElem,'slider-vertical');
+        this.stylePos = 'top';
+        this.mousePos = 'pageY';
+        this.sizePos = 'offsetHeight';
+      } else {
+        this._addClass(this.sliderElem, 'slider-horizontal');
+        this.sliderElem.style.width = origWidth;
+        this.options.orientation = 'horizontal';
+        this.stylePos = 'left';
+        this.mousePos = 'pageX';
+        this.sizePos = 'offsetWidth';
+
+      }
+      this._setTooltipPosition();
+      /* In case ticks are specified, overwrite the min and max bounds */
+      if (Array.isArray(this.options.ticks) && this.options.ticks.length > 0) {
+          this.options.max = Math.max.apply(Math, this.options.ticks);
+          this.options.min = Math.min.apply(Math, this.options.ticks);
+      }
+
+      if (Array.isArray(this.options.value)) {
+        this.options.range = true;
+      } else if (this.options.range) {
+        // User wants a range, but value is not an array
+        this.options.value = [this.options.value, this.options.max];
+      }
+
+      this.trackLow = sliderTrackLow || this.trackLow;
+      this.trackSelection = sliderTrackSelection || this.trackSelection;
+      this.trackHigh = sliderTrackHigh || this.trackHigh;
+
+      if (this.options.selection === 'none') {
+        this._addClass(this.trackLow, 'hide');
+        this._addClass(this.trackSelection, 'hide');
+        this._addClass(this.trackHigh, 'hide');
+      }
+
+      this.handle1 = sliderMinHandle || this.handle1;
+      this.handle2 = sliderMaxHandle || this.handle2;
+
+      if (updateSlider === true) {
+        // Reset classes
+        this._removeClass(this.handle1, 'round triangle');
+        this._removeClass(this.handle2, 'round triangle hide');
+
+        for (i = 0; i < this.ticks.length; i++) {
+          this._removeClass(this.ticks[i], 'round triangle hide');
+        }
+      }
+
+      var availableHandleModifiers = ['round', 'triangle', 'custom'];
+      var isValidHandleType = availableHandleModifiers.indexOf(this.options.handle) !== -1;
+      if (isValidHandleType) {
+        this._addClass(this.handle1, this.options.handle);
+        this._addClass(this.handle2, this.options.handle);
+
+        for (i = 0; i < this.ticks.length; i++) {
+          this._addClass(this.ticks[i], this.options.handle);
+        }
+      }
+
+      this.offset = this._offset(this.sliderElem);
+      this.size = this.sliderElem[this.sizePos];
+      this.setValue(this.options.value);
+
+      /******************************************
+
+            Bind Event Listeners
+
+      ******************************************/
+
+      // Bind keyboard handlers
+      this.handle1Keydown = this._keydown.bind(this, 0);
+      this.handle1.addEventListener("keydown", this.handle1Keydown, false);
+
+      this.handle2Keydown = this._keydown.bind(this, 1);
+      this.handle2.addEventListener("keydown", this.handle2Keydown, false);
+
+      this.mousedown = this._mousedown.bind(this);
+      if (this.touchCapable) {
+        // Bind touch handlers
+        this.sliderElem.addEventListener("touchstart", this.mousedown, false);
+      }
+      this.sliderElem.addEventListener("mousedown", this.mousedown, false);
+
+
+      // Bind tooltip-related handlers
+      if(this.options.tooltip === 'hide') {
+        this._addClass(this.tooltip, 'hide');
+        this._addClass(this.tooltip_min, 'hide');
+        this._addClass(this.tooltip_max, 'hide');
+      } else if(this.options.tooltip === 'always') {
+        this._showTooltip();
+        this._alwaysShowTooltip = true;
+      } else {
+        this.showTooltip = this._showTooltip.bind(this);
+        this.hideTooltip = this._hideTooltip.bind(this);
+
+        this.sliderElem.addEventListener("mouseenter", this.showTooltip, false);
+        this.sliderElem.addEventListener("mouseleave", this.hideTooltip, false);
+
+        this.handle1.addEventListener("focus", this.showTooltip, false);
+        this.handle1.addEventListener("blur", this.hideTooltip, false);
+
+        this.handle2.addEventListener("focus", this.showTooltip, false);
+        this.handle2.addEventListener("blur", this.hideTooltip, false);
+      }
+
+      if(this.options.enabled) {
+        this.enable();
+      } else {
+        this.disable();
+      }
+    }
+
+
+
+    /*************************************************
+
+          INSTANCE PROPERTIES/METHODS
+
+    - Any methods bound to the prototype are considered
+    part of the plugin's `public` interface
+
+    **************************************************/
+    Slider.prototype = {
+      _init: function() {}, // NOTE: Must exist to support bridget
+
+      constructor: Slider,
+
+      defaultOptions: {
+        id: "",
+        min: 0,
+        max: 10,
+        step: 1,
+        precision: 0,
+        orientation: 'horizontal',
+        value: 5,
+        range: false,
+        selection: 'before',
+        tooltip: 'show',
+        tooltip_split: false,
+        handle: 'round',
+        reversed: false,
+        enabled: true,
+        formatter: function(val) {
+          if (Array.isArray(val)) {
+            return val[0] + " : " + val[1];
+          } else {
+            return val;
+          }
+        },
+        natural_arrow_keys: false,
+        ticks: [],
+        ticks_positions: [],
+        ticks_labels: [],
+        ticks_snap_bounds: 0,
+        scale: 'linear',
+        focus: false,
+        tooltip_position: null
+      },
+
+      over: false,
+
+      inDrag: false,
+
+      getElement: function() {
+        return this.sliderElem;
+      },
+
+      getValue: function() {
+        if (this.options.range) {
+          return this.options.value;
+        }
+        return this.options.value[0];
+      },
+
+      setValue: function(val, triggerSlideEvent, triggerChangeEvent) {
+        if (!val) {
+          val = 0;
+        }
+        var oldValue = this.getValue();
+        this.options.value = this._validateInputValue(val);
+        var applyPrecision = this._applyPrecision.bind(this);
+
+        if (this.options.range) {
+          this.options.value[0] = applyPrecision(this.options.value[0]);
+          this.options.value[1] = applyPrecision(this.options.value[1]);
+
+          this.options.value[0] = Math.max(this.options.min, Math.min(this.options.max, this.options.value[0]));
+          this.options.value[1] = Math.max(this.options.min, Math.min(this.options.max, this.options.value[1]));
+        } else {
+          this.options.value = applyPrecision(this.options.value);
+          this.options.value = [ Math.max(this.options.min, Math.min(this.options.max, this.options.value))];
+          this._addClass(this.handle2, 'hide');
+          if (this.options.selection === 'after') {
+            this.options.value[1] = this.options.max;
+          } else {
+            this.options.value[1] = this.options.min;
+          }
+        }
+
+        if (this.options.max > this.options.min) {
+          this.percentage = [
+            this._toPercentage(this.options.value[0]),
+            this._toPercentage(this.options.value[1]),
+            this.options.step * 100 / (this.options.max - this.options.min)
+          ];
+        } else {
+          this.percentage = [0, 0, 100];
+        }
+
+        this._layout();
+        var newValue = this.options.range ? this.options.value : this.options.value[0];
+
+        if(triggerSlideEvent === true) {
+          this._trigger('slide', newValue);
+        }
+        if( (oldValue !== newValue) && (triggerChangeEvent === true) ) {
+          this._trigger('change', {
+            oldValue: oldValue,
+            newValue: newValue
+          });
+        }
+        this._setDataVal(newValue);
+
+        return this;
+      },
+
+      destroy: function(){
+        // Remove event handlers on slider elements
+        this._removeSliderEventHandlers();
+
+        // Remove the slider from the DOM
+        this.sliderElem.parentNode.removeChild(this.sliderElem);
+        /* Show original <input> element */
+        this.element.style.display = "";
+
+        // Clear out custom event bindings
+        this._cleanUpEventCallbacksMap();
+
+        // Remove data values
+        this.element.removeAttribute("data");
+
+        // Remove JQuery handlers/data
+        if($) {
+          this._unbindJQueryEventHandlers();
+          this.$element.removeData('slider');
+        }
+      },
+
+      disable: function() {
+        this.options.enabled = false;
+        this.handle1.removeAttribute("tabindex");
+        this.handle2.removeAttribute("tabindex");
+        this._addClass(this.sliderElem, 'slider-disabled');
+        this._trigger('slideDisabled');
+
+        return this;
+      },
+
+      enable: function() {
+        this.options.enabled = true;
+        this.handle1.setAttribute("tabindex", 0);
+        this.handle2.setAttribute("tabindex", 0);
+        this._removeClass(this.sliderElem, 'slider-disabled');
+        this._trigger('slideEnabled');
+
+        return this;
+      },
+
+      toggle: function() {
+        if(this.options.enabled) {
+          this.disable();
+        } else {
+          this.enable();
+        }
+        return this;
+      },
+
+      isEnabled: function() {
+        return this.options.enabled;
+      },
+
+      on: function(evt, callback) {
+        this._bindNonQueryEventHandler(evt, callback);
+        return this;
+      },
+
+            off: function(evt, callback) {
+                if($) {
+                    this.$element.off(evt, callback);
+                    this.$sliderElem.off(evt, callback);
+                } else {
+                    this._unbindNonQueryEventHandler(evt, callback);
+                }
+            },
+
+      getAttribute: function(attribute) {
+        if(attribute) {
+          return this.options[attribute];
+        } else {
+          return this.options;
+        }
+      },
+
+      setAttribute: function(attribute, value) {
+        this.options[attribute] = value;
+        return this;
+      },
+
+      refresh: function() {
+        this._removeSliderEventHandlers();
+        createNewSlider.call(this, this.element, this.options);
+        if($) {
+          // Bind new instance of slider to the element
+          $.data(this.element, 'slider', this);
+        }
+        return this;
+      },
+
+      relayout: function() {
+        this._layout();
+        return this;
+      },
+
+      /******************************+
+
+            HELPERS
+
+      - Any method that is not part of the public interface.
+      - Place it underneath this comment block and write its signature like so:
+
+                  _fnName : function() {...}
+
+      ********************************/
+      _removeSliderEventHandlers: function() {
+        // Remove event listeners from handle1
+        this.handle1.removeEventListener("keydown", this.handle1Keydown, false);
+        this.handle1.removeEventListener("focus", this.showTooltip, false);
+        this.handle1.removeEventListener("blur", this.hideTooltip, false);
+
+        // Remove event listeners from handle2
+        this.handle2.removeEventListener("keydown", this.handle2Keydown, false);
+        this.handle2.removeEventListener("focus", this.handle2Keydown, false);
+        this.handle2.removeEventListener("blur", this.handle2Keydown, false);
+
+        // Remove event listeners from sliderElem
+        this.sliderElem.removeEventListener("mouseenter", this.showTooltip, false);
+        this.sliderElem.removeEventListener("mouseleave", this.hideTooltip, false);
+        this.sliderElem.removeEventListener("touchstart", this.mousedown, false);
+        this.sliderElem.removeEventListener("mousedown", this.mousedown, false);
+      },
+      _bindNonQueryEventHandler: function(evt, callback) {
+        if(this.eventToCallbackMap[evt] === undefined) {
+          this.eventToCallbackMap[evt] = [];
+        }
+        this.eventToCallbackMap[evt].push(callback);
+      },
+            _unbindNonQueryEventHandler: function(evt, callback) {
+                var callbacks = this.eventToCallbackMap[evt];
+                if(callbacks !== undefined) {
+                    for (var i = 0; i < callbacks.length; i++) {
+                        if (callbacks[i] === callback) {
+                            callbacks.splice(i, 1);
+                            break;
+                        }
+                    }
+                }
+            },
+      _cleanUpEventCallbacksMap: function() {
+        var eventNames = Object.keys(this.eventToCallbackMap);
+        for(var i = 0; i < eventNames.length; i++) {
+          var eventName = eventNames[i];
+          this.eventToCallbackMap[eventName] = null;
+        }
+      },
+      _showTooltip: function() {
+        if (this.options.tooltip_split === false ){
+                this._addClass(this.tooltip, 'in');
+                this.tooltip_min.style.display = 'none';
+                this.tooltip_max.style.display = 'none';
+            } else {
+                this._addClass(this.tooltip_min, 'in');
+                this._addClass(this.tooltip_max, 'in');
+                this.tooltip.style.display = 'none';
+            }
+        this.over = true;
+      },
+      _hideTooltip: function() {
+        if (this.inDrag === false && this.alwaysShowTooltip !== true) {
+          this._removeClass(this.tooltip, 'in');
+          this._removeClass(this.tooltip_min, 'in');
+          this._removeClass(this.tooltip_max, 'in');
+        }
+        this.over = false;
+      },
+      _layout: function() {
+        var positionPercentages;
+
+        if(this.options.reversed) {
+          positionPercentages = [ 100 - this.percentage[0], this.options.range ? 100 - this.percentage[1] : this.percentage[1]];
+        } else {
+          positionPercentages = [ this.percentage[0], this.percentage[1] ];
+        }
+
+        this.handle1.style[this.stylePos] = positionPercentages[0]+'%';
+        this.handle2.style[this.stylePos] = positionPercentages[1]+'%';
+
+        /* Position ticks and labels */
+        if (Array.isArray(this.options.ticks) && this.options.ticks.length > 0) {
+          var maxTickValue = Math.max.apply(Math, this.options.ticks);
+          var minTickValue = Math.min.apply(Math, this.options.ticks);
+
+          var styleSize = this.options.orientation === 'vertical' ? 'height' : 'width';
+          var styleMargin = this.options.orientation === 'vertical' ? 'marginTop' : 'marginLeft';
+          var labelSize = this.size / (this.options.ticks.length - 1);
+
+          if (this.tickLabelContainer) {
+            var extraMargin = 0;
+            if (this.options.ticks_positions.length === 0) {
+              this.tickLabelContainer.style[styleMargin] = -labelSize/2 + 'px';
+              extraMargin = this.tickLabelContainer.offsetHeight;
+            } else {
+              /* Chidren are position absolute, calculate height by finding the max offsetHeight of a child */
+              for (i = 0 ; i < this.tickLabelContainer.childNodes.length; i++) {
+                if (this.tickLabelContainer.childNodes[i].offsetHeight > extraMargin) {
+                  extraMargin = this.tickLabelContainer.childNodes[i].offsetHeight;
+                }
+              }
+            }
+            if (this.options.orientation === 'horizontal') {
+              this.sliderElem.style.marginBottom = extraMargin + 'px';
+            }
+          }
+          for (var i = 0; i < this.options.ticks.length; i++) {
+
+            var percentage = this.options.ticks_positions[i] ||
+              100 * (this.options.ticks[i] - minTickValue) / (maxTickValue - minTickValue);
+
+            this.ticks[i].style[this.stylePos] = percentage + '%';
+
+            /* Set class labels to denote whether ticks are in the selection */
+            this._removeClass(this.ticks[i], 'in-selection');
+            if (!this.options.range) {
+              if (this.options.selection === 'after' && percentage >= positionPercentages[0]){
+                this._addClass(this.ticks[i], 'in-selection');
+              } else if (this.options.selection === 'before' && percentage <= positionPercentages[0]) {
+                this._addClass(this.ticks[i], 'in-selection');
+              }
+            } else if (percentage >= positionPercentages[0] && percentage <= positionPercentages[1]) {
+              this._addClass(this.ticks[i], 'in-selection');
+            }
+
+            if (this.tickLabels[i]) {
+              this.tickLabels[i].style[styleSize] = labelSize + 'px';
+
+              if (this.options.ticks_positions[i] !== undefined) {
+                this.tickLabels[i].style.position = 'absolute';
+                this.tickLabels[i].style[this.stylePos] = this.options.ticks_positions[i] + '%';
+                this.tickLabels[i].style[styleMargin] = -labelSize/2 + 'px';
+              }
+            }
+          }
+        }
+
+        if (this.options.orientation === 'vertical') {
+          this.trackLow.style.top = '0';
+          this.trackLow.style.height = Math.min(positionPercentages[0], positionPercentages[1]) +'%';
+
+          this.trackSelection.style.top = Math.min(positionPercentages[0], positionPercentages[1]) +'%';
+          this.trackSelection.style.height = Math.abs(positionPercentages[0] - positionPercentages[1]) +'%';
+
+          this.trackHigh.style.bottom = '0';
+          this.trackHigh.style.height = (100 - Math.min(positionPercentages[0], positionPercentages[1]) - Math.abs(positionPercentages[0] - positionPercentages[1])) +'%';
+        } else {
+          this.trackLow.style.left = '0';
+          this.trackLow.style.width = Math.min(positionPercentages[0], positionPercentages[1]) +'%';
+
+          this.trackSelection.style.left = Math.min(positionPercentages[0], positionPercentages[1]) +'%';
+          this.trackSelection.style.width = Math.abs(positionPercentages[0] - positionPercentages[1]) +'%';
+
+          this.trackHigh.style.right = '0';
+          this.trackHigh.style.width = (100 - Math.min(positionPercentages[0], positionPercentages[1]) - Math.abs(positionPercentages[0] - positionPercentages[1])) +'%';
+
+              var offset_min = this.tooltip_min.getBoundingClientRect();
+              var offset_max = this.tooltip_max.getBoundingClientRect();
+
+              if (offset_min.right > offset_max.left) {
+                  this._removeClass(this.tooltip_max, 'top');
+                  this._addClass(this.tooltip_max, 'bottom');
+                  this.tooltip_max.style.top = 18 + 'px';
+              } else {
+                  this._removeClass(this.tooltip_max, 'bottom');
+                  this._addClass(this.tooltip_max, 'top');
+                  this.tooltip_max.style.top = this.tooltip_min.style.top;
+              }
+        }
+
+        var formattedTooltipVal;
+
+        if (this.options.range) {
+          formattedTooltipVal = this.options.formatter(this.options.value);
+          this._setText(this.tooltipInner, formattedTooltipVal);
+          this.tooltip.style[this.stylePos] = (positionPercentages[1] + positionPercentages[0])/2 + '%';
+
+          if (this.options.orientation === 'vertical') {
+            this._css(this.tooltip, 'margin-top', -this.tooltip.offsetHeight / 2 + 'px');
+          } else {
+            this._css(this.tooltip, 'margin-left', -this.tooltip.offsetWidth / 2 + 'px');
+          }
+
+          if (this.options.orientation === 'vertical') {
+            this._css(this.tooltip, 'margin-top', -this.tooltip.offsetHeight / 2 + 'px');
+          } else {
+            this._css(this.tooltip, 'margin-left', -this.tooltip.offsetWidth / 2 + 'px');
+          }
+
+          var innerTooltipMinText = this.options.formatter(this.options.value[0]);
+          this._setText(this.tooltipInner_min, innerTooltipMinText);
+
+          var innerTooltipMaxText = this.options.formatter(this.options.value[1]);
+          this._setText(this.tooltipInner_max, innerTooltipMaxText);
+
+          this.tooltip_min.style[this.stylePos] = positionPercentages[0] + '%';
+
+          if (this.options.orientation === 'vertical') {
+            this._css(this.tooltip_min, 'margin-top', -this.tooltip_min.offsetHeight / 2 + 'px');
+          } else {
+            this._css(this.tooltip_min, 'margin-left', -this.tooltip_min.offsetWidth / 2 + 'px');
+          }
+
+          this.tooltip_max.style[this.stylePos] = positionPercentages[1] + '%';
+
+          if (this.options.orientation === 'vertical') {
+            this._css(this.tooltip_max, 'margin-top', -this.tooltip_max.offsetHeight / 2 + 'px');
+          } else {
+            this._css(this.tooltip_max, 'margin-left', -this.tooltip_max.offsetWidth / 2 + 'px');
+          }
+        } else {
+          formattedTooltipVal = this.options.formatter(this.options.value[0]);
+          this._setText(this.tooltipInner, formattedTooltipVal);
+
+          this.tooltip.style[this.stylePos] = positionPercentages[0] + '%';
+          if (this.options.orientation === 'vertical') {
+            this._css(this.tooltip, 'margin-top', -this.tooltip.offsetHeight / 2 + 'px');
+          } else {
+            this._css(this.tooltip, 'margin-left', -this.tooltip.offsetWidth / 2 + 'px');
+          }
+        }
+      },
+      _removeProperty: function(element, prop) {
+        if (element.style.removeProperty) {
+            element.style.removeProperty(prop);
+        } else {
+            element.style.removeAttribute(prop);
+        }
+      },
+      _mousedown: function(ev) {
+        if(!this.options.enabled) {
+          return false;
+        }
+
+        this.offset = this._offset(this.sliderElem);
+        this.size = this.sliderElem[this.sizePos];
+
+        var percentage = this._getPercentage(ev);
+
+        if (this.options.range) {
+          var diff1 = Math.abs(this.percentage[0] - percentage);
+          var diff2 = Math.abs(this.percentage[1] - percentage);
+          this.dragged = (diff1 < diff2) ? 0 : 1;
+        } else {
+          this.dragged = 0;
+        }
+
+        this.percentage[this.dragged] = percentage;
+        this._layout();
+
+        if (this.touchCapable) {
+          document.removeEventListener("touchmove", this.mousemove, false);
+          document.removeEventListener("touchend", this.mouseup, false);
+        }
+
+        if(this.mousemove){
+          document.removeEventListener("mousemove", this.mousemove, false);
+        }
+        if(this.mouseup){
+          document.removeEventListener("mouseup", this.mouseup, false);
+        }
+
+        this.mousemove = this._mousemove.bind(this);
+        this.mouseup = this._mouseup.bind(this);
+
+        if (this.touchCapable) {
+          // Touch: Bind touch events:
+          document.addEventListener("touchmove", this.mousemove, false);
+          document.addEventListener("touchend", this.mouseup, false);
+        }
+        // Bind mouse events:
+        document.addEventListener("mousemove", this.mousemove, false);
+        document.addEventListener("mouseup", this.mouseup, false);
+
+        this.inDrag = true;
+        var newValue = this._calculateValue();
+
+        this._trigger('slideStart', newValue);
+
+        this._setDataVal(newValue);
+        this.setValue(newValue, false, true);
+
+        this._pauseEvent(ev);
+
+        if (this.options.focus) {
+          this._triggerFocusOnHandle(this.dragged);
+        }
+
+        return true;
+      },
+      _triggerFocusOnHandle: function(handleIdx) {
+        if(handleIdx === 0) {
+          this.handle1.focus();
+        }
+        if(handleIdx === 1) {
+          this.handle2.focus();
+        }
+      },
+      _keydown: function(handleIdx, ev) {
+        if(!this.options.enabled) {
+          return false;
+        }
+
+        var dir;
+        switch (ev.keyCode) {
+          case 37: // left
+          case 40: // down
+            dir = -1;
+            break;
+          case 39: // right
+          case 38: // up
+            dir = 1;
+            break;
+        }
+        if (!dir) {
+          return;
+        }
+
+        // use natural arrow keys instead of from min to max
+        if (this.options.natural_arrow_keys) {
+          var ifVerticalAndNotReversed = (this.options.orientation === 'vertical' && !this.options.reversed);
+          var ifHorizontalAndReversed = (this.options.orientation === 'horizontal' && this.options.reversed);
+
+          if (ifVerticalAndNotReversed || ifHorizontalAndReversed) {
+            dir = -dir;
+          }
+        }
+
+        var val = this.options.value[handleIdx] + dir * this.options.step;
+        if (this.options.range) {
+          val = [ (!handleIdx) ? val : this.options.value[0],
+                ( handleIdx) ? val : this.options.value[1]];
+        }
+
+        this._trigger('slideStart', val);
+        this._setDataVal(val);
+        this.setValue(val, true, true);
+
+        this._setDataVal(val);
+        this._trigger('slideStop', val);
+        this._layout();
+
+        this._pauseEvent(ev);
+
+        return false;
+      },
+      _pauseEvent: function(ev) {
+        if(ev.stopPropagation) {
+          ev.stopPropagation();
+        }
+          if(ev.preventDefault) {
+            ev.preventDefault();
+          }
+          ev.cancelBubble=true;
+          ev.returnValue=false;
+      },
+      _mousemove: function(ev) {
+        if(!this.options.enabled) {
+          return false;
+        }
+
+        var percentage = this._getPercentage(ev);
+        this._adjustPercentageForRangeSliders(percentage);
+        this.percentage[this.dragged] =  percentage;
+        this._layout();
+
+        var val = this._calculateValue(true);
+        this.setValue(val, true, true);
+
+        return false;
+      },
+      _adjustPercentageForRangeSliders: function(percentage) {
+        if (this.options.range) {
+          var precision = this._getNumDigitsAfterDecimalPlace(percentage);
+          precision = precision ? precision - 1 : 0;
+          var percentageWithAdjustedPrecision = this._applyToFixedAndParseFloat(percentage, precision);
+          if (this.dragged === 0 && this._applyToFixedAndParseFloat(this.percentage[1], precision) < percentageWithAdjustedPrecision) {
+            this.percentage[0] = this.percentage[1];
+            this.dragged = 1;
+          } else if (this.dragged === 1 && this._applyToFixedAndParseFloat(this.percentage[0], precision) > percentageWithAdjustedPrecision) {
+            this.percentage[1] = this.percentage[0];
+            this.dragged = 0;
+          }
+        }
+      },
+      _mouseup: function() {
+        if(!this.options.enabled) {
+          return false;
+        }
+        if (this.touchCapable) {
+          // Touch: Unbind touch event handlers:
+          document.removeEventListener("touchmove", this.mousemove, false);
+          document.removeEventListener("touchend", this.mouseup, false);
+        }
+                // Unbind mouse event handlers:
+                document.removeEventListener("mousemove", this.mousemove, false);
+                document.removeEventListener("mouseup", this.mouseup, false);
+
+        this.inDrag = false;
+        if (this.over === false) {
+          this._hideTooltip();
+        }
+        var val = this._calculateValue(true);
+
+        this._layout();
+        this._setDataVal(val);
+        this._trigger('slideStop', val);
+
+        return false;
+      },
+      _calculateValue: function(snapToClosestTick) {
+        var val;
+        if (this.options.range) {
+          val = [this.options.min,this.options.max];
+              if (this.percentage[0] !== 0){
+                  val[0] = this._toValue(this.percentage[0]);
+                  val[0] = this._applyPrecision(val[0]);
+              }
+              if (this.percentage[1] !== 100){
+                  val[1] = this._toValue(this.percentage[1]);
+                  val[1] = this._applyPrecision(val[1]);
+              }
+        } else {
+                val = this._toValue(this.percentage[0]);
+          val = parseFloat(val);
+          val = this._applyPrecision(val);
+        }
+
+        if (snapToClosestTick) {
+          var min = [val, Infinity];
+          for (var i = 0; i < this.options.ticks.length; i++) {
+            var diff = Math.abs(this.options.ticks[i] - val);
+            if (diff <= min[1]) {
+              min = [this.options.ticks[i], diff];
+            }
+          }
+          if (min[1] <= this.options.ticks_snap_bounds) {
+            return min[0];
+          }
+        }
+
+        return val;
+      },
+      _applyPrecision: function(val) {
+        var precision = this.options.precision || this._getNumDigitsAfterDecimalPlace(this.options.step);
+        return this._applyToFixedAndParseFloat(val, precision);
+      },
+      _getNumDigitsAfterDecimalPlace: function(num) {
+        var match = (''+num).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
+        if (!match) { return 0; }
+        return Math.max(0, (match[1] ? match[1].length : 0) - (match[2] ? +match[2] : 0));
+      },
+      _applyToFixedAndParseFloat: function(num, toFixedInput) {
+        var truncatedNum = num.toFixed(toFixedInput);
+        return parseFloat(truncatedNum);
+      },
+      /*
+        Credits to Mike Samuel for the following method!
+        Source: http://stackoverflow.com/questions/10454518/javascript-how-to-retrieve-the-number-of-decimals-of-a-string-number
+      */
+      _getPercentage: function(ev) {
+        if (this.touchCapable && (ev.type === 'touchstart' || ev.type === 'touchmove')) {
+          ev = ev.touches[0];
+        }
+
+        var eventPosition = ev[this.mousePos];
+        var sliderOffset = this.offset[this.stylePos];
+        var distanceToSlide = eventPosition - sliderOffset;
+        // Calculate what percent of the length the slider handle has slid
+        var percentage = (distanceToSlide / this.size) * 100;
+        percentage = Math.round(percentage / this.percentage[2]) * this.percentage[2];
+        if (this.options.reversed) {
+          percentage = 100 - percentage;
+        }
+
+        // Make sure the percent is within the bounds of the slider.
+        // 0% corresponds to the 'min' value of the slide
+        // 100% corresponds to the 'max' value of the slide
+        return Math.max(0, Math.min(100, percentage));
+      },
+      _validateInputValue: function(val) {
+        if (typeof val === 'number') {
+          return val;
+        } else if (Array.isArray(val)) {
+          this._validateArray(val);
+          return val;
+        } else {
+          throw new Error( ErrorMsgs.formatInvalidInputErrorMsg(val) );
+        }
+      },
+      _validateArray: function(val) {
+        for(var i = 0; i < val.length; i++) {
+          var input =  val[i];
+          if (typeof input !== 'number') { throw new Error( ErrorMsgs.formatInvalidInputErrorMsg(input) ); }
+        }
+      },
+      _setDataVal: function(val) {
+        var value = "value: '" + val + "'";
+        this.element.setAttribute('data', value);
+        this.element.setAttribute('value', val);
+                this.element.value = val;
+      },
+      _trigger: function(evt, val) {
+        val = (val || val === 0) ? val : undefined;
+
+        var callbackFnArray = this.eventToCallbackMap[evt];
+        if(callbackFnArray && callbackFnArray.length) {
+          for(var i = 0; i < callbackFnArray.length; i++) {
+            var callbackFn = callbackFnArray[i];
+            callbackFn(val);
+          }
+        }
+
+        /* If JQuery exists, trigger JQuery events */
+        if($) {
+          this._triggerJQueryEvent(evt, val);
+        }
+      },
+      _triggerJQueryEvent: function(evt, val) {
+        var eventData = {
+          type: evt,
+          value: val
+        };
+        this.$element.trigger(eventData);
+        this.$sliderElem.trigger(eventData);
+      },
+      _unbindJQueryEventHandlers: function() {
+        this.$element.off();
+        this.$sliderElem.off();
+      },
+      _setText: function(element, text) {
+        if(typeof element.innerText !== "undefined") {
+          element.innerText = text;
+        } else if(typeof element.textContent !== "undefined") {
+          element.textContent = text;
+        }
+      },
+      _removeClass: function(element, classString) {
+        var classes = classString.split(" ");
+        var newClasses = element.className;
+
+        for(var i = 0; i < classes.length; i++) {
+          var classTag = classes[i];
+          var regex = new RegExp("(?:\\s|^)" + classTag + "(?:\\s|$)");
+          newClasses = newClasses.replace(regex, " ");
+        }
+
+        element.className = newClasses.trim();
+      },
+      _addClass: function(element, classString) {
+        var classes = classString.split(" ");
+        var newClasses = element.className;
+
+        for(var i = 0; i < classes.length; i++) {
+          var classTag = classes[i];
+          var regex = new RegExp("(?:\\s|^)" + classTag + "(?:\\s|$)");
+          var ifClassExists = regex.test(newClasses);
+
+          if(!ifClassExists) {
+            newClasses += " " + classTag;
+          }
+        }
+
+        element.className = newClasses.trim();
+      },
+      _offsetLeft: function(obj){
+        return obj.getBoundingClientRect().left;
+      },
+      _offsetTop: function(obj){
+        var offsetTop = obj.offsetTop;
+        while((obj = obj.offsetParent) && !isNaN(obj.offsetTop)){
+          offsetTop += obj.offsetTop;
+        }
+        return offsetTop;
+      },
+        _offset: function (obj) {
+        return {
+          left: this._offsetLeft(obj),
+          top: this._offsetTop(obj)
+        };
+        },
+      _css: function(elementRef, styleName, value) {
+                if ($) {
+                    $.style(elementRef, styleName, value);
+                } else {
+                    var style = styleName.replace(/^-ms-/, "ms-").replace(/-([\da-z])/gi, function (all, letter) {
+                        return letter.toUpperCase();
+                    });
+                    elementRef.style[style] = value;
+                }
+      },
+      _toValue: function(percentage) {
+        return this.options.scale.toValue.apply(this, [percentage]);
+      },
+      _toPercentage: function(value) {
+        return this.options.scale.toPercentage.apply(this, [value]);
+      },
+      _setTooltipPosition: function(){
+        var tooltips = [this.tooltip, this.tooltip_min, this.tooltip_max];
+        if (this.options.orientation === 'vertical'){
+          this.options.tooltip_position = this.options.tooltip_position || 'right';
+          var oppositeSide = this.options.tooltip_position === 'left' ? 'right' : 'left';
+          tooltips.forEach(function(tooltip){
+            this._addClass(tooltip, this.options.tooltip_position);
+            tooltip.style[oppositeSide] = '100%';
+          }.bind(this));
+        } else if(this.options.tooltip_position === 'bottom') {
+          tooltips.forEach(function(tooltip){
+            this._addClass(tooltip, 'bottom');
+            tooltip.style.top = 22 + 'px';
+          }.bind(this));
+        } else {
+          tooltips.forEach(function(tooltip){
+            this._addClass(tooltip, 'top');
+            tooltip.style.top = -this.tooltip.outerHeight - 14 + 'px';
+          }.bind(this));
+        }
+      }
+    };
+
+    /*********************************
+
+      Attach to global namespace
+
+    *********************************/
+    if($) {
+      var namespace = $.fn.slider ? 'bootstrapSlider' : 'slider';
+      $.bridget(namespace, Slider);
+    }
+
+  })( $ );
+
+  return Slider;
+}));