text: "use strict";
  
  /**
   * @class KTUtil  base utilize class that privides helper functions
   */
  
  // Polyfills
  /**
   * Element.matches() polyfill (simple version)
   * https://developer.mozilla.org/en-US/docs/Web/API/Element/matches#Polyfill
   */
  if (!Element.prototype.matches) {
  	Element.prototype.matches = Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
  }
  
  /**
   * Element.closest() polyfill
   * https://developer.mozilla.org/en-US/docs/Web/API/Element/closest#Polyfill
   */
  if (!Element.prototype.closest) {
  	if (!Element.prototype.matches) {
  		Element.prototype.matches = Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
  	}
  	Element.prototype.closest = function (s) {
  		var el = this;
  		var ancestor = this;
  		if (!document.documentElement.contains(el)) return null;
  		do {
  			if (ancestor.matches(s)) return ancestor;
  			ancestor = ancestor.parentElement;
  		} while (ancestor !== null);
  		return null;
  	};
  }
  
  /**
   * ChildNode.remove() polyfill
   * https://gomakethings.com/removing-an-element-from-the-dom-the-es6-way/
   * @author Chris Ferdinandi
   * @license MIT
   */
  (function (elem) {
  	for (var i = 0; i < elem.length; i++) {
  		if (!window[elem[i]] || 'remove' in window[elem[i]].prototype) continue;
  		window[elem[i]].prototype.remove = function () {
  			this.parentNode.removeChild(this);
  		};
  	}
  })(['Element', 'CharacterData', 'DocumentType']);
  
  
  //
  // requestAnimationFrame polyfill by Erik Möller.
  //  With fixes from Paul Irish and Tino Zijdel
  //
  //  http://paulirish.com/2011/requestanimationframe-for-smart-animating/
  //  http://my.opera.com/emoller/blog/2011/12/20/requestanimationframe-for-smart-er-animating
  //
  //  MIT license
  //
  (function() {
      var lastTime = 0;
      var vendors = ['webkit', 'moz'];
      for (var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {
          window.requestAnimationFrame = window[vendors[x] + 'RequestAnimationFrame'];
          window.cancelAnimationFrame =
              window[vendors[x] + 'CancelAnimationFrame'] || window[vendors[x] + 'CancelRequestAnimationFrame'];
      }
  
      if (!window.requestAnimationFrame)
          window.requestAnimationFrame = function(callback) {
              var currTime = new Date().getTime();
              var timeToCall = Math.max(0, 16 - (currTime - lastTime));
              var id = window.setTimeout(function() {
                  callback(currTime + timeToCall);
              }, timeToCall);
              lastTime = currTime + timeToCall;
              return id;
          };
  
      if (!window.cancelAnimationFrame)
          window.cancelAnimationFrame = function(id) {
              clearTimeout(id);
          };
  }());
  
  // Source: https://github.com/jserz/js_piece/blob/master/DOM/ParentNode/prepend()/prepend().md
  (function(arr) {
      arr.forEach(function(item) {
          if (item.hasOwnProperty('prepend')) {
              return;
          }
          Object.defineProperty(item, 'prepend', {
              configurable: true,
              enumerable: true,
              writable: true,
              value: function prepend() {
                  var argArr = Array.prototype.slice.call(arguments),
                      docFrag = document.createDocumentFragment();
  
                  argArr.forEach(function(argItem) {
                      var isNode = argItem instanceof Node;
                      docFrag.appendChild(isNode ? argItem : document.createTextNode(String(argItem)));
                  });
  
                  this.insertBefore(docFrag, this.firstChild);
              }
          });
      });
  })([Element.prototype, Document.prototype, DocumentFragment.prototype]);
  
  // getAttributeNames
  if (Element.prototype.getAttributeNames == undefined) {
    Element.prototype.getAttributeNames = function () {
      var attributes = this.attributes;
      var length = attributes.length;
      var result = new Array(length);
      for (var i = 0; i < length; i++) {
        result[i] = attributes[i].name;
      }
      return result;
    };
  }
  
  // Global variables
  window.KTUtilElementDataStore = {};
  window.KTUtilElementDataStoreID = 0;
  window.KTUtilDelegatedEventHandlers = {};
  
  var KTUtil = function() {
      var resizeHandlers = [];
  
      /** @type {object} breakpoints The device width breakpoints **/
      var breakpoints = {
          sm: 544, // Small screen / phone
          md: 768, // Medium screen / tablet
          lg: 992, // Large screen / desktop
          xl: 1200 // Extra large screen / wide desktop
      };
  
      /**
       * Handle window resize event with some
       * delay to attach event handlers upon resize complete
       */
      var _windowResizeHandler = function() {
          var _runResizeHandlers = function() {
              // reinitialize other subscribed elements
              for (var i = 0; i < resizeHandlers.length; i++) {
                  var each = resizeHandlers[i];
                  each.call();
              }
          };
  
          var timer;
  
          window.addEventListener('resize', function() {
              KTUtil.throttle(timer, function() {
                  _runResizeHandlers();
              }, 200);
          });
      };
  
      return {
          /**
           * Class main initializer.
           * @param {object} settings.
           * @returns null
           */
          //main function to initiate the theme
          init: function(settings) {
              if (settings && settings.breakpoints) {
                  breakpoints = settings.breakpoints;
              }
  
              _windowResizeHandler();
          },
  
          /**
           * Adds window resize event handler.
           * @param {function} callback function.
           */
          addResizeHandler: function(callback) {
              resizeHandlers.push(callback);
          },
  
          /**
           * Removes window resize event handler.
           * @param {function} callback function.
           */
          removeResizeHandler: function(callback) {
              for (var i = 0; i < resizeHandlers.length; i++) {
                  if (callback === resizeHandlers[i]) {
                      delete resizeHandlers[i];
                  }
              }
          },
  
          /**
           * Trigger window resize handlers.
           */
          runResizeHandlers: function() {
              _runResizeHandlers();
          },
  
          resize: function() {
              if (typeof(Event) === 'function') {
                  // modern browsers
                  window.dispatchEvent(new Event('resize'));
              } else {
                  // for IE and other old browsers
                  // causes deprecation warning on modern browsers
                  var evt = window.document.createEvent('UIEvents');
                  evt.initUIEvent('resize', true, false, window, 0);
                  window.dispatchEvent(evt);
              }
          },
  
          /**
           * Get GET parameter value from URL.
           * @param {string} paramName Parameter name.
           * @returns {string}
           */
          getURLParam: function(paramName) {
              var searchString = window.location.search.substring(1),
                  i, val, params = searchString.split("&");
  
              for (i = 0; i < params.length; i++) {
                  val = params[i].split("=");
                  if (val[0] == paramName) {
                      return unescape(val[1]);
                  }
              }
  
              return null;
          },
  
          /**
           * Checks whether current device is mobile touch.
           * @returns {boolean}
           */
          isMobileDevice: function() {
              var test = (this.getViewPort().width < this.getBreakpoint('lg') ? true : false);
  
              if (test === false) {
                  // For use within normal web clients
                  test = navigator.userAgent.match(/iPad/i) != null;
              }
  
              return test;
          },
  
          /**
           * Checks whether current device is desktop.
           * @returns {boolean}
           */
          isDesktopDevice: function() {
              return KTUtil.isMobileDevice() ? false : true;
          },
  
          /**
           * Gets browser window viewport size. Ref:
           * http://andylangton.co.uk/articles/javascript/get-viewport-size-javascript/
           * @returns {object}
           */
          getViewPort: function() {
              var e = window,
                  a = 'inner';
              if (!('innerWidth' in window)) {
                  a = 'client';
                  e = document.documentElement || document.body;
              }
  
              return {
                  width: e[a + 'Width'],
                  height: e[a + 'Height']
              };
          },
  
          /**
           * Checks whether given device mode is currently activated.
           * @param {string} mode Responsive mode name(e.g: desktop,
           *     desktop-and-tablet, tablet, tablet-and-mobile, mobile)
           * @returns {boolean}
           */
          isInResponsiveRange: function(mode) {
              var breakpoint = this.getViewPort().width;
  
              if (mode == 'general') {
                  return true;
              } else if (mode == 'desktop' && breakpoint >= (this.getBreakpoint('lg') + 1)) {
                  return true;
              } else if (mode == 'tablet' && (breakpoint >= (this.getBreakpoint('md') + 1) && breakpoint < this.getBreakpoint('lg'))) {
                  return true;
              } else if (mode == 'mobile' && breakpoint <= this.getBreakpoint('md')) {
                  return true;
              } else if (mode == 'desktop-and-tablet' && breakpoint >= (this.getBreakpoint('md') + 1)) {
                  return true;
              } else if (mode == 'tablet-and-mobile' && breakpoint <= this.getBreakpoint('lg')) {
                  return true;
              } else if (mode == 'minimal-desktop-and-below' && breakpoint <= this.getBreakpoint('xl')) {
                  return true;
              }
  
              return false;
          },
  
  		/**
           * Checks whether given device mode is currently activated.
           * @param {string} mode Responsive mode name(e.g: desktop,
           *     desktop-and-tablet, tablet, tablet-and-mobile, mobile)
           * @returns {boolean}
           */
          isBreakpointUp: function(mode) {
              var width = this.getViewPort().width;
  			var breakpoint = this.getBreakpoint(mode);
  
  			return (width >= breakpoint);
          },
  
  		isBreakpointDown: function(mode) {
              var width = this.getViewPort().width;
  			var breakpoint = this.getBreakpoint(mode);
  
  			return (width < breakpoint);
          },
  
          /**
           * Generates unique ID for give prefix.
           * @param {string} prefix Prefix for generated ID
           * @returns {boolean}
           */
          getUniqueID: function(prefix) {
              return prefix + Math.floor(Math.random() * (new Date()).getTime());
          },
  
          /**
           * Gets window width for give breakpoint mode.
           * @param {string} mode Responsive mode name(e.g: xl, lg, md, sm)
           * @returns {number}
           */
          getBreakpoint: function(mode) {
              return breakpoints[mode];
          },
  
          /**
           * Checks whether object has property matchs given key path.
           * @param {object} obj Object contains values paired with given key path
           * @param {string} keys Keys path seperated with dots
           * @returns {object}
           */
          isset: function(obj, keys) {
              var stone;
  
              keys = keys || '';
  
              if (keys.indexOf('[') !== -1) {
                  throw new Error('Unsupported object path notation.');
              }
  
              keys = keys.split('.');
  
              do {
                  if (obj === undefined) {
                      return false;
                  }
  
                  stone = keys.shift();
  
                  if (!obj.hasOwnProperty(stone)) {
                      return false;
                  }
  
                  obj = obj[stone];
  
              } while (keys.length);
  
              return true;
          },
  
          /**
           * Gets highest z-index of the given element parents
           * @param {object} el jQuery element object
           * @returns {number}
           */
          getHighestZindex: function(el) {
              var position, value;
  
              while (el && el !== document) {
                  // Ignore z-index if position is set to a value where z-index is ignored by the browser
                  // This makes behavior of this function consistent across browsers
                  // WebKit always returns auto if the element is positioned
                  position = KTUtil.css(el, 'position');
  
                  if (position === "absolute" || position === "relative" || position === "fixed") {
                      // IE returns 0 when zIndex is not specified
                      // other browsers return a string
                      // we ignore the case of nested elements with an explicit value of 0
                      // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
                      value = parseInt(KTUtil.css(el, 'z-index'));
  
                      if (!isNaN(value) && value !== 0) {
                          return value;
                      }
                  }
  
                  el = el.parentNode;
              }
  
              return null;
          },
  
          /**
           * Checks whether the element has any parent with fixed positionfreg
           * @param {object} el jQuery element object
           * @returns {boolean}
           */
          hasFixedPositionedParent: function(el) {
              var position;
  
              while (el && el !== document) {
                  position = KTUtil.css(el, 'position');
  
                  if (position === "fixed") {
                      return true;
                  }
  
                  el = el.parentNode;
              }
  
              return false;
          },
  
          /**
           * Simulates delay
           */
          sleep: function(milliseconds) {
              var start = new Date().getTime();
              for (var i = 0; i < 1e7; i++) {
                  if ((new Date().getTime() - start) > milliseconds) {
                      break;
                  }
              }
          },
  
          /**
           * Gets randomly generated integer value within given min and max range
           * @param {number} min Range start value
           * @param {number} max Range end value
           * @returns {number}
           */
          getRandomInt: function(min, max) {
              return Math.floor(Math.random() * (max - min + 1)) + min;
          },
  
          /**
           * Checks whether Angular library is included
           * @returns {boolean}
           */
          isAngularVersion: function() {
              return window.Zone !== undefined ? true : false;
          },
  
          // jQuery Workarounds
  
          // Deep extend:  $.extend(true, {}, objA, objB);
          deepExtend: function(out) {
              out = out || {};
  
              for (var i = 1; i < arguments.length; i++) {
                  var obj = arguments[i];
  
                  if (!obj)
                      continue;
  
                  for (var key in obj) {
                      if (obj.hasOwnProperty(key)) {
                          if (typeof obj[key] === 'object')
                              out[key] = KTUtil.deepExtend(out[key], obj[key]);
                          else
                              out[key] = obj[key];
                      }
                  }
              }
  
              return out;
          },
  
          // extend:  $.extend({}, objA, objB);
          extend: function(out) {
              out = out || {};
  
              for (var i = 1; i < arguments.length; i++) {
                  if (!arguments[i])
                      continue;
  
                  for (var key in arguments[i]) {
                      if (arguments[i].hasOwnProperty(key))
                          out[key] = arguments[i][key];
                  }
              }
  
              return out;
          },
  
          getById: function(el) {
              if (typeof el === 'string') {
                  return document.getElementById(el);
              } else {
                  return el;
              }
          },
  
          getByTag: function(query) {
              return document.getElementsByTagName(query);
          },
  
          getByTagName: function(query) {
              return document.getElementsByTagName(query);
          },
  
          getByClass: function(query) {
              return document.getElementsByClassName(query);
          },
  
          getBody: function() {
              return document.getElementsByTagName('body')[0];
          },
  
          /**
           * Checks whether the element has given classes
           * @param {object} el jQuery element object
           * @param {string} Classes string
           * @returns {boolean}
           */
          hasClasses: function(el, classes) {
              if (!el) {
                  return;
              }
  
              var classesArr = classes.split(" ");
  
              for (var i = 0; i < classesArr.length; i++) {
                  if (KTUtil.hasClass(el, KTUtil.trim(classesArr[i])) == false) {
                      return false;
                  }
              }
  
              return true;
          },
  
          hasClass: function(el, className) {
              if (!el) {
                  return;
              }
  
              return el.classList ? el.classList.contains(className) : new RegExp('\\b' + className + '\\b').test(el.className);
          },
  
          addClass: function(el, className) {
              if (!el || typeof className === 'undefined') {
                  return;
              }
  
              var classNames = className.split(' ');
  
              if (el.classList) {
                  for (var i = 0; i < classNames.length; i++) {
                      if (classNames[i] && classNames[i].length > 0) {
                          el.classList.add(KTUtil.trim(classNames[i]));
                      }
                  }
              } else if (!KTUtil.hasClass(el, className)) {
                  for (var x = 0; x < classNames.length; x++) {
                      el.className += ' ' + KTUtil.trim(classNames[x]);
                  }
              }
          },
  
          removeClass: function(el, className) {
            if (!el || typeof className === 'undefined') {
                  return;
              }
  
              var classNames = className.split(' ');
  
              if (el.classList) {
                  for (var i = 0; i < classNames.length; i++) {
                      el.classList.remove(KTUtil.trim(classNames[i]));
                  }
              } else if (KTUtil.hasClass(el, className)) {
                  for (var x = 0; x < classNames.length; x++) {
                      el.className = el.className.replace(new RegExp('\\b' + KTUtil.trim(classNames[x]) + '\\b', 'g'), '');
                  }
              }
          },
  
          triggerCustomEvent: function(el, eventName, data) {
              var event;
              if (window.CustomEvent) {
                  event = new CustomEvent(eventName, {
                      detail: data
                  });
              } else {
                  event = document.createEvent('CustomEvent');
                  event.initCustomEvent(eventName, true, true, data);
              }
  
              el.dispatchEvent(event);
          },
  
          triggerEvent: function(node, eventName) {
              // Make sure we use the ownerDocument from the provided node to avoid cross-window problems
              var doc;
              if (node.ownerDocument) {
                  doc = node.ownerDocument;
              } else if (node.nodeType == 9) {
                  // the node may be the document itself, nodeType 9 = DOCUMENT_NODE
                  doc = node;
              } else {
                  throw new Error("Invalid node passed to fireEvent: " + node.id);
              }
  
              if (node.dispatchEvent) {
                  // Gecko-style approach (now the standard) takes more work
                  var eventClass = "";
  
                  // Different events have different event classes.
                  // If this switch statement can't map an eventName to an eventClass,
                  // the event firing is going to fail.
                  switch (eventName) {
                  case "click": // Dispatching of 'click' appears to not work correctly in Safari. Use 'mousedown' or 'mouseup' instead.
                  case "mouseenter":
                  case "mouseleave":
                  case "mousedown":
                  case "mouseup":
                      eventClass = "MouseEvents";
                      break;
  
                  case "focus":
                  case "change":
                  case "blur":
                  case "select":
                      eventClass = "HTMLEvents";
                      break;
  
                  default:
                      throw "fireEvent: Couldn't find an event class for event '" + eventName + "'.";
                      break;
                  }
                  var event = doc.createEvent(eventClass);
  
                  var bubbles = eventName == "change" ? false : true;
                  event.initEvent(eventName, bubbles, true); // All events created as bubbling and cancelable.
  
                  event.synthetic = true; // allow detection of synthetic events
                  // The second parameter says go ahead with the default action
                  node.dispatchEvent(event, true);
              } else if (node.fireEvent) {
                  // IE-old school style
                  var event = doc.createEventObject();
                  event.synthetic = true; // allow detection of synthetic events
                  node.fireEvent("on" + eventName, event);
              }
          },
  
          index: function( el ){
              var c = el.parentNode.children, i = 0;
              for(; i < c.length; i++ )
                  if( c[i] == el ) return i;
          },
  
          trim: function(string) {
              return string.trim();
          },
  
          eventTriggered: function(e) {
              if (e.currentTarget.dataset.triggered) {
                  return true;
              } else {
                  e.currentTarget.dataset.triggered = true;
  
                  return false;
              }
          },
  
          remove: function(el) {
              if (el && el.parentNode) {
                  el.parentNode.removeChild(el);
              }
          },
  
          find: function(parent, query) {
              parent = KTUtil.getById(parent);
              if (parent) {
                  return parent.querySelector(query);
              }
          },
  
          findAll: function(parent, query) {
              parent = KTUtil.getById(parent);
              if (parent) {
                  return parent.querySelectorAll(query);
              }
          },
  
          insertAfter: function(el, referenceNode) {
              return referenceNode.parentNode.insertBefore(el, referenceNode.nextSibling);
          },
  
          parents: function(elem, selector) {
              // Element.matches() polyfill
              if (!Element.prototype.matches) {
                  Element.prototype.matches =
                      Element.prototype.matchesSelector ||
                      Element.prototype.mozMatchesSelector ||
                      Element.prototype.msMatchesSelector ||
                      Element.prototype.oMatchesSelector ||
                      Element.prototype.webkitMatchesSelector ||
                      function(s) {
                          var matches = (this.document || this.ownerDocument).querySelectorAll(s),
                              i = matches.length;
                          while (--i >= 0 && matches.item(i) !== this) {}
                          return i > -1;
                      };
              }
  
              // Set up a parent array
              var parents = [];
  
              // Push each parent element to the array
              for ( ; elem && elem !== document; elem = elem.parentNode ) {
                  if (selector) {
                      if (elem.matches(selector)) {
                          parents.push(elem);
                      }
                      continue;
                  }
                  parents.push(elem);
              }
  
              // Return our parent array
              return parents;
          },
  
          children: function(el, selector, log) {
              if (!el || !el.childNodes) {
                  return;
              }
  
              var result = [],
                  i = 0,
                  l = el.childNodes.length;
  
              for (var i; i < l; ++i) {
                  if (el.childNodes[i].nodeType == 1 && KTUtil.matches(el.childNodes[i], selector, log)) {
                      result.push(el.childNodes[i]);
                  }
              }
  
              return result;
          },
  
          child: function(el, selector, log) {
              var children = KTUtil.children(el, selector, log);
  
              return children ? children[0] : null;
          },
  
          matches: function(el, selector, log) {
              var p = Element.prototype;
              var f = p.matches || p.webkitMatchesSelector || p.mozMatchesSelector || p.msMatchesSelector || function(s) {
                  return [].indexOf.call(document.querySelectorAll(s), this) !== -1;
              };
  
              if (el && el.tagName) {
                  return f.call(el, selector);
              } else {
                  return false;
              }
          },
  
          data: function(el) {
              return {
                  set: function(name, data) {
                      if (!el) {
                          return;
                      }
  
                      if (el.customDataTag === undefined) {
                          window.KTUtilElementDataStoreID++;
                          el.customDataTag = window.KTUtilElementDataStoreID;
                      }
  
                      if (window.KTUtilElementDataStore[el.customDataTag] === undefined) {
                          window.KTUtilElementDataStore[el.customDataTag] = {};
                      }
  
                      window.KTUtilElementDataStore[el.customDataTag][name] = data;
                  },
  
                  get: function(name) {
                      if (!el) {
                          return;
                      }
  
                      if (el.customDataTag === undefined) {
                          return null;
                      }
  
                      return this.has(name) ? window.KTUtilElementDataStore[el.customDataTag][name] : null;
                  },
  
                  has: function(name) {
                      if (!el) {
                          return false;
                      }
  
                      if (el.customDataTag === undefined) {
                          return false;
                      }
  
                      return (window.KTUtilElementDataStore[el.customDataTag] && window.KTUtilElementDataStore[el.customDataTag][name]) ? true : false;
                  },
  
                  remove: function(name) {
                      if (el && this.has(name)) {
                          delete window.KTUtilElementDataStore[el.customDataTag][name];
                      }
                  }
              };
          },
  
          outerWidth: function(el, margin) {
              var width;
  
              if (margin === true) {
                  width = parseFloat(el.offsetWidth);
                  width += parseFloat(KTUtil.css(el, 'margin-left')) + parseFloat(KTUtil.css(el, 'margin-right'));
  
                  return parseFloat(width);
              } else {
                  width = parseFloat(el.offsetWidth);
  
                  return width;
              }
          },
  
          offset: function(el) {
              var rect, win;
  
              if ( !el ) {
                  return;
              }
  
              // Return zeros for disconnected and hidden (display: none) elements (gh-2310)
              // Support: IE <=11 only
              // Running getBoundingClientRect on a
              // disconnected node in IE throws an error
  
              if ( !el.getClientRects().length ) {
                  return { top: 0, left: 0 };
              }
  
              // Get document-relative position by adding viewport scroll to viewport-relative gBCR
              rect = el.getBoundingClientRect();
              win = el.ownerDocument.defaultView;
  
              return {
                  top: rect.top + win.pageYOffset,
                  left: rect.left + win.pageXOffset
              };
          },
  
          height: function(el) {
              return KTUtil.css(el, 'height');
          },
  
          outerHeight: function(el, withMargin) {
              var height = el.offsetHeight;
              var style;
  
              if (typeof withMargin !== 'undefined' && withMargin === true) {
                  style = getComputedStyle(el);
                  height += parseInt(style.marginTop) + parseInt(style.marginBottom);
  
                  return height;
              } else {
                  return height;
              }
          },
  
          visible: function(el) {
              return !(el.offsetWidth === 0 && el.offsetHeight === 0);
          },
  
          attr: function(el, name, value) {
              if (el == undefined) {
                  return;
              }
  
              if (value !== undefined) {
                  el.setAttribute(name, value);
              } else {
                  return el.getAttribute(name);
              }
          },
  
          hasAttr: function(el, name) {
              if (el == undefined) {
                  return;
              }
  
              return el.getAttribute(name) ? true : false;
          },
  
          removeAttr: function(el, name) {
              if (el == undefined) {
                  return;
              }
  
              el.removeAttribute(name);
          },
  
          animate: function(from, to, duration, update, easing, done) {
              /**
               * TinyAnimate.easings
               *  Adapted from jQuery Easing
               */
              var easings = {};
              var easing;
  
              easings.linear = function(t, b, c, d) {
                  return c * t / d + b;
              };
  
              easing = easings.linear;
  
              // Early bail out if called incorrectly
              if (typeof from !== 'number' ||
                  typeof to !== 'number' ||
                  typeof duration !== 'number' ||
                  typeof update !== 'function') {
                  return;
              }
  
              // Create mock done() function if necessary
              if (typeof done !== 'function') {
                  done = function() {};
              }
  
              // Pick implementation (requestAnimationFrame | setTimeout)
              var rAF = window.requestAnimationFrame || function(callback) {
                  window.setTimeout(callback, 1000 / 50);
              };
  
              // Animation loop
              var canceled = false;
              var change = to - from;
  
              function loop(timestamp) {
                  var time = (timestamp || +new Date()) - start;
  
                  if (time >= 0) {
                      update(easing(time, from, change, duration));
                  }
                  if (time >= 0 && time >= duration) {
                      update(to);
                      done();
                  } else {
                      rAF(loop);
                  }
              }
  
              update(from);
  
              // Start animation loop
              var start = window.performance && window.performance.now ? window.performance.now() : +new Date();
  
              rAF(loop);
          },
  
          actualCss: function(el, prop, cache) {
              var css = '';
  
              if (el instanceof HTMLElement === false) {
                  return;
              }
  
              if (!el.getAttribute('kt-hidden-' + prop) || cache === false) {
                  var value;
  
                  // the element is hidden so:
                  // making the el block so we can meassure its height but still be hidden
                  css = el.style.cssText;
                  el.style.cssText = 'position: absolute; visibility: hidden; display: block;';
  
                  if (prop == 'width') {
                      value = el.offsetWidth;
                  } else if (prop == 'height') {
                      value = el.offsetHeight;
                  }
  
                  el.style.cssText = css;
  
                  // store it in cache
                  el.setAttribute('kt-hidden-' + prop, value);
  
                  return parseFloat(value);
              } else {
                  // store it in cache
                  return parseFloat(el.getAttribute('kt-hidden-' + prop));
              }
          },
  
          actualHeight: function(el, cache) {
              return KTUtil.actualCss(el, 'height', cache);
          },
  
          actualWidth: function(el, cache) {
              return KTUtil.actualCss(el, 'width', cache);
          },
  
          getScroll: function(element, method) {
              // The passed in `method` value should be 'Top' or 'Left'
              method = 'scroll' + method;
              return (element == window || element == document) ? (
                  self[(method == 'scrollTop') ? 'pageYOffset' : 'pageXOffset'] ||
                  (browserSupportsBoxModel && document.documentElement[method]) ||
                  document.body[method]
              ) : element[method];
          },
  
          css: function(el, styleProp, value) {
              if (!el) {
                  return;
              }
  
              if (value !== undefined) {
                  el.style[styleProp] = value;
              } else {
                  var defaultView = (el.ownerDocument || document).defaultView;
                  // W3C standard way:
                  if (defaultView && defaultView.getComputedStyle) {
                      // sanitize property name to css notation
                      // (hyphen separated words eg. font-Size)
                      styleProp = styleProp.replace(/([A-Z])/g, "-$1").toLowerCase();
                      return defaultView.getComputedStyle(el, null).getPropertyValue(styleProp);
                  } else if (el.currentStyle) { // IE
                      // sanitize property name to camelCase
                      styleProp = styleProp.replace(/\-(\w)/g, function(str, letter) {
                          return letter.toUpperCase();
                      });
                      value = el.currentStyle[styleProp];
                      // convert other units to pixels on IE
                      if (/^\d+(em|pt|%|ex)?$/i.test(value)) {
                          return (function(value) {
                              var oldLeft = el.style.left,
                                  oldRsLeft = el.runtimeStyle.left;
                              el.runtimeStyle.left = el.currentStyle.left;
                              el.style.left = value || 0;
                              value = el.style.pixelLeft + "px";
                              el.style.left = oldLeft;
                              el.runtimeStyle.left = oldRsLeft;
                              return value;
                          })(value);
                      }
                      return value;
                  }
              }
          },
  
          slide: function(el, dir, speed, callback, recalcMaxHeight) {
              if (!el || (dir == 'up' && KTUtil.visible(el) === false) || (dir == 'down' && KTUtil.visible(el) === true)) {
                  return;
              }
  
              speed = (speed ? speed : 600);
              var calcHeight = KTUtil.actualHeight(el);
              var calcPaddingTop = false;
              var calcPaddingBottom = false;
  
              if (KTUtil.css(el, 'padding-top') && KTUtil.data(el).has('slide-padding-top') !== true) {
                  KTUtil.data(el).set('slide-padding-top', KTUtil.css(el, 'padding-top'));
              }
  
              if (KTUtil.css(el, 'padding-bottom') && KTUtil.data(el).has('slide-padding-bottom') !== true) {
                  KTUtil.data(el).set('slide-padding-bottom', KTUtil.css(el, 'padding-bottom'));
              }
  
              if (KTUtil.data(el).has('slide-padding-top')) {
                  calcPaddingTop = parseInt(KTUtil.data(el).get('slide-padding-top'));
              }
  
              if (KTUtil.data(el).has('slide-padding-bottom')) {
                  calcPaddingBottom = parseInt(KTUtil.data(el).get('slide-padding-bottom'));
              }
  
              if (dir == 'up') { // up
                  el.style.cssText = 'display: block; overflow: hidden;';
  
                  if (calcPaddingTop) {
                      KTUtil.animate(0, calcPaddingTop, speed, function(value) {
                          el.style.paddingTop = (calcPaddingTop - value) + 'px';
                      }, 'linear');
                  }
  
                  if (calcPaddingBottom) {
                      KTUtil.animate(0, calcPaddingBottom, speed, function(value) {
                          el.style.paddingBottom = (calcPaddingBottom - value) + 'px';
                      }, 'linear');
                  }
  
                  KTUtil.animate(0, calcHeight, speed, function(value) {
                      el.style.height = (calcHeight - value) + 'px';
                  }, 'linear', function() {
                      el.style.height = '';
                      el.style.display = 'none';
  
                      if (typeof callback === 'function') {
                          callback();
                      }
                  });
  
  
              } else if (dir == 'down') { // down
                  el.style.cssText = 'display: block; overflow: hidden;';
  
                  if (calcPaddingTop) {
                      KTUtil.animate(0, calcPaddingTop, speed, function(value) {//
                          el.style.paddingTop = value + 'px';
                      }, 'linear', function() {
                          el.style.paddingTop = '';
                      });
                  }
  
                  if (calcPaddingBottom) {
                      KTUtil.animate(0, calcPaddingBottom, speed, function(value) {
                          el.style.paddingBottom = value + 'px';
                      }, 'linear', function() {
                          el.style.paddingBottom = '';
                      });
                  }
  
                  KTUtil.animate(0, calcHeight, speed, function(value) {
                      el.style.height = value + 'px';
                  }, 'linear', function() {
                      el.style.height = '';
                      el.style.display = '';
                      el.style.overflow = '';
  
                      if (typeof callback === 'function') {
                          callback();
                      }
                  });
              }
          },
  
          slideUp: function(el, speed, callback) {
              KTUtil.slide(el, 'up', speed, callback);
          },
  
          slideDown: function(el, speed, callback) {
              KTUtil.slide(el, 'down', speed, callback);
          },
  
          show: function(el, display) {
              if (typeof el !== 'undefined') {
                  el.style.display = (display ? display : 'block');
              }
          },
  
          hide: function(el) {
              if (typeof el !== 'undefined') {
                  el.style.display = 'none';
              }
          },
  
          addEvent: function(el, type, handler, one) {
              if (typeof el !== 'undefined' && el !== null) {
                  el.addEventListener(type, handler);
              }
          },
  
          removeEvent: function(el, type, handler) {
              if (el !== null) {
                  el.removeEventListener(type, handler);
              }
          },
  
          on: function(element, selector, event, handler) {
              if (!selector) {
                  return;
              }
  
              var eventId = KTUtil.getUniqueID('event');
  
              window.KTUtilDelegatedEventHandlers[eventId] = function(e) {
                  var targets = element.querySelectorAll(selector);
                  var target = e.target;
  
                  while (target && target !== element) {
                      for (var i = 0, j = targets.length; i < j; i++) {
                          if (target === targets[i]) {
                              handler.call(target, e);
                          }
                      }
  
                      target = target.parentNode;
                  }
              }
  
              KTUtil.addEvent(element, event, window.KTUtilDelegatedEventHandlers[eventId]);
  
              return eventId;
          },
  
          off: function(element, event, eventId) {
              if (!element || !window.KTUtilDelegatedEventHandlers[eventId]) {
                  return;
              }
  
              KTUtil.removeEvent(element, event, window.KTUtilDelegatedEventHandlers[eventId]);
  
              delete window.KTUtilDelegatedEventHandlers[eventId];
          },
  
          one: function onetime(el, type, callback) {
              el.addEventListener(type, function callee(e) {
                  // remove event
                  if (e.target && e.target.removeEventListener) {
                      e.target.removeEventListener(e.type, callee);
                  }
  
                  // need to verify from https://themeforest.net/author_dashboard#comment_23615588
                  if (el && el.removeEventListener) {
  				    e.currentTarget.removeEventListener(e.type, callee);
  			    }
  
                  // call handler
                  return callback(e);
              });
          },
  
          hash: function(str) {
              var hash = 0,
                  i, chr;
  
              if (str.length === 0) return hash;
              for (i = 0; i < str.length; i++) {
                  chr = str.charCodeAt(i);
                  hash = ((hash << 5) - hash) + chr;
                  hash |= 0; // Convert to 32bit integer
              }
  
              return hash;
          },
  
          animateClass: function(el, animationName, callback) {
              var animation;
              var animations = {
                  animation: 'animationend',
                  OAnimation: 'oAnimationEnd',
                  MozAnimation: 'mozAnimationEnd',
                  WebkitAnimation: 'webkitAnimationEnd',
                  msAnimation: 'msAnimationEnd',
              };
  
              for (var t in animations) {
                  if (el.style[t] !== undefined) {
                      animation = animations[t];
                  }
              }
  
              KTUtil.addClass(el, 'animated ' + animationName);
  
              KTUtil.one(el, animation, function() {
                  KTUtil.removeClass(el, 'animated ' + animationName);
              });
  
              if (callback) {
                  KTUtil.one(el, animation, callback);
              }
          },
  
          transitionEnd: function(el, callback) {
              var transition;
              var transitions = {
                  transition: 'transitionend',
                  OTransition: 'oTransitionEnd',
                  MozTransition: 'mozTransitionEnd',
                  WebkitTransition: 'webkitTransitionEnd',
                  msTransition: 'msTransitionEnd'
              };
  
              for (var t in transitions) {
                  if (el.style[t] !== undefined) {
                      transition = transitions[t];
                  }
              }
  
              KTUtil.one(el, transition, callback);
          },
  
          animationEnd: function(el, callback) {
              var animation;
              var animations = {
                  animation: 'animationend',
                  OAnimation: 'oAnimationEnd',
                  MozAnimation: 'mozAnimationEnd',
                  WebkitAnimation: 'webkitAnimationEnd',
                  msAnimation: 'msAnimationEnd'
              };
  
              for (var t in animations) {
                  if (el.style[t] !== undefined) {
                      animation = animations[t];
                  }
              }
  
              KTUtil.one(el, animation, callback);
          },
  
          animateDelay: function(el, value) {
              var vendors = ['webkit-', 'moz-', 'ms-', 'o-', ''];
              for (var i = 0; i < vendors.length; i++) {
                  KTUtil.css(el, vendors[i] + 'animation-delay', value);
              }
          },
  
          animateDuration: function(el, value) {
              var vendors = ['webkit-', 'moz-', 'ms-', 'o-', ''];
              for (var i = 0; i < vendors.length; i++) {
                  KTUtil.css(el, vendors[i] + 'animation-duration', value);
              }
          },
  
          scrollTo: function(target, offset, duration) {
              var duration = duration ? duration : 500;
              var targetPos = target ? KTUtil.offset(target).top : 0;
              var scrollPos = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
              var from, to;
  
              if (offset) {
                  scrollPos += offset;
              }
  
              from = scrollPos;
              to = targetPos;
  
              KTUtil.animate(from, to, duration, function(value) {
                  document.documentElement.scrollTop = value;
                  document.body.parentNode.scrollTop = value;
                  document.body.scrollTop = value;
              }); //, easing, done
          },
  
          scrollTop: function(offset, duration) {
              KTUtil.scrollTo(null, offset, duration);
          },
  
          isArray: function(obj) {
              return obj && Array.isArray(obj);
          },
  
          ready: function(callback) {
              if (document.attachEvent ? document.readyState === "complete" : document.readyState !== "loading") {
                  callback();
              } else {
                  document.addEventListener('DOMContentLoaded', callback);
              }
          },
  
          isEmpty: function(obj) {
              for (var prop in obj) {
                  if (obj.hasOwnProperty(prop)) {
                      return false;
                  }
              }
  
              return true;
          },
  
          numberString: function(nStr) {
              nStr += '';
              var x = nStr.split('.');
              var x1 = x[0];
              var x2 = x.length > 1 ? '.' + x[1] : '';
              var rgx = /(\d+)(\d{3})/;
              while (rgx.test(x1)) {
                  x1 = x1.replace(rgx, '$1' + ',' + '$2');
              }
              return x1 + x2;
          },
  
          detectIE: function() {
              var ua = window.navigator.userAgent;
  
              // Test values; Uncomment to check result …
  
              // IE 10
              // ua = 'Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Trident/6.0)';
  
              // IE 11
              // ua = 'Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko';
  
              // Edge 12 (Spartan)
              // ua = 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36 Edge/12.0';
  
              // Edge 13
              // ua = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2486.0 Safari/537.36 Edge/13.10586';
  
              var msie = ua.indexOf('MSIE ');
              if (msie > 0) {
                  // IE 10 or older => return version number
                  return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);
              }
  
              var trident = ua.indexOf('Trident/');
              if (trident > 0) {
                  // IE 11 => return version number
                  var rv = ua.indexOf('rv:');
                  return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);
              }
  
              var edge = ua.indexOf('Edge/');
              if (edge > 0) {
                  // Edge (IE 12+) => return version number
                  return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);
              }
  
              // other browser
              return false;
          },
  
          isRTL: function() {
              var html = KTUtil.getByTagName('html')[0];
  
              if (html) {
                  return (KTUtil.attr(html, 'direction') == 'rtl');
              }
          },
  
          // Scroller
          scrollInit: function(element, options) {
              if (!element) {
                  return;
              }
  
              // Learn more: https://github.com/mdbootstrap/perfect-scrollbar#options
              var pluginDefOptions = {
                  wheelSpeed: 0.5,
                  swipeEasing: true,
                  wheelPropagation: false,
                  minScrollbarLength: 40,
                  maxScrollbarLength: 300,
                  suppressScrollX: true
              };
  
              options = KTUtil.deepExtend({}, pluginDefOptions, options);
  
              // Define init function
              function init() {
                  var ps;
                  var height;
  
                  // Get extra options via data attributes
                  var attrs = element.getAttributeNames();
                  if (attrs.length > 0) {
                      attrs.forEach(function(attrName) {
              			// more options; https://github.com/ganlanyuan/tiny-slider#options
              			if ((/^data-.*/g).test(attrName)) {
                              if (['scroll', 'height', 'mobile-height'].includes(optionName) == false) {
                                  var optionName = attrName.replace('data-', '').toLowerCase().replace(/(?:[\s-])\w/g, function(match) {
                  					return match.replace('-', '').toUpperCase();
                  				});
  
                                  options[optionName] = KTUtil.filterBoolean(element.getAttribute(attrName));
                              }
              			}
              		});
                  }
  
                  if (options.height instanceof Function) {
                      height = options.height.call();
                  } else {
                      if (KTUtil.isMobileDevice() === true && options.mobileHeight) {
                          height = parseInt(options.mobileHeight);
                      } else if (options.height) {
                          height = parseInt(options.height);
                      } else {
                          height = parseInt(KTUtil.css(element, 'height'));
                      }
                  }
  
                  if (height === false) {
                      KTUtil.scrollDestroy(element, true);
  
                      return;
                  }
  
                  height = parseInt(height);
  
                  // Destroy scroll on table and mobile modes
                  if ((options.mobileNativeScroll || options.disableForMobile) && KTUtil.isMobileDevice() === true) {
                      ps = KTUtil.data(element).get('ps');
                      if (ps) {
                          if (options.resetHeightOnDestroy) {
                              KTUtil.css(element, 'height', 'auto');
                          } else {
                              KTUtil.css(element, 'overflow', 'auto');
                              if (height > 0) {
                                  KTUtil.css(element, 'height', height + 'px');
                              }
                          }
  
                          ps.destroy();
                          ps = KTUtil.data(element).remove('ps');
                      } else if (height > 0){
                          KTUtil.css(element, 'overflow', 'auto');
                          KTUtil.css(element, 'height', height + 'px');
                      }
  
                      return;
                  }
  
                  if (height > 0) {
                      KTUtil.css(element, 'height', height + 'px');
                  }
  
                  if (options.desktopNativeScroll) {
                      KTUtil.css(element, 'overflow', 'auto');
                      return;
                  }
  
                  // Pass options via HTML Attributes
                  if (KTUtil.attr(element, 'data-window-scroll') == 'true') {
                       options.windowScroll = true;
                  }
  
                  // Init scroll
                  ps = KTUtil.data(element).get('ps');
  
                  if (ps) {
                      ps.update();
                  } else {
                      KTUtil.css(element, 'overflow', 'hidden');
                      KTUtil.addClass(element, 'scroll');
  
                      ps = new PerfectScrollbar(element, options);
  
                      KTUtil.data(element).set('ps', ps);
                  }
  
                  // Remember scroll position in cookie
                  var uid = KTUtil.attr(element, 'id');
  
                  // Todo:Consider using Localstorage
                  if (options.rememberPosition === true && KTCookie && uid) {
                      if (KTCookie.getCookie(uid)) {
                          var pos = parseInt(KTCookie.getCookie(uid));
  
                          if (pos > 0) {
                              element.scrollTop = pos;
                          }
                      }
  
                      element.addEventListener('ps-scroll-y', function() {
                          KTCookie.setCookie(uid, element.scrollTop);
                      });
                  }
              }
  
              // Init
              init();
  
              // Handle window resize
              if (options.handleWindowResize) {
                  KTUtil.addResizeHandler(function() {
                      init();
                  });
              }
          },
  
          scrollUpdate: function(element) {
              var ps = KTUtil.data(element).get('ps');
              if (ps) {
                  ps.update();
              }
          },
  
          scrollUpdateAll: function(parent) {
              var scrollers = KTUtil.findAll(parent, '.ps');
              for (var i = 0, len = scrollers.length; i < len; i++) {
                  KTUtil.scrollUpdate(scrollers[i]);
              }
          },
  
          scrollDestroy: function(element, resetAll) {
              var ps = KTUtil.data(element).get('ps');
  
              if (ps) {
                  ps.destroy();
                  ps = KTUtil.data(element).remove('ps');
              }
  
              if (element && resetAll) {
                  element.style.setProperty('overflow', '');
                  element.style.setProperty('height', '');
              }
          },
  
          filterBoolean: function(val) {
              // Convert string boolean
  			if (val === true || val === 'true') {
  				return true;
  			}
  
  			if (val === false || val === 'false') {
  				return false;
  			}
  
              return val;
          },
  
          setHTML: function(el, html) {
              el.innerHTML = html;
          },
  
          getHTML: function(el) {
              if (el) {
                  return el.innerHTML;
              }
          },
  
          getDocumentHeight: function() {
              var body = document.body;
              var html = document.documentElement;
  
              return Math.max( body.scrollHeight, body.offsetHeight, html.clientHeight, html.scrollHeight, html.offsetHeight );
          },
  
          getScrollTop: function() {
              return  (document.scrollingElement || document.documentElement).scrollTop;
          },
  
          changeColor: function(col, amt) {
  
              var usePound = false;
  
              if (col[0] == "#") {
                  col = col.slice(1);
                  usePound = true;
              }
  
              var num = parseInt(col,16);
  
              var r = (num >> 16) + amt;
  
              if (r > 255) r = 255;
              else if  (r < 0) r = 0;
  
              var b = ((num >> 8) & 0x00FF) + amt;
  
              if (b > 255) b = 255;
              else if  (b < 0) b = 0;
  
              var g = (num & 0x0000FF) + amt;
  
              if (g > 255) g = 255;
              else if (g < 0) g = 0;
  
              return (usePound?"#":"") + (g | (b << 8) | (r << 16)).toString(16);
  
          },
  
          // Throttle function: Input as function which needs to be throttled and delay is the time interval in milliseconds
          throttle:  function (timer, func, delay) {
          	// If setTimeout is already scheduled, no need to do anything
          	if (timer) {
          		return;
          	}
  
          	// Schedule a setTimeout after delay seconds
          	timer  =  setTimeout(function () {
          		func();
  
          		// Once setTimeout function execution is finished, timerId = undefined so that in <br>
          		// the next scroll event function execution can be scheduled by the setTimeout
          		timer  =  undefined;
          	}, delay);
          },
  
          // Debounce function: Input as function which needs to be debounced and delay is the debounced time in milliseconds
          debounce: function (timer, func, delay) {
          	// Cancels the setTimeout method execution
          	clearTimeout(timer)
  
          	// Executes the func after delay time.
          	timer  =  setTimeout(func, delay);
          },
  
          btnWait: function(el, cls, message, disable) {
              if (!el) {
                  return;
              }
  
              if (typeof disable !== 'undefined' && disable === true) {
                  KTUtil.attr(el, "disabled", true);
              }
  
              if (cls) {
                  KTUtil.addClass(el, cls);
                  KTUtil.attr(el, "wait-class", cls);
              }
  
              if (message) {
                  var caption = KTUtil.find(el, '.btn-caption');
  
                  if (caption) {
                      KTUtil.data(caption).set('caption', KTUtil.getHTML(caption));
                      KTUtil.setHTML(caption, message);
                  } else {
                      KTUtil.data(el).set('caption', KTUtil.getHTML(el));
                      KTUtil.setHTML(el, message);
                  }
              }
          },
  
          btnRelease: function(el) {
              if (!el) {
                  return;
              }
  
              /// Show loading state on button
              KTUtil.removeAttr(el, "disabled");
  
              if (KTUtil.hasAttr(el, "wait-class")) {
                  KTUtil.removeClass(el, KTUtil.attr(el, "wait-class"));
              }
  
              var caption = KTUtil.find(el, '.btn-caption');
  
              if (caption && KTUtil.data(caption).has('caption')) {
                  KTUtil.setHTML(caption, KTUtil.data(caption).get('caption'));
              } else if (KTUtil.data(el).has('caption')) {
                  KTUtil.setHTML(el, KTUtil.data(el).get('caption'));
              }
          },
  
          isOffscreen: function(el, direction, offset) {
              offset = offset || 0;
  
              var windowWidth = KTUtil.getViewPort().width;
              var windowHeight = KTUtil.getViewPort().height;
  
              var top = KTUtil.offset(el).top;
              var height = KTUtil.outerHeight(el) + offset;
              var left = KTUtil.offset(el).left;
              var width = KTUtil.outerWidth(el) + offset;
  
              if (direction == 'bottom') {
                  if (windowHeight < top + height) {
                      return true;
                  } else if (windowHeight > top + height * 1.5) {
                      return true;
                  }
              }
  
              if (direction == 'top') {
                  if (top < 0) {
                      return true;
                  } else if (top > height) {
                      return true;
                  }
              }
  
              if (direction == 'left') {
                  if (left < 0) {
                      return true;
                  } else if (left * 2 > width) {
                      //console.log('left 2');
                      //return true;
                  }
              }
  
              if (direction == 'right') {
                  if (windowWidth < left + width) {
                      return true;
                  } else {
                      //console.log('right 2');
                      //return true;
                  }
              }
  
              return false;
          }
      }
  }();
  
  // webpack support
  if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
      module.exports = KTUtil;
  }
  
  // Initialize KTUtil class on document ready
  KTUtil.ready(function() {
  	if (typeof KTAppSettings !== 'undefined') {
  		KTUtil.init(KTAppSettings);
  	} else {
  		KTUtil.init();
  	}
  });
  
  // CSS3 Transitions only after page load(.page-loading class added to body tag and remove with JS on page load)
  window.onload = function() {
      var result = KTUtil.getByTagName('body');
      if (result && result[0]) {
          KTUtil.removeClass(result[0], 'page-loading');
      }
  }
  