https://stlpartners.com/wp-content/themes/stl-partners/dist/scripts/main.js?ver=1.0.1

537/***/ "./node_modules/css-loader/dist/runtime/api.js":
538/*!*****************************************************!*\
539  !*** ./node_modules/css-loader/dist/runtime/api.js ***!
540  \*****************************************************/
541/***/ ((module) => {
542
543"use strict";
544
545
546/*
547  MIT License http://www.opensource.org/licenses/mit-license.php
548  Author Tobias Koppers @sokra
549*/
550// css base code, injected by the css-loader
551// eslint-disable-next-line func-names
552module.exports = function (cssWithMappingToString) {
553  var list = []; // return the list of modules as css string
554
555  list.toString = function toString() {
556    return this.map(function (item) {
557      var content = cssWithMappingToString(item);
558
559      if (item[2]) {
560        return "@media ".concat(item[2], " {").concat(content, "}");
561      }
562
563      return content;
564    }).join("");
565  }; // import a list of modules into the list
566  // eslint-disable-next-line func-names
567
568
569  list.i = function (modules, mediaQuery, dedupe) {
570    if (typeof modules === "string") {
571      // eslint-disable-next-line no-param-reassign
572      modules = [[null, modules, ""]];
573    }
574
575    var alreadyImportedModules = {};
576
577    if (dedupe) {
578      for (var i = 0; i < this.length; i++) {
579        // eslint-disable-next-line prefer-destructuring
580        var id = this[i][0];
581
582        if (id != null) {
583          alreadyImportedModules[id] = true;
584        }
585      }
586    }
587
588    for (var _i = 0; _i < modules.length; _i++) {
589      var item = [].concat(modules[_i]);
590
591      if (dedupe && alreadyImportedModules[item[0]]) {
592        // eslint-disable-next-line no-continue
593        continue;
594      }
595
596      if (mediaQuery) {
597        if (!item[2]) {
598          item[2] = mediaQuery;
599        } else {
600          item[2] = "".concat(mediaQuery, " and ").concat(item[2]);
601        }
602      }
603
604      list.push(item);
605    }
606  };
607
608  return list;
609};
610
611/***/ }),
612

613/***/ "./node_modules/jquery.nicescroll/jquery.nicescroll.js":
614/*!*************************************************************!*\
615  !*** ./node_modules/jquery.nicescroll/jquery.nicescroll.js ***!
616  \*************************************************************/
617/***/ ((module, exports, __webpack_require__) => {
618
619var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/* jquery.nicescroll
620-- version 3.7.6
621-- copyright 2017-07-19 InuYaksa*2017
622-- licensed under the MIT
623--
624-- https://nicescroll.areaaperta.com/
625-- https://github.com/inuyaksa/jquery.nicescroll
626--
627*/
628
629/* jshint expr: true */
630
631(function (factory) {
632  if (true) {
633    // AMD. Register as anonymous module.
634    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js")], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
635		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
636		(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
637		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
638  } else {}
639}(function (jQuery) {
640
641  "use strict";
642
643  // globals
644  var domfocus = false,
645    mousefocus = false,
646    tabindexcounter = 0,
647    ascrailcounter = 2000,
648    globalmaxzindex = 0;
649
650  var $ = jQuery,       // sandbox
651    _doc = document,
652    _win = window,
653    $window = $(_win);
654
655  var delegatevents = [];
656
657  // http://stackoverflow.com/questions/2161159/get-script-path
658  function getScriptPath() {
659    var scripts = _doc.currentScript || (function () { var s = _doc.getElementsByTagName('script'); return (s.length) ? s[s.length - 1] : false; })();
660    var path = scripts ? scripts.src.split('?')[0] : '';
661    return (path.split('/').length > 0) ? path.split('/').slice(0, -1).join('/') + '/' : '';
662  }
663
664  // based on code by Paul Irish https://www.paulirish.com/2011/requestanimationframe-for-smart-animating/  
665  var setAnimationFrame = _win.requestAnimationFrame || _win.webkitRequestAnimationFrame || _win.mozRequestAnimationFrame || false;
666  var clearAnimationFrame = _win.cancelAnimationFrame || _win.webkitCancelAnimationFrame || _win.mozCancelAnimationFrame || false;
667
668  if (!setAnimationFrame) {
669    var anilasttime = 0;
670    setAnimationFrame = function (callback, element) {
671      var currTime = new Date().getTime();
672      var timeToCall = Math.max(0, 16 - (currTime - anilasttime));
673      var id = _win.setTimeout(function () { callback(currTime + timeToCall); },
674        timeToCall);
675      anilasttime = currTime + timeToCall;
676      return id;
677    };
678    clearAnimationFrame = function (id) {
679      _win.clearTimeout(id);
680    };
681  } else {
682    if (!_win.cancelAnimationFrame) clearAnimationFrame = function (id) { };
683  }
684
685  var ClsMutationObserver = _win.MutationObserver || _win.WebKitMutationObserver || false;
686
687  var now = Date.now || function () { return new Date().getTime(); };
688
689  var _globaloptions = {
690    zindex: "auto",
691    cursoropacitymin: 0,
692    cursoropacitymax: 1,
693    cursorcolor: "#424242",
694    cursorwidth: "6px",
695    cursorborder: "1px solid #fff",
696    cursorborderradius: "5px",
697    scrollspeed: 40,
698    mousescrollstep: 9 * 3,
699    touchbehavior: false,   // deprecated
700    emulatetouch: false,    // replacing touchbehavior
701    hwacceleration: true,
702    usetransition: true,
703    boxzoom: false,
704    dblclickzoom: true,
705    gesturezoom: true,
706    grabcursorenabled: true,
707    autohidemode: true,
708    background: "",
709    iframeautoresize: true,
710    cursorminheight: 32,
711    preservenativescrolling: true,
712    railoffset: false,
713    railhoffset: false,
714    bouncescroll: true,
715    spacebarenabled: true,
716    railpadding: {
717      top: 0,
718      right: 0,
719      left: 0,
720      bottom: 0
721    },
722    disableoutline: true,
723    horizrailenabled: true,
724    railalign: "right",
725    railvalign: "bottom",
726    enabletranslate3d: true,
727    enablemousewheel: true,
728    enablekeyboard: true,
729    smoothscroll: true,
730    sensitiverail: true,
731    enablemouselockapi: true,
732    //      cursormaxheight:false,
733    cursorfixedheight: false,
734    directionlockdeadzone: 6,
735    hidecursordelay: 400,
736    nativeparentscrolling: true,
737    enablescrollonselection: true,
738    overflowx: true,
739    overflowy: true,
740    cursordragspeed: 0.3,
741    rtlmode: "auto",
742    cursordragontouch: false,
743    oneaxismousemode: "auto",
744    scriptpath: getScriptPath(),
745    preventmultitouchscrolling: true,
746    disablemutationobserver: false,
747    enableobserver: true,
748    scrollbarid: false
749  };
750
751  var browserdetected = false;
752
753  var getBrowserDetection = function () {
754
755    if (browserdetected) return browserdetected;
756
757    var _el = _doc.createElement('DIV'),
758      _style = _el.style,
759      _agent = navigator.userAgent,
760      _platform = navigator.platform,
761      d = {};
762
763    d.haspointerlock = "pointerLockElement" in _doc || "webkitPointerLockElement" in _doc || "mozPointerLockElement" in _doc;
764
765    d.isopera = ("opera" in _win); // 12-
766    d.isopera12 = (d.isopera && ("getUserMedia" in navigator));
767    d.isoperamini = (Object.prototype.toString.call(_win.operamini) === "[object OperaMini]");
768
769    d.isie = (("all" in _doc) && ("attachEvent" in _el) && !d.isopera); //IE10-
770    d.isieold = (d.isie && !("msInterpolationMode" in _style)); // IE6 and older
771    d.isie7 = d.isie && !d.isieold && (!("documentMode" in _doc) || (_doc.documentMode === 7));
772    d.isie8 = d.isie && ("documentMode" in _doc) && (_doc.documentMode === 8);
773    d.isie9 = d.isie && ("performance" in _win) && (_doc.documentMode === 9);
774    d.isie10 = d.isie && ("performance" in _win) && (_doc.documentMode === 10);
775    d.isie11 = ("msRequestFullscreen" in _el) && (_doc.documentMode >= 11); // IE11+
776
777    d.ismsedge = ("msCredentials" in _win);  // MS Edge 14+
778
779    d.ismozilla = ("MozAppearance" in _style);
780
781    d.iswebkit = !d.ismsedge && ("WebkitAppearance" in _style);
782
783    d.ischrome = d.iswebkit && ("chrome" in _win);
784    d.ischrome38 = (d.ischrome && ("touchAction" in _style)); // behavior changed in touch emulation    
785    d.ischrome22 = (!d.ischrome38) && (d.ischrome && d.haspointerlock);
786    d.ischrome26 = (!d.ischrome38) && (d.ischrome && ("transition" in _style)); // issue with transform detection (maintain prefix)
787
788    d.cantouch = ("ontouchstart" in _doc.documentElement) || ("ontouchstart" in _win); // with detection for Chrome Touch Emulation    
789    d.hasw3ctouch = (_win.PointerEvent || false) && ((navigator.maxTouchPoints > 0) || (navigator.msMaxTouchPoints > 0)); //IE11 pointer events, following W3C Pointer Events spec
790    d.hasmstouch = (!d.hasw3ctouch) && (_win.MSPointerEvent || false); // IE10 pointer events
791
792    d.ismac = /^mac$/i.test(_platform);
793
794    d.isios = d.cantouch && /iphone|ipad|ipod/i.test(_platform);
795    d.isios4 = d.isios && !("seal" in Object);
796    d.isios7 = d.isios && ("webkitHidden" in _doc);  //iOS 7+
797    d.isios8 = d.isios && ("hidden" in _doc);  //iOS 8+
798    d.isios10 = d.isios && _win.Proxy;  //iOS 10+
799
800    d.isandroid = (/android/i.test(_agent));
801
802    d.haseventlistener = ("addEventListener" in _el);
803
804    d.trstyle = false;
805    d.hastransform = false;
806    d.hastranslate3d = false;
807    d.transitionstyle = false;
808    d.hastransition = false;
809    d.transitionend = false;
810
811    d.trstyle = "transform";
812    d.hastransform = ("transform" in _style) || (function () {
813      var check = ['msTransform', 'webkitTransform', 'MozTransform', 'OTransform'];
814      for (var a = 0, c = check.length; a < c; a++) {
815        if (_style[check[a]] !== undefined) {
816          d.trstyle = check[a];
817          break;
818        }
819      }
820      d.hastransform = (!!d.trstyle);
821    })();
822
823    if (d.hastransform) {
824      _style[d.trstyle] = "translate3d(1px,2px,3px)";
825      d.hastranslate3d = /translate3d/.test(_style[d.trstyle]);
826    }
827
828    d.transitionstyle = "transition";
829    d.prefixstyle = '';
830    d.transitionend = "transitionend";
831
832    d.hastransition = ("transition" in _style) || (function () {
833
834      d.transitionend = false;
835      var check = ['webkitTransition', 'msTransition', 'MozTransition', 'OTransition', 'OTransition', 'KhtmlTransition'];
836      var prefix = ['-webkit-', '-ms-', '-moz-', '-o-', '-o', '-khtml-'];
837      var evs = ['webkitTransitionEnd', 'msTransitionEnd', 'transitionend', 'otransitionend', 'oTransitionEnd', 'KhtmlTransitionEnd'];
838      for (var a = 0, c = check.length; a < c; a++) {
839        if (check[a] in _style) {
840          d.transitionstyle = check[a];
841          d.prefixstyle = prefix[a];
842          d.transitionend = evs[a];
843          break;
844        }
845      }
846      if (d.ischrome26) d.prefixstyle = prefix[1];  // always use prefix
847
848      d.hastransition = (d.transitionstyle);
849
850    })();
851
852    function detectCursorGrab() {
853      var lst = ['grab', '-webkit-grab', '-moz-grab'];
854      if ((d.ischrome && !d.ischrome38) || d.isie) lst = []; // force setting for IE returns false positive and chrome cursor bug
855      for (var a = 0, l = lst.length; a < l; a++) {
856        var p = lst[a];
857        _style.cursor = p;
858        if (_style.cursor == p) return p;
859      }
860      return 'url(https://cdnjs.cloudflare.com/ajax/libs/slider-pro/1.3.0/css/images/openhand.cur),n-resize'; // thanks to https://cdnjs.com/ for the openhand cursor!
861    }
862    d.cursorgrabvalue = detectCursorGrab();
863
864    d.hasmousecapture = ("setCapture" in _el);
865
866    d.hasMutationObserver = (ClsMutationObserver !== false);
867
868    _el = null; //memory released
869
870    browserdetected = d;
871
872    return d;
873  };
874
875  var NiceScrollClass = function (myopt, me) {
876
877    var self = this;
878
879    this.version = '3.7.6';
880    this.name = 'nicescroll';
881
882    this.me = me;
883
884    var $body = $("body");
885
886    var opt = this.opt = {
887      doc: $body,
888      win: false
889    };
890
891    $.extend(opt, _globaloptions);  // clone opts
892
893    // Options for internal use
894    opt.snapbackspeed = 80;
895
896    if (myopt || false) {
897      for (var a in opt) {
898        if (myopt[a] !== undefined) opt[a] = myopt[a];
899      }
900    }
901
902    if (opt.disablemutationobserver) ClsMutationObserver = false;
903
904    this.doc = opt.doc;
905    this.iddoc = (this.doc && this.doc[0]) ? this.doc[0].id || '' : '';
906    this.ispage = /^BODY|HTML/.test((opt.win) ? opt.win[0].nodeName : this.doc[0].nodeName);
907    this.haswrapper = (opt.win !== false);
908    this.win = opt.win || (this.ispage ? $window : this.doc);
909    this.docscroll = (this.ispage && !this.haswrapper) ? $window : this.win;
910    this.body = $body;
911    this.viewport = false;
912
913    this.isfixed = false;
914
915    this.iframe = false;
916    this.isiframe = ((this.doc[0].nodeName == 'IFRAME') && (this.win[0].nodeName == 'IFRAME'));
917
918    this.istextarea = (this.win[0].nodeName == 'TEXTAREA');
919
920    this.forcescreen = false; //force to use screen position on events
921
922    this.canshowonmouseevent = (opt.autohidemode != "scroll");
923
924    // Events jump table    
925    this.onmousedown = false;
926    this.onmouseup = false;
927    this.onmousemove = false;
928    this.onmousewheel = false;
929    this.onkeypress = false;
930    this.ongesturezoom = false;
931    this.onclick = false;
932
933    // Nicescroll custom events
934    this.onscrollstart = false;
935    this.onscrollend = false;
936    this.onscrollcancel = false;
937
938    this.onzoomin = false;
939    this.onzoomout = false;
940
941    // Let's start!  
942    this.view = false;
943    this.page = false;
944
945    this.scroll = {
946      x: 0,
947      y: 0
948    };
949    this.scrollratio = {
950      x: 0,
951      y: 0
952    };
953    this.cursorheight = 20;
954    this.scrollvaluemax = 0;
955
956    // http://dev.w3.org/csswg/css-writing-modes-3/#logical-to-physical
957    // http://dev.w3.org/csswg/css-writing-modes-3/#svg-writing-mode
958    if (opt.rtlmode == "auto") {
959      var target = this.win[0] == _win ? this.body : this.win;
960      var writingMode = target.css("writing-mode") || target.css("-webkit-writing-mode") || target.css("-ms-writing-mode") || target.css("-moz-writing-mode");
961
962      if (writingMode == "horizontal-tb" || writingMode == "lr-tb" || writingMode === "") {
963        this.isrtlmode = (target.css("direction") == "rtl");
964        this.isvertical = false;
965      } else {
966        this.isrtlmode = (writingMode == "vertical-rl" || writingMode == "tb" || writingMode == "tb-rl" || writingMode == "rl-tb");
967        this.isvertical = (writingMode == "vertical-rl" || writingMode == "tb" || writingMode == "tb-rl");
968      }
969    } else {
970      this.isrtlmode = (opt.rtlmode === true);
971      this.isvertical = false;
972    }
973    //    this.checkrtlmode = false;
974
975    this.scrollrunning = false;
976
977    this.scrollmom = false;
978
979    this.observer = false;  // observer div changes
980    this.observerremover = false;  // observer on parent for remove detection
981    this.observerbody = false;  // observer on body for position change
982
983    if (opt.scrollbarid !== false) {
984      this.id = opt.scrollbarid;
985    } else {
986      do {
987        this.id = "ascrail" + (ascrailcounter++);
988      } while (_doc.getElementById(this.id));
989    }
990
991    this.rail = false;
992    this.cursor = false;
993    this.cursorfreezed = false;
994    this.selectiondrag = false;
995
996    this.zoom = false;
997    this.zoomactive = false;
998
999    this.hasfocus = false;
1000    this.hasmousefocus = false;
1001
1002    //this.visibility = true;
1003    this.railslocked = false;  // locked by resize
1004    this.locked = false;  // prevent lost of locked status sets by user
1005    this.hidden = false; // rails always hidden
1006    this.cursoractive = true; // user can interact with cursors
1007
1008    this.wheelprevented = false; //prevent mousewheel event
1009
1010    this.overflowx = opt.overflowx;
1011    this.overflowy = opt.overflowy;
1012
1013    this.nativescrollingarea = false;
1014    this.checkarea = 0;
1015
1016    this.events = []; // event list for unbind
1017
1018    this.saved = {};  // style saved
1019
1020    this.delaylist = {};
1021    this.synclist = {};
1022
1023    this.lastdeltax = 0;
1024    this.lastdeltay = 0;
1025
1026    this.detected = getBrowserDetection();
1027
1028    var cap = $.extend({}, this.detected);
1029
1030    this.canhwscroll = (cap.hastransform && opt.hwacceleration);
1031    this.ishwscroll = (this.canhwscroll && self.haswrapper);
1032
1033    if (!this.isrtlmode) {
1034      this.hasreversehr = false;
1035    } else if (this.isvertical) { // RTL mode with reverse horizontal axis
1036      this.hasreversehr = !(cap.iswebkit || cap.isie || cap.isie11);
1037    } else {
1038      this.hasreversehr = !(cap.iswebkit || (cap.isie && !cap.isie10 && !cap.isie11));
1039    }
1040
1041    this.istouchcapable = false; // desktop devices with touch screen support
1042
1043    //## Check WebKit-based desktop with touch support
1044    //## + Firefox 18 nightly build (desktop) false positive (or desktop with touch support)
1045
1046    if (!cap.cantouch && (cap.hasw3ctouch || cap.hasmstouch)) {  // desktop device with multiple input
1047      this.istouchcapable = true;
1048    } else if (cap.cantouch && !cap.isios && !cap.isandroid && (cap.iswebkit || cap.ismozilla)) {
1049      this.istouchcapable = true;
1050    }
1051
1052    //## disable MouseLock API on user request
1053    if (!opt.enablemouselockapi) {
1054      cap.hasmousecapture = false;
1055      cap.haspointerlock = false;
1056    }
1057
1058    this.debounced = function (name, fn, tm) {
1059      if (!self) return;
1060      var dd = self.delaylist[name] || false;
1061      if (!dd) {
1062        self.delaylist[name] = {
1063          h: setAnimationFrame(function () {
1064            self.delaylist[name].fn.call(self);
1065            self.delaylist[name] = false;
1066          }, tm)
1067        };
1068        fn.call(self);
1069      }
1070      self.delaylist[name].fn = fn;
1071    };
1072
1073
1074    this.synched = function (name, fn) {
1075      if (self.synclist[name]) self.synclist[name] = fn;
1076      else {
1077        self.synclist[name] = fn;
1078        setAnimationFrame(function () {
1079          if (!self) return;
1080          self.synclist[name] && self.synclist[name].call(self);
1081          self.synclist[name] = null;
1082        });
1083      }
1084    };
1085
1086    this.unsynched = function (name) {
1087      if (self.synclist[name]) self.synclist[name] = false;
1088    };
1089
1090    this.css = function (el, pars) { // save & set
1091      for (var n in pars) {
1092        self.saved.css.push([el, n, el.css(n)]);
1093        el.css(n, pars[n]);
1094      }
1095    };
1096
1097    this.scrollTop = function (val) {
1098      return (val === undefined) ? self.getScrollTop() : self.setScrollTop(val);
1099    };
1100
1101    this.scrollLeft = function (val) {
1102      return (val === undefined) ? self.getScrollLeft() : self.setScrollLeft(val);
1103    };
1104
1105    // derived by by Dan Pupius www.pupius.net
1106    var BezierClass = function (st, ed, spd, p1, p2, p3, p4) {
1107
1108      this.st = st;
1109      this.ed = ed;
1110      this.spd = spd;
1111
1112      this.p1 = p1 || 0;
1113      this.p2 = p2 || 1;
1114      this.p3 = p3 || 0;
1115      this.p4 = p4 || 1;
1116
1117      this.ts = now();
1118      this.df = ed - st;
1119    };
1120    BezierClass.prototype = {
1121      B2: function (t) {
1122        return 3 * (1 - t) * (1 - t) * t;
1123      },
1124      B3: function (t) {
1125        return 3 * (1 - t) * t * t;
1126      },
1127      B4: function (t) {
1128        return t * t * t;
1129      },
1130      getPos: function () {
1131        return (now() - this.ts) / this.spd;
1132      },
1133      getNow: function () {
1134        var pc = (now() - this.ts) / this.spd;
1135        var bz = this.B2(pc) + this.B3(pc) + this.B4(pc);
1136        return (pc >= 1) ? this.ed : this.st + (this.df * bz) | 0;
1137      },
1138      update: function (ed, spd) {
1139        this.st = this.getNow();
1140        this.ed = ed;
1141        this.spd = spd;
1142        this.ts = now();
1143        this.df = this.ed - this.st;
1144        return this;
1145      }
1146    };
1147
1148    //derived from http://stackoverflow.com/questions/11236090/
1149    function getMatrixValues() {
1150      var tr = self.doc.css(cap.trstyle);
1151      if (tr && (tr.substr(0, 6) == "matrix")) {
1152        return tr.replace(/^.*\((.*)\)$/g, "$1").replace(/px/g, '').split(/, +/);
1153      }
1154      return false;
1155    }
1156
1157    if (this.ishwscroll) {    // hw accelerated scroll
1158
1159      this.doc.translate = {
1160        x: 0,
1161        y: 0,
1162        tx: "0px",
1163        ty: "0px"
1164      };
1165
1166      //this one can help to enable hw accel on ios6 http://indiegamr.com/ios6-html-hardware-acceleration-changes-and-how-to-fix-them/
1167      if (cap.hastranslate3d && cap.isios) this.doc.css("-webkit-backface-visibility", "hidden"); // prevent flickering http://stackoverflow.com/questions/3461441/      
1168
1169      this.getScrollTop = function (last) {
1170        if (!last) {
1171          var mtx = getMatrixValues();
1172          if (mtx) return (mtx.length == 16) ? -mtx[13] : -mtx[5]; //matrix3d 16 on IE10
1173          if (self.timerscroll && self.timerscroll.bz) return self.timerscroll.bz.getNow();
1174        }
1175        return self.doc.translate.y;
1176      };
1177
1178      this.getScrollLeft = function (last) {
1179        if (!last) {
1180          var mtx = getMatrixValues();
1181          if (mtx) return (mtx.length == 16) ? -mtx[12] : -mtx[4]; //matrix3d 16 on IE10
1182          if (self.timerscroll && self.timerscroll.bh) return self.timerscroll.bh.getNow();
1183        }
1184        return self.doc.translate.x;
1185      };
1186
1187      this.notifyScrollEvent = function (el) {
1188        var e = _doc.createEvent("UIEvents");
1189        e.initUIEvent("scroll", false, false, _win, 1);
1190        e.niceevent = true;
1191        el.dispatchEvent(e);
1192      };
1193
1194      var cxscrollleft = (this.isrtlmode) ? 1 : -1;
1195
1196      if (cap.hastranslate3d && opt.enabletranslate3d) {
1197        this.setScrollTop = function (val, silent) {
1198          self.doc.translate.y = val;
1199          self.doc.translate.ty = (val * -1) + "px";
1200          self.doc.css(cap.trstyle, "translate3d(" + self.doc.translate.tx + "," + self.doc.translate.ty + ",0)");
1201          if (!silent) self.notifyScrollEvent(self.win[0]);
1202        };
1203        this.setScrollLeft = function (val, silent) {
1204          self.doc.translate.x = val;
1205          self.doc.translate.tx = (val * cxscrollleft) + "px";
1206          self.doc.css(cap.trstyle, "translate3d(" + self.doc.translate.tx + "," + self.doc.translate.ty + ",0)");
1207          if (!silent) self.notifyScrollEvent(self.win[0]);
1208        };
1209      } else {
1210        this.setScrollTop = function (val, silent) {
1211          self.doc.translate.y = val;
1212          self.doc.translate.ty = (val * -1) + "px";
1213          self.doc.css(cap.trstyle, "translate(" + self.doc.translate.tx + "," + self.doc.translate.ty + ")");
1214          if (!silent) self.notifyScrollEvent(self.win[0]);
1215        };
1216        this.setScrollLeft = function (val, silent) {
1217          self.doc.translate.x = val;
1218          self.doc.translate.tx = (val * cxscrollleft) + "px";
1219          self.doc.css(cap.trstyle, "translate(" + self.doc.translate.tx + "," + self.doc.translate.ty + ")");
1220          if (!silent) self.notifyScrollEvent(self.win[0]);
1221        };
1222      }
1223    } else {    // native scroll
1224
1225      this.getScrollTop = function () {
1226        return self.docscroll.scrollTop();
1227      };
1228      this.setScrollTop = function (val) {
1229        self.docscroll.scrollTop(val);
1230      };
1231
1232      this.getScrollLeft = function () {
1233        var val;
1234        if (!self.hasreversehr) {
1235          val = self.docscroll.scrollLeft();
1236        } else if (self.detected.ismozilla) {
1237          val = self.page.maxw - Math.abs(self.docscroll.scrollLeft());
1238        } else {
1239          val = self.page.maxw - self.docscroll.scrollLeft();
1240        }
1241        return val;
1242      };
1243      this.setScrollLeft = function (val) {
1244        return setTimeout(function () {
1245          if (!self) return;
1246          if (self.hasreversehr) {
1247            if (self.detected.ismozilla) {
1248              val = -(self.page.maxw - val);
1249            } else {
1250              val = self.page.maxw - val;
1251            }
1252          }
1253          return self.docscroll.scrollLeft(val);
1254        }, 1);
1255      };
1256    }
1257
1258    this.getTarget = function (e) {
1259      if (!e) return false;
1260      if (e.target) return e.target;
1261      if (e.srcElement) return e.srcElement;
1262      return false;
1263    };
1264
1265    this.hasParent = function (e, id) {
1266      if (!e) return false;
1267      var el = e.target || e.srcElement || e || false;
1268      while (el && el.id != id) {
1269        el = el.parentNode || false;
1270      }
1271      return (el !== false);
1272    };
1273
1274    function getZIndex() {
1275      var dom = self.win;
1276      if ("zIndex" in dom) return dom.zIndex(); // use jQuery UI method when available
1277      while (dom.length > 0) {
1278        if (dom[0].nodeType == 9) return false;
1279        var zi = dom.css('zIndex');
1280        if (!isNaN(zi) && zi !== 0) return parseInt(zi);
1281        dom = dom.parent();
1282      }
1283      return false;
1284    }
1285
1286    //inspired by http://forum.jquery.com/topic/width-includes-border-width-when-set-to-thin-medium-thick-in-ie
1287    var _convertBorderWidth = {
1288      "thin": 1,
1289      "medium": 3,
1290      "thick": 5
1291    };
1292
1293    function getWidthToPixel(dom, prop, chkheight) {
1294      var wd = dom.css(prop);
1295      var px = parseFloat(wd);
1296      if (isNaN(px)) {
1297        px = _convertBorderWidth[wd] || 0;
1298        var brd = (px == 3) ? ((chkheight) ? (self.win.outerHeight() - self.win.innerHeight()) : (self.win.outerWidth() - self.win.innerWidth())) : 1; //DON'T TRUST CSS
1299        if (self.isie8 && px) px += 1;
1300        return (brd) ? px : 0;
1301      }
1302      return px;
1303    }
1304
1305    this.getDocumentScrollOffset = function () {
1306      return {
1307        top: _win.pageYOffset || _doc.documentElement.scrollTop,
1308        left: _win.pageXOffset || _doc.documentElement.scrollLeft
1309      };
1310    };
1311
1312    this.getOffset = function () {
1313      if (self.isfixed) {
1314        var ofs = self.win.offset();  // fix Chrome auto issue (when right/bottom props only)
1315        var scrl = self.getDocumentScrollOffset();
1316        ofs.top -= scrl.top;
1317        ofs.left -= scrl.left;
1318        return ofs;
1319      }
1320      var ww = self.win.offset();
1321      if (!self.viewport) return ww;
1322      var vp = self.viewport.offset();
1323      return {
1324        top: ww.top - vp.top,
1325        left: ww.left - vp.left
1326      };
1327    };
1328
1329    this.updateScrollBar = function (len) {
1330      var pos, off;
1331      if (self.ishwscroll) {
1332        self.rail.css({
1333          height: self.win.innerHeight() - (opt.railpadding.top + opt.railpadding.bottom)
1334        });
1335        if (self.railh) self.railh.css({
1336          width: self.win.innerWidth() - (opt.railpadding.left + opt.railpadding.right)
1337        });
1338      } else {
1339        var wpos = self.getOffset();
1340        pos = {
1341          top: wpos.top,
1342          left: wpos.left - (opt.railpadding.left + opt.railpadding.right)
1343        };
1344        pos.top += getWidthToPixel(self.win, 'border-top-width', true);
1345        pos.left += (self.rail.align) ? self.win.outerWidth() - getWidthToPixel(self.win, 'border-right-width') - self.rail.width : getWidthToPixel(self.win, 'border-left-width');
1346
1347        off = opt.railoffset;
1348        if (off) {
1349          if (off.top) pos.top += off.top;
1350          if (off.left) pos.left += off.left;
1351        }
1352
1353        if (!self.railslocked) self.rail.css({
1354          top: pos.top,
1355          left: pos.left,
1356          height: ((len) ? len.h : self.win.innerHeight()) - (opt.railpadding.top + opt.railpadding.bottom)
1357        });
1358
1359        if (self.zoom) {
1360          self.zoom.css({
1361            top: pos.top + 1,
1362            left: (self.rail.align == 1) ? pos.left - 20 : pos.left + self.rail.width + 4
1363          });
1364        }
1365
1366        if (self.railh && !self.railslocked) {
1367          pos = {
1368            top: wpos.top,
1369            left: wpos.left
1370          };
1371          off = opt.railhoffset;
1372          if (off) {
1373            if (off.top) pos.top += off.top;
1374            if (off.left) pos.left += off.left;
1375          }
1376          var y = (self.railh.align) ? pos.top + getWidthToPixel(self.win, 'border-top-width', true) + self.win.innerHeight() - self.railh.height : pos.top + getWidthToPixel(self.win, 'border-top-width', true);
1377          var x = pos.left + getWidthToPixel(self.win, 'border-left-width');
1378          self.railh.css({
1379            top: y - (opt.railpadding.top + opt.railpadding.bottom),
1380            left: x,
1381            width: self.railh.width
1382          });
1383        }
1384
1385      }
1386    };
1387
1388    this.doRailClick = function (e, dbl, hr) {
1389      var fn, pg, cur, pos;
1390
1391      if (self.railslocked) return;
1392
1393      self.cancelEvent(e);
1394
1395      if (!("pageY" in e)) {
1396        e.pageX = e.clientX + _doc.documentElement.scrollLeft;
1397        e.pageY = e.clientY + _doc.documentElement.scrollTop;
1398      }
1399
1400      if (dbl) {
1401        fn = (hr) ? self.doScrollLeft : self.doScrollTop;
1402        cur = (hr) ? ((e.pageX - self.railh.offset().left - (self.cursorwidth / 2)) * self.scrollratio.x) : ((e.pageY - self.rail.offset().top - (self.cursorheight / 2)) * self.scrollratio.y);
1403        self.unsynched("relativexy");
1404        fn(cur|0);
1405      } else {
1406        fn = (hr) ? self.doScrollLeftBy : self.doScrollBy;
1407        cur = (hr) ? self.scroll.x : self.scroll.y;
1408        pos = (hr) ? e.pageX - self.railh.offset().left : e.pageY - self.rail.offset().top;
1409        pg = (hr) ? self.view.w : self.view.h;
1410        fn((cur >= pos) ? pg : -pg);
1411      }
1412
1413    };
1414
1415    self.newscrolly = self.newscrollx = 0;
1416
1417    self.hasanimationframe = ("requestAnimationFrame" in _win);
1418    self.hascancelanimationframe = ("cancelAnimationFrame" in _win);
1419
1420    self.hasborderbox = false;
1421
1422    this.init = function () {
1423
1424      self.saved.css = [];
1425
1426      if (cap.isoperamini) return true; // SORRY, DO NOT WORK!
1427      if (cap.isandroid && !("hidden" in _doc)) return true; // Android 3- SORRY, DO NOT WORK!
1428
1429      opt.emulatetouch = opt.emulatetouch || opt.touchbehavior;  // mantain compatibility with "touchbehavior"      
1430
1431      self.hasborderbox = _win.getComputedStyle && (_win.getComputedStyle(_doc.body)['box-sizing'] === "border-box");
1432
1433      var _scrollyhidden = { 'overflow-y': 'hidden' };
1434      if (cap.isie11 || cap.isie10) _scrollyhidden['-ms-overflow-style'] = 'none';  // IE 10 & 11 is always a world apart!
1435
1436      if (self.ishwscroll) {
1437        this.doc.css(cap.transitionstyle, cap.prefixstyle + 'transform 0ms ease-out');
1438        if (cap.transitionend) self.bind(self.doc, cap.transitionend, self.onScrollTransitionEnd, false); //I have got to do something usefull!!
1439      }
1440
1441      self.zindex = "auto";
1442      if (!self.ispage && opt.zindex == "auto") {
1443        self.zindex = getZIndex() || "auto";
1444      } else {
1445        self.zindex = opt.zindex;
1446      }
1447
1448      if (!self.ispage && self.zindex != "auto" && self.zindex > globalmaxzindex) {
1449        globalmaxzindex = self.zindex;
1450      }
1451
1452      if (self.isie && self.zindex === 0 && opt.zindex == "auto") { // fix IE auto == 0
1453        self.zindex = "auto";
1454      }
1455
1456      if (!self.ispage || !cap.isieold) {
1457
1458        var cont = self.docscroll;
1459        if (self.ispage) cont = (self.haswrapper) ? self.win : self.doc;
1460
1461        self.css(cont, _scrollyhidden);
1462
1463        if (self.ispage && (cap.isie11 || cap.isie)) { // IE 7-11
1464          self.css($("html"), _scrollyhidden);
1465        }
1466
1467        if (cap.isios && !self.ispage && !self.haswrapper) self.css($body, {
1468          "-webkit-overflow-scrolling": "touch"
1469        }); //force hw acceleration
1470
1471        var cursor = $(_doc.createElement('div'));
1472        cursor.css({
1473          position: "relative",
1474          top: 0,
1475          "float": "right",
1476          width: opt.cursorwidth,
1477          height: 0,
1478          'background-color': opt.cursorcolor,
1479          border: opt.cursorborder,
1480          'background-clip': 'padding-box',
1481          '-webkit-border-radius': opt.cursorborderradius,
1482          '-moz-border-radius': opt.cursorborderradius,
1483          'border-radius': opt.cursorborderradius
1484        });
1485
1486        cursor.addClass('nicescroll-cursors');
1487
1488        self.cursor = cursor;
1489
1490        var rail = $(_doc.createElement('div'));
1491        rail.attr('id', self.id);
1492        rail.addClass('nicescroll-rails nicescroll-rails-vr');
1493
1494        var v, a, kp = ["left", "right", "top", "bottom"];  //**
1495        for (var n in kp) {
1496          a = kp[n];
1497          v = opt.railpadding[a] || 0;
1498          v && rail.css("padding-" + a, v + "px");
1499        }
1500
1501        rail.append(cursor);
1502
1503        rail.width = Math.max(parseFloat(opt.cursorwidth), cursor.outerWidth());
1504        rail.css({
1505          width: rail.width + "px",
1506          zIndex: self.zindex,
1507          background: opt.background,
1508          cursor: "default"
1509        });
1510
1511        rail.visibility = true;
1512        rail.scrollable = true;
1513
1514        rail.align = (opt.railalign == "left") ? 0 : 1;
1515
1516        self.rail = rail;
1517
1518        self.rail.drag = false;
1519
1520        var zoom = false;
1521        if (opt.boxzoom && !self.ispage && !cap.isieold) {
1522          zoom = _doc.createElement('div');
1523
1524          self.bind(zoom, "click", self.doZoom);
1525          self.bind(zoom, "mouseenter", function () {
1526            self.zoom.css('opacity', opt.cursoropacitymax);
1527          });
1528          self.bind(zoom, "mouseleave", function () {
1529            self.zoom.css('opacity', opt.cursoropacitymin);
1530          });
1531
1532          self.zoom = $(zoom);
1533          self.zoom.css({
1534            cursor: "pointer",
1535            zIndex: self.zindex,
1536            backgroundImage: 'url(' + opt.scriptpath + 'zoomico.png)',
1537            height: 18,
1538            width: 18,
1539            backgroundPosition: '0 0'
1540          });
1541          if (opt.dblclickzoom) self.bind(self.win, "dblclick", self.doZoom);
1542          if (cap.cantouch && opt.gesturezoom) {
1543            self.ongesturezoom = function (e) {
1544              if (e.scale > 1.5) self.doZoomIn(e);
1545              if (e.scale < 0.8) self.doZoomOut(e);
1546              return self.cancelEvent(e);
1547            };
1548            self.bind(self.win, "gestureend", self.ongesturezoom);
1549          }
1550        }
1551
1552        // init HORIZ
1553
1554        self.railh = false;
1555        var railh;
1556
1557        if (opt.horizrailenabled) {
1558
1559          self.css(cont, {
1560            overflowX: 'hidden'
1561          });
1562
1563          cursor = $(_doc.createElement('div'));
1564          cursor.css({
1565            position: "absolute",
1566            top: 0,
1567            height: opt.cursorwidth,
1568            width: 0,
1569            backgroundColor: opt.cursorcolor,
1570            border: opt.cursorborder,
1571            backgroundClip: 'padding-box',
1572            '-webkit-border-radius': opt.cursorborderradius,
1573            '-moz-border-radius': opt.cursorborderradius,
1574            'border-radius': opt.cursorborderradius
1575          });
1576
1577          if (cap.isieold) cursor.css('overflow', 'hidden');  //IE6 horiz scrollbar issue
1578
1579          cursor.addClass('nicescroll-cursors');
1580
1581          self.cursorh = cursor;
1582
1583          railh = $(_doc.createElement('div'));
1584          railh.attr('id', self.id + '-hr');
1585          railh.addClass('nicescroll-rails nicescroll-rails-hr');
1586          railh.height = Math.max(parseFloat(opt.cursorwidth), cursor.outerHeight());
1587          railh.css({
1588            height: railh.height + "px",
1589            'zIndex': self.zindex,
1590            "background": opt.background
1591          });
1592
1593          railh.append(cursor);
1594
1595          railh.visibility = true;
1596          railh.scrollable = true;
1597
1598          railh.align = (opt.railvalign == "top") ? 0 : 1;
1599
1600          self.railh = railh;
1601
1602          self.railh.drag = false;
1603
1604        }
1605
1606        if (self.ispage) {
1607
1608          rail.css({
1609            position: "fixed",
1610            top: 0,
1611            height: "100%"
1612          });
1613
1614          rail.css((rail.align) ? { right: 0 } : { left: 0 });
1615
1616          self.body.append(rail);
1617          if (self.railh) {
1618            railh.css({
1619              position: "fixed",
1620              left: 0,
1621              width: "100%"
1622            });
1623
1624            railh.css((railh.align) ? { bottom: 0 } : { top: 0 });
1625
1626            self.body.append(railh);
1627          }
1628        } else {
1629          if (self.ishwscroll) {
1630            if (self.win.css('position') == 'static') self.css(self.win, { 'position': 'relative' });
1631            var bd = (self.win[0].nodeName == 'HTML') ? self.body : self.win;
1632            $(bd).scrollTop(0).scrollLeft(0);  // fix rail position if content already scrolled
1633            if (self.zoom) {
1634              self.zoom.css({
1635                position: "absolute",
1636                top: 1,
1637                right: 0,
1638                "margin-right": rail.width + 4
1639              });
1640              bd.append(self.zoom);
1641            }
1642            rail.css({
1643              position: "absolute",
1644              top: 0
1645            });
1646            rail.css((rail.align) ? { right: 0 } : { left: 0 });
1647            bd.append(rail);
1648            if (railh) {
1649              railh.css({
1650                position: "absolute",
1651                left: 0,
1652                bottom: 0
1653              });
1654              railh.css((railh.align) ? { bottom: 0 } : { top: 0 });
1655              bd.append(railh);
1656            }
1657          } else {
1658            self.isfixed = (self.win.css("position") == "fixed");
1659            var rlpos = (self.isfixed) ? "fixed" : "absolute";
1660
1661            if (!self.isfixed) self.viewport = self.getViewport(self.win[0]);
1662            if (self.viewport) {
1663              self.body = self.viewport;
1664              if (!(/fixed|absolute/.test(self.viewport.css("position")))) self.css(self.viewport, {
1665                "position": "relative"
1666              });
1667            }
1668
1669            rail.css({
1670              position: rlpos
1671            });
1672            if (self.zoom) self.zoom.css({
1673              position: rlpos
1674            });
1675            self.updateScrollBar();
1676            self.body.append(rail);
1677            if (self.zoom) self.body.append(self.zoom);
1678            if (self.railh) {
1679              railh.css({
1680                position: rlpos
1681              });
1682              self.body.append(railh);
1683            }
1684          }
1685
1686          if (cap.isios) self.css(self.win, {
1687            '-webkit-tap-highlight-color': 'rgba(0,0,0,0)',
1688            '-webkit-touch-callout': 'none'
1689          }); // prevent grey layer on click
1690
1691          if (opt.disableoutline) {
1692            if (cap.isie) self.win.attr("hideFocus", "true"); // IE, prevent dotted rectangle on focused div
1693            if (cap.iswebkit) self.win.css('outline', 'none');  // Webkit outline
1694          }
1695
1696        }
1697
1698        if (opt.autohidemode === false) {
1699          self.autohidedom = false;
1700          self.rail.css({
1701            opacity: opt.cursoropacitymax
1702          });
1703          if (self.railh) self.railh.css({
1704            opacity: opt.cursoropacitymax
1705          });
1706        } else if ((opt.autohidemode === true) || (opt.autohidemode === "leave")) {
1707          self.autohidedom = $().add(self.rail);
1708          if (cap.isie8) self.autohidedom = self.autohidedom.add(self.cursor);
1709          if (self.railh) self.autohidedom = self.autohidedom.add(self.railh);
1710          if (self.railh && cap.isie8) self.autohidedom = self.autohidedom.add(self.cursorh);
1711        } else if (opt.autohidemode == "scroll") {
1712          self.autohidedom = $().add(self.rail);
1713          if (self.railh) self.autohidedom = self.autohidedom.add(self.railh);
1714        } else if (opt.autohidemode == "cursor") {
1715          self.autohidedom = $().add(self.cursor);
1716          if (self.railh) self.autohidedom = self.autohidedom.add(self.cursorh);
1717        } else if (opt.autohidemode == "hidden") {
1718          self.autohidedom = false;
1719          self.hide();
1720          self.railslocked = false;
1721        }
1722
1723        if (cap.cantouch || self.istouchcapable || opt.emulatetouch || cap.hasmstouch) {
1724
1725          self.scrollmom = new ScrollMomentumClass2D(self);
1726
1727          var delayedclick = null;
1728
1729          self.ontouchstart = function (e) {
1730
1731            if (self.locked) return false;
1732
1733            //if (e.pointerType && e.pointerType != 2 && e.pointerType != "touch") return false;
1734            if (e.pointerType && (e.pointerType === 'mouse' || e.pointerType === e.MSPOINTER_TYPE_MOUSE)) return false;  // need test on surface!!
1735
1736            self.hasmoving = false;
1737
1738            if (self.scrollmom.timer) {
1739              self.triggerScrollEnd();
1740              self.scrollmom.stop();
1741            }
1742
1743            if (!self.railslocked) {
1744              var tg = self.getTarget(e);
1745
1746              if (tg) {
1747                var skp = (/INPUT/i.test(tg.nodeName)) && (/range/i.test(tg.type));
1748                if (skp) return self.stopPropagation(e);
1749              }
1750
1751              var ismouse = (e.type === "mousedown");
1752
1753              if (!("clientX" in e) && ("changedTouches" in e)) {
1754                e.clientX = e.changedTouches[0].clientX;
1755                e.clientY = e.changedTouches[0].clientY;
1756              }
1757
1758              if (self.forcescreen) {
1759                var le = e;
1760                e = {
1761                  "original": (e.original) ? e.original : e
1762                };
1763                e.clientX = le.screenX;
1764                e.clientY = le.screenY;
1765              }
1766
1767              self.rail.drag = {
1768                x: e.clientX,
1769                y: e.clientY,
1770                sx: self.scroll.x,
1771                sy: self.scroll.y,
1772                st: self.getScrollTop(),
1773                sl: self.getScrollLeft(),
1774                pt: 2,
1775                dl: false,
1776                tg: tg
1777              };
1778
1779              if (self.ispage || !opt.directionlockdeadzone) {
1780
1781                self.rail.drag.dl = "f";
1782
1783              } else {
1784
1785                var view = {
1786                  w: $window.width(),
1787                  h: $window.height()
1788                };
1789
1790                var page = self.getContentSize();
1791
1792                var maxh = page.h - view.h;
1793                var maxw = page.w - view.w;
1794
1795                if (self.rail.scrollable && !self.railh.scrollable) self.rail.drag.ck = (maxh > 0) ? "v" : false;
1796                else if (!self.rail.scrollable && self.railh.scrollable) self.rail.drag.ck = (maxw > 0) ? "h" : false;
1797                else self.rail.drag.ck = false;
1798
1799              }
1800
1801              if (opt.emulatetouch && self.isiframe && cap.isie) {
1802                var wp = self.win.position();
1803                self.rail.drag.x += wp.left;
1804                self.rail.drag.y += wp.top;
1805              }
1806
1807              self.hasmoving = false;
1808              self.lastmouseup = false;
1809              self.scrollmom.reset(e.clientX, e.clientY);
1810
1811              if (tg&&ismouse) {
1812
1813                var ip = /INPUT|SELECT|BUTTON|TEXTAREA/i.test(tg.nodeName);
1814                if (!ip) {
1815                  if (cap.hasmousecapture) tg.setCapture();
1816                  if (opt.emulatetouch) {
1817                    if (tg.onclick && !(tg._onclick || false)) { // intercept DOM0 onclick event
1818                      tg._onclick = tg.onclick;
1819                      tg.onclick = function (e) {
1820                        if (self.hasmoving) return false;
1821                        tg._onclick.call(this, e);
1822                      };
1823                    }
1824                    return self.cancelEvent(e);
1825                  }
1826                  return self.stopPropagation(e);
1827                }
1828
1829                if (/SUBMIT|CANCEL|BUTTON/i.test($(tg).attr('type'))) {
1830                  self.preventclick = {
1831                    "tg": tg,
1832                    "click": false
1833                  };
1834                }
1835
1836              }
1837            }
1838
1839          };
1840
1841          self.ontouchend = function (e) {
1842
1843            if (!self.rail.drag) return true;
1844
1845            if (self.rail.drag.pt == 2) {
1846              //if (e.pointerType && e.pointerType != 2 && e.pointerType != "touch") return false;
1847              if (e.pointerType && (e.pointerType === 'mouse' || e.pointerType === e.MSPOINTER_TYPE_MOUSE)) return false;
1848
1849              self.rail.drag = false;
1850
1851              var ismouse = (e.type === "mouseup");
1852
1853              if (self.hasmoving) {
1854                self.scrollmom.doMomentum();
1855                self.lastmouseup = true;
1856                self.hideCursor();
1857                if (cap.hasmousecapture) _doc.releaseCapture();
1858                if (ismouse) return self.cancelEvent(e);
1859              }
1860
1861            }
1862            else if (self.rail.drag.pt == 1) {
1863              return self.onmouseup(e);
1864            }
1865
1866          };
1867
1868          var moveneedoffset = (opt.emulatetouch && self.isiframe && !cap.hasmousecapture);
1869
1870          var locktollerance = opt.directionlockdeadzone * 0.3 | 0;
1871
1872          self.ontouchmove = function (e, byiframe) {
1873
1874            if (!self.rail.drag) return true;
1875
1876            if (e.targetTouches && opt.preventmultitouchscrolling) {
1877              if (e.targetTouches.length > 1) return true; // multitouch
1878            }
1879
1880            //if (e.pointerType && e.pointerType != 2 && e.pointerType != "touch") return false;
1881            if (e.pointerType && (e.pointerType === 'mouse' || e.pointerType === e.MSPOINTER_TYPE_MOUSE)) return true;
1882
1883            if (self.rail.drag.pt == 2) {
1884
1885              if (("changedTouches" in e)) {
1886                e.clientX = e.changedTouches[0].clientX;
1887                e.clientY = e.changedTouches[0].clientY;
1888              }
1889
1890              var ofy, ofx;
1891              ofx = ofy = 0;
1892
1893              if (moveneedoffset && !byiframe) {
1894                var wp = self.win.position();
1895                ofx = -wp.left;
1896                ofy = -wp.top;
1897              }
1898
1899              var fy = e.clientY + ofy;
1900              var my = (fy - self.rail.drag.y);
1901              var fx = e.clientX + ofx;
1902              var mx = (fx - self.rail.drag.x);
1903
1904              var ny = self.rail.drag.st - my;
1905
1906              if (self.ishwscroll && opt.bouncescroll) {
1907                if (ny < 0) {
1908                  ny = Math.round(ny / 2);
1909                } else if (ny > self.page.maxh) {
1910                  ny = self.page.maxh + Math.round((ny - self.page.maxh) / 2);
1911                }
1912              } else {
1913                if (ny < 0) {
1914                  ny = 0;
1915                  fy = 0;
1916                }
1917                else if (ny > self.page.maxh) {
1918                  ny = self.page.maxh;
1919                  fy = 0;
1920                }
1921                if (fy === 0 && !self.hasmoving) {
1922                  if (!self.ispage) self.rail.drag = false;
1923                  return true;
1924                }
1925              }
1926
1927              var nx = self.getScrollLeft();
1928
1929              if (self.railh && self.railh.scrollable) {
1930                nx = (self.isrtlmode) ? mx - self.rail.drag.sl : self.rail.drag.sl - mx;
1931
1932                if (self.ishwscroll && opt.bouncescroll) {
1933                  if (nx < 0) {
1934                    nx = Math.round(nx / 2);
1935                  } else if (nx > self.page.maxw) {
1936                    nx = self.page.maxw + Math.round((nx - self.page.maxw) / 2);
1937                  }
1938                } else {
1939                  if (nx < 0) {
1940                    nx = 0;
1941                    fx = 0;
1942                  }
1943                  if (nx > self.page.maxw) {
1944                    nx = self.page.maxw;
1945                    fx = 0;
1946                  }
1947                }
1948
1949              }
1950
1951
1952              if (!self.hasmoving) {
1953
1954                if (self.rail.drag.y === e.clientY && self.rail.drag.x === e.clientX) return self.cancelEvent(e);  // prevent first useless move event 
1955
1956                var ay = Math.abs(my);
1957                var ax = Math.abs(mx);
1958                var dz = opt.directionlockdeadzone;
1959
1960                if (!self.rail.drag.ck) {
1961                  if (ay > dz && ax > dz) self.rail.drag.dl = "f";
1962                  else if (ay > dz) self.rail.drag.dl = (ax > locktollerance) ? "f" : "v";
1963                  else if (ax > dz) self.rail.drag.dl = (ay > locktollerance) ? "f" : "h";
1964                }
1965                else if (self.rail.drag.ck == "v") {
1966                  if (ax > dz && ay <= locktollerance) {
1967                    self.rail.drag = false;
1968                  }
1969                  else if (ay > dz) self.rail.drag.dl = "v";
1970
1971                }
1972                else if (self.rail.drag.ck == "h") {
1973
1974                  if (ay > dz && ax <= locktollerance) {
1975                    self.rail.drag = false;
1976                  }
1977                  else if (ax > dz) self.rail.drag.dl = "h";
1978
1979                }
1980
1981                if (!self.rail.drag.dl) return self.cancelEvent(e);
1982
1983                self.triggerScrollStart(e.clientX, e.clientY, 0, 0, 0);
1984                self.hasmoving = true;
1985              }
1986
1987              if (self.preventclick && !self.preventclick.click) {
1988                self.preventclick.click = self.preventclick.tg.onclick || false;
1989                self.preventclick.tg.onclick = self.onpreventclick;
1990              }
1991
1992              if (self.rail.drag.dl) {
1993                if (self.rail.drag.dl == "v") nx = self.rail.drag.sl;
1994                else if (self.rail.drag.dl == "h") ny = self.rail.drag.st;
1995              }
1996
1997              self.synched("touchmove", function () {
1998                if (self.rail.drag && (self.rail.drag.pt == 2)) {
1999                  if (self.prepareTransition) self.resetTransition();
2000                  if (self.rail.scrollable) self.setScrollTop(ny);
2001                  self.scrollmom.update(fx, fy);
2002                  if (self.railh && self.railh.scrollable) {
2003                    self.setScrollLeft(nx);
2004                    self.showCursor(ny, nx);
2005                  } else {
2006                    self.showCursor(ny);
2007                  }
2008                  if (cap.isie10) _doc.selection.clear();
2009                }
2010              });
2011
2012              return self.cancelEvent(e);
2013
2014            }
2015            else if (self.rail.drag.pt == 1) { // drag on cursor
2016              return self.onmousemove(e);
2017            }
2018
2019          };
2020
2021          self.ontouchstartCursor = function (e, hronly) {
2022            if (self.rail.drag && self.rail.drag.pt != 3) return;
2023            if (self.locked) return self.cancelEvent(e);
2024            self.cancelScroll();
2025            self.rail.drag = {
2026              x: e.touches[0].clientX,
2027              y: e.touches[0].clientY,
2028              sx: self.scroll.x,
2029              sy: self.scroll.y,
2030              pt: 3,
2031              hr: (!!hronly)
2032            };
2033            var tg = self.getTarget(e);
2034            if (!self.ispage && cap.hasmousecapture) tg.setCapture();
2035            if (self.isiframe && !cap.hasmousecapture) {
2036              self.saved.csspointerevents = self.doc.css("pointer-events");
2037              self.css(self.doc, { "pointer-events": "none" });
2038            }
2039            return self.cancelEvent(e);
2040          };
2041
2042          self.ontouchendCursor = function (e) {
2043            if (self.rail.drag) {
2044              if (cap.hasmousecapture) _doc.releaseCapture();
2045              if (self.isiframe && !cap.hasmousecapture) self.doc.css("pointer-events", self.saved.csspointerevents);
2046              if (self.rail.drag.pt != 3) return;
2047              self.rail.drag = false;
2048              return self.cancelEvent(e);
2049            }
2050          };
2051
2052          self.ontouchmoveCursor = function (e) {
2053            if (self.rail.drag) {
2054              if (self.rail.drag.pt != 3) return;
2055
2056              self.cursorfreezed = true;
2057
2058              if (self.rail.drag.hr) {
2059                self.scroll.x = self.rail.drag.sx + (e.touches[0].clientX - self.rail.drag.x);
2060                if (self.scroll.x < 0) self.scroll.x = 0;
2061                var mw = self.scrollvaluemaxw;
2062                if (self.scroll.x > mw) self.scroll.x = mw;
2063              } else {
2064                self.scroll.y = self.rail.drag.sy + (e.touches[0].clientY - self.rail.drag.y);
2065                if (self.scroll.y < 0) self.scroll.y = 0;
2066                var my = self.scrollvaluemax;
2067                if (self.scroll.y > my) self.scroll.y = my;
2068              }
2069
2070              self.synched('touchmove', function () {
2071                if (self.rail.drag && (self.rail.drag.pt == 3)) {
2072                  self.showCursor();
2073                  if (self.rail.drag.hr) self.doScrollLeft(Math.round(self.scroll.x * self.scrollratio.x), opt.cursordragspeed);
2074                  else self.doScrollTop(Math.round(self.scroll.y * self.scrollratio.y), opt.cursordragspeed);
2075                }
2076              });
2077
2078              return self.cancelEvent(e);
2079            }
2080
2081          };
2082
2083        }
2084
2085        self.onmousedown = function (e, hronly) {
2086          if (self.rail.drag && self.rail.drag.pt != 1) return;
2087          if (self.railslocked) return self.cancelEvent(e);
2088          self.cancelScroll();
2089          self.rail.drag = {
2090            x: e.clientX,
2091            y: e.clientY,
2092            sx: self.scroll.x,
2093            sy: self.scroll.y,
2094            pt: 1,
2095            hr: hronly || false
2096          };
2097          var tg = self.getTarget(e);
2098
2099          if (cap.hasmousecapture) tg.setCapture();
2100          if (self.isiframe && !cap.hasmousecapture) {
2101            self.saved.csspointerevents = self.doc.css("pointer-events");
2102            self.css(self.doc, {
2103              "pointer-events": "none"
2104            });
2105          }
2106          self.hasmoving = false;
2107          return self.cancelEvent(e);
2108        };
2109
2110        self.onmouseup = function (e) {
2111          if (self.rail.drag) {
2112            if (self.rail.drag.pt != 1) return true;
2113
2114            if (cap.hasmousecapture) _doc.releaseCapture();
2115            if (self.isiframe && !cap.hasmousecapture) self.doc.css("pointer-events", self.saved.csspointerevents);
2116            self.rail.drag = false;
2117            self.cursorfreezed = false;
2118            if (self.hasmoving) self.triggerScrollEnd();
2119            return self.cancelEvent(e);
2120          }
2121        };
2122
2123        self.onmousemove = function (e) {
2124          if (self.rail.drag) {
2125            if (self.rail.drag.pt !== 1) return;
2126
2127            if (cap.ischrome && e.which === 0) return self.onmouseup(e);
2128
2129            self.cursorfreezed = true;
2130
2131            if (!self.hasmoving) self.triggerScrollStart(e.clientX, e.clientY, 0, 0, 0);
2132
2133            self.hasmoving = true;
2134
2135            if (self.rail.drag.hr) {
2136              self.scroll.x = self.rail.drag.sx + (e.clientX - self.rail.drag.x);
2137              if (self.scroll.x < 0) self.scroll.x = 0;
2138              var mw = self.scrollvaluemaxw;
2139              if (self.scroll.x > mw) self.scroll.x = mw;
2140            } else {
2141              self.scroll.y = self.rail.drag.sy + (e.clientY - self.rail.drag.y);
2142              if (self.scroll.y < 0) self.scroll.y = 0;
2143              var my = self.scrollvaluemax;
2144              if (self.scroll.y > my) self.scroll.y = my;
2145            }
2146
2147            self.synched('mousemove', function () {
2148
2149              if (self.cursorfreezed) {
2150                self.showCursor();
2151
2152                if (self.rail.drag.hr) {
2153                  self.scrollLeft(Math.round(self.scroll.x * self.scrollratio.x));
2154                } else {
2155                  self.scrollTop(Math.round(self.scroll.y * self.scrollratio.y));
2156                }
2157
2158              }
2159            });
2160
2161            return self.cancelEvent(e);
2162          }
2163          else {
2164            self.checkarea = 0;
2165          }
2166        };
2167
2168        if (cap.cantouch || opt.emulatetouch) {
2169
2170          self.onpreventclick = function (e) {
2171            if (self.preventclick) {
2172              self.preventclick.tg.onclick = self.preventclick.click;
2173              self.preventclick = false;
2174              return self.cancelEvent(e);
2175            }
2176          };
2177
2178          self.onclick = (cap.isios) ? false : function (e) {  // it needs to check IE11 ???
2179            if (self.lastmouseup) {
2180              self.lastmouseup = false;
2181              return self.cancelEvent(e);
2182            } else {
2183              return true;
2184            }
2185          };
2186
2187          if (opt.grabcursorenabled && cap.cursorgrabvalue) {
2188            self.css((self.ispage) ? self.doc : self.win, {
2189              'cursor': cap.cursorgrabvalue
2190            });
2191            self.css(self.rail, {
2192              'cursor': cap.cursorgrabvalue
2193            });
2194          }
2195
2196        } else {
2197
2198          var checkSelectionScroll = function (e) {
2199            if (!self.selectiondrag) return;
2200
2201            if (e) {
2202              var ww = self.win.outerHeight();
2203              var df = (e.pageY - self.selectiondrag.top);
2204              if (df > 0 && df < ww) df = 0;
2205              if (df >= ww) df -= ww;
2206              self.selectiondrag.df = df;
2207            }
2208            if (self.selectiondrag.df === 0) return;
2209
2210            var rt = -(self.selectiondrag.df*2/6)|0;
2211            self.doScrollBy(rt);
2212
2213            self.debounced("doselectionscroll", function () {
2214              checkSelectionScroll();
2215            }, 50);
2216          };
2217
2218          if ("getSelection" in _doc) { // A grade - Major browsers
2219            self.hasTextSelected = function () {
2220              return (_doc.getSelection().rangeCount > 0);
2221            };
2222          } else if ("selection" in _doc) { //IE9-
2223            self.hasTextSelected = function () {
2224              return (_doc.selection.type != "None");
2225            };
2226          } else {
2227            self.hasTextSelected = function () { // no support
2228              return false;
2229            };
2230          }
2231
2232          self.onselectionstart = function (e) {
2233            //  More testing - severe chrome issues           
2234            /* 
2235                          if (!self.haswrapper&&(e.which&&e.which==2)) {  // fool browser to manage middle button scrolling
2236                            self.win.css({'overflow':'auto'});
2237                            setTimeout(function(){
2238                              self.win.css({'overflow':'hidden'});
2239                            },10);                
2240                            return true;
2241                          }            
2242            */
2243            if (self.ispage) return;
2244            self.selectiondrag = self.win.offset();
2245          };
2246
2247          self.onselectionend = function (e) {
2248            self.selectiondrag = false;
2249          };
2250          self.onselectiondrag = function (e) {
2251            if (!self.selectiondrag) return;
2252            if (self.hasTextSelected()) self.debounced("selectionscroll", function () {
2253              checkSelectionScroll(e);
2254            }, 250);
2255          };
2256        }
2257
2258        if (cap.hasw3ctouch) { //IE11+
2259          self.css((self.ispage) ? $("html") : self.win, { 'touch-action': 'none' });
2260          self.css(self.rail, {
2261            'touch-action': 'none'
2262          });
2263          self.css(self.cursor, {
2264            'touch-action': 'none'
2265          });
2266          self.bind(self.win, "pointerdown", self.ontouchstart);
2267          self.bind(_doc, "pointerup", self.ontouchend);
2268          self.delegate(_doc, "pointermove", self.ontouchmove);
2269        } else if (cap.hasmstouch) { //IE10
2270          self.css((self.ispage) ? $("html") : self.win, { '-ms-touch-action': 'none' });
2271          self.css(self.rail, {
2272            '-ms-touch-action': 'none'
2273          });
2274          self.css(self.cursor, {
2275            '-ms-touch-action': 'none'
2276          });
2277          self.bind(self.win, "MSPointerDown", self.ontouchstart);
2278          self.bind(_doc, "MSPointerUp", self.ontouchend);
2279          self.delegate(_doc, "MSPointerMove", self.ontouchmove);
2280          self.bind(self.cursor, "MSGestureHold", function (e) {
2281            e.preventDefault();
2282          });
2283          self.bind(self.cursor, "contextmenu", function (e) {
2284            e.preventDefault();
2285          });
2286        } else if (cap.cantouch) { // smartphones/touch devices
2287          self.bind(self.win, "touchstart", self.ontouchstart, false, true);
2288          self.bind(_doc, "touchend", self.ontouchend, false, true);
2289          self.bind(_doc, "touchcancel", self.ontouchend, false, true);
2290          self.delegate(_doc, "touchmove", self.ontouchmove, false, true);
2291        }
2292
2293        if (opt.emulatetouch) {
2294          self.bind(self.win, "mousedown", self.ontouchstart, false, true);
2295          self.bind(_doc, "mouseup", self.ontouchend, false, true);
2296          self.bind(_doc, "mousemove", self.ontouchmove, false, true);
2297        }
2298
2299        if (opt.cursordragontouch || (!cap.cantouch && !opt.emulatetouch)) {
2300
2301          self.rail.css({
2302            cursor: "default"
2303          });
2304          self.railh && self.railh.css({
2305            cursor: "default"
2306          });
2307
2308          self.jqbind(self.rail, "mouseenter", function () {
2309            if (!self.ispage && !self.win.is(":visible")) return false;
2310            if (self.canshowonmouseevent) self.showCursor();
2311            self.rail.active = true;
2312          });
2313          self.jqbind(self.rail, "mouseleave", function () {
2314            self.rail.active = false;
2315            if (!self.rail.drag) self.hideCursor();
2316          });
2317
2318          if (opt.sensitiverail) {
2319            self.bind(self.rail, "click", function (e) {
2320              self.doRailClick(e, false, false);
2321            });
2322            self.bind(self.rail, "dblclick", function (e) {
2323              self.doRailClick(e, true, false);
2324            });
2325            self.bind(self.cursor, "click", function (e) {
2326              self.cancelEvent(e);
2327            });
2328            self.bind(self.cursor, "dblclick", function (e) {
2329              self.cancelEvent(e);
2330            });
2331          }
2332
2333          if (self.railh) {
2334            self.jqbind(self.railh, "mouseenter", function () {
2335              if (!self.ispage && !self.win.is(":visible")) return false;
2336              if (self.canshowonmouseevent) self.showCursor();
2337              self.rail.active = true;
2338            });
2339            self.jqbind(self.railh, "mouseleave", function () {
2340              self.rail.active = false;
2341              if (!self.rail.drag) self.hideCursor();
2342            });
2343
2344            if (opt.sensitiverail) {
2345              self.bind(self.railh, "click", function (e) {
2346                self.doRailClick(e, false, true);
2347              });
2348              self.bind(self.railh, "dblclick", function (e) {
2349                self.doRailClick(e, true, true);
2350              });
2351              self.bind(self.cursorh, "click", function (e) {
2352                self.cancelEvent(e);
2353              });
2354              self.bind(self.cursorh, "dblclick", function (e) {
2355                self.cancelEvent(e);
2356              });
2357            }
2358
2359          }
2360
2361        }
2362
2363        if (opt.cursordragontouch && (this.istouchcapable || cap.cantouch)) {
2364          self.bind(self.cursor, "touchstart", self.ontouchstartCursor);
2365          self.bind(self.cursor, "touchmove", self.ontouchmoveCursor);
2366          self.bind(self.cursor, "touchend", self.ontouchendCursor);
2367          self.cursorh && self.bind(self.cursorh, "touchstart", function (e) {
2368            self.ontouchstartCursor(e, true);
2369          });
2370          self.cursorh && self.bind(self.cursorh, "touchmove", self.ontouchmoveCursor);
2371          self.cursorh && self.bind(self.cursorh, "touchend", self.ontouchendCursor);
2372        }
2373
2374//        if (!cap.cantouch && !opt.emulatetouch) {
2375        if (!opt.emulatetouch && !cap.isandroid && !cap.isios) {
2376
2377          self.bind((cap.hasmousecapture) ? self.win : _doc, "mouseup", self.onmouseup);
2378          self.bind(_doc, "mousemove", self.onmousemove);
2379          if (self.onclick) self.bind(_doc, "click", self.onclick);
2380
2381          self.bind(self.cursor, "mousedown", self.onmousedown);
2382          self.bind(self.cursor, "mouseup", self.onmouseup);
2383
2384          if (self.railh) {
2385            self.bind(self.cursorh, "mousedown", function (e) {
2386              self.onmousedown(e, true);
2387            });
2388            self.bind(self.cursorh, "mouseup", self.onmouseup);
2389          }
2390
2391          if (!self.ispage && opt.enablescrollonselection) {
2392            self.bind(self.win[0], "mousedown", self.onselectionstart);
2393            self.bind(_doc, "mouseup", self.onselectionend);
2394            self.bind(self.cursor, "mouseup", self.onselectionend);
2395            if (self.cursorh) self.bind(self.cursorh, "mouseup", self.onselectionend);
2396            self.bind(_doc, "mousemove", self.onselectiondrag);
2397          }
2398
2399          if (self.zoom) {
2400            self.jqbind(self.zoom, "mouseenter", function () {
2401              if (self.canshowonmouseevent) self.showCursor();
2402              self.rail.active = true;
2403            });
2404            self.jqbind(self.zoom, "mouseleave", function () {
2405              self.rail.active = false;
2406              if (!self.rail.drag) self.hideCursor();
2407            });
2408          }
2409
2410        } else {
2411
2412          self.bind((cap.hasmousecapture) ? self.win : _doc, "mouseup", self.ontouchend);
2413          if (self.onclick) self.bind(_doc, "click", self.onclick);
2414
2415          if (opt.cursordragontouch) {
2416            self.bind(self.cursor, "mousedown", self.onmousedown);
2417            self.bind(self.cursor, "mouseup", self.onmouseup);
2418            self.cursorh && self.bind(self.cursorh, "mousedown", function (e) {
2419              self.onmousedown(e, true);
2420            });
2421            self.cursorh && self.bind(self.cursorh, "mouseup", self.onmouseup);
2422          } else {
2423            self.bind(self.rail, "mousedown", function (e) { e.preventDefault(); });  // prevent text selection             
2424            self.railh && self.bind(self.railh, "mousedown", function (e) { e.preventDefault(); });
2425          }
2426
2427        }
2428
2429
2430        if (opt.enablemousewheel) {
2431          if (!self.isiframe) self.mousewheel((cap.isie && self.ispage) ? _doc : self.win, self.onmousewheel);
2432          self.mousewheel(self.rail, self.onmousewheel);
2433          if (self.railh) self.mousewheel(self.railh, self.onmousewheelhr);
2434        }
2435
2436        if (!self.ispage && !cap.cantouch && !(/HTML|^BODY/.test(self.win[0].nodeName))) {
2437          if (!self.win.attr("tabindex")) self.win.attr({
2438            "tabindex": ++tabindexcounter
2439          });
2440
2441          self.bind(self.win, "focus", function (e) {  // better using native events
2442            domfocus = (self.getTarget(e)).id || self.getTarget(e) || false;
2443            self.hasfocus = true;
2444            if (self.canshowonmouseevent) self.noticeCursor();
2445          });
2446          self.bind(self.win, "blur", function (e) {  // *
2447            domfocus = false;
2448            self.hasfocus = false;
2449          });
2450
2451          self.bind(self.win, "mouseenter", function (e) {   // *
2452            mousefocus = (self.getTarget(e)).id || self.getTarget(e) || false;
2453            self.hasmousefocus = true;
2454            if (self.canshowonmouseevent) self.noticeCursor();
2455          });
2456          self.bind(self.win, "mouseleave", function (e) {   // *       
2457            mousefocus = false;
2458            self.hasmousefocus = false;
2459            if (!self.rail.drag) self.hideCursor();
2460          });
2461
2462        }
2463
2464
2465        //Thanks to http://www.quirksmode.org !!
2466        self.onkeypress = function (e) {
2467          if (self.railslocked && self.page.maxh === 0) return true;
2468
2469          e = e || _win.event;
2470          var tg = self.getTarget(e);
2471          if (tg && /INPUT|TEXTAREA|SELECT|OPTION/.test(tg.nodeName)) {
2472            var tp = tg.getAttribute('type') || tg.type || false;
2473            if ((!tp) || !(/submit|button|cancel/i.tp)) return true;
2474          }
2475
2476          if ($(tg).attr('contenteditable')) return true;
2477
2478          if (self.hasfocus || (self.hasmousefocus && !domfocus) || (self.ispage && !domfocus && !mousefocus)) {
2479            var key = e.keyCode;
2480
2481            if (self.railslocked && key != 27) return self.cancelEvent(e);
2482
2483            var ctrl = e.ctrlKey || false;
2484            var shift = e.shiftKey || false;
2485
2486            var ret = false;
2487            switch (key) {
2488              case 38:
2489              case 63233: //safari
2490                self.doScrollBy(24 * 3);
2491                ret = true;
2492                break;
2493              case 40:
2494              case 63235: //safari
2495                self.doScrollBy(-24 * 3);
2496                ret = true;
2497                break;
2498              case 37:
2499              case 63232: //safari
2500                if (self.railh) {
2501                  (ctrl) ? self.doScrollLeft(0) : self.doScrollLeftBy(24 * 3);
2502                  ret = true;
2503                }
2504                break;
2505              case 39:
2506              case 63234: //safari
2507                if (self.railh) {
2508                  (ctrl) ? self.doScrollLeft(self.page.maxw) : self.doScrollLeftBy(-24 * 3);
2509                  ret = true;
2510                }
2511                break;
2512              case 33:
2513              case 63276: // safari
2514                self.doScrollBy(self.view.h);
2515                ret = true;
2516                break;
2517              case 34:
2518              case 63277: // safari
2519                self.doScrollBy(-self.view.h);
2520                ret = true;
2521                break;
2522              case 36:
2523              case 63273: // safari                
2524                (self.railh && ctrl) ? self.doScrollPos(0, 0) : self.doScrollTo(0);
2525                ret = true;
2526                break;
2527              case 35:
2528              case 63275: // safari
2529                (self.railh && ctrl) ? self.doScrollPos(self.page.maxw, self.page.maxh) : self.doScrollTo(self.page.maxh);
2530                ret = true;
2531                break;
2532              case 32:
2533                if (opt.spacebarenabled) {
2534                  (shift) ? self.doScrollBy(self.view.h) : self.doScrollBy(-self.view.h);
2535                  ret = true;
2536                }
2537                break;
2538              case 27: // ESC
2539                if (self.zoomactive) {
2540                  self.doZoom();
2541                  ret = true;
2542                }
2543                break;
2544            }
2545            if (ret) return self.cancelEvent(e);
2546          }
2547        };
2548
2549        if (opt.enablekeyboard) self.bind(_doc, (cap.isopera && !cap.isopera12) ? "keypress" : "keydown", self.onkeypress);
2550
2551        self.bind(_doc, "keydown", function (e) {
2552          var ctrl = e.ctrlKey || false;
2553          if (ctrl) self.wheelprevented = true;
2554        });
2555        self.bind(_doc, "keyup", function (e) {
2556          var ctrl = e.ctrlKey || false;
2557          if (!ctrl) self.wheelprevented = false;
2558        });
2559        self.bind(_win, "blur", function (e) {
2560          self.wheelprevented = false;
2561        });
2562
2563        self.bind(_win, 'resize', self.onscreenresize);
2564        self.bind(_win, 'orientationchange', self.onscreenresize);
2565
2566        self.bind(_win, "load", self.lazyResize);
2567
2568        if (cap.ischrome && !self.ispage && !self.haswrapper) { //chrome void scrollbar bug - it persists in version 26
2569          var tmp = self.win.attr("style");
2570          var ww = parseFloat(self.win.css("width")) + 1;
2571          self.win.css('width', ww);
2572          self.synched("chromefix", function () {
2573            self.win.attr("style", tmp);
2574          });
2575        }
2576
2577
2578        // Trying a cross-browser implementation - good luck!
2579
2580        self.onAttributeChange = function (e) {
2581          self.lazyResize(self.isieold ? 250 : 30);
2582        };
2583
2584        if (opt.enableobserver) {
2585
2586          if ((!self.isie11) && (ClsMutationObserver !== false)) {  // IE11 crashes  #568
2587            self.observerbody = new ClsMutationObserver(function (mutations) {
2588              mutations.forEach(function (mut) {
2589                if (mut.type == "attributes") {
2590                  return ($body.hasClass("modal-open") && $body.hasClass("modal-dialog") && !$.contains($('.modal-dialog')[0], self.doc[0])) ? self.hide() : self.show();  // Support for Bootstrap modal; Added check if the nice scroll element is inside a modal
2591                }
2592              });
2593              if (self.me.clientWidth != self.page.width || self.me.clientHeight != self.page.height) return self.lazyResize(30);
2594            });
2595            self.observerbody.observe(_doc.body, {
2596              childList: true,
2597              subtree: true,
2598              characterData: false,
2599              attributes: true,
2600              attributeFilter: ['class']
2601            });
2602          }
2603
2604          if (!self.ispage && !self.haswrapper) {
2605
2606            var _dom = self.win[0];
2607
2608            // redesigned MutationObserver for Chrome18+/Firefox14+/iOS6+ with support for: remove div, add/remove content
2609            if (ClsMutationObserver !== false) {
2610              self.observer = new ClsMutationObserver(function (mutations) {
2611                mutations.forEach(self.onAttributeChange);
2612              });
2613              self.observer.observe(_dom, {
2614                childList: true,
2615                characterData: false,
2616                attributes: true,
2617                subtree: false
2618              });
2619              self.observerremover = new ClsMutationObserver(function (mutations) {
2620                mutations.forEach(function (mo) {
2621                  if (mo.removedNodes.length > 0) {
2622                    for (var dd in mo.removedNodes) {
2623                      if (!!self && (mo.removedNodes[dd] === _dom)) return self.remove();
2624                    }
2625                  }
2626                });
2627              });
2628              self.observerremover.observe(_dom.parentNode, {
2629                childList: true,
2630                characterData: false,
2631                attributes: false,
2632                subtree: false
2633              });
2634            } else {
2635              self.bind(_dom, (cap.isie && !cap.isie9) ? "propertychange" : "DOMAttrModified", self.onAttributeChange);
2636              if (cap.isie9) _dom.attachEvent("onpropertychange", self.onAttributeChange); //IE9 DOMAttrModified bug
2637              self.bind(_dom, "DOMNodeRemoved", function (e) {
2638                if (e.target === _dom) self.remove();
2639              });
2640            }
2641          }
2642
2643        }
2644
2645        //
2646
2647        if (!self.ispage && opt.boxzoom) self.bind(_win, "resize", self.resizeZoom);
2648        if (self.istextarea) {
2649          self.bind(self.win, "keydown", self.lazyResize);
2650          self.bind(self.win, "mouseup", self.lazyResize);
2651        }
2652
2653        self.lazyResize(30);
2654
2655      }
2656
2657      if (this.doc[0].nodeName == 'IFRAME') {
2658        var oniframeload = function () {
2659          self.iframexd = false;
2660          var doc;
2661          try {
2662            doc = 'contentDocument' in this ? this.contentDocument : this.contentWindow._doc;
2663            var a = doc.domain;
2664          } catch (e) {
2665            self.iframexd = true;
2666            doc = false;
2667          }
2668
2669          if (self.iframexd) {
2670            if ("console" in _win) console.log('NiceScroll error: policy restriced iframe');
2671            return true; //cross-domain - I can't manage this        
2672          }
2673
2674          self.forcescreen = true;
2675
2676          if (self.isiframe) {
2677            self.iframe = {
2678              "doc": $(doc),
2679              "html": self.doc.contents().find('html')[0],
2680              "body": self.doc.contents().find('body')[0]
2681            };
2682            self.getContentSize = function () {
2683              return {
2684                w: Math.max(self.iframe.html.scrollWidth, self.iframe.body.scrollWidth),
2685                h: Math.max(self.iframe.html.scrollHeight, self.iframe.body.scrollHeight)
2686              };
2687            };
2688            self.docscroll = $(self.iframe.body);
2689          }
2690
2691          if (!cap.isios && opt.iframeautoresize && !self.isiframe) {
2692            self.win.scrollTop(0); // reset position
2693            self.doc.height(""); //reset height to fix browser bug
2694            var hh = Math.max(doc.getElementsByTagName('html')[0].scrollHeight, doc.body.scrollHeight);
2695            self.doc.height(hh);
2696          }
2697          self.lazyResize(30);
2698
2699          self.css($(self.iframe.body), _scrollyhidden);
2700
2701          if (cap.isios && self.haswrapper) {
2702            self.css($(doc.body), {
2703              '-webkit-transform': 'translate3d(0,0,0)'
2704            }); // avoid iFrame content clipping - thanks to http://blog.derraab.com/2012/04/02/avoid-iframe-content-clipping-with-css-transform-on-ios/
2705          }
2706
2707          if ('contentWindow' in this) {
2708            self.bind(this.contentWindow, "scroll", self.onscroll); //IE8 & minor
2709          } else {
2710            self.bind(doc, "scroll", self.onscroll);
2711          }
2712
2713          if (opt.enablemousewheel) {
2714            self.mousewheel(doc, self.onmousewheel);
2715          }
2716
2717          if (opt.enablekeyboard) self.bind(doc, (cap.isopera) ? "keypress" : "keydown", self.onkeypress);
2718
2719          if (cap.cantouch) {
2720            self.bind(doc, "touchstart", self.ontouchstart);
2721            self.bind(doc, "touchmove", self.ontouchmove);
2722          }
2723          else if (opt.emulatetouch) {
2724            self.bind(doc, "mousedown", self.ontouchstart);
2725            self.bind(doc, "mousemove", function (e) {
2726              return self.ontouchmove(e, true);
2727            });
2728            if (opt.grabcursorenabled && cap.cursorgrabvalue) self.css($(doc.body), {
2729              'cursor': cap.cursorgrabvalue
2730            });
2731          }
2732
2733          self.bind(doc, "mouseup", self.ontouchend);
2734
2735          if (self.zoom) {
2736            if (opt.dblclickzoom) self.bind(doc, 'dblclick', self.doZoom);
2737            if (self.ongesturezoom) self.bind(doc, "gestureend", self.ongesturezoom);
2738          }
2739        };
2740
2741        if (this.doc[0].readyState && this.doc[0].readyState === "complete") {
2742          setTimeout(function () {
2743            oniframeload.call(self.doc[0], false);
2744          }, 500);
2745        }
2746        self.bind(this.doc, "load", oniframeload);
2747
2748      }
2749
2750    };
2751
2752    this.showCursor = function (py, px) {
2753      if (self.cursortimeout) {
2754        clearTimeout(self.cursortimeout);
2755        self.cursortimeout = 0;
2756      }
2757      if (!self.rail) return;
2758      if (self.autohidedom) {
2759        self.autohidedom.stop().css({
2760          opacity: opt.cursoropacitymax
2761        });
2762        self.cursoractive = true;
2763      }
2764
2765      if (!self.rail.drag || self.rail.drag.pt != 1) {
2766        if (py !== undefined && py !== false) {
2767          self.scroll.y = (py / self.scrollratio.y) | 0;
2768        }
2769        if (px !== undefined) {
2770          self.scroll.x = (px / self.scrollratio.x) | 0;
2771        }
2772      }
2773
2774      self.cursor.css({
2775        height: self.cursorheight,
2776        top: self.scroll.y
2777      });
2778      if (self.cursorh) {
2779        var lx = (self.hasreversehr) ? self.scrollvaluemaxw - self.scroll.x : self.scroll.x;
2780        self.cursorh.css({
2781          width: self.cursorwidth,
2782          left: (!self.rail.align && self.rail.visibility) ? lx + self.rail.width : lx
2783        });
2784        self.cursoractive = true;
2785      }
2786
2787      if (self.zoom) self.zoom.stop().css({
2788        opacity: opt.cursoropacitymax
2789      });
2790    };
2791
2792    this.hideCursor = function (tm) {
2793      if (self.cursortimeout) return;
2794      if (!self.rail) return;
2795      if (!self.autohidedom) return;
2796
2797      if (self.hasmousefocus && opt.autohidemode === "leave") return;
2798      self.cursortimeout = setTimeout(function () {
2799        if (!self.rail.active || !self.showonmouseevent) {
2800          self.autohidedom.stop().animate({
2801            opacity: opt.cursoropacitymin
2802          });
2803          if (self.zoom) self.zoom.stop().animate({
2804            opacity: opt.cursoropacitymin
2805          });
2806          self.cursoractive = false;
2807        }
2808        self.cursortimeout = 0;
2809      }, tm || opt.hidecursordelay);
2810    };
2811
2812    this.noticeCursor = function (tm, py, px) {
2813      self.showCursor(py, px);
2814      if (!self.rail.active) self.hideCursor(tm);
2815    };
2816
2817    this.getContentSize =
2818      (self.ispage) ?
2819        function () {
2820          return {
2821            w: Math.max(_doc.body.scrollWidth, _doc.documentElement.scrollWidth),
2822            h: Math.max(_doc.body.scrollHeight, _doc.documentElement.scrollHeight)
2823          };
2824        } : (self.haswrapper) ?
2825          function () {
2826            return {
2827              w: self.doc[0].offsetWidth,
2828              h: self.doc[0].offsetHeight
2829            };
2830          } : function () {
2831            return {
2832              w: self.docscroll[0].scrollWidth,
2833              h: self.docscroll[0].scrollHeight
2834            };
2835          };
2836
2837    this.onResize = function (e, page) {
2838
2839      if (!self || !self.win) return false;
2840
2841      var premaxh = self.page.maxh,
2842          premaxw = self.page.maxw,
2843          previewh = self.view.h,
2844          previeww = self.view.w;
2845
2846      self.view = {
2847        w: (self.ispage) ? self.win.width() : self.win[0].clientWidth,
2848        h: (self.ispage) ? self.win.height() : self.win[0].clientHeight
2849      };
2850
2851      self.page = (page) ? page : self.getContentSize();
2852
2853      self.page.maxh = Math.max(0, self.page.h - self.view.h);
2854      self.page.maxw = Math.max(0, self.page.w - self.view.w);
2855
2856      if ((self.page.maxh == premaxh) && (self.page.maxw == premaxw) && (self.view.w == previeww) && (self.view.h == previewh)) {
2857        // test position        
2858        if (!self.ispage) {
2859          var pos = self.win.offset();
2860          if (self.lastposition) {
2861            var lst = self.lastposition;
2862            if ((lst.top == pos.top) && (lst.left == pos.left)) return self; //nothing to do            
2863          }
2864          self.lastposition = pos;
2865        } else {
2866          return self; //nothing to do
2867        }
2868      }
2869
2870      if (self.page.maxh === 0) {
2871        self.hideRail();
2872        self.scrollvaluemax = 0;
2873        self.scroll.y = 0;
2874        self.scrollratio.y = 0;
2875        self.cursorheight = 0;
2876        self.setScrollTop(0);
2877        if (self.rail) self.rail.scrollable = false;
2878      } else {
2879        self.page.maxh -= (opt.railpadding.top + opt.railpadding.bottom);
2880        self.rail.scrollable = true;
2881      }
2882
2883      if (self.page.maxw === 0) {
2884        self.hideRailHr();
2885        self.scrollvaluemaxw = 0;
2886        self.scroll.x = 0;
2887        self.scrollratio.x = 0;
2888        self.cursorwidth = 0;
2889        self.setScrollLeft(0);
2890        if (self.railh) {
2891          self.railh.scrollable = false;
2892        }
2893      } else {
2894        self.page.maxw -= (opt.railpadding.left + opt.railpadding.right);
2895        if (self.railh) self.railh.scrollable = (opt.horizrailenabled);
2896      }
2897
2898      self.railslocked = (self.locked) || ((self.page.maxh === 0) && (self.page.maxw === 0));
2899      if (self.railslocked) {
2900        if (!self.ispage) self.updateScrollBar(self.view);
2901        return false;
2902      }
2903
2904      if (!self.hidden) {
2905        if (!self.rail.visibility) self.showRail();
2906        if (self.railh && !self.railh.visibility) self.showRailHr();
2907      }
2908
2909      if (self.istextarea && self.win.css('resize') && self.win.css('resize') != 'none') self.view.h -= 20;
2910
2911      self.cursorheight = Math.min(self.view.h, Math.round(self.view.h * (self.view.h / self.page.h)));
2912      self.cursorheight = (opt.cursorfixedheight) ? opt.cursorfixedheight : Math.max(opt.cursorminheight, self.cursorheight);
2913
2914      self.cursorwidth = Math.min(self.view.w, Math.round(self.view.w * (self.view.w / self.page.w)));
2915      self.cursorwidth = (opt.cursorfixedheight) ? opt.cursorfixedheight : Math.max(opt.cursorminheight, self.cursorwidth);
2916
2917      self.scrollvaluemax = self.view.h - self.cursorheight - (opt.railpadding.top + opt.railpadding.bottom);
2918      if (!self.hasborderbox) self.scrollvaluemax -= self.cursor[0].offsetHeight - self.cursor[0].clientHeight;
2919
2920      if (self.railh) {
2921        self.railh.width = (self.page.maxh > 0) ? (self.view.w - self.rail.width) : self.view.w;
2922        self.scrollvaluemaxw = self.railh.width - self.cursorwidth - (opt.railpadding.left + opt.railpadding.right);
2923      }
2924
2925      if (!self.ispage) self.updateScrollBar(self.view);
2926
2927      self.scrollratio = {
2928        x: (self.page.maxw / self.scrollvaluemaxw),
2929        y: (self.page.maxh / self.scrollvaluemax)
2930      };
2931
2932      var sy = self.getScrollTop();
2933      if (sy > self.page.maxh) {
2934        self.doScrollTop(self.page.maxh);
2935      } else {
2936        self.scroll.y = (self.getScrollTop() / self.scrollratio.y) | 0;
2937        self.scroll.x = (self.getScrollLeft() / self.scrollratio.x) | 0;
2938        if (self.cursoractive) self.noticeCursor();
2939      }
2940
2941      if (self.scroll.y && (self.getScrollTop() === 0)) self.doScrollTo((self.scroll.y * self.scrollratio.y)|0);
2942
2943      return self;
2944    };
2945
2946    this.resize = self.onResize;
2947
2948    var hlazyresize = 0;
2949
2950    this.onscreenresize = function(e) {
2951      clearTimeout(hlazyresize);
2952
2953      var hiderails = (!self.ispage && !self.haswrapper);
2954      if (hiderails) self.hideRails();
2955
2956      hlazyresize = setTimeout(function () {
2957        if (self) {
2958          if (hiderails) self.showRails();
2959          self.resize();
2960        }
2961        hlazyresize=0;
2962      }, 120);
2963    };
2964
2965    this.lazyResize = function (tm) { // event debounce
2966
2967      clearTimeout(hlazyresize);
2968
2969      tm = isNaN(tm) ? 240 : tm;
2970
2971      hlazyresize = setTimeout(function () {
2972        self && self.resize();
2973        hlazyresize=0;
2974      }, tm);
2975
2976      return self;
2977
2978    };
2979
2980    // derived by MDN https://developer.mozilla.org/en-US/docs/DOM/Mozilla_event_reference/wheel
2981    function _modernWheelEvent(dom, name, fn, bubble) {
2982      self._bind(dom, name, function (e) {
2983        e = e || _win.event;
2984        var event = {
2985          original: e,
2986          target: e.target || e.srcElement,
2987          type: "wheel",
2988          deltaMode: e.type == "MozMousePixelScroll" ? 0 : 1,
2989          deltaX: 0,
2990          deltaZ: 0,
2991          preventDefault: function () {
2992            e.preventDefault ? e.preventDefault() : e.returnValue = false;
2993            return false;
2994          },
2995          stopImmediatePropagation: function () {
2996            (e.stopImmediatePropagation) ? e.stopImmediatePropagation() : e.cancelBubble = true;
2997          }
2998        };
2999
3000        if (name == "mousewheel") {
3001          e.wheelDeltaX && (event.deltaX = -1 / 40 * e.wheelDeltaX);
3002          e.wheelDeltaY && (event.deltaY = -1 / 40 * e.wheelDeltaY);
3003          !event.deltaY && !event.deltaX && (event.deltaY = -1 / 40 * e.wheelDelta);
3004        } else {
3005          event.deltaY = e.detail;
3006        }
3007
3008        return fn.call(dom, event);
3009      }, bubble);
3010    }
3011
3012
3013
3014    this.jqbind = function (dom, name, fn) { // use jquery bind for non-native events (mouseenter/mouseleave)
3015      self.events.push({
3016        e: dom,
3017        n: name,
3018        f: fn,
3019        q: true
3020      });
3021      $(dom).on(name, fn);
3022    };
3023
3024    this.mousewheel = function (dom, fn, bubble) { // bind mousewheel
3025      var el = ("jquery" in dom) ? dom[0] : dom;
3026      if ("onwheel" in _doc.createElement("div")) { // Modern browsers support "wheel"
3027        self._bind(el, "wheel", fn, bubble || false);
3028      } else {
3029        var wname = (_doc.onmousewheel !== undefined) ? "mousewheel" : "DOMMouseScroll"; // older Webkit+IE support or older Firefox          
3030        _modernWheelEvent(el, wname, fn, bubble || false);
3031        if (wname == "DOMMouseScroll") _modernWheelEvent(el, "MozMousePixelScroll", fn, bubble || false); // Firefox legacy
3032      }
3033    };
3034
3035    var passiveSupported = false;
3036
3037    if (cap.haseventlistener) {  // W3C standard event model
3038
3039      // thanks to https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
3040      try { var options = Object.defineProperty({}, "passive", { get: function () { passiveSupported = !0; } }); _win.addEventListener("test", null, options); } catch (err) { }
3041
3042      this.stopPropagation = function (e) {
3043        if (!e) return false;
3044        e = (e.original) ? e.original : e;
3045        e.stopPropagation();
3046        return false;
3047      };
3048
3049      this.cancelEvent = function(e) {
3050        if (e.cancelable) e.preventDefault();
3051        e.stopImmediatePropagation();
3052        if (e.preventManipulation) e.preventManipulation();  // IE10+
3053        return false;
3054      };      
3055
3056    } else {
3057
3058      // inspired from https://gist.github.com/jonathantneal/2415137      
3059
3060      Event.prototype.preventDefault = function () {
3061        this.returnValue = false;
3062      };
3063
3064      Event.prototype.stopPropagation = function () {
3065        this.cancelBubble = true;
3066      };
3067
3068      _win.constructor.prototype.addEventListener = _doc.constructor.prototype.addEventListener = Element.prototype.addEventListener = function (type, listener, useCapture) {
3069        this.attachEvent("on" + type, listener);
3070      };
3071      _win.constructor.prototype.removeEventListener = _doc.constructor.prototype.removeEventListener = Element.prototype.removeEventListener = function (type, listener, useCapture) {
3072        this.detachEvent("on" + type, listener);
3073      };
3074
3075      // Thanks to http://www.switchonthecode.com !!
3076      this.cancelEvent = function (e) {
3077        e = e || _win.event;
3078        if (e) {          
3079          e.cancelBubble = true;
3080          e.cancel = true;
3081          e.returnValue = false;
3082        }  
3083        return false;
3084      };
3085
3086      this.stopPropagation = function (e) {
3087        e = e || _win.event;
3088        if (e) e.cancelBubble = true;
3089        return false;
3090      };
3091
3092    }
3093
3094    this.delegate = function (dom, name, fn, bubble, active) {
3095
3096      var de = delegatevents[name] || false;
3097
3098      if (!de) {
3099
3100        de = {
3101          a: [],
3102          l: [],
3103          f: function (e) {
3104            var lst = de.l, l = lst.length - 1;
3105            var r = false;
3106            for (var a = l; a >= 0; a--) {
3107              r = lst[a].call(e.target, e);
3108              if (r === false) return false;
3109            }
3110            return r;
3111          }
3112        };
3113
3114        self.bind(dom, name, de.f, bubble, active);
3115
3116        delegatevents[name] = de;
3117
3118      }
3119
3120      if (self.ispage) {
3121        de.a = [self.id].concat(de.a);
3122        de.l = [fn].concat(de.l);
3123      } else {
3124        de.a.push(self.id);
3125        de.l.push(fn);        
3126      }
3127
3128    };
3129
3130    this.undelegate = function (dom, name, fn, bubble, active) {
3131      var de = delegatevents[name]||false;
3132      if (de&&de.l) {  // quick fix #683
3133        for (var a=0,l=de.l.length;a<l;a++) {
3134          if (de.a[a] === self.id) {
3135            de.a.splice(a);
3136            de.l.splice(a);
3137            if (de.a.length===0) {
3138              self._unbind(dom,name,de.l.f);
3139              delegatevents[name] = null;
3140            }
3141          }
3142        }
3143      }
3144    };
3145
3146    this.bind = function (dom, name, fn, bubble, active) {
3147      var el = ("jquery" in dom) ? dom[0] : dom;
3148      self._bind(el, name, fn, bubble || false, active || false);
3149    };
3150
3151    this._bind = function (el, name, fn, bubble, active) { // primitive bind
3152
3153      self.events.push({
3154        e: el,
3155        n: name,
3156        f: fn,
3157        b: bubble,
3158        q: false
3159      });
3160
3161      (passiveSupported && active) ? el.addEventListener(name, fn, { passive: false, capture: bubble }) : el.addEventListener(name, fn, bubble || false);
3162    };
3163
3164    this._unbind = function (el, name, fn, bub) { // primitive unbind
3165      if (delegatevents[name]) self.undelegate(el, name, fn, bub);
3166      else el.removeEventListener(name, fn, bub);
3167    };
3168
3169    this.unbindAll = function () {
3170      for (var a = 0; a < self.events.length; a++) {
3171        var r = self.events[a];
3172        (r.q) ? r.e.unbind(r.n, r.f) : self._unbind(r.e, r.n, r.f, r.b);
3173      }
3174    };
3175
3176    this.showRails = function () {
3177      return self.showRail().showRailHr();
3178    };
3179
3180    this.showRail = function () {
3181      if ((self.page.maxh !== 0) && (self.ispage || self.win.css('display') != 'none')) {
3182        //self.visibility = true;
3183        self.rail.visibility = true;
3184        self.rail.css('display', 'block');
3185      }
3186      return self;
3187    };
3188
3189    this.showRailHr = function () {
3190      if (self.railh) {
3191        if ((self.page.maxw !== 0) && (self.ispage || self.win.css('display') != 'none')) {
3192          self.railh.visibility = true;
3193          self.railh.css('display', 'block');
3194        }
3195      }
3196      return self;
3197    };
3198
3199    this.hideRails = function () {
3200      return self.hideRail().hideRailHr();
3201    };
3202
3203    this.hideRail = function () {
3204      //self.visibility = false;
3205      self.rail.visibility = false;
3206      self.rail.css('display', 'none');
3207      return self;
3208    };
3209
3210    this.hideRailHr = function () {
3211      if (self.railh) {
3212        self.railh.visibility = false;
3213        self.railh.css('display', 'none');
3214      }
3215      return self;
3216    };
3217
3218    this.show = function () {
3219      self.hidden = false;
3220      self.railslocked = false;
3221      return self.showRails();
3222    };
3223
3224    this.hide = function () {
3225      self.hidden = true;
3226      self.railslocked = true;
3227      return self.hideRails();
3228    };
3229
3230    this.toggle = function () {
3231      return (self.hidden) ? self.show() : self.hide();
3232    };
3233
3234    this.remove = function () {
3235      self.stop();
3236      if (self.cursortimeout) clearTimeout(self.cursortimeout);
3237      for (var n in self.delaylist) if (self.delaylist[n]) clearAnimationFrame(self.delaylist[n].h);
3238      self.doZoomOut();
3239      self.unbindAll();
3240
3241      if (cap.isie9) self.win[0].detachEvent("onpropertychange", self.onAttributeChange); //IE9 DOMAttrModified bug
3242
3243      if (self.observer !== false) self.observer.disconnect();
3244      if (self.observerremover !== false) self.observerremover.disconnect();
3245      if (self.observerbody !== false) self.observerbody.disconnect();
3246
3247      self.events = null;
3248
3249      if (self.cursor) {
3250        self.cursor.remove();
3251      }
3252      if (self.cursorh) {
3253        self.cursorh.remove();
3254      }
3255      if (self.rail) {
3256        self.rail.remove();
3257      }
3258      if (self.railh) {
3259        self.railh.remove();
3260      }
3261      if (self.zoom) {
3262        self.zoom.remove();
3263      }
3264      for (var a = 0; a < self.saved.css.length; a++) {
3265        var d = self.saved.css[a];
3266        d[0].css(d[1], (d[2] === undefined) ? '' : d[2]);
3267      }
3268      self.saved = false;
3269      self.me.data('__nicescroll', ''); //erase all traces
3270
3271      // memory leak fixed by GianlucaGuarini - thanks a lot!
3272      // remove the current nicescroll from the $.nicescroll array & normalize array
3273      var lst = $.nicescroll;
3274      lst.each(function (i) {
3275        if (!this) return;
3276        if (this.id === self.id) {
3277          delete lst[i];
3278          for (var b = ++i; b < lst.length; b++ , i++) lst[i] = lst[b];
3279          lst.length--;
3280          if (lst.length) delete lst[lst.length];
3281        }
3282      });
3283
3284      for (var i in self) {
3285        self[i] = null;
3286        delete self[i];
3287      }
3288
3289      self = null;
3290
3291    };
3292
3293    this.scrollstart = function (fn) {
3294      this.onscrollstart = fn;
3295      return self;
3296    };
3297    this.scrollend = function (fn) {
3298      this.onscrollend = fn;
3299      return self;
3300    };
3301    this.scrollcancel = function (fn) {
3302      this.onscrollcancel = fn;
3303      return self;
3304    };
3305
3306    this.zoomin = function (fn) {
3307      this.onzoomin = fn;
3308      return self;
3309    };
3310    this.zoomout = function (fn) {
3311      this.onzoomout = fn;
3312      return self;
3313    };
3314
3315    this.isScrollable = function (e) {
3316      var dom = (e.target) ? e.target : e;
3317      if (dom.nodeName == 'OPTION') return true;
3318      while (dom && (dom.nodeType == 1) && (dom !== this.me[0]) && !(/^BODY|HTML/.test(dom.nodeName))) {
3319        var dd = $(dom);
3320        var ov = dd.css('overflowY') || dd.css('overflowX') || dd.css('overflow') || '';
3321        if (/scroll|auto/.test(ov)) return (dom.clientHeight != dom.scrollHeight);
3322        dom = (dom.parentNode) ? dom.parentNode : false;
3323      }
3324      return false;
3325    };
3326
3327    this.getViewport = function (me) {
3328      var dom = (me && me.parentNode) ? me.parentNode : false;
3329      while (dom && (dom.nodeType == 1) && !(/^BODY|HTML/.test(dom.nodeName))) {
3330        var dd = $(dom);
3331        if (/fixed|absolute/.test(dd.css("position"))) return dd;
3332        var ov = dd.css('overflowY') || dd.css('overflowX') || dd.css('overflow') || '';
3333        if ((/scroll|auto/.test(ov)) && (dom.clientHeight != dom.scrollHeight)) return dd;
3334        if (dd.getNiceScroll().length > 0) return dd;
3335        dom = (dom.parentNode) ? dom.parentNode : false;
3336      }
3337      return false;
3338    };
3339
3340    this.triggerScrollStart = function (cx, cy, rx, ry, ms) {
3341
3342      if (self.onscrollstart) {
3343        var info = {
3344          type: "scrollstart",
3345          current: {
3346            x: cx,
3347            y: cy
3348          },
3349          request: {
3350            x: rx,
3351            y: ry
3352          },
3353          end: {
3354            x: self.newscrollx,
3355            y: self.newscrolly
3356          },
3357          speed: ms
3358        };
3359        self.onscrollstart.call(self, info);
3360      }
3361
3362    };
3363
3364    this.triggerScrollEnd = function () {
3365      if (self.onscrollend) {
3366
3367        var px = self.getScrollLeft();
3368        var py = self.getScrollTop();
3369
3370        var info = {
3371          type: "scrollend",
3372          current: {
3373            x: px,
3374            y: py
3375          },
3376          end: {
3377            x: px,
3378            y: py
3379          }
3380        };
3381
3382        self.onscrollend.call(self, info);
3383
3384      }
3385
3386    };
3387
3388    var scrolldiry = 0, scrolldirx = 0, scrolltmr = 0, scrollspd = 1;
3389
3390    function doScrollRelative(px, py, chkscroll, iswheel) {
3391
3392      if (!self.scrollrunning) {
3393        self.newscrolly = self.getScrollTop();
3394        self.newscrollx = self.getScrollLeft();
3395        scrolltmr = now();
3396      }
3397
3398      var gap = (now() - scrolltmr);
3399      scrolltmr = now();
3400
3401      if (gap > 350) {
3402        scrollspd = 1;
3403      } else {
3404        scrollspd += (2 - scrollspd) / 10;
3405      }
3406
3407      px = px * scrollspd | 0;
3408      py = py * scrollspd | 0;
3409
3410      if (px) {
3411
3412        if (iswheel) { // mouse-only
3413          if (px < 0) {  // fix apple magic mouse swipe back/forward
3414            if (self.getScrollLeft() >= self.page.maxw) return true;
3415          } else {
3416            if (self.getScrollLeft() <= 0) return true;
3417          }
3418        }
3419
3420        var dx = px > 0 ? 1 : -1;
3421
3422        if (scrolldirx !== dx) {
3423          if (self.scrollmom) self.scrollmom.stop();
3424          self.newscrollx = self.getScrollLeft();
3425          scrolldirx = dx;
3426        }
3427
3428        self.lastdeltax -= px;
3429
3430      }
3431
3432      if (py) {
3433
3434        var chk = (function () {
3435          var top = self.getScrollTop();
3436          if (py < 0) {
3437            if (top >= self.page.maxh) return true;
3438          } else {
3439            if (top <= 0) return true;
3440          }
3441        })();
3442
3443        if (chk) {
3444          if (opt.nativeparentscrolling && chkscroll && !self.ispage && !self.zoomactive) return true;
3445          var ny = self.view.h >> 1;
3446          if (self.newscrolly < -ny) { self.newscrolly = -ny; py = -1; }
3447          else if (self.newscrolly > self.page.maxh + ny) { self.newscrolly = self.page.maxh + ny; py = 1; }
3448          else py = 0;
3449        }
3450
3451        var dy = py > 0 ? 1 : -1;
3452
3453        if (scrolldiry !== dy) {
3454          if (self.scrollmom) self.scrollmom.stop();
3455          self.newscrolly = self.getScrollTop();
3456          scrolldiry = dy;
3457        }
3458
3459        self.lastdeltay -= py;
3460
3461      }
3462
3463      if (py || px) {
3464        self.synched("relativexy", function () {
3465
3466          var dty = self.lastdeltay + self.newscrolly;
3467          self.lastdeltay = 0;
3468
3469          var dtx = self.lastdeltax + self.newscrollx;
3470          self.lastdeltax = 0;
3471
3472          if (!self.rail.drag) self.doScrollPos(dtx, dty);
3473
3474        });
3475      }
3476
3477    }
3478
3479    var hasparentscrollingphase = false;
3480
3481    function execScrollWheel(e, hr, chkscroll) {
3482      var px, py;
3483
3484      if (!chkscroll && hasparentscrollingphase) return true;
3485
3486      if (e.deltaMode === 0) { // PIXEL
3487        px = -(e.deltaX * (opt.mousescrollstep / (18 * 3))) | 0;
3488        py = -(e.deltaY * (opt.mousescrollstep / (18 * 3))) | 0;
3489      } else if (e.deltaMode === 1) { // LINE
3490        px = -(e.deltaX * opt.mousescrollstep * 50 / 80) | 0;
3491        py = -(e.deltaY * opt.mousescrollstep * 50 / 80) | 0;
3492      }
3493
3494      if (hr && opt.oneaxismousemode && (px === 0) && py) { // classic vertical-only mousewheel + browser with x/y support 
3495        px = py;
3496        py = 0;
3497
3498        if (chkscroll) {
3499          var hrend = (px < 0) ? (self.getScrollLeft() >= self.page.maxw) : (self.getScrollLeft() <= 0);
3500          if (hrend) {  // preserve vertical scrolling
3501            py = px;
3502            px = 0;
3503          }
3504        }
3505
3506      }
3507
3508      // invert horizontal direction for rtl mode
3509      if (self.isrtlmode) px = -px;
3510
3511      var chk = doScrollRelative(px, py, chkscroll, true);
3512
3513      if (chk) {
3514        if (chkscroll) hasparentscrollingphase = true;
3515      } else {
3516        hasparentscrollingphase = false;
3517        e.stopImmediatePropagation();
3518        return e.preventDefault();
3519      }
3520
3521    }
3522
3523    this.onmousewheel = function (e) {
3524      if (self.wheelprevented||self.locked) return false;
3525      if (self.railslocked) {
3526        self.debounced("checkunlock", self.resize, 250);
3527        return false;
3528      }
3529      if (self.rail.drag) return self.cancelEvent(e);
3530
3531      if (opt.oneaxismousemode === "auto" && e.deltaX !== 0) opt.oneaxismousemode = false; // check two-axis mouse support (not very elegant)
3532
3533      if (opt.oneaxismousemode && e.deltaX === 0) {
3534        if (!self.rail.scrollable) {
3535          if (self.railh && self.railh.scrollable) {
3536            return self.onmousewheelhr(e);
3537          } else {
3538            return true;
3539          }
3540        }
3541      }
3542
3543      var nw = now();
3544      var chk = false;
3545      if (opt.preservenativescrolling && ((self.checkarea + 600) < nw)) {
3546        self.nativescrollingarea = self.isScrollable(e);
3547        chk = true;
3548      }
3549      self.checkarea = nw;
3550      if (self.nativescrollingarea) return true; // this isn't my business
3551      var ret = execScrollWheel(e, false, chk);
3552      if (ret) self.checkarea = 0;
3553      return ret;
3554    };
3555
3556    this.onmousewheelhr = function (e) {
3557      if (self.wheelprevented) return;
3558      if (self.railslocked || !self.railh.scrollable) return true;
3559      if (self.rail.drag) return self.cancelEvent(e);
3560
3561      var nw = now();
3562      var chk = false;
3563      if (opt.preservenativescrolling && ((self.checkarea + 600) < nw)) {
3564        self.nativescrollingarea = self.isScrollable(e);
3565        chk = true;
3566      }
3567      self.checkarea = nw;
3568      if (self.nativescrollingarea) return true; // this is not my business
3569      if (self.railslocked) return self.cancelEvent(e);
3570
3571      return execScrollWheel(e, true, chk);
3572    };
3573
3574    this.stop = function () {
3575      self.cancelScroll();
3576      if (self.scrollmon) self.scrollmon.stop();
3577      self.cursorfreezed = false;
3578      self.scroll.y = Math.round(self.getScrollTop() * (1 / self.scrollratio.y));
3579      self.noticeCursor();
3580      return self;
3581    };
3582
3583    this.getTransitionSpeed = function (dif) {
3584
3585      return 80 + (dif / 72) * opt.scrollspeed |0;
3586
3587    };
3588
3589    if (!opt.smoothscroll) {
3590      this.doScrollLeft = function (x, spd) { //direct
3591        var y = self.getScrollTop();
3592        self.doScrollPos(x, y, spd);
3593      };
3594      this.doScrollTop = function (y, spd) { //direct
3595        var x = self.getScrollLeft();
3596        self.doScrollPos(x, y, spd);
3597      };
3598      this.doScrollPos = function (x, y, spd) { //direct
3599        var nx = (x > self.page.maxw) ? self.page.maxw : x;
3600        if (nx < 0) nx = 0;
3601        var ny = (y > self.page.maxh) ? self.page.maxh : y;
3602        if (ny < 0) ny = 0;
3603        self.synched('scroll', function () {
3604          self.setScrollTop(ny);
3605          self.setScrollLeft(nx);
3606        });
3607      };
3608      this.cancelScroll = function () { }; // direct
3609
3610    } else if (self.ishwscroll && cap.hastransition && opt.usetransition && !!opt.smoothscroll) {
3611
3612      var lasttransitionstyle = '';
3613
3614      this.resetTransition = function () {
3615        lasttransitionstyle = '';
3616        self.doc.css(cap.prefixstyle + 'transition-duration', '0ms');
3617      };
3618
3619      this.prepareTransition = function (dif, istime) {
3620        var ex = (istime) ? dif : self.getTransitionSpeed(dif);
3621        var trans = ex + 'ms';
3622        if (lasttransitionstyle !== trans) {
3623          lasttransitionstyle = trans;
3624          self.doc.css(cap.prefixstyle + 'transition-duration', trans);
3625        }
3626        return ex;
3627      };
3628
3629      this.doScrollLeft = function (x, spd) { //trans
3630        var y = (self.scrollrunning) ? self.newscrolly : self.getScrollTop();
3631        self.doScrollPos(x, y, spd);
3632      };
3633
3634      this.doScrollTop = function (y, spd) { //trans
3635        var x = (self.scrollrunning) ? self.newscrollx : self.getScrollLeft();
3636        self.doScrollPos(x, y, spd);
3637      };
3638
3639      this.cursorupdate = {
3640        running: false,
3641        start: function () {
3642          var m = this;
3643
3644          if (m.running) return;
3645          m.running = true;
3646
3647          var loop = function () {
3648            if (m.running) setAnimationFrame(loop);
3649            self.showCursor(self.getScrollTop(), self.getScrollLeft());
3650            self.notifyScrollEvent(self.win[0]);
3651          };
3652
3653          setAnimationFrame(loop);
3654        },
3655        stop: function () {
3656          this.running = false;
3657        }
3658      };
3659
3660      this.doScrollPos = function (x, y, spd) { //trans
3661
3662        var py = self.getScrollTop();
3663        var px = self.getScrollLeft();
3664
3665        if (((self.newscrolly - py) * (y - py) < 0) || ((self.newscrollx - px) * (x - px) < 0)) self.cancelScroll(); //inverted movement detection      
3666
3667        if (!opt.bouncescroll) {
3668          if (y < 0) y = 0;
3669          else if (y > self.page.maxh) y = self.page.maxh;
3670          if (x < 0) x = 0;
3671          else if (x > self.page.maxw) x = self.page.maxw;
3672        } else {
3673          if (y < 0) y = y / 2 | 0;
3674          else if (y > self.page.maxh) y = self.page.maxh + (y - self.page.maxh) / 2 | 0;
3675          if (x < 0) x = x / 2 | 0;
3676          else if (x > self.page.maxw) x = self.page.maxw + (x - self.page.maxw) / 2 | 0;
3677        }
3678
3679        if (self.scrollrunning && x == self.newscrollx && y == self.newscrolly) return false;
3680
3681        self.newscrolly = y;
3682        self.newscrollx = x;
3683
3684        var top = self.getScrollTop();
3685        var lft = self.getScrollLeft();
3686
3687        var dst = {};
3688        dst.x = x - lft;
3689        dst.y = y - top;
3690
3691        var dd = Math.sqrt((dst.x * dst.x) + (dst.y * dst.y)) | 0;
3692
3693        var ms = self.prepareTransition(dd);
3694
3695        if (!self.scrollrunning) {
3696          self.scrollrunning = true;
3697          self.triggerScrollStart(lft, top, x, y, ms);
3698          self.cursorupdate.start();
3699        }
3700
3701        self.scrollendtrapped = true;
3702
3703        if (!cap.transitionend) {
3704          if (self.scrollendtrapped) clearTimeout(self.scrollendtrapped);
3705          self.scrollendtrapped = setTimeout(self.onScrollTransitionEnd, ms); // simulate transitionend event
3706        }
3707
3708        self.setScrollTop(self.newscrolly);
3709        self.setScrollLeft(self.newscrollx);
3710
3711      };
3712
3713      this.cancelScroll = function () {
3714        if (!self.scrollendtrapped) return true;
3715        var py = self.getScrollTop();
3716        var px = self.getScrollLeft();
3717        self.scrollrunning = false;
3718        if (!cap.transitionend) clearTimeout(cap.transitionend);
3719        self.scrollendtrapped = false;
3720        self.resetTransition();
3721        self.setScrollTop(py); // fire event onscroll
3722        if (self.railh) self.setScrollLeft(px);
3723        if (self.timerscroll && self.timerscroll.tm) clearInterval(self.timerscroll.tm);
3724        self.timerscroll = false;
3725
3726        self.cursorfreezed = false;
3727
3728        self.cursorupdate.stop();
3729        self.showCursor(py, px);
3730        return self;
3731      };
3732
3733      this.onScrollTransitionEnd = function () {
3734
3735        if (!self.scrollendtrapped) return;
3736
3737        var py = self.getScrollTop();
3738        var px = self.getScrollLeft();
3739
3740        if (py < 0) py = 0;
3741        else if (py > self.page.maxh) py = self.page.maxh;
3742        if (px < 0) px = 0;
3743        else if (px > self.page.maxw) px = self.page.maxw;
3744        if ((py != self.newscrolly) || (px != self.newscrollx)) return self.doScrollPos(px, py, opt.snapbackspeed);
3745
3746        if (self.scrollrunning) self.triggerScrollEnd();
3747        self.scrollrunning = false;
3748
3749        self.scrollendtrapped = false;
3750        self.resetTransition();
3751        self.timerscroll = false;
3752        self.setScrollTop(py); // fire event onscroll        
3753        if (self.railh) self.setScrollLeft(px); // fire event onscroll left
3754
3755        self.cursorupdate.stop();
3756        self.noticeCursor(false, py, px);
3757
3758        self.cursorfreezed = false;
3759
3760      };
3761
3762    } else {
3763
3764      this.doScrollLeft = function (x, spd) { //no-trans
3765        var y = (self.scrollrunning) ? self.newscrolly : self.getScrollTop();
3766        self.doScrollPos(x, y, spd);
3767      };
3768
3769      this.doScrollTop = function (y, spd) { //no-trans
3770        var x = (self.scrollrunning) ? self.newscrollx : self.getScrollLeft();
3771        self.doScrollPos(x, y, spd);
3772      };
3773
3774      this.doScrollPos = function (x, y, spd) { //no-trans
3775
3776        var py = self.getScrollTop();
3777        var px = self.getScrollLeft();
3778
3779        if (((self.newscrolly - py) * (y - py) < 0) || ((self.newscrollx - px) * (x - px) < 0)) self.cancelScroll(); //inverted movement detection
3780
3781        var clipped = false;
3782
3783        if (!self.bouncescroll || !self.rail.visibility) {
3784          if (y < 0) {
3785            y = 0;
3786            clipped = true;
3787          } else if (y > self.page.maxh) {
3788            y = self.page.maxh;
3789            clipped = true;
3790          }
3791        }
3792        if (!self.bouncescroll || !self.railh.visibility) {
3793          if (x < 0) {
3794            x = 0;
3795            clipped = true;
3796          } else if (x > self.page.maxw) {
3797            x = self.page.maxw;
3798            clipped = true;
3799          }
3800        }
3801
3802        if (self.scrollrunning && (self.newscrolly === y) && (self.newscrollx === x)) return true;
3803
3804        self.newscrolly = y;
3805        self.newscrollx = x;
3806
3807        self.dst = {};
3808        self.dst.x = x - px;
3809        self.dst.y = y - py;
3810        self.dst.px = px;
3811        self.dst.py = py;
3812
3813        var dd = Math.sqrt((self.dst.x * self.dst.x) + (self.dst.y * self.dst.y)) | 0;
3814        var ms = self.getTransitionSpeed(dd);
3815
3816        self.bzscroll = {};
3817
3818        var p3 = (clipped) ? 1 : 0.58;
3819        self.bzscroll.x = new BezierClass(px, self.newscrollx, ms, 0, 0, p3, 1);
3820        self.bzscroll.y = new BezierClass(py, self.newscrolly, ms, 0, 0, p3, 1);
3821
3822        var loopid = now();
3823
3824        var loop = function () {
3825
3826          if (!self.scrollrunning) return;
3827          var x = self.bzscroll.y.getPos();
3828
3829          self.setScrollLeft(self.bzscroll.x.getNow());
3830          self.setScrollTop(self.bzscroll.y.getNow());
3831
3832          if (x <= 1) {
3833            self.timer = setAnimationFrame(loop);
3834          } else {
3835            self.scrollrunning = false;
3836            self.timer = 0;
3837            self.triggerScrollEnd();
3838          }
3839
3840        };
3841
3842        if (!self.scrollrunning) {
3843          self.triggerScrollStart(px, py, x, y, ms);
3844          self.scrollrunning = true;
3845          self.timer = setAnimationFrame(loop);
3846        }
3847
3848      };
3849
3850      this.cancelScroll = function () {
3851        if (self.timer) clearAnimationFrame(self.timer);
3852        self.timer = 0;
3853        self.bzscroll = false;
3854        self.scrollrunning = false;
3855        return self;
3856      };
3857
3858    }
3859
3860    this.doScrollBy = function (stp, relative) {
3861      doScrollRelative(0, stp);
3862    };
3863
3864    this.doScrollLeftBy = function (stp, relative) {
3865      doScrollRelative(stp, 0);
3866    };
3867
3868    this.doScrollTo = function (pos, relative) {
3869      var ny = (relative) ? Math.round(pos * self.scrollratio.y) : pos;
3870      if (ny < 0) ny = 0;
3871      else if (ny > self.page.maxh) ny = self.page.maxh;
3872      self.cursorfreezed = false;
3873      self.doScrollTop(pos);
3874    };
3875
3876    this.checkContentSize = function () {
3877      var pg = self.getContentSize();
3878      if ((pg.h != self.page.h) || (pg.w != self.page.w)) self.resize(false, pg);
3879    };
3880
3881    self.onscroll = function (e) {
3882      if (self.rail.drag) return;
3883      if (!self.cursorfreezed) {
3884        self.synched('scroll', function () {
3885          self.scroll.y = Math.round(self.getScrollTop() / self.scrollratio.y);
3886          if (self.railh) self.scroll.x = Math.round(self.getScrollLeft() / self.scrollratio.x);
3887          self.noticeCursor();
3888        });
3889      }
3890    };
3891    self.bind(self.docscroll, "scroll", self.onscroll);
3892
3893    this.doZoomIn = function (e) {
3894      if (self.zoomactive) return;
3895      self.zoomactive = true;
3896
3897      self.zoomrestore = {
3898        style: {}
3899      };
3900      var lst = ['position', 'top', 'left', 'zIndex', 'backgroundColor', 'marginTop', 'marginBottom', 'marginLeft', 'marginRight'];
3901      var win = self.win[0].style;
3902      for (var a in lst) {
3903        var pp = lst[a];
3904        self.zoomrestore.style[pp] = (win[pp] !== undefined) ? win[pp] : '';
3905      }
3906
3907      self.zoomrestore.style.width = self.win.css('width');
3908      self.zoomrestore.style.height = self.win.css('height');
3909
3910      self.zoomrestore.padding = {
3911        w: self.win.outerWidth() - self.win.width(),
3912        h: self.win.outerHeight() - self.win.height()
3913      };
3914
3915      if (cap.isios4) {
3916        self.zoomrestore.scrollTop = $window.scrollTop();
3917        $window.scrollTop(0);
3918      }
3919
3920      self.win.css({
3921        position: (cap.isios4) ? "absolute" : "fixed",
3922        top: 0,
3923        left: 0,
3924        zIndex: globalmaxzindex + 100,
3925        margin: 0
3926      });
3927      var bkg = self.win.css("backgroundColor");
3928      if ("" === bkg || /transparent|rgba\(0, 0, 0, 0\)|rgba\(0,0,0,0\)/.test(bkg)) self.win.css("backgroundColor", "#fff");
3929      self.rail.css({
3930        zIndex: globalmaxzindex + 101
3931      });
3932      self.zoom.css({
3933        zIndex: globalmaxzindex + 102
3934      });
3935      self.zoom.css('backgroundPosition', '0 -18px');
3936      self.resizeZoom();
3937
3938      if (self.onzoomin) self.onzoomin.call(self);
3939
3940      return self.cancelEvent(e);
3941    };
3942
3943    this.doZoomOut = function (e) {
3944      if (!self.zoomactive) return;
3945      self.zoomactive = false;
3946
3947      self.win.css("margin", "");
3948      self.win.css(self.zoomrestore.style);
3949
3950      if (cap.isios4) {
3951        $window.scrollTop(self.zoomrestore.scrollTop);
3952      }
3953
3954      self.rail.css({
3955        "z-index": self.zindex
3956      });
3957      self.zoom.css({
3958        "z-index": self.zindex
3959      });
3960      self.zoomrestore = false;
3961      self.zoom.css('backgroundPosition', '0 0');
3962      self.onResize();
3963
3964      if (self.onzoomout) self.onzoomout.call(self);
3965
3966      return self.cancelEvent(e);
3967    };
3968
3969    this.doZoom = function (e) {
3970      return (self.zoomactive) ? self.doZoomOut(e) : self.doZoomIn(e);
3971    };
3972
3973    this.resizeZoom = function () {
3974      if (!self.zoomactive) return;
3975
3976      var py = self.getScrollTop(); //preserve scrolling position
3977      self.win.css({
3978        width: $window.width() - self.zoomrestore.padding.w + "px",
3979        height: $window.height() - self.zoomrestore.padding.h + "px"
3980      });
3981      self.onResize();
3982
3983      self.setScrollTop(Math.min(self.page.maxh, py));
3984    };
3985
3986    this.init();
3987
3988    $.nicescroll.push(this);
3989
3990  };
3991
3992  // Inspired by the work of Kin Blas
3993  // http://webpro.host.adobe.com/people/jblas/momentum/includes/jquery.momentum.0.7.js  
3994  var ScrollMomentumClass2D = function (nc) {
3995    var self = this;
3996    this.nc = nc;
3997
3998    this.lastx = 0;
3999    this.lasty = 0;
4000    this.speedx = 0;
4001    this.speedy = 0;
4002    this.lasttime = 0;
4003    this.steptime = 0;
4004    this.snapx = false;
4005    this.snapy = false;
4006    this.demulx = 0;
4007    this.demuly = 0;
4008
4009    this.lastscrollx = -1;
4010    this.lastscrolly = -1;
4011
4012    this.chkx = 0;
4013    this.chky = 0;
4014
4015    this.timer = 0;
4016
4017    this.reset = function (px, py) {
4018      self.stop();
4019      self.steptime = 0;
4020      self.lasttime = now();
4021      self.speedx = 0;
4022      self.speedy = 0;
4023      self.lastx = px;
4024      self.lasty = py;
4025      self.lastscrollx = -1;
4026      self.lastscrolly = -1;
4027    };
4028
4029    this.update = function (px, py) {
4030      var tm = now();
4031      self.steptime = tm - self.lasttime;
4032      self.lasttime = tm;
4033      var dy = py - self.lasty;
4034      var dx = px - self.lastx;
4035      var sy = self.nc.getScrollTop();
4036      var sx = self.nc.getScrollLeft();
4037      var newy = sy + dy;
4038      var newx = sx + dx;
4039      self.snapx = (newx < 0) || (newx > self.nc.page.maxw);
4040      self.snapy = (newy < 0) || (newy > self.nc.page.maxh);
4041      self.speedx = dx;
4042      self.speedy = dy;
4043      self.lastx = px;
4044      self.lasty = py;
4045    };
4046
4047    this.stop = function () {
4048      self.nc.unsynched("domomentum2d");
4049      if (self.timer) clearTimeout(self.timer);
4050      self.timer = 0;
4051      self.lastscrollx = -1;
4052      self.lastscrolly = -1;
4053    };
4054
4055    this.doSnapy = function (nx, ny) {
4056      var snap = false;
4057
4058      if (ny < 0) {
4059        ny = 0;
4060        snap = true;
4061      } else if (ny > self.nc.page.maxh) {
4062        ny = self.nc.page.maxh;
4063        snap = true;
4064      }
4065
4066      if (nx < 0) {
4067        nx = 0;
4068        snap = true;
4069      } else if (nx > self.nc.page.maxw) {
4070        nx = self.nc.page.maxw;
4071        snap = true;
4072      }
4073
4074      (snap) ? self.nc.doScrollPos(nx, ny, self.nc.opt.snapbackspeed) : self.nc.triggerScrollEnd();
4075    };
4076
4077    this.doMomentum = function (gp) {
4078      var t = now();
4079      var l = (gp) ? t + gp : self.lasttime;
4080
4081      var sl = self.nc.getScrollLeft();
4082      var st = self.nc.getScrollTop();
4083
4084      var pageh = self.nc.page.maxh;
4085      var pagew = self.nc.page.maxw;
4086
4087      self.speedx = (pagew > 0) ? Math.min(60, self.speedx) : 0;
4088      self.speedy = (pageh > 0) ? Math.min(60, self.speedy) : 0;
4089
4090      var chk = l && (t - l) <= 60;
4091
4092      if ((st < 0) || (st > pageh) || (sl < 0) || (sl > pagew)) chk = false;
4093
4094      var sy = (self.speedy && chk) ? self.speedy : false;
4095      var sx = (self.speedx && chk) ? self.speedx : false;
4096
4097      if (sy || sx) {
4098        var tm = Math.max(16, self.steptime); //timeout granularity
4099
4100        if (tm > 50) { // do smooth
4101          var xm = tm / 50;
4102          self.speedx *= xm;
4103          self.speedy *= xm;
4104          tm = 50;
4105        }
4106
4107        self.demulxy = 0;
4108
4109        self.lastscrollx = self.nc.getScrollLeft();
4110        self.chkx = self.lastscrollx;
4111        self.lastscrolly = self.nc.getScrollTop();
4112        self.chky = self.lastscrolly;
4113
4114        var nx = self.lastscrollx;
4115        var ny = self.lastscrolly;
4116
4117        var onscroll = function () {
4118          var df = ((now() - t) > 600) ? 0.04 : 0.02;
4119
4120          if (self.speedx) {
4121            nx = Math.floor(self.lastscrollx - (self.speedx * (1 - self.demulxy)));
4122            self.lastscrollx = nx;
4123            if ((nx < 0) || (nx > pagew)) df = 0.10;
4124          }
4125
4126          if (self.speedy) {
4127            ny = Math.floor(self.lastscrolly - (self.speedy * (1 - self.demulxy)));
4128            self.lastscrolly = ny;
4129            if ((ny < 0) || (ny > pageh)) df = 0.10;
4130          }
4131
4132          self.demulxy = Math.min(1, self.demulxy + df);
4133
4134          self.nc.synched("domomentum2d", function () {
4135
4136            if (self.speedx) {
4137              var scx = self.nc.getScrollLeft();
4138              //              if (scx != self.chkx) self.stop();
4139              self.chkx = nx;
4140              self.nc.setScrollLeft(nx);
4141            }
4142
4143            if (self.speedy) {
4144              var scy = self.nc.getScrollTop();
4145              //              if (scy != self.chky) self.stop();
4146              self.chky = ny;
4147              self.nc.setScrollTop(ny);
4148            }
4149
4150            if (!self.timer) {
4151              self.nc.hideCursor();
4152              self.doSnapy(nx, ny);
4153            }
4154
4155          });
4156
4157          if (self.demulxy < 1) {
4158            self.timer = setTimeout(onscroll, tm);
4159          } else {
4160            self.stop();
4161            self.nc.hideCursor();
4162            self.doSnapy(nx, ny);
4163          }
4164        };
4165
4166        onscroll();
4167
4168      } else {
4169        self.doSnapy(self.nc.getScrollLeft(), self.nc.getScrollTop());
4170      }
4171
4172    };
4173
4174  };
4175
4176
4177  // override jQuery scrollTop
4178  var _scrollTop = jQuery.fn.scrollTop; // preserve original function
4179
4180  jQuery.cssHooks.pageYOffset = {
4181    get: function (elem, computed, extra) {
4182      var nice = $.data(elem, '__nicescroll') || false;
4183      return (nice && nice.ishwscroll) ? nice.getScrollTop() : _scrollTop.call(elem);
4184    },
4185    set: function (elem, value) {
4186      var nice = $.data(elem, '__nicescroll') || false;
4187      (nice && nice.ishwscroll) ? nice.setScrollTop(parseInt(value)) : _scrollTop.call(elem, value);
4188      return this;
4189    }
4190  };
4191
4192  jQuery.fn.scrollTop = function (value) {
4193    if (value === undefined) {
4194      var nice = (this[0]) ? $.data(this[0], '__nicescroll') || false : false;
4195      return (nice && nice.ishwscroll) ? nice.getScrollTop() : _scrollTop.call(this);
4196    } else {
4197      return this.each(function () {
4198        var nice = $.data(this, '__nicescroll') || false;
4199        (nice && nice.ishwscroll) ? nice.setScrollTop(parseInt(value)) : _scrollTop.call($(this), value);
4200      });
4201    }
4202  };
4203
4204  // override jQuery scrollLeft
4205  var _scrollLeft = jQuery.fn.scrollLeft; // preserve original function
4206
4207  $.cssHooks.pageXOffset = {
4208    get: function (elem, computed, extra) {
4209      var nice = $.data(elem, '__nicescroll') || false;
4210      return (nice && nice.ishwscroll) ? nice.getScrollLeft() : _scrollLeft.call(elem);
4211    },
4212    set: function (elem, value) {
4213      var nice = $.data(elem, '__nicescroll') || false;
4214      (nice && nice.ishwscroll) ? nice.setScrollLeft(parseInt(value)) : _scrollLeft.call(elem, value);
4215      return this;
4216    }
4217  };
4218
4219  jQuery.fn.scrollLeft = function (value) {
4220    if (value === undefined) {
4221      var nice = (this[0]) ? $.data(this[0], '__nicescroll') || false : false;
4222      return (nice && nice.ishwscroll) ? nice.getScrollLeft() : _scrollLeft.call(this);
4223    } else {
4224      return this.each(function () {
4225        var nice = $.data(this, '__nicescroll') || false;
4226        (nice && nice.ishwscroll) ? nice.setScrollLeft(parseInt(value)) : _scrollLeft.call($(this), value);
4227      });
4228    }
4229  };
4230
4231  var NiceScrollArray = function (doms) {
4232    var self = this;
4233    this.length = 0;
4234    this.name = "nicescrollarray";
4235
4236    this.each = function (fn) {
4237      $.each(self, fn);
4238      return self;
4239    };
4240
4241    this.push = function (nice) {
4242      self[self.length] = nice;
4243      self.length++;
4244    };
4245
4246    this.eq = function (idx) {
4247      return self[idx];
4248    };
4249
4250    if (doms) {
4251      for (var a = 0; a < doms.length; a++) {
4252        var nice = $.data(doms[a], '__nicescroll') || false;
4253        if (nice) {
4254          this[this.length] = nice;
4255          this.length++;
4256        }
4257      }
4258    }
4259
4260    return this;
4261  };
4262
4263  function mplex(el, lst, fn) {
4264    for (var a = 0, l = lst.length; a < l; a++) fn(el, lst[a]);
4265  }
4266  mplex(
4267    NiceScrollArray.prototype, ['show', 'hide', 'toggle', 'onResize', 'resize', 'remove', 'stop', 'doScrollPos'],
4268    function (e, n) {
4269      e[n] = function () {
4270        var args = arguments;
4271        return this.each(function () {
4272          this[n].apply(this, args);
4273        });
4274      };
4275    }
4276  );
4277
4278  jQuery.fn.getNiceScroll = function (index) {
4279    if (index === undefined) {
4280      return new NiceScrollArray(this);
4281    } else {
4282      return this[index] && $.data(this[index], '__nicescroll') || false;
4283    }
4284  };
4285
4286  var pseudos = jQuery.expr.pseudos || jQuery.expr[':'];  // jQuery 3 migration
4287  pseudos.nicescroll = function (a) {
4288    return $.data(a, '__nicescroll') !== undefined;
4289  };
4290
4291  $.fn.niceScroll = function (wrapper, _opt) {
4292    if (_opt === undefined && typeof wrapper == "object" && !("jquery" in wrapper)) {
4293      _opt = wrapper;
4294      wrapper = false;
4295    }
4296
4297    var ret = new NiceScrollArray();
4298
4299    this.each(function () {
4300      var $this = $(this);
4301
4302      var opt = $.extend({}, _opt); // cloning
4303
4304      if (wrapper || false) {
4305        var wrp = $(wrapper);
4306        opt.doc = (wrp.length > 1) ? $(wrapper, $this) : wrp;
4307        opt.win = $this;
4308      }
4309      var docundef = !("doc" in opt);
4310      if (!docundef && !("win" in opt)) opt.win = $this;
4311
4312      var nice = $this.data('__nicescroll') || false;
4313      if (!nice) {
4314        opt.doc = opt.doc || $this;
4315        nice = new NiceScrollClass(opt, $this);
4316        $this.data('__nicescroll', nice);
4317      }
4318      ret.push(nice);
4319    });
4320
4321    return (ret.length === 1) ? ret[0] : ret;
4322  };
4323
4324  _win.NiceScroll = {
4325    getjQuery: function () {
4326      return jQuery;
4327    }
4328  };
4329
4330  if (!$.nicescroll) {
4331    $.nicescroll = new NiceScrollArray();
4332    $.nicescroll.options = _globaloptions;
4333  }
4334
4335}));
4336
4337/***/ }),
4338