{"version":3,"file":"632cba62-6a80191236e5295bd1d8.js","mappings":"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","sources":["webpack://minerall.io/./node_modules/overlayscrollbars/js/OverlayScrollbars.js"],"sourcesContent":["/*!\r\n * OverlayScrollbars\r\n * https://github.com/KingSora/OverlayScrollbars\r\n *\r\n * Version: 1.13.3\r\n *\r\n * Copyright KingSora | Rene Haas.\r\n * https://github.com/KingSora\r\n *\r\n * Released under the MIT license.\r\n * Date: 20.07.2022\r\n */\n(function (global, factory) {\n  if (typeof define === 'function' && define.amd) define(function () {\n    return factory(global, global.document, undefined);\n  });else if (typeof module === 'object' && typeof module.exports === 'object') module.exports = factory(global, global.document, undefined);else factory(global, global.document, undefined);\n})(typeof window !== 'undefined' ? window : this, function (window, document, undefined) {\n  'use strict';\n\n  var PLUGINNAME = 'OverlayScrollbars';\n  var TYPES = {\n    o: 'object',\n    f: 'function',\n    a: 'array',\n    s: 'string',\n    b: 'boolean',\n    n: 'number',\n    u: 'undefined',\n    z: 'null' //d : 'date',\n    //e : 'error',\n    //r : 'regexp',\n    //y : 'symbol'\n\n  };\n  var LEXICON = {\n    c: 'class',\n    s: 'style',\n    i: 'id',\n    l: 'length',\n    p: 'prototype',\n    ti: 'tabindex',\n    oH: 'offsetHeight',\n    cH: 'clientHeight',\n    sH: 'scrollHeight',\n    oW: 'offsetWidth',\n    cW: 'clientWidth',\n    sW: 'scrollWidth',\n    hOP: 'hasOwnProperty',\n    bCR: 'getBoundingClientRect'\n  };\n\n  var VENDORS = function () {\n    //https://developer.mozilla.org/en-US/docs/Glossary/Vendor_Prefix\n    var jsCache = {};\n    var cssCache = {};\n    var cssPrefixes = ['-webkit-', '-moz-', '-o-', '-ms-'];\n    var jsPrefixes = ['WebKit', 'Moz', 'O', 'MS'];\n\n    function firstLetterToUpper(str) {\n      return str.charAt(0).toUpperCase() + str.slice(1);\n    }\n\n    return {\n      _cssPrefixes: cssPrefixes,\n      _jsPrefixes: jsPrefixes,\n      _cssProperty: function _cssProperty(name) {\n        var result = cssCache[name];\n        if (cssCache[LEXICON.hOP](name)) return result;\n        var uppercasedName = firstLetterToUpper(name);\n        var elmStyle = document.createElement('div')[LEXICON.s];\n        var resultPossibilities;\n        var i = 0;\n        var v;\n        var currVendorWithoutDashes;\n\n        for (; i < cssPrefixes.length; i++) {\n          currVendorWithoutDashes = cssPrefixes[i].replace(/-/g, '');\n          resultPossibilities = [name, //transition\n          cssPrefixes[i] + name, //-webkit-transition\n          currVendorWithoutDashes + uppercasedName, //webkitTransition\n          firstLetterToUpper(currVendorWithoutDashes) + uppercasedName //WebkitTransition\n          ];\n\n          for (v = 0; v < resultPossibilities[LEXICON.l]; v++) {\n            if (elmStyle[resultPossibilities[v]] !== undefined) {\n              result = resultPossibilities[v];\n              break;\n            }\n          }\n        }\n\n        cssCache[name] = result;\n        return result;\n      },\n      _cssPropertyValue: function _cssPropertyValue(property, values, suffix) {\n        var name = property + ' ' + values;\n        var result = cssCache[name];\n        if (cssCache[LEXICON.hOP](name)) return result;\n        var dummyStyle = document.createElement('div')[LEXICON.s];\n        var possbleValues = values.split(' ');\n        var preparedSuffix = suffix || '';\n        var i = 0;\n        var v = -1;\n        var prop;\n\n        for (; i < possbleValues[LEXICON.l]; i++) {\n          for (; v < VENDORS._cssPrefixes[LEXICON.l]; v++) {\n            prop = v < 0 ? possbleValues[i] : VENDORS._cssPrefixes[v] + possbleValues[i];\n            dummyStyle.cssText = property + ':' + prop + preparedSuffix;\n\n            if (dummyStyle[LEXICON.l]) {\n              result = prop;\n              break;\n            }\n          }\n        }\n\n        cssCache[name] = result;\n        return result;\n      },\n      _jsAPI: function _jsAPI(name, isInterface, fallback) {\n        var i = 0;\n        var result = jsCache[name];\n\n        if (!jsCache[LEXICON.hOP](name)) {\n          result = window[name];\n\n          for (; i < jsPrefixes[LEXICON.l]; i++) {\n            result = result || window[(isInterface ? jsPrefixes[i] : jsPrefixes[i].toLowerCase()) + firstLetterToUpper(name)];\n          }\n\n          jsCache[name] = result;\n        }\n\n        return result || fallback;\n      }\n    };\n  }();\n\n  var COMPATIBILITY = function () {\n    function windowSize(x) {\n      return x ? window.innerWidth || document.documentElement[LEXICON.cW] || document.body[LEXICON.cW] : window.innerHeight || document.documentElement[LEXICON.cH] || document.body[LEXICON.cH];\n    }\n\n    function bind(func, thisObj) {\n      if (typeof func != TYPES.f) {\n        throw \"Can't bind function!\"; // closest thing possible to the ECMAScript 5\n        // internal IsCallable function\n        //throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable');\n      }\n\n      var proto = LEXICON.p;\n      var aArgs = Array[proto].slice.call(arguments, 2);\n\n      var fNOP = function fNOP() {};\n\n      var fBound = function fBound() {\n        return func.apply(this instanceof fNOP ? this : thisObj, aArgs.concat(Array[proto].slice.call(arguments)));\n      };\n\n      if (func[proto]) fNOP[proto] = func[proto]; // Function.prototype doesn't have a prototype property\n\n      fBound[proto] = new fNOP();\n      return fBound;\n    }\n\n    return {\n      /**\r\n       * Gets the current window width.\r\n       * @returns {Number|number} The current window width in pixel.\r\n       */\n      wW: bind(windowSize, 0, true),\n\n      /**\r\n       * Gets the current window height.\r\n       * @returns {Number|number} The current window height in pixel.\r\n       */\n      wH: bind(windowSize, 0),\n\n      /**\r\n       * Gets the MutationObserver Object or undefined if not supported.\r\n       * @returns {MutationObserver|*|undefined} The MutationsObserver Object or undefined.\r\n       */\n      mO: bind(VENDORS._jsAPI, 0, 'MutationObserver', true),\n\n      /**\r\n       * Gets the ResizeObserver Object or undefined if not supported.\r\n       * @returns {MutationObserver|*|undefined} The ResizeObserver Object or undefined.\r\n       */\n      rO: bind(VENDORS._jsAPI, 0, 'ResizeObserver', true),\n\n      /**\r\n       * Gets the RequestAnimationFrame method or it's corresponding polyfill.\r\n       * @returns {*|Function} The RequestAnimationFrame method or it's corresponding polyfill.\r\n       */\n      rAF: bind(VENDORS._jsAPI, 0, 'requestAnimationFrame', false, function (func) {\n        return window.setTimeout(func, 1000 / 60);\n      }),\n\n      /**\r\n       * Gets the CancelAnimationFrame method or it's corresponding polyfill.\r\n       * @returns {*|Function} The CancelAnimationFrame method or it's corresponding polyfill.\r\n       */\n      cAF: bind(VENDORS._jsAPI, 0, 'cancelAnimationFrame', false, function (id) {\n        return window.clearTimeout(id);\n      }),\n\n      /**\r\n       * Gets the current time.\r\n       * @returns {number} The current time.\r\n       */\n      now: function now() {\n        return Date.now && Date.now() || new Date().getTime();\n      },\n\n      /**\r\n       * Stops the propagation of the given event.\r\n       * @param event The event of which the propagation shall be stoped.\r\n       */\n      stpP: function stpP(event) {\n        if (event.stopPropagation) event.stopPropagation();else event.cancelBubble = true;\n      },\n\n      /**\r\n       * Prevents the default action of the given event.\r\n       * @param event The event of which the default action shall be prevented.\r\n       */\n      prvD: function prvD(event) {\n        if (event.preventDefault && event.cancelable) event.preventDefault();else event.returnValue = false;\n      },\n\n      /**\r\n       * Gets the pageX and pageY values of the given mouse event.\r\n       * @param event The mouse event of which the pageX and pageX shall be got.\r\n       * @returns {{x: number, y: number}} x = pageX value, y = pageY value.\r\n       */\n      page: function page(event) {\n        event = event.originalEvent || event;\n        var strPage = 'page';\n        var strClient = 'client';\n        var strX = 'X';\n        var strY = 'Y';\n        var target = event.target || event.srcElement || document;\n        var eventDoc = target.ownerDocument || document;\n        var doc = eventDoc.documentElement;\n        var body = eventDoc.body; //if touch event return return pageX/Y of it\n\n        if (event.touches !== undefined) {\n          var touch = event.touches[0];\n          return {\n            x: touch[strPage + strX],\n            y: touch[strPage + strY]\n          };\n        } // Calculate pageX/Y if not native supported\n\n\n        if (!event[strPage + strX] && event[strClient + strX] && event[strClient + strX] != null) {\n          return {\n            x: event[strClient + strX] + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0),\n            y: event[strClient + strY] + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0)\n          };\n        }\n\n        return {\n          x: event[strPage + strX],\n          y: event[strPage + strY]\n        };\n      },\n\n      /**\r\n       * Gets the clicked mouse button of the given mouse event.\r\n       * @param event The mouse event of which the clicked button shal be got.\r\n       * @returns {number} The number of the clicked mouse button. (0 : none | 1 : leftButton | 2 : middleButton | 3 : rightButton)\r\n       */\n      mBtn: function mBtn(event) {\n        var button = event.button;\n        if (!event.which && button !== undefined) return button & 1 ? 1 : button & 2 ? 3 : button & 4 ? 2 : 0;else return event.which;\n      },\n\n      /**\r\n       * Checks whether a item is in the given array and returns its index.\r\n       * @param item The item of which the position in the array shall be determined.\r\n       * @param arr The array.\r\n       * @returns {number} The zero based index of the item or -1 if the item isn't in the array.\r\n       */\n      inA: function inA(item, arr) {\n        for (var i = 0; i < arr[LEXICON.l]; i++) {\n          //Sometiems in IE a \"SCRIPT70\" Permission denied error occurs if HTML elements in a iFrame are compared\n          try {\n            if (arr[i] === item) return i;\n          } catch (e) {}\n        }\n\n        return -1;\n      },\n\n      /**\r\n       * Returns true if the given value is a array.\r\n       * @param arr The potential array.\r\n       * @returns {boolean} True if the given value is a array, false otherwise.\r\n       */\n      isA: function isA(arr) {\n        var def = Array.isArray;\n        return def ? def(arr) : this.type(arr) == TYPES.a;\n      },\n\n      /**\r\n       * Determine the internal JavaScript [[Class]] of the given object.\r\n       * @param obj The object of which the type shall be determined.\r\n       * @returns {string} The type of the given object.\r\n       */\n      type: function type(obj) {\n        if (obj === undefined) return obj + '';\n        if (obj === null) return obj + '';\n        return Object[LEXICON.p].toString.call(obj).replace(/^\\[object (.+)\\]$/, '$1').toLowerCase();\n      },\n      bind: bind\n      /**\r\n       * Gets the vendor-prefixed CSS property by the given name.\r\n       * For example the given name is \"transform\" and you're using a old Firefox browser then the returned value would be \"-moz-transform\".\r\n       * If the browser doesn't need a vendor-prefix, then the returned string is the given name.\r\n       * If the browser doesn't support the given property name at all (not even with a vendor-prefix) the returned value is null.\r\n       * @param propName The unprefixed CSS property name.\r\n       * @returns {string|null} The vendor-prefixed CSS property or null if the browser doesn't support the given CSS property.\r\n        cssProp: function(propName) {\r\n          return VENDORS._cssProperty(propName);\r\n      }\r\n      */\n\n    };\n  }();\n\n  var MATH = Math;\n  var JQUERY = window.jQuery;\n\n  var EASING = function () {\n    var _easingsMath = {\n      p: MATH.PI,\n      c: MATH.cos,\n      s: MATH.sin,\n      w: MATH.pow,\n      t: MATH.sqrt,\n      n: MATH.asin,\n      a: MATH.abs,\n      o: 1.70158\n    };\n    /*\r\n     x : current percent (0 - 1),\r\n     t : current time (duration * percent),\r\n     b : start value (from),\r\n     c : end value (to),\r\n     d : duration\r\n       easingName : function(x, t, b, c, d) { return easedValue; }\r\n     */\n\n    return {\n      swing: function swing(x, t, b, c, d) {\n        return 0.5 - _easingsMath.c(x * _easingsMath.p) / 2;\n      },\n      linear: function linear(x, t, b, c, d) {\n        return x;\n      },\n      easeInQuad: function easeInQuad(x, t, b, c, d) {\n        return c * (t /= d) * t + b;\n      },\n      easeOutQuad: function easeOutQuad(x, t, b, c, d) {\n        return -c * (t /= d) * (t - 2) + b;\n      },\n      easeInOutQuad: function easeInOutQuad(x, t, b, c, d) {\n        return (t /= d / 2) < 1 ? c / 2 * t * t + b : -c / 2 * (--t * (t - 2) - 1) + b;\n      },\n      easeInCubic: function easeInCubic(x, t, b, c, d) {\n        return c * (t /= d) * t * t + b;\n      },\n      easeOutCubic: function easeOutCubic(x, t, b, c, d) {\n        return c * ((t = t / d - 1) * t * t + 1) + b;\n      },\n      easeInOutCubic: function easeInOutCubic(x, t, b, c, d) {\n        return (t /= d / 2) < 1 ? c / 2 * t * t * t + b : c / 2 * ((t -= 2) * t * t + 2) + b;\n      },\n      easeInQuart: function easeInQuart(x, t, b, c, d) {\n        return c * (t /= d) * t * t * t + b;\n      },\n      easeOutQuart: function easeOutQuart(x, t, b, c, d) {\n        return -c * ((t = t / d - 1) * t * t * t - 1) + b;\n      },\n      easeInOutQuart: function easeInOutQuart(x, t, b, c, d) {\n        return (t /= d / 2) < 1 ? c / 2 * t * t * t * t + b : -c / 2 * ((t -= 2) * t * t * t - 2) + b;\n      },\n      easeInQuint: function easeInQuint(x, t, b, c, d) {\n        return c * (t /= d) * t * t * t * t + b;\n      },\n      easeOutQuint: function easeOutQuint(x, t, b, c, d) {\n        return c * ((t = t / d - 1) * t * t * t * t + 1) + b;\n      },\n      easeInOutQuint: function easeInOutQuint(x, t, b, c, d) {\n        return (t /= d / 2) < 1 ? c / 2 * t * t * t * t * t + b : c / 2 * ((t -= 2) * t * t * t * t + 2) + b;\n      },\n      easeInSine: function easeInSine(x, t, b, c, d) {\n        return -c * _easingsMath.c(t / d * (_easingsMath.p / 2)) + c + b;\n      },\n      easeOutSine: function easeOutSine(x, t, b, c, d) {\n        return c * _easingsMath.s(t / d * (_easingsMath.p / 2)) + b;\n      },\n      easeInOutSine: function easeInOutSine(x, t, b, c, d) {\n        return -c / 2 * (_easingsMath.c(_easingsMath.p * t / d) - 1) + b;\n      },\n      easeInExpo: function easeInExpo(x, t, b, c, d) {\n        return t == 0 ? b : c * _easingsMath.w(2, 10 * (t / d - 1)) + b;\n      },\n      easeOutExpo: function easeOutExpo(x, t, b, c, d) {\n        return t == d ? b + c : c * (-_easingsMath.w(2, -10 * t / d) + 1) + b;\n      },\n      easeInOutExpo: function easeInOutExpo(x, t, b, c, d) {\n        if (t == 0) return b;\n        if (t == d) return b + c;\n        if ((t /= d / 2) < 1) return c / 2 * _easingsMath.w(2, 10 * (t - 1)) + b;\n        return c / 2 * (-_easingsMath.w(2, -10 * --t) + 2) + b;\n      },\n      easeInCirc: function easeInCirc(x, t, b, c, d) {\n        return -c * (_easingsMath.t(1 - (t /= d) * t) - 1) + b;\n      },\n      easeOutCirc: function easeOutCirc(x, t, b, c, d) {\n        return c * _easingsMath.t(1 - (t = t / d - 1) * t) + b;\n      },\n      easeInOutCirc: function easeInOutCirc(x, t, b, c, d) {\n        return (t /= d / 2) < 1 ? -c / 2 * (_easingsMath.t(1 - t * t) - 1) + b : c / 2 * (_easingsMath.t(1 - (t -= 2) * t) + 1) + b;\n      },\n      easeInElastic: function easeInElastic(x, t, b, c, d) {\n        var s = _easingsMath.o;\n        var p = 0;\n        var a = c;\n        if (t == 0) return b;\n        if ((t /= d) == 1) return b + c;\n        if (!p) p = d * .3;\n\n        if (a < _easingsMath.a(c)) {\n          a = c;\n          s = p / 4;\n        } else s = p / (2 * _easingsMath.p) * _easingsMath.n(c / a);\n\n        return -(a * _easingsMath.w(2, 10 * (t -= 1)) * _easingsMath.s((t * d - s) * (2 * _easingsMath.p) / p)) + b;\n      },\n      easeOutElastic: function easeOutElastic(x, t, b, c, d) {\n        var s = _easingsMath.o;\n        var p = 0;\n        var a = c;\n        if (t == 0) return b;\n        if ((t /= d) == 1) return b + c;\n        if (!p) p = d * .3;\n\n        if (a < _easingsMath.a(c)) {\n          a = c;\n          s = p / 4;\n        } else s = p / (2 * _easingsMath.p) * _easingsMath.n(c / a);\n\n        return a * _easingsMath.w(2, -10 * t) * _easingsMath.s((t * d - s) * (2 * _easingsMath.p) / p) + c + b;\n      },\n      easeInOutElastic: function easeInOutElastic(x, t, b, c, d) {\n        var s = _easingsMath.o;\n        var p = 0;\n        var a = c;\n        if (t == 0) return b;\n        if ((t /= d / 2) == 2) return b + c;\n        if (!p) p = d * (.3 * 1.5);\n\n        if (a < _easingsMath.a(c)) {\n          a = c;\n          s = p / 4;\n        } else s = p / (2 * _easingsMath.p) * _easingsMath.n(c / a);\n\n        if (t < 1) return -.5 * (a * _easingsMath.w(2, 10 * (t -= 1)) * _easingsMath.s((t * d - s) * (2 * _easingsMath.p) / p)) + b;\n        return a * _easingsMath.w(2, -10 * (t -= 1)) * _easingsMath.s((t * d - s) * (2 * _easingsMath.p) / p) * .5 + c + b;\n      },\n      easeInBack: function easeInBack(x, t, b, c, d, s) {\n        s = s || _easingsMath.o;\n        return c * (t /= d) * t * ((s + 1) * t - s) + b;\n      },\n      easeOutBack: function easeOutBack(x, t, b, c, d, s) {\n        s = s || _easingsMath.o;\n        return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;\n      },\n      easeInOutBack: function easeInOutBack(x, t, b, c, d, s) {\n        s = s || _easingsMath.o;\n        return (t /= d / 2) < 1 ? c / 2 * (t * t * (((s *= 1.525) + 1) * t - s)) + b : c / 2 * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2) + b;\n      },\n      easeInBounce: function easeInBounce(x, t, b, c, d) {\n        return c - this.easeOutBounce(x, d - t, 0, c, d) + b;\n      },\n      easeOutBounce: function easeOutBounce(x, t, b, c, d) {\n        var o = 7.5625;\n\n        if ((t /= d) < 1 / 2.75) {\n          return c * (o * t * t) + b;\n        } else if (t < 2 / 2.75) {\n          return c * (o * (t -= 1.5 / 2.75) * t + .75) + b;\n        } else if (t < 2.5 / 2.75) {\n          return c * (o * (t -= 2.25 / 2.75) * t + .9375) + b;\n        } else {\n          return c * (o * (t -= 2.625 / 2.75) * t + .984375) + b;\n        }\n      },\n      easeInOutBounce: function easeInOutBounce(x, t, b, c, d) {\n        return t < d / 2 ? this.easeInBounce(x, t * 2, 0, c, d) * .5 + b : this.easeOutBounce(x, t * 2 - d, 0, c, d) * .5 + c * .5 + b;\n      }\n    };\n    /*\r\n     *\r\n     * TERMS OF USE - EASING EQUATIONS\r\n     * \r\n     * Open source under the BSD License. \r\n     * \r\n     * Copyright © 2001 Robert Penner\r\n     * All rights reserved.\r\n     * \r\n     * Redistribution and use in source and binary forms, with or without modification, \r\n     * are permitted provided that the following conditions are met:\r\n     * \r\n     * Redistributions of source code must retain the above copyright notice, this list of \r\n     * conditions and the following disclaimer.\r\n     * Redistributions in binary form must reproduce the above copyright notice, this list \r\n     * of conditions and the following disclaimer in the documentation and/or other materials \r\n     * provided with the distribution.\r\n     * \r\n     * Neither the name of the author nor the names of contributors may be used to endorse \r\n     * or promote products derived from this software without specific prior written permission.\r\n     * \r\n     * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY \r\n     * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\r\n     * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE\r\n     *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\r\n     *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE\r\n     *  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED \r\n     * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\r\n     *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED \r\n     * OF THE POSSIBILITY OF SUCH DAMAGE. \r\n     *\r\n     */\n  }();\n\n  var FRAMEWORK = function () {\n    var _rnothtmlwhite = /[^\\x20\\t\\r\\n\\f]+/g;\n    var _strSpace = ' ';\n    var _strEmpty = '';\n    var _strScrollLeft = 'scrollLeft';\n    var _strScrollTop = 'scrollTop';\n    var _animations = [];\n    var _type = COMPATIBILITY.type;\n    var _cssNumber = {\n      animationIterationCount: true,\n      columnCount: true,\n      fillOpacity: true,\n      flexGrow: true,\n      flexShrink: true,\n      fontWeight: true,\n      lineHeight: true,\n      opacity: true,\n      order: true,\n      orphans: true,\n      widows: true,\n      zIndex: true,\n      zoom: true\n    };\n\n    function extend() {\n      var src,\n          copyIsArray,\n          copy,\n          name,\n          options,\n          clone,\n          target = arguments[0] || {},\n          i = 1,\n          length = arguments[LEXICON.l],\n          deep = false; // Handle a deep copy situation\n\n      if (_type(target) == TYPES.b) {\n        deep = target;\n        target = arguments[1] || {}; // skip the boolean and the target\n\n        i = 2;\n      } // Handle case when target is a string or something (possible in deep copy)\n\n\n      if (_type(target) != TYPES.o && !_type(target) == TYPES.f) {\n        target = {};\n      } // extend jQuery itself if only one argument is passed\n\n\n      if (length === i) {\n        target = FakejQuery;\n        --i;\n      }\n\n      for (; i < length; i++) {\n        // Only deal with non-null/undefined values\n        if ((options = arguments[i]) != null) {\n          // Extend the base object\n          for (name in options) {\n            src = target[name];\n            copy = options[name]; // Prevent never-ending loop\n\n            if (target === copy) {\n              continue;\n            } // Recurse if we're merging plain objects or arrays\n\n\n            if (deep && copy && (isPlainObject(copy) || (copyIsArray = COMPATIBILITY.isA(copy)))) {\n              if (copyIsArray) {\n                copyIsArray = false;\n                clone = src && COMPATIBILITY.isA(src) ? src : [];\n              } else {\n                clone = src && isPlainObject(src) ? src : {};\n              } // Never move original objects, clone them\n\n\n              target[name] = extend(deep, clone, copy); // Don't bring in undefined values\n            } else if (copy !== undefined) {\n              target[name] = copy;\n            }\n          }\n        }\n      } // Return the modified object\n\n\n      return target;\n    }\n\n    ;\n\n    function inArray(item, arr, fromIndex) {\n      for (var i = fromIndex || 0; i < arr[LEXICON.l]; i++) {\n        if (arr[i] === item) return i;\n      }\n\n      return -1;\n    }\n\n    function isFunction(obj) {\n      return _type(obj) == TYPES.f;\n    }\n\n    ;\n\n    function isEmptyObject(obj) {\n      for (var name in obj) {\n        return false;\n      }\n\n      return true;\n    }\n\n    ;\n\n    function isPlainObject(obj) {\n      if (!obj || _type(obj) != TYPES.o) return false;\n      var key;\n      var proto = LEXICON.p;\n      var hasOwnProperty = Object[proto].hasOwnProperty;\n      var hasOwnConstructor = hasOwnProperty.call(obj, 'constructor');\n      var hasIsPrototypeOf = obj.constructor && obj.constructor[proto] && hasOwnProperty.call(obj.constructor[proto], 'isPrototypeOf');\n\n      if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n        return false;\n      }\n\n      for (key in obj) {\n        /**/\n      }\n\n      return _type(key) == TYPES.u || hasOwnProperty.call(obj, key);\n    }\n\n    ;\n\n    function _each(obj, callback) {\n      var i = 0;\n\n      if (isArrayLike(obj)) {\n        for (; i < obj[LEXICON.l]; i++) {\n          if (callback.call(obj[i], i, obj[i]) === false) break;\n        }\n      } else {\n        for (i in obj) {\n          if (callback.call(obj[i], i, obj[i]) === false) break;\n        }\n      }\n\n      return obj;\n    }\n\n    ;\n\n    function isArrayLike(obj) {\n      var length = !!obj && [LEXICON.l] in obj && obj[LEXICON.l];\n\n      var t = _type(obj);\n\n      return isFunction(t) ? false : t == TYPES.a || length === 0 || _type(length) == TYPES.n && length > 0 && length - 1 in obj;\n    }\n\n    function stripAndCollapse(value) {\n      var tokens = value.match(_rnothtmlwhite) || [];\n      return tokens.join(_strSpace);\n    }\n\n    function matches(elem, selector) {\n      var nodeList = (elem.parentNode || document).querySelectorAll(selector) || [];\n      var i = nodeList[LEXICON.l];\n\n      while (i--) {\n        if (nodeList[i] == elem) return true;\n      }\n\n      return false;\n    }\n\n    function insertAdjacentElement(el, strategy, child) {\n      if (COMPATIBILITY.isA(child)) {\n        for (var i = 0; i < child[LEXICON.l]; i++) {\n          insertAdjacentElement(el, strategy, child[i]);\n        }\n      } else if (_type(child) == TYPES.s) el.insertAdjacentHTML(strategy, child);else el.insertAdjacentElement(strategy, child.nodeType ? child : child[0]);\n    }\n\n    function setCSSVal(el, prop, val) {\n      try {\n        if (el[LEXICON.s][prop] !== undefined) el[LEXICON.s][prop] = parseCSSVal(prop, val);\n      } catch (e) {}\n    }\n\n    function parseCSSVal(prop, val) {\n      if (!_cssNumber[prop.toLowerCase()] && _type(val) == TYPES.n) val += 'px';\n      return val;\n    }\n\n    function startNextAnimationInQ(animObj, removeFromQ) {\n      var index;\n      var nextAnim;\n      if (removeFromQ !== false) animObj.q.splice(0, 1);\n\n      if (animObj.q[LEXICON.l] > 0) {\n        nextAnim = animObj.q[0];\n\n        _animate(animObj.el, nextAnim.props, nextAnim.duration, nextAnim.easing, nextAnim.complete, true);\n      } else {\n        index = inArray(animObj, _animations);\n        if (index > -1) _animations.splice(index, 1);\n      }\n    }\n\n    function setAnimationValue(el, prop, value) {\n      if (prop === _strScrollLeft || prop === _strScrollTop) el[prop] = value;else setCSSVal(el, prop, value);\n    }\n\n    function _animate(el, props, options, easing, complete, guaranteedNext) {\n      var hasOptions = isPlainObject(options);\n      var from = {};\n      var to = {};\n      var i = 0;\n      var key;\n      var animObj;\n      var start;\n      var progress;\n      var step;\n      var specialEasing;\n      var duration;\n\n      if (hasOptions) {\n        easing = options.easing;\n        start = options.start;\n        progress = options.progress;\n        step = options.step;\n        specialEasing = options.specialEasing;\n        complete = options.complete;\n        duration = options.duration;\n      } else duration = options;\n\n      specialEasing = specialEasing || {};\n      duration = duration || 400;\n      easing = easing || 'swing';\n      guaranteedNext = guaranteedNext || false;\n\n      for (; i < _animations[LEXICON.l]; i++) {\n        if (_animations[i].el === el) {\n          animObj = _animations[i];\n          break;\n        }\n      }\n\n      if (!animObj) {\n        animObj = {\n          el: el,\n          q: []\n        };\n\n        _animations.push(animObj);\n      }\n\n      for (key in props) {\n        if (key === _strScrollLeft || key === _strScrollTop) from[key] = el[key];else from[key] = FakejQuery(el).css(key);\n      }\n\n      for (key in from) {\n        if (from[key] !== props[key] && props[key] !== undefined) to[key] = props[key];\n      }\n\n      if (!isEmptyObject(to)) {\n        var timeNow;\n        var end;\n        var percent;\n        var fromVal;\n        var toVal;\n        var easedVal;\n        var timeStart;\n\n        var _frame;\n\n        var elapsed;\n        var qPos = guaranteedNext ? 0 : inArray(qObj, animObj.q);\n        var qObj = {\n          props: to,\n          duration: hasOptions ? options : duration,\n          easing: easing,\n          complete: complete\n        };\n\n        if (qPos === -1) {\n          qPos = animObj.q[LEXICON.l];\n          animObj.q.push(qObj);\n        }\n\n        if (qPos === 0) {\n          if (duration > 0) {\n            timeStart = COMPATIBILITY.now();\n\n            _frame = function frame() {\n              timeNow = COMPATIBILITY.now();\n              elapsed = timeNow - timeStart;\n              end = qObj.stop || elapsed >= duration;\n              percent = 1 - (MATH.max(0, timeStart + duration - timeNow) / duration || 0);\n\n              for (key in to) {\n                fromVal = parseFloat(from[key]);\n                toVal = parseFloat(to[key]);\n                easedVal = (toVal - fromVal) * EASING[specialEasing[key] || easing](percent, percent * duration, 0, 1, duration) + fromVal;\n                setAnimationValue(el, key, easedVal);\n\n                if (isFunction(step)) {\n                  step(easedVal, {\n                    elem: el,\n                    prop: key,\n                    start: fromVal,\n                    now: easedVal,\n                    end: toVal,\n                    pos: percent,\n                    options: {\n                      easing: easing,\n                      speacialEasing: specialEasing,\n                      duration: duration,\n                      complete: complete,\n                      step: step\n                    },\n                    startTime: timeStart\n                  });\n                }\n              }\n\n              if (isFunction(progress)) progress({}, percent, MATH.max(0, duration - elapsed));\n\n              if (end) {\n                startNextAnimationInQ(animObj);\n                if (isFunction(complete)) complete();\n              } else qObj.frame = COMPATIBILITY.rAF()(_frame);\n            };\n\n            qObj.frame = COMPATIBILITY.rAF()(_frame);\n          } else {\n            for (key in to) {\n              setAnimationValue(el, key, to[key]);\n            }\n\n            startNextAnimationInQ(animObj);\n          }\n        }\n      } else if (guaranteedNext) startNextAnimationInQ(animObj);\n    }\n\n    function _stop(el, clearQ, jumpToEnd) {\n      var animObj;\n      var qObj;\n      var key;\n      var i = 0;\n\n      for (; i < _animations[LEXICON.l]; i++) {\n        animObj = _animations[i];\n\n        if (animObj.el === el) {\n          if (animObj.q[LEXICON.l] > 0) {\n            qObj = animObj.q[0];\n            qObj.stop = true;\n            COMPATIBILITY.cAF()(qObj.frame);\n            animObj.q.splice(0, 1);\n            if (jumpToEnd) for (key in qObj.props) {\n              setAnimationValue(el, key, qObj.props[key]);\n            }\n            if (clearQ) animObj.q = [];else startNextAnimationInQ(animObj, false);\n          }\n\n          break;\n        }\n      }\n    }\n\n    function elementIsVisible(el) {\n      return !!(el[LEXICON.oW] || el[LEXICON.oH] || el.getClientRects()[LEXICON.l]);\n    }\n\n    function FakejQuery(selector) {\n      if (arguments[LEXICON.l] === 0) return this;\n      var base = new FakejQuery();\n      var elements = selector;\n      var i = 0;\n      var elms;\n      var el;\n\n      if (_type(selector) == TYPES.s) {\n        elements = [];\n\n        if (selector.charAt(0) === '<') {\n          el = document.createElement('div');\n          el.innerHTML = selector;\n          elms = el.children;\n        } else {\n          elms = document.querySelectorAll(selector);\n        }\n\n        for (; i < elms[LEXICON.l]; i++) {\n          elements.push(elms[i]);\n        }\n      }\n\n      if (elements) {\n        if (_type(elements) != TYPES.s && (!isArrayLike(elements) || elements === window || elements === elements.self)) elements = [elements];\n\n        for (i = 0; i < elements[LEXICON.l]; i++) {\n          base[i] = elements[i];\n        }\n\n        base[LEXICON.l] = elements[LEXICON.l];\n      }\n\n      return base;\n    }\n\n    ;\n    FakejQuery[LEXICON.p] = {\n      //EVENTS:\n      on: function on(eventName, handler) {\n        eventName = (eventName || _strEmpty).match(_rnothtmlwhite) || [_strEmpty];\n        var eventNameLength = eventName[LEXICON.l];\n        var i = 0;\n        var el;\n        return this.each(function () {\n          el = this;\n\n          try {\n            if (el.addEventListener) {\n              for (; i < eventNameLength; i++) {\n                el.addEventListener(eventName[i], handler);\n              }\n            } else if (el.detachEvent) {\n              for (; i < eventNameLength; i++) {\n                el.attachEvent('on' + eventName[i], handler);\n              }\n            }\n          } catch (e) {}\n        });\n      },\n      off: function off(eventName, handler) {\n        eventName = (eventName || _strEmpty).match(_rnothtmlwhite) || [_strEmpty];\n        var eventNameLength = eventName[LEXICON.l];\n        var i = 0;\n        var el;\n        return this.each(function () {\n          el = this;\n\n          try {\n            if (el.removeEventListener) {\n              for (; i < eventNameLength; i++) {\n                el.removeEventListener(eventName[i], handler);\n              }\n            } else if (el.detachEvent) {\n              for (; i < eventNameLength; i++) {\n                el.detachEvent('on' + eventName[i], handler);\n              }\n            }\n          } catch (e) {}\n        });\n      },\n      one: function one(eventName, handler) {\n        eventName = (eventName || _strEmpty).match(_rnothtmlwhite) || [_strEmpty];\n        return this.each(function () {\n          var el = FakejQuery(this);\n          FakejQuery.each(eventName, function (i, oneEventName) {\n            var oneHandler = function oneHandler(e) {\n              handler.call(this, e);\n              el.off(oneEventName, oneHandler);\n            };\n\n            el.on(oneEventName, oneHandler);\n          });\n        });\n      },\n      trigger: function trigger(eventName) {\n        var el;\n        var event;\n        return this.each(function () {\n          el = this;\n\n          if (document.createEvent) {\n            event = document.createEvent('HTMLEvents');\n            event.initEvent(eventName, true, false);\n            el.dispatchEvent(event);\n          } else {\n            el.fireEvent('on' + eventName);\n          }\n        });\n      },\n      //DOM NODE INSERTING / REMOVING:\n      append: function append(child) {\n        return this.each(function () {\n          insertAdjacentElement(this, 'beforeend', child);\n        });\n      },\n      prepend: function prepend(child) {\n        return this.each(function () {\n          insertAdjacentElement(this, 'afterbegin', child);\n        });\n      },\n      before: function before(child) {\n        return this.each(function () {\n          insertAdjacentElement(this, 'beforebegin', child);\n        });\n      },\n      after: function after(child) {\n        return this.each(function () {\n          insertAdjacentElement(this, 'afterend', child);\n        });\n      },\n      remove: function remove() {\n        return this.each(function () {\n          var el = this;\n          var parentNode = el.parentNode;\n          if (parentNode != null) parentNode.removeChild(el);\n        });\n      },\n      unwrap: function unwrap() {\n        var parents = [];\n        var i;\n        var el;\n        var parent;\n        this.each(function () {\n          parent = this.parentNode;\n          if (inArray(parent, parents) === -1) parents.push(parent);\n        });\n\n        for (i = 0; i < parents[LEXICON.l]; i++) {\n          el = parents[i];\n          parent = el.parentNode;\n\n          while (el.firstChild) {\n            parent.insertBefore(el.firstChild, el);\n          }\n\n          parent.removeChild(el);\n        }\n\n        return this;\n      },\n      wrapAll: function wrapAll(wrapperHTML) {\n        var i;\n        var nodes = this;\n        var wrapper = FakejQuery(wrapperHTML)[0];\n        var deepest = wrapper;\n        var parent = nodes[0].parentNode;\n        var previousSibling = nodes[0].previousSibling;\n\n        while (deepest.childNodes[LEXICON.l] > 0) {\n          deepest = deepest.childNodes[0];\n        }\n\n        for (i = 0; nodes[LEXICON.l] - i; deepest.firstChild === nodes[0] && i++) {\n          deepest.appendChild(nodes[i]);\n        }\n\n        var nextSibling = previousSibling ? previousSibling.nextSibling : parent.firstChild;\n        parent.insertBefore(wrapper, nextSibling);\n        return this;\n      },\n      wrapInner: function wrapInner(wrapperHTML) {\n        return this.each(function () {\n          var el = FakejQuery(this);\n          var contents = el.contents();\n          if (contents[LEXICON.l]) contents.wrapAll(wrapperHTML);else el.append(wrapperHTML);\n        });\n      },\n      wrap: function wrap(wrapperHTML) {\n        return this.each(function () {\n          FakejQuery(this).wrapAll(wrapperHTML);\n        });\n      },\n      //DOM NODE MANIPULATION / INFORMATION:\n      css: function css(styles, val) {\n        var el;\n        var key;\n        var cptStyle;\n        var getCptStyle = window.getComputedStyle;\n\n        if (_type(styles) == TYPES.s) {\n          if (val === undefined) {\n            el = this[0];\n            cptStyle = getCptStyle ? getCptStyle(el, null) : el.currentStyle[styles]; //https://bugzilla.mozilla.org/show_bug.cgi?id=548397 can be null sometimes if iframe with display: none (firefox only!)\n\n            return getCptStyle ? cptStyle != null ? cptStyle.getPropertyValue(styles) : el[LEXICON.s][styles] : cptStyle;\n          } else {\n            return this.each(function () {\n              setCSSVal(this, styles, val);\n            });\n          }\n        } else {\n          return this.each(function () {\n            for (key in styles) {\n              setCSSVal(this, key, styles[key]);\n            }\n          });\n        }\n      },\n      hasClass: function hasClass(className) {\n        var elem,\n            i = 0;\n        var classNamePrepared = _strSpace + className + _strSpace;\n        var classList;\n\n        while (elem = this[i++]) {\n          classList = elem.classList;\n          if (classList && classList.contains(className)) return true;else if (elem.nodeType === 1 && (_strSpace + stripAndCollapse(elem.className + _strEmpty) + _strSpace).indexOf(classNamePrepared) > -1) return true;\n        }\n\n        return false;\n      },\n      addClass: function addClass(className) {\n        var classes;\n        var elem;\n        var cur;\n        var curValue;\n        var clazz;\n        var finalValue;\n        var supportClassList;\n        var elmClassList;\n        var i = 0;\n        var v = 0;\n\n        if (className) {\n          classes = className.match(_rnothtmlwhite) || [];\n\n          while (elem = this[i++]) {\n            elmClassList = elem.classList;\n            if (supportClassList === undefined) supportClassList = elmClassList !== undefined;\n\n            if (supportClassList) {\n              while (clazz = classes[v++]) {\n                elmClassList.add(clazz);\n              }\n            } else {\n              curValue = elem.className + _strEmpty;\n              cur = elem.nodeType === 1 && _strSpace + stripAndCollapse(curValue) + _strSpace;\n\n              if (cur) {\n                while (clazz = classes[v++]) {\n                  if (cur.indexOf(_strSpace + clazz + _strSpace) < 0) cur += clazz + _strSpace;\n                }\n\n                finalValue = stripAndCollapse(cur);\n                if (curValue !== finalValue) elem.className = finalValue;\n              }\n            }\n          }\n        }\n\n        return this;\n      },\n      removeClass: function removeClass(className) {\n        var classes;\n        var elem;\n        var cur;\n        var curValue;\n        var clazz;\n        var finalValue;\n        var supportClassList;\n        var elmClassList;\n        var i = 0;\n        var v = 0;\n\n        if (className) {\n          classes = className.match(_rnothtmlwhite) || [];\n\n          while (elem = this[i++]) {\n            elmClassList = elem.classList;\n            if (supportClassList === undefined) supportClassList = elmClassList !== undefined;\n\n            if (supportClassList) {\n              while (clazz = classes[v++]) {\n                elmClassList.remove(clazz);\n              }\n            } else {\n              curValue = elem.className + _strEmpty;\n              cur = elem.nodeType === 1 && _strSpace + stripAndCollapse(curValue) + _strSpace;\n\n              if (cur) {\n                while (clazz = classes[v++]) {\n                  while (cur.indexOf(_strSpace + clazz + _strSpace) > -1) {\n                    cur = cur.replace(_strSpace + clazz + _strSpace, _strSpace);\n                  }\n                }\n\n                finalValue = stripAndCollapse(cur);\n                if (curValue !== finalValue) elem.className = finalValue;\n              }\n            }\n          }\n        }\n\n        return this;\n      },\n      hide: function hide() {\n        return this.each(function () {\n          this[LEXICON.s].display = 'none';\n        });\n      },\n      show: function show() {\n        return this.each(function () {\n          this[LEXICON.s].display = 'block';\n        });\n      },\n      attr: function attr(attrName, value) {\n        var i = 0;\n        var el;\n\n        while (el = this[i++]) {\n          if (value === undefined) return el.getAttribute(attrName);\n          el.setAttribute(attrName, value);\n        }\n\n        return this;\n      },\n      removeAttr: function removeAttr(attrName) {\n        return this.each(function () {\n          this.removeAttribute(attrName);\n        });\n      },\n      offset: function offset() {\n        var el = this[0];\n        var rect = el[LEXICON.bCR]();\n        var scrollLeft = window.pageXOffset || document.documentElement[_strScrollLeft];\n        var scrollTop = window.pageYOffset || document.documentElement[_strScrollTop];\n        return {\n          top: rect.top + scrollTop,\n          left: rect.left + scrollLeft\n        };\n      },\n      position: function position() {\n        var el = this[0];\n        return {\n          top: el.offsetTop,\n          left: el.offsetLeft\n        };\n      },\n      scrollLeft: function scrollLeft(value) {\n        var i = 0;\n        var el;\n\n        while (el = this[i++]) {\n          if (value === undefined) return el[_strScrollLeft];\n          el[_strScrollLeft] = value;\n        }\n\n        return this;\n      },\n      scrollTop: function scrollTop(value) {\n        var i = 0;\n        var el;\n\n        while (el = this[i++]) {\n          if (value === undefined) return el[_strScrollTop];\n          el[_strScrollTop] = value;\n        }\n\n        return this;\n      },\n      val: function val(value) {\n        var el = this[0];\n        if (!value) return el.value;\n        el.value = value;\n        return this;\n      },\n      //DOM TRAVERSAL / FILTERING:\n      first: function first() {\n        return this.eq(0);\n      },\n      last: function last() {\n        return this.eq(-1);\n      },\n      eq: function eq(index) {\n        return FakejQuery(this[index >= 0 ? index : this[LEXICON.l] + index]);\n      },\n      find: function find(selector) {\n        var children = [];\n        var i;\n        this.each(function () {\n          var el = this;\n          var ch = el.querySelectorAll(selector);\n\n          for (i = 0; i < ch[LEXICON.l]; i++) {\n            children.push(ch[i]);\n          }\n        });\n        return FakejQuery(children);\n      },\n      children: function children(selector) {\n        var children = [];\n        var el;\n        var ch;\n        var i;\n        this.each(function () {\n          ch = this.children;\n\n          for (i = 0; i < ch[LEXICON.l]; i++) {\n            el = ch[i];\n\n            if (selector) {\n              if (el.matches && el.matches(selector) || matches(el, selector)) children.push(el);\n            } else children.push(el);\n          }\n        });\n        return FakejQuery(children);\n      },\n      parent: function parent(selector) {\n        var parents = [];\n        var parent;\n        this.each(function () {\n          parent = this.parentNode;\n          if (selector ? FakejQuery(parent).is(selector) : true) parents.push(parent);\n        });\n        return FakejQuery(parents);\n      },\n      is: function is(selector) {\n        var el;\n        var i;\n\n        for (i = 0; i < this[LEXICON.l]; i++) {\n          el = this[i];\n          if (selector === ':visible') return elementIsVisible(el);\n          if (selector === ':hidden') return !elementIsVisible(el);\n          if (el.matches && el.matches(selector) || matches(el, selector)) return true;\n        }\n\n        return false;\n      },\n      contents: function contents() {\n        var contents = [];\n        var childs;\n        var i;\n        this.each(function () {\n          childs = this.childNodes;\n\n          for (i = 0; i < childs[LEXICON.l]; i++) {\n            contents.push(childs[i]);\n          }\n        });\n        return FakejQuery(contents);\n      },\n      each: function each(callback) {\n        return _each(this, callback);\n      },\n      //ANIMATION:\n      animate: function animate(props, duration, easing, complete) {\n        return this.each(function () {\n          _animate(this, props, duration, easing, complete);\n        });\n      },\n      stop: function stop(clearQ, jump) {\n        return this.each(function () {\n          _stop(this, clearQ, jump);\n        });\n      }\n    };\n    extend(FakejQuery, {\n      extend: extend,\n      inArray: inArray,\n      isEmptyObject: isEmptyObject,\n      isPlainObject: isPlainObject,\n      each: _each\n    });\n    return FakejQuery;\n  }();\n\n  var INSTANCES = function () {\n    var _targets = [];\n    var _instancePropertyString = '__overlayScrollbars__';\n    /**\r\n     * Register, unregister or get a certain (or all) instances.\r\n     * Register: Pass the target and the instance.\r\n     * Unregister: Pass the target and null.\r\n     * Get Instance: Pass the target from which the instance shall be got.\r\n     * Get Targets: Pass no arguments.\r\n     * @param target The target to which the instance shall be registered / from which the instance shall be unregistered / the instance shall be got\r\n     * @param instance The instance.\r\n     * @returns {*|void} Returns the instance from the given target.\r\n     */\n\n    return function (target, instance) {\n      var argLen = arguments[LEXICON.l];\n\n      if (argLen < 1) {\n        //return all targets\n        return _targets;\n      } else {\n        if (instance) {\n          //register instance\n          target[_instancePropertyString] = instance;\n\n          _targets.push(target);\n        } else {\n          var index = COMPATIBILITY.inA(target, _targets);\n\n          if (index > -1) {\n            if (argLen > 1) {\n              //unregister instance\n              delete target[_instancePropertyString];\n\n              _targets.splice(index, 1);\n            } else {\n              //get instance from target\n              return _targets[index][_instancePropertyString];\n            }\n          }\n        }\n      }\n    };\n  }();\n\n  var PLUGIN = function () {\n    var _plugin;\n\n    var _pluginsGlobals;\n\n    var _pluginsAutoUpdateLoop;\n\n    var _pluginsExtensions = [];\n\n    var _pluginsOptions = function () {\n      var type = COMPATIBILITY.type;\n      var possibleTemplateTypes = [TYPES.b, //boolean\n      TYPES.n, //number\n      TYPES.s, //string\n      TYPES.a, //array\n      TYPES.o, //object\n      TYPES.f, //function\n      TYPES.z //null\n      ];\n      var restrictedStringsSplit = ' ';\n      var restrictedStringsPossibilitiesSplit = ':';\n      var classNameAllowedValues = [TYPES.z, TYPES.s];\n      var numberAllowedValues = TYPES.n;\n      var booleanNullAllowedValues = [TYPES.z, TYPES.b];\n      var booleanTrueTemplate = [true, TYPES.b];\n      var booleanFalseTemplate = [false, TYPES.b];\n      var callbackTemplate = [null, [TYPES.z, TYPES.f]];\n      var updateOnLoadTemplate = [['img'], [TYPES.s, TYPES.a, TYPES.z]];\n      var inheritedAttrsTemplate = [['style', 'class'], [TYPES.s, TYPES.a, TYPES.z]];\n      var resizeAllowedValues = 'n:none b:both h:horizontal v:vertical';\n      var overflowBehaviorAllowedValues = 'v-h:visible-hidden v-s:visible-scroll s:scroll h:hidden';\n      var scrollbarsVisibilityAllowedValues = 'v:visible h:hidden a:auto';\n      var scrollbarsAutoHideAllowedValues = 'n:never s:scroll l:leave m:move';\n      var optionsDefaultsAndTemplate = {\n        className: ['os-theme-dark', classNameAllowedValues],\n        //null || string\n        resize: ['none', resizeAllowedValues],\n        //none || both  || horizontal || vertical || n || b || h || v\n        sizeAutoCapable: booleanTrueTemplate,\n        //true || false\n        clipAlways: booleanTrueTemplate,\n        //true || false\n        normalizeRTL: booleanTrueTemplate,\n        //true || false\n        paddingAbsolute: booleanFalseTemplate,\n        //true || false\n        autoUpdate: [null, booleanNullAllowedValues],\n        //true || false || null\n        autoUpdateInterval: [33, numberAllowedValues],\n        //number\n        updateOnLoad: updateOnLoadTemplate,\n        //string || array || null\n        nativeScrollbarsOverlaid: {\n          showNativeScrollbars: booleanFalseTemplate,\n          //true || false\n          initialize: booleanTrueTemplate //true || false\n\n        },\n        overflowBehavior: {\n          x: ['scroll', overflowBehaviorAllowedValues],\n          //visible-hidden  || visible-scroll || hidden || scroll || v-h || v-s || h || s\n          y: ['scroll', overflowBehaviorAllowedValues] //visible-hidden  || visible-scroll || hidden || scroll || v-h || v-s || h || s\n\n        },\n        scrollbars: {\n          visibility: ['auto', scrollbarsVisibilityAllowedValues],\n          //visible || hidden || auto || v || h || a\n          autoHide: ['never', scrollbarsAutoHideAllowedValues],\n          //never || scroll || leave || move || n || s || l || m\n          autoHideDelay: [800, numberAllowedValues],\n          //number\n          dragScrolling: booleanTrueTemplate,\n          //true || false\n          clickScrolling: booleanFalseTemplate,\n          //true || false\n          touchSupport: booleanTrueTemplate,\n          //true || false\n          snapHandle: booleanFalseTemplate //true || false\n\n        },\n        textarea: {\n          dynWidth: booleanFalseTemplate,\n          //true || false\n          dynHeight: booleanFalseTemplate,\n          //true || false\n          inheritedAttrs: inheritedAttrsTemplate //string || array || null\n\n        },\n        callbacks: {\n          onInitialized: callbackTemplate,\n          //null || function\n          onInitializationWithdrawn: callbackTemplate,\n          //null || function\n          onDestroyed: callbackTemplate,\n          //null || function\n          onScrollStart: callbackTemplate,\n          //null || function\n          onScroll: callbackTemplate,\n          //null || function\n          onScrollStop: callbackTemplate,\n          //null || function\n          onOverflowChanged: callbackTemplate,\n          //null || function\n          onOverflowAmountChanged: callbackTemplate,\n          //null || function\n          onDirectionChanged: callbackTemplate,\n          //null || function\n          onContentSizeChanged: callbackTemplate,\n          //null || function\n          onHostSizeChanged: callbackTemplate,\n          //null || function\n          onUpdated: callbackTemplate //null || function\n\n        }\n      };\n\n      var convert = function convert(template) {\n        var recursive = function recursive(obj) {\n          var key;\n          var val;\n          var valType;\n\n          for (key in obj) {\n            if (!obj[LEXICON.hOP](key)) continue;\n            val = obj[key];\n            valType = type(val);\n            if (valType == TYPES.a) obj[key] = val[template ? 1 : 0];else if (valType == TYPES.o) obj[key] = recursive(val);\n          }\n\n          return obj;\n        };\n\n        return recursive(FRAMEWORK.extend(true, {}, optionsDefaultsAndTemplate));\n      };\n\n      return {\n        _defaults: convert(),\n        _template: convert(true),\n\n        /**\r\n         * Validates the passed object by the passed template.\r\n         * @param obj The object which shall be validated.\r\n         * @param template The template which defines the allowed values and types.\r\n         * @param writeErrors True if errors shall be logged to the console.\r\n         * @param diffObj If a object is passed then only valid differences to this object will be returned.\r\n         * @returns {{}} A object which contains two objects called \"default\" and \"prepared\" which contains only the valid properties of the passed original object and discards not different values compared to the passed diffObj.\r\n         */\n        _validate: function _validate(obj, template, writeErrors, diffObj) {\n          var validatedOptions = {};\n          var validatedOptionsPrepared = {};\n          var objectCopy = FRAMEWORK.extend(true, {}, obj);\n          var inArray = FRAMEWORK.inArray;\n          var isEmptyObj = FRAMEWORK.isEmptyObject;\n\n          var checkObjectProps = function checkObjectProps(data, template, diffData, validatedOptions, validatedOptionsPrepared, prevPropName) {\n            for (var prop in template) {\n              if (template[LEXICON.hOP](prop) && data[LEXICON.hOP](prop)) {\n                var isValid = false;\n                var isDiff = false;\n                var templateValue = template[prop];\n                var templateValueType = type(templateValue);\n                var templateIsComplex = templateValueType == TYPES.o;\n                var templateTypes = !COMPATIBILITY.isA(templateValue) ? [templateValue] : templateValue;\n                var dataDiffValue = diffData[prop];\n                var dataValue = data[prop];\n                var dataValueType = type(dataValue);\n                var propPrefix = prevPropName ? prevPropName + '.' : '';\n                var error = \"The option \\\"\" + propPrefix + prop + \"\\\" wasn't set, because\";\n                var errorPossibleTypes = [];\n                var errorRestrictedStrings = [];\n                var restrictedStringValuesSplit;\n                var restrictedStringValuesPossibilitiesSplit;\n                var isRestrictedValue;\n                var mainPossibility;\n                var currType;\n                var i;\n                var v;\n                var j;\n                dataDiffValue = dataDiffValue === undefined ? {} : dataDiffValue; //if the template has a object as value, it means that the options are complex (verschachtelt)\n\n                if (templateIsComplex && dataValueType == TYPES.o) {\n                  validatedOptions[prop] = {};\n                  validatedOptionsPrepared[prop] = {};\n                  checkObjectProps(dataValue, templateValue, dataDiffValue, validatedOptions[prop], validatedOptionsPrepared[prop], propPrefix + prop);\n                  FRAMEWORK.each([data, validatedOptions, validatedOptionsPrepared], function (index, value) {\n                    if (isEmptyObj(value[prop])) {\n                      delete value[prop];\n                    }\n                  });\n                } else if (!templateIsComplex) {\n                  for (i = 0; i < templateTypes[LEXICON.l]; i++) {\n                    currType = templateTypes[i];\n                    templateValueType = type(currType); //if currtype is string and starts with restrictedStringPrefix and end with restrictedStringSuffix\n\n                    isRestrictedValue = templateValueType == TYPES.s && inArray(currType, possibleTemplateTypes) === -1;\n\n                    if (isRestrictedValue) {\n                      errorPossibleTypes.push(TYPES.s); //split it into a array which contains all possible values for example: [\"y:yes\", \"n:no\", \"m:maybe\"]\n\n                      restrictedStringValuesSplit = currType.split(restrictedStringsSplit);\n                      errorRestrictedStrings = errorRestrictedStrings.concat(restrictedStringValuesSplit);\n\n                      for (v = 0; v < restrictedStringValuesSplit[LEXICON.l]; v++) {\n                        //split the possible values into their possibiliteis for example: [\"y\", \"yes\"] -> the first is always the mainPossibility\n                        restrictedStringValuesPossibilitiesSplit = restrictedStringValuesSplit[v].split(restrictedStringsPossibilitiesSplit);\n                        mainPossibility = restrictedStringValuesPossibilitiesSplit[0];\n\n                        for (j = 0; j < restrictedStringValuesPossibilitiesSplit[LEXICON.l]; j++) {\n                          //if any possibility matches with the dataValue, its valid\n                          if (dataValue === restrictedStringValuesPossibilitiesSplit[j]) {\n                            isValid = true;\n                            break;\n                          }\n                        }\n\n                        if (isValid) break;\n                      }\n                    } else {\n                      errorPossibleTypes.push(currType);\n\n                      if (dataValueType === currType) {\n                        isValid = true;\n                        break;\n                      }\n                    }\n                  }\n\n                  if (isValid) {\n                    isDiff = dataValue !== dataDiffValue;\n                    if (isDiff) validatedOptions[prop] = dataValue;\n                    if (isRestrictedValue ? inArray(dataDiffValue, restrictedStringValuesPossibilitiesSplit) < 0 : isDiff) validatedOptionsPrepared[prop] = isRestrictedValue ? mainPossibility : dataValue;\n                  } else if (writeErrors) {\n                    console.warn(error + \" it doesn't accept the type [ \" + dataValueType.toUpperCase() + \" ] with the value of \\\"\" + dataValue + \"\\\".\\r\\n\" + \"Accepted types are: [ \" + errorPossibleTypes.join(', ').toUpperCase() + \" ].\" + (errorRestrictedStrings[length] > 0 ? \"\\r\\nValid strings are: [ \" + errorRestrictedStrings.join(', ').split(restrictedStringsPossibilitiesSplit).join(', ') + \" ].\" : ''));\n                  }\n\n                  delete data[prop];\n                }\n              }\n            }\n          };\n\n          checkObjectProps(objectCopy, template, diffObj || {}, validatedOptions, validatedOptionsPrepared); //add values which aren't specified in the template to the finished validated object to prevent them from being discarded\n\n          /*\r\n          if(keepForeignProps) {\r\n              FRAMEWORK.extend(true, validatedOptions, objectCopy);\r\n              FRAMEWORK.extend(true, validatedOptionsPrepared, objectCopy);\r\n          }\r\n          */\n\n          if (!isEmptyObj(objectCopy) && writeErrors) console.warn('The following options are discarded due to invalidity:\\r\\n' + window.JSON.stringify(objectCopy, null, 2));\n          return {\n            _default: validatedOptions,\n            _prepared: validatedOptionsPrepared\n          };\n        }\n      };\n    }();\n    /**\r\n     * Initializes the object which contains global information about the plugin and each instance of it.\r\n     */\n\n\n    function initOverlayScrollbarsStatics() {\n      if (!_pluginsGlobals) _pluginsGlobals = new OverlayScrollbarsGlobals(_pluginsOptions._defaults);\n      if (!_pluginsAutoUpdateLoop) _pluginsAutoUpdateLoop = new OverlayScrollbarsAutoUpdateLoop(_pluginsGlobals);\n    }\n    /**\r\n     * The global object for the OverlayScrollbars objects. It contains resources which every OverlayScrollbars object needs. This object is initialized only once: if the first OverlayScrollbars object gets initialized.\r\n     * @param defaultOptions\r\n     * @constructor\r\n     */\n\n\n    function OverlayScrollbarsGlobals(defaultOptions) {\n      var _base = this;\n\n      var strOverflow = 'overflow';\n      var strHidden = 'hidden';\n      var strScroll = 'scroll';\n      var bodyElement = FRAMEWORK('body');\n      var scrollbarDummyElement = FRAMEWORK('<div id=\"os-dummy-scrollbar-size\"><div></div></div>');\n      var scrollbarDummyElement0 = scrollbarDummyElement[0];\n      var dummyContainerChild = FRAMEWORK(scrollbarDummyElement.children('div').eq(0));\n      bodyElement.append(scrollbarDummyElement);\n      scrollbarDummyElement.hide().show(); //fix IE8 bug (incorrect measuring)\n\n      var nativeScrollbarSize = calcNativeScrollbarSize(scrollbarDummyElement0);\n      var nativeScrollbarIsOverlaid = {\n        x: nativeScrollbarSize.x === 0,\n        y: nativeScrollbarSize.y === 0\n      };\n\n      var msie = function () {\n        var ua = window.navigator.userAgent;\n        var strIndexOf = 'indexOf';\n        var strSubString = 'substring';\n        var msie = ua[strIndexOf]('MSIE ');\n        var trident = ua[strIndexOf]('Trident/');\n        var edge = ua[strIndexOf]('Edge/');\n        var rv = ua[strIndexOf]('rv:');\n        var result;\n        var parseIntFunc = parseInt; // IE 10 or older => return version number\n\n        if (msie > 0) result = parseIntFunc(ua[strSubString](msie + 5, ua[strIndexOf]('.', msie)), 10); // IE 11 => return version number\n        else if (trident > 0) result = parseIntFunc(ua[strSubString](rv + 3, ua[strIndexOf]('.', rv)), 10); // Edge (IE 12+) => return version number\n        else if (edge > 0) result = parseIntFunc(ua[strSubString](edge + 5, ua[strIndexOf]('.', edge)), 10); // other browser\n\n        return result;\n      }();\n\n      FRAMEWORK.extend(_base, {\n        defaultOptions: defaultOptions,\n        msie: msie,\n        autoUpdateLoop: false,\n        autoUpdateRecommended: !COMPATIBILITY.mO(),\n        nativeScrollbarSize: nativeScrollbarSize,\n        nativeScrollbarIsOverlaid: nativeScrollbarIsOverlaid,\n        nativeScrollbarStyling: function () {\n          var result = false;\n          scrollbarDummyElement.addClass('os-viewport-native-scrollbars-invisible');\n\n          try {\n            result = scrollbarDummyElement.css('scrollbar-width') === 'none' && (msie > 9 || !msie) || window.getComputedStyle(scrollbarDummyElement0, '::-webkit-scrollbar').getPropertyValue('display') === 'none';\n          } catch (ex) {} //fix opera bug: scrollbar styles will only appear if overflow value is scroll or auto during the activation of the style.\n          //and set overflow to scroll\n          //scrollbarDummyElement.css(strOverflow, strHidden).hide().css(strOverflow, strScroll).show();\n          //return (scrollbarDummyElement0[LEXICON.oH] - scrollbarDummyElement0[LEXICON.cH]) === 0 && (scrollbarDummyElement0[LEXICON.oW] - scrollbarDummyElement0[LEXICON.cW]) === 0;\n\n\n          return result;\n        }(),\n        overlayScrollbarDummySize: {\n          x: 30,\n          y: 30\n        },\n        cssCalc: VENDORS._cssPropertyValue('width', 'calc', '(1px)') || null,\n        restrictedMeasuring: function () {\n          //https://bugzilla.mozilla.org/show_bug.cgi?id=1439305\n          //since 1.11.0 always false -> fixed via CSS (hopefully)\n          scrollbarDummyElement.css(strOverflow, strHidden);\n          var scrollSize = {\n            w: scrollbarDummyElement0[LEXICON.sW],\n            h: scrollbarDummyElement0[LEXICON.sH]\n          };\n          scrollbarDummyElement.css(strOverflow, 'visible');\n          var scrollSize2 = {\n            w: scrollbarDummyElement0[LEXICON.sW],\n            h: scrollbarDummyElement0[LEXICON.sH]\n          };\n          return scrollSize.w - scrollSize2.w !== 0 || scrollSize.h - scrollSize2.h !== 0;\n        }(),\n        rtlScrollBehavior: function () {\n          scrollbarDummyElement.css({\n            'overflow-y': strHidden,\n            'overflow-x': strScroll,\n            'direction': 'rtl'\n          }).scrollLeft(0);\n          var dummyContainerOffset = scrollbarDummyElement.offset();\n          var dummyContainerChildOffset = dummyContainerChild.offset(); //https://github.com/KingSora/OverlayScrollbars/issues/187\n\n          scrollbarDummyElement.scrollLeft(-999);\n          var dummyContainerChildOffsetAfterScroll = dummyContainerChild.offset();\n          return {\n            //origin direction = determines if the zero scroll position is on the left or right side\n            //'i' means 'invert' (i === true means that the axis must be inverted to be correct)\n            //true = on the left side\n            //false = on the right side\n            i: dummyContainerOffset.left === dummyContainerChildOffset.left,\n            //negative = determines if the maximum scroll is positive or negative\n            //'n' means 'negate' (n === true means that the axis must be negated to be correct)\n            //true = negative\n            //false = positive\n            n: dummyContainerChildOffset.left !== dummyContainerChildOffsetAfterScroll.left\n          };\n        }(),\n        supportTransform: !!VENDORS._cssProperty('transform'),\n        supportTransition: !!VENDORS._cssProperty('transition'),\n        supportPassiveEvents: function () {\n          var supportsPassive = false;\n\n          try {\n            window.addEventListener('test', null, Object.defineProperty({}, 'passive', {\n              get: function get() {\n                supportsPassive = true;\n              }\n            }));\n          } catch (e) {}\n\n          return supportsPassive;\n        }(),\n        supportResizeObserver: !!COMPATIBILITY.rO(),\n        supportMutationObserver: !!COMPATIBILITY.mO()\n      });\n      scrollbarDummyElement.removeAttr(LEXICON.s).remove(); //Catch zoom event:\n\n      (function () {\n        if (nativeScrollbarIsOverlaid.x && nativeScrollbarIsOverlaid.y) return;\n        var abs = MATH.abs;\n        var windowWidth = COMPATIBILITY.wW();\n        var windowHeight = COMPATIBILITY.wH();\n        var windowDpr = getWindowDPR();\n\n        var onResize = function onResize() {\n          if (INSTANCES().length > 0) {\n            var newW = COMPATIBILITY.wW();\n            var newH = COMPATIBILITY.wH();\n            var deltaW = newW - windowWidth;\n            var deltaH = newH - windowHeight;\n            if (deltaW === 0 && deltaH === 0) return;\n            var deltaWRatio = MATH.round(newW / (windowWidth / 100.0));\n            var deltaHRatio = MATH.round(newH / (windowHeight / 100.0));\n            var absDeltaW = abs(deltaW);\n            var absDeltaH = abs(deltaH);\n            var absDeltaWRatio = abs(deltaWRatio);\n            var absDeltaHRatio = abs(deltaHRatio);\n            var newDPR = getWindowDPR();\n            var deltaIsBigger = absDeltaW > 2 && absDeltaH > 2;\n            var difference = !differenceIsBiggerThanOne(absDeltaWRatio, absDeltaHRatio);\n            var dprChanged = newDPR !== windowDpr && windowDpr > 0;\n            var isZoom = deltaIsBigger && difference && dprChanged;\n            var oldScrollbarSize = _base.nativeScrollbarSize;\n            var newScrollbarSize;\n\n            if (isZoom) {\n              bodyElement.append(scrollbarDummyElement);\n              newScrollbarSize = _base.nativeScrollbarSize = calcNativeScrollbarSize(scrollbarDummyElement[0]);\n              scrollbarDummyElement.remove();\n\n              if (oldScrollbarSize.x !== newScrollbarSize.x || oldScrollbarSize.y !== newScrollbarSize.y) {\n                FRAMEWORK.each(INSTANCES(), function () {\n                  if (INSTANCES(this)) INSTANCES(this).update('zoom');\n                });\n              }\n            }\n\n            windowWidth = newW;\n            windowHeight = newH;\n            windowDpr = newDPR;\n          }\n        };\n\n        function differenceIsBiggerThanOne(valOne, valTwo) {\n          var absValOne = abs(valOne);\n          var absValTwo = abs(valTwo);\n          return !(absValOne === absValTwo || absValOne + 1 === absValTwo || absValOne - 1 === absValTwo);\n        }\n\n        function getWindowDPR() {\n          var dDPI = window.screen.deviceXDPI || 0;\n          var sDPI = window.screen.logicalXDPI || 1;\n          return window.devicePixelRatio || dDPI / sDPI;\n        }\n\n        FRAMEWORK(window).on('resize', onResize);\n      })();\n\n      function calcNativeScrollbarSize(measureElement) {\n        return {\n          x: measureElement[LEXICON.oH] - measureElement[LEXICON.cH],\n          y: measureElement[LEXICON.oW] - measureElement[LEXICON.cW]\n        };\n      }\n    }\n    /**\r\n     * The object which manages the auto update loop for all OverlayScrollbars objects. This object is initialized only once: if the first OverlayScrollbars object gets initialized.\r\n     * @constructor\r\n     */\n\n\n    function OverlayScrollbarsAutoUpdateLoop(globals) {\n      var _base = this;\n\n      var _inArray = FRAMEWORK.inArray;\n      var _getNow = COMPATIBILITY.now;\n      var _strAutoUpdate = 'autoUpdate';\n\n      var _strAutoUpdateInterval = _strAutoUpdate + 'Interval';\n\n      var _strLength = LEXICON.l;\n      var _loopingInstances = [];\n      var _loopingInstancesIntervalCache = [];\n      var _loopIsActive = false;\n      var _loopIntervalDefault = 33;\n      var _loopInterval = _loopIntervalDefault;\n\n      var _loopTimeOld = _getNow();\n\n      var _loopID;\n      /**\r\n       * The auto update loop which will run every 50 milliseconds or less if the update interval of a instance is lower than 50 milliseconds.\r\n       */\n\n\n      var loop = function loop() {\n        if (_loopingInstances[_strLength] > 0 && _loopIsActive) {\n          _loopID = COMPATIBILITY.rAF()(function () {\n            loop();\n          });\n\n          var timeNew = _getNow();\n\n          var timeDelta = timeNew - _loopTimeOld;\n          var lowestInterval;\n          var instance;\n          var instanceOptions;\n          var instanceAutoUpdateAllowed;\n          var instanceAutoUpdateInterval;\n          var now;\n\n          if (timeDelta > _loopInterval) {\n            _loopTimeOld = timeNew - timeDelta % _loopInterval;\n            lowestInterval = _loopIntervalDefault;\n\n            for (var i = 0; i < _loopingInstances[_strLength]; i++) {\n              instance = _loopingInstances[i];\n\n              if (instance !== undefined) {\n                instanceOptions = instance.options();\n                instanceAutoUpdateAllowed = instanceOptions[_strAutoUpdate];\n                instanceAutoUpdateInterval = MATH.max(1, instanceOptions[_strAutoUpdateInterval]);\n                now = _getNow();\n\n                if ((instanceAutoUpdateAllowed === true || instanceAutoUpdateAllowed === null) && now - _loopingInstancesIntervalCache[i] > instanceAutoUpdateInterval) {\n                  instance.update('auto');\n                  _loopingInstancesIntervalCache[i] = new Date(now += instanceAutoUpdateInterval);\n                }\n\n                lowestInterval = MATH.max(1, MATH.min(lowestInterval, instanceAutoUpdateInterval));\n              }\n            }\n\n            _loopInterval = lowestInterval;\n          }\n        } else {\n          _loopInterval = _loopIntervalDefault;\n        }\n      };\n      /**\r\n       * Add OverlayScrollbars instance to the auto update loop. Only successful if the instance isn't already added.\r\n       * @param instance The instance which shall be updated in a loop automatically.\r\n       */\n\n\n      _base.add = function (instance) {\n        if (_inArray(instance, _loopingInstances) === -1) {\n          _loopingInstances.push(instance);\n\n          _loopingInstancesIntervalCache.push(_getNow());\n\n          if (_loopingInstances[_strLength] > 0 && !_loopIsActive) {\n            _loopIsActive = true;\n            globals.autoUpdateLoop = _loopIsActive;\n            loop();\n          }\n        }\n      };\n      /**\r\n       * Remove OverlayScrollbars instance from the auto update loop. Only successful if the instance was added before.\r\n       * @param instance The instance which shall be updated in a loop automatically.\r\n       */\n\n\n      _base.remove = function (instance) {\n        var index = _inArray(instance, _loopingInstances);\n\n        if (index > -1) {\n          //remove from loopingInstances list\n          _loopingInstancesIntervalCache.splice(index, 1);\n\n          _loopingInstances.splice(index, 1); //correct update loop behavior\n\n\n          if (_loopingInstances[_strLength] === 0 && _loopIsActive) {\n            _loopIsActive = false;\n            globals.autoUpdateLoop = _loopIsActive;\n\n            if (_loopID !== undefined) {\n              COMPATIBILITY.cAF()(_loopID);\n              _loopID = -1;\n            }\n          }\n        }\n      };\n    }\n    /**\r\n     * A object which manages the scrollbars visibility of the target element.\r\n     * @param pluginTargetElement The element from which the scrollbars shall be hidden.\r\n     * @param options The custom options.\r\n     * @param extensions The custom extensions.\r\n     * @param globals\r\n     * @param autoUpdateLoop\r\n     * @returns {*}\r\n     * @constructor\r\n     */\n\n\n    function OverlayScrollbarsInstance(pluginTargetElement, options, extensions, globals, autoUpdateLoop) {\n      //shortcuts\n      var type = COMPATIBILITY.type;\n      var inArray = FRAMEWORK.inArray;\n      var each = FRAMEWORK.each; //make correct instanceof\n\n      var _base = new _plugin();\n\n      var _frameworkProto = FRAMEWORK[LEXICON.p]; //if passed element is no HTML element: skip and return\n\n      if (!isHTMLElement(pluginTargetElement)) return; //if passed element is already initialized: set passed options if there are any and return its instance\n\n      if (INSTANCES(pluginTargetElement)) {\n        var inst = INSTANCES(pluginTargetElement);\n        inst.options(options);\n        return inst;\n      } //globals:\n\n\n      var _nativeScrollbarIsOverlaid;\n\n      var _overlayScrollbarDummySize;\n\n      var _rtlScrollBehavior;\n\n      var _autoUpdateRecommended;\n\n      var _msieVersion;\n\n      var _nativeScrollbarStyling;\n\n      var _cssCalc;\n\n      var _nativeScrollbarSize;\n\n      var _supportTransition;\n\n      var _supportTransform;\n\n      var _supportPassiveEvents;\n\n      var _supportResizeObserver;\n\n      var _supportMutationObserver;\n\n      var _restrictedMeasuring; //general readonly:\n\n\n      var _initialized;\n\n      var _destroyed;\n\n      var _isTextarea;\n\n      var _isBody;\n\n      var _documentMixed;\n\n      var _domExists; //general:\n\n\n      var _isBorderBox;\n\n      var _sizeAutoObserverAdded;\n\n      var _paddingX;\n\n      var _paddingY;\n\n      var _borderX;\n\n      var _borderY;\n\n      var _marginX;\n\n      var _marginY;\n\n      var _isRTL;\n\n      var _sleeping;\n\n      var _contentBorderSize = {};\n      var _scrollHorizontalInfo = {};\n      var _scrollVerticalInfo = {};\n      var _viewportSize = {};\n      var _nativeScrollbarMinSize = {}; //naming:\t\n\n      var _strMinusHidden = '-hidden';\n      var _strMarginMinus = 'margin-';\n      var _strPaddingMinus = 'padding-';\n      var _strBorderMinus = 'border-';\n      var _strTop = 'top';\n      var _strRight = 'right';\n      var _strBottom = 'bottom';\n      var _strLeft = 'left';\n      var _strMinMinus = 'min-';\n      var _strMaxMinus = 'max-';\n      var _strWidth = 'width';\n      var _strHeight = 'height';\n      var _strFloat = 'float';\n      var _strEmpty = '';\n      var _strAuto = 'auto';\n      var _strSync = 'sync';\n      var _strScroll = 'scroll';\n      var _strHundredPercent = '100%';\n      var _strX = 'x';\n      var _strY = 'y';\n      var _strDot = '.';\n      var _strSpace = ' ';\n      var _strScrollbar = 'scrollbar';\n      var _strMinusHorizontal = '-horizontal';\n      var _strMinusVertical = '-vertical';\n\n      var _strScrollLeft = _strScroll + 'Left';\n\n      var _strScrollTop = _strScroll + 'Top';\n\n      var _strMouseTouchDownEvent = 'mousedown touchstart';\n      var _strMouseTouchUpEvent = 'mouseup touchend touchcancel';\n      var _strMouseTouchMoveEvent = 'mousemove touchmove';\n      var _strMouseEnter = 'mouseenter';\n      var _strMouseLeave = 'mouseleave';\n      var _strKeyDownEvent = 'keydown';\n      var _strKeyUpEvent = 'keyup';\n      var _strSelectStartEvent = 'selectstart';\n      var _strTransitionEndEvent = 'transitionend webkitTransitionEnd oTransitionEnd';\n      var _strResizeObserverProperty = '__overlayScrollbarsRO__'; //class names:\t\n\n      var _cassNamesPrefix = 'os-';\n\n      var _classNameHTMLElement = _cassNamesPrefix + 'html';\n\n      var _classNameHostElement = _cassNamesPrefix + 'host';\n\n      var _classNameHostElementForeign = _classNameHostElement + '-foreign';\n\n      var _classNameHostTextareaElement = _classNameHostElement + '-textarea';\n\n      var _classNameHostScrollbarHorizontalHidden = _classNameHostElement + '-' + _strScrollbar + _strMinusHorizontal + _strMinusHidden;\n\n      var _classNameHostScrollbarVerticalHidden = _classNameHostElement + '-' + _strScrollbar + _strMinusVertical + _strMinusHidden;\n\n      var _classNameHostTransition = _classNameHostElement + '-transition';\n\n      var _classNameHostRTL = _classNameHostElement + '-rtl';\n\n      var _classNameHostResizeDisabled = _classNameHostElement + '-resize-disabled';\n\n      var _classNameHostScrolling = _classNameHostElement + '-scrolling';\n\n      var _classNameHostOverflow = _classNameHostElement + '-overflow';\n\n      var _classNameHostOverflow = _classNameHostElement + '-overflow';\n\n      var _classNameHostOverflowX = _classNameHostOverflow + '-x';\n\n      var _classNameHostOverflowY = _classNameHostOverflow + '-y';\n\n      var _classNameTextareaElement = _cassNamesPrefix + 'textarea';\n\n      var _classNameTextareaCoverElement = _classNameTextareaElement + '-cover';\n\n      var _classNamePaddingElement = _cassNamesPrefix + 'padding';\n\n      var _classNameViewportElement = _cassNamesPrefix + 'viewport';\n\n      var _classNameViewportNativeScrollbarsInvisible = _classNameViewportElement + '-native-scrollbars-invisible';\n\n      var _classNameViewportNativeScrollbarsOverlaid = _classNameViewportElement + '-native-scrollbars-overlaid';\n\n      var _classNameContentElement = _cassNamesPrefix + 'content';\n\n      var _classNameContentArrangeElement = _cassNamesPrefix + 'content-arrange';\n\n      var _classNameContentGlueElement = _cassNamesPrefix + 'content-glue';\n\n      var _classNameSizeAutoObserverElement = _cassNamesPrefix + 'size-auto-observer';\n\n      var _classNameResizeObserverElement = _cassNamesPrefix + 'resize-observer';\n\n      var _classNameResizeObserverItemElement = _cassNamesPrefix + 'resize-observer-item';\n\n      var _classNameResizeObserverItemFinalElement = _classNameResizeObserverItemElement + '-final';\n\n      var _classNameTextInherit = _cassNamesPrefix + 'text-inherit';\n\n      var _classNameScrollbar = _cassNamesPrefix + _strScrollbar;\n\n      var _classNameScrollbarTrack = _classNameScrollbar + '-track';\n\n      var _classNameScrollbarTrackOff = _classNameScrollbarTrack + '-off';\n\n      var _classNameScrollbarHandle = _classNameScrollbar + '-handle';\n\n      var _classNameScrollbarHandleOff = _classNameScrollbarHandle + '-off';\n\n      var _classNameScrollbarUnusable = _classNameScrollbar + '-unusable';\n\n      var _classNameScrollbarAutoHidden = _classNameScrollbar + '-' + _strAuto + _strMinusHidden;\n\n      var _classNameScrollbarCorner = _classNameScrollbar + '-corner';\n\n      var _classNameScrollbarCornerResize = _classNameScrollbarCorner + '-resize';\n\n      var _classNameScrollbarCornerResizeB = _classNameScrollbarCornerResize + '-both';\n\n      var _classNameScrollbarCornerResizeH = _classNameScrollbarCornerResize + _strMinusHorizontal;\n\n      var _classNameScrollbarCornerResizeV = _classNameScrollbarCornerResize + _strMinusVertical;\n\n      var _classNameScrollbarHorizontal = _classNameScrollbar + _strMinusHorizontal;\n\n      var _classNameScrollbarVertical = _classNameScrollbar + _strMinusVertical;\n\n      var _classNameDragging = _cassNamesPrefix + 'dragging';\n\n      var _classNameThemeNone = _cassNamesPrefix + 'theme-none';\n\n      var _classNamesDynamicDestroy = [_classNameViewportNativeScrollbarsInvisible, _classNameViewportNativeScrollbarsOverlaid, _classNameScrollbarTrackOff, _classNameScrollbarHandleOff, _classNameScrollbarUnusable, _classNameScrollbarAutoHidden, _classNameScrollbarCornerResize, _classNameScrollbarCornerResizeB, _classNameScrollbarCornerResizeH, _classNameScrollbarCornerResizeV, _classNameDragging].join(_strSpace); //callbacks:\t\n\n\n      var _callbacksInitQeueue = []; //attrs viewport shall inherit from target\t\n\n      var _viewportAttrsFromTarget = [LEXICON.ti]; //options:\t\n\n      var _defaultOptions;\n\n      var _currentOptions;\n\n      var _currentPreparedOptions; //extensions:\t\n\n\n      var _extensions = {};\n      var _extensionsPrivateMethods = 'added removed on contract'; //update\t\n\n      var _lastUpdateTime;\n\n      var _swallowedUpdateHints = {};\n\n      var _swallowedUpdateTimeout;\n\n      var _swallowUpdateLag = 42;\n      var _updateOnLoadEventName = 'load';\n      var _updateOnLoadElms = []; //DOM elements:\t\n\n      var _windowElement;\n\n      var _documentElement;\n\n      var _htmlElement;\n\n      var _bodyElement;\n\n      var _targetElement; //the target element of this OverlayScrollbars object\t\n\n\n      var _hostElement; //the host element of this OverlayScrollbars object -> may be the same as targetElement\t\n\n\n      var _sizeAutoObserverElement; //observes size auto changes\t\n\n\n      var _sizeObserverElement; //observes size and padding changes\t\n\n\n      var _paddingElement; //manages the padding\t\n\n\n      var _viewportElement; //is the viewport of our scrollbar model\t\n\n\n      var _contentElement; //the element which holds the content\t\n\n\n      var _contentArrangeElement; //is needed for correct sizing of the content element (only if native scrollbars are overlays)\t\n\n\n      var _contentGlueElement; //has always the size of the content element\t\n\n\n      var _textareaCoverElement; //only applied if target is a textarea element. Used for correct size calculation and for prevention of uncontrolled scrolling\t\n\n\n      var _scrollbarCornerElement;\n\n      var _scrollbarHorizontalElement;\n\n      var _scrollbarHorizontalTrackElement;\n\n      var _scrollbarHorizontalHandleElement;\n\n      var _scrollbarVerticalElement;\n\n      var _scrollbarVerticalTrackElement;\n\n      var _scrollbarVerticalHandleElement;\n\n      var _windowElementNative;\n\n      var _documentElementNative;\n\n      var _targetElementNative;\n\n      var _hostElementNative;\n\n      var _sizeAutoObserverElementNative;\n\n      var _sizeObserverElementNative;\n\n      var _paddingElementNative;\n\n      var _viewportElementNative;\n\n      var _contentElementNative; //Cache:\t\n\n\n      var _hostSizeCache;\n\n      var _contentScrollSizeCache;\n\n      var _arrangeContentSizeCache;\n\n      var _hasOverflowCache;\n\n      var _hideOverflowCache;\n\n      var _widthAutoCache;\n\n      var _heightAutoCache;\n\n      var _cssBoxSizingCache;\n\n      var _cssPaddingCache;\n\n      var _cssBorderCache;\n\n      var _cssMarginCache;\n\n      var _cssDirectionCache;\n\n      var _cssDirectionDetectedCache;\n\n      var _paddingAbsoluteCache;\n\n      var _clipAlwaysCache;\n\n      var _contentGlueSizeCache;\n\n      var _overflowBehaviorCache;\n\n      var _overflowAmountCache;\n\n      var _ignoreOverlayScrollbarHidingCache;\n\n      var _autoUpdateCache;\n\n      var _sizeAutoCapableCache;\n\n      var _contentElementScrollSizeChangeDetectedCache;\n\n      var _hostElementSizeChangeDetectedCache;\n\n      var _scrollbarsVisibilityCache;\n\n      var _scrollbarsAutoHideCache;\n\n      var _scrollbarsClickScrollingCache;\n\n      var _scrollbarsDragScrollingCache;\n\n      var _resizeCache;\n\n      var _normalizeRTLCache;\n\n      var _classNameCache;\n\n      var _oldClassName;\n\n      var _textareaAutoWrappingCache;\n\n      var _textareaInfoCache;\n\n      var _textareaSizeCache;\n\n      var _textareaDynHeightCache;\n\n      var _textareaDynWidthCache;\n\n      var _bodyMinSizeCache;\n\n      var _updateAutoCache = {}; //MutationObserver:\t\n\n      var _mutationObserverHost;\n\n      var _mutationObserverContent;\n\n      var _mutationObserverHostCallback;\n\n      var _mutationObserverContentCallback;\n\n      var _mutationObserversConnected;\n\n      var _mutationObserverAttrsTextarea = ['wrap', 'cols', 'rows'];\n\n      var _mutationObserverAttrsHost = [LEXICON.i, LEXICON.c, LEXICON.s, 'open'].concat(_viewportAttrsFromTarget); //events:\t\n\n\n      var _destroyEvents = []; //textarea:\t\n\n      var _textareaHasFocus; //scrollbars:\t\n\n\n      var _scrollbarsAutoHideTimeoutId;\n\n      var _scrollbarsAutoHideMoveTimeoutId;\n\n      var _scrollbarsAutoHideDelay;\n\n      var _scrollbarsAutoHideNever;\n\n      var _scrollbarsAutoHideScroll;\n\n      var _scrollbarsAutoHideMove;\n\n      var _scrollbarsAutoHideLeave;\n\n      var _scrollbarsHandleHovered;\n\n      var _scrollbarsHandlesDefineScrollPos; //resize\t\n\n\n      var _resizeNone;\n\n      var _resizeBoth;\n\n      var _resizeHorizontal;\n\n      var _resizeVertical; //==== Event Listener ====//\t\n\n      /**\t\r\n       * Adds or removes a event listener from the given element. \t\r\n       * @param element The element to which the event listener shall be applied or removed.\t\r\n       * @param eventNames The name(s) of the events.\t\r\n       * @param listener The method which shall be called.\t\r\n       * @param remove True if the handler shall be removed, false or undefined if the handler shall be added.\t\r\n       * @param passiveOrOptions The options for the event.\r\n       */\n\n\n      function setupResponsiveEventListener(element, eventNames, listener, remove, passiveOrOptions) {\n        var collected = COMPATIBILITY.isA(eventNames) && COMPATIBILITY.isA(listener);\n        var method = remove ? 'removeEventListener' : 'addEventListener';\n        var onOff = remove ? 'off' : 'on';\n        var events = collected ? false : eventNames.split(_strSpace);\n        var i = 0;\n        var passiveOrOptionsIsObj = FRAMEWORK.isPlainObject(passiveOrOptions);\n        var passive = _supportPassiveEvents && (passiveOrOptionsIsObj ? passiveOrOptions._passive : passiveOrOptions) || false;\n        var capture = passiveOrOptionsIsObj && (passiveOrOptions._capture || false);\n        var nativeParam = _supportPassiveEvents ? {\n          passive: passive,\n          capture: capture\n        } : capture;\n\n        if (collected) {\n          for (; i < eventNames[LEXICON.l]; i++) {\n            setupResponsiveEventListener(element, eventNames[i], listener[i], remove, passiveOrOptions);\n          }\n        } else {\n          for (; i < events[LEXICON.l]; i++) {\n            if (_supportPassiveEvents) {\n              element[0][method](events[i], listener, nativeParam);\n            } else {\n              element[onOff](events[i], listener);\n            }\n          }\n        }\n      }\n\n      function addDestroyEventListener(element, eventNames, listener, passive) {\n        setupResponsiveEventListener(element, eventNames, listener, false, passive);\n\n        _destroyEvents.push(COMPATIBILITY.bind(setupResponsiveEventListener, 0, element, eventNames, listener, true, passive));\n      } //==== Resize Observer ====//\n\n      /**\r\n       * Adds or removes a resize observer from the given element.\r\n       * @param targetElement The element to which the resize observer shall be added or removed.\r\n       * @param onElementResizedCallback The callback which is fired every time the resize observer registers a size change or false / undefined if the resizeObserver shall be removed.\r\n       */\n\n\n      function setupResizeObserver(targetElement, onElementResizedCallback) {\n        if (targetElement) {\n          var resizeObserver = COMPATIBILITY.rO();\n          var strAnimationStartEvent = 'animationstart mozAnimationStart webkitAnimationStart MSAnimationStart';\n          var strChildNodes = 'childNodes';\n          var constScroll = 3333333;\n\n          var callback = function callback() {\n            targetElement[_strScrollTop](constScroll)[_strScrollLeft](_isRTL ? _rtlScrollBehavior.n ? -constScroll : _rtlScrollBehavior.i ? 0 : constScroll : constScroll);\n\n            onElementResizedCallback();\n          }; //add resize observer:\n\n\n          if (onElementResizedCallback) {\n            if (_supportResizeObserver) {\n              var element = targetElement.addClass('observed').append(generateDiv(_classNameResizeObserverElement)).contents()[0];\n              var observer = element[_strResizeObserverProperty] = new resizeObserver(callback);\n              observer.observe(element);\n            } else {\n              if (_msieVersion > 9 || !_autoUpdateRecommended) {\n                targetElement.prepend(generateDiv(_classNameResizeObserverElement, generateDiv({\n                  c: _classNameResizeObserverItemElement,\n                  dir: 'ltr'\n                }, generateDiv(_classNameResizeObserverItemElement, generateDiv(_classNameResizeObserverItemFinalElement)) + generateDiv(_classNameResizeObserverItemElement, generateDiv({\n                  c: _classNameResizeObserverItemFinalElement,\n                  style: 'width: 200%; height: 200%'\n                })))));\n                var observerElement = targetElement[0][strChildNodes][0][strChildNodes][0];\n                var shrinkElement = FRAMEWORK(observerElement[strChildNodes][1]);\n                var expandElement = FRAMEWORK(observerElement[strChildNodes][0]);\n                var expandElementChild = FRAMEWORK(expandElement[0][strChildNodes][0]);\n                var widthCache = observerElement[LEXICON.oW];\n                var heightCache = observerElement[LEXICON.oH];\n                var isDirty;\n                var rAFId;\n                var currWidth;\n                var currHeight;\n                var factor = 2;\n                var nativeScrollbarSize = globals.nativeScrollbarSize; //care don't make changes to this object!!!\n\n                var reset = function reset() {\n                  /*\r\n                   var sizeResetWidth = observerElement[LEXICON.oW] + nativeScrollbarSize.x * factor + nativeScrollbarSize.y * factor + _overlayScrollbarDummySize.x + _overlayScrollbarDummySize.y;\r\n                   var sizeResetHeight = observerElement[LEXICON.oH] + nativeScrollbarSize.x * factor + nativeScrollbarSize.y * factor + _overlayScrollbarDummySize.x + _overlayScrollbarDummySize.y;\r\n                   var expandChildCSS = {};\r\n                   expandChildCSS[_strWidth] = sizeResetWidth;\r\n                   expandChildCSS[_strHeight] = sizeResetHeight;\r\n                   expandElementChild.css(expandChildCSS);\r\n                       expandElement[_strScrollLeft](sizeResetWidth)[_strScrollTop](sizeResetHeight);\r\n                   shrinkElement[_strScrollLeft](sizeResetWidth)[_strScrollTop](sizeResetHeight);\r\n                   */\n                  expandElement[_strScrollLeft](constScroll)[_strScrollTop](constScroll);\n\n                  shrinkElement[_strScrollLeft](constScroll)[_strScrollTop](constScroll);\n                };\n\n                var onResized = function onResized() {\n                  rAFId = 0;\n                  if (!isDirty) return;\n                  widthCache = currWidth;\n                  heightCache = currHeight;\n                  callback();\n                };\n\n                var onScroll = function onScroll(event) {\n                  currWidth = observerElement[LEXICON.oW];\n                  currHeight = observerElement[LEXICON.oH];\n                  isDirty = currWidth != widthCache || currHeight != heightCache;\n\n                  if (event && isDirty && !rAFId) {\n                    COMPATIBILITY.cAF()(rAFId);\n                    rAFId = COMPATIBILITY.rAF()(onResized);\n                  } else if (!event) onResized();\n\n                  reset();\n\n                  if (event) {\n                    COMPATIBILITY.prvD(event);\n                    COMPATIBILITY.stpP(event);\n                  }\n\n                  return false;\n                };\n\n                var expandChildCSS = {};\n                var observerElementCSS = {};\n                setTopRightBottomLeft(observerElementCSS, _strEmpty, [-((nativeScrollbarSize.y + 1) * factor), nativeScrollbarSize.x * -factor, nativeScrollbarSize.y * -factor, -((nativeScrollbarSize.x + 1) * factor)]);\n                FRAMEWORK(observerElement).css(observerElementCSS);\n                expandElement.on(_strScroll, onScroll);\n                shrinkElement.on(_strScroll, onScroll);\n                targetElement.on(strAnimationStartEvent, function () {\n                  onScroll(false);\n                }); //lets assume that the divs will never be that large and a constant value is enough\n\n                expandChildCSS[_strWidth] = constScroll;\n                expandChildCSS[_strHeight] = constScroll;\n                expandElementChild.css(expandChildCSS);\n                reset();\n              } else {\n                var attachEvent = _documentElementNative.attachEvent;\n                var isIE = _msieVersion !== undefined;\n\n                if (attachEvent) {\n                  targetElement.prepend(generateDiv(_classNameResizeObserverElement));\n                  findFirst(targetElement, _strDot + _classNameResizeObserverElement)[0].attachEvent('onresize', callback);\n                } else {\n                  var obj = _documentElementNative.createElement(TYPES.o);\n\n                  obj.setAttribute(LEXICON.ti, '-1');\n                  obj.setAttribute(LEXICON.c, _classNameResizeObserverElement);\n\n                  obj.onload = function () {\n                    var wnd = this.contentDocument.defaultView;\n                    wnd.addEventListener('resize', callback);\n                    wnd.document.documentElement.style.display = 'none';\n                  };\n\n                  obj.type = 'text/html';\n                  if (isIE) targetElement.prepend(obj);\n                  obj.data = 'about:blank';\n                  if (!isIE) targetElement.prepend(obj);\n                  targetElement.on(strAnimationStartEvent, callback);\n                }\n              }\n            }\n\n            if (targetElement[0] === _sizeObserverElementNative) {\n              var directionChanged = function directionChanged() {\n                var dir = _hostElement.css('direction');\n\n                var css = {};\n                var scrollLeftValue = 0;\n                var result = false;\n\n                if (dir !== _cssDirectionDetectedCache) {\n                  if (dir === 'ltr') {\n                    css[_strLeft] = 0;\n                    css[_strRight] = _strAuto;\n                    scrollLeftValue = constScroll;\n                  } else {\n                    css[_strLeft] = _strAuto;\n                    css[_strRight] = 0;\n                    scrollLeftValue = _rtlScrollBehavior.n ? -constScroll : _rtlScrollBehavior.i ? 0 : constScroll;\n                  } //execution order is important for IE!!!\n\n\n                  _sizeObserverElement.children().eq(0).css(css);\n\n                  _sizeObserverElement[_strScrollLeft](scrollLeftValue)[_strScrollTop](constScroll);\n\n                  _cssDirectionDetectedCache = dir;\n                  result = true;\n                }\n\n                return result;\n              };\n\n              directionChanged();\n              addDestroyEventListener(targetElement, _strScroll, function (event) {\n                if (directionChanged()) update();\n                COMPATIBILITY.prvD(event);\n                COMPATIBILITY.stpP(event);\n                return false;\n              });\n            }\n          } //remove resize observer:\n          else {\n            if (_supportResizeObserver) {\n              var element = targetElement.contents()[0];\n              var resizeObserverObj = element[_strResizeObserverProperty];\n\n              if (resizeObserverObj) {\n                resizeObserverObj.disconnect();\n                delete element[_strResizeObserverProperty];\n              }\n            } else {\n              remove(targetElement.children(_strDot + _classNameResizeObserverElement).eq(0));\n            }\n          }\n        }\n      }\n      /**\r\n       * Freezes or unfreezes the given resize observer.\r\n       * @param targetElement The element to which the target resize observer is applied.\r\n       * @param freeze True if the resize observer shall be frozen, false otherwise.\r\n       \r\n      function freezeResizeObserver(targetElement, freeze) {\r\n          if (targetElement !== undefined) {\r\n              if(freeze) {\r\n                  if (_supportResizeObserver) {\r\n                      var element = targetElement.contents()[0];\r\n                      element[_strResizeObserverProperty].unobserve(element);\r\n                  }\r\n                  else {\r\n                      targetElement = targetElement.children(_strDot + _classNameResizeObserverElement).eq(0);\r\n                      var w = targetElement.css(_strWidth);\r\n                      var h = targetElement.css(_strHeight);\r\n                      var css = {};\r\n                      css[_strWidth] = w;\r\n                      css[_strHeight] = h;\r\n                      targetElement.css(css);\r\n                  }\r\n              }\r\n              else {\r\n                  if (_supportResizeObserver) {\r\n                      var element = targetElement.contents()[0];\r\n                      element[_strResizeObserverProperty].observe(element);\r\n                  }\r\n                  else {\r\n                      var css = { };\r\n                      css[_strHeight] = _strEmpty;\r\n                      css[_strWidth] = _strEmpty;\r\n                      targetElement.children(_strDot + _classNameResizeObserverElement).eq(0).css(css);\r\n                  }\r\n              }\r\n          }\r\n      }\r\n      */\n      //==== Mutation Observers ====//\n\n      /**\r\n       * Creates MutationObservers for the host and content Element if they are supported.\r\n       */\n\n\n      function createMutationObservers() {\n        if (_supportMutationObserver) {\n          var mutationObserverContentLag = 11;\n          var mutationObserver = COMPATIBILITY.mO();\n          var contentLastUpdate = COMPATIBILITY.now();\n          var mutationTarget;\n          var mutationAttrName;\n          var mutationIsClass;\n          var oldMutationVal;\n          var newClassVal;\n          var hostClassNameRegex;\n          var contentTimeout;\n          var now;\n          var sizeAuto;\n          var action;\n\n          _mutationObserverHostCallback = function _mutationObserverHostCallback(mutations) {\n            var doUpdate = false;\n            var doUpdateForce = false;\n            var mutation;\n            var mutatedAttrs = [];\n\n            if (_initialized && !_sleeping) {\n              each(mutations, function () {\n                mutation = this;\n                mutationTarget = mutation.target;\n                mutationAttrName = mutation.attributeName;\n                mutationIsClass = mutationAttrName === LEXICON.c;\n                oldMutationVal = mutation.oldValue;\n                newClassVal = mutationTarget.className;\n\n                if (_domExists && mutationIsClass && !doUpdateForce) {\n                  // if old class value contains _classNameHostElementForeign and new class value doesn't\n                  if (oldMutationVal.indexOf(_classNameHostElementForeign) > -1 && newClassVal.indexOf(_classNameHostElementForeign) < 0) {\n                    hostClassNameRegex = createHostClassNameRegExp(true);\n                    _hostElementNative.className = newClassVal.split(_strSpace).concat(oldMutationVal.split(_strSpace).filter(function (name) {\n                      return name.match(hostClassNameRegex);\n                    })).join(_strSpace);\n                    doUpdate = doUpdateForce = true;\n                  }\n                }\n\n                if (!doUpdate) {\n                  doUpdate = mutationIsClass ? hostClassNamesChanged(oldMutationVal, newClassVal) : mutationAttrName === LEXICON.s ? oldMutationVal !== mutationTarget[LEXICON.s].cssText : true;\n                }\n\n                mutatedAttrs.push(mutationAttrName);\n              });\n              updateViewportAttrsFromTarget(mutatedAttrs);\n              if (doUpdate) _base.update(doUpdateForce || _strAuto);\n            }\n\n            return doUpdate;\n          };\n\n          _mutationObserverContentCallback = function _mutationObserverContentCallback(mutations) {\n            var doUpdate = false;\n            var mutation;\n\n            if (_initialized && !_sleeping) {\n              each(mutations, function () {\n                mutation = this;\n                doUpdate = isUnknownMutation(mutation);\n                return !doUpdate;\n              });\n\n              if (doUpdate) {\n                now = COMPATIBILITY.now();\n                sizeAuto = _heightAutoCache || _widthAutoCache;\n\n                action = function action() {\n                  if (!_destroyed) {\n                    contentLastUpdate = now; //if cols, rows or wrap attr was changed\n\n                    if (_isTextarea) textareaUpdate();\n                    if (sizeAuto) update();else _base.update(_strAuto);\n                  }\n                };\n\n                clearTimeout(contentTimeout);\n                if (mutationObserverContentLag <= 0 || now - contentLastUpdate > mutationObserverContentLag || !sizeAuto) action();else contentTimeout = setTimeout(action, mutationObserverContentLag);\n              }\n            }\n\n            return doUpdate;\n          };\n\n          _mutationObserverHost = new mutationObserver(_mutationObserverHostCallback);\n          _mutationObserverContent = new mutationObserver(_mutationObserverContentCallback);\n        }\n      }\n      /**\r\n       * Connects the MutationObservers if they are supported.\r\n       */\n\n\n      function connectMutationObservers() {\n        if (_supportMutationObserver && !_mutationObserversConnected) {\n          _mutationObserverHost.observe(_hostElementNative, {\n            attributes: true,\n            attributeOldValue: true,\n            attributeFilter: _mutationObserverAttrsHost\n          });\n\n          _mutationObserverContent.observe(_isTextarea ? _targetElementNative : _contentElementNative, {\n            attributes: true,\n            attributeOldValue: true,\n            subtree: !_isTextarea,\n            childList: !_isTextarea,\n            characterData: !_isTextarea,\n            attributeFilter: _isTextarea ? _mutationObserverAttrsTextarea : _mutationObserverAttrsHost\n          });\n\n          _mutationObserversConnected = true;\n        }\n      }\n      /**\r\n       * Disconnects the MutationObservers if they are supported.\r\n       */\n\n\n      function disconnectMutationObservers() {\n        if (_supportMutationObserver && _mutationObserversConnected) {\n          _mutationObserverHost.disconnect();\n\n          _mutationObserverContent.disconnect();\n\n          _mutationObserversConnected = false;\n        }\n      } //==== Events of elements ====//\n\n      /**\r\n       * This method gets called every time the host element gets resized. IMPORTANT: Padding changes are detected too!!\r\n       * It refreshes the hostResizedEventArgs and the hostSizeResizeCache.\r\n       * If there are any size changes, the update method gets called.\r\n       */\n\n\n      function hostOnResized() {\n        if (!_sleeping) {\n          var changed;\n          var hostSize = {\n            w: _sizeObserverElementNative[LEXICON.sW],\n            h: _sizeObserverElementNative[LEXICON.sH]\n          };\n          changed = checkCache(hostSize, _hostElementSizeChangeDetectedCache);\n          _hostElementSizeChangeDetectedCache = hostSize;\n          if (changed) update({\n            _hostSizeChanged: true\n          });\n        }\n      }\n      /**\r\n       * The mouse enter event of the host element. This event is only needed for the autoHide feature.\r\n       */\n\n\n      function hostOnMouseEnter() {\n        if (_scrollbarsAutoHideLeave) refreshScrollbarsAutoHide(true);\n      }\n      /**\r\n       * The mouse leave event of the host element. This event is only needed for the autoHide feature.\r\n       */\n\n\n      function hostOnMouseLeave() {\n        if (_scrollbarsAutoHideLeave && !_bodyElement.hasClass(_classNameDragging)) refreshScrollbarsAutoHide(false);\n      }\n      /**\r\n       * The mouse move event of the host element. This event is only needed for the autoHide \"move\" feature.\r\n       */\n\n\n      function hostOnMouseMove() {\n        if (_scrollbarsAutoHideMove) {\n          refreshScrollbarsAutoHide(true);\n          clearTimeout(_scrollbarsAutoHideMoveTimeoutId);\n          _scrollbarsAutoHideMoveTimeoutId = setTimeout(function () {\n            if (_scrollbarsAutoHideMove && !_destroyed) refreshScrollbarsAutoHide(false);\n          }, 100);\n        }\n      }\n      /**\r\n       * Prevents text from deselection if attached to the document element on the mousedown event of a DOM element.\r\n       * @param event The select start event.\r\n       */\n\n\n      function documentOnSelectStart(event) {\n        COMPATIBILITY.prvD(event);\n        return false;\n      }\n      /**\t\r\n       * A callback which will be called after a element has loaded.\t\r\n       */\n\n\n      function updateOnLoadCallback(event) {\n        if (!_destroyed) {\n          var target = event.target;\n          var elm = FRAMEWORK(event.target);\n          var index = FRAMEWORK.inArray(target, _updateOnLoadElms);\n\n          if (index > -1) {\n            _updateOnLoadElms.splice(index, 1);\n          }\n\n          eachUpdateOnLoad(function (i, updateOnLoadSelector) {\n            if (elm.is(updateOnLoadSelector)) {\n              update({\n                _contentSizeChanged: true\n              });\n            }\n          });\n        }\n      }\n      /**\r\n      * Adds or removes mouse & touch events of the host element. (for handling auto-hiding of the scrollbars)\r\n      * @param destroy Indicates whether the events shall be added or removed.\r\n      */\n\n\n      function setupHostMouseTouchEvents(destroy) {\n        if (!destroy) setupHostMouseTouchEvents(true);\n        setupResponsiveEventListener(_hostElement, _strMouseTouchMoveEvent.split(_strSpace)[0], hostOnMouseMove, !_scrollbarsAutoHideMove || destroy, true);\n        setupResponsiveEventListener(_hostElement, [_strMouseEnter, _strMouseLeave], [hostOnMouseEnter, hostOnMouseLeave], !_scrollbarsAutoHideLeave || destroy, true); //if the plugin is initialized and the mouse is over the host element, make the scrollbars visible\n\n        if (!_initialized && !destroy) _hostElement.one('mouseover', hostOnMouseEnter);\n      } //==== Update Detection ====//\n\n      /**\r\n       * Measures the min width and min height of the body element and refreshes the related cache.\r\n       * @returns {boolean} True if the min width or min height has changed, false otherwise.\r\n       */\n\n\n      function bodyMinSizeChanged() {\n        var bodyMinSize = {};\n\n        if (_isBody && _contentArrangeElement) {\n          bodyMinSize.w = parseToZeroOrNumber(_contentArrangeElement.css(_strMinMinus + _strWidth));\n          bodyMinSize.h = parseToZeroOrNumber(_contentArrangeElement.css(_strMinMinus + _strHeight));\n          bodyMinSize.c = checkCache(bodyMinSize, _bodyMinSizeCache);\n          bodyMinSize.f = true; //flag for \"measured at least once\"\n        }\n\n        _bodyMinSizeCache = bodyMinSize;\n        return !!bodyMinSize.c;\n      }\n      /**\r\n       * Returns true if the class names really changed (new class without plugin host prefix)\r\n       * @param oldClassNames The old ClassName string or array.\r\n       * @param newClassNames The new ClassName string or array.\r\n       * @returns {boolean} True if the class names has really changed, false otherwise.\r\n       */\n\n\n      function hostClassNamesChanged(oldClassNames, newClassNames) {\n        var currClasses = typeof newClassNames == TYPES.s ? newClassNames.split(_strSpace) : [];\n        var oldClasses = typeof oldClassNames == TYPES.s ? oldClassNames.split(_strSpace) : [];\n        var diff = getArrayDifferences(oldClasses, currClasses); // remove none theme from diff list to prevent update\n\n        var idx = inArray(_classNameThemeNone, diff);\n        var i;\n        var regex;\n        if (idx > -1) diff.splice(idx, 1);\n\n        if (diff[LEXICON.l] > 0) {\n          regex = createHostClassNameRegExp(true, true);\n\n          for (i = 0; i < diff.length; i++) {\n            if (!diff[i].match(regex)) {\n              return true;\n            }\n          }\n        }\n\n        return false;\n      }\n      /**\r\n       * Returns true if the given mutation is not from a from the plugin generated element. If the target element is a textarea the mutation is always unknown.\r\n       * @param mutation The mutation which shall be checked.\r\n       * @returns {boolean} True if the mutation is from a unknown element, false otherwise.\r\n       */\n\n\n      function isUnknownMutation(mutation) {\n        var attributeName = mutation.attributeName;\n        var mutationTarget = mutation.target;\n        var mutationType = mutation.type;\n        var strClosest = 'closest';\n        if (mutationTarget === _contentElementNative) return attributeName === null;\n\n        if (mutationType === 'attributes' && (attributeName === LEXICON.c || attributeName === LEXICON.s) && !_isTextarea) {\n          //ignore className changes by the plugin\t\n          if (attributeName === LEXICON.c && FRAMEWORK(mutationTarget).hasClass(_classNameHostElement)) return hostClassNamesChanged(mutation.oldValue, mutationTarget.className); //only do it of browser support it natively\t\n\n          if (typeof mutationTarget[strClosest] != TYPES.f) return true;\n          if (mutationTarget[strClosest](_strDot + _classNameResizeObserverElement) !== null || mutationTarget[strClosest](_strDot + _classNameScrollbar) !== null || mutationTarget[strClosest](_strDot + _classNameScrollbarCorner) !== null) return false;\n        }\n\n        return true;\n      }\n      /**\r\n       * Returns true if the content size was changed since the last time this method was called.\r\n       * @returns {boolean} True if the content size was changed, false otherwise.\r\n       */\n\n\n      function updateAutoContentSizeChanged() {\n        if (_sleeping) return false;\n        var contentMeasureElement = getContentMeasureElement();\n        var textareaValueLength = _isTextarea && _widthAutoCache && !_textareaAutoWrappingCache ? _targetElement.val().length : 0;\n        var setCSS = !_mutationObserversConnected && _widthAutoCache && !_isTextarea;\n        var css = {};\n        var float;\n        var bodyMinSizeC;\n        var changed;\n        var contentElementScrollSize;\n\n        if (setCSS) {\n          float = _contentElement.css(_strFloat);\n          css[_strFloat] = _isRTL ? _strRight : _strLeft;\n          css[_strWidth] = _strAuto;\n\n          _contentElement.css(css);\n        }\n\n        contentElementScrollSize = {\n          w: contentMeasureElement[LEXICON.sW] + textareaValueLength,\n          h: contentMeasureElement[LEXICON.sH] + textareaValueLength\n        };\n\n        if (setCSS) {\n          css[_strFloat] = float;\n          css[_strWidth] = _strHundredPercent;\n\n          _contentElement.css(css);\n        }\n\n        bodyMinSizeC = bodyMinSizeChanged();\n        changed = checkCache(contentElementScrollSize, _contentElementScrollSizeChangeDetectedCache);\n        _contentElementScrollSizeChangeDetectedCache = contentElementScrollSize;\n        return changed || bodyMinSizeC;\n      }\n      /**\r\n       * Returns true when a attribute which the MutationObserver would observe has changed.  \r\n       * @returns {boolean} True if one of the attributes which a MutationObserver would observe has changed, false or undefined otherwise.\r\n       */\n\n\n      function meaningfulAttrsChanged() {\n        if (_sleeping || _mutationObserversConnected) return;\n        var elem;\n        var curr;\n        var cache;\n        var changedAttrs = [];\n        var checks = [{\n          _elem: _hostElement,\n          _attrs: _mutationObserverAttrsHost.concat(':visible')\n        }, {\n          _elem: _isTextarea ? _targetElement : undefined,\n          _attrs: _mutationObserverAttrsTextarea\n        }];\n        each(checks, function (index, check) {\n          elem = check._elem;\n\n          if (elem) {\n            each(check._attrs, function (index, attr) {\n              curr = attr.charAt(0) === ':' ? elem.is(attr) : elem.attr(attr);\n              cache = _updateAutoCache[attr];\n\n              if (checkCache(curr, cache)) {\n                changedAttrs.push(attr);\n              }\n\n              _updateAutoCache[attr] = curr;\n            });\n          }\n        });\n        updateViewportAttrsFromTarget(changedAttrs);\n        return changedAttrs[LEXICON.l] > 0;\n      }\n      /**\r\n       * Checks is a CSS Property of a child element is affecting the scroll size of the content.\r\n       * @param propertyName The CSS property name.\r\n       * @returns {boolean} True if the property is affecting the content scroll size, false otherwise.\r\n       */\n\n\n      function isSizeAffectingCSSProperty(propertyName) {\n        if (!_initialized) return true;\n        var flexGrow = 'flex-grow';\n        var flexShrink = 'flex-shrink';\n        var flexBasis = 'flex-basis';\n        var affectingPropsX = [_strWidth, _strMinMinus + _strWidth, _strMaxMinus + _strWidth, _strMarginMinus + _strLeft, _strMarginMinus + _strRight, _strLeft, _strRight, 'font-weight', 'word-spacing', flexGrow, flexShrink, flexBasis];\n        var affectingPropsXContentBox = [_strPaddingMinus + _strLeft, _strPaddingMinus + _strRight, _strBorderMinus + _strLeft + _strWidth, _strBorderMinus + _strRight + _strWidth];\n        var affectingPropsY = [_strHeight, _strMinMinus + _strHeight, _strMaxMinus + _strHeight, _strMarginMinus + _strTop, _strMarginMinus + _strBottom, _strTop, _strBottom, 'line-height', flexGrow, flexShrink, flexBasis];\n        var affectingPropsYContentBox = [_strPaddingMinus + _strTop, _strPaddingMinus + _strBottom, _strBorderMinus + _strTop + _strWidth, _strBorderMinus + _strBottom + _strWidth];\n        var _strS = 's';\n        var _strVS = 'v-s';\n        var checkX = _overflowBehaviorCache.x === _strS || _overflowBehaviorCache.x === _strVS;\n        var checkY = _overflowBehaviorCache.y === _strS || _overflowBehaviorCache.y === _strVS;\n        var sizeIsAffected = false;\n\n        var checkPropertyName = function checkPropertyName(arr, name) {\n          for (var i = 0; i < arr[LEXICON.l]; i++) {\n            if (arr[i] === name) return true;\n          }\n\n          return false;\n        };\n\n        if (checkY) {\n          sizeIsAffected = checkPropertyName(affectingPropsY, propertyName);\n          if (!sizeIsAffected && !_isBorderBox) sizeIsAffected = checkPropertyName(affectingPropsYContentBox, propertyName);\n        }\n\n        if (checkX && !sizeIsAffected) {\n          sizeIsAffected = checkPropertyName(affectingPropsX, propertyName);\n          if (!sizeIsAffected && !_isBorderBox) sizeIsAffected = checkPropertyName(affectingPropsXContentBox, propertyName);\n        }\n\n        return sizeIsAffected;\n      } //==== Update ====//\n\n      /**\r\n       * Sets the attribute values of the viewport element to the values from the target element.\r\n       * The value of a attribute is only set if the attribute is whitelisted.\r\n       * @attrs attrs The array of attributes which shall be set or undefined if all whitelisted shall be set.\r\n       */\n\n\n      function updateViewportAttrsFromTarget(attrs) {\n        attrs = attrs || _viewportAttrsFromTarget;\n        each(attrs, function (index, attr) {\n          if (COMPATIBILITY.inA(attr, _viewportAttrsFromTarget) > -1) {\n            var targetAttr = _targetElement.attr(attr);\n\n            if (type(targetAttr) == TYPES.s) {\n              _viewportElement.attr(attr, targetAttr);\n            } else {\n              _viewportElement.removeAttr(attr);\n            }\n          }\n        });\n      }\n      /**\r\n       * Updates the variables and size of the textarea element, and manages the scroll on new line or new character.\r\n       */\n\n\n      function textareaUpdate() {\n        if (!_sleeping) {\n          var wrapAttrOff = !_textareaAutoWrappingCache;\n          var minWidth = _viewportSize.w;\n          var minHeight = _viewportSize.h;\n          var css = {};\n          var doMeasure = _widthAutoCache || wrapAttrOff;\n          var origWidth;\n          var width;\n          var origHeight;\n          var height; //reset min size\n\n          css[_strMinMinus + _strWidth] = _strEmpty;\n          css[_strMinMinus + _strHeight] = _strEmpty; //set width auto\n\n          css[_strWidth] = _strAuto;\n\n          _targetElement.css(css); //measure width\n\n\n          origWidth = _targetElementNative[LEXICON.oW];\n          width = doMeasure ? MATH.max(origWidth, _targetElementNative[LEXICON.sW] - 1) : 1;\n          /*width += (_widthAutoCache ? _marginX + (!_isBorderBox ? wrapAttrOff ? 0 : _paddingX + _borderX : 0) : 0);*/\n          //set measured width\n\n          css[_strWidth] = _widthAutoCache ? _strAuto\n          /*width*/\n          : _strHundredPercent;\n          css[_strMinMinus + _strWidth] = _strHundredPercent; //set height auto\n\n          css[_strHeight] = _strAuto;\n\n          _targetElement.css(css); //measure height\n\n\n          origHeight = _targetElementNative[LEXICON.oH];\n          height = MATH.max(origHeight, _targetElementNative[LEXICON.sH] - 1); //append correct size values\n\n          css[_strWidth] = width;\n          css[_strHeight] = height;\n\n          _textareaCoverElement.css(css); //apply min width / min height to prevent textarea collapsing\n\n\n          css[_strMinMinus + _strWidth] = minWidth\n          /*+ (!_isBorderBox && _widthAutoCache ? _paddingX + _borderX : 0)*/\n          ;\n          css[_strMinMinus + _strHeight] = minHeight\n          /*+ (!_isBorderBox && _heightAutoCache ? _paddingY + _borderY : 0)*/\n          ;\n\n          _targetElement.css(css);\n\n          return {\n            _originalWidth: origWidth,\n            _originalHeight: origHeight,\n            _dynamicWidth: width,\n            _dynamicHeight: height\n          };\n        }\n      }\n      /**\r\n       * Updates the plugin and DOM to the current options.\r\n       * This method should only be called if a update is 100% required.\r\n       * @param updateHints A objects which contains hints for this update:\r\n       * {\r\n       *   _hostSizeChanged : boolean,\r\n       *   _contentSizeChanged : boolean,\r\n       *   _force : boolean,                             == preventSwallowing\r\n       *   _changedOptions : { },                        == preventSwallowing && preventSleep\r\n      *  }\r\n       */\n\n\n      function update(updateHints) {\n        clearTimeout(_swallowedUpdateTimeout);\n        updateHints = updateHints || {};\n        _swallowedUpdateHints._hostSizeChanged |= updateHints._hostSizeChanged;\n        _swallowedUpdateHints._contentSizeChanged |= updateHints._contentSizeChanged;\n        _swallowedUpdateHints._force |= updateHints._force;\n        var now = COMPATIBILITY.now();\n        var hostSizeChanged = !!_swallowedUpdateHints._hostSizeChanged;\n        var contentSizeChanged = !!_swallowedUpdateHints._contentSizeChanged;\n        var force = !!_swallowedUpdateHints._force;\n        var changedOptions = updateHints._changedOptions;\n        var swallow = _swallowUpdateLag > 0 && _initialized && !_destroyed && !force && !changedOptions && now - _lastUpdateTime < _swallowUpdateLag && !_heightAutoCache && !_widthAutoCache;\n        var displayIsHidden;\n        if (swallow) _swallowedUpdateTimeout = setTimeout(update, _swallowUpdateLag); //abort update due to:\n        //destroyed\n        //swallowing\n        //sleeping\n        //host is hidden or has false display\n\n        if (_destroyed || swallow || _sleeping && !changedOptions || _initialized && !force && (displayIsHidden = _hostElement.is(':hidden')) || _hostElement.css('display') === 'inline') return;\n        _lastUpdateTime = now;\n        _swallowedUpdateHints = {}; //if scrollbar styling is possible and native scrollbars aren't overlaid the scrollbar styling will be applied which hides the native scrollbars completely.\n\n        if (_nativeScrollbarStyling && !(_nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.y)) {\n          //native scrollbars are hidden, so change the values to zero\n          _nativeScrollbarSize.x = 0;\n          _nativeScrollbarSize.y = 0;\n        } else {\n          //refresh native scrollbar size (in case of zoom)\n          _nativeScrollbarSize = extendDeep({}, globals.nativeScrollbarSize);\n        } // Scrollbar padding is needed for firefox, because firefox hides scrollbar automatically if the size of the div is too small.\n        // The calculation: [scrollbar size +3 *3]\n        // (+3 because of possible decoration e.g. borders, margins etc., but only if native scrollbar is NOT a overlaid scrollbar)\n        // (*3 because (1)increase / (2)decrease -button and (3)resize handle)\n\n\n        _nativeScrollbarMinSize = {\n          x: (_nativeScrollbarSize.x + (_nativeScrollbarIsOverlaid.x ? 0 : 3)) * 3,\n          y: (_nativeScrollbarSize.y + (_nativeScrollbarIsOverlaid.y ? 0 : 3)) * 3\n        };\n        changedOptions = changedOptions || {}; //freezeResizeObserver(_sizeObserverElement, true);\n        //freezeResizeObserver(_sizeAutoObserverElement, true);\n\n        var checkCacheAutoForce = function checkCacheAutoForce() {\n          return checkCache.apply(this, [].slice.call(arguments).concat([force]));\n        }; //save current scroll offset\n\n\n        var currScroll = {\n          x: _viewportElement[_strScrollLeft](),\n          y: _viewportElement[_strScrollTop]()\n        };\n        var currentPreparedOptionsScrollbars = _currentPreparedOptions.scrollbars;\n        var currentPreparedOptionsTextarea = _currentPreparedOptions.textarea; //scrollbars visibility:\n\n        var scrollbarsVisibility = currentPreparedOptionsScrollbars.visibility;\n        var scrollbarsVisibilityChanged = checkCacheAutoForce(scrollbarsVisibility, _scrollbarsVisibilityCache); //scrollbars autoHide:\n\n        var scrollbarsAutoHide = currentPreparedOptionsScrollbars.autoHide;\n        var scrollbarsAutoHideChanged = checkCacheAutoForce(scrollbarsAutoHide, _scrollbarsAutoHideCache); //scrollbars click scrolling\n\n        var scrollbarsClickScrolling = currentPreparedOptionsScrollbars.clickScrolling;\n        var scrollbarsClickScrollingChanged = checkCacheAutoForce(scrollbarsClickScrolling, _scrollbarsClickScrollingCache); //scrollbars drag scrolling\n\n        var scrollbarsDragScrolling = currentPreparedOptionsScrollbars.dragScrolling;\n        var scrollbarsDragScrollingChanged = checkCacheAutoForce(scrollbarsDragScrolling, _scrollbarsDragScrollingCache); //className\n\n        var className = _currentPreparedOptions.className;\n        var classNameChanged = checkCacheAutoForce(className, _classNameCache); //resize\n\n        var resize = _currentPreparedOptions.resize;\n        var resizeChanged = checkCacheAutoForce(resize, _resizeCache) && !_isBody; //body can't be resized since the window itself acts as resize possibility.\n        //paddingAbsolute\n\n        var paddingAbsolute = _currentPreparedOptions.paddingAbsolute;\n        var paddingAbsoluteChanged = checkCacheAutoForce(paddingAbsolute, _paddingAbsoluteCache); //clipAlways\n\n        var clipAlways = _currentPreparedOptions.clipAlways;\n        var clipAlwaysChanged = checkCacheAutoForce(clipAlways, _clipAlwaysCache); //sizeAutoCapable\n\n        var sizeAutoCapable = _currentPreparedOptions.sizeAutoCapable && !_isBody; //body can never be size auto, because it shall be always as big as the viewport.\n\n        var sizeAutoCapableChanged = checkCacheAutoForce(sizeAutoCapable, _sizeAutoCapableCache); //showNativeScrollbars\n\n        var ignoreOverlayScrollbarHiding = _currentPreparedOptions.nativeScrollbarsOverlaid.showNativeScrollbars;\n        var ignoreOverlayScrollbarHidingChanged = checkCacheAutoForce(ignoreOverlayScrollbarHiding, _ignoreOverlayScrollbarHidingCache); //autoUpdate\n\n        var autoUpdate = _currentPreparedOptions.autoUpdate;\n        var autoUpdateChanged = checkCacheAutoForce(autoUpdate, _autoUpdateCache); //overflowBehavior\n\n        var overflowBehavior = _currentPreparedOptions.overflowBehavior;\n        var overflowBehaviorChanged = checkCacheAutoForce(overflowBehavior, _overflowBehaviorCache, force); //dynWidth:\n\n        var textareaDynWidth = currentPreparedOptionsTextarea.dynWidth;\n        var textareaDynWidthChanged = checkCacheAutoForce(_textareaDynWidthCache, textareaDynWidth); //dynHeight:\n\n        var textareaDynHeight = currentPreparedOptionsTextarea.dynHeight;\n        var textareaDynHeightChanged = checkCacheAutoForce(_textareaDynHeightCache, textareaDynHeight); //scrollbars visibility\n\n        _scrollbarsAutoHideNever = scrollbarsAutoHide === 'n';\n        _scrollbarsAutoHideScroll = scrollbarsAutoHide === 's';\n        _scrollbarsAutoHideMove = scrollbarsAutoHide === 'm';\n        _scrollbarsAutoHideLeave = scrollbarsAutoHide === 'l'; //scrollbars autoHideDelay\n\n        _scrollbarsAutoHideDelay = currentPreparedOptionsScrollbars.autoHideDelay; //old className\n\n        _oldClassName = _classNameCache; //resize\n\n        _resizeNone = resize === 'n';\n        _resizeBoth = resize === 'b';\n        _resizeHorizontal = resize === 'h';\n        _resizeVertical = resize === 'v'; //normalizeRTL\n\n        _normalizeRTLCache = _currentPreparedOptions.normalizeRTL; //ignore overlay scrollbar hiding\n\n        ignoreOverlayScrollbarHiding = ignoreOverlayScrollbarHiding && _nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.y; //refresh options cache\n\n        _scrollbarsVisibilityCache = scrollbarsVisibility;\n        _scrollbarsAutoHideCache = scrollbarsAutoHide;\n        _scrollbarsClickScrollingCache = scrollbarsClickScrolling;\n        _scrollbarsDragScrollingCache = scrollbarsDragScrolling;\n        _classNameCache = className;\n        _resizeCache = resize;\n        _paddingAbsoluteCache = paddingAbsolute;\n        _clipAlwaysCache = clipAlways;\n        _sizeAutoCapableCache = sizeAutoCapable;\n        _ignoreOverlayScrollbarHidingCache = ignoreOverlayScrollbarHiding;\n        _autoUpdateCache = autoUpdate;\n        _overflowBehaviorCache = extendDeep({}, overflowBehavior);\n        _textareaDynWidthCache = textareaDynWidth;\n        _textareaDynHeightCache = textareaDynHeight;\n        _hasOverflowCache = _hasOverflowCache || {\n          x: false,\n          y: false\n        }; //set correct class name to the host element\n\n        if (classNameChanged) {\n          removeClass(_hostElement, _oldClassName + _strSpace + _classNameThemeNone);\n          addClass(_hostElement, className !== undefined && className !== null && className.length > 0 ? className : _classNameThemeNone);\n        } //set correct auto Update\n\n\n        if (autoUpdateChanged) {\n          if (autoUpdate === true || autoUpdate === null && _autoUpdateRecommended) {\n            disconnectMutationObservers();\n            autoUpdateLoop.add(_base);\n          } else {\n            autoUpdateLoop.remove(_base);\n            connectMutationObservers();\n          }\n        } //activate or deactivate size auto capability\n\n\n        if (sizeAutoCapableChanged) {\n          if (sizeAutoCapable) {\n            if (_contentGlueElement) {\n              _contentGlueElement.show();\n            } else {\n              _contentGlueElement = FRAMEWORK(generateDiv(_classNameContentGlueElement));\n\n              _paddingElement.before(_contentGlueElement);\n            }\n\n            if (_sizeAutoObserverAdded) {\n              _sizeAutoObserverElement.show();\n            } else {\n              _sizeAutoObserverElement = FRAMEWORK(generateDiv(_classNameSizeAutoObserverElement));\n              _sizeAutoObserverElementNative = _sizeAutoObserverElement[0];\n\n              _contentGlueElement.before(_sizeAutoObserverElement);\n\n              var oldSize = {\n                w: -1,\n                h: -1\n              };\n              setupResizeObserver(_sizeAutoObserverElement, function () {\n                var newSize = {\n                  w: _sizeAutoObserverElementNative[LEXICON.oW],\n                  h: _sizeAutoObserverElementNative[LEXICON.oH]\n                };\n\n                if (checkCache(newSize, oldSize)) {\n                  if (_initialized && _heightAutoCache && newSize.h > 0 || _widthAutoCache && newSize.w > 0) {\n                    update();\n                  } else if (_initialized && !_heightAutoCache && newSize.h === 0 || !_widthAutoCache && newSize.w === 0) {\n                    update();\n                  }\n                }\n\n                oldSize = newSize;\n              });\n              _sizeAutoObserverAdded = true; //fix heightAuto detector bug if height is fixed but contentHeight is 0.\n              //the probability this bug will ever happen is very very low, thats why its ok if we use calc which isn't supported in IE8.\n\n              if (_cssCalc !== null) _sizeAutoObserverElement.css(_strHeight, _cssCalc + '(100% + 1px)');\n            }\n          } else {\n            if (_sizeAutoObserverAdded) _sizeAutoObserverElement.hide();\n            if (_contentGlueElement) _contentGlueElement.hide();\n          }\n        } //if force, update all resizeObservers too\n\n\n        if (force) {\n          _sizeObserverElement.find('*').trigger(_strScroll);\n\n          if (_sizeAutoObserverAdded) _sizeAutoObserverElement.find('*').trigger(_strScroll);\n        } //display hidden:\n\n\n        displayIsHidden = displayIsHidden === undefined ? _hostElement.is(':hidden') : displayIsHidden; //textarea AutoWrapping:\n\n        var textareaAutoWrapping = _isTextarea ? _targetElement.attr('wrap') !== 'off' : false;\n        var textareaAutoWrappingChanged = checkCacheAutoForce(textareaAutoWrapping, _textareaAutoWrappingCache); //detect direction:\n\n        var cssDirection = _hostElement.css('direction');\n\n        var cssDirectionChanged = checkCacheAutoForce(cssDirection, _cssDirectionCache); //detect box-sizing:\n\n        var boxSizing = _hostElement.css('box-sizing');\n\n        var boxSizingChanged = checkCacheAutoForce(boxSizing, _cssBoxSizingCache); //detect padding:\n\n        var padding = getTopRightBottomLeftHost(_strPaddingMinus); //width + height auto detecting var:\n\n        var sizeAutoObserverElementBCRect; //exception occurs in IE8 sometimes (unknown exception)\n\n        try {\n          sizeAutoObserverElementBCRect = _sizeAutoObserverAdded ? _sizeAutoObserverElementNative[LEXICON.bCR]() : null;\n        } catch (ex) {\n          return;\n        }\n\n        _isRTL = cssDirection === 'rtl';\n        _isBorderBox = boxSizing === 'border-box';\n        var isRTLLeft = _isRTL ? _strLeft : _strRight;\n        var isRTLRight = _isRTL ? _strRight : _strLeft; //detect width auto:\n\n        var widthAutoResizeDetection = false;\n        var widthAutoObserverDetection = _sizeAutoObserverAdded && _hostElement.css(_strFloat) !== 'none'\n        /*|| _isTextarea */\n        ? MATH.round(sizeAutoObserverElementBCRect.right - sizeAutoObserverElementBCRect.left) === 0 && (!paddingAbsolute ? _hostElementNative[LEXICON.cW] - _paddingX > 0 : true) : false;\n\n        if (sizeAutoCapable && !widthAutoObserverDetection) {\n          var tmpCurrHostWidth = _hostElementNative[LEXICON.oW];\n\n          var tmpCurrContentGlueWidth = _contentGlueElement.css(_strWidth);\n\n          _contentGlueElement.css(_strWidth, _strAuto);\n\n          var tmpNewHostWidth = _hostElementNative[LEXICON.oW];\n\n          _contentGlueElement.css(_strWidth, tmpCurrContentGlueWidth);\n\n          widthAutoResizeDetection = tmpCurrHostWidth !== tmpNewHostWidth;\n\n          if (!widthAutoResizeDetection) {\n            _contentGlueElement.css(_strWidth, tmpCurrHostWidth + 1);\n\n            tmpNewHostWidth = _hostElementNative[LEXICON.oW];\n\n            _contentGlueElement.css(_strWidth, tmpCurrContentGlueWidth);\n\n            widthAutoResizeDetection = tmpCurrHostWidth !== tmpNewHostWidth;\n          }\n        }\n\n        var widthAuto = (widthAutoObserverDetection || widthAutoResizeDetection) && sizeAutoCapable && !displayIsHidden;\n        var widthAutoChanged = checkCacheAutoForce(widthAuto, _widthAutoCache);\n        var wasWidthAuto = !widthAuto && _widthAutoCache; //detect height auto:\n\n        var heightAuto = _sizeAutoObserverAdded && sizeAutoCapable && !displayIsHidden ? MATH.round(sizeAutoObserverElementBCRect.bottom - sizeAutoObserverElementBCRect.top) === 0\n        /* && (!paddingAbsolute && (_msieVersion > 9 || !_msieVersion) ? true : true) */\n        : false;\n        var heightAutoChanged = checkCacheAutoForce(heightAuto, _heightAutoCache);\n        var wasHeightAuto = !heightAuto && _heightAutoCache; //detect border:\n        //we need the border only if border box and auto size\n\n        var updateBorderX = widthAuto && _isBorderBox || !_isBorderBox;\n        var updateBorderY = heightAuto && _isBorderBox || !_isBorderBox;\n        var border = getTopRightBottomLeftHost(_strBorderMinus, '-' + _strWidth, !updateBorderX, !updateBorderY); //detect margin:\n\n        var margin = getTopRightBottomLeftHost(_strMarginMinus); //vars to apply correct css\n\n        var contentElementCSS = {};\n        var contentGlueElementCSS = {}; //funcs\n\n        var getHostSize = function getHostSize() {\n          //has to be clientSize because offsetSize respect borders\n          return {\n            w: _hostElementNative[LEXICON.cW],\n            h: _hostElementNative[LEXICON.cH]\n          };\n        };\n\n        var getViewportSize = function getViewportSize() {\n          //viewport size is padding container because it never has padding, margin and a border\n          //determine zoom rounding error -> sometimes scrollWidth/Height is smaller than clientWidth/Height\n          //if this happens add the difference to the viewportSize to compensate the rounding error\n          return {\n            w: _paddingElementNative[LEXICON.oW] + MATH.max(0, _contentElementNative[LEXICON.cW] - _contentElementNative[LEXICON.sW]),\n            h: _paddingElementNative[LEXICON.oH] + MATH.max(0, _contentElementNative[LEXICON.cH] - _contentElementNative[LEXICON.sH])\n          };\n        }; //set info for padding\n\n\n        var paddingAbsoluteX = _paddingX = padding.l + padding.r;\n        var paddingAbsoluteY = _paddingY = padding.t + padding.b;\n        paddingAbsoluteX *= paddingAbsolute ? 1 : 0;\n        paddingAbsoluteY *= paddingAbsolute ? 1 : 0;\n        padding.c = checkCacheAutoForce(padding, _cssPaddingCache); //set info for border\n\n        _borderX = border.l + border.r;\n        _borderY = border.t + border.b;\n        border.c = checkCacheAutoForce(border, _cssBorderCache); //set info for margin\n\n        _marginX = margin.l + margin.r;\n        _marginY = margin.t + margin.b;\n        margin.c = checkCacheAutoForce(margin, _cssMarginCache); //refresh cache\n\n        _textareaAutoWrappingCache = textareaAutoWrapping;\n        _cssDirectionCache = cssDirection;\n        _cssBoxSizingCache = boxSizing;\n        _widthAutoCache = widthAuto;\n        _heightAutoCache = heightAuto;\n        _cssPaddingCache = padding;\n        _cssBorderCache = border;\n        _cssMarginCache = margin; //IEFix direction changed\n\n        if (cssDirectionChanged && _sizeAutoObserverAdded) _sizeAutoObserverElement.css(_strFloat, isRTLRight); //apply padding:\n\n        if (padding.c || cssDirectionChanged || paddingAbsoluteChanged || widthAutoChanged || heightAutoChanged || boxSizingChanged || sizeAutoCapableChanged) {\n          var paddingElementCSS = {};\n          var textareaCSS = {};\n          var paddingValues = [padding.t, padding.r, padding.b, padding.l];\n          setTopRightBottomLeft(contentGlueElementCSS, _strMarginMinus, [-padding.t, -padding.r, -padding.b, -padding.l]);\n\n          if (paddingAbsolute) {\n            setTopRightBottomLeft(paddingElementCSS, _strEmpty, paddingValues);\n            setTopRightBottomLeft(_isTextarea ? textareaCSS : contentElementCSS, _strPaddingMinus);\n          } else {\n            setTopRightBottomLeft(paddingElementCSS, _strEmpty);\n            setTopRightBottomLeft(_isTextarea ? textareaCSS : contentElementCSS, _strPaddingMinus, paddingValues);\n          }\n\n          _paddingElement.css(paddingElementCSS);\n\n          _targetElement.css(textareaCSS);\n        } //viewport size is padding container because it never has padding, margin and a border.\n\n\n        _viewportSize = getViewportSize(); //update Textarea\n\n        var textareaSize = _isTextarea ? textareaUpdate() : false;\n\n        var textareaSizeChanged = _isTextarea && checkCacheAutoForce(textareaSize, _textareaSizeCache);\n\n        var textareaDynOrigSize = _isTextarea && textareaSize ? {\n          w: textareaDynWidth ? textareaSize._dynamicWidth : textareaSize._originalWidth,\n          h: textareaDynHeight ? textareaSize._dynamicHeight : textareaSize._originalHeight\n        } : {};\n        _textareaSizeCache = textareaSize; //fix height auto / width auto in cooperation with current padding & boxSizing behavior:\n\n        if (heightAuto && (heightAutoChanged || paddingAbsoluteChanged || boxSizingChanged || padding.c || border.c)) {\n          contentElementCSS[_strHeight] = _strAuto;\n        } else if (heightAutoChanged || paddingAbsoluteChanged) {\n          contentElementCSS[_strHeight] = _strHundredPercent;\n        }\n\n        if (widthAuto && (widthAutoChanged || paddingAbsoluteChanged || boxSizingChanged || padding.c || border.c || cssDirectionChanged)) {\n          contentElementCSS[_strWidth] = _strAuto;\n          contentGlueElementCSS[_strMaxMinus + _strWidth] = _strHundredPercent; //IE Fix\n        } else if (widthAutoChanged || paddingAbsoluteChanged) {\n          contentElementCSS[_strWidth] = _strHundredPercent;\n          contentElementCSS[_strFloat] = _strEmpty;\n          contentGlueElementCSS[_strMaxMinus + _strWidth] = _strEmpty; //IE Fix\n        }\n\n        if (widthAuto) {\n          //textareaDynOrigSize.w || _strAuto :: doesnt works because applied margin will shift width\n          contentGlueElementCSS[_strWidth] = _strAuto;\n          contentElementCSS[_strWidth] = VENDORS._cssPropertyValue(_strWidth, 'max-content intrinsic') || _strAuto;\n          contentElementCSS[_strFloat] = isRTLRight;\n        } else {\n          contentGlueElementCSS[_strWidth] = _strEmpty;\n        }\n\n        if (heightAuto) {\n          //textareaDynOrigSize.h || _contentElementNative[LEXICON.cH] :: use for anti scroll jumping\n          contentGlueElementCSS[_strHeight] = textareaDynOrigSize.h || _contentElementNative[LEXICON.cH];\n        } else {\n          contentGlueElementCSS[_strHeight] = _strEmpty;\n        }\n\n        if (sizeAutoCapable) _contentGlueElement.css(contentGlueElementCSS);\n\n        _contentElement.css(contentElementCSS); //CHECKPOINT HERE ~\n\n\n        contentElementCSS = {};\n        contentGlueElementCSS = {}; //if [content(host) client / scroll size, or target element direction, or content(host) max-sizes] changed, or force is true\n\n        if (hostSizeChanged || contentSizeChanged || textareaSizeChanged || cssDirectionChanged || boxSizingChanged || paddingAbsoluteChanged || widthAutoChanged || widthAuto || heightAutoChanged || heightAuto || ignoreOverlayScrollbarHidingChanged || overflowBehaviorChanged || clipAlwaysChanged || resizeChanged || scrollbarsVisibilityChanged || scrollbarsAutoHideChanged || scrollbarsDragScrollingChanged || scrollbarsClickScrollingChanged || textareaDynWidthChanged || textareaDynHeightChanged || textareaAutoWrappingChanged) {\n          var strOverflow = 'overflow';\n          var strOverflowX = strOverflow + '-x';\n          var strOverflowY = strOverflow + '-y';\n          var strHidden = 'hidden';\n          var strVisible = 'visible'; //Reset the viewport (very important for natively overlaid scrollbars and zoom change\n          //don't change the overflow prop as it is very expensive and affects performance !A LOT!\n\n          if (!_nativeScrollbarStyling) {\n            var viewportElementResetCSS = {};\n            var resetXTmp = _hasOverflowCache.y && _hideOverflowCache.ys && !ignoreOverlayScrollbarHiding ? _nativeScrollbarIsOverlaid.y ? _viewportElement.css(isRTLLeft) : -_nativeScrollbarSize.y : 0;\n            var resetBottomTmp = _hasOverflowCache.x && _hideOverflowCache.xs && !ignoreOverlayScrollbarHiding ? _nativeScrollbarIsOverlaid.x ? _viewportElement.css(_strBottom) : -_nativeScrollbarSize.x : 0;\n            setTopRightBottomLeft(viewportElementResetCSS, _strEmpty);\n\n            _viewportElement.css(viewportElementResetCSS);\n          } //measure several sizes:\n\n\n          var contentMeasureElement = getContentMeasureElement(); //in Firefox content element has to have overflow hidden, else element margins aren't calculated properly, this element prevents this bug, but only if scrollbars aren't overlaid\n\n          var contentSize = {\n            //use clientSize because natively overlaidScrollbars add borders\n            w: textareaDynOrigSize.w || contentMeasureElement[LEXICON.cW],\n            h: textareaDynOrigSize.h || contentMeasureElement[LEXICON.cH]\n          };\n          var scrollSize = {\n            w: contentMeasureElement[LEXICON.sW],\n            h: contentMeasureElement[LEXICON.sH]\n          }; //apply the correct viewport style and measure viewport size\n\n          if (!_nativeScrollbarStyling) {\n            viewportElementResetCSS[_strBottom] = wasHeightAuto ? _strEmpty : resetBottomTmp;\n            viewportElementResetCSS[isRTLLeft] = wasWidthAuto ? _strEmpty : resetXTmp;\n\n            _viewportElement.css(viewportElementResetCSS);\n          }\n\n          _viewportSize = getViewportSize(); //measure and correct several sizes\n\n          var hostSize = getHostSize();\n          var hostAbsoluteRectSize = {\n            w: hostSize.w - _marginX - _borderX - (_isBorderBox ? 0 : _paddingX),\n            h: hostSize.h - _marginY - _borderY - (_isBorderBox ? 0 : _paddingY)\n          };\n          var contentGlueSize = {\n            //client/scrollSize + AbsolutePadding -> because padding is only applied to the paddingElement if its absolute, so you have to add it manually\n            //hostSize is clientSize -> so padding should be added manually, right? FALSE! Because content glue is inside hostElement, so we don't have to worry about padding\n            w: MATH.max((widthAuto ? contentSize.w : scrollSize.w) + paddingAbsoluteX, hostAbsoluteRectSize.w),\n            h: MATH.max((heightAuto ? contentSize.h : scrollSize.h) + paddingAbsoluteY, hostAbsoluteRectSize.h)\n          };\n          contentGlueSize.c = checkCacheAutoForce(contentGlueSize, _contentGlueSizeCache);\n          _contentGlueSizeCache = contentGlueSize; //apply correct contentGlue size\n\n          if (sizeAutoCapable) {\n            //size contentGlue correctly to make sure the element has correct size if the sizing switches to auto\n            if (contentGlueSize.c || heightAuto || widthAuto) {\n              contentGlueElementCSS[_strWidth] = contentGlueSize.w;\n              contentGlueElementCSS[_strHeight] = contentGlueSize.h; //textarea-sizes are already calculated correctly at this point\n\n              if (!_isTextarea) {\n                contentSize = {\n                  //use clientSize because natively overlaidScrollbars add borders\n                  w: contentMeasureElement[LEXICON.cW],\n                  h: contentMeasureElement[LEXICON.cH]\n                };\n              }\n            }\n\n            var textareaCoverCSS = {};\n\n            var setContentGlueElementCSSfunction = function setContentGlueElementCSSfunction(horizontal) {\n              var scrollbarVars = getScrollbarVars(horizontal);\n              var wh = scrollbarVars._w_h;\n              var strWH = scrollbarVars._width_height;\n              var autoSize = horizontal ? widthAuto : heightAuto;\n              var borderSize = horizontal ? _borderX : _borderY;\n              var paddingSize = horizontal ? _paddingX : _paddingY;\n              var marginSize = horizontal ? _marginX : _marginY;\n              var viewportSize = _viewportSize[wh] - borderSize - marginSize - (_isBorderBox ? 0 : paddingSize); //make contentGlue size -1 if element is not auto sized, to make sure that a resize event happens when the element shrinks\n\n              if (!autoSize || !autoSize && border.c) contentGlueElementCSS[strWH] = hostAbsoluteRectSize[wh] - 1; //if size is auto and host is smaller than size as min size, make content glue size -1 to make sure size changes will be detected (this is only needed if padding is 0)\n\n              if (autoSize && contentSize[wh] < viewportSize && (horizontal && _isTextarea ? !textareaAutoWrapping : true)) {\n                if (_isTextarea) textareaCoverCSS[strWH] = parseToZeroOrNumber(_textareaCoverElement.css(strWH)) - 1;\n                contentGlueElementCSS[strWH] -= 1;\n              } //make sure content glue size is at least 1\n\n\n              if (contentSize[wh] > 0) contentGlueElementCSS[strWH] = MATH.max(1, contentGlueElementCSS[strWH]);\n            };\n\n            setContentGlueElementCSSfunction(true);\n            setContentGlueElementCSSfunction(false);\n            if (_isTextarea) _textareaCoverElement.css(textareaCoverCSS);\n\n            _contentGlueElement.css(contentGlueElementCSS);\n          }\n\n          if (widthAuto) contentElementCSS[_strWidth] = _strHundredPercent;\n          if (widthAuto && !_isBorderBox && !_mutationObserversConnected) contentElementCSS[_strFloat] = 'none'; //apply and reset content style\n\n          _contentElement.css(contentElementCSS);\n\n          contentElementCSS = {}; //measure again, but this time all correct sizes:\n\n          var contentScrollSize = {\n            w: contentMeasureElement[LEXICON.sW],\n            h: contentMeasureElement[LEXICON.sH]\n          };\n          contentScrollSize.c = contentSizeChanged = checkCacheAutoForce(contentScrollSize, _contentScrollSizeCache);\n          _contentScrollSizeCache = contentScrollSize; //refresh viewport size after correct measuring\n\n          _viewportSize = getViewportSize();\n          hostSize = getHostSize();\n          hostSizeChanged = checkCacheAutoForce(hostSize, _hostSizeCache);\n          _hostSizeCache = hostSize;\n          var hideOverflowForceTextarea = _isTextarea && (_viewportSize.w === 0 || _viewportSize.h === 0);\n          var previousOverflowAmount = _overflowAmountCache;\n          var overflowBehaviorIsVS = {};\n          var overflowBehaviorIsVH = {};\n          var overflowBehaviorIsS = {};\n          var overflowAmount = {};\n          var hasOverflow = {};\n          var hideOverflow = {};\n          var canScroll = {};\n\n          var viewportRect = _paddingElementNative[LEXICON.bCR]();\n\n          var setOverflowVariables = function setOverflowVariables(horizontal) {\n            var scrollbarVars = getScrollbarVars(horizontal);\n            var scrollbarVarsInverted = getScrollbarVars(!horizontal);\n            var xyI = scrollbarVarsInverted._x_y;\n            var xy = scrollbarVars._x_y;\n            var wh = scrollbarVars._w_h;\n            var widthHeight = scrollbarVars._width_height;\n            var scrollMax = _strScroll + scrollbarVars._Left_Top + 'Max';\n            var fractionalOverflowAmount = viewportRect[widthHeight] ? MATH.abs(viewportRect[widthHeight] - _viewportSize[wh]) : 0;\n            var checkFractionalOverflowAmount = previousOverflowAmount && previousOverflowAmount[xy] > 0 && _viewportElementNative[scrollMax] === 0;\n            overflowBehaviorIsVS[xy] = overflowBehavior[xy] === 'v-s';\n            overflowBehaviorIsVH[xy] = overflowBehavior[xy] === 'v-h';\n            overflowBehaviorIsS[xy] = overflowBehavior[xy] === 's';\n            overflowAmount[xy] = MATH.max(0, MATH.round((contentScrollSize[wh] - _viewportSize[wh]) * 100) / 100);\n            overflowAmount[xy] *= hideOverflowForceTextarea || checkFractionalOverflowAmount && fractionalOverflowAmount > 0 && fractionalOverflowAmount < 1 ? 0 : 1;\n            hasOverflow[xy] = overflowAmount[xy] > 0; //hideOverflow:\n            //x || y : true === overflow is hidden by \"overflow: scroll\" OR \"overflow: hidden\"\n            //xs || ys : true === overflow is hidden by \"overflow: scroll\"\n\n            hideOverflow[xy] = overflowBehaviorIsVS[xy] || overflowBehaviorIsVH[xy] ? hasOverflow[xyI] && !overflowBehaviorIsVS[xyI] && !overflowBehaviorIsVH[xyI] : hasOverflow[xy];\n            hideOverflow[xy + 's'] = hideOverflow[xy] ? overflowBehaviorIsS[xy] || overflowBehaviorIsVS[xy] : false;\n            canScroll[xy] = hasOverflow[xy] && hideOverflow[xy + 's'];\n          };\n\n          setOverflowVariables(true);\n          setOverflowVariables(false);\n          overflowAmount.c = checkCacheAutoForce(overflowAmount, _overflowAmountCache);\n          _overflowAmountCache = overflowAmount;\n          hasOverflow.c = checkCacheAutoForce(hasOverflow, _hasOverflowCache);\n          _hasOverflowCache = hasOverflow;\n          hideOverflow.c = checkCacheAutoForce(hideOverflow, _hideOverflowCache);\n          _hideOverflowCache = hideOverflow; //if native scrollbar is overlay at x OR y axis, prepare DOM\n\n          if (_nativeScrollbarIsOverlaid.x || _nativeScrollbarIsOverlaid.y) {\n            var borderDesign = 'px solid transparent';\n            var contentArrangeElementCSS = {};\n            var arrangeContent = {};\n            var arrangeChanged = force;\n            var setContentElementCSS;\n\n            if (hasOverflow.x || hasOverflow.y) {\n              arrangeContent.w = _nativeScrollbarIsOverlaid.y && hasOverflow.y ? contentScrollSize.w + _overlayScrollbarDummySize.y : _strEmpty;\n              arrangeContent.h = _nativeScrollbarIsOverlaid.x && hasOverflow.x ? contentScrollSize.h + _overlayScrollbarDummySize.x : _strEmpty;\n              arrangeChanged = checkCacheAutoForce(arrangeContent, _arrangeContentSizeCache);\n              _arrangeContentSizeCache = arrangeContent;\n            }\n\n            if (hasOverflow.c || hideOverflow.c || contentScrollSize.c || cssDirectionChanged || widthAutoChanged || heightAutoChanged || widthAuto || heightAuto || ignoreOverlayScrollbarHidingChanged) {\n              contentElementCSS[_strMarginMinus + isRTLRight] = contentElementCSS[_strBorderMinus + isRTLRight] = _strEmpty;\n\n              setContentElementCSS = function setContentElementCSS(horizontal) {\n                var scrollbarVars = getScrollbarVars(horizontal);\n                var scrollbarVarsInverted = getScrollbarVars(!horizontal);\n                var xy = scrollbarVars._x_y;\n                var strDirection = horizontal ? _strBottom : isRTLLeft;\n                var invertedAutoSize = horizontal ? heightAuto : widthAuto;\n\n                if (_nativeScrollbarIsOverlaid[xy] && hasOverflow[xy] && hideOverflow[xy + 's']) {\n                  contentElementCSS[_strMarginMinus + strDirection] = invertedAutoSize ? ignoreOverlayScrollbarHiding ? _strEmpty : _overlayScrollbarDummySize[xy] : _strEmpty;\n                  contentElementCSS[_strBorderMinus + strDirection] = (horizontal ? !invertedAutoSize : true) && !ignoreOverlayScrollbarHiding ? _overlayScrollbarDummySize[xy] + borderDesign : _strEmpty;\n                } else {\n                  arrangeContent[scrollbarVarsInverted._w_h] = contentElementCSS[_strMarginMinus + strDirection] = contentElementCSS[_strBorderMinus + strDirection] = _strEmpty;\n                  arrangeChanged = true;\n                }\n              };\n\n              if (_nativeScrollbarStyling) {\n                addRemoveClass(_viewportElement, _classNameViewportNativeScrollbarsInvisible, !ignoreOverlayScrollbarHiding);\n              } else {\n                setContentElementCSS(true);\n                setContentElementCSS(false);\n              }\n            }\n\n            if (ignoreOverlayScrollbarHiding) {\n              arrangeContent.w = arrangeContent.h = _strEmpty;\n              arrangeChanged = true;\n            }\n\n            if (arrangeChanged && !_nativeScrollbarStyling) {\n              contentArrangeElementCSS[_strWidth] = hideOverflow.y ? arrangeContent.w : _strEmpty;\n              contentArrangeElementCSS[_strHeight] = hideOverflow.x ? arrangeContent.h : _strEmpty;\n\n              if (!_contentArrangeElement) {\n                _contentArrangeElement = FRAMEWORK(generateDiv(_classNameContentArrangeElement));\n\n                _viewportElement.prepend(_contentArrangeElement);\n              }\n\n              _contentArrangeElement.css(contentArrangeElementCSS);\n            }\n\n            _contentElement.css(contentElementCSS);\n          }\n\n          var viewportElementCSS = {};\n          var paddingElementCSS = {};\n          var setViewportCSS;\n\n          if (hostSizeChanged || hasOverflow.c || hideOverflow.c || contentScrollSize.c || overflowBehaviorChanged || boxSizingChanged || ignoreOverlayScrollbarHidingChanged || cssDirectionChanged || clipAlwaysChanged || heightAutoChanged) {\n            viewportElementCSS[isRTLRight] = _strEmpty;\n\n            setViewportCSS = function setViewportCSS(horizontal) {\n              var scrollbarVars = getScrollbarVars(horizontal);\n              var scrollbarVarsInverted = getScrollbarVars(!horizontal);\n              var xy = scrollbarVars._x_y;\n              var XY = scrollbarVars._X_Y;\n              var strDirection = horizontal ? _strBottom : isRTLLeft;\n\n              var reset = function reset() {\n                viewportElementCSS[strDirection] = _strEmpty;\n                _contentBorderSize[scrollbarVarsInverted._w_h] = 0;\n              };\n\n              if (hasOverflow[xy] && hideOverflow[xy + 's']) {\n                viewportElementCSS[strOverflow + XY] = _strScroll;\n\n                if (ignoreOverlayScrollbarHiding || _nativeScrollbarStyling) {\n                  reset();\n                } else {\n                  viewportElementCSS[strDirection] = -(_nativeScrollbarIsOverlaid[xy] ? _overlayScrollbarDummySize[xy] : _nativeScrollbarSize[xy]);\n                  _contentBorderSize[scrollbarVarsInverted._w_h] = _nativeScrollbarIsOverlaid[xy] ? _overlayScrollbarDummySize[scrollbarVarsInverted._x_y] : 0;\n                }\n              } else {\n                viewportElementCSS[strOverflow + XY] = _strEmpty;\n                reset();\n              }\n            };\n\n            setViewportCSS(true);\n            setViewportCSS(false); // if the scroll container is too small and if there is any overflow with no overlay scrollbar (and scrollbar styling isn't possible), \n            // make viewport element greater in size (Firefox hide Scrollbars fix)\n            // because firefox starts hiding scrollbars on too small elements\n            // with this behavior the overflow calculation may be incorrect or the scrollbars would appear suddenly\n            // https://bugzilla.mozilla.org/show_bug.cgi?id=292284\n\n            if (!_nativeScrollbarStyling && (_viewportSize.h < _nativeScrollbarMinSize.x || _viewportSize.w < _nativeScrollbarMinSize.y) && (hasOverflow.x && hideOverflow.x && !_nativeScrollbarIsOverlaid.x || hasOverflow.y && hideOverflow.y && !_nativeScrollbarIsOverlaid.y)) {\n              viewportElementCSS[_strPaddingMinus + _strTop] = _nativeScrollbarMinSize.x;\n              viewportElementCSS[_strMarginMinus + _strTop] = -_nativeScrollbarMinSize.x;\n              viewportElementCSS[_strPaddingMinus + isRTLRight] = _nativeScrollbarMinSize.y;\n              viewportElementCSS[_strMarginMinus + isRTLRight] = -_nativeScrollbarMinSize.y;\n            } else {\n              viewportElementCSS[_strPaddingMinus + _strTop] = viewportElementCSS[_strMarginMinus + _strTop] = viewportElementCSS[_strPaddingMinus + isRTLRight] = viewportElementCSS[_strMarginMinus + isRTLRight] = _strEmpty;\n            }\n\n            viewportElementCSS[_strPaddingMinus + isRTLLeft] = viewportElementCSS[_strMarginMinus + isRTLLeft] = _strEmpty; //if there is any overflow (x OR y axis) and this overflow shall be hidden, make overflow hidden, else overflow visible\n\n            if (hasOverflow.x && hideOverflow.x || hasOverflow.y && hideOverflow.y || hideOverflowForceTextarea) {\n              //only hide if is Textarea\n              if (_isTextarea && hideOverflowForceTextarea) {\n                paddingElementCSS[strOverflowX] = paddingElementCSS[strOverflowY] = strHidden;\n              }\n            } else {\n              if (!clipAlways || overflowBehaviorIsVH.x || overflowBehaviorIsVS.x || overflowBehaviorIsVH.y || overflowBehaviorIsVS.y) {\n                //only un-hide if Textarea\n                if (_isTextarea) {\n                  paddingElementCSS[strOverflowX] = paddingElementCSS[strOverflowY] = _strEmpty;\n                }\n\n                viewportElementCSS[strOverflowX] = viewportElementCSS[strOverflowY] = strVisible;\n              }\n            }\n\n            _paddingElement.css(paddingElementCSS);\n\n            _viewportElement.css(viewportElementCSS);\n\n            viewportElementCSS = {}; //force soft redraw in webkit because without the scrollbars will may appear because DOM wont be redrawn under special conditions\n\n            if ((hasOverflow.c || boxSizingChanged || widthAutoChanged || heightAutoChanged) && !(_nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.y)) {\n              var elementStyle = _contentElementNative[LEXICON.s];\n              var dump;\n              elementStyle.webkitTransform = 'scale(1)';\n              elementStyle.display = 'run-in';\n              dump = _contentElementNative[LEXICON.oH];\n              elementStyle.display = _strEmpty; //|| dump; //use dump to prevent it from deletion if minify\n\n              elementStyle.webkitTransform = _strEmpty;\n            }\n            /*\r\n            //force hard redraw in webkit if native overlaid scrollbars shall appear\r\n            if (ignoreOverlayScrollbarHidingChanged && ignoreOverlayScrollbarHiding) {\r\n                _hostElement.hide();\r\n                var dump = _hostElementNative[LEXICON.oH];\r\n                _hostElement.show();\r\n            }\r\n            */\n\n          } //change to direction RTL and width auto Bugfix in Webkit\n          //without this fix, the DOM still thinks the scrollbar is LTR and thus the content is shifted to the left\n\n\n          contentElementCSS = {};\n\n          if (cssDirectionChanged || widthAutoChanged || heightAutoChanged) {\n            if (_isRTL && widthAuto) {\n              var floatTmp = _contentElement.css(_strFloat);\n\n              var posLeftWithoutFloat = MATH.round(_contentElement.css(_strFloat, _strEmpty).css(_strLeft, _strEmpty).position().left);\n\n              _contentElement.css(_strFloat, floatTmp);\n\n              var posLeftWithFloat = MATH.round(_contentElement.position().left);\n              if (posLeftWithoutFloat !== posLeftWithFloat) contentElementCSS[_strLeft] = posLeftWithoutFloat;\n            } else {\n              contentElementCSS[_strLeft] = _strEmpty;\n            }\n          }\n\n          _contentElement.css(contentElementCSS); //handle scroll position\n\n\n          if (_isTextarea && contentSizeChanged) {\n            var textareaInfo = getTextareaInfo();\n\n            if (textareaInfo) {\n              var textareaRowsChanged = _textareaInfoCache === undefined ? true : textareaInfo._rows !== _textareaInfoCache._rows;\n              var cursorRow = textareaInfo._cursorRow;\n              var cursorCol = textareaInfo._cursorColumn;\n              var widestRow = textareaInfo._widestRow;\n              var lastRow = textareaInfo._rows;\n              var lastCol = textareaInfo._columns;\n              var cursorPos = textareaInfo._cursorPosition;\n              var cursorMax = textareaInfo._cursorMax;\n              var cursorIsLastPosition = cursorPos >= cursorMax && _textareaHasFocus;\n              var textareaScrollAmount = {\n                x: !textareaAutoWrapping && cursorCol === lastCol && cursorRow === widestRow ? _overflowAmountCache.x : -1,\n                y: (textareaAutoWrapping ? cursorIsLastPosition || textareaRowsChanged && (previousOverflowAmount ? currScroll.y === previousOverflowAmount.y : false) : (cursorIsLastPosition || textareaRowsChanged) && cursorRow === lastRow) ? _overflowAmountCache.y : -1\n              };\n              currScroll.x = textareaScrollAmount.x > -1 ? _isRTL && _normalizeRTLCache && _rtlScrollBehavior.i ? 0 : textareaScrollAmount.x : currScroll.x; //if inverted, scroll to 0 -> normalized this means to max scroll offset.\n\n              currScroll.y = textareaScrollAmount.y > -1 ? textareaScrollAmount.y : currScroll.y;\n            }\n\n            _textareaInfoCache = textareaInfo;\n          }\n\n          if (_isRTL && _rtlScrollBehavior.i && _nativeScrollbarIsOverlaid.y && hasOverflow.x && _normalizeRTLCache) currScroll.x += _contentBorderSize.w || 0;\n          if (widthAuto) _hostElement[_strScrollLeft](0);\n          if (heightAuto) _hostElement[_strScrollTop](0);\n\n          _viewportElement[_strScrollLeft](currScroll.x)[_strScrollTop](currScroll.y); //scrollbars management:\n\n\n          var scrollbarsVisibilityVisible = scrollbarsVisibility === 'v';\n          var scrollbarsVisibilityHidden = scrollbarsVisibility === 'h';\n          var scrollbarsVisibilityAuto = scrollbarsVisibility === 'a';\n\n          var refreshScrollbarsVisibility = function refreshScrollbarsVisibility(showX, showY) {\n            showY = showY === undefined ? showX : showY;\n            refreshScrollbarAppearance(true, showX, canScroll.x);\n            refreshScrollbarAppearance(false, showY, canScroll.y);\n          }; //manage class name which indicates scrollable overflow\n\n\n          addRemoveClass(_hostElement, _classNameHostOverflow, hideOverflow.x || hideOverflow.y);\n          addRemoveClass(_hostElement, _classNameHostOverflowX, hideOverflow.x);\n          addRemoveClass(_hostElement, _classNameHostOverflowY, hideOverflow.y); //add or remove rtl class name for styling purposes except when its body, then the scrollbar stays\n\n          if (cssDirectionChanged && !_isBody) {\n            addRemoveClass(_hostElement, _classNameHostRTL, _isRTL);\n          } //manage the resize feature (CSS3 resize \"polyfill\" for this plugin)\n\n\n          if (_isBody) addClass(_hostElement, _classNameHostResizeDisabled);\n\n          if (resizeChanged) {\n            addRemoveClass(_hostElement, _classNameHostResizeDisabled, _resizeNone);\n            addRemoveClass(_scrollbarCornerElement, _classNameScrollbarCornerResize, !_resizeNone);\n            addRemoveClass(_scrollbarCornerElement, _classNameScrollbarCornerResizeB, _resizeBoth);\n            addRemoveClass(_scrollbarCornerElement, _classNameScrollbarCornerResizeH, _resizeHorizontal);\n            addRemoveClass(_scrollbarCornerElement, _classNameScrollbarCornerResizeV, _resizeVertical);\n          } //manage the scrollbars general visibility + the scrollbar interactivity (unusable class name)\n\n\n          if (scrollbarsVisibilityChanged || overflowBehaviorChanged || hideOverflow.c || hasOverflow.c || ignoreOverlayScrollbarHidingChanged) {\n            if (ignoreOverlayScrollbarHiding) {\n              if (ignoreOverlayScrollbarHidingChanged) {\n                removeClass(_hostElement, _classNameHostScrolling);\n\n                if (ignoreOverlayScrollbarHiding) {\n                  refreshScrollbarsVisibility(false);\n                }\n              }\n            } else if (scrollbarsVisibilityAuto) {\n              refreshScrollbarsVisibility(canScroll.x, canScroll.y);\n            } else if (scrollbarsVisibilityVisible) {\n              refreshScrollbarsVisibility(true);\n            } else if (scrollbarsVisibilityHidden) {\n              refreshScrollbarsVisibility(false);\n            }\n          } //manage the scrollbars auto hide feature (auto hide them after specific actions)\n\n\n          if (scrollbarsAutoHideChanged || ignoreOverlayScrollbarHidingChanged) {\n            setupHostMouseTouchEvents(!_scrollbarsAutoHideLeave && !_scrollbarsAutoHideMove);\n            refreshScrollbarsAutoHide(_scrollbarsAutoHideNever, !_scrollbarsAutoHideNever);\n          } //manage scrollbars handle length & offset - don't remove!\n\n\n          if (hostSizeChanged || overflowAmount.c || heightAutoChanged || widthAutoChanged || resizeChanged || boxSizingChanged || paddingAbsoluteChanged || ignoreOverlayScrollbarHidingChanged || cssDirectionChanged) {\n            refreshScrollbarHandleLength(true);\n            refreshScrollbarHandleOffset(true);\n            refreshScrollbarHandleLength(false);\n            refreshScrollbarHandleOffset(false);\n          } //manage interactivity\n\n\n          if (scrollbarsClickScrollingChanged) refreshScrollbarsInteractive(true, scrollbarsClickScrolling);\n          if (scrollbarsDragScrollingChanged) refreshScrollbarsInteractive(false, scrollbarsDragScrolling); //callbacks:\n\n          dispatchCallback('onDirectionChanged', {\n            isRTL: _isRTL,\n            dir: cssDirection\n          }, cssDirectionChanged);\n          dispatchCallback('onHostSizeChanged', {\n            width: _hostSizeCache.w,\n            height: _hostSizeCache.h\n          }, hostSizeChanged);\n          dispatchCallback('onContentSizeChanged', {\n            width: _contentScrollSizeCache.w,\n            height: _contentScrollSizeCache.h\n          }, contentSizeChanged);\n          dispatchCallback('onOverflowChanged', {\n            x: hasOverflow.x,\n            y: hasOverflow.y,\n            xScrollable: hideOverflow.xs,\n            yScrollable: hideOverflow.ys,\n            clipped: hideOverflow.x || hideOverflow.y\n          }, hasOverflow.c || hideOverflow.c);\n          dispatchCallback('onOverflowAmountChanged', {\n            x: overflowAmount.x,\n            y: overflowAmount.y\n          }, overflowAmount.c);\n        } //fix body min size\n\n\n        if (_isBody && _bodyMinSizeCache && (_hasOverflowCache.c || _bodyMinSizeCache.c)) {\n          //its possible that no min size was measured until now, because the content arrange element was just added now, in this case, measure now the min size.\n          if (!_bodyMinSizeCache.f) bodyMinSizeChanged();\n          if (_nativeScrollbarIsOverlaid.y && _hasOverflowCache.x) _contentElement.css(_strMinMinus + _strWidth, _bodyMinSizeCache.w + _overlayScrollbarDummySize.y);\n          if (_nativeScrollbarIsOverlaid.x && _hasOverflowCache.y) _contentElement.css(_strMinMinus + _strHeight, _bodyMinSizeCache.h + _overlayScrollbarDummySize.x);\n          _bodyMinSizeCache.c = false;\n        }\n\n        if (_initialized && changedOptions.updateOnLoad) {\n          updateElementsOnLoad();\n        } //freezeResizeObserver(_sizeObserverElement, false);\n        //freezeResizeObserver(_sizeAutoObserverElement, false);\n\n\n        dispatchCallback('onUpdated', {\n          forced: force\n        });\n      }\n      /**\r\n       * Updates the found elements of which the load event shall be handled.\r\n       */\n\n\n      function updateElementsOnLoad() {\n        if (!_isTextarea) {\n          eachUpdateOnLoad(function (i, updateOnLoadSelector) {\n            _contentElement.find(updateOnLoadSelector).each(function (i, el) {\n              // if element doesn't have a updateOnLoadCallback applied\n              if (COMPATIBILITY.inA(el, _updateOnLoadElms) < 0) {\n                _updateOnLoadElms.push(el);\n\n                FRAMEWORK(el).off(_updateOnLoadEventName, updateOnLoadCallback).on(_updateOnLoadEventName, updateOnLoadCallback);\n              }\n            });\n          });\n        }\n      } //==== Options ====//\n\n      /**\r\n       * Sets new options but doesn't call the update method.\r\n       * @param newOptions The object which contains the new options.\r\n       * @returns {*} A object which contains the changed options.\r\n       */\n\n\n      function setOptions(newOptions) {\n        var validatedOpts = _pluginsOptions._validate(newOptions, _pluginsOptions._template, true, _currentOptions);\n\n        _currentOptions = extendDeep({}, _currentOptions, validatedOpts._default);\n        _currentPreparedOptions = extendDeep({}, _currentPreparedOptions, validatedOpts._prepared);\n        return validatedOpts._prepared;\n      } //==== Structure ====//\n\n      /**\r\n       * Builds or destroys the wrapper and helper DOM elements.\r\n       * @param destroy Indicates whether the DOM shall be build or destroyed.\r\n       */\n\n      /**\r\n       * Builds or destroys the wrapper and helper DOM elements.\r\n       * @param destroy Indicates whether the DOM shall be build or destroyed.\r\n       */\n\n\n      function setupStructureDOM(destroy) {\n        var strParent = 'parent';\n        var classNameResizeObserverHost = 'os-resize-observer-host';\n        var classNameTextareaElementFull = _classNameTextareaElement + _strSpace + _classNameTextInherit;\n        var textareaClass = _isTextarea ? _strSpace + _classNameTextInherit : _strEmpty;\n        var adoptAttrs = _currentPreparedOptions.textarea.inheritedAttrs;\n        var adoptAttrsMap = {};\n\n        var applyAdoptedAttrs = function applyAdoptedAttrs() {\n          var applyAdoptedAttrsElm = destroy ? _targetElement : _hostElement;\n          each(adoptAttrsMap, function (key, value) {\n            if (type(value) == TYPES.s) {\n              if (key == LEXICON.c) applyAdoptedAttrsElm.addClass(value);else applyAdoptedAttrsElm.attr(key, value);\n            }\n          });\n        };\n\n        var hostElementClassNames = [_classNameHostElement, _classNameHostElementForeign, _classNameHostTextareaElement, _classNameHostResizeDisabled, _classNameHostRTL, _classNameHostScrollbarHorizontalHidden, _classNameHostScrollbarVerticalHidden, _classNameHostTransition, _classNameHostScrolling, _classNameHostOverflow, _classNameHostOverflowX, _classNameHostOverflowY, _classNameThemeNone, _classNameTextareaElement, _classNameTextInherit, _classNameCache].join(_strSpace);\n        var hostElementCSS = {}; //get host element as first element, because that's the most upper element and required for the other elements\n\n        _hostElement = _hostElement || (_isTextarea ? _domExists ? _targetElement[strParent]()[strParent]()[strParent]()[strParent]() : FRAMEWORK(generateDiv(_classNameHostTextareaElement)) : _targetElement);\n        _contentElement = _contentElement || selectOrGenerateDivByClass(_classNameContentElement + textareaClass);\n        _viewportElement = _viewportElement || selectOrGenerateDivByClass(_classNameViewportElement + textareaClass);\n        _paddingElement = _paddingElement || selectOrGenerateDivByClass(_classNamePaddingElement + textareaClass);\n        _sizeObserverElement = _sizeObserverElement || selectOrGenerateDivByClass(classNameResizeObserverHost);\n        _textareaCoverElement = _textareaCoverElement || (_isTextarea ? selectOrGenerateDivByClass(_classNameTextareaCoverElement) : undefined); //add this class to workaround class changing issues with UI frameworks especially Vue\n\n        if (_domExists) addClass(_hostElement, _classNameHostElementForeign); //on destroy, remove all generated class names from the host element before collecting the adopted attributes \n        //to prevent adopting generated class names\n\n        if (destroy) removeClass(_hostElement, hostElementClassNames); //collect all adopted attributes\n\n        adoptAttrs = type(adoptAttrs) == TYPES.s ? adoptAttrs.split(_strSpace) : adoptAttrs;\n\n        if (COMPATIBILITY.isA(adoptAttrs) && _isTextarea) {\n          each(adoptAttrs, function (i, v) {\n            if (type(v) == TYPES.s) {\n              adoptAttrsMap[v] = destroy ? _hostElement.attr(v) : _targetElement.attr(v);\n            }\n          });\n        }\n\n        if (!destroy) {\n          if (_isTextarea) {\n            if (!_currentPreparedOptions.sizeAutoCapable) {\n              hostElementCSS[_strWidth] = _targetElement.css(_strWidth);\n              hostElementCSS[_strHeight] = _targetElement.css(_strHeight);\n            }\n\n            if (!_domExists) _targetElement.addClass(_classNameTextInherit).wrap(_hostElement); //jQuery clones elements in wrap functions, so we have to select them again\n\n            _hostElement = _targetElement[strParent]().css(hostElementCSS);\n          }\n\n          if (!_domExists) {\n            //add the correct class to the target element\n            addClass(_targetElement, _isTextarea ? classNameTextareaElementFull : _classNameHostElement); //wrap the content into the generated elements to create the required DOM\n\n            _hostElement.wrapInner(_contentElement).wrapInner(_viewportElement).wrapInner(_paddingElement).prepend(_sizeObserverElement); //jQuery clones elements in wrap functions, so we have to select them again\n\n\n            _contentElement = findFirst(_hostElement, _strDot + _classNameContentElement);\n            _viewportElement = findFirst(_hostElement, _strDot + _classNameViewportElement);\n            _paddingElement = findFirst(_hostElement, _strDot + _classNamePaddingElement);\n\n            if (_isTextarea) {\n              _contentElement.prepend(_textareaCoverElement);\n\n              applyAdoptedAttrs();\n            }\n          }\n\n          if (_nativeScrollbarStyling) addClass(_viewportElement, _classNameViewportNativeScrollbarsInvisible);\n          if (_nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.y) addClass(_viewportElement, _classNameViewportNativeScrollbarsOverlaid);\n          if (_isBody) addClass(_htmlElement, _classNameHTMLElement);\n          _sizeObserverElementNative = _sizeObserverElement[0];\n          _hostElementNative = _hostElement[0];\n          _paddingElementNative = _paddingElement[0];\n          _viewportElementNative = _viewportElement[0];\n          _contentElementNative = _contentElement[0];\n          updateViewportAttrsFromTarget();\n        } else {\n          if (_domExists && _initialized) {\n            //clear size observer\n            _sizeObserverElement.children().remove(); //remove the style property and classes from already generated elements\n\n\n            each([_paddingElement, _viewportElement, _contentElement, _textareaCoverElement], function (i, elm) {\n              if (elm) {\n                removeClass(elm.removeAttr(LEXICON.s), _classNamesDynamicDestroy);\n              }\n            }); //add classes to the host element which was removed previously to match the expected DOM\n\n            addClass(_hostElement, _isTextarea ? _classNameHostTextareaElement : _classNameHostElement);\n          } else {\n            //remove size observer\n            remove(_sizeObserverElement); //unwrap the content to restore DOM\n\n            _contentElement.contents().unwrap().unwrap().unwrap();\n\n            if (_isTextarea) {\n              _targetElement.unwrap();\n\n              remove(_hostElement);\n              remove(_textareaCoverElement);\n              applyAdoptedAttrs();\n            }\n          }\n\n          if (_isTextarea) _targetElement.removeAttr(LEXICON.s);\n          if (_isBody) removeClass(_htmlElement, _classNameHTMLElement);\n        }\n      }\n      /**\r\n       * Adds or removes all wrapper elements interactivity events.\r\n       * @param destroy Indicates whether the Events shall be added or removed.\r\n       */\n\n\n      function setupStructureEvents() {\n        var textareaKeyDownRestrictedKeyCodes = [112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 123, //F1 to F12\n        33, 34, //page up, page down\n        37, 38, 39, 40, //left, up, right, down arrows\n        16, 17, 18, 19, 20, 144 //Shift, Ctrl, Alt, Pause, CapsLock, NumLock\n        ];\n        var textareaKeyDownKeyCodesList = [];\n        var textareaUpdateIntervalID;\n        var scrollStopTimeoutId;\n        var scrollStopDelay = 175;\n        var strFocus = 'focus';\n\n        function updateTextarea(doClearInterval) {\n          textareaUpdate();\n\n          _base.update(_strAuto);\n\n          if (doClearInterval && _autoUpdateRecommended) clearInterval(textareaUpdateIntervalID);\n        }\n\n        function textareaOnScroll(event) {\n          _targetElement[_strScrollLeft](_rtlScrollBehavior.i && _normalizeRTLCache ? 9999999 : 0);\n\n          _targetElement[_strScrollTop](0);\n\n          COMPATIBILITY.prvD(event);\n          COMPATIBILITY.stpP(event);\n          return false;\n        }\n\n        function textareaOnDrop(event) {\n          setTimeout(function () {\n            if (!_destroyed) updateTextarea();\n          }, 50);\n        }\n\n        function textareaOnFocus() {\n          _textareaHasFocus = true;\n          addClass(_hostElement, strFocus);\n        }\n\n        function textareaOnFocusout() {\n          _textareaHasFocus = false;\n          textareaKeyDownKeyCodesList = [];\n          removeClass(_hostElement, strFocus);\n          updateTextarea(true);\n        }\n\n        function textareaOnKeyDown(event) {\n          var keyCode = event.keyCode;\n\n          if (inArray(keyCode, textareaKeyDownRestrictedKeyCodes) < 0) {\n            if (!textareaKeyDownKeyCodesList[LEXICON.l]) {\n              updateTextarea();\n              textareaUpdateIntervalID = setInterval(updateTextarea, 1000 / 60);\n            }\n\n            if (inArray(keyCode, textareaKeyDownKeyCodesList) < 0) textareaKeyDownKeyCodesList.push(keyCode);\n          }\n        }\n\n        function textareaOnKeyUp(event) {\n          var keyCode = event.keyCode;\n          var index = inArray(keyCode, textareaKeyDownKeyCodesList);\n\n          if (inArray(keyCode, textareaKeyDownRestrictedKeyCodes) < 0) {\n            if (index > -1) textareaKeyDownKeyCodesList.splice(index, 1);\n            if (!textareaKeyDownKeyCodesList[LEXICON.l]) updateTextarea(true);\n          }\n        }\n\n        function contentOnTransitionEnd(event) {\n          if (_autoUpdateCache === true) return;\n          event = event.originalEvent || event;\n          if (isSizeAffectingCSSProperty(event.propertyName)) _base.update(_strAuto);\n        }\n\n        function viewportOnScroll(event) {\n          if (!_sleeping) {\n            if (scrollStopTimeoutId !== undefined) clearTimeout(scrollStopTimeoutId);else {\n              if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) refreshScrollbarsAutoHide(true);\n              if (!nativeOverlayScrollbarsAreActive()) addClass(_hostElement, _classNameHostScrolling);\n              dispatchCallback('onScrollStart', event);\n            } //if a scrollbars handle gets dragged, the mousemove event is responsible for refreshing the handle offset\n            //because if CSS scroll-snap is used, the handle offset gets only refreshed on every snap point\n            //this looks laggy & clunky, it looks much better if the offset refreshes with the mousemove\n\n            if (!_scrollbarsHandlesDefineScrollPos) {\n              refreshScrollbarHandleOffset(true);\n              refreshScrollbarHandleOffset(false);\n            }\n\n            dispatchCallback('onScroll', event);\n            scrollStopTimeoutId = setTimeout(function () {\n              if (!_destroyed) {\n                //OnScrollStop:\n                clearTimeout(scrollStopTimeoutId);\n                scrollStopTimeoutId = undefined;\n                if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) refreshScrollbarsAutoHide(false);\n                if (!nativeOverlayScrollbarsAreActive()) removeClass(_hostElement, _classNameHostScrolling);\n                dispatchCallback('onScrollStop', event);\n              }\n            }, scrollStopDelay);\n          }\n        }\n\n        if (_isTextarea) {\n          if (_msieVersion > 9 || !_autoUpdateRecommended) {\n            addDestroyEventListener(_targetElement, 'input', updateTextarea);\n          } else {\n            addDestroyEventListener(_targetElement, [_strKeyDownEvent, _strKeyUpEvent], [textareaOnKeyDown, textareaOnKeyUp]);\n          }\n\n          addDestroyEventListener(_targetElement, [_strScroll, 'drop', strFocus, strFocus + 'out'], [textareaOnScroll, textareaOnDrop, textareaOnFocus, textareaOnFocusout]);\n        } else {\n          addDestroyEventListener(_contentElement, _strTransitionEndEvent, contentOnTransitionEnd);\n        }\n\n        addDestroyEventListener(_viewportElement, _strScroll, viewportOnScroll, true);\n      } //==== Scrollbars ====//\n\n      /**\r\n       * Builds or destroys all scrollbar DOM elements (scrollbar, track, handle)\r\n       * @param destroy Indicates whether the DOM shall be build or destroyed.\r\n       */\n\n\n      function setupScrollbarsDOM(destroy) {\n        var selectOrGenerateScrollbarDOM = function selectOrGenerateScrollbarDOM(isHorizontal) {\n          var scrollbarClassName = isHorizontal ? _classNameScrollbarHorizontal : _classNameScrollbarVertical;\n          var scrollbar = selectOrGenerateDivByClass(_classNameScrollbar + _strSpace + scrollbarClassName, true);\n          var track = selectOrGenerateDivByClass(_classNameScrollbarTrack, scrollbar);\n          var handle = selectOrGenerateDivByClass(_classNameScrollbarHandle, scrollbar);\n\n          if (!_domExists && !destroy) {\n            scrollbar.append(track);\n            track.append(handle);\n          }\n\n          return {\n            _scrollbar: scrollbar,\n            _track: track,\n            _handle: handle\n          };\n        };\n\n        function resetScrollbarDOM(isHorizontal) {\n          var scrollbarVars = getScrollbarVars(isHorizontal);\n          var scrollbar = scrollbarVars._scrollbar;\n          var track = scrollbarVars._track;\n          var handle = scrollbarVars._handle;\n\n          if (_domExists && _initialized) {\n            each([scrollbar, track, handle], function (i, elm) {\n              removeClass(elm.removeAttr(LEXICON.s), _classNamesDynamicDestroy);\n            });\n          } else {\n            remove(scrollbar || selectOrGenerateScrollbarDOM(isHorizontal)._scrollbar);\n          }\n        }\n\n        var horizontalElements;\n        var verticalElements;\n\n        if (!destroy) {\n          horizontalElements = selectOrGenerateScrollbarDOM(true);\n          verticalElements = selectOrGenerateScrollbarDOM();\n          _scrollbarHorizontalElement = horizontalElements._scrollbar;\n          _scrollbarHorizontalTrackElement = horizontalElements._track;\n          _scrollbarHorizontalHandleElement = horizontalElements._handle;\n          _scrollbarVerticalElement = verticalElements._scrollbar;\n          _scrollbarVerticalTrackElement = verticalElements._track;\n          _scrollbarVerticalHandleElement = verticalElements._handle;\n\n          if (!_domExists) {\n            _paddingElement.after(_scrollbarVerticalElement);\n\n            _paddingElement.after(_scrollbarHorizontalElement);\n          }\n        } else {\n          resetScrollbarDOM(true);\n          resetScrollbarDOM();\n        }\n      }\n      /**\r\n       * Initializes all scrollbar interactivity events. (track and handle dragging, clicking, scrolling)\r\n       * @param isHorizontal True if the target scrollbar is the horizontal scrollbar, false if the target scrollbar is the vertical scrollbar.\r\n       */\n\n\n      function setupScrollbarEvents(isHorizontal) {\n        var scrollbarVars = getScrollbarVars(isHorizontal);\n        var scrollbarVarsInfo = scrollbarVars._info;\n        var insideIFrame = _windowElementNative.top !== _windowElementNative;\n        var xy = scrollbarVars._x_y;\n        var XY = scrollbarVars._X_Y;\n        var scroll = _strScroll + scrollbarVars._Left_Top;\n        var strActive = 'active';\n        var strSnapHandle = 'snapHandle';\n        var strClickEvent = 'click';\n        var scrollDurationFactor = 1;\n        var increaseDecreaseScrollAmountKeyCodes = [16, 17]; //shift, ctrl\n\n        var trackTimeout;\n        var mouseDownScroll;\n        var mouseDownOffset;\n        var mouseDownInvertedScale;\n\n        function getPointerPosition(event) {\n          return _msieVersion && insideIFrame ? event['screen' + XY] : COMPATIBILITY.page(event)[xy]; //use screen coordinates in EDGE & IE because the page values are incorrect in frames.\n        }\n\n        function getPreparedScrollbarsOption(name) {\n          return _currentPreparedOptions.scrollbars[name];\n        }\n\n        function increaseTrackScrollAmount() {\n          scrollDurationFactor = 0.5;\n        }\n\n        function decreaseTrackScrollAmount() {\n          scrollDurationFactor = 1;\n        }\n\n        function stopClickEventPropagation(event) {\n          COMPATIBILITY.stpP(event);\n        }\n\n        function documentKeyDown(event) {\n          if (inArray(event.keyCode, increaseDecreaseScrollAmountKeyCodes) > -1) increaseTrackScrollAmount();\n        }\n\n        function documentKeyUp(event) {\n          if (inArray(event.keyCode, increaseDecreaseScrollAmountKeyCodes) > -1) decreaseTrackScrollAmount();\n        }\n\n        function onMouseTouchDownContinue(event) {\n          var originalEvent = event.originalEvent || event;\n          var isTouchEvent = originalEvent.touches !== undefined;\n          return _sleeping || _destroyed || nativeOverlayScrollbarsAreActive() || !_scrollbarsDragScrollingCache || isTouchEvent && !getPreparedScrollbarsOption('touchSupport') ? false : COMPATIBILITY.mBtn(event) === 1 || isTouchEvent;\n        }\n\n        function documentDragMove(event) {\n          if (onMouseTouchDownContinue(event)) {\n            var trackLength = scrollbarVarsInfo._trackLength;\n            var handleLength = scrollbarVarsInfo._handleLength;\n            var scrollRange = scrollbarVarsInfo._maxScroll;\n            var scrollRaw = (getPointerPosition(event) - mouseDownOffset) * mouseDownInvertedScale;\n            var scrollDeltaPercent = scrollRaw / (trackLength - handleLength);\n            var scrollDelta = scrollRange * scrollDeltaPercent;\n            scrollDelta = isFinite(scrollDelta) ? scrollDelta : 0;\n            if (_isRTL && isHorizontal && !_rtlScrollBehavior.i) scrollDelta *= -1;\n\n            _viewportElement[scroll](MATH.round(mouseDownScroll + scrollDelta));\n\n            if (_scrollbarsHandlesDefineScrollPos) refreshScrollbarHandleOffset(isHorizontal, mouseDownScroll + scrollDelta);\n            if (!_supportPassiveEvents) COMPATIBILITY.prvD(event);\n          } else documentMouseTouchUp(event);\n        }\n\n        function documentMouseTouchUp(event) {\n          event = event || event.originalEvent;\n          setupResponsiveEventListener(_documentElement, [_strMouseTouchMoveEvent, _strMouseTouchUpEvent, _strKeyDownEvent, _strKeyUpEvent, _strSelectStartEvent], [documentDragMove, documentMouseTouchUp, documentKeyDown, documentKeyUp, documentOnSelectStart], true);\n          COMPATIBILITY.rAF()(function () {\n            setupResponsiveEventListener(_documentElement, strClickEvent, stopClickEventPropagation, true, {\n              _capture: true\n            });\n          });\n          if (_scrollbarsHandlesDefineScrollPos) refreshScrollbarHandleOffset(isHorizontal, true);\n          _scrollbarsHandlesDefineScrollPos = false;\n          removeClass(_bodyElement, _classNameDragging);\n          removeClass(scrollbarVars._handle, strActive);\n          removeClass(scrollbarVars._track, strActive);\n          removeClass(scrollbarVars._scrollbar, strActive);\n          mouseDownScroll = undefined;\n          mouseDownOffset = undefined;\n          mouseDownInvertedScale = 1;\n          decreaseTrackScrollAmount();\n\n          if (trackTimeout !== undefined) {\n            _base.scrollStop();\n\n            clearTimeout(trackTimeout);\n            trackTimeout = undefined;\n          }\n\n          if (event) {\n            var rect = _hostElementNative[LEXICON.bCR]();\n\n            var mouseInsideHost = event.clientX >= rect.left && event.clientX <= rect.right && event.clientY >= rect.top && event.clientY <= rect.bottom; //if mouse is outside host element\n\n            if (!mouseInsideHost) hostOnMouseLeave();\n            if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) refreshScrollbarsAutoHide(false);\n          }\n        }\n\n        function onHandleMouseTouchDown(event) {\n          if (onMouseTouchDownContinue(event)) onHandleMouseTouchDownAction(event);\n        }\n\n        function onHandleMouseTouchDownAction(event) {\n          mouseDownScroll = _viewportElement[scroll]();\n          mouseDownScroll = isNaN(mouseDownScroll) ? 0 : mouseDownScroll;\n          if (_isRTL && isHorizontal && !_rtlScrollBehavior.n || !_isRTL) mouseDownScroll = mouseDownScroll < 0 ? 0 : mouseDownScroll;\n          mouseDownInvertedScale = getHostElementInvertedScale()[xy];\n          mouseDownOffset = getPointerPosition(event);\n          _scrollbarsHandlesDefineScrollPos = !getPreparedScrollbarsOption(strSnapHandle);\n          addClass(_bodyElement, _classNameDragging);\n          addClass(scrollbarVars._handle, strActive);\n          addClass(scrollbarVars._scrollbar, strActive);\n          setupResponsiveEventListener(_documentElement, [_strMouseTouchMoveEvent, _strMouseTouchUpEvent, _strSelectStartEvent], [documentDragMove, documentMouseTouchUp, documentOnSelectStart]);\n          COMPATIBILITY.rAF()(function () {\n            setupResponsiveEventListener(_documentElement, strClickEvent, stopClickEventPropagation, false, {\n              _capture: true\n            });\n          });\n          if (_msieVersion || !_documentMixed) COMPATIBILITY.prvD(event);\n          COMPATIBILITY.stpP(event);\n        }\n\n        function onTrackMouseTouchDown(event) {\n          if (onMouseTouchDownContinue(event)) {\n            var handleToViewportRatio = scrollbarVars._info._handleLength / Math.round(MATH.min(1, _viewportSize[scrollbarVars._w_h] / _contentScrollSizeCache[scrollbarVars._w_h]) * scrollbarVars._info._trackLength);\n            var scrollDistance = MATH.round(_viewportSize[scrollbarVars._w_h] * handleToViewportRatio);\n            var scrollBaseDuration = 270 * handleToViewportRatio;\n            var scrollFirstIterationDelay = 400 * handleToViewportRatio;\n\n            var trackOffset = scrollbarVars._track.offset()[scrollbarVars._left_top];\n\n            var ctrlKey = event.ctrlKey;\n            var instantScroll = event.shiftKey;\n            var instantScrollTransition = instantScroll && ctrlKey;\n            var isFirstIteration = true;\n            var easing = 'linear';\n            var decreaseScroll;\n            var finishedCondition;\n\n            var scrollActionFinsished = function scrollActionFinsished(transition) {\n              if (_scrollbarsHandlesDefineScrollPos) refreshScrollbarHandleOffset(isHorizontal, transition);\n            };\n\n            var scrollActionInstantFinished = function scrollActionInstantFinished() {\n              scrollActionFinsished();\n              onHandleMouseTouchDownAction(event);\n            };\n\n            var scrollAction = function scrollAction() {\n              if (!_destroyed) {\n                var mouseOffset = (mouseDownOffset - trackOffset) * mouseDownInvertedScale;\n                var handleOffset = scrollbarVarsInfo._handleOffset;\n                var trackLength = scrollbarVarsInfo._trackLength;\n                var handleLength = scrollbarVarsInfo._handleLength;\n                var scrollRange = scrollbarVarsInfo._maxScroll;\n                var currScroll = scrollbarVarsInfo._currentScroll;\n                var scrollDuration = scrollBaseDuration * scrollDurationFactor;\n                var timeoutDelay = isFirstIteration ? MATH.max(scrollFirstIterationDelay, scrollDuration) : scrollDuration;\n                var instantScrollPosition = scrollRange * ((mouseOffset - handleLength / 2) / (trackLength - handleLength)); // 100% * positionPercent\n\n                var rtlIsNormal = _isRTL && isHorizontal && (!_rtlScrollBehavior.i && !_rtlScrollBehavior.n || _normalizeRTLCache);\n                var decreaseScrollCondition = rtlIsNormal ? handleOffset < mouseOffset : handleOffset > mouseOffset;\n                var scrollObj = {};\n                var animationObj = {\n                  easing: easing,\n                  step: function step(now) {\n                    if (_scrollbarsHandlesDefineScrollPos) {\n                      _viewportElement[scroll](now); //https://github.com/jquery/jquery/issues/4340\n\n\n                      refreshScrollbarHandleOffset(isHorizontal, now);\n                    }\n                  }\n                };\n                instantScrollPosition = isFinite(instantScrollPosition) ? instantScrollPosition : 0;\n                instantScrollPosition = _isRTL && isHorizontal && !_rtlScrollBehavior.i ? scrollRange - instantScrollPosition : instantScrollPosition; //_base.scrollStop();\n\n                if (instantScroll) {\n                  _viewportElement[scroll](instantScrollPosition); //scroll instantly to new position\n\n\n                  if (instantScrollTransition) {\n                    //get the scroll position after instant scroll (in case CSS Snap Points are used) to get the correct snapped scroll position\n                    //and the animation stops at the correct point\n                    instantScrollPosition = _viewportElement[scroll](); //scroll back to the position before instant scrolling so animation can be performed\n\n                    _viewportElement[scroll](currScroll);\n\n                    instantScrollPosition = rtlIsNormal && _rtlScrollBehavior.i ? scrollRange - instantScrollPosition : instantScrollPosition;\n                    instantScrollPosition = rtlIsNormal && _rtlScrollBehavior.n ? -instantScrollPosition : instantScrollPosition;\n                    scrollObj[xy] = instantScrollPosition;\n\n                    _base.scroll(scrollObj, extendDeep(animationObj, {\n                      duration: 130,\n                      complete: scrollActionInstantFinished\n                    }));\n                  } else scrollActionInstantFinished();\n                } else {\n                  decreaseScroll = isFirstIteration ? decreaseScrollCondition : decreaseScroll;\n                  finishedCondition = rtlIsNormal ? decreaseScroll ? handleOffset + handleLength >= mouseOffset : handleOffset <= mouseOffset : decreaseScroll ? handleOffset <= mouseOffset : handleOffset + handleLength >= mouseOffset;\n\n                  if (finishedCondition) {\n                    clearTimeout(trackTimeout);\n\n                    _base.scrollStop();\n\n                    trackTimeout = undefined;\n                    scrollActionFinsished(true);\n                  } else {\n                    trackTimeout = setTimeout(scrollAction, timeoutDelay);\n                    scrollObj[xy] = (decreaseScroll ? '-=' : '+=') + scrollDistance;\n\n                    _base.scroll(scrollObj, extendDeep(animationObj, {\n                      duration: scrollDuration\n                    }));\n                  }\n\n                  isFirstIteration = false;\n                }\n              }\n            };\n\n            if (ctrlKey) increaseTrackScrollAmount();\n            mouseDownInvertedScale = getHostElementInvertedScale()[xy];\n            mouseDownOffset = COMPATIBILITY.page(event)[xy];\n            _scrollbarsHandlesDefineScrollPos = !getPreparedScrollbarsOption(strSnapHandle);\n            addClass(_bodyElement, _classNameDragging);\n            addClass(scrollbarVars._track, strActive);\n            addClass(scrollbarVars._scrollbar, strActive);\n            setupResponsiveEventListener(_documentElement, [_strMouseTouchUpEvent, _strKeyDownEvent, _strKeyUpEvent, _strSelectStartEvent], [documentMouseTouchUp, documentKeyDown, documentKeyUp, documentOnSelectStart]);\n            scrollAction();\n            COMPATIBILITY.prvD(event);\n            COMPATIBILITY.stpP(event);\n          }\n        }\n\n        function onTrackMouseTouchEnter(event) {\n          //make sure both scrollbars will stay visible if one scrollbar is hovered if autoHide is \"scroll\" or \"move\".\n          _scrollbarsHandleHovered = true;\n          if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) refreshScrollbarsAutoHide(true);\n        }\n\n        function onTrackMouseTouchLeave(event) {\n          _scrollbarsHandleHovered = false;\n          if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) refreshScrollbarsAutoHide(false);\n        }\n\n        function onScrollbarMouseTouchDown(event) {\n          COMPATIBILITY.stpP(event);\n        }\n\n        addDestroyEventListener(scrollbarVars._handle, _strMouseTouchDownEvent, onHandleMouseTouchDown);\n        addDestroyEventListener(scrollbarVars._track, [_strMouseTouchDownEvent, _strMouseEnter, _strMouseLeave], [onTrackMouseTouchDown, onTrackMouseTouchEnter, onTrackMouseTouchLeave]);\n        addDestroyEventListener(scrollbarVars._scrollbar, _strMouseTouchDownEvent, onScrollbarMouseTouchDown);\n\n        if (_supportTransition) {\n          addDestroyEventListener(scrollbarVars._scrollbar, _strTransitionEndEvent, function (event) {\n            if (event.target !== scrollbarVars._scrollbar[0]) return;\n            refreshScrollbarHandleLength(isHorizontal);\n            refreshScrollbarHandleOffset(isHorizontal);\n          });\n        }\n      }\n      /**\r\n       * Shows or hides the given scrollbar and applied a class name which indicates if the scrollbar is scrollable or not.\r\n       * @param isHorizontal True if the horizontal scrollbar is the target, false if the vertical scrollbar is the target.\r\n       * @param shallBeVisible True if the scrollbar shall be shown, false if hidden.\r\n       * @param canScroll True if the scrollbar is scrollable, false otherwise.\r\n       */\n\n\n      function refreshScrollbarAppearance(isHorizontal, shallBeVisible, canScroll) {\n        var scrollbarHiddenClassName = isHorizontal ? _classNameHostScrollbarHorizontalHidden : _classNameHostScrollbarVerticalHidden;\n        var scrollbarElement = isHorizontal ? _scrollbarHorizontalElement : _scrollbarVerticalElement;\n        addRemoveClass(_hostElement, scrollbarHiddenClassName, !shallBeVisible);\n        addRemoveClass(scrollbarElement, _classNameScrollbarUnusable, !canScroll);\n      }\n      /**\r\n       * Autoshows / autohides both scrollbars with.\r\n       * @param shallBeVisible True if the scrollbars shall be autoshown (only the case if they are hidden by a autohide), false if the shall be auto hidden.\r\n       * @param delayfree True if the scrollbars shall be hidden without a delay, false or undefined otherwise.\r\n       */\n\n\n      function refreshScrollbarsAutoHide(shallBeVisible, delayfree) {\n        clearTimeout(_scrollbarsAutoHideTimeoutId);\n\n        if (shallBeVisible) {\n          //if(_hasOverflowCache.x && _hideOverflowCache.xs)\n          removeClass(_scrollbarHorizontalElement, _classNameScrollbarAutoHidden); //if(_hasOverflowCache.y && _hideOverflowCache.ys)\n\n          removeClass(_scrollbarVerticalElement, _classNameScrollbarAutoHidden);\n        } else {\n          var anyActive;\n          var strActive = 'active';\n\n          var hide = function hide() {\n            if (!_scrollbarsHandleHovered && !_destroyed) {\n              anyActive = _scrollbarHorizontalHandleElement.hasClass(strActive) || _scrollbarVerticalHandleElement.hasClass(strActive);\n              if (!anyActive && (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove || _scrollbarsAutoHideLeave)) addClass(_scrollbarHorizontalElement, _classNameScrollbarAutoHidden);\n              if (!anyActive && (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove || _scrollbarsAutoHideLeave)) addClass(_scrollbarVerticalElement, _classNameScrollbarAutoHidden);\n            }\n          };\n\n          if (_scrollbarsAutoHideDelay > 0 && delayfree !== true) _scrollbarsAutoHideTimeoutId = setTimeout(hide, _scrollbarsAutoHideDelay);else hide();\n        }\n      }\n      /**\r\n       * Refreshes the handle length of the given scrollbar.\r\n       * @param isHorizontal True if the horizontal scrollbar handle shall be refreshed, false if the vertical one shall be refreshed.\r\n       */\n\n\n      function refreshScrollbarHandleLength(isHorizontal) {\n        var handleCSS = {};\n        var scrollbarVars = getScrollbarVars(isHorizontal);\n        var scrollbarVarsInfo = scrollbarVars._info;\n        var digit = 1000000; //get and apply intended handle length\n\n        var handleRatio = MATH.min(1, _viewportSize[scrollbarVars._w_h] / _contentScrollSizeCache[scrollbarVars._w_h]);\n        handleCSS[scrollbarVars._width_height] = MATH.floor(handleRatio * 100 * digit) / digit + '%'; //the last * digit / digit is for flooring to the 4th digit\n\n        if (!nativeOverlayScrollbarsAreActive()) scrollbarVars._handle.css(handleCSS); //measure the handle length to respect min & max length\n\n        scrollbarVarsInfo._handleLength = scrollbarVars._handle[0]['offset' + scrollbarVars._Width_Height];\n        scrollbarVarsInfo._handleLengthRatio = handleRatio;\n      }\n      /**\r\n       * Refreshes the handle offset of the given scrollbar.\r\n       * @param isHorizontal True if the horizontal scrollbar handle shall be refreshed, false if the vertical one shall be refreshed.\r\n       * @param scrollOrTransition The scroll position of the given scrollbar axis to which the handle shall be moved or a boolean which indicates whether a transition shall be applied. If undefined or boolean if the current scroll-offset is taken. (if isHorizontal ? scrollLeft : scrollTop)\r\n       */\n\n\n      function refreshScrollbarHandleOffset(isHorizontal, scrollOrTransition) {\n        var transition = type(scrollOrTransition) == TYPES.b;\n        var transitionDuration = 250;\n        var isRTLisHorizontal = _isRTL && isHorizontal;\n        var scrollbarVars = getScrollbarVars(isHorizontal);\n        var scrollbarVarsInfo = scrollbarVars._info;\n        var strTranslateBrace = 'translate(';\n\n        var strTransform = VENDORS._cssProperty('transform');\n\n        var strTransition = VENDORS._cssProperty('transition');\n\n        var nativeScroll = isHorizontal ? _viewportElement[_strScrollLeft]() : _viewportElement[_strScrollTop]();\n        var currentScroll = scrollOrTransition === undefined || transition ? nativeScroll : scrollOrTransition; //measure the handle length to respect min & max length\n\n        var handleLength = scrollbarVarsInfo._handleLength;\n        var trackLength = scrollbarVars._track[0]['offset' + scrollbarVars._Width_Height];\n        var handleTrackDiff = trackLength - handleLength;\n        var handleCSS = {};\n        var transformOffset;\n        var translateValue; //DONT use the variable '_contentScrollSizeCache[scrollbarVars._w_h]' instead of '_viewportElement[0]['scroll' + scrollbarVars._Width_Height]'\n        // because its a bit behind during the small delay when content size updates\n        //(delay = mutationObserverContentLag, if its 0 then this var could be used)\n\n        var maxScroll = (_viewportElementNative[_strScroll + scrollbarVars._Width_Height] - _viewportElementNative['client' + scrollbarVars._Width_Height]) * (_rtlScrollBehavior.n && isRTLisHorizontal ? -1 : 1); //* -1 if rtl scroll max is negative\n\n        var getScrollRatio = function getScrollRatio(base) {\n          return isNaN(base / maxScroll) ? 0 : MATH.max(0, MATH.min(1, base / maxScroll));\n        };\n\n        var getHandleOffset = function getHandleOffset(scrollRatio) {\n          var offset = handleTrackDiff * scrollRatio;\n          offset = isNaN(offset) ? 0 : offset;\n          offset = isRTLisHorizontal && !_rtlScrollBehavior.i ? trackLength - handleLength - offset : offset;\n          offset = MATH.max(0, offset);\n          return offset;\n        };\n\n        var scrollRatio = getScrollRatio(nativeScroll);\n        var unsnappedScrollRatio = getScrollRatio(currentScroll);\n        var handleOffset = getHandleOffset(unsnappedScrollRatio);\n        var snappedHandleOffset = getHandleOffset(scrollRatio);\n        scrollbarVarsInfo._maxScroll = maxScroll;\n        scrollbarVarsInfo._currentScroll = nativeScroll;\n        scrollbarVarsInfo._currentScrollRatio = scrollRatio;\n\n        if (_supportTransform) {\n          transformOffset = isRTLisHorizontal ? -(trackLength - handleLength - handleOffset) : handleOffset; //in px\n          //transformOffset = (transformOffset / trackLength * 100) * (trackLength / handleLength); //in %\n\n          translateValue = isHorizontal ? strTranslateBrace + transformOffset + 'px, 0)' : strTranslateBrace + '0, ' + transformOffset + 'px)';\n          handleCSS[strTransform] = translateValue; //apply or clear up transition\n\n          if (_supportTransition) handleCSS[strTransition] = transition && MATH.abs(handleOffset - scrollbarVarsInfo._handleOffset) > 1 ? getCSSTransitionString(scrollbarVars._handle) + ', ' + (strTransform + _strSpace + transitionDuration + 'ms') : _strEmpty;\n        } else handleCSS[scrollbarVars._left_top] = handleOffset; //only apply css if offset has changed and overflow exists.\n\n\n        if (!nativeOverlayScrollbarsAreActive()) {\n          scrollbarVars._handle.css(handleCSS); //clear up transition\n\n\n          if (_supportTransform && _supportTransition && transition) {\n            scrollbarVars._handle.one(_strTransitionEndEvent, function () {\n              if (!_destroyed) scrollbarVars._handle.css(strTransition, _strEmpty);\n            });\n          }\n        }\n\n        scrollbarVarsInfo._handleOffset = handleOffset;\n        scrollbarVarsInfo._snappedHandleOffset = snappedHandleOffset;\n        scrollbarVarsInfo._trackLength = trackLength;\n      }\n      /**\r\n       * Refreshes the interactivity of the given scrollbar element.\r\n       * @param isTrack True if the track element is the target, false if the handle element is the target.\r\n       * @param value True for interactivity false for no interactivity.\r\n       */\n\n\n      function refreshScrollbarsInteractive(isTrack, value) {\n        var action = value ? 'removeClass' : 'addClass';\n        var element1 = isTrack ? _scrollbarHorizontalTrackElement : _scrollbarHorizontalHandleElement;\n        var element2 = isTrack ? _scrollbarVerticalTrackElement : _scrollbarVerticalHandleElement;\n        var className = isTrack ? _classNameScrollbarTrackOff : _classNameScrollbarHandleOff;\n        element1[action](className);\n        element2[action](className);\n      }\n      /**\r\n       * Returns a object which is used for fast access for specific variables.\r\n       * @param isHorizontal True if the horizontal scrollbar vars shall be accessed, false if the vertical scrollbar vars shall be accessed.\r\n       * @returns {{wh: string, WH: string, lt: string, _wh: string, _lt: string, t: *, h: *, c: {}, s: *}}\r\n       */\n\n\n      function getScrollbarVars(isHorizontal) {\n        return {\n          _width_height: isHorizontal ? _strWidth : _strHeight,\n          _Width_Height: isHorizontal ? 'Width' : 'Height',\n          _left_top: isHorizontal ? _strLeft : _strTop,\n          _Left_Top: isHorizontal ? 'Left' : 'Top',\n          _x_y: isHorizontal ? _strX : _strY,\n          _X_Y: isHorizontal ? 'X' : 'Y',\n          _w_h: isHorizontal ? 'w' : 'h',\n          _l_t: isHorizontal ? 'l' : 't',\n          _track: isHorizontal ? _scrollbarHorizontalTrackElement : _scrollbarVerticalTrackElement,\n          _handle: isHorizontal ? _scrollbarHorizontalHandleElement : _scrollbarVerticalHandleElement,\n          _scrollbar: isHorizontal ? _scrollbarHorizontalElement : _scrollbarVerticalElement,\n          _info: isHorizontal ? _scrollHorizontalInfo : _scrollVerticalInfo\n        };\n      } //==== Scrollbar Corner ====//\n\n      /**\r\n       * Builds or destroys the scrollbar corner DOM element.\r\n       * @param destroy Indicates whether the DOM shall be build or destroyed.\r\n       */\n\n\n      function setupScrollbarCornerDOM(destroy) {\n        _scrollbarCornerElement = _scrollbarCornerElement || selectOrGenerateDivByClass(_classNameScrollbarCorner, true);\n\n        if (!destroy) {\n          if (!_domExists) {\n            _hostElement.append(_scrollbarCornerElement);\n          }\n        } else {\n          if (_domExists && _initialized) {\n            removeClass(_scrollbarCornerElement.removeAttr(LEXICON.s), _classNamesDynamicDestroy);\n          } else {\n            remove(_scrollbarCornerElement);\n          }\n        }\n      }\n      /**\r\n       * Initializes all scrollbar corner interactivity events.\r\n       */\n\n\n      function setupScrollbarCornerEvents() {\n        var insideIFrame = _windowElementNative.top !== _windowElementNative;\n        var mouseDownPosition = {};\n        var mouseDownSize = {};\n        var mouseDownInvertedScale = {};\n        var reconnectMutationObserver;\n\n        function documentDragMove(event) {\n          if (onMouseTouchDownContinue(event)) {\n            var pageOffset = getCoordinates(event);\n            var hostElementCSS = {};\n            if (_resizeHorizontal || _resizeBoth) hostElementCSS[_strWidth] = mouseDownSize.w + (pageOffset.x - mouseDownPosition.x) * mouseDownInvertedScale.x;\n            if (_resizeVertical || _resizeBoth) hostElementCSS[_strHeight] = mouseDownSize.h + (pageOffset.y - mouseDownPosition.y) * mouseDownInvertedScale.y;\n\n            _hostElement.css(hostElementCSS);\n\n            COMPATIBILITY.stpP(event);\n          } else {\n            documentMouseTouchUp(event);\n          }\n        }\n\n        function documentMouseTouchUp(event) {\n          var eventIsTrusted = event !== undefined;\n          setupResponsiveEventListener(_documentElement, [_strSelectStartEvent, _strMouseTouchMoveEvent, _strMouseTouchUpEvent], [documentOnSelectStart, documentDragMove, documentMouseTouchUp], true);\n          removeClass(_bodyElement, _classNameDragging);\n          if (_scrollbarCornerElement.releaseCapture) _scrollbarCornerElement.releaseCapture();\n\n          if (eventIsTrusted) {\n            if (reconnectMutationObserver) connectMutationObservers();\n\n            _base.update(_strAuto);\n          }\n\n          reconnectMutationObserver = false;\n        }\n\n        function onMouseTouchDownContinue(event) {\n          var originalEvent = event.originalEvent || event;\n          var isTouchEvent = originalEvent.touches !== undefined;\n          return _sleeping || _destroyed ? false : COMPATIBILITY.mBtn(event) === 1 || isTouchEvent;\n        }\n\n        function getCoordinates(event) {\n          return _msieVersion && insideIFrame ? {\n            x: event.screenX,\n            y: event.screenY\n          } : COMPATIBILITY.page(event);\n        }\n\n        addDestroyEventListener(_scrollbarCornerElement, _strMouseTouchDownEvent, function (event) {\n          if (onMouseTouchDownContinue(event) && !_resizeNone) {\n            if (_mutationObserversConnected) {\n              reconnectMutationObserver = true;\n              disconnectMutationObservers();\n            }\n\n            mouseDownPosition = getCoordinates(event);\n            mouseDownSize.w = _hostElementNative[LEXICON.oW] - (!_isBorderBox ? _paddingX : 0);\n            mouseDownSize.h = _hostElementNative[LEXICON.oH] - (!_isBorderBox ? _paddingY : 0);\n            mouseDownInvertedScale = getHostElementInvertedScale();\n            setupResponsiveEventListener(_documentElement, [_strSelectStartEvent, _strMouseTouchMoveEvent, _strMouseTouchUpEvent], [documentOnSelectStart, documentDragMove, documentMouseTouchUp]);\n            addClass(_bodyElement, _classNameDragging);\n            if (_scrollbarCornerElement.setCapture) _scrollbarCornerElement.setCapture();\n            COMPATIBILITY.prvD(event);\n            COMPATIBILITY.stpP(event);\n          }\n        });\n      } //==== Utils ====//\n\n      /**\r\n       * Calls the callback with the given name. The Context of this callback is always _base (this).\r\n       * @param name The name of the target which shall be called.\r\n       * @param args The args with which the callback shall be called.\r\n       * @param dependent Boolean which decides whether the callback shall be fired, undefined is like a \"true\" value.\r\n       */\n\n\n      function dispatchCallback(name, args, dependent) {\n        if (dependent === false) return;\n\n        if (_initialized) {\n          var callback = _currentPreparedOptions.callbacks[name];\n          var extensionOnName = name;\n          var ext;\n          if (extensionOnName.substr(0, 2) === 'on') extensionOnName = extensionOnName.substr(2, 1).toLowerCase() + extensionOnName.substr(3);\n          if (type(callback) == TYPES.f) callback.call(_base, args);\n          each(_extensions, function () {\n            ext = this;\n            if (type(ext.on) == TYPES.f) ext.on(extensionOnName, args);\n          });\n        } else if (!_destroyed) _callbacksInitQeueue.push({\n          n: name,\n          a: args\n        });\n      }\n      /**\r\n       * Sets the \"top, right, bottom, left\" properties, with a given prefix, of the given css object.\r\n       * @param targetCSSObject The css object to which the values shall be applied.\r\n       * @param prefix The prefix of the \"top, right, bottom, left\" css properties. (example: 'padding-' is a valid prefix)\r\n       * @param values A array of values which shall be applied to the \"top, right, bottom, left\" -properties. The array order is [top, right, bottom, left].\r\n       * If this argument is undefined the value '' (empty string) will be applied to all properties.\r\n       */\n\n\n      function setTopRightBottomLeft(targetCSSObject, prefix, values) {\n        prefix = prefix || _strEmpty;\n        values = values || [_strEmpty, _strEmpty, _strEmpty, _strEmpty];\n        targetCSSObject[prefix + _strTop] = values[0];\n        targetCSSObject[prefix + _strRight] = values[1];\n        targetCSSObject[prefix + _strBottom] = values[2];\n        targetCSSObject[prefix + _strLeft] = values[3];\n      }\n      /**\r\n       * Gets the \"top, right, bottom, left\" CSS properties of the CSS property with the given prefix from the host element.\r\n       * @param prefix The prefix of the \"top, right, bottom, left\" css properties. (example: 'padding-' is a valid prefix)\r\n       * @param suffix The suffix of the \"top, right, bottom, left\" css properties. (example: 'border-' is a valid prefix with '-width' is a valid suffix)\r\n       * @param zeroX True if the x axis shall be 0.\r\n       * @param zeroY True if the y axis shall be 0.\r\n       * @returns {{}} The object which contains the numbers of the read CSS properties.\r\n       */\n\n\n      function getTopRightBottomLeftHost(prefix, suffix, zeroX, zeroY) {\n        suffix = suffix || _strEmpty;\n        prefix = prefix || _strEmpty;\n        return {\n          t: zeroY ? 0 : parseToZeroOrNumber(_hostElement.css(prefix + _strTop + suffix)),\n          r: zeroX ? 0 : parseToZeroOrNumber(_hostElement.css(prefix + _strRight + suffix)),\n          b: zeroY ? 0 : parseToZeroOrNumber(_hostElement.css(prefix + _strBottom + suffix)),\n          l: zeroX ? 0 : parseToZeroOrNumber(_hostElement.css(prefix + _strLeft + suffix))\n        };\n      }\n      /**\r\n       * Returns the computed CSS transition string from the given element.\r\n       * @param element The element from which the transition string shall be returned.\r\n       * @returns {string} The CSS transition string from the given element.\r\n       */\n\n\n      function getCSSTransitionString(element) {\n        var transitionStr = VENDORS._cssProperty('transition');\n\n        var assembledValue = element.css(transitionStr);\n        if (assembledValue) return assembledValue;\n        var regExpString = '\\\\s*(' + '([^,(]+(\\\\(.+?\\\\))?)+' + ')[\\\\s,]*';\n        var regExpMain = new RegExp(regExpString);\n        var regExpValidate = new RegExp('^(' + regExpString + ')+$');\n        var properties = 'property duration timing-function delay'.split(' ');\n        var result = [];\n        var strResult;\n        var valueArray;\n        var i = 0;\n        var j;\n\n        var splitCssStyleByComma = function splitCssStyleByComma(str) {\n          strResult = [];\n          if (!str.match(regExpValidate)) return str;\n\n          while (str.match(regExpMain)) {\n            strResult.push(RegExp.$1);\n            str = str.replace(regExpMain, _strEmpty);\n          }\n\n          return strResult;\n        };\n\n        for (; i < properties[LEXICON.l]; i++) {\n          valueArray = splitCssStyleByComma(element.css(transitionStr + '-' + properties[i]));\n\n          for (j = 0; j < valueArray[LEXICON.l]; j++) {\n            result[j] = (result[j] ? result[j] + _strSpace : _strEmpty) + valueArray[j];\n          }\n        }\n\n        return result.join(', ');\n      }\n      /**\r\n       * Generates a Regular Expression which matches with a string which starts with 'os-host'.\r\n       * @param {boolean} withCurrClassNameOption The Regular Expression also matches if the string is the current ClassName option (multiple values splitted by space possible).\r\n       * @param {boolean} withOldClassNameOption The Regular Expression also matches if the string is the old ClassName option (multiple values splitted by space possible).\r\n       */\n\n\n      function createHostClassNameRegExp(withCurrClassNameOption, withOldClassNameOption) {\n        var i;\n        var split;\n        var appendix;\n\n        var appendClasses = function appendClasses(classes, condition) {\n          appendix = '';\n\n          if (condition && typeof classes == TYPES.s) {\n            split = classes.split(_strSpace);\n\n            for (i = 0; i < split[LEXICON.l]; i++) {\n              appendix += '|' + split[i] + '$';\n            } // split[i].replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&') for escaping regex characters\n\n          }\n\n          return appendix;\n        };\n\n        return new RegExp('(^' + _classNameHostElement + '([-_].+|)$)' + appendClasses(_classNameCache, withCurrClassNameOption) + appendClasses(_oldClassName, withOldClassNameOption), 'g');\n      }\n      /**\r\n       * Calculates the host-elements inverted scale. (invertedScale = 1 / scale)\r\n       * @returns {{x: number, y: number}} The scale of the host-element.\r\n       */\n\n\n      function getHostElementInvertedScale() {\n        var rect = _paddingElementNative[LEXICON.bCR]();\n\n        return {\n          x: _supportTransform ? 1 / (MATH.round(rect.width) / _paddingElementNative[LEXICON.oW]) || 1 : 1,\n          y: _supportTransform ? 1 / (MATH.round(rect.height) / _paddingElementNative[LEXICON.oH]) || 1 : 1\n        };\n      }\n      /**\r\n       * Checks whether the given object is a HTMLElement.\r\n       * @param o The object which shall be checked.\r\n       * @returns {boolean} True the given object is a HTMLElement, false otherwise.\r\n       */\n\n\n      function isHTMLElement(o) {\n        var strOwnerDocument = 'ownerDocument';\n        var strHTMLElement = 'HTMLElement';\n        var wnd = o && o[strOwnerDocument] ? o[strOwnerDocument].parentWindow || window : window;\n        return typeof wnd[strHTMLElement] == TYPES.o ? o instanceof wnd[strHTMLElement] : //DOM2\n        o && typeof o == TYPES.o && o !== null && o.nodeType === 1 && typeof o.nodeName == TYPES.s;\n      }\n      /**\r\n       * Compares 2 arrays and returns the differences between them as a array.\r\n       * @param a1 The first array which shall be compared.\r\n       * @param a2 The second array which shall be compared.\r\n       * @returns {Array} The differences between the two arrays.\r\n       */\n\n\n      function getArrayDifferences(a1, a2) {\n        var a = [];\n        var diff = [];\n        var i;\n        var k;\n\n        for (i = 0; i < a1.length; i++) {\n          a[a1[i]] = true;\n        }\n\n        for (i = 0; i < a2.length; i++) {\n          if (a[a2[i]]) delete a[a2[i]];else a[a2[i]] = true;\n        }\n\n        for (k in a) {\n          diff.push(k);\n        }\n\n        return diff;\n      }\n      /**\r\n       * Returns Zero or the number to which the value can be parsed.\r\n       * @param value The value which shall be parsed.\r\n       * @param toFloat Indicates whether the number shall be parsed to a float.\r\n       */\n\n\n      function parseToZeroOrNumber(value, toFloat) {\n        var num = toFloat ? parseFloat(value) : parseInt(value, 10);\n        return isNaN(num) ? 0 : num;\n      }\n      /**\r\n       * Gets several information of the textarea and returns them as a object or undefined if the browser doesn't support it.\r\n       * @returns {{cursorRow: Number, cursorCol, rows: Number, cols: number, wRow: number, pos: number, max : number}} or undefined if not supported.\r\n       */\n\n\n      function getTextareaInfo() {\n        //read needed values\n        var textareaCursorPosition = _targetElementNative.selectionStart;\n        if (textareaCursorPosition === undefined) return;\n\n        var textareaValue = _targetElement.val();\n\n        var textareaLength = textareaValue[LEXICON.l];\n        var textareaRowSplit = textareaValue.split('\\n');\n        var textareaLastRow = textareaRowSplit[LEXICON.l];\n        var textareaCurrentCursorRowSplit = textareaValue.substr(0, textareaCursorPosition).split('\\n');\n        var widestRow = 0;\n        var textareaLastCol = 0;\n        var cursorRow = textareaCurrentCursorRowSplit[LEXICON.l];\n        var cursorCol = textareaCurrentCursorRowSplit[textareaCurrentCursorRowSplit[LEXICON.l] - 1][LEXICON.l];\n        var rowCols;\n        var i; //get widest Row and the last column of the textarea\n\n        for (i = 0; i < textareaRowSplit[LEXICON.l]; i++) {\n          rowCols = textareaRowSplit[i][LEXICON.l];\n\n          if (rowCols > textareaLastCol) {\n            widestRow = i + 1;\n            textareaLastCol = rowCols;\n          }\n        }\n\n        return {\n          _cursorRow: cursorRow,\n          //cursorRow\n          _cursorColumn: cursorCol,\n          //cursorCol\n          _rows: textareaLastRow,\n          //rows\n          _columns: textareaLastCol,\n          //cols\n          _widestRow: widestRow,\n          //wRow\n          _cursorPosition: textareaCursorPosition,\n          //pos\n          _cursorMax: textareaLength //max\n\n        };\n      }\n      /**\r\n       * Determines whether native overlay scrollbars are active.\r\n       * @returns {boolean} True if native overlay scrollbars are active, false otherwise.\r\n       */\n\n\n      function nativeOverlayScrollbarsAreActive() {\n        return _ignoreOverlayScrollbarHidingCache && _nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.y;\n      }\n      /**\r\n       * Gets the element which is used to measure the content size.\r\n       * @returns {*} TextareaCover if target element is textarea else the ContentElement.\r\n       */\n\n\n      function getContentMeasureElement() {\n        return _isTextarea ? _textareaCoverElement[0] : _contentElementNative;\n      }\n      /**\r\n       * Generates a string which represents a HTML div with the given classes or attributes.\r\n       * @param classesOrAttrs The class of the div as string or a object which represents the attributes of the div. (The class attribute can also be written as \"className\".)\r\n       * @param content The content of the div as string.\r\n       * @returns {string} The concated string which represents a HTML div and its content.\r\n       */\n\n\n      function generateDiv(classesOrAttrs, content) {\n        return '<div ' + (classesOrAttrs ? type(classesOrAttrs) == TYPES.s ? 'class=\"' + classesOrAttrs + '\"' : function () {\n          var key;\n          var attrs = _strEmpty;\n\n          if (FRAMEWORK.isPlainObject(classesOrAttrs)) {\n            for (key in classesOrAttrs) {\n              attrs += (key === 'c' ? 'class' : key) + '=\"' + classesOrAttrs[key] + '\" ';\n            }\n          }\n\n          return attrs;\n        }() : _strEmpty) + '>' + (content || _strEmpty) + '</div>';\n      }\n      /**\r\n       * Selects or generates a div with the given class attribute.\r\n       * @param className The class names (divided by spaces) of the div which shall be selected or generated.\r\n       * @param selectParentOrOnlyChildren The parent element from which of the element shall be selected. (if undefined or boolean its hostElement)\r\n       * If its a boolean it decides whether only the children of the host element shall be selected.\r\n       * @returns {*} The generated or selected element.\r\n       */\n\n\n      function selectOrGenerateDivByClass(className, selectParentOrOnlyChildren) {\n        var onlyChildren = type(selectParentOrOnlyChildren) == TYPES.b;\n        var selectParent = onlyChildren ? _hostElement : selectParentOrOnlyChildren || _hostElement;\n        return _domExists && !selectParent[LEXICON.l] ? null : _domExists ? selectParent[onlyChildren ? 'children' : 'find'](_strDot + className.replace(/\\s/g, _strDot)).eq(0) : FRAMEWORK(generateDiv(className));\n      }\n      /**\r\n       * Gets the value of the given property from the given object.\r\n       * @param obj The object from which the property value shall be got.\r\n       * @param path The property of which the value shall be got.\r\n       * @returns {*} Returns the value of the searched property or undefined of the property wasn't found.\r\n       */\n\n\n      function getObjectPropVal(obj, path) {\n        var splits = path.split(_strDot);\n        var i = 0;\n        var val;\n\n        for (; i < splits.length; i++) {\n          if (!obj[LEXICON.hOP](splits[i])) return;\n          val = obj[splits[i]];\n          if (i < splits.length && type(val) == TYPES.o) obj = val;\n        }\n\n        return val;\n      }\n      /**\r\n       * Sets the value of the given property from the given object.\r\n       * @param obj The object from which the property value shall be set.\r\n       * @param path The property of which the value shall be set.\r\n       * @param val The value of the property which shall be set.\r\n       */\n\n\n      function setObjectPropVal(obj, path, val) {\n        var splits = path.split(_strDot);\n        var splitsLength = splits.length;\n        var i = 0;\n        var extendObj = {};\n        var extendObjRoot = extendObj;\n\n        for (; i < splitsLength; i++) {\n          extendObj = extendObj[splits[i]] = i + 1 < splitsLength ? {} : val;\n        }\n\n        FRAMEWORK.extend(obj, extendObjRoot, true);\n      }\n      /**\t\r\n       * Runs a action for each selector inside the updateOnLoad option.\t\r\n       * @param {Function} action The action for each updateOnLoad selector, the arguments the function takes is the index and the value (the selector).\t\r\n       */\n\n\n      function eachUpdateOnLoad(action) {\n        var updateOnLoad = _currentPreparedOptions.updateOnLoad;\n        updateOnLoad = type(updateOnLoad) == TYPES.s ? updateOnLoad.split(_strSpace) : updateOnLoad;\n\n        if (COMPATIBILITY.isA(updateOnLoad) && !_destroyed) {\n          each(updateOnLoad, action);\n        }\n      } //==== Utils Cache ====//\n\n      /**\r\n       * Compares two values or objects and returns true if they aren't equal.\r\n       * @param current The first value or object which shall be compared.\r\n       * @param cache The second value or object which shall be compared.\r\n       * @param force If true the returned value is always true.\r\n       * @returns {boolean} True if both values or objects aren't equal or force is true, false otherwise.\r\n       */\n\n\n      function checkCache(current, cache, force) {\n        if (force) return force;\n\n        if (type(current) == TYPES.o && type(cache) == TYPES.o) {\n          for (var prop in current) {\n            if (prop !== 'c') {\n              if (current[LEXICON.hOP](prop) && cache[LEXICON.hOP](prop)) {\n                if (checkCache(current[prop], cache[prop])) return true;\n              } else {\n                return true;\n              }\n            }\n          }\n        } else {\n          return current !== cache;\n        }\n\n        return false;\n      } //==== Shortcuts ====//\n\n      /**\r\n       * jQuery extend method shortcut with a appended \"true\" as first argument.\r\n       */\n\n\n      function extendDeep() {\n        return FRAMEWORK.extend.apply(this, [true].concat([].slice.call(arguments)));\n      }\n      /**\r\n       * jQuery addClass method shortcut.\r\n       */\n\n\n      function addClass(el, classes) {\n        return _frameworkProto.addClass.call(el, classes);\n      }\n      /**\r\n       * jQuery removeClass method shortcut.\r\n       */\n\n\n      function removeClass(el, classes) {\n        return _frameworkProto.removeClass.call(el, classes);\n      }\n      /**\r\n       * Adds or removes the given classes dependent on the boolean value. True for add, false for remove.\r\n       */\n\n\n      function addRemoveClass(el, classes, doAdd) {\n        return doAdd ? addClass(el, classes) : removeClass(el, classes);\n      }\n      /**\r\n       * jQuery remove method shortcut.\r\n       */\n\n\n      function remove(el) {\n        return _frameworkProto.remove.call(el);\n      }\n      /**\r\n       * Finds the first child element with the given selector of the given element.\r\n       * @param el The root element from which the selector shall be valid.\r\n       * @param selector The selector of the searched element.\r\n       * @returns {*} The first element which is a child of the given element and matches the givens selector.\r\n       */\n\n\n      function findFirst(el, selector) {\n        return _frameworkProto.find.call(el, selector).eq(0);\n      } //==== API ====//\n\n      /**\r\n       * Puts the instance to sleep. It wont respond to any changes in the DOM and won't update. Scrollbar Interactivity is also disabled as well as the resize handle.\r\n       * This behavior can be reset by calling the update method.\r\n       */\n\n\n      _base.sleep = function () {\n        _sleeping = true;\n      };\n      /**\r\n       * Updates the plugin and DOM to the current options.\r\n       * This method should only be called if a update is 100% required.\r\n       * @param force True if every property shall be updated and the cache shall be ignored.\r\n       * !INTERNAL USAGE! : force can be a string \"auto\", \"sync\" or \"zoom\" too\r\n       * if \"auto\" then before a real update the content size and host element attributes gets checked, and if they changed only then the update method will be called.\r\n       * if \"sync\" then the async update process (MutationObserver or UpdateLoop) gets synchronized and a corresponding update takes place if one was needed due to pending changes.\r\n       * if \"zoom\" then a update takes place where it's assumed that content and host size changed\r\n       * @returns {boolean|undefined} \r\n       * If force is \"sync\" then a boolean is returned which indicates whether a update was needed due to pending changes.\r\n       * If force is \"auto\" then a boolean is returned whether a update was needed due to attribute or size changes.\r\n       * undefined otherwise.\r\n       */\n\n\n      _base.update = function (force) {\n        if (_destroyed) return;\n        var attrsChanged;\n        var contentSizeC;\n        var isString = type(force) == TYPES.s;\n        var doUpdateAuto;\n        var mutHost;\n        var mutContent;\n\n        if (isString) {\n          if (force === _strAuto) {\n            attrsChanged = meaningfulAttrsChanged();\n            contentSizeC = updateAutoContentSizeChanged();\n            doUpdateAuto = attrsChanged || contentSizeC;\n\n            if (doUpdateAuto) {\n              update({\n                _contentSizeChanged: contentSizeC,\n                _changedOptions: _initialized ? undefined : _currentPreparedOptions\n              });\n            }\n          } else if (force === _strSync) {\n            if (_mutationObserversConnected) {\n              mutHost = _mutationObserverHostCallback(_mutationObserverHost.takeRecords());\n              mutContent = _mutationObserverContentCallback(_mutationObserverContent.takeRecords());\n            } else {\n              mutHost = _base.update(_strAuto);\n            }\n          } else if (force === 'zoom') {\n            update({\n              _hostSizeChanged: true,\n              _contentSizeChanged: true\n            });\n          }\n        } else {\n          force = _sleeping || force;\n          _sleeping = false;\n          if (!_base.update(_strSync) || force) update({\n            _force: force\n          });\n        }\n\n        updateElementsOnLoad();\n        return doUpdateAuto || mutHost || mutContent;\n      };\n      /**\r\n       Gets or sets the current options. The update method will be called automatically if new options were set.\r\n       * @param newOptions If new options are given, then the new options will be set, if new options aren't given (undefined or a not a plain object) then the current options will be returned.\r\n       * @param value If new options is a property path string, then this value will be used to set the option to which the property path string leads.\r\n       * @returns {*}\r\n       */\n\n\n      _base.options = function (newOptions, value) {\n        var option = {};\n        var changedOps; //return current options if newOptions are undefined or empty\n\n        if (FRAMEWORK.isEmptyObject(newOptions) || !FRAMEWORK.isPlainObject(newOptions)) {\n          if (type(newOptions) == TYPES.s) {\n            if (arguments.length > 1) {\n              setObjectPropVal(option, newOptions, value);\n              changedOps = setOptions(option);\n            } else return getObjectPropVal(_currentOptions, newOptions);\n          } else return _currentOptions;\n        } else {\n          changedOps = setOptions(newOptions);\n        }\n\n        if (!FRAMEWORK.isEmptyObject(changedOps)) {\n          update({\n            _changedOptions: changedOps\n          });\n        }\n      };\n      /**\r\n       * Restore the DOM, disconnects all observers, remove all resize observers and put the instance to sleep.\r\n       */\n\n\n      _base.destroy = function () {\n        if (_destroyed) return; //remove this instance from auto update loop\n\n        autoUpdateLoop.remove(_base); //disconnect all mutation observers\n\n        disconnectMutationObservers(); //remove all resize observers\n\n        setupResizeObserver(_sizeObserverElement);\n        setupResizeObserver(_sizeAutoObserverElement); //remove all extensions\n\n        for (var extName in _extensions) {\n          _base.removeExt(extName);\n        } //remove all 'destroy' events\n\n\n        while (_destroyEvents[LEXICON.l] > 0) {\n          _destroyEvents.pop()();\n        } //remove all events from host element\n\n\n        setupHostMouseTouchEvents(true); //remove all helper / detection elements\n\n        if (_contentGlueElement) remove(_contentGlueElement);\n        if (_contentArrangeElement) remove(_contentArrangeElement);\n        if (_sizeAutoObserverAdded) remove(_sizeAutoObserverElement); //remove all generated DOM\n\n        setupScrollbarsDOM(true);\n        setupScrollbarCornerDOM(true);\n        setupStructureDOM(true); //remove all generated image load events\n\n        for (var i = 0; i < _updateOnLoadElms[LEXICON.l]; i++) {\n          FRAMEWORK(_updateOnLoadElms[i]).off(_updateOnLoadEventName, updateOnLoadCallback);\n        }\n\n        _updateOnLoadElms = undefined;\n        _destroyed = true;\n        _sleeping = true; //remove this instance from the instances list\n\n        INSTANCES(pluginTargetElement, 0);\n        dispatchCallback('onDestroyed'); //remove all properties and methods\n        //for (var property in _base)\n        //    delete _base[property];\n        //_base = undefined;\n      };\n      /**\r\n       * Scrolls to a given position or element.\r\n       * @param coordinates\r\n       * 1. Can be \"coordinates\" which looks like:\r\n       *    { x : ?, y : ? } OR          Object with x and y properties\r\n       *    { left : ?, top : ? } OR     Object with left and top properties\r\n       *    { l : ?, t : ? } OR          Object with l and t properties\r\n       *    [ ?, ? ] OR                  Array where the first two element are the coordinates (first is x, second is y)\r\n       *    ?                            A single value which stays for both axis\r\n       *    A value can be a number, a string or a calculation.\r\n       *\r\n       *    Operators:\r\n       *    [NONE]  The current scroll will be overwritten by the value.\r\n       *    '+='    The value will be added to the current scroll offset\r\n       *    '-='    The value will be subtracted from the current scroll offset\r\n       *    '*='    The current scroll wil be multiplicated by the value.\r\n       *    '/='    The current scroll wil be divided by the value.\r\n       *\r\n       *    Units:\r\n       *    [NONE]  The value is the final scroll amount.                   final = (value * 1)\r\n       *    'px'    Same as none\r\n       *    '%'     The value is dependent on the current scroll value.     final = ((currentScrollValue / 100) * value)\r\n       *    'vw'    The value is multiplicated by the viewport width.       final = (value * viewportWidth)\r\n       *    'vh'    The value is multiplicated by the viewport height.      final = (value * viewportHeight)\r\n       *\r\n       *    example final values:\r\n       *    200, '200px', '50%', '1vw', '1vh', '+=200', '/=1vw', '*=2px', '-=5vh', '+=33%', '+= 50% - 2px', '-= 1vw - 50%'\r\n       *\r\n       * 2. Can be a HTML or jQuery element:\r\n       *    The final scroll offset is the offset (without margin) of the given HTML / jQuery element.\r\n       *\r\n       * 3. Can be a object with a HTML or jQuery element with additional settings:\r\n       *    {\r\n       *      el : [HTMLElement, jQuery element],             MUST be specified, else this object isn't valid.\r\n       *      scroll : [string, array, object],               Default value is 'always'.\r\n       *      block : [string, array, object],                Default value is 'begin'.\r\n       *      margin : [number, boolean, array, object]       Default value is false.\r\n       *    }\r\n       *\r\n       *    Possible scroll settings are:\r\n       *    'always'      Scrolls always.\r\n       *    'ifneeded'    Scrolls only if the element isnt fully in view.\r\n       *    'never'       Scrolls never.\r\n       *\r\n       *    Possible block settings are:\r\n       *    'begin'   Both axis shall be docked to the \"begin\" edge. - The element will be docked to the top and left edge of the viewport.\r\n       *    'end'     Both axis shall be docked to the \"end\" edge. - The element will be docked to the bottom and right edge of the viewport. (If direction is RTL to the bottom and left edge.)\r\n       *    'center'  Both axis shall be docked to \"center\". - The element will be centered in the viewport.\r\n       *    'nearest' The element will be docked to the nearest edge(s).\r\n       *\r\n       *    Possible margin settings are: -- The actual margin of the element wont be affect, this option affects only the final scroll offset.\r\n       *    [BOOLEAN]                                         If true the css margin of the element will be used, if false no margin will be used.\r\n       *    [NUMBER]                                          The margin will be used for all edges.\r\n       *\r\n       * @param duration The duration of the scroll animation, OR a jQuery animation configuration object.\r\n       * @param easing The animation easing.\r\n       * @param complete The animation complete callback.\r\n       * @returns {{\r\n       *   position: {x: number, y: number},\r\n       *   ratio: {x: number, y: number},\r\n       *   max: {x: number, y: number},\r\n       *   handleOffset: {x: number, y: number},\r\n       *   handleLength: {x: number, y: number},\r\n       *   handleLengthRatio: {x: number, y: number}, t\r\n       *   rackLength: {x: number, y: number},\r\n       *   isRTL: boolean,\r\n       *   isRTLNormalized: boolean\r\n       *  }}\r\n       */\n\n\n      _base.scroll = function (coordinates, duration, easing, complete) {\n        if (arguments.length === 0 || coordinates === undefined) {\n          var infoX = _scrollHorizontalInfo;\n          var infoY = _scrollVerticalInfo;\n          var normalizeInvert = _normalizeRTLCache && _isRTL && _rtlScrollBehavior.i;\n          var normalizeNegate = _normalizeRTLCache && _isRTL && _rtlScrollBehavior.n;\n          var scrollX = infoX._currentScroll;\n          var scrollXRatio = infoX._currentScrollRatio;\n          var maxScrollX = infoX._maxScroll;\n          scrollXRatio = normalizeInvert ? 1 - scrollXRatio : scrollXRatio;\n          scrollX = normalizeInvert ? maxScrollX - scrollX : scrollX;\n          scrollX *= normalizeNegate ? -1 : 1;\n          maxScrollX *= normalizeNegate ? -1 : 1;\n          return {\n            position: {\n              x: scrollX,\n              y: infoY._currentScroll\n            },\n            ratio: {\n              x: scrollXRatio,\n              y: infoY._currentScrollRatio\n            },\n            max: {\n              x: maxScrollX,\n              y: infoY._maxScroll\n            },\n            handleOffset: {\n              x: infoX._handleOffset,\n              y: infoY._handleOffset\n            },\n            handleLength: {\n              x: infoX._handleLength,\n              y: infoY._handleLength\n            },\n            handleLengthRatio: {\n              x: infoX._handleLengthRatio,\n              y: infoY._handleLengthRatio\n            },\n            trackLength: {\n              x: infoX._trackLength,\n              y: infoY._trackLength\n            },\n            snappedHandleOffset: {\n              x: infoX._snappedHandleOffset,\n              y: infoY._snappedHandleOffset\n            },\n            isRTL: _isRTL,\n            isRTLNormalized: _normalizeRTLCache\n          };\n        }\n\n        _base.update(_strSync);\n\n        var normalizeRTL = _normalizeRTLCache;\n        var coordinatesXAxisProps = [_strX, _strLeft, 'l'];\n        var coordinatesYAxisProps = [_strY, _strTop, 't'];\n        var coordinatesOperators = ['+=', '-=', '*=', '/='];\n        var durationIsObject = type(duration) == TYPES.o;\n        var completeCallback = durationIsObject ? duration.complete : complete;\n        var i;\n        var finalScroll = {};\n        var specialEasing = {};\n        var doScrollLeft;\n        var doScrollTop;\n        var animationOptions;\n        var strEnd = 'end';\n        var strBegin = 'begin';\n        var strCenter = 'center';\n        var strNearest = 'nearest';\n        var strAlways = 'always';\n        var strNever = 'never';\n        var strIfNeeded = 'ifneeded';\n        var strLength = LEXICON.l;\n        var settingsAxis;\n        var settingsScroll;\n        var settingsBlock;\n        var settingsMargin;\n        var finalElement;\n        var elementObjSettingsAxisValues = [_strX, _strY, 'xy', 'yx'];\n        var elementObjSettingsBlockValues = [strBegin, strEnd, strCenter, strNearest];\n        var elementObjSettingsScrollValues = [strAlways, strNever, strIfNeeded];\n        var coordinatesIsElementObj = coordinates[LEXICON.hOP]('el');\n        var possibleElement = coordinatesIsElementObj ? coordinates.el : coordinates;\n        var possibleElementIsJQuery = possibleElement instanceof FRAMEWORK || JQUERY ? possibleElement instanceof JQUERY : false;\n        var possibleElementIsHTMLElement = possibleElementIsJQuery ? false : isHTMLElement(possibleElement);\n\n        var updateScrollbarInfos = function updateScrollbarInfos() {\n          if (doScrollLeft) refreshScrollbarHandleOffset(true);\n          if (doScrollTop) refreshScrollbarHandleOffset(false);\n        };\n\n        var proxyCompleteCallback = type(completeCallback) != TYPES.f ? undefined : function () {\n          updateScrollbarInfos();\n          completeCallback();\n        };\n\n        function checkSettingsStringValue(currValue, allowedValues) {\n          for (i = 0; i < allowedValues[strLength]; i++) {\n            if (currValue === allowedValues[i]) return true;\n          }\n\n          return false;\n        }\n\n        function getRawScroll(isX, coordinates) {\n          var coordinateProps = isX ? coordinatesXAxisProps : coordinatesYAxisProps;\n          coordinates = type(coordinates) == TYPES.s || type(coordinates) == TYPES.n ? [coordinates, coordinates] : coordinates;\n          if (COMPATIBILITY.isA(coordinates)) return isX ? coordinates[0] : coordinates[1];else if (type(coordinates) == TYPES.o) {\n            //decides RTL normalization \"hack\" with .n\n            //normalizeRTL = type(coordinates.n) == TYPES.b ? coordinates.n : normalizeRTL; \n            for (i = 0; i < coordinateProps[strLength]; i++) {\n              if (coordinateProps[i] in coordinates) return coordinates[coordinateProps[i]];\n            }\n          }\n        }\n\n        function getFinalScroll(isX, rawScroll) {\n          var isString = type(rawScroll) == TYPES.s;\n          var operator;\n          var amount;\n          var scrollInfo = isX ? _scrollHorizontalInfo : _scrollVerticalInfo;\n          var currScroll = scrollInfo._currentScroll;\n          var maxScroll = scrollInfo._maxScroll;\n          var mult = ' * ';\n          var finalValue;\n          var isRTLisX = _isRTL && isX;\n          var normalizeShortcuts = isRTLisX && _rtlScrollBehavior.n && !normalizeRTL;\n          var strReplace = 'replace';\n          var evalFunc = eval;\n          var possibleOperator;\n\n          if (isString) {\n            //check operator\n            if (rawScroll[strLength] > 2) {\n              possibleOperator = rawScroll.substr(0, 2);\n              if (inArray(possibleOperator, coordinatesOperators) > -1) operator = possibleOperator;\n            } //calculate units and shortcuts\n\n\n            rawScroll = operator ? rawScroll.substr(2) : rawScroll;\n            rawScroll = rawScroll[strReplace](/min/g, 0) //'min' = 0%\n            [strReplace](/</g, 0) //'<'   = 0%\n            [strReplace](/max/g, (normalizeShortcuts ? '-' : _strEmpty) + _strHundredPercent) //'max' = 100%\n            [strReplace](/>/g, (normalizeShortcuts ? '-' : _strEmpty) + _strHundredPercent) //'>'   = 100%\n            [strReplace](/px/g, _strEmpty)[strReplace](/%/g, mult + maxScroll * (isRTLisX && _rtlScrollBehavior.n ? -1 : 1) / 100.0)[strReplace](/vw/g, mult + _viewportSize.w)[strReplace](/vh/g, mult + _viewportSize.h);\n            amount = parseToZeroOrNumber(isNaN(rawScroll) ? parseToZeroOrNumber(evalFunc(rawScroll), true).toFixed() : rawScroll);\n          } else {\n            amount = rawScroll;\n          }\n\n          if (amount !== undefined && !isNaN(amount) && type(amount) == TYPES.n) {\n            var normalizeIsRTLisX = normalizeRTL && isRTLisX;\n            var operatorCurrScroll = currScroll * (normalizeIsRTLisX && _rtlScrollBehavior.n ? -1 : 1);\n            var invert = normalizeIsRTLisX && _rtlScrollBehavior.i;\n            var negate = normalizeIsRTLisX && _rtlScrollBehavior.n;\n            operatorCurrScroll = invert ? maxScroll - operatorCurrScroll : operatorCurrScroll;\n\n            switch (operator) {\n              case '+=':\n                finalValue = operatorCurrScroll + amount;\n                break;\n\n              case '-=':\n                finalValue = operatorCurrScroll - amount;\n                break;\n\n              case '*=':\n                finalValue = operatorCurrScroll * amount;\n                break;\n\n              case '/=':\n                finalValue = operatorCurrScroll / amount;\n                break;\n\n              default:\n                finalValue = amount;\n                break;\n            }\n\n            finalValue = invert ? maxScroll - finalValue : finalValue;\n            finalValue *= negate ? -1 : 1;\n            finalValue = isRTLisX && _rtlScrollBehavior.n ? MATH.min(0, MATH.max(maxScroll, finalValue)) : MATH.max(0, MATH.min(maxScroll, finalValue));\n          }\n\n          return finalValue === currScroll ? undefined : finalValue;\n        }\n\n        function getPerAxisValue(value, valueInternalType, defaultValue, allowedValues) {\n          var resultDefault = [defaultValue, defaultValue];\n          var valueType = type(value);\n          var valueArrLength;\n          var valueArrItem; //value can be [ string, or array of two strings ]\n\n          if (valueType == valueInternalType) {\n            value = [value, value];\n          } else if (valueType == TYPES.a) {\n            valueArrLength = value[strLength];\n            if (valueArrLength > 2 || valueArrLength < 1) value = resultDefault;else {\n              if (valueArrLength === 1) value[1] = defaultValue;\n\n              for (i = 0; i < valueArrLength; i++) {\n                valueArrItem = value[i];\n\n                if (type(valueArrItem) != valueInternalType || !checkSettingsStringValue(valueArrItem, allowedValues)) {\n                  value = resultDefault;\n                  break;\n                }\n              }\n            }\n          } else if (valueType == TYPES.o) value = [value[_strX] || defaultValue, value[_strY] || defaultValue];else value = resultDefault;\n\n          return {\n            x: value[0],\n            y: value[1]\n          };\n        }\n\n        function generateMargin(marginTopRightBottomLeftArray) {\n          var result = [];\n          var currValue;\n          var currValueType;\n          var valueDirections = [_strTop, _strRight, _strBottom, _strLeft];\n\n          for (i = 0; i < marginTopRightBottomLeftArray[strLength]; i++) {\n            if (i === valueDirections[strLength]) break;\n            currValue = marginTopRightBottomLeftArray[i];\n            currValueType = type(currValue);\n            if (currValueType == TYPES.b) result.push(currValue ? parseToZeroOrNumber(finalElement.css(_strMarginMinus + valueDirections[i])) : 0);else result.push(currValueType == TYPES.n ? currValue : 0);\n          }\n\n          return result;\n        }\n\n        if (possibleElementIsJQuery || possibleElementIsHTMLElement) {\n          //get settings\n          var margin = coordinatesIsElementObj ? coordinates.margin : 0;\n          var axis = coordinatesIsElementObj ? coordinates.axis : 0;\n          var scroll = coordinatesIsElementObj ? coordinates.scroll : 0;\n          var block = coordinatesIsElementObj ? coordinates.block : 0;\n          var marginDefault = [0, 0, 0, 0];\n          var marginType = type(margin);\n          var marginLength;\n          finalElement = possibleElementIsJQuery ? possibleElement : FRAMEWORK(possibleElement);\n\n          if (finalElement[strLength] > 0) {\n            //margin can be [ boolean, number, array of 2, array of 4, object ]\n            if (marginType == TYPES.n || marginType == TYPES.b) margin = generateMargin([margin, margin, margin, margin]);else if (marginType == TYPES.a) {\n              marginLength = margin[strLength];\n              if (marginLength === 2) margin = generateMargin([margin[0], margin[1], margin[0], margin[1]]);else if (marginLength >= 4) margin = generateMargin(margin);else margin = marginDefault;\n            } else if (marginType == TYPES.o) margin = generateMargin([margin[_strTop], margin[_strRight], margin[_strBottom], margin[_strLeft]]);else margin = marginDefault; //block = type(block) === TYPES.b ? block ? [ strNearest, strBegin ] : [ strNearest, strEnd ] : block;\n\n            settingsAxis = checkSettingsStringValue(axis, elementObjSettingsAxisValues) ? axis : 'xy';\n            settingsScroll = getPerAxisValue(scroll, TYPES.s, strAlways, elementObjSettingsScrollValues);\n            settingsBlock = getPerAxisValue(block, TYPES.s, strBegin, elementObjSettingsBlockValues);\n            settingsMargin = margin;\n            var viewportScroll = {\n              l: _scrollHorizontalInfo._currentScroll,\n              t: _scrollVerticalInfo._currentScroll\n            }; // use padding element instead of viewport element because padding element has never padding, margin or position applied.\n\n            var viewportOffset = _paddingElement.offset(); //get coordinates\n\n\n            var elementOffset = finalElement.offset();\n            var doNotScroll = {\n              x: settingsScroll.x == strNever || settingsAxis == _strY,\n              y: settingsScroll.y == strNever || settingsAxis == _strX\n            };\n            elementOffset[_strTop] -= settingsMargin[0];\n            elementOffset[_strLeft] -= settingsMargin[3];\n            var elementScrollCoordinates = {\n              x: MATH.round(elementOffset[_strLeft] - viewportOffset[_strLeft] + viewportScroll.l),\n              y: MATH.round(elementOffset[_strTop] - viewportOffset[_strTop] + viewportScroll.t)\n            };\n\n            if (_isRTL) {\n              if (!_rtlScrollBehavior.n && !_rtlScrollBehavior.i) elementScrollCoordinates.x = MATH.round(viewportOffset[_strLeft] - elementOffset[_strLeft] + viewportScroll.l);\n              if (_rtlScrollBehavior.n && normalizeRTL) elementScrollCoordinates.x *= -1;\n              if (_rtlScrollBehavior.i && normalizeRTL) elementScrollCoordinates.x = MATH.round(viewportOffset[_strLeft] - elementOffset[_strLeft] + (_scrollHorizontalInfo._maxScroll - viewportScroll.l));\n            } //measuring is required\n\n\n            if (settingsBlock.x != strBegin || settingsBlock.y != strBegin || settingsScroll.x == strIfNeeded || settingsScroll.y == strIfNeeded || _isRTL) {\n              var measuringElm = finalElement[0];\n              var rawElementSize = _supportTransform ? measuringElm[LEXICON.bCR]() : {\n                width: measuringElm[LEXICON.oW],\n                height: measuringElm[LEXICON.oH]\n              };\n              var elementSize = {\n                w: rawElementSize[_strWidth] + settingsMargin[3] + settingsMargin[1],\n                h: rawElementSize[_strHeight] + settingsMargin[0] + settingsMargin[2]\n              };\n\n              var finalizeBlock = function finalizeBlock(isX) {\n                var vars = getScrollbarVars(isX);\n                var wh = vars._w_h;\n                var lt = vars._left_top;\n                var xy = vars._x_y;\n                var blockIsEnd = settingsBlock[xy] == (isX ? _isRTL ? strBegin : strEnd : strEnd);\n                var blockIsCenter = settingsBlock[xy] == strCenter;\n                var blockIsNearest = settingsBlock[xy] == strNearest;\n                var scrollNever = settingsScroll[xy] == strNever;\n                var scrollIfNeeded = settingsScroll[xy] == strIfNeeded;\n                var vpSize = _viewportSize[wh];\n                var vpOffset = viewportOffset[lt];\n                var elSize = elementSize[wh];\n                var elOffset = elementOffset[lt];\n                var divide = blockIsCenter ? 2 : 1;\n                var elementCenterOffset = elOffset + elSize / 2;\n                var viewportCenterOffset = vpOffset + vpSize / 2;\n                var isInView = elSize <= vpSize && elOffset >= vpOffset && elOffset + elSize <= vpOffset + vpSize;\n                if (scrollNever) doNotScroll[xy] = true;else if (!doNotScroll[xy]) {\n                  if (blockIsNearest || scrollIfNeeded) {\n                    doNotScroll[xy] = scrollIfNeeded ? isInView : false;\n                    blockIsEnd = elSize < vpSize ? elementCenterOffset > viewportCenterOffset : elementCenterOffset < viewportCenterOffset;\n                  }\n\n                  elementScrollCoordinates[xy] -= blockIsEnd || blockIsCenter ? (vpSize / divide - elSize / divide) * (isX && _isRTL && normalizeRTL ? -1 : 1) : 0;\n                }\n              };\n\n              finalizeBlock(true);\n              finalizeBlock(false);\n            }\n\n            if (doNotScroll.y) delete elementScrollCoordinates.y;\n            if (doNotScroll.x) delete elementScrollCoordinates.x;\n            coordinates = elementScrollCoordinates;\n          }\n        }\n\n        finalScroll[_strScrollLeft] = getFinalScroll(true, getRawScroll(true, coordinates));\n        finalScroll[_strScrollTop] = getFinalScroll(false, getRawScroll(false, coordinates));\n        doScrollLeft = finalScroll[_strScrollLeft] !== undefined;\n        doScrollTop = finalScroll[_strScrollTop] !== undefined;\n\n        if ((doScrollLeft || doScrollTop) && (duration > 0 || durationIsObject)) {\n          if (durationIsObject) {\n            duration.complete = proxyCompleteCallback;\n\n            _viewportElement.animate(finalScroll, duration);\n          } else {\n            animationOptions = {\n              duration: duration,\n              complete: proxyCompleteCallback\n            };\n\n            if (COMPATIBILITY.isA(easing) || FRAMEWORK.isPlainObject(easing)) {\n              specialEasing[_strScrollLeft] = easing[0] || easing.x;\n              specialEasing[_strScrollTop] = easing[1] || easing.y;\n              animationOptions.specialEasing = specialEasing;\n            } else {\n              animationOptions.easing = easing;\n            }\n\n            _viewportElement.animate(finalScroll, animationOptions);\n          }\n        } else {\n          if (doScrollLeft) _viewportElement[_strScrollLeft](finalScroll[_strScrollLeft]);\n          if (doScrollTop) _viewportElement[_strScrollTop](finalScroll[_strScrollTop]);\n          updateScrollbarInfos();\n        }\n      };\n      /**\r\n       * Stops all scroll animations.\r\n       * @returns {*} The current OverlayScrollbars instance (for chaining).\r\n       */\n\n\n      _base.scrollStop = function (param1, param2, param3) {\n        _viewportElement.stop(param1, param2, param3);\n\n        return _base;\n      };\n      /**\r\n       * Returns all relevant elements.\r\n       * @param elementName The name of the element which shall be returned.\r\n       * @returns {{target: *, host: *, padding: *, viewport: *, content: *, scrollbarHorizontal: {scrollbar: *, track: *, handle: *}, scrollbarVertical: {scrollbar: *, track: *, handle: *}, scrollbarCorner: *} | *}\r\n       */\n\n\n      _base.getElements = function (elementName) {\n        var obj = {\n          target: _targetElementNative,\n          host: _hostElementNative,\n          padding: _paddingElementNative,\n          viewport: _viewportElementNative,\n          content: _contentElementNative,\n          scrollbarHorizontal: {\n            scrollbar: _scrollbarHorizontalElement[0],\n            track: _scrollbarHorizontalTrackElement[0],\n            handle: _scrollbarHorizontalHandleElement[0]\n          },\n          scrollbarVertical: {\n            scrollbar: _scrollbarVerticalElement[0],\n            track: _scrollbarVerticalTrackElement[0],\n            handle: _scrollbarVerticalHandleElement[0]\n          },\n          scrollbarCorner: _scrollbarCornerElement[0]\n        };\n        return type(elementName) == TYPES.s ? getObjectPropVal(obj, elementName) : obj;\n      };\n      /**\r\n       * Returns a object which describes the current state of this instance.\r\n       * @param stateProperty A specific property from the state object which shall be returned.\r\n       * @returns {{widthAuto, heightAuto, overflowAmount, hideOverflow, hasOverflow, contentScrollSize, viewportSize, hostSize, autoUpdate} | *}\r\n       */\n\n\n      _base.getState = function (stateProperty) {\n        function prepare(obj) {\n          if (!FRAMEWORK.isPlainObject(obj)) return obj;\n          var extended = extendDeep({}, obj);\n\n          var changePropertyName = function changePropertyName(from, to) {\n            if (extended[LEXICON.hOP](from)) {\n              extended[to] = extended[from];\n              delete extended[from];\n            }\n          };\n\n          changePropertyName('w', _strWidth); //change w to width\n\n          changePropertyName('h', _strHeight); //change h to height\n\n          delete extended.c; //delete c (the 'changed' prop)\n\n          return extended;\n        }\n\n        ;\n        var obj = {\n          destroyed: !!prepare(_destroyed),\n          sleeping: !!prepare(_sleeping),\n          autoUpdate: prepare(!_mutationObserversConnected),\n          widthAuto: prepare(_widthAutoCache),\n          heightAuto: prepare(_heightAutoCache),\n          padding: prepare(_cssPaddingCache),\n          overflowAmount: prepare(_overflowAmountCache),\n          hideOverflow: prepare(_hideOverflowCache),\n          hasOverflow: prepare(_hasOverflowCache),\n          contentScrollSize: prepare(_contentScrollSizeCache),\n          viewportSize: prepare(_viewportSize),\n          hostSize: prepare(_hostSizeCache),\n          documentMixed: prepare(_documentMixed)\n        };\n        return type(stateProperty) == TYPES.s ? getObjectPropVal(obj, stateProperty) : obj;\n      };\n      /**\r\n       * Gets all or specific extension instance.\r\n       * @param extName The name of the extension from which the instance shall be got.\r\n       * @returns {{}} The instance of the extension with the given name or undefined if the instance couldn't be found.\r\n       */\n\n\n      _base.ext = function (extName) {\n        var result;\n\n        var privateMethods = _extensionsPrivateMethods.split(' ');\n\n        var i = 0;\n\n        if (type(extName) == TYPES.s) {\n          if (_extensions[LEXICON.hOP](extName)) {\n            result = extendDeep({}, _extensions[extName]);\n\n            for (; i < privateMethods.length; i++) {\n              delete result[privateMethods[i]];\n            }\n          }\n        } else {\n          result = {};\n\n          for (i in _extensions) {\n            result[i] = extendDeep({}, _base.ext(i));\n          }\n        }\n\n        return result;\n      };\n      /**\r\n       * Adds a extension to this instance.\r\n       * @param extName The name of the extension which shall be added.\r\n       * @param extensionOptions The extension options which shall be used.\r\n       * @returns {{}} The instance of the added extension or undefined if the extension couldn't be added properly.\r\n       */\n\n\n      _base.addExt = function (extName, extensionOptions) {\n        var registeredExtensionObj = _plugin.extension(extName);\n\n        var instance;\n        var instanceAdded;\n        var instanceContract;\n        var contractResult;\n        var contractFulfilled = true;\n\n        if (registeredExtensionObj) {\n          if (!_extensions[LEXICON.hOP](extName)) {\n            instance = registeredExtensionObj.extensionFactory.call(_base, extendDeep({}, registeredExtensionObj.defaultOptions), FRAMEWORK, COMPATIBILITY);\n\n            if (instance) {\n              instanceContract = instance.contract;\n\n              if (type(instanceContract) == TYPES.f) {\n                contractResult = instanceContract(window);\n                contractFulfilled = type(contractResult) == TYPES.b ? contractResult : contractFulfilled;\n              }\n\n              if (contractFulfilled) {\n                _extensions[extName] = instance;\n                instanceAdded = instance.added;\n                if (type(instanceAdded) == TYPES.f) instanceAdded(extensionOptions);\n                return _base.ext(extName);\n              }\n            }\n          } else return _base.ext(extName);\n        } else console.warn(\"A extension with the name \\\"\" + extName + \"\\\" isn't registered.\");\n      };\n      /**\r\n       * Removes a extension from this instance.\r\n       * @param extName The name of the extension which shall be removed.\r\n       * @returns {boolean} True if the extension was removed, false otherwise e.g. if the extension wasn't added before.\r\n       */\n\n\n      _base.removeExt = function (extName) {\n        var instance = _extensions[extName];\n        var instanceRemoved;\n\n        if (instance) {\n          delete _extensions[extName];\n          instanceRemoved = instance.removed;\n          if (type(instanceRemoved) == TYPES.f) instanceRemoved();\n          return true;\n        }\n\n        return false;\n      };\n      /**\r\n       * Constructs the plugin.\r\n       * @param targetElement The element to which the plugin shall be applied.\r\n       * @param options The initial options of the plugin.\r\n       * @param extensions The extension(s) which shall be added right after the initialization.\r\n       * @returns {boolean} True if the plugin was successfully initialized, false otherwise.\r\n       */\n\n\n      function construct(targetElement, options, extensions) {\n        _defaultOptions = globals.defaultOptions;\n        _nativeScrollbarStyling = globals.nativeScrollbarStyling;\n        _nativeScrollbarSize = extendDeep({}, globals.nativeScrollbarSize);\n        _nativeScrollbarIsOverlaid = extendDeep({}, globals.nativeScrollbarIsOverlaid);\n        _overlayScrollbarDummySize = extendDeep({}, globals.overlayScrollbarDummySize);\n        _rtlScrollBehavior = extendDeep({}, globals.rtlScrollBehavior); //parse & set options but don't update\n\n        setOptions(extendDeep({}, _defaultOptions, options));\n        _cssCalc = globals.cssCalc;\n        _msieVersion = globals.msie;\n        _autoUpdateRecommended = globals.autoUpdateRecommended;\n        _supportTransition = globals.supportTransition;\n        _supportTransform = globals.supportTransform;\n        _supportPassiveEvents = globals.supportPassiveEvents;\n        _supportResizeObserver = globals.supportResizeObserver;\n        _supportMutationObserver = globals.supportMutationObserver;\n        _restrictedMeasuring = globals.restrictedMeasuring;\n        _documentElement = FRAMEWORK(targetElement.ownerDocument);\n        _documentElementNative = _documentElement[0];\n        _windowElement = FRAMEWORK(_documentElementNative.defaultView || _documentElementNative.parentWindow);\n        _windowElementNative = _windowElement[0];\n        _htmlElement = findFirst(_documentElement, 'html');\n        _bodyElement = findFirst(_htmlElement, 'body');\n        _targetElement = FRAMEWORK(targetElement);\n        _targetElementNative = _targetElement[0];\n        _isTextarea = _targetElement.is('textarea');\n        _isBody = _targetElement.is('body');\n        _documentMixed = _documentElementNative !== document;\n        /* On a div Element The if checks only whether:\r\n         * - the targetElement has the class \"os-host\"\r\n         * - the targetElement has a a child with the class \"os-padding\"\r\n         * \r\n         * If that's the case, its assumed the DOM has already the following structure:\r\n         * (The \".os-host\" element is the targetElement)\r\n         *\r\n         *  <div class=\"os-host\">\r\n         *      <div class=\"os-resize-observer-host\"></div>\r\n         *      <div class=\"os-padding\">\r\n         *          <div class=\"os-viewport\">\r\n         *              <div class=\"os-content\"></div>\r\n         *          </div>\r\n         *      </div>\r\n         *      <div class=\"os-scrollbar os-scrollbar-horizontal \">\r\n         *          <div class=\"os-scrollbar-track\">\r\n         *              <div class=\"os-scrollbar-handle\"></div>\r\n         *          </div>\r\n         *      </div>\r\n         *      <div class=\"os-scrollbar os-scrollbar-vertical\">\r\n         *          <div class=\"os-scrollbar-track\">\r\n         *              <div class=\"os-scrollbar-handle\"></div>\r\n         *          </div>\r\n         *      </div>\r\n         *      <div class=\"os-scrollbar-corner\"></div>\r\n         *  </div>\r\n         *\r\n         * =====================================================================================\r\n         * \r\n         * On a Textarea Element The if checks only whether:\r\n         * - the targetElement has the class \"os-textarea\" \r\n         * - the targetElement is inside a element with the class \"os-content\" \r\n         * \r\n         * If that's the case, its assumed the DOM has already the following structure:\r\n         * (The \".os-textarea\" (textarea) element is the targetElement)\r\n         *\r\n         *  <div class=\"os-host-textarea\">\r\n         *      <div class=\"os-resize-observer-host\"></div>\r\n         *      <div class=\"os-padding os-text-inherit\">\r\n         *          <div class=\"os-viewport os-text-inherit\">\r\n         *              <div class=\"os-content os-text-inherit\">\r\n         *                  <div class=\"os-textarea-cover\"></div>\r\n         *                  <textarea class=\"os-textarea os-text-inherit\"></textarea>\r\n         *              </div>\r\n         *          </div>\r\n         *      </div>\r\n         *      <div class=\"os-scrollbar os-scrollbar-horizontal \">\r\n         *          <div class=\"os-scrollbar-track\">\r\n         *              <div class=\"os-scrollbar-handle\"></div>\r\n         *          </div>\r\n         *      </div>\r\n         *      <div class=\"os-scrollbar os-scrollbar-vertical\">\r\n         *          <div class=\"os-scrollbar-track\">\r\n         *              <div class=\"os-scrollbar-handle\"></div>\r\n         *          </div>\r\n         *      </div>\r\n         *      <div class=\"os-scrollbar-corner\"></div>\r\n         *  </div>\r\n         */\n\n        _domExists = _isTextarea ? _targetElement.hasClass(_classNameTextareaElement) && _targetElement.parent().hasClass(_classNameContentElement) : _targetElement.hasClass(_classNameHostElement) && _targetElement.children(_strDot + _classNamePaddingElement)[LEXICON.l];\n        var initBodyScroll;\n\n        var _bodyMouseTouchDownListener; //check if the plugin hasn't to be initialized\n\n\n        if (_nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.y && !_currentPreparedOptions.nativeScrollbarsOverlaid.initialize) {\n          _initialized = true; // workaround so the onInitializationWithdrawn callback below is fired\n\n          dispatchCallback('onInitializationWithdrawn');\n\n          if (_domExists) {\n            setupStructureDOM(true);\n            setupScrollbarsDOM(true);\n            setupScrollbarCornerDOM(true);\n          }\n\n          _initialized = false;\n          _destroyed = true;\n          _sleeping = true;\n          return _base;\n        }\n\n        if (_isBody) {\n          initBodyScroll = {};\n          initBodyScroll.l = MATH.max(_targetElement[_strScrollLeft](), _htmlElement[_strScrollLeft](), _windowElement[_strScrollLeft]());\n          initBodyScroll.t = MATH.max(_targetElement[_strScrollTop](), _htmlElement[_strScrollTop](), _windowElement[_strScrollTop]());\n\n          _bodyMouseTouchDownListener = function bodyMouseTouchDownListener() {\n            _viewportElement.removeAttr(LEXICON.ti);\n\n            setupResponsiveEventListener(_viewportElement, _strMouseTouchDownEvent, _bodyMouseTouchDownListener, true, true);\n          };\n        } //build OverlayScrollbars DOM\n\n\n        setupStructureDOM();\n        setupScrollbarsDOM();\n        setupScrollbarCornerDOM(); //create OverlayScrollbars events\n\n        setupStructureEvents();\n        setupScrollbarEvents(true);\n        setupScrollbarEvents(false);\n        setupScrollbarCornerEvents(); //create mutation observers\n\n        createMutationObservers(); //build resize observer for the host element\n\n        setupResizeObserver(_sizeObserverElement, hostOnResized);\n\n        if (_isBody) {\n          //apply the body scroll to handle it right in the update method\n          _viewportElement[_strScrollLeft](initBodyScroll.l)[_strScrollTop](initBodyScroll.t); //set the focus on the viewport element so you dont have to click on the page to use keyboard keys (up / down / space) for scrolling\n\n\n          if (document.activeElement == targetElement && _viewportElementNative.focus) {\n            //set a tabindex to make the viewportElement focusable\n            _viewportElement.attr(LEXICON.ti, '-1');\n\n            _viewportElementNative.focus();\n            /* the tabindex has to be removed due to;\r\n             * If you set the tabindex attribute on an <div>, then its child content cannot be scrolled with the arrow keys unless you set tabindex on the content, too\r\n             * https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/tabindex\r\n             */\n\n\n            setupResponsiveEventListener(_viewportElement, _strMouseTouchDownEvent, _bodyMouseTouchDownListener, false, true);\n          }\n        } //update for the first time & initialize cache\n\n\n        _base.update(_strAuto); //the plugin is initialized now!\n\n\n        _initialized = true;\n        dispatchCallback('onInitialized'); //call all callbacks which would fire before the initialized was complete\n\n        each(_callbacksInitQeueue, function (index, value) {\n          dispatchCallback(value.n, value.a);\n        });\n        _callbacksInitQeueue = []; //add extensions\n\n        if (type(extensions) == TYPES.s) extensions = [extensions];\n        if (COMPATIBILITY.isA(extensions)) each(extensions, function (index, value) {\n          _base.addExt(value);\n        });else if (FRAMEWORK.isPlainObject(extensions)) each(extensions, function (key, value) {\n          _base.addExt(key, value);\n        }); //add the transition class for transitions AFTER the first update & AFTER the applied extensions (for preventing unwanted transitions)\n\n        setTimeout(function () {\n          if (_supportTransition && !_destroyed) addClass(_hostElement, _classNameHostTransition);\n        }, 333);\n        return _base;\n      }\n\n      if (_plugin.valid(construct(pluginTargetElement, options, extensions))) {\n        INSTANCES(pluginTargetElement, _base);\n      }\n\n      return _base;\n    }\n    /**\r\n     * Initializes a new OverlayScrollbarsInstance object or changes options if already initialized or returns the current instance.\r\n     * @param pluginTargetElements The elements to which the Plugin shall be initialized.\r\n     * @param options The custom options with which the plugin shall be initialized.\r\n     * @param extensions The extension(s) which shall be added right after initialization.\r\n     * @returns {*}\r\n     */\n\n\n    _plugin = window[PLUGINNAME] = function (pluginTargetElements, options, extensions) {\n      if (arguments[LEXICON.l] === 0) return this;\n      var arr = [];\n      var optsIsPlainObj = FRAMEWORK.isPlainObject(options);\n      var inst;\n      var result; //pluginTargetElements is null or undefined\n\n      if (!pluginTargetElements) return optsIsPlainObj || !options ? result : arr;\n      /*\r\n         pluginTargetElements will be converted to:\r\n         1. A jQueryElement Array\r\n         2. A HTMLElement Array\r\n         3. A Array with a single HTML Element\r\n         so pluginTargetElements is always a array.\r\n      */\n\n      pluginTargetElements = pluginTargetElements[LEXICON.l] != undefined ? pluginTargetElements : [pluginTargetElements[0] || pluginTargetElements];\n      initOverlayScrollbarsStatics();\n\n      if (pluginTargetElements[LEXICON.l] > 0) {\n        if (optsIsPlainObj) {\n          FRAMEWORK.each(pluginTargetElements, function (i, v) {\n            inst = v;\n            if (inst !== undefined) arr.push(OverlayScrollbarsInstance(inst, options, extensions, _pluginsGlobals, _pluginsAutoUpdateLoop));\n          });\n        } else {\n          FRAMEWORK.each(pluginTargetElements, function (i, v) {\n            inst = INSTANCES(v);\n            if (options === '!' && _plugin.valid(inst) || COMPATIBILITY.type(options) == TYPES.f && options(v, inst)) arr.push(inst);else if (options === undefined) arr.push(inst);\n          });\n        }\n\n        result = arr[LEXICON.l] === 1 ? arr[0] : arr;\n      }\n\n      return result;\n    };\n    /**\r\n     * Returns a object which contains global information about the plugin and each instance of it.\r\n     * The returned object is just a copy, that means that changes to the returned object won't have any effect to the original object.\r\n     */\n\n\n    _plugin.globals = function () {\n      initOverlayScrollbarsStatics();\n      var globals = FRAMEWORK.extend(true, {}, _pluginsGlobals);\n      delete globals['msie'];\n      return globals;\n    };\n    /**\r\n     * Gets or Sets the default options for each new plugin initialization.\r\n     * @param newDefaultOptions The object with which the default options shall be extended.\r\n     */\n\n\n    _plugin.defaultOptions = function (newDefaultOptions) {\n      initOverlayScrollbarsStatics();\n      var currDefaultOptions = _pluginsGlobals.defaultOptions;\n      if (newDefaultOptions === undefined) return FRAMEWORK.extend(true, {}, currDefaultOptions); //set the new default options\n\n      _pluginsGlobals.defaultOptions = FRAMEWORK.extend(true, {}, currDefaultOptions, _pluginsOptions._validate(newDefaultOptions, _pluginsOptions._template, true, currDefaultOptions)._default);\n    };\n    /**\r\n     * Checks whether the passed instance is a non-destroyed OverlayScrollbars instance.\r\n     * @param osInstance The potential OverlayScrollbars instance which shall be checked.\r\n     * @returns {boolean} True if the passed value is a non-destroyed OverlayScrollbars instance, false otherwise.\r\n     */\n\n\n    _plugin.valid = function (osInstance) {\n      return osInstance instanceof _plugin && !osInstance.getState().destroyed;\n    };\n    /**\r\n     * Registers, Unregisters or returns a extension.\r\n     * Register: Pass the name and the extension. (defaultOptions is optional)\r\n     * Unregister: Pass the name and anything except a function as extension parameter.\r\n     * Get extension: Pass the name of the extension which shall be got.\r\n     * Get all extensions: Pass no arguments.\r\n     * @param extensionName The name of the extension which shall be registered, unregistered or returned.\r\n     * @param extension A function which generates the instance of the extension or anything other to remove a already registered extension.\r\n     * @param defaultOptions The default options which shall be used for the registered extension.\r\n     */\n\n\n    _plugin.extension = function (extensionName, extension, defaultOptions) {\n      var extNameTypeString = COMPATIBILITY.type(extensionName) == TYPES.s;\n      var argLen = arguments[LEXICON.l];\n      var i = 0;\n\n      if (argLen < 1 || !extNameTypeString) {\n        //return a copy of all extension objects\n        return FRAMEWORK.extend(true, {\n          length: _pluginsExtensions[LEXICON.l]\n        }, _pluginsExtensions);\n      } else if (extNameTypeString) {\n        if (COMPATIBILITY.type(extension) == TYPES.f) {\n          //register extension\n          _pluginsExtensions.push({\n            name: extensionName,\n            extensionFactory: extension,\n            defaultOptions: defaultOptions\n          });\n        } else {\n          for (; i < _pluginsExtensions[LEXICON.l]; i++) {\n            if (_pluginsExtensions[i].name === extensionName) {\n              if (argLen > 1) _pluginsExtensions.splice(i, 1); //remove extension\n              else return FRAMEWORK.extend(true, {}, _pluginsExtensions[i]); //return extension with the given name\n            }\n          }\n        }\n      }\n    };\n\n    return _plugin;\n  }();\n\n  if (JQUERY && JQUERY.fn) {\n    /**\r\n     * The jQuery initialization interface.\r\n     * @param options The initial options for the construction of the plugin. To initialize the plugin, this option has to be a object! If it isn't a object, the instance(s) are returned and the plugin wont be initialized.\r\n     * @param extensions The extension(s) which shall be added right after initialization.\r\n     * @returns {*} After initialization it returns the jQuery element array, else it returns the instance(s) of the elements which are selected.\r\n     */\n    JQUERY.fn.overlayScrollbars = function (options, extensions) {\n      var _elements = this;\n\n      if (JQUERY.isPlainObject(options)) {\n        JQUERY.each(_elements, function () {\n          PLUGIN(this, options, extensions);\n        });\n        return _elements;\n      } else return PLUGIN(_elements, options);\n    };\n  }\n\n  return PLUGIN;\n});"],"names":["global","window","this","document","undefined","_targets","_instancePropertyString","_easingsMath","PLUGINNAME","TYPES","o","f","a","s","b","n","u","z","LEXICON","c","i","l","p","ti","oH","cH","sH","oW","cW","sW","hOP","bCR","VENDORS","jsCache","cssCache","cssPrefixes","jsPrefixes","firstLetterToUpper","str","charAt","toUpperCase","slice","_cssPrefixes","_jsPrefixes","_cssProperty","name","result","resultPossibilities","v","currVendorWithoutDashes","uppercasedName","elmStyle","createElement","length","replace","_cssPropertyValue","property","values","suffix","prop","dummyStyle","possbleValues","split","preparedSuffix","cssText","_jsAPI","isInterface","fallback","toLowerCase","COMPATIBILITY","windowSize","x","innerWidth","documentElement","body","innerHeight","bind","func","thisObj","proto","aArgs","Array","call","arguments","fNOP","fBound","apply","concat","wW","wH","mO","rO","rAF","setTimeout","cAF","id","clearTimeout","now","Date","getTime","stpP","event","stopPropagation","cancelBubble","prvD","preventDefault","cancelable","returnValue","page","strPage","strClient","strX","strY","eventDoc","originalEvent","target","srcElement","ownerDocument","doc","touches","touch","y","scrollLeft","clientLeft","scrollTop","clientTop","mBtn","button","which","inA","item","arr","e","isA","def","isArray","type","obj","Object","toString","MATH","Math","JQUERY","jQuery","EASING","PI","cos","sin","w","pow","t","sqrt","asin","abs","swing","d","linear","easeInQuad","easeOutQuad","easeInOutQuad","easeInCubic","easeOutCubic","easeInOutCubic","easeInQuart","easeOutQuart","easeInOutQuart","easeInQuint","easeOutQuint","easeInOutQuint","easeInSine","easeOutSine","easeInOutSine","easeInExpo","easeOutExpo","easeInOutExpo","easeInCirc","easeOutCirc","easeInOutCirc","easeInElastic","easeOutElastic","easeInOutElastic","easeInBack","easeOutBack","easeInOutBack","easeInBounce","easeOutBounce","easeInOutBounce","FRAMEWORK","_rnothtmlwhite","_strSpace","_strEmpty","_strScrollLeft","_strScrollTop","_animations","_type","_cssNumber","animationIterationCount","columnCount","fillOpacity","flexGrow","flexShrink","fontWeight","lineHeight","opacity","order","orphans","widows","zIndex","zoom","extend","src","copyIsArray","copy","options","clone","deep","FakejQuery","isPlainObject","inArray","fromIndex","isFunction","isEmptyObject","key","hasOwnProperty","hasOwnConstructor","hasIsPrototypeOf","constructor","_each","callback","isArrayLike","stripAndCollapse","value","match","join","matches","elem","selector","nodeList","parentNode","querySelectorAll","insertAdjacentElement","el","strategy","child","insertAdjacentHTML","nodeType","setCSSVal","val","parseCSSVal","startNextAnimationInQ","animObj","removeFromQ","index","nextAnim","q","splice","_animate","props","duration","easing","complete","setAnimationValue","guaranteedNext","progress","step","specialEasing","hasOptions","from","to","start","push","css","timeNow","end","percent","fromVal","toVal","easedVal","timeStart","_frame","elapsed","qPos","qObj","stop","max","parseFloat","pos","speacialEasing","startTime","frame","_stop","clearQ","jumpToEnd","elementIsVisible","getClientRects","elms","base","elements","innerHTML","children","self","on","eventName","handler","eventNameLength","each","addEventListener","detachEvent","attachEvent","off","removeEventListener","one","oneEventName","oneHandler","trigger","createEvent","initEvent","dispatchEvent","fireEvent","append","prepend","before","after","remove","removeChild","unwrap","parent","parents","firstChild","insertBefore","wrapAll","wrapperHTML","nodes","wrapper","deepest","previousSibling","childNodes","appendChild","nextSibling","wrapInner","contents","wrap","styles","cptStyle","getCptStyle","getComputedStyle","currentStyle","getPropertyValue","hasClass","className","classList","classNamePrepared","contains","indexOf","addClass","classes","cur","curValue","clazz","finalValue","supportClassList","elmClassList","add","removeClass","hide","display","show","attr","attrName","getAttribute","setAttribute","removeAttr","removeAttribute","offset","rect","pageXOffset","pageYOffset","top","left","position","offsetTop","offsetLeft","first","eq","last","find","ch","is","childs","animate","jump","INSTANCES","instance","argLen","PLUGIN","_plugin","_pluginsGlobals","_pluginsAutoUpdateLoop","possibleTemplateTypes","restrictedStringsSplit","restrictedStringsPossibilitiesSplit","classNameAllowedValues","numberAllowedValues","booleanNullAllowedValues","booleanTrueTemplate","booleanFalseTemplate","callbackTemplate","overflowBehaviorAllowedValues","optionsDefaultsAndTemplate","convert","_pluginsExtensions","_pluginsOptions","resize","sizeAutoCapable","clipAlways","normalizeRTL","paddingAbsolute","autoUpdate","autoUpdateInterval","updateOnLoad","nativeScrollbarsOverlaid","showNativeScrollbars","initialize","overflowBehavior","scrollbars","visibility","autoHide","autoHideDelay","dragScrolling","clickScrolling","touchSupport","snapHandle","textarea","dynWidth","dynHeight","inheritedAttrs","callbacks","onInitialized","onInitializationWithdrawn","onDestroyed","onScrollStart","onScroll","onScrollStop","onOverflowChanged","onOverflowAmountChanged","onDirectionChanged","onContentSizeChanged","onHostSizeChanged","onUpdated","_defaults","template","recursive","valType","_template","_validate","writeErrors","diffObj","validatedOptions","validatedOptionsPrepared","objectCopy","isEmptyObj","checkObjectProps","data","diffData","prevPropName","restrictedStringValuesSplit","restrictedStringValuesPossibilitiesSplit","isRestrictedValue","mainPossibility","currType","j","isValid","isDiff","templateValue","templateValueType","templateIsComplex","templateTypes","dataDiffValue","dataValue","dataValueType","propPrefix","error","errorPossibleTypes","errorRestrictedStrings","console","warn","JSON","stringify","_default","_prepared","initOverlayScrollbarsStatics","OverlayScrollbarsGlobals","OverlayScrollbarsAutoUpdateLoop","defaultOptions","_base","strOverflow","strHidden","strScroll","bodyElement","scrollbarDummyElement","scrollbarDummyElement0","dummyContainerChild","nativeScrollbarSize","calcNativeScrollbarSize","nativeScrollbarIsOverlaid","msie","ua","navigator","userAgent","strIndexOf","strSubString","trident","edge","rv","parseIntFunc","parseInt","measureElement","autoUpdateLoop","autoUpdateRecommended","nativeScrollbarStyling","ex","overlayScrollbarDummySize","cssCalc","restrictedMeasuring","scrollSize","h","scrollSize2","rtlScrollBehavior","dummyContainerOffset","dummyContainerChildOffset","dummyContainerChildOffsetAfterScroll","supportTransform","supportTransition","supportPassiveEvents","supportsPassive","defineProperty","get","supportResizeObserver","supportMutationObserver","windowWidth","windowHeight","windowDpr","getWindowDPR","onResize","newW","newH","deltaW","deltaH","newScrollbarSize","deltaWRatio","round","deltaHRatio","absDeltaW","absDeltaH","absDeltaWRatio","absDeltaHRatio","newDPR","deltaIsBigger","difference","differenceIsBiggerThanOne","isZoom","oldScrollbarSize","update","valOne","valTwo","absValOne","absValTwo","dDPI","screen","deviceXDPI","sDPI","logicalXDPI","devicePixelRatio","globals","_loopID","_inArray","_getNow","_strAutoUpdate","_strAutoUpdateInterval","_strLength","_loopingInstances","_loopingInstancesIntervalCache","_loopIsActive","_loopIntervalDefault","_loopInterval","_loopTimeOld","loop","lowestInterval","instanceOptions","instanceAutoUpdateAllowed","instanceAutoUpdateInterval","timeNew","timeDelta","min","OverlayScrollbarsInstance","pluginTargetElement","extensions","_frameworkProto","isHTMLElement","inst","_nativeScrollbarIsOverlaid","_overlayScrollbarDummySize","_rtlScrollBehavior","_autoUpdateRecommended","_msieVersion","_nativeScrollbarStyling","_cssCalc","_nativeScrollbarSize","_supportTransition","_supportTransform","_supportPassiveEvents","_supportResizeObserver","_supportMutationObserver","_initialized","_destroyed","_isTextarea","_isBody","_documentMixed","_domExists","_isBorderBox","_sizeAutoObserverAdded","_paddingX","_paddingY","_borderX","_borderY","_marginX","_marginY","_isRTL","_sleeping","_defaultOptions","_currentOptions","_currentPreparedOptions","_lastUpdateTime","_swallowedUpdateTimeout","_windowElement","_documentElement","_htmlElement","_bodyElement","_targetElement","_hostElement","_sizeAutoObserverElement","_sizeObserverElement","_paddingElement","_viewportElement","_contentElement","_contentArrangeElement","_contentGlueElement","_textareaCoverElement","_scrollbarCornerElement","_scrollbarHorizontalElement","_scrollbarHorizontalTrackElement","_scrollbarHorizontalHandleElement","_scrollbarVerticalElement","_scrollbarVerticalTrackElement","_scrollbarVerticalHandleElement","_windowElementNative","_documentElementNative","_targetElementNative","_hostElementNative","_sizeAutoObserverElementNative","_sizeObserverElementNative","_paddingElementNative","_viewportElementNative","_contentElementNative","_hostSizeCache","_contentScrollSizeCache","_arrangeContentSizeCache","_hasOverflowCache","_hideOverflowCache","_widthAutoCache","_heightAutoCache","_cssBoxSizingCache","_cssPaddingCache","_cssBorderCache","_cssMarginCache","_cssDirectionCache","_cssDirectionDetectedCache","_paddingAbsoluteCache","_clipAlwaysCache","_contentGlueSizeCache","_overflowBehaviorCache","_overflowAmountCache","_ignoreOverlayScrollbarHidingCache","_autoUpdateCache","_sizeAutoCapableCache","_contentElementScrollSizeChangeDetectedCache","_hostElementSizeChangeDetectedCache","_scrollbarsVisibilityCache","_scrollbarsAutoHideCache","_scrollbarsClickScrollingCache","_scrollbarsDragScrollingCache","_resizeCache","_normalizeRTLCache","_classNameCache","_oldClassName","_textareaAutoWrappingCache","_textareaInfoCache","_textareaSizeCache","_textareaDynHeightCache","_textareaDynWidthCache","_bodyMinSizeCache","_mutationObserverHost","_mutationObserverContent","_mutationObserverHostCallback","_mutationObserverContentCallback","_mutationObserversConnected","_textareaHasFocus","_scrollbarsAutoHideTimeoutId","_scrollbarsAutoHideMoveTimeoutId","_scrollbarsAutoHideDelay","_scrollbarsAutoHideNever","_scrollbarsAutoHideScroll","_scrollbarsAutoHideMove","_scrollbarsAutoHideLeave","_scrollbarsHandleHovered","_scrollbarsHandlesDefineScrollPos","_resizeNone","_resizeBoth","_resizeHorizontal","_resizeVertical","_contentBorderSize","_scrollHorizontalInfo","_scrollVerticalInfo","_viewportSize","_nativeScrollbarMinSize","_strMinusHidden","_strMarginMinus","_strPaddingMinus","_strBorderMinus","_strTop","_strRight","_strBottom","_strLeft","_strMinMinus","_strMaxMinus","_strWidth","_strHeight","_strFloat","_strAuto","_strSync","_strScroll","_strHundredPercent","_strX","_strY","_strDot","_strScrollbar","_strMinusHorizontal","_strMinusVertical","_strMouseTouchDownEvent","_strMouseTouchUpEvent","_strMouseTouchMoveEvent","_strMouseEnter","_strMouseLeave","_strKeyDownEvent","_strKeyUpEvent","_strSelectStartEvent","_strTransitionEndEvent","_strResizeObserverProperty","_cassNamesPrefix","_classNameHTMLElement","_classNameHostElement","_classNameHostElementForeign","_classNameHostTextareaElement","_classNameHostScrollbarHorizontalHidden","_classNameHostScrollbarVerticalHidden","_classNameHostTransition","_classNameHostRTL","_classNameHostResizeDisabled","_classNameHostScrolling","_classNameHostOverflow","_classNameHostOverflowX","_classNameHostOverflowY","_classNameTextareaElement","_classNameTextareaCoverElement","_classNamePaddingElement","_classNameViewportElement","_classNameViewportNativeScrollbarsInvisible","_classNameViewportNativeScrollbarsOverlaid","_classNameContentElement","_classNameContentArrangeElement","_classNameContentGlueElement","_classNameSizeAutoObserverElement","_classNameResizeObserverElement","_classNameResizeObserverItemElement","_classNameResizeObserverItemFinalElement","_classNameTextInherit","_classNameScrollbar","_classNameScrollbarTrack","_classNameScrollbarTrackOff","_classNameScrollbarHandle","_classNameScrollbarHandleOff","_classNameScrollbarUnusable","_classNameScrollbarAutoHidden","_classNameScrollbarCorner","_classNameScrollbarCornerResize","_classNameScrollbarCornerResizeB","_classNameScrollbarCornerResizeH","_classNameScrollbarCornerResizeV","_classNameScrollbarHorizontal","_classNameScrollbarVertical","_classNameDragging","_classNameThemeNone","_classNamesDynamicDestroy","_callbacksInitQeueue","_viewportAttrsFromTarget","_extensions","_extensionsPrivateMethods","_swallowedUpdateHints","_swallowUpdateLag","_updateOnLoadEventName","_updateOnLoadElms","_updateAutoCache","_mutationObserverAttrsTextarea","_mutationObserverAttrsHost","_destroyEvents","sleep","force","attrsChanged","contentSizeC","doUpdateAuto","mutHost","mutContent","meaningfulAttrsChanged","updateAutoContentSizeChanged","_contentSizeChanged","_changedOptions","takeRecords","_hostSizeChanged","_force","updateElementsOnLoad","newOptions","changedOps","option","getObjectPropVal","setObjectPropVal","setOptions","destroy","extName","disconnectMutationObservers","setupResizeObserver","removeExt","pop","setupHostMouseTouchEvents","setupScrollbarsDOM","setupScrollbarCornerDOM","setupStructureDOM","updateOnLoadCallback","dispatchCallback","scroll","coordinates","infoX","infoY","normalizeInvert","normalizeNegate","scrollX","_currentScroll","scrollXRatio","_currentScrollRatio","maxScrollX","_maxScroll","ratio","handleOffset","_handleOffset","handleLength","_handleLength","handleLengthRatio","_handleLengthRatio","trackLength","_trackLength","snappedHandleOffset","_snappedHandleOffset","isRTL","isRTLNormalized","doScrollLeft","doScrollTop","animationOptions","settingsAxis","settingsScroll","settingsBlock","settingsMargin","finalElement","coordinatesXAxisProps","coordinatesYAxisProps","coordinatesOperators","durationIsObject","completeCallback","finalScroll","strEnd","strBegin","strCenter","strNearest","strAlways","strNever","strIfNeeded","strLength","elementObjSettingsAxisValues","elementObjSettingsBlockValues","elementObjSettingsScrollValues","coordinatesIsElementObj","possibleElement","possibleElementIsJQuery","possibleElementIsHTMLElement","updateScrollbarInfos","refreshScrollbarHandleOffset","proxyCompleteCallback","checkSettingsStringValue","currValue","allowedValues","getRawScroll","isX","coordinateProps","getFinalScroll","rawScroll","operator","amount","possibleOperator","isString","scrollInfo","currScroll","maxScroll","mult","isRTLisX","normalizeShortcuts","strReplace","evalFunc","eval","substr","parseToZeroOrNumber","isNaN","toFixed","normalizeIsRTLisX","operatorCurrScroll","invert","negate","getPerAxisValue","valueInternalType","defaultValue","valueArrLength","valueArrItem","resultDefault","valueType","generateMargin","marginTopRightBottomLeftArray","currValueType","valueDirections","marginLength","margin","axis","block","marginDefault","marginType","viewportScroll","viewportOffset","elementOffset","doNotScroll","elementScrollCoordinates","measuringElm","rawElementSize","width","height","elementSize","finalizeBlock","vars","getScrollbarVars","wh","_w_h","lt","_left_top","xy","_x_y","blockIsEnd","blockIsCenter","blockIsNearest","scrollNever","scrollIfNeeded","vpSize","vpOffset","elSize","elOffset","divide","elementCenterOffset","viewportCenterOffset","isInView","scrollStop","param1","param2","param3","getElements","elementName","host","padding","viewport","content","scrollbarHorizontal","scrollbar","track","handle","scrollbarVertical","scrollbarCorner","getState","stateProperty","prepare","extended","extendDeep","changePropertyName","destroyed","sleeping","widthAuto","heightAuto","overflowAmount","hideOverflow","hasOverflow","contentScrollSize","viewportSize","hostSize","documentMixed","ext","privateMethods","addExt","extensionOptions","instanceAdded","instanceContract","contractResult","registeredExtensionObj","extension","contractFulfilled","extensionFactory","contract","added","instanceRemoved","removed","valid","construct","setupResponsiveEventListener","element","eventNames","listener","passiveOrOptions","collected","method","onOff","events","passiveOrOptionsIsObj","passive","_passive","capture","_capture","nativeParam","addDestroyEventListener","targetElement","onElementResizedCallback","resizeObserver","strAnimationStartEvent","strChildNodes","constScroll","generateDiv","observe","dir","style","isDirty","rAFId","currWidth","currHeight","observerElement","shrinkElement","expandElement","expandElementChild","widthCache","heightCache","factor","reset","onResized","expandChildCSS","observerElementCSS","setTopRightBottomLeft","isIE","findFirst","onload","wnd","contentDocument","defaultView","directionChanged","scrollLeftValue","resizeObserverObj","disconnect","createMutationObservers","mutationTarget","mutationAttrName","mutationIsClass","oldMutationVal","newClassVal","hostClassNameRegex","contentTimeout","sizeAuto","action","mutationObserverContentLag","mutationObserver","contentLastUpdate","mutations","doUpdate","isUnknownMutation","textareaUpdate","mutation","doUpdateForce","mutatedAttrs","attributeName","oldValue","createHostClassNameRegExp","filter","hostClassNamesChanged","updateViewportAttrsFromTarget","connectMutationObservers","attributes","attributeOldValue","attributeFilter","subtree","childList","characterData","hostOnResized","changed","checkCache","hostOnMouseEnter","refreshScrollbarsAutoHide","hostOnMouseLeave","hostOnMouseMove","documentOnSelectStart","elm","eachUpdateOnLoad","updateOnLoadSelector","bodyMinSizeChanged","bodyMinSize","oldClassNames","newClassNames","regex","currClasses","diff","getArrayDifferences","idx","mutationType","strClosest","float","bodyMinSizeC","contentElementScrollSize","contentMeasureElement","getContentMeasureElement","textareaValueLength","setCSS","curr","cache","changedAttrs","checks","_elem","_attrs","check","isSizeAffectingCSSProperty","propertyName","flexBasis","affectingPropsX","affectingPropsXContentBox","affectingPropsY","affectingPropsYContentBox","_strS","_strVS","checkX","sizeIsAffected","checkPropertyName","attrs","targetAttr","origWidth","origHeight","wrapAttrOff","minWidth","minHeight","doMeasure","_originalWidth","_originalHeight","_dynamicWidth","_dynamicHeight","updateHints","displayIsHidden","hostSizeChanged","contentSizeChanged","changedOptions","swallow","checkCacheAutoForce","currentPreparedOptionsScrollbars","currentPreparedOptionsTextarea","scrollbarsVisibility","scrollbarsVisibilityChanged","scrollbarsAutoHide","scrollbarsAutoHideChanged","scrollbarsClickScrolling","scrollbarsClickScrollingChanged","scrollbarsDragScrolling","scrollbarsDragScrollingChanged","classNameChanged","resizeChanged","paddingAbsoluteChanged","clipAlwaysChanged","sizeAutoCapableChanged","ignoreOverlayScrollbarHiding","ignoreOverlayScrollbarHidingChanged","autoUpdateChanged","overflowBehaviorChanged","textareaDynWidth","textareaDynWidthChanged","textareaDynHeight","textareaDynHeightChanged","oldSize","newSize","sizeAutoObserverElementBCRect","textareaAutoWrapping","textareaAutoWrappingChanged","cssDirection","cssDirectionChanged","boxSizing","boxSizingChanged","getTopRightBottomLeftHost","isRTLLeft","isRTLRight","widthAutoResizeDetection","widthAutoObserverDetection","right","tmpCurrHostWidth","tmpCurrContentGlueWidth","tmpNewHostWidth","widthAutoChanged","wasWidthAuto","bottom","heightAutoChanged","wasHeightAuto","border","contentElementCSS","contentGlueElementCSS","getHostSize","getViewportSize","paddingAbsoluteX","r","paddingAbsoluteY","paddingElementCSS","textareaCSS","paddingValues","textareaSize","textareaSizeChanged","textareaDynOrigSize","strOverflowX","strOverflowY","strVisible","viewportElementResetCSS","resetXTmp","ys","resetBottomTmp","xs","contentSize","hostAbsoluteRectSize","contentGlueSize","textareaCoverCSS","setContentGlueElementCSSfunction","horizontal","scrollbarVars","strWH","_width_height","autoSize","borderSize","paddingSize","marginSize","hideOverflowForceTextarea","previousOverflowAmount","overflowBehaviorIsVS","overflowBehaviorIsVH","overflowBehaviorIsS","canScroll","viewportRect","setOverflowVariables","xyI","widthHeight","scrollMax","_Left_Top","fractionalOverflowAmount","checkFractionalOverflowAmount","setContentElementCSS","borderDesign","contentArrangeElementCSS","arrangeContent","arrangeChanged","scrollbarVarsInverted","strDirection","invertedAutoSize","addRemoveClass","setViewportCSS","viewportElementCSS","XY","_X_Y","elementStyle","webkitTransform","floatTmp","posLeftWithoutFloat","textareaInfo","getTextareaInfo","textareaRowsChanged","_rows","cursorRow","_cursorRow","cursorCol","_cursorColumn","widestRow","_widestRow","lastRow","lastCol","_columns","cursorIsLastPosition","_cursorPosition","_cursorMax","textareaScrollAmount","scrollbarsVisibilityVisible","scrollbarsVisibilityHidden","scrollbarsVisibilityAuto","refreshScrollbarsVisibility","showX","showY","refreshScrollbarAppearance","refreshScrollbarHandleLength","refreshScrollbarsInteractive","xScrollable","yScrollable","clipped","forced","validatedOpts","strParent","classNameResizeObserverHost","classNameTextareaElementFull","textareaClass","adoptAttrs","adoptAttrsMap","applyAdoptedAttrs","applyAdoptedAttrsElm","hostElementClassNames","hostElementCSS","selectOrGenerateDivByClass","setupStructureEvents","textareaUpdateIntervalID","scrollStopTimeoutId","textareaKeyDownRestrictedKeyCodes","textareaKeyDownKeyCodesList","scrollStopDelay","strFocus","updateTextarea","doClearInterval","clearInterval","textareaOnScroll","textareaOnDrop","textareaOnFocus","textareaOnFocusout","textareaOnKeyDown","keyCode","setInterval","textareaOnKeyUp","contentOnTransitionEnd","viewportOnScroll","nativeOverlayScrollbarsAreActive","horizontalElements","verticalElements","selectOrGenerateScrollbarDOM","isHorizontal","_scrollbar","_track","_handle","resetScrollbarDOM","setupScrollbarEvents","trackTimeout","mouseDownScroll","mouseDownOffset","mouseDownInvertedScale","scrollbarVarsInfo","_info","insideIFrame","strActive","strSnapHandle","strClickEvent","scrollDurationFactor","increaseDecreaseScrollAmountKeyCodes","getPointerPosition","getPreparedScrollbarsOption","increaseTrackScrollAmount","decreaseTrackScrollAmount","stopClickEventPropagation","documentKeyDown","documentKeyUp","onMouseTouchDownContinue","isTouchEvent","documentDragMove","scrollDelta","isFinite","documentMouseTouchUp","clientX","clientY","onHandleMouseTouchDown","onHandleMouseTouchDownAction","getHostElementInvertedScale","onTrackMouseTouchDown","decreaseScroll","handleToViewportRatio","scrollDistance","scrollBaseDuration","scrollFirstIterationDelay","trackOffset","ctrlKey","instantScroll","shiftKey","instantScrollTransition","isFirstIteration","scrollActionFinsished","transition","scrollActionInstantFinished","scrollAction","mouseOffset","scrollRange","scrollDuration","timeoutDelay","instantScrollPosition","rtlIsNormal","decreaseScrollCondition","scrollObj","animationObj","onTrackMouseTouchEnter","onTrackMouseTouchLeave","onScrollbarMouseTouchDown","shallBeVisible","scrollbarElement","delayfree","anyActive","handleCSS","digit","handleRatio","floor","_Width_Height","scrollOrTransition","transformOffset","translateValue","transitionDuration","isRTLisHorizontal","strTranslateBrace","strTransform","strTransition","nativeScroll","currentScroll","handleTrackDiff","getScrollRatio","getHandleOffset","scrollRatio","getCSSTransitionString","isTrack","element2","_l_t","setupScrollbarCornerEvents","reconnectMutationObserver","mouseDownPosition","mouseDownSize","pageOffset","getCoordinates","eventIsTrusted","releaseCapture","screenX","screenY","setCapture","args","dependent","extensionOnName","targetCSSObject","prefix","zeroX","zeroY","transitionStr","assembledValue","strResult","valueArray","regExpString","regExpMain","RegExp","regExpValidate","properties","splitCssStyleByComma","$1","withCurrClassNameOption","withOldClassNameOption","appendix","appendClasses","condition","strOwnerDocument","strHTMLElement","parentWindow","nodeName","a1","a2","k","toFloat","num","textareaCursorPosition","selectionStart","rowCols","textareaValue","textareaLength","textareaRowSplit","textareaLastRow","textareaCurrentCursorRowSplit","textareaLastCol","classesOrAttrs","selectParentOrOnlyChildren","onlyChildren","selectParent","path","splits","splitsLength","extendObj","extendObjRoot","current","doAdd","initBodyScroll","_bodyMouseTouchDownListener","activeElement","focus","pluginTargetElements","optsIsPlainObj","newDefaultOptions","currDefaultOptions","osInstance","extensionName","extNameTypeString","fn","overlayScrollbars","_elements","factory"],"sourceRoot":""}