https://bestlifetimedeals.com/wp-content/themes/mayosis/js/smoothscroll.min.js?ver=1.1

1//
2// SmoothScroll for websites v1.5.1 (Balazs Galambosi)
3// http://www.smoothscroll.net/
4//
5// Licensed under the terms of the MIT license.
6//
7// You may use it in your theme if you credit me. 
8// It is also free to use on any individual website.
9//
10// Exception:
11// The only restriction is to not publish any  
12// extension for browsers or native application
13// without getting a written permission first.
14//
15if (!document.body.classList.contains('logged-in')) {
16(function () {
17  
18// Scroll Variables (tweakable)
19var defaultOptions = {
20
21    // Scrolling Core
22    frameRate        : 150, // [Hz]
23    animationTime    : 400, // [ms]
24    stepSize         : 100, // [px]
25
26    // Pulse (less tweakable)
27    // ratio of "tail" to "acceleration"
28    pulseAlgorithm   : true,
29    pulseScale       : 4,
30    pulseNormalize   : 1,
31
32    // Acceleration
33    accelerationDelta : 50,  // 50
34    accelerationMax   : 3,   // 3
35
36    // Keyboard Settings
37    keyboardSupport   : true,  // option
38    arrowScroll       : 50,    // [px]
39
40    // Other
41    fixedBackground   : true, 
42    excluded          : ''    
43};
44
45var options = defaultOptions;
46
47
48// Other Variables
49var isExcluded = false;
50var isFrame = false;
51var direction = { x: 0, y: 0 };
52var initDone  = false;
53var root = document.documentElement;
54var activeElement;
55var observer;
56var refreshSize;
57var deltaBuffer = [];
58var deltaBufferTimer;
59var isMac = /^Mac/.test(navigator.platform);
60
61/***********************************************
62 * INITIALIZE
63 ***********************************************/
64
65/**
66 * Tests if smooth scrolling is allowed. Shuts down everything if not.
67 */
68function initTest() {
69    if (options.keyboardSupport) {
70        addEvent('keydown', keydown);
71    }
72}
73
74/**
75 * Sets up scrolls array, determines if frames are involved.
76 */
77function init() {
78  
79    if (initDone || !document.body) return;
80
81    initDone = true;
82
83    var body = document.body;
84    var html = document.documentElement;
85    var windowHeight = window.innerHeight; 
86    var scrollHeight = body.scrollHeight;
87    
88    // check compat mode for root element
89    root = (document.compatMode.indexOf('CSS') >= 0) ? html : body;
90    activeElement = body;
91    
92    initTest();
93
94    // Checks if this script is running in a frame
95    if (top != self) {
96        isFrame = true;
97    }
98
99    /**
100     * Safari 10 fixed it, Chrome fixed it in v45:
101     * This fixes a bug where the areas left and right to 
102     * the content does not trigger the onmousewheel event
103     * on some pages. e.g.: html, body { height: 100% }
104     */
105    else if (isOldSafari &&
106             scrollHeight > windowHeight &&
107            (body.offsetHeight <= windowHeight || 
108             html.offsetHeight <= windowHeight)) {
109
110        var fullPageElem = document.createElement('div');
111        fullPageElem.style.cssText = 'position:absolute; z-index:-10000; ' +
112                                     'top:0; left:0; right:0; height:' + 
113                                      root.scrollHeight + 'px';
114        document.body.appendChild(fullPageElem);
115        
116        // DOM changed (throttled) to fix height
117        var pendingRefresh;
118        refreshSize = function () {
119            if (pendingRefresh) return; // could also be: clearTimeout(pendingRefresh);
120            pendingRefresh = setTimeout(function () {
121                if (isExcluded) return; // could be running after cleanup
122                fullPageElem.style.height = '0';
123                fullPageElem.style.height = root.scrollHeight + 'px';
124                pendingRefresh = null;
125            }, 500); // act rarely to stay fast
126        };
127  
128        setTimeout(refreshSize, 10);
129
130        addEvent('resize', refreshSize);
131
132        // TODO: attributeFilter?
133        var config = {
134            attributes: true, 
135            childList: true, 
136            characterData: false 
137            // subtree: true
138        };
139
140        observer = new MutationObserver(refreshSize);
141        observer.observe(body, config);
142
143        if (root.offsetHeight <= windowHeight) {
144            var clearfix = document.createElement('div');   
145            clearfix.style.clear = 'both';
146            body.appendChild(clearfix);
147        }
148    }
149
150    // disable fixed background
151    if (!options.fixedBackground && !isExcluded) {
152        body.style.backgroundAttachment = 'scroll';
153        html.style.backgroundAttachment = 'scroll';
154    }
155}
156
157/**
158 * Removes event listeners and other traces left on the page.
159 */
160function cleanup() {
161    observer && observer.disconnect();
162    removeEvent(wheelEvent, wheel);
163    removeEvent('mousedown', mousedown);
164    removeEvent('keydown', keydown);
165    removeEvent('resize', refreshSize);
166    removeEvent('load', init);
167}
168
169
170/************************************************
171 * SCROLLING 
172 ************************************************/
173 
174var que = [];
175var pending = false;
176var lastScroll = Date.now();
177
178/**
179 * Pushes scroll actions to the scrolling queue.
180 */
181function scrollArray(elem, left, top) {
182    
183    directionCheck(left, top);
184
185    if (options.accelerationMax != 1) {
186        var now = Date.now();
187        var elapsed = now - lastScroll;
188        if (elapsed < options.accelerationDelta) {
189            var factor = (1 + (50 / elapsed)) / 2;
190            if (factor > 1) {
191                factor = Math.min(factor, options.accelerationMax);
192                left *= factor;
193                top  *= factor;
194            }
195        }
196        lastScroll = Date.now();
197    }          
198    
199    // push a scroll command
200    que.push({
201        x: left, 
202        y: top, 
203        lastX: (left < 0) ? 0.99 : -0.99,
204        lastY: (top  < 0) ? 0.99 : -0.99, 
205        start: Date.now()
206    });
207        
208    // don't act if there's a pending queue
209    if (pending) {
210        return;
211    }  
212
213    var scrollRoot = getScrollRoot();
214    var isWindowScroll = (elem === scrollRoot || elem === document.body);
215    
216    // if we haven't already fixed the behavior, 
217    // and it needs fixing for this sesh
218    if (elem.$scrollBehavior == null && isScrollBehaviorSmooth(elem)) {
219        elem.$scrollBehavior = elem.style.scrollBehavior;
220        elem.style.scrollBehavior = 'auto';
221    }
222
223    var step = function (time) {
224        
225        var now = Date.now();
226        var scrollX = 0;
227        var scrollY = 0; 
228    
229        for (var i = 0; i < que.length; i++) {
230            
231            var item = que[i];
232            var elapsed  = now - item.start;
233            var finished = (elapsed >= options.animationTime);
234            
235            // scroll position: [0, 1]
236            var position = (finished) ? 1 : elapsed / options.animationTime;
237            
238            // easing [optional]
239            if (options.pulseAlgorithm) {
240                position = pulse(position);
241            }
242            
243            // only need the difference
244            var x = (item.x * position - item.lastX) >> 0;
245            var y = (item.y * position - item.lastY) >> 0;
246            
247            // add this to the total scrolling
248            scrollX += x;
249            scrollY += y;            
250            
251            // update last values
252            item.lastX += x;
253            item.lastY += y;
254        
255            // delete and step back if it's over
256            if (finished) {
257                que.splice(i, 1); i--;
258            }           
259        }
260
261        // scroll left and top
262        if (isWindowScroll) {
263            window.scrollBy(scrollX, scrollY);
264        } 
265        else {
266            if (scrollX) elem.scrollLeft += scrollX;
267            if (scrollY) elem.scrollTop  += scrollY;                    
268        }
269        
270        // clean up if there's nothing left to do
271        if (!left && !top) {
272            que = [];
273        }
274        
275        if (que.length) { 
276            requestFrame(step, elem, (1000 / options.frameRate + 1)); 
277        } else { 
278            pending = false;
279            // restore default behavior at the end of scrolling sesh
280            if (elem.$scrollBehavior != null) {
281                elem.style.scrollBehavior = elem.$scrollBehavior;
282                elem.$scrollBehavior = null;
283            }
284        }
285    };
286    
287    // start a new queue of actions
288    requestFrame(step, elem, 0);
289    pending = true;
290}
291
292
293/***********************************************
294 * EVENTS
295 ***********************************************/
296
297/**
298 * Mouse wheel handler.
299 * @param {Object} event
300 */
301function wheel(event) {
302
303    if (!initDone) {
304        init();
305    }
306    
307    var target = getEventTargetDeep(event);
308
309    // leave early if default action is prevented   
310    // or it's a zooming event with CTRL 
311    if (event.defaultPrevented || event.ctrlKey) {
312        return true;
313    }
314    
315    // leave embedded content alone (flash & pdf)
316    if (isNodeName(activeElement, 'embed') || 
317       (isNodeName(target, 'embed') && /\.pdf/i.test(target.src)) ||
318        isNodeName(activeElement, 'object')) {
319        return true;
320    }
321
322    // TODO:
323    //
324    // wheelDeltaY (DEPRECATED):
325    //   - Mac: positive (+) for scrolling down; Win: negative (-) for up
326    //   - Mac & Win: in simple case multiple of 120 or 100 (except Firefox maybe)
327    //   - scaled by zoom level (hard to detect, devicePixelRatio affected by ppi)
328    // deltaY (NEW):
329    //   - Mac: negative (-) for scrolling down; Win: positive (+) for up
330    //   - Win: in simple case it's multiple of 300
331    //   - Mac: can be any number because of default shitty "acceleration"
332    //          some third party apps might change it to line-based (120x)
333    //   - scaled by zoom level (hard to detect, devicePixelRatio affected by ppi)
334    //
335    // For touchpad in Chromium this seems to hold true: 
336    //    e.wheelDeltaY === (e.deltaY * -3)
337    // but it also holds for mouses on Safari Mac with default "acceleration".
338    // Also not future-proof because wheelDeltaY is deprecated
339
340    var deltaX = -event.wheelDeltaX || event.deltaX || 0;
341    var deltaY = -event.wheelDeltaY || event.deltaY || 0;
342    
343    if (isMac) {
344        if (event.wheelDeltaX && isDivisible(event.wheelDeltaX, 120)) {
345            deltaX = -120 * (event.wheelDeltaX / Math.abs(event.wheelDeltaX));
346        }
347        if (event.wheelDeltaY && isDivisible(event.wheelDeltaY, 120)) {
348            deltaY = -120 * (event.wheelDeltaY / Math.abs(event.wheelDeltaY));
349        }
350    }
351    
352    // use wheelDelta if deltaX/Y is not available
353    if (!deltaX && !deltaY) {
354        deltaY = -event.wheelDelta || 0;
355    }
356
357    // line based scrolling (Firefox mostly)
358    if (event.deltaMode === 1) {
359        deltaX *= 40;
360        deltaY *= 40;
361    }
362
363    var overflowing = overflowingAncestor(target);
364
365    // nothing to do if there's no element that's scrollable
366    if (!overflowing) {
367        // except Chrome iframes seem to eat wheel events, which we need to 
368        // propagate up, if the iframe has nothing overflowing to scroll
369        if (isFrame && isChrome)  {
370            // change target to iframe element itself for the parent frame
371            Object.defineProperty(event, "target", {value: window.frameElement});
372            return parent.wheel(event);
373        }
374        return true;
375    }
376    
377    // check if it's a touchpad scroll that should be ignored
378    if (isTouchpad(deltaY)) {
379        return true;
380    }
381
382    // scale by step size
383    // delta is 120 most of the time
384    // synaptics seems to send 1 sometimes
385    if (Math.abs(deltaX) > 1.2) {
386        deltaX *= options.stepSize / 120;
387    }
388    if (Math.abs(deltaY) > 1.2) {
389        deltaY *= options.stepSize / 120;
390    }
391    
392    scrollArray(overflowing, deltaX, deltaY);
393    event.preventDefault();
394    scheduleClearCache();
395}
396
397/**
398 * Keydown event handler.
399 * @param {Object} event
400 */
401function keydown(event) {
402
403    var target = getEventTargetDeep(event);
404    var modifier = event.ctrlKey || event.altKey || event.metaKey || 
405                  (event.shiftKey && event.code !== 'Space');
406    
407    // our own tracked active element could've been removed from the DOM
408    if (!document.body.contains(activeElement)) {
409        activeElement = document.activeElement;
410    }
411
412    // do nothing if user is editing text
413    // or using a modifier key (except shift)
414    // or in a dropdown
415    // or inside interactive elements
416    var inputNodeNames = /^(textarea|select|embed|object)$/i;
417    var buttonTypes = /^(button|submit|radio|checkbox|file|color|image)$/i;
418    if ( event.defaultPrevented ||
419         inputNodeNames.test(target.nodeName) ||
420         isNodeName(target, 'input') && !buttonTypes.test(target.type) ||
421         isNodeName(activeElement, 'video') ||
422         isInsideYoutubeVideo(event) ||
423         target.isContentEditable || 
424         modifier ) {
425      return true;
426    }
427
428    // [spacebar] should trigger button press, leave it alone
429    if ((isNodeName(target, 'button') ||
430         isNodeName(target, 'input') && buttonTypes.test(target.type)) &&
431        event.code === 'Space') {
432      return true;
433    }
434
435    // [arrow keys] on radio buttons should be left alone
436    if (isNodeName(target, 'input') && target.type == 'radio' &&
437        (event.code === 'ArrowUp' || event.code === 'ArrowDown' || 
438         event.code === 'ArrowLeft' || event.code === 'ArrowRight'))  {
439      return true;
440    }
441    
442    var shift, x = 0, y = 0;
443    var overflowing = overflowingAncestor(activeElement);
444
445    if (!overflowing) {
446        // Chrome iframes seem to eat key events, which we need to 
447        // propagate up, if the iframe has nothing overflowing to scroll
448        return (isFrame && isChrome) ? parent.keydown(event) : true;
449    }
450
451    var clientHeight = overflowing.clientHeight; 
452
453    if (overflowing == document.body) {
454        clientHeight = window.innerHeight;
455    }
456
457    switch (event.code) {
458        case 'ArrowUp':
459            y = -options.arrowScroll;
460            break;
461        case 'ArrowDown':
462            y = options.arrowScroll;
463            break;         
464        case 'Space':
465            shift = event.shiftKey ? 1 : -1;
466            y = -shift * clientHeight * 0.9;
467            break;
468        case 'PageUp':
469            y = -clientHeight * 0.9;
470            break;
471        case 'PageDown':
472            y = clientHeight * 0.9;
473            break;
474        case 'Home':
475            if (overflowing == document.body && document.scrollingElement)
476                overflowing = document.scrollingElement;
477            y = -overflowing.scrollTop;
478            break;
479        case 'End':
480            var scroll = overflowing.scrollHeight - overflowing.scrollTop;
481            var scrollRemaining = scroll - clientHeight;
482            y = (scrollRemaining > 0) ? scrollRemaining + 10 : 0;
483            break;
484        case 'ArrowLeft':
485            x = -options.arrowScroll;
486            break;
487        case 'ArrowRight':
488            x = options.arrowScroll;
489            break;            
490        default:
491            return true; // a key we don't care about
492    }
493
494    scrollArray(overflowing, x, y);
495    event.preventDefault();
496    scheduleClearCache();
497}
498
499/**
500 * Mousedown event only for updating activeElement
501 */
502function mousedown(event) {
503    activeElement = getEventTargetDeep(event);
504}
505
506/**
507 * Get the deepest event target even through shadow DOM.
508 * @param {Object} event
509 * @return {Element}
510 */
511function getEventTargetDeep(event) {
512    return event.composedPath ? event.composedPath()[0] : event.target;
513}
514
515
516/***********************************************
517 * OVERFLOW
518 ***********************************************/
519
520var uniqueID = (function () {
521    var i = 0;
522    return function (el) {
523        return el.uniqueID || (el.uniqueID = i++);
524    };
525})();
526
527var cacheX = {}; // cleared out after a scrolling session
528var cacheY = {}; // cleared out after a scrolling session
529var clearCacheTimer;
530var smoothBehaviorForElement = {};
531
532//setInterval(function () { cache = {}; }, 10 * 1000);
533
534function scheduleClearCache() {
535    clearTimeout(clearCacheTimer);
536    clearCacheTimer = setInterval(function () { 
537        cacheX = cacheY = smoothBehaviorForElement = {}; 
538    }, 1*1000);
539}
540
541function setCache(elems, overflowing, x) {
542    var cache = x ? cacheX : cacheY;
543    for (var i = elems.length; i--;)
544        cache[uniqueID(elems[i])] = overflowing;
545    return overflowing;
546}
547
548function getCache(el, x) {
549    return (x ? cacheX : cacheY)[uniqueID(el)];
550}
551
552//  (body)                (root)
553//         | hidden | visible | scroll |  auto  |
554// hidden  |   no   |    no   |   YES  |   YES  |
555// visible |   no   |   YES   |   YES  |   YES  |
556// scroll  |   no   |   YES   |   YES  |   YES  |
557// auto    |   no   |   YES   |   YES  |   YES  |
558
559function overflowingAncestor(el) {
560    var elems = [];
561    var body = document.body;
562    var rootScrollHeight = root.scrollHeight;
563    while (el) {
564        var cached = getCache(el, false);
565        if (cached) {
566            return setCache(elems, cached);
567        }
568        elems.push(el);
569        if (rootScrollHeight === el.scrollHeight) {
570            var topOverflowsNotHidden = overflowNotHidden(root) && overflowNotHidden(body);
571            var isOverflowCSS = topOverflowsNotHidden || overflowAutoOrScroll(root);
572            if (isFrame && isContentOverflowing(root) || 
573               !isFrame && isOverflowCSS) {
574                return setCache(elems, getScrollRoot()); 
575            }
576        } else if (isContentOverflowing(el) && overflowAutoOrScroll(el)) {
577            return setCache(elems, el);
578        }
579        // Support shadow DOM
580        el = el.parentElement || (el.getRootNode && el.getRootNode().host); 
581    }
582}
583
584function isContentOverflowing(el) {
585    return (el.clientHeight + 10 < el.scrollHeight);
586}
587
588// typically for <body> and <html>
589function overflowNotHidden(el) {
590    var overflow = getComputedStyle(el, '').getPropertyValue('overflow-y');
591    return (overflow !== 'hidden');
592}
593
594// for all other elements
595function overflowAutoOrScroll(el) {
596    var overflow = getComputedStyle(el, '').getPropertyValue('overflow-y');
597    return (overflow === 'scroll' || overflow === 'auto');
598}
599
600// for all other elements
601function isScrollBehaviorSmooth(el) {
602    var id = uniqueID(el);
603    if (smoothBehaviorForElement[id] == null) {
604        var scrollBehavior = getComputedStyle(el, '')['scroll-behavior'];
605        smoothBehaviorForElement[id] = ('smooth' == scrollBehavior);
606    }
607    return smoothBehaviorForElement[id];
608}
609
610
611/***********************************************
612 * HELPERS
613 ***********************************************/
614
615function addEvent(type, fn, arg) {
616    window.addEventListener(type, fn, arg || false);
617}
618
619function removeEvent(type, fn, arg) {
620    window.removeEventListener(type, fn, arg || false);  
621}
622
623function isNodeName(el, tag) {
624    return el && (el.nodeName||'').toLowerCase() === tag.toLowerCase();
625}
626
627function directionCheck(x, y) {
628    x = (x > 0) ? 1 : -1;
629    y = (y > 0) ? 1 : -1;
630    if (direction.x !== x || direction.y !== y) {
631        direction.x = x;
632        direction.y = y;
633        que = [];
634        lastScroll = 0;
635    }
636}
637
638try { // #46 Safari throws in private browsing for localStorage 
639    if (localStorage.SS_deltaBuffer) {
640        deltaBuffer = localStorage.SS_deltaBuffer.split(',');
641    }
642} catch (e) { } 
643
644function isTouchpad(deltaY) {
645    if (!deltaY) return;
646    if (!deltaBuffer.length) {
647        deltaBuffer = [deltaY, deltaY, deltaY];
648    }
649    deltaY = Math.abs(deltaY);
650    deltaBuffer.push(deltaY);
651    deltaBuffer.shift();
652    clearTimeout(deltaBufferTimer);
653    deltaBufferTimer = setTimeout(function () {
654        try { // #46 Safari throws in private browsing for localStorage
655            localStorage.SS_deltaBuffer = deltaBuffer.join(',');
656        } catch (e) { }  
657    }, 1000);
658    var dpiScaledWheelDelta = deltaY > 120 && allDeltasDivisableBy(deltaY); // win64 
659    var tp = !allDeltasDivisableBy(120) && !allDeltasDivisableBy(100) && !dpiScaledWheelDelta;
660    if (deltaY < 50) return true;
661    return tp;
662} 
663
664function isDivisible(n, divisor) {
665    return (Math.floor(n / divisor) == n / divisor);
666}
667
668function allDeltasDivisableBy(divisor) {
669    return (isDivisible(deltaBuffer[0], divisor) &&
670            isDivisible(deltaBuffer[1], divisor) &&
671            isDivisible(deltaBuffer[2], divisor));
672}
673
674function isInsideYoutubeVideo(event) {
675    var elem = getEventTargetDeep(event);
676    var isControl = false;
677    if (document.URL.indexOf ('www.youtube.com/watch') != -1) {
678        do {
679            isControl = (elem.classList && 
680                         elem.classList.contains('html5-video-controls'));
681            if (isControl) break;
682        } while ((elem = elem.parentNode));
683    }
684    return isControl;
685}
686
687var requestFrame = (function () {
688      return (window.requestAnimationFrame       || 
689              window.webkitRequestAnimationFrame || 
690              window.mozRequestAnimationFrame    ||
691              function (callback, element, delay) {
692                 window.setTimeout(callback, delay || (1000/60));
693             });
694})();
695
696var MutationObserver = (window.MutationObserver || 
697                        window.WebKitMutationObserver ||
698                        window.MozMutationObserver);  
699
700var getScrollRoot = (function() {
701  var SCROLL_ROOT = document.scrollingElement;
702  return function() {
703    if (!SCROLL_ROOT) {
704      var dummy = document.createElement('div');
705      dummy.style.cssText = 'height:10000px;width:1px;';
706      document.body.appendChild(dummy);
707      var bodyScrollTop  = document.body.scrollTop;
708      var docElScrollTop = document.documentElement.scrollTop;
709      window.scrollBy(0, 3);
710      if (document.body.scrollTop != bodyScrollTop)
711        (SCROLL_ROOT = document.body);
712      else 
713        (SCROLL_ROOT = document.documentElement);
714      window.scrollBy(0, -3);
715      document.body.removeChild(dummy);
716    }
717    return SCROLL_ROOT;
718  };
719})();
720
721
722/***********************************************
723 * PULSE (by Michael Herf)
724 ***********************************************/
725 
726/**
727 * Viscous fluid with a pulse for part and decay for the rest.
728 * - Applies a fixed force over an interval (a damped acceleration), and
729 * - Lets the exponential bleed away the velocity over a longer interval
730 * - Michael Herf, http://stereopsis.com/stopping/
731 */
732function pulse_(x) {
733    var val, start, expx;
734    // test
735    x = x * options.pulseScale;
736    if (x < 1) { // acceleartion
737        val = x - (1 - Math.exp(-x));
738    } else {     // tail
739        // the previous animation ended here:
740        start = Math.exp(-1);
741        // simple viscous drag
742        x -= 1;
743        expx = 1 - Math.exp(-x);
744        val = start + (expx * (1 - start));
745    }
746    return val * options.pulseNormalize;
747}
748
749function pulse(x) {
750    if (x >= 1) return 1;
751    if (x <= 0) return 0;
752
753    if (options.pulseNormalize == 1) {
754        options.pulseNormalize /= pulse_(1);
755    }
756    return pulse_(x);
757}
758
759
760/***********************************************
761 * FIRST RUN
762 ***********************************************/
763
764var userAgent = window.navigator.userAgent;
765var isEdge    = /Edge/.test(userAgent); // thank you MS
766var isChrome  = /chrome/i.test(userAgent) && !isEdge; 
767var isSafari  = /safari/i.test(userAgent) && !isEdge; 
768var isMobile  = /mobile/i.test(userAgent);
769var isIEWin7  = /Windows NT 6.1/i.test(userAgent) && /rv:11/i.test(userAgent);
770var isOldSafari = isSafari && (/Version\/8/i.test(userAgent) || /Version\/9/i.test(userAgent));
771var isEnabledForBrowser = (isChrome || isSafari || isIEWin7) && !isMobile;
772
773var supportsPassive = false;
774try {
775  window.addEventListener("test", null, Object.defineProperty({}, 'passive', {
776    get: function () {
777            supportsPassive = true;
778        } 
779    }));
780} catch(e) {}
781
782var wheelOpt = supportsPassive ? { passive: false } : false;
783var wheelEvent = 'onwheel' in document.createElement('div') ? 'wheel' : 'mousewheel'; 
784
785if (wheelEvent && isEnabledForBrowser) {
786    addEvent(wheelEvent, wheel, wheelOpt);
787    addEvent('mousedown', mousedown);