/* --------------------------------------------------------------------------------------
 * tooltip.js
 * version 1.50
 * @20100214
-------------------------------------------------------------------------------------- */
var VCOMN;
if (!VCOMN) {
  VCOMN = {};
}

/* version 1.30 or earlier compatible code */
function EventObserve(elem,name,func,cap){VCOMN.EventObserve(elem,name,func,cap);};
function fncSwapImage(){VCOMN.swapImage();}
function comHasClass(id,className){VCOMN.hasClass(id,className);}
function comAddClass(id,addClassStr){VCOMN.addClass(id, addClassStr);}
function comRemoveClass(id,removeClassStr){VCOMN.removeClass(id,removeClassStr);}
function comSetCookie(cookieName,cookieVal,expireDay,domain,path){VCOMN.setCookie(cookieName,cookieVal,expireDay,domain,path);}
function comGetCookie(cookieName){VCOMN.getCookie(cookieName);}
function fncWinOpenBase(src,type){VCOMN.winOpenBase(src, type);}
function fncWinOpen(src){VCOMN.winOpen(src);}
function fncWinLiquidOpen(src){VCOMN.winLiquidOpen(src);}
function fncWinFixOpen(src){VCOMN.winFixOpen(src);}
function fncWinClose(){VCOMN.winClose();}
function fncWinChange(src){VCOMN.winChange(src);}
function fncWinChangeAndClose(src){VCOMN.winChangeAndClose(src);}
function fncWinCheckOpener(){VCOMN.winCheckOpener();}
function popupWindow(url){VCOMN.popupWindow(url);}
function fncSmoothScroll(id){VCOMN.smoothScroll(id);}
function fncPagePrint(tags){VCOMN.pagePrint(tags);}

// =====================================
// Utility Functions
// =====================================

// --------------------
// Browser check
// --------------------
VCOMN.env = {
  isIE:     !!(window.attachEvent && !window.opera),
  isOpera:  !!window.opera,
  isSafari: navigator.userAgent.indexOf('AppleWebKit/') > -1,
  isGecko:  navigator.userAgent.indexOf('Gecko') > -1 && navigator.userAgent.indexOf('KHTML') == -1,
  isNN:     document.layers
};

(function() {
  var _start = 
    navigator.userAgent.indexOf('MSIE') > -1 ? (navigator.userAgent.indexOf('MSIE') + 5) :
    navigator.userAgent.indexOf('Opera') > -1 ? (navigator.userAgent.indexOf('Opera') + 6) :
    navigator.userAgent.indexOf('Version') > -1 ? (navigator.userAgent.indexOf('Version') + 8) :
    navigator.userAgent.indexOf('Gecko') > -1 ? (navigator.userAgent.lastIndexOf('/') + 1) :
    navigator.userAgent.indexOf('Mozilla') > -1 ? (navigator.userAgent.indexOf('Mozilla') + 8) : 0;
  var _match =  navigator.userAgent.substr(_start).match(/^([\d\.]*)/);
  VCOMN.env.version = _match ? _match[0] : '';
})();

VCOMN.env.os =
  navigator.appVersion.indexOf('Mac') > -1 ? 'Macintosh' :
  navigator.appVersion.indexOf('Win') > -1 ? 'Windows' :
  navigator.appVersion.indexOf('Linux') > -1 ? 'Linux' :
  'Unknown';


VCOMN.DOM = {};
VCOMN.DOM.loaded = false;
VCOMN.DOM.onLoadeds = [];
/* --------------------------------------------------------------------------------------
 * DOM loaded function
 *   ObserveDOMLoaded
-------------------------------------------------------------------------------------- */
VCOMN.ObserveDOMLoaded = function() {
  if (arguments.length < 1) return;
  var func = arguments[0];
  var object = arguments[1] || this;
  var args = [];
  for (var i = 2; i < arguments.length; i++) {
    args[args.length] = arguments[i];
  }
  if (VCOMN.DOM.loaded) {
    func.apply(object, args);
  } else {
    VCOMN.DOM.onLoadeds[VCOMN.DOM.onLoadeds.length] = {func: func, object: object, args: args};
  }
};

(function() {
  var timer = null;
  function onLoaded() {
    if(VCOMN.DOM.loaded) return;
    VCOMN.DOM.loaded = true;
    if (timer){
       clearInterval(timer);
       timer = null;
    }
    var loaded;
    for (var i = 0; i < VCOMN.DOM.onLoadeds.length; i++) {
      loaded = VCOMN.DOM.onLoadeds[i];
      loaded.func.apply(loaded.object, loaded.args);
    }
    VCOMN.DOM.onLoadeds = [];
  }
  var d = document;
  if (d.addEventListener) {
    if (navigator.userAgent.match(/webkit|safari|khtml/i)) {// for Safari
      timer = setInterval(function() {
        if (d.readyState.match(/loaded|complete/)) {
          onLoaded();
        }
      }, 0);
    } else { // for Mozilla/Opera9
      d.addEventListener('DOMContentLoaded', onLoaded, false);
    }
  } else {
    // for IE
    d.write('<script id="_decoy_" defer src=//:><\/script>');
    d.getElementById('_decoy_').onreadystatechange = function() {
      if (this.readyState == 'complete') {
        onLoaded();
      }
    }
  }
})();

/* --------------------------------------------------------------------------------------
 * bind function
 *   bindFunc
-------------------------------------------------------------------------------------- */
VCOMN.bindFunc = function(method, object) {
  var args = [];
  for (var i = 2; i < arguments.length; i++) {
    args[args.length] = arguments[i];
  }
  return function () {
    var _args = [];
    for (var i = 0; i < arguments.length; i++) {
      _args[_args.length] = arguments[i];
    }
    return method.apply(object, args.concat(_args));
  }
};

/* --------------------------------------------------------------------------------------
 * Event Observe
 *   EventObserve
-------------------------------------------------------------------------------------- */
VCOMN.EventObserve = function(elem, name, func, cap) {
  if(elem.addEventListener){
    elem.addEventListener(name, func, cap);
  }else if(elem.attachEvent){
    elem.attachEvent('on' + name, func);
  }
};

/* --------------------------------------------------------------------------------------
 * get element node list by class name
 *   getElementsByClassName
-------------------------------------------------------------------------------------- */
VCOMN.getElementsByClassName = function (className, elem) {
  elem = elem || document;
  if (typeof elem.getElementsByClassName == 'function') {
    return elem.getElementsByClassName(className);
  }
  if (document.evaluate) {
    var results = new Array();
    var q = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
    var ret = document.evaluate(q, elem, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
    for (var i = 0, len = ret.snapshotLength; i < len; i++) {
      results.push(ret.snapshotItem(i));
    }
    return results;
  }
  elem = elem || document.body;
  var elems = elem.getElementsByTagName('*');
  var res = new Array();
  for (var i = 0; i < elems.length; i++) {
    if (VCOMN.hasClass(elems[i], className)) {
      res[res.length] = elems[i];
    }
  }
  return res;
}

/* --------------------------------------------------------------------------------------
 * set element opacity
 * 0.0 - 1.0, ''
 *   setOpacity
-------------------------------------------------------------------------------------- */
VCOMN.setOpacity = function (elem, value) {
  if (VCOMN.env.isIE) {
    function stripAlpha(filter){
      return filter.replace(/alpha\([^\)]*\)/gi,'');
    }
    var currentStyle = elem.currentStyle;
    if ((currentStyle && !currentStyle.hasLayout) ||
      (!currentStyle && elem.style.zoom == 'normal')) {
      elem.style.zoom = 1;
    }

    var filter = elem.style.filter;
    var style = elem.style;
    if (value == 1 || value === '') {
      (filter = stripAlpha(filter)) ?
        style.filter = filter : style.removeAttribute('filter');
      return;
    } else if (value < 0.00001) {
      value = 0;
    }
    style.filter = stripAlpha(filter) + 'alpha(opacity=' + (value * 100) + ')';
  } else {
    var opacity = (value == 1 || value === '') ? '' : (value < 0.00001) ? 0 : value;
    if (value == 1 && VCOMN.env.isGecko && /rv:1\.8\.0/.test(navigator.userAgent)) {
      opacity = 0.999999;
    }
    elem.style.opacity = opacity;
    if (value == 1 && VCOMN.env.isSafari) {
      if(elem.tagName.toUpperCase() == 'IMG' && elem.width) {
        elem.width++; elem.width--;
      } else try {
        var n = document.createTextNode(' ');
        elem.appendChild(n);
        elem.removeChild(n);
      } catch (e) { }
    }
  }
}

/* --------------------------------------------------------------------------------------
 * get element opacity
 * 0.0 - 1.0, ''
 *   getOpacity
-------------------------------------------------------------------------------------- */
VCOMN.getOpacity = function (elem, value) {
  var style = VCOMN.env.isIE ? 'filter' : 'opacity';
  var value = element.style[style];
  if (!value || value == 'auto') {
    var css = document.defaultView.getComputedStyle(elem, null);
    value = css ? css[style] : '';
  }
  if (value) {
    if (style == 'opacity') {
      return parseFloat(value);
    }
    if (value = value.match(/alpha\(opacity=(.*)\)/)) {
      if (value[1]) {
        return parseFloat(value[1]) / 100;
      }
    }
  }
  return 1.0;
}

/* --------------------------------------------------------------------------------------
 * cumulative offset
 *   cumulativeOffset
-------------------------------------------------------------------------------------- */
VCOMN.cumulativeOffset = function(element) {
  var valueT = 0, valueL = 0;
  do {
    valueT += element.offsetTop  || 0;
    valueL += element.offsetLeft || 0;
    element = element.offsetParent;
  } while (element);
  return [valueL, valueT];
};

/* --------------------------------------------------------------------------------------
 * get browser size
 *   getBrowserSize
-------------------------------------------------------------------------------------- */
VCOMN.getBrowserSize = function() {
  if (document.documentElement && document.documentElement.clientWidth) {
    return [document.documentElement.clientWidth, document.documentElement.clientHeight];
  } else if (document.body) {
    return [document.body.clientWidth, document.body.clientHeight];
  } else if (window.innerWidth) {
    return [window.innerWidth, window.innerHeight];
  }
  return [0, 0];
};

/* --------------------------------------------------------------------------------------
 * get mouse coordinates
 *   getMousePosition
-------------------------------------------------------------------------------------- */
VCOMN.getMousePosition = function (evt) {
  var x = (evt && evt.pageX !== undefined) ? evt.pageX : event.clientX + (document.body.scrollLeft || document.documentElement.scrollLeft);
  var y = (evt && evt.pageY !== undefined) ? evt.pageY : event.clientY + (document.body.scrollTop || document.documentElement.scrollTop);
  return {x: x, y: y};
}


/* --------------------------------------------------------------------------------------
 * Add Child Class
 *   addChildClass
-------------------------------------------------------------------------------------- */
VCOMN.addChildClass = function(parent) {
  var CLASS_NAME = {
    TARGET: 'hasChild',
    HAS_E: 'hasE',
    HAS_O: 'hasO',
    HAS_EO: 'hasEO',
    FIRST: 'firstChild',
    LAST: 'lastChild',
    ODD: 'odd',
    EVEN: 'even',
    NEST: 'nest'
  };
  function _addChildClass(parent) {
    var childs = [];
    for (var i = 0; i < parent.childNodes.length; i++) {
      if (parent.childNodes[i].nodeType == 1) {
        childs.push(parent.childNodes[i]);
      }
    }
    var nest_interval = -1;
    var nest_repeat = false;
    var matched = parent.className.match(/(^|\s)has(\d+)(n?)(\s|$)/);
    if (matched) {
      nest_interval = +matched[2];
      nest_repeat = !!matched[3];
    }
    VCOMN.addClass(childs[0], CLASS_NAME.FIRST);
    VCOMN.addClass(childs[childs.length - 1], CLASS_NAME.LAST);
    var hasE = VCOMN.hasClass(parent, CLASS_NAME.HAS_E) || VCOMN.hasClass(parent, CLASS_NAME.HAS_EO);
    var hasO = VCOMN.hasClass(parent, CLASS_NAME.HAS_O) || VCOMN.hasClass(parent, CLASS_NAME.HAS_EO);
    for (var i = 0; i < childs.length; i++) {
      if (i % 2 == 0 && hasO) {
        VCOMN.addClass(childs[i], CLASS_NAME.ODD);
      }
      if (i % 2 == 1 && hasE) {
        VCOMN.addClass(childs[i], CLASS_NAME.EVEN);
      }
      if (nest_interval - 1 == i || (nest_repeat && (i + 1) % nest_interval == 0)) {
        VCOMN.addClass(childs[i], CLASS_NAME.NEST);
      }
    }
  }
  if (!parent || !parent.getElementsByTagName) {
    parent = document;
  }
  if (VCOMN.hasClass(parent, CLASS_NAME.TARGET)) {
    _addChildClass(parent);
  } else {
    var elements = VCOMN.getElementsByClassName(CLASS_NAME.TARGET, parent);
    for (var i = 0; i < elements.length; i++) {
      _addChildClass(elements[i]);
    }
  }
}

VCOMN.ObserveDOMLoaded(VCOMN.addChildClass);

/* get element */
VCOMN.getElement = function(elem) {
  if (typeof elem == 'string') {
    elem = document.getElementById(elem);
  }
  return elem;
}

/* get className */
VCOMN.hasClass = function(id, className) {
  var elem = VCOMN.getElement(id);
  if (!elem || elem.className == undefined) return false;
  var elementClassName = elem.className;
  if (elementClassName.length == 0) return false;
  if (elementClassName == className ||
    elementClassName.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
    return true;
  return false;
}
/* add className */
VCOMN.addClass = function(id, addClassStr) {
  var elem = VCOMN.getElement(id);
  if (!elem || elem.className == undefined) return false;
  if(elem.className == ''){
    elem.className = addClassStr;
  } else if (!VCOMN.hasClass(elem, addClassStr)) {
    elem.className += ' ' + addClassStr;
  }
}
/* remove className */
VCOMN.removeClass = function(id, removeClassStr) {
  var elem = VCOMN.getElement(id);
  if (!elem || elem.className == undefined) return false;
  if (!VCOMN.hasClass(elem, removeClassStr)) return;
  var classes = elem.className.split(' ');
  var defaultClassName= '';
  for (var i=0; i < classes.length; i++){
    if (classes[i] != removeClassStr) {
      defaultClassName += classes[i] + ' ';
    }
  }
  elem.className = defaultClassName;
}
/* set cookie */
VCOMN.setCookie = function(cookieName, cookieVal, expireDay, domain, path) {
  var cookie = cookieName + '=' + escape(cookieVal);
  if (expireDay >= 10000) {
    cookie += '; expires=Tue, 19 Jan 2038 00:00:00 UTC';
  } else if (+expireDay == expireDay && expireDay != '') {
    cookie += '; expires=' + new Date(new Date().getTime() + expireDay*24*60*60*1000).toGMTString();
  }
  if (domain) {
    cookie += '; domain=' + domain;
  }
  if (path) {
    cookie += '; path=' + path;
  }
  document.cookie = cookie;
}
/* get cookie */
VCOMN.getCookie = function(cookieName) {
  var isName = cookieName + "=";
  var isCookie = document.cookie + ";";
  startPos = isCookie.indexOf(isName);
  if (startPos != -1) {
    endPos = isCookie.indexOf(";", startPos);
    var isVal = unescape(isCookie.substring(startPos + isName.length, endPos));
  }
  if(isVal){
    return isVal;
  }
}

// tooltip.js
// ver 1.0.0
// require common.js v1.5.0 or later
// @20100214

VCOMN.ObserveDOMLoaded(fncToolTip, null, {inner_tag_name: 'div', inner_tag_class: 'ttTooltipBoxTxt', position_x: 10, position_y: 20, position_standard:'top-left'});


var VCOMN;
if (!VCOMN) {
  VCOMN = {};
}

function fncToolTip(opt) {
  new VCOMN.ToolTip(opt);
}

VCOMN.ToolTip = function() {this.initialize.apply(this, arguments)}

VCOMN.ToolTip.prototype = {
  CLASS_NAME: {
    TOOLTIP: 'ttTooltip',
    TOOLTIPBOX: 'ttTooltipBox'
  },
  ID_PREXFIX: {
    TOOLTIP: 'ttTooltip',
    TRIGGER: 'ttTrigger'
  },
  INNER_TAG: {
    NAME: '',
    CLASS: ''
  },
  POSITION: {
    BASE: 'mouse',
    STANDARD: 'top-left',
    X: 5,
    Y: 5
  },
  initialize: function (opt) {
    opt = opt || {};
    this.opt = {};
    this.opt.inner_tag_name = opt.inner_tag_name !== undefined ? opt.inner_tag_name : this.INNER_TAG.NAME;
    this.opt.inner_tag_class = opt.inner_tag_class !== undefined ? opt.inner_tag_class : this.INNER_TAG.CLASS;
    this.opt.class_name_tooltip = opt.class_name_tooltip || this.CLASS_NAME.TOOLTIP;
    this.opt.class_name_tooltipbox = opt.class_name_tooltipbox || this.CLASS_NAME.TOOLTIPBOX;
    this.opt.id_prefix_tooltip = opt.id_prefix_tooltip || this.ID_PREXFIX.TOOLTIP;
    this.opt.id_prefix_trigger = opt.id_prefix_trigger || this.ID_PREXFIX.TRIGGER;
    this.opt.opacity = opt.opacity || 1.0;
    this.opt.position = {};
    this.opt.position.base = opt.position_base || this.POSITION.BASE;
    this.opt.position.standard = opt.position_standard || this.POSITION.STANDARD;
    this.opt.position.x = opt.position_x !== undefined ? opt.position_x : this.POSITION.X;
    this.opt.position.y = opt.position_y !== undefined ? opt.position_y : this.POSITION.Y;
    this.targets = {};
    var tips = VCOMN.getElementsByClassName(this.opt.class_name_tooltip);
    for (var i = 0; i < tips.length; i++) {
      var suffix = tips[i].id.replace(this.opt.id_prefix_tooltip, '');
      var trigger = document.getElementById(this.opt.id_prefix_trigger + suffix);
      if (!trigger) {
        continue;
      }
      VCOMN.EventObserve(trigger, 'mouseover', 
        VCOMN.bindFunc(this.onMouseOver, this, trigger, tips[i]),
        false);
      VCOMN.EventObserve(trigger, 'mouseout', 
        VCOMN.bindFunc(this.onMouseOut, this, trigger, tips[i]),
        false);
      VCOMN.EventObserve(tips[i], 'mouseover', 
        VCOMN.bindFunc(this.onTipMouseOver, this, trigger, tips[i]),
        false);
      VCOMN.EventObserve(tips[i], 'mouseout', 
        VCOMN.bindFunc(this.onTipMouseOut, this, trigger, tips[i]),
        false);
      this.targets[i] = {
        trigger: trigger,
        tooltip: tips[i]
      };
    }
  },
  onTipMouseOver: function (triggerElem, targetElem) {
    targetElem._over = true;
  },
  onTipMouseOut: function (triggerElem, targetElem) {
    targetElem._over = false;
    if (!triggerElem._over) {
      this.onMouseOut(triggerElem, targetElem);
    }
  },
  onMouseOver: function (triggerElem, targetElem, e) {
    triggerElem._over = true;
    this.setTooltip(triggerElem, targetElem, e);
  },
  onMouseMove: function (triggerElem, targetElem, e) {
    if (this.opt.position.base != 'mouse') {
      return;
    }
    var mouse = VCOMN.getMousePosition(e);
    var pos = VCOMN.cumulativeOffset(triggerElem);
    this.setTargetPosition(targetElem, mouse.x + this.opt.position.x, mouse.y + this.opt.position.y);
  },
  onMouseOut: function (triggerElem, targetElem) {
    setTimeout(VCOMN.bindFunc(this.onMouseOutCB, this, triggerElem, targetElem), 0);
    triggerElem._over = false;
  },
  onMouseOutCB: function (triggerElem, targetElem) {
    if (triggerElem._over || targetElem._over) {
      return;
    }
    this.backTooltip(triggerElem, targetElem);
  },
  setTargetPosition: function (targetElem, x, y) {
    var documentElement = document.documentElement;
    var body = document.body;
    if (!this.opt.position.standards) {
      this.opt.position.standards = {};
      var _splits = this.opt.position.standard.split('-');
      for (var i = 0; i < _splits.length; i++) {
        if (_splits[i]) {
          this.opt.position.standards[_splits[i]] = true;
        }
      }
    }
    if (this.opt.position.standards.right) {
      x -= targetElem.clientWidth;
    }
    if (this.opt.position.standards.bottom) {
      y -= targetElem.clientHeight;
    }
    var browser = VCOMN.getBrowserSize();
    var scrollLeft = document.body.scrollLeft || document.documentElement.scrollLeft;
    var scrollTop = document.body.scrollTop || document.documentElement.scrollTop;
    if (x + targetElem.clientWidth > browser[0] + scrollLeft) {
      x = browser[0] + scrollLeft - targetElem.clientWidth;
      if (x < scrollLeft && !this.opt.position.standards.right) {
        x = scrollLeft;
      }
    } else if (x < scrollLeft) {
      x = scrollLeft;
    }
    if (y + targetElem.clientHeight > browser[1] + scrollTop) {
      y = browser[1] + scrollTop - targetElem.clientHeight;
      if (y < scrollTop && !this.opt.position.standards.bottom) {
        y = scrollTop;
      }
    } else if (y < scrollTop) {
      y = scrollTop;
    }
    targetElem.style.left = x + 'px';
    targetElem.style.top = y + 'px';
  },
  setTooltip: function (triggerElem, targetElem, e) {
    VCOMN.addClass(targetElem, this.opt.class_name_tooltipbox);
    VCOMN.removeClass(targetElem, this.opt.class_name_tooltip);
    if (this.opt.inner_tag_name && this.opt.inner_tag_class) {
      var test = VCOMN.getElementsByClassName(this.opt.inner_tag_class, targetElem);
      if (!test || !test.length) {
        var inner = document.createElement(this.opt.inner_tag_name);
        inner.className = this.opt.inner_tag_class;
        while (targetElem.firstChild) {
          inner.appendChild(targetElem.firstChild);
        }
        targetElem.appendChild(inner);
      }
    }
    VCOMN.setOpacity(targetElem, this.opt.opacity);
    targetElem.style.position = 'absolute';
    var x, y;
    if (this.opt.position.base == 'mouse') {
      var mouse = VCOMN.getMousePosition(e);
      if (mouse.x) {
        x = mouse.x + this.opt.position.x;
        y = mouse.y + this.opt.position.y;
      }
      triggerElem.onmousemove = VCOMN.bindFunc(this.onMouseMove, this, triggerElem, targetElem);
    } else {
      if (!this.opt.position.bases) {
        this.opt.position.bases = {};
        var _splits = this.opt.position.base.split('-');
        for (var i = 0; i < _splits.length; i++) {
          if (_splits[i]) {
            this.opt.position.bases[_splits[i]] = true;
          }
        }
      }
      var baseElem = triggerElem;
      if (baseElem.tagName.toUpperCase() == 'A') {
        baseElem = triggerElem.firstChild;
        while (baseElem && baseElem.nodeType != 1) {
          baseElem = baseElem.nextSibling;
        }
        if (!baseElem) {
          baseElem = triggerElem;
        }
      }
      var pos = VCOMN.cumulativeOffset(baseElem);
      x = pos[0] + this.opt.position.x;
      y = pos[1] + this.opt.position.y;
      if (this.opt.position.bases.right) {
        x += baseElem.offsetWidth;
      }
      if (this.opt.position.bases.bottom) {
        y += baseElem.offsetHeight;
      }
    }
    this.setTargetPosition(targetElem, x, y);
    if (targetElem.parentNode != document.body) {
      targetElem._parentNode = targetElem.parentNode;
      targetElem._nextSibling = targetElem.nextSibling;
      document.body.insertBefore(targetElem, document.body.firstChild);
    }
  },
  backTooltip: function (triggerElem, targetElem) {
    VCOMN.addClass(targetElem, this.opt.class_name_tooltip);
    VCOMN.removeClass(targetElem, this.opt.class_name_tooltipbox);
    if (this.opt.inner_tag_name && this.opt.inner_tag_class) {
      var test = VCOMN.getElementsByClassName(this.opt.inner_tag_class, targetElem);
      if (test && test.length) {
        var inner = test[0];
        while (inner.firstChild) {
          targetElem.appendChild(inner.firstChild);
        }
        targetElem.removeChild(inner);
      }
    }
    if (targetElem._parentNode && targetElem.parentNode != targetElem._parentNode) {
      targetElem._parentNode.insertBefore(targetElem, targetElem._nextSibling);
      targetElem._parentNode = undefined;
      targetElem._nextSibling = undefined;
    }
    triggerElem.onmousemove = '';
  }
};