bk-magic-vue 2.5.9-beta.2 → 2.5.9-beta.21

package/lib/card.js

@@ -1,9 +1,10 @@
 (function (global, factory) {
-	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('bk-magic-vue/lib/locale')) :
-	typeof define === 'function' && define.amd ? define(['exports', 'bk-magic-vue/lib/locale'], factory) :
-	(global = global || self, factory(global.library = {}, global.locale));
-}(this, function (exports, locale) { 'use strict';
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue'), require('bk-magic-vue/lib/locale')) :
+	typeof define === 'function' && define.amd ? define(['exports', 'vue', 'bk-magic-vue/lib/locale'], factory) :
+	(global = global || self, factory(global.library = {}, global.Vue, global.locale));
+}(this, function (exports, Vue, locale) { 'use strict';
 
+	Vue = Vue && Vue.hasOwnProperty('default') ? Vue['default'] : Vue;
 	locale = locale && locale.hasOwnProperty('default') ? locale['default'] : locale;
 
 	function createCommonjsModule(fn, module) {
@@ -215,6 +216,51 @@
 
 	var _parseInt$2 = _parseInt$1;
 
+	function _typeof(obj) {
+	  "@babel/helpers - typeof";
+
+	  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+	    return typeof obj;
+	  } : function (obj) {
+	    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+	  }, _typeof(obj);
+	}
+	function _classCallCheck(instance, Constructor) {
+	  if (!(instance instanceof Constructor)) {
+	    throw new TypeError("Cannot call a class as a function");
+	  }
+	}
+	function _defineProperties(target, props) {
+	  for (var i = 0; i < props.length; i++) {
+	    var descriptor = props[i];
+	    descriptor.enumerable = descriptor.enumerable || false;
+	    descriptor.configurable = true;
+	    if ("value" in descriptor) descriptor.writable = true;
+	    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+	  }
+	}
+	function _createClass(Constructor, protoProps, staticProps) {
+	  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+	  if (staticProps) _defineProperties(Constructor, staticProps);
+	  Object.defineProperty(Constructor, "prototype", {
+	    writable: false
+	  });
+	  return Constructor;
+	}
+	function _defineProperty(obj, key, value) {
+	  key = _toPropertyKey(key);
+	  if (key in obj) {
+	    Object.defineProperty(obj, key, {
+	      value: value,
+	      enumerable: true,
+	      configurable: true,
+	      writable: true
+	    });
+	  } else {
+	    obj[key] = value;
+	  }
+	  return obj;
+	}
 	function _extends() {
 	  _extends = Object.assign ? Object.assign.bind() : function (target) {
 	    for (var i = 1; i < arguments.length; i++) {
@@ -229,6 +275,21 @@
 	  };
 	  return _extends.apply(this, arguments);
 	}
+	function _objectSpread(target) {
+	  for (var i = 1; i < arguments.length; i++) {
+	    var source = arguments[i] != null ? Object(arguments[i]) : {};
+	    var ownKeys = Object.keys(source);
+	    if (typeof Object.getOwnPropertySymbols === 'function') {
+	      ownKeys.push.apply(ownKeys, Object.getOwnPropertySymbols(source).filter(function (sym) {
+	        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+	      }));
+	    }
+	    ownKeys.forEach(function (key) {
+	      _defineProperty(target, key, source[key]);
+	    });
+	  }
+	  return target;
+	}
 	function _unsupportedIterableToArray(o, minLen) {
 	  if (!o) return;
 	  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
@@ -293,6 +354,20 @@
 	    }
 	  };
 	}
+	function _toPrimitive$1(input, hint) {
+	  if (typeof input !== "object" || input === null) return input;
+	  var prim = input[Symbol.toPrimitive];
+	  if (prim !== undefined) {
+	    var res = prim.call(input, hint || "default");
+	    if (typeof res !== "object") return res;
+	    throw new TypeError("@@toPrimitive must return a primitive value.");
+	  }
+	  return (hint === "string" ? String : Number)(input);
+	}
+	function _toPropertyKey(arg) {
+	  var key = _toPrimitive$1(arg, "string");
+	  return typeof key === "symbol" ? key : String(key);
+	}
 
 	var $parseFloat = _global.parseFloat;
 	var $trim$1 = _stringTrim.trim;
@@ -338,101 +413,2851 @@
 	  }
 	};
 
-	var requestAnimationFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function (callback) {
-	  window.setTimeout(callback, 1000 / 60);
-	};
-	var cancelAnimationFrame = window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || window.oCancelAnimationFrame || window.msCancelAnimationFrame || function (id) {
-	  window.clearTimeout(id);
-	};
-	var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g;
-	var MOZ_HACK_REGEXP = /^moz([A-Z])/;
-	var trim$1 = function trim(string) {
-	  return (string || '').replace(/^[\s\uFEFF]+|[\s\uFEFF]+$/g, '');
-	};
-	var camelCase = function camelCase(name) {
-	  return name.replace(SPECIAL_CHARS_REGEXP, function (_, separator, letter, offset) {
-	    return offset ? letter.toUpperCase() : letter;
-	  }).replace(MOZ_HACK_REGEXP, 'Moz$1');
+	var requestAnimationFrame$1 = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function (callback) {
+	  window.setTimeout(callback, 1000 / 60);
+	};
+	var cancelAnimationFrame$1 = window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || window.oCancelAnimationFrame || window.msCancelAnimationFrame || function (id) {
+	  window.clearTimeout(id);
+	};
+	var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g;
+	var MOZ_HACK_REGEXP = /^moz([A-Z])/;
+	var trim$1 = function trim(string) {
+	  return (string || '').replace(/^[\s\uFEFF]+|[\s\uFEFF]+$/g, '');
+	};
+	var camelCase = function camelCase(name) {
+	  return name.replace(SPECIAL_CHARS_REGEXP, function (_, separator, letter, offset) {
+	    return offset ? letter.toUpperCase() : letter;
+	  }).replace(MOZ_HACK_REGEXP, 'Moz$1');
+	};
+	function hasClass(el, cls) {
+	  if (!el || !cls) return false;
+	  if (cls.indexOf(' ') !== -1) throw new Error('className should not contain space.');
+	  if (el.classList) {
+	    return el.classList.contains(cls);
+	  } else {
+	    return (' ' + el.className + ' ').indexOf(' ' + cls + ' ') > -1;
+	  }
+	}
+	function addClass(el, cls) {
+	  if (!el) return;
+	  var curClass = el.className;
+	  var classes = (cls || '').split(' ');
+	  for (var i = 0, j = classes.length; i < j; i++) {
+	    var clsName = classes[i];
+	    if (!clsName) continue;
+	    if (el.classList) {
+	      el.classList.add(clsName);
+	    } else if (!hasClass(el, clsName)) {
+	      curClass += ' ' + clsName;
+	    }
+	  }
+	  if (!el.classList) {
+	    el.className = curClass;
+	  }
+	}
+	function removeClass(el, cls) {
+	  if (!el || !cls) return;
+	  var classes = cls.split(' ');
+	  var curClass = ' ' + el.className + ' ';
+	  for (var i = 0, j = classes.length; i < j; i++) {
+	    var clsName = classes[i];
+	    if (!clsName) continue;
+	    if (el.classList) {
+	      el.classList.remove(clsName);
+	    } else if (hasClass(el, clsName)) {
+	      curClass = curClass.replace(' ' + clsName + ' ', ' ');
+	    }
+	  }
+	  if (!el.classList) {
+	    el.className = trim$1(curClass);
+	  }
+	}
+	var getStyle = Number(document.documentMode) < 9 ? function (element, styleName) {
+	  if (!element || !styleName) return null;
+	  styleName = camelCase(styleName);
+	  if (styleName === 'float') {
+	    styleName = 'styleFloat';
+	  }
+	  try {
+	    switch (styleName) {
+	      case 'opacity':
+	        try {
+	          return element.filters.item('alpha').opacity / 100;
+	        } catch (e) {
+	          return 1.0;
+	        }
+	      default:
+	        return element.style[styleName] || element.currentStyle ? element.currentStyle[styleName] : null;
+	    }
+	  } catch (e) {
+	    return element.style[styleName];
+	  }
+	} : function (element, styleName) {
+	  if (!element || !styleName) return null;
+	  styleName = camelCase(styleName);
+	  if (styleName === 'float') {
+	    styleName = 'cssFloat';
+	  }
+	  try {
+	    var computed = document.defaultView.getComputedStyle(element, '');
+	    return element.style[styleName] || computed ? computed[styleName] : null;
+	  } catch (e) {
+	    return element.style[styleName];
+	  }
+	};
+
+	var toString = {}.toString;
+	var _cof = function (it) {
+	  return toString.call(it).slice(8, -1);
+	};
+
+	var _isArray = Array.isArray || function isArray(arg) {
+	  return _cof(arg) == 'Array';
+	};
+
+	_export(_export.S, 'Array', { isArray: _isArray });
+
+	var isArray = _core.Array.isArray;
+
+	var isArray$1 = isArray;
+
+	var _toObject = function (it) {
+	  return Object(_defined(it));
+	};
+
+	var _iobject = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
+	  return _cof(it) == 'String' ? it.split('') : Object(it);
+	};
+
+	var _toIobject = function (it) {
+	  return _iobject(_defined(it));
+	};
+
+	var ceil = Math.ceil;
+	var floor = Math.floor;
+	var _toInteger = function (it) {
+	  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
+	};
+
+	var min = Math.min;
+	var _toLength = function (it) {
+	  return it > 0 ? min(_toInteger(it), 0x1fffffffffffff) : 0;
+	};
+
+	var max = Math.max;
+	var min$1 = Math.min;
+	var _toAbsoluteIndex = function (index, length) {
+	  index = _toInteger(index);
+	  return index < 0 ? max(index + length, 0) : min$1(index, length);
+	};
+
+	var _arrayIncludes = function (IS_INCLUDES) {
+	  return function ($this, el, fromIndex) {
+	    var O = _toIobject($this);
+	    var length = _toLength(O.length);
+	    var index = _toAbsoluteIndex(fromIndex, length);
+	    var value;
+	    if (IS_INCLUDES && el != el) while (length > index) {
+	      value = O[index++];
+	      if (value != value) return true;
+	    } else for (;length > index; index++) if (IS_INCLUDES || index in O) {
+	      if (O[index] === el) return IS_INCLUDES || index || 0;
+	    } return !IS_INCLUDES && -1;
+	  };
+	};
+
+	var _shared = createCommonjsModule(function (module) {
+	var SHARED = '__core-js_shared__';
+	var store = _global[SHARED] || (_global[SHARED] = {});
+	(module.exports = function (key, value) {
+	  return store[key] || (store[key] = value !== undefined ? value : {});
+	})('versions', []).push({
+	  version: _core.version,
+	  mode:  'pure' ,
+	  copyright: '© 2020 Denis Pushkarev (zloirock.ru)'
+	});
+	});
+
+	var id = 0;
+	var px = Math.random();
+	var _uid = function (key) {
+	  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
+	};
+
+	var shared = _shared('keys');
+	var _sharedKey = function (key) {
+	  return shared[key] || (shared[key] = _uid(key));
+	};
+
+	var arrayIndexOf = _arrayIncludes(false);
+	var IE_PROTO = _sharedKey('IE_PROTO');
+	var _objectKeysInternal = function (object, names) {
+	  var O = _toIobject(object);
+	  var i = 0;
+	  var result = [];
+	  var key;
+	  for (key in O) if (key != IE_PROTO) _has(O, key) && result.push(key);
+	  while (names.length > i) if (_has(O, key = names[i++])) {
+	    ~arrayIndexOf(result, key) || result.push(key);
+	  }
+	  return result;
+	};
+
+	var _enumBugKeys = (
+	  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
+	).split(',');
+
+	var _objectKeys = Object.keys || function keys(O) {
+	  return _objectKeysInternal(O, _enumBugKeys);
+	};
+
+	var _objectSap = function (KEY, exec) {
+	  var fn = (_core.Object || {})[KEY] || Object[KEY];
+	  var exp = {};
+	  exp[KEY] = exec(fn);
+	  _export(_export.S + _export.F * _fails(function () { fn(1); }), 'Object', exp);
+	};
+
+	_objectSap('keys', function () {
+	  return function keys(it) {
+	    return _objectKeys(_toObject(it));
+	  };
+	});
+
+	var keys = _core.Object.keys;
+
+	var keys$1 = keys;
+
+	var f$1 = Object.getOwnPropertySymbols;
+	var _objectGops = {
+		f: f$1
+	};
+
+	var f$2 = {}.propertyIsEnumerable;
+	var _objectPie = {
+		f: f$2
+	};
+
+	var $assign = Object.assign;
+	var _objectAssign = !$assign || _fails(function () {
+	  var A = {};
+	  var B = {};
+	  var S = Symbol();
+	  var K = 'abcdefghijklmnopqrst';
+	  A[S] = 7;
+	  K.split('').forEach(function (k) { B[k] = k; });
+	  return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
+	}) ? function assign(target, source) {
+	  var T = _toObject(target);
+	  var aLen = arguments.length;
+	  var index = 1;
+	  var getSymbols = _objectGops.f;
+	  var isEnum = _objectPie.f;
+	  while (aLen > index) {
+	    var S = _iobject(arguments[index++]);
+	    var keys = getSymbols ? _objectKeys(S).concat(getSymbols(S)) : _objectKeys(S);
+	    var length = keys.length;
+	    var j = 0;
+	    var key;
+	    while (length > j) {
+	      key = keys[j++];
+	      if (!_descriptors || isEnum.call(S, key)) T[key] = S[key];
+	    }
+	  } return T;
+	} : $assign;
+
+	_export(_export.S + _export.F, 'Object', { assign: _objectAssign });
+
+	var assign = _core.Object.assign;
+
+	var assign$1 = assign;
+
+	var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
+	var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];
+	var timeoutDuration = 0;
+	for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {
+	  if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {
+	    timeoutDuration = 1;
+	    break;
+	  }
+	}
+	function microtaskDebounce(fn) {
+	  var called = false;
+	  return function () {
+	    if (called) {
+	      return;
+	    }
+	    called = true;
+	    window.Promise.resolve().then(function () {
+	      called = false;
+	      fn();
+	    });
+	  };
+	}
+	function taskDebounce(fn) {
+	  var scheduled = false;
+	  return function () {
+	    if (!scheduled) {
+	      scheduled = true;
+	      setTimeout(function () {
+	        scheduled = false;
+	        fn();
+	      }, timeoutDuration);
+	    }
+	  };
+	}
+	var supportsMicroTasks = isBrowser && window.Promise;
+	var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;
+	function isFunction(functionToCheck) {
+	  var getType = {};
+	  return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
+	}
+	function getStyleComputedProperty(element, property) {
+	  if (element.nodeType !== 1) {
+	    return [];
+	  }
+	  var window = element.ownerDocument.defaultView;
+	  var css = window.getComputedStyle(element, null);
+	  return property ? css[property] : css;
+	}
+	function getParentNode(element) {
+	  if (element.nodeName === 'HTML') {
+	    return element;
+	  }
+	  return element.parentNode || element.host;
+	}
+	function getScrollParent(element) {
+	  if (!element) {
+	    return document.body;
+	  }
+	  switch (element.nodeName) {
+	    case 'HTML':
+	    case 'BODY':
+	      return element.ownerDocument.body;
+	    case '#document':
+	      return element.body;
+	  }
+	  var _getStyleComputedProp = getStyleComputedProperty(element),
+	    overflow = _getStyleComputedProp.overflow,
+	    overflowX = _getStyleComputedProp.overflowX,
+	    overflowY = _getStyleComputedProp.overflowY;
+	  if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {
+	    return element;
+	  }
+	  return getScrollParent(getParentNode(element));
+	}
+	var isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);
+	var isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);
+	function isIE(version) {
+	  if (version === 11) {
+	    return isIE11;
+	  }
+	  if (version === 10) {
+	    return isIE10;
+	  }
+	  return isIE11 || isIE10;
+	}
+	function getOffsetParent(element) {
+	  if (!element) {
+	    return document.documentElement;
+	  }
+	  var noOffsetParent = isIE(10) ? document.body : null;
+	  var offsetParent = element.offsetParent || null;
+	  while (offsetParent === noOffsetParent && element.nextElementSibling) {
+	    offsetParent = (element = element.nextElementSibling).offsetParent;
+	  }
+	  var nodeName = offsetParent && offsetParent.nodeName;
+	  if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {
+	    return element ? element.ownerDocument.documentElement : document.documentElement;
+	  }
+	  if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {
+	    return getOffsetParent(offsetParent);
+	  }
+	  return offsetParent;
+	}
+	function isOffsetContainer(element) {
+	  var nodeName = element.nodeName;
+	  if (nodeName === 'BODY') {
+	    return false;
+	  }
+	  return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;
+	}
+	function getRoot(node) {
+	  if (node.parentNode !== null) {
+	    return getRoot(node.parentNode);
+	  }
+	  return node;
+	}
+	function findCommonOffsetParent(element1, element2) {
+	  if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {
+	    return document.documentElement;
+	  }
+	  var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
+	  var start = order ? element1 : element2;
+	  var end = order ? element2 : element1;
+	  var range = document.createRange();
+	  range.setStart(start, 0);
+	  range.setEnd(end, 0);
+	  var commonAncestorContainer = range.commonAncestorContainer;
+	  if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {
+	    if (isOffsetContainer(commonAncestorContainer)) {
+	      return commonAncestorContainer;
+	    }
+	    return getOffsetParent(commonAncestorContainer);
+	  }
+	  var element1root = getRoot(element1);
+	  if (element1root.host) {
+	    return findCommonOffsetParent(element1root.host, element2);
+	  } else {
+	    return findCommonOffsetParent(element1, getRoot(element2).host);
+	  }
+	}
+	function getScroll(element) {
+	  var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';
+	  var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';
+	  var nodeName = element.nodeName;
+	  if (nodeName === 'BODY' || nodeName === 'HTML') {
+	    var html = element.ownerDocument.documentElement;
+	    var scrollingElement = element.ownerDocument.scrollingElement || html;
+	    return scrollingElement[upperSide];
+	  }
+	  return element[upperSide];
+	}
+	function includeScroll(rect, element) {
+	  var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+	  var scrollTop = getScroll(element, 'top');
+	  var scrollLeft = getScroll(element, 'left');
+	  var modifier = subtract ? -1 : 1;
+	  rect.top += scrollTop * modifier;
+	  rect.bottom += scrollTop * modifier;
+	  rect.left += scrollLeft * modifier;
+	  rect.right += scrollLeft * modifier;
+	  return rect;
+	}
+	function getBordersSize(styles, axis) {
+	  var sideA = axis === 'x' ? 'Left' : 'Top';
+	  var sideB = sideA === 'Left' ? 'Right' : 'Bottom';
+	  return _parseFloat$2(styles["border".concat(sideA, "Width")], 10) + _parseFloat$2(styles["border".concat(sideB, "Width")], 10);
+	}
+	function getSize(axis, body, html, computedStyle) {
+	  return Math.max(body["offset".concat(axis)], body["scroll".concat(axis)], html["client".concat(axis)], html["offset".concat(axis)], html["scroll".concat(axis)], isIE(10) ? _parseInt$2(html["offset".concat(axis)]) + _parseInt$2(computedStyle["margin".concat(axis === 'Height' ? 'Top' : 'Left')]) + _parseInt$2(computedStyle["margin".concat(axis === 'Height' ? 'Bottom' : 'Right')]) : 0);
+	}
+	function getWindowSizes(document) {
+	  var body = document.body;
+	  var html = document.documentElement;
+	  var computedStyle = isIE(10) && getComputedStyle(html);
+	  return {
+	    height: getSize('Height', body, html, computedStyle),
+	    width: getSize('Width', body, html, computedStyle)
+	  };
+	}
+	var _extends$1 = assign$1 || function (target) {
+	  for (var i = 1; i < arguments.length; i++) {
+	    var source = arguments[i];
+	    for (var key in source) {
+	      if (Object.prototype.hasOwnProperty.call(source, key)) {
+	        target[key] = source[key];
+	      }
+	    }
+	  }
+	  return target;
+	};
+	function getClientRect(offsets) {
+	  return _extends$1({}, offsets, {
+	    right: offsets.left + offsets.width,
+	    bottom: offsets.top + offsets.height
+	  });
+	}
+	function getBoundingClientRect(element) {
+	  var rect = {};
+	  try {
+	    if (isIE(10)) {
+	      rect = element.getBoundingClientRect();
+	      var scrollTop = getScroll(element, 'top');
+	      var scrollLeft = getScroll(element, 'left');
+	      rect.top += scrollTop;
+	      rect.left += scrollLeft;
+	      rect.bottom += scrollTop;
+	      rect.right += scrollLeft;
+	    } else {
+	      rect = element.getBoundingClientRect();
+	    }
+	  } catch (e) {}
+	  var result = {
+	    left: rect.left,
+	    top: rect.top,
+	    width: rect.right - rect.left,
+	    height: rect.bottom - rect.top
+	  };
+	  var sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {};
+	  var width = sizes.width || element.clientWidth || result.right - result.left;
+	  var height = sizes.height || element.clientHeight || result.bottom - result.top;
+	  var horizScrollbar = element.offsetWidth - width;
+	  var vertScrollbar = element.offsetHeight - height;
+	  if (horizScrollbar || vertScrollbar) {
+	    var styles = getStyleComputedProperty(element);
+	    horizScrollbar -= getBordersSize(styles, 'x');
+	    vertScrollbar -= getBordersSize(styles, 'y');
+	    result.width -= horizScrollbar;
+	    result.height -= vertScrollbar;
+	  }
+	  return getClientRect(result);
+	}
+	function getOffsetRectRelativeToArbitraryNode(children, parent) {
+	  var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+	  var isIE10 = isIE(10);
+	  var isHTML = parent.nodeName === 'HTML';
+	  var childrenRect = getBoundingClientRect(children);
+	  var parentRect = getBoundingClientRect(parent);
+	  var scrollParent = getScrollParent(children);
+	  var styles = getStyleComputedProperty(parent);
+	  var borderTopWidth = _parseFloat$2(styles.borderTopWidth, 10);
+	  var borderLeftWidth = _parseFloat$2(styles.borderLeftWidth, 10);
+	  if (fixedPosition && isHTML) {
+	    parentRect.top = Math.max(parentRect.top, 0);
+	    parentRect.left = Math.max(parentRect.left, 0);
+	  }
+	  var offsets = getClientRect({
+	    top: childrenRect.top - parentRect.top - borderTopWidth,
+	    left: childrenRect.left - parentRect.left - borderLeftWidth,
+	    width: childrenRect.width,
+	    height: childrenRect.height
+	  });
+	  offsets.marginTop = 0;
+	  offsets.marginLeft = 0;
+	  if (!isIE10 && isHTML) {
+	    var marginTop = _parseFloat$2(styles.marginTop, 10);
+	    var marginLeft = _parseFloat$2(styles.marginLeft, 10);
+	    offsets.top -= borderTopWidth - marginTop;
+	    offsets.bottom -= borderTopWidth - marginTop;
+	    offsets.left -= borderLeftWidth - marginLeft;
+	    offsets.right -= borderLeftWidth - marginLeft;
+	    offsets.marginTop = marginTop;
+	    offsets.marginLeft = marginLeft;
+	  }
+	  if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {
+	    offsets = includeScroll(offsets, parent);
+	  }
+	  return offsets;
+	}
+	function getViewportOffsetRectRelativeToArtbitraryNode(element) {
+	  var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+	  var html = element.ownerDocument.documentElement;
+	  var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);
+	  var width = Math.max(html.clientWidth, window.innerWidth || 0);
+	  var height = Math.max(html.clientHeight, window.innerHeight || 0);
+	  var scrollTop = !excludeScroll ? getScroll(html) : 0;
+	  var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;
+	  var offset = {
+	    top: scrollTop - relativeOffset.top + relativeOffset.marginTop,
+	    left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,
+	    width: width,
+	    height: height
+	  };
+	  return getClientRect(offset);
+	}
+	function isFixed(element) {
+	  var nodeName = element.nodeName;
+	  if (nodeName === 'BODY' || nodeName === 'HTML') {
+	    return false;
+	  }
+	  if (getStyleComputedProperty(element, 'position') === 'fixed') {
+	    return true;
+	  }
+	  var parentNode = getParentNode(element);
+	  if (!parentNode) {
+	    return false;
+	  }
+	  return isFixed(parentNode);
+	}
+	function getFixedPositionOffsetParent(element) {
+	  if (!element || !element.parentElement || isIE()) {
+	    return document.documentElement;
+	  }
+	  var el = element.parentElement;
+	  while (el && getStyleComputedProperty(el, 'transform') === 'none') {
+	    el = el.parentElement;
+	  }
+	  return el || document.documentElement;
+	}
+	function getBoundaries(popper, reference, padding, boundariesElement) {
+	  var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+	  var boundaries = {
+	    top: 0,
+	    left: 0
+	  };
+	  var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, reference);
+	  if (boundariesElement === 'viewport') {
+	    boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);
+	  } else {
+	    var boundariesNode;
+	    if (boundariesElement === 'scrollParent') {
+	      boundariesNode = getScrollParent(getParentNode(reference));
+	      if (boundariesNode.nodeName === 'BODY') {
+	        boundariesNode = popper.ownerDocument.documentElement;
+	      }
+	    } else if (boundariesElement === 'window') {
+	      boundariesNode = popper.ownerDocument.documentElement;
+	    } else {
+	      boundariesNode = boundariesElement;
+	    }
+	    var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);
+	    if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {
+	      var _getWindowSizes = getWindowSizes(popper.ownerDocument),
+	        height = _getWindowSizes.height,
+	        width = _getWindowSizes.width;
+	      boundaries.top += offsets.top - offsets.marginTop;
+	      boundaries.bottom = height + offsets.top;
+	      boundaries.left += offsets.left - offsets.marginLeft;
+	      boundaries.right = width + offsets.left;
+	    } else {
+	      boundaries = offsets;
+	    }
+	  }
+	  padding = padding || 0;
+	  var isPaddingNumber = typeof padding === 'number';
+	  boundaries.left += isPaddingNumber ? padding : padding.left || 0;
+	  boundaries.top += isPaddingNumber ? padding : padding.top || 0;
+	  boundaries.right -= isPaddingNumber ? padding : padding.right || 0;
+	  boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0;
+	  return boundaries;
+	}
+	function getArea(_ref) {
+	  var width = _ref.width,
+	    height = _ref.height;
+	  return width * height;
+	}
+	function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {
+	  var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
+	  if (placement.indexOf('auto') === -1) {
+	    return placement;
+	  }
+	  var boundaries = getBoundaries(popper, reference, padding, boundariesElement);
+	  var rects = {
+	    top: {
+	      width: boundaries.width,
+	      height: refRect.top - boundaries.top
+	    },
+	    right: {
+	      width: boundaries.right - refRect.right,
+	      height: boundaries.height
+	    },
+	    bottom: {
+	      width: boundaries.width,
+	      height: boundaries.bottom - refRect.bottom
+	    },
+	    left: {
+	      width: refRect.left - boundaries.left,
+	      height: boundaries.height
+	    }
+	  };
+	  var sortedAreas = keys$1(rects).map(function (key) {
+	    return _extends$1({
+	      key: key
+	    }, rects[key], {
+	      area: getArea(rects[key])
+	    });
+	  }).sort(function (a, b) {
+	    return b.area - a.area;
+	  });
+	  var filteredAreas = sortedAreas.filter(function (_ref2) {
+	    var width = _ref2.width,
+	      height = _ref2.height;
+	    return width >= popper.clientWidth && height >= popper.clientHeight;
+	  });
+	  var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;
+	  var variation = placement.split('-')[1];
+	  return computedPlacement + (variation ? "-".concat(variation) : '');
+	}
+	function getReferenceOffsets(state, popper, reference) {
+	  var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+	  var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, reference);
+	  return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);
+	}
+	function getOuterSizes(element) {
+	  var window = element.ownerDocument.defaultView;
+	  var styles = window.getComputedStyle(element);
+	  var x = _parseFloat$2(styles.marginTop || 0) + _parseFloat$2(styles.marginBottom || 0);
+	  var y = _parseFloat$2(styles.marginLeft || 0) + _parseFloat$2(styles.marginRight || 0);
+	  var result = {
+	    width: element.offsetWidth + y,
+	    height: element.offsetHeight + x
+	  };
+	  return result;
+	}
+	function getOppositePlacement(placement) {
+	  var hash = {
+	    left: 'right',
+	    right: 'left',
+	    bottom: 'top',
+	    top: 'bottom'
+	  };
+	  return placement.replace(/left|right|bottom|top/g, function (matched) {
+	    return hash[matched];
+	  });
+	}
+	function getPopperOffsets(popper, referenceOffsets, placement) {
+	  placement = placement.split('-')[0];
+	  var popperRect = getOuterSizes(popper);
+	  var popperOffsets = {
+	    width: popperRect.width,
+	    height: popperRect.height
+	  };
+	  var isHoriz = ['right', 'left'].indexOf(placement) !== -1;
+	  var mainSide = isHoriz ? 'top' : 'left';
+	  var secondarySide = isHoriz ? 'left' : 'top';
+	  var measurement = isHoriz ? 'height' : 'width';
+	  var secondaryMeasurement = !isHoriz ? 'height' : 'width';
+	  popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;
+	  if (placement === secondarySide) {
+	    popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];
+	  } else {
+	    popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];
+	  }
+	  return popperOffsets;
+	}
+	function find(arr, check) {
+	  if (Array.prototype.find) {
+	    return arr.find(check);
+	  }
+	  return arr.filter(check)[0];
+	}
+	function findIndex(arr, prop, value) {
+	  if (Array.prototype.findIndex) {
+	    return arr.findIndex(function (cur) {
+	      return cur[prop] === value;
+	    });
+	  }
+	  var match = find(arr, function (obj) {
+	    return obj[prop] === value;
+	  });
+	  return arr.indexOf(match);
+	}
+	function runModifiers(modifiers, data, ends) {
+	  var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));
+	  modifiersToRun.forEach(function (modifier) {
+	    if (modifier['function']) {
+	      console.warn('`modifier.function` is deprecated, use `modifier.fn`!');
+	    }
+	    var fn = modifier['function'] || modifier.fn;
+	    if (modifier.enabled && isFunction(fn)) {
+	      data.offsets.popper = getClientRect(data.offsets.popper);
+	      data.offsets.reference = getClientRect(data.offsets.reference);
+	      data = fn(data, modifier);
+	    }
+	  });
+	  return data;
+	}
+	function _update() {
+	  if (this.state.isDestroyed) {
+	    return;
+	  }
+	  var data = {
+	    instance: this,
+	    styles: {},
+	    arrowStyles: {},
+	    attributes: {},
+	    flipped: false,
+	    offsets: {}
+	  };
+	  data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed);
+	  data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);
+	  data.originalPlacement = data.placement;
+	  data.positionFixed = this.options.positionFixed;
+	  data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);
+	  data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute';
+	  data = runModifiers(this.modifiers, data);
+	  if (!this.state.isCreated) {
+	    this.state.isCreated = true;
+	    this.options.onCreate(data);
+	  } else {
+	    this.options.onUpdate(data);
+	  }
+	}
+	function isModifierEnabled(modifiers, modifierName) {
+	  return modifiers.some(function (_ref3) {
+	    var name = _ref3.name,
+	      enabled = _ref3.enabled;
+	    return enabled && name === modifierName;
+	  });
+	}
+	function getSupportedPropertyName(property) {
+	  var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];
+	  var upperProp = property.charAt(0).toUpperCase() + property.slice(1);
+	  for (var _i = 0; _i < prefixes.length; _i++) {
+	    var prefix = prefixes[_i];
+	    var toCheck = prefix ? "".concat(prefix).concat(upperProp) : property;
+	    if (typeof document.body.style[toCheck] !== 'undefined') {
+	      return toCheck;
+	    }
+	  }
+	  return null;
+	}
+	function _destroy() {
+	  this.state.isDestroyed = true;
+	  if (isModifierEnabled(this.modifiers, 'applyStyle')) {
+	    this.popper.removeAttribute('x-placement');
+	    this.popper.style.position = '';
+	    this.popper.style.top = '';
+	    this.popper.style.left = '';
+	    this.popper.style.right = '';
+	    this.popper.style.bottom = '';
+	    this.popper.style.willChange = '';
+	    this.popper.style[getSupportedPropertyName('transform')] = '';
+	  }
+	  this.disableEventListeners();
+	  if (this.options.removeOnDestroy) {
+	    this.popper.parentNode.removeChild(this.popper);
+	  }
+	  return this;
+	}
+	function getWindow(element) {
+	  var ownerDocument = element.ownerDocument;
+	  return ownerDocument ? ownerDocument.defaultView : window;
+	}
+	function attachToScrollParents(scrollParent, event, callback, scrollParents) {
+	  var isBody = scrollParent.nodeName === 'BODY';
+	  var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;
+	  target.addEventListener(event, callback, {
+	    passive: true
+	  });
+	  if (!isBody) {
+	    attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);
+	  }
+	  scrollParents.push(target);
+	}
+	function setupEventListeners(reference, options, state, updateBound) {
+	  state.updateBound = updateBound;
+	  getWindow(reference).addEventListener('resize', state.updateBound, {
+	    passive: true
+	  });
+	  var scrollElement = getScrollParent(reference);
+	  attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);
+	  state.scrollElement = scrollElement;
+	  state.eventsEnabled = true;
+	  return state;
+	}
+	function _enableEventListeners() {
+	  if (!this.state.eventsEnabled) {
+	    this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);
+	  }
+	}
+	function removeEventListeners(reference, state) {
+	  getWindow(reference).removeEventListener('resize', state.updateBound);
+	  state.scrollParents.forEach(function (target) {
+	    target.removeEventListener('scroll', state.updateBound);
+	  });
+	  state.updateBound = null;
+	  state.scrollParents = [];
+	  state.scrollElement = null;
+	  state.eventsEnabled = false;
+	  return state;
+	}
+	function _disableEventListeners() {
+	  if (this.state.eventsEnabled) {
+	    cancelAnimationFrame(this.scheduleUpdate);
+	    this.state = removeEventListeners(this.reference, this.state);
+	  }
+	}
+	function isNumeric(n) {
+	  return n !== '' && !isNaN(_parseFloat$2(n)) && isFinite(n);
+	}
+	function setStyles(element, styles) {
+	  keys$1(styles).forEach(function (prop) {
+	    var unit = '';
+	    if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {
+	      unit = 'px';
+	    }
+	    element.style[prop] = styles[prop] + unit;
+	  });
+	}
+	function setAttributes(element, attributes) {
+	  keys$1(attributes).forEach(function (prop) {
+	    var value = attributes[prop];
+	    if (value !== false) {
+	      element.setAttribute(prop, attributes[prop]);
+	    } else {
+	      element.removeAttribute(prop);
+	    }
+	  });
+	}
+	function applyStyle(data) {
+	  setStyles(data.instance.popper, data.styles);
+	  setAttributes(data.instance.popper, data.attributes);
+	  if (data.arrowElement && keys$1(data.arrowStyles).length) {
+	    setStyles(data.arrowElement, data.arrowStyles);
+	  }
+	  return data;
+	}
+	function applyStyleOnLoad(reference, popper, options, modifierOptions, state) {
+	  var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);
+	  var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);
+	  popper.setAttribute('x-placement', placement);
+	  setStyles(popper, {
+	    position: options.positionFixed ? 'fixed' : 'absolute'
+	  });
+	  return options;
+	}
+	function getRoundedOffsets(data, shouldRound) {
+	  var _data$offsets = data.offsets,
+	    popper = _data$offsets.popper,
+	    reference = _data$offsets.reference;
+	  var round = Math.round,
+	    floor = Math.floor;
+	  var noRound = function noRound(v) {
+	    return v;
+	  };
+	  var referenceWidth = round(reference.width);
+	  var popperWidth = round(popper.width);
+	  var isVertical = ['left', 'right'].indexOf(data.placement) !== -1;
+	  var isVariation = data.placement.indexOf('-') !== -1;
+	  var sameWidthParity = referenceWidth % 2 === popperWidth % 2;
+	  var bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1;
+	  var horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor;
+	  var verticalToInteger = !shouldRound ? noRound : round;
+	  return {
+	    left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left),
+	    top: verticalToInteger(popper.top),
+	    bottom: verticalToInteger(popper.bottom),
+	    right: horizontalToInteger(popper.right)
+	  };
+	}
+	var isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent);
+	function computeStyle(data, options) {
+	  var x = options.x,
+	    y = options.y;
+	  var popper = data.offsets.popper;
+	  var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) {
+	    return modifier.name === 'applyStyle';
+	  }).gpuAcceleration;
+	  if (legacyGpuAccelerationOption !== undefined) {
+	    console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');
+	  }
+	  var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration;
+	  var offsetParent = getOffsetParent(data.instance.popper);
+	  var offsetParentRect = getBoundingClientRect(offsetParent);
+	  var styles = {
+	    position: popper.position
+	  };
+	  var offsets = getRoundedOffsets(data, window.devicePixelRatio < 2 || !isFirefox);
+	  var sideA = x === 'bottom' ? 'top' : 'bottom';
+	  var sideB = y === 'right' ? 'left' : 'right';
+	  var prefixedProperty = getSupportedPropertyName('transform');
+	  var left, top;
+	  if (sideA === 'bottom') {
+	    if (offsetParent.nodeName === 'HTML') {
+	      top = -offsetParent.clientHeight + offsets.bottom;
+	    } else {
+	      top = -offsetParentRect.height + offsets.bottom;
+	    }
+	  } else {
+	    top = offsets.top;
+	  }
+	  if (sideB === 'right') {
+	    if (offsetParent.nodeName === 'HTML') {
+	      left = -offsetParent.clientWidth + offsets.right;
+	    } else {
+	      left = -offsetParentRect.width + offsets.right;
+	    }
+	  } else {
+	    left = offsets.left;
+	  }
+	  if (gpuAcceleration && prefixedProperty) {
+	    styles[prefixedProperty] = "translate3d(".concat(left, "px, ").concat(top, "px, 0)");
+	    styles[sideA] = 0;
+	    styles[sideB] = 0;
+	  } else {
+	    var invertTop = sideA === 'bottom' ? -1 : 1;
+	    var invertLeft = sideB === 'right' ? -1 : 1;
+	    styles[sideA] = top * invertTop;
+	    styles[sideB] = left * invertLeft;
+	  }
+	  var attributes = {
+	    'x-placement': data.placement
+	  };
+	  data.attributes = _extends$1({}, attributes, data.attributes);
+	  data.styles = _extends$1({}, styles, data.styles);
+	  data.arrowStyles = _extends$1({}, data.offsets.arrow, data.arrowStyles);
+	  return data;
+	}
+	function isModifierRequired(modifiers, requestingName, requestedName) {
+	  var requesting = find(modifiers, function (_ref4) {
+	    var name = _ref4.name;
+	    return name === requestingName;
+	  });
+	  var isRequired = !!requesting && modifiers.some(function (modifier) {
+	    return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;
+	  });
+	  if (!isRequired) {
+	    var _requesting = "`".concat(requestingName, "`");
+	    var requested = "`".concat(requestedName, "`");
+	    console.warn("".concat(requested, " modifier is required by ").concat(_requesting, " modifier in order to work, be sure to include it before ").concat(_requesting, "!"));
+	  }
+	  return isRequired;
+	}
+	function arrow(data, options) {
+	  var _data$offsets$arrow;
+	  if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {
+	    return data;
+	  }
+	  var arrowElement = options.element;
+	  if (typeof arrowElement === 'string') {
+	    arrowElement = data.instance.popper.querySelector(arrowElement);
+	    if (!arrowElement) {
+	      return data;
+	    }
+	  } else {
+	    if (!data.instance.popper.contains(arrowElement)) {
+	      console.warn('WARNING: `arrow.element` must be child of its popper element!');
+	      return data;
+	    }
+	  }
+	  var placement = data.placement.split('-')[0];
+	  var _data$offsets2 = data.offsets,
+	    popper = _data$offsets2.popper,
+	    reference = _data$offsets2.reference;
+	  var isVertical = ['left', 'right'].indexOf(placement) !== -1;
+	  var len = isVertical ? 'height' : 'width';
+	  var sideCapitalized = isVertical ? 'Top' : 'Left';
+	  var side = sideCapitalized.toLowerCase();
+	  var altSide = isVertical ? 'left' : 'top';
+	  var opSide = isVertical ? 'bottom' : 'right';
+	  var arrowElementSize = getOuterSizes(arrowElement)[len];
+	  if (reference[opSide] - arrowElementSize < popper[side]) {
+	    data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize);
+	  }
+	  if (reference[side] + arrowElementSize > popper[opSide]) {
+	    data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide];
+	  }
+	  data.offsets.popper = getClientRect(data.offsets.popper);
+	  var center = reference[side] + reference[len] / 2 - arrowElementSize / 2;
+	  var css = getStyleComputedProperty(data.instance.popper);
+	  var popperMarginSide = _parseFloat$2(css["margin".concat(sideCapitalized)], 10);
+	  var popperBorderSide = _parseFloat$2(css["border".concat(sideCapitalized, "Width")], 10);
+	  var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide;
+	  sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0);
+	  data.arrowElement = arrowElement;
+	  data.offsets.arrow = (_data$offsets$arrow = {}, _defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), _defineProperty(_data$offsets$arrow, altSide, ''), _data$offsets$arrow);
+	  return data;
+	}
+	function getOppositeVariation(variation) {
+	  if (variation === 'end') {
+	    return 'start';
+	  } else if (variation === 'start') {
+	    return 'end';
+	  }
+	  return variation;
+	}
+	var placements = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start'];
+	var validPlacements = placements.slice(3);
+	function clockwise(placement) {
+	  var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+	  var index = validPlacements.indexOf(placement);
+	  var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index));
+	  return counter ? arr.reverse() : arr;
+	}
+	var BEHAVIORS = {
+	  FLIP: 'flip',
+	  CLOCKWISE: 'clockwise',
+	  COUNTERCLOCKWISE: 'counterclockwise'
+	};
+	function flip(data, options) {
+	  if (isModifierEnabled(data.instance.modifiers, 'inner')) {
+	    return data;
+	  }
+	  if (data.flipped && data.placement === data.originalPlacement) {
+	    return data;
+	  }
+	  var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed);
+	  var placement = data.placement.split('-')[0];
+	  var placementOpposite = getOppositePlacement(placement);
+	  var variation = data.placement.split('-')[1] || '';
+	  var flipOrder = [];
+	  switch (options.behavior) {
+	    case BEHAVIORS.FLIP:
+	      flipOrder = [placement, placementOpposite];
+	      break;
+	    case BEHAVIORS.CLOCKWISE:
+	      flipOrder = clockwise(placement);
+	      break;
+	    case BEHAVIORS.COUNTERCLOCKWISE:
+	      flipOrder = clockwise(placement, true);
+	      break;
+	    default:
+	      flipOrder = options.behavior;
+	  }
+	  flipOrder.forEach(function (step, index) {
+	    if (placement !== step || flipOrder.length === index + 1) {
+	      return data;
+	    }
+	    placement = data.placement.split('-')[0];
+	    placementOpposite = getOppositePlacement(placement);
+	    var popperOffsets = data.offsets.popper;
+	    var refOffsets = data.offsets.reference;
+	    var floor = Math.floor;
+	    var overlapsRef = placement === 'left' && floor(popperOffsets.right) > floor(refOffsets.left) || placement === 'right' && floor(popperOffsets.left) < floor(refOffsets.right) || placement === 'top' && floor(popperOffsets.bottom) > floor(refOffsets.top) || placement === 'bottom' && floor(popperOffsets.top) < floor(refOffsets.bottom);
+	    var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);
+	    var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);
+	    var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);
+	    var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom);
+	    var overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom;
+	    var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
+	    var flippedVariationByRef = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom);
+	    var flippedVariationByContent = !!options.flipVariationsByContent && (isVertical && variation === 'start' && overflowsRight || isVertical && variation === 'end' && overflowsLeft || !isVertical && variation === 'start' && overflowsBottom || !isVertical && variation === 'end' && overflowsTop);
+	    var flippedVariation = flippedVariationByRef || flippedVariationByContent;
+	    if (overlapsRef || overflowsBoundaries || flippedVariation) {
+	      data.flipped = true;
+	      if (overlapsRef || overflowsBoundaries) {
+	        placement = flipOrder[index + 1];
+	      }
+	      if (flippedVariation) {
+	        variation = getOppositeVariation(variation);
+	      }
+	      data.placement = placement + (variation ? '-' + variation : '');
+	      data.offsets.popper = _extends$1({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement));
+	      data = runModifiers(data.instance.modifiers, data, 'flip');
+	    }
+	  });
+	  return data;
+	}
+	function keepTogether(data) {
+	  var _data$offsets3 = data.offsets,
+	    popper = _data$offsets3.popper,
+	    reference = _data$offsets3.reference;
+	  var placement = data.placement.split('-')[0];
+	  var floor = Math.floor;
+	  var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
+	  var side = isVertical ? 'right' : 'bottom';
+	  var opSide = isVertical ? 'left' : 'top';
+	  var measurement = isVertical ? 'width' : 'height';
+	  if (popper[side] < floor(reference[opSide])) {
+	    data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement];
+	  }
+	  if (popper[opSide] > floor(reference[side])) {
+	    data.offsets.popper[opSide] = floor(reference[side]);
+	  }
+	  return data;
+	}
+	function toValue(str, measurement, popperOffsets, referenceOffsets) {
+	  var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/);
+	  var value = +split[1];
+	  var unit = split[2];
+	  if (!value) {
+	    return str;
+	  }
+	  if (unit.indexOf('%') === 0) {
+	    var element;
+	    switch (unit) {
+	      case '%p':
+	        element = popperOffsets;
+	        break;
+	      case '%':
+	      case '%r':
+	      default:
+	        element = referenceOffsets;
+	    }
+	    var rect = getClientRect(element);
+	    return rect[measurement] / 100 * value;
+	  } else if (unit === 'vh' || unit === 'vw') {
+	    var size;
+	    if (unit === 'vh') {
+	      size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
+	    } else {
+	      size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
+	    }
+	    return size / 100 * value;
+	  } else {
+	    return value;
+	  }
+	}
+	function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {
+	  var offsets = [0, 0];
+	  var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1;
+	  var fragments = offset.split(/(\+|\-)/).map(function (frag) {
+	    return frag.trim();
+	  });
+	  var divider = fragments.indexOf(find(fragments, function (frag) {
+	    return frag.search(/,|\s/) !== -1;
+	  }));
+	  if (fragments[divider] && fragments[divider].indexOf(',') === -1) {
+	    console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.');
+	  }
+	  var splitRegex = /\s*,\s*|\s+/;
+	  var ops = divider !== -1 ? [fragments.slice(0, divider).concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat(fragments.slice(divider + 1))] : [fragments];
+	  ops = ops.map(function (op, index) {
+	    var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width';
+	    var mergeWithPrevious = false;
+	    return op
+	    .reduce(function (a, b) {
+	      if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) {
+	        a[a.length - 1] = b;
+	        mergeWithPrevious = true;
+	        return a;
+	      } else if (mergeWithPrevious) {
+	        a[a.length - 1] += b;
+	        mergeWithPrevious = false;
+	        return a;
+	      } else {
+	        return a.concat(b);
+	      }
+	    }, [])
+	    .map(function (str) {
+	      return toValue(str, measurement, popperOffsets, referenceOffsets);
+	    });
+	  });
+	  ops.forEach(function (op, index) {
+	    op.forEach(function (frag, index2) {
+	      if (isNumeric(frag)) {
+	        offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1);
+	      }
+	    });
+	  });
+	  return offsets;
+	}
+	function offset(data, _ref5) {
+	  var offset = _ref5.offset;
+	  var placement = data.placement,
+	    _data$offsets4 = data.offsets,
+	    popper = _data$offsets4.popper,
+	    reference = _data$offsets4.reference;
+	  var basePlacement = placement.split('-')[0];
+	  var offsets;
+	  if (isNumeric(+offset)) {
+	    offsets = [+offset, 0];
+	  } else {
+	    offsets = parseOffset(offset, popper, reference, basePlacement);
+	  }
+	  if (basePlacement === 'left') {
+	    popper.top += offsets[0];
+	    popper.left -= offsets[1];
+	  } else if (basePlacement === 'right') {
+	    popper.top += offsets[0];
+	    popper.left += offsets[1];
+	  } else if (basePlacement === 'top') {
+	    popper.left += offsets[0];
+	    popper.top -= offsets[1];
+	  } else if (basePlacement === 'bottom') {
+	    popper.left += offsets[0];
+	    popper.top += offsets[1];
+	  }
+	  data.popper = popper;
+	  return data;
+	}
+	function preventOverflow(data, options) {
+	  var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);
+	  if (data.instance.reference === boundariesElement) {
+	    boundariesElement = getOffsetParent(boundariesElement);
+	  }
+	  var transformProp = getSupportedPropertyName('transform');
+	  var popperStyles = data.instance.popper.style;
+	  var top = popperStyles.top,
+	    left = popperStyles.left,
+	    transform = popperStyles[transformProp];
+	  popperStyles.top = '';
+	  popperStyles.left = '';
+	  popperStyles[transformProp] = '';
+	  var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed);
+	  popperStyles.top = top;
+	  popperStyles.left = left;
+	  popperStyles[transformProp] = transform;
+	  options.boundaries = boundaries;
+	  var order = options.priority;
+	  var popper = data.offsets.popper;
+	  var check = {
+	    primary: function primary(placement) {
+	      var value = popper[placement];
+	      if (popper[placement] < boundaries[placement] && !options.escapeWithReference) {
+	        value = Math.max(popper[placement], boundaries[placement]);
+	      }
+	      return _defineProperty({}, placement, value);
+	    },
+	    secondary: function secondary(placement) {
+	      var mainSide = placement === 'right' ? 'left' : 'top';
+	      var value = popper[mainSide];
+	      if (popper[placement] > boundaries[placement] && !options.escapeWithReference) {
+	        value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height));
+	      }
+	      return _defineProperty({}, mainSide, value);
+	    }
+	  };
+	  order.forEach(function (placement) {
+	    var side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary';
+	    popper = _extends$1({}, popper, check[side](placement));
+	  });
+	  data.offsets.popper = popper;
+	  return data;
+	}
+	function shift(data) {
+	  var placement = data.placement;
+	  var basePlacement = placement.split('-')[0];
+	  var shiftvariation = placement.split('-')[1];
+	  if (shiftvariation) {
+	    var _data$offsets5 = data.offsets,
+	      reference = _data$offsets5.reference,
+	      popper = _data$offsets5.popper;
+	    var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;
+	    var side = isVertical ? 'left' : 'top';
+	    var measurement = isVertical ? 'width' : 'height';
+	    var shiftOffsets = {
+	      start: _defineProperty({}, side, reference[side]),
+	      end: _defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement])
+	    };
+	    data.offsets.popper = _extends$1({}, popper, shiftOffsets[shiftvariation]);
+	  }
+	  return data;
+	}
+	function hide(data) {
+	  if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {
+	    return data;
+	  }
+	  var refRect = data.offsets.reference;
+	  var bound = find(data.instance.modifiers, function (modifier) {
+	    return modifier.name === 'preventOverflow';
+	  }).boundaries;
+	  if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) {
+	    if (data.hide === true) {
+	      return data;
+	    }
+	    data.hide = true;
+	    data.attributes['x-out-of-boundaries'] = '';
+	  } else {
+	    if (data.hide === false) {
+	      return data;
+	    }
+	    data.hide = false;
+	    data.attributes['x-out-of-boundaries'] = false;
+	  }
+	  return data;
+	}
+	function inner(data) {
+	  var placement = data.placement;
+	  var basePlacement = placement.split('-')[0];
+	  var _data$offsets6 = data.offsets,
+	    popper = _data$offsets6.popper,
+	    reference = _data$offsets6.reference;
+	  var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;
+	  var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;
+	  popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);
+	  data.placement = getOppositePlacement(placement);
+	  data.offsets.popper = getClientRect(popper);
+	  return data;
+	}
+	var modifiers = {
+	  shift: {
+	    order: 100,
+	    enabled: true,
+	    fn: shift
+	  },
+	  offset: {
+	    order: 200,
+	    enabled: true,
+	    fn: offset,
+	    offset: 0
+	  },
+	  preventOverflow: {
+	    order: 300,
+	    enabled: true,
+	    fn: preventOverflow,
+	    priority: ['left', 'right', 'top', 'bottom'],
+	    padding: 5,
+	    boundariesElement: 'scrollParent'
+	  },
+	  keepTogether: {
+	    order: 400,
+	    enabled: true,
+	    fn: keepTogether
+	  },
+	  arrow: {
+	    order: 500,
+	    enabled: true,
+	    fn: arrow,
+	    element: '[x-arrow]'
+	  },
+	  flip: {
+	    order: 600,
+	    enabled: true,
+	    fn: flip,
+	    behavior: 'flip',
+	    padding: 5,
+	    boundariesElement: 'viewport',
+	    flipVariations: false,
+	    flipVariationsByContent: false
+	  },
+	  inner: {
+	    order: 700,
+	    enabled: false,
+	    fn: inner
+	  },
+	  hide: {
+	    order: 800,
+	    enabled: true,
+	    fn: hide
+	  },
+	  computeStyle: {
+	    order: 850,
+	    enabled: true,
+	    fn: computeStyle,
+	    gpuAcceleration: true,
+	    x: 'bottom',
+	    y: 'right'
+	  },
+	  applyStyle: {
+	    order: 900,
+	    enabled: true,
+	    fn: applyStyle,
+	    onLoad: applyStyleOnLoad,
+	    gpuAcceleration: undefined
+	  }
+	};
+	var Defaults = {
+	  placement: 'bottom',
+	  positionFixed: false,
+	  eventsEnabled: true,
+	  removeOnDestroy: false,
+	  onCreate: function onCreate() {},
+	  onUpdate: function onUpdate() {},
+	  modifiers: modifiers
+	};
+	var Popper = function () {
+	  function Popper(reference, popper) {
+	    var _this = this;
+	    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+	    _classCallCheck(this, Popper);
+	    this.scheduleUpdate = function () {
+	      return requestAnimationFrame(_this.update);
+	    };
+	    this.update = debounce(this.update.bind(this));
+	    this.options = _extends$1({}, Popper.Defaults, options);
+	    this.state = {
+	      isDestroyed: false,
+	      isCreated: false,
+	      scrollParents: []
+	    };
+	    this.reference = reference && reference.jquery ? reference[0] : reference;
+	    this.popper = popper && popper.jquery ? popper[0] : popper;
+	    this.options.modifiers = {};
+	    keys$1(_extends$1({}, Popper.Defaults.modifiers, options.modifiers)).forEach(function (name) {
+	      _this.options.modifiers[name] = _extends$1({}, Popper.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {});
+	    });
+	    this.modifiers = keys$1(this.options.modifiers).map(function (name) {
+	      return _extends$1({
+	        name: name
+	      }, _this.options.modifiers[name]);
+	    })
+	    .sort(function (a, b) {
+	      return a.order - b.order;
+	    });
+	    this.modifiers.forEach(function (modifierOptions) {
+	      if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {
+	        modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state);
+	      }
+	    });
+	    this.update();
+	    var eventsEnabled = this.options.eventsEnabled;
+	    if (eventsEnabled) {
+	      this.enableEventListeners();
+	    }
+	    this.state.eventsEnabled = eventsEnabled;
+	  }
+	  _createClass(Popper, [{
+	    key: "update",
+	    value: function update() {
+	      return _update.call(this);
+	    }
+	  }, {
+	    key: "destroy",
+	    value: function destroy() {
+	      return _destroy.call(this);
+	    }
+	  }, {
+	    key: "enableEventListeners",
+	    value: function enableEventListeners() {
+	      return _enableEventListeners.call(this);
+	    }
+	  }, {
+	    key: "disableEventListeners",
+	    value: function disableEventListeners() {
+	      return _disableEventListeners.call(this);
+	    }
+	  }]);
+	  return Popper;
+	}();
+	Popper.Utils = (typeof window !== 'undefined' ? window : global).PopperUtils;
+	Popper.placements = placements;
+	Popper.Defaults = Defaults;
+
+	var requestAnimationFrame$2 = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function (callback) {
+	  window.setTimeout(callback, 1000 / 60);
+	};
+	var cancelAnimationFrame$2 = window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || window.oCancelAnimationFrame || window.msCancelAnimationFrame || function (id) {
+	  window.clearTimeout(id);
+	};
+
+	function _extends$2() {
+	  _extends$2 = assign$1 || function (target) {
+	    for (var i = 1; i < arguments.length; i++) {
+	      var source = arguments[i];
+	      for (var key in source) {
+	        if (Object.prototype.hasOwnProperty.call(source, key)) {
+	          target[key] = source[key];
+	        }
+	      }
+	    }
+	    return target;
+	  };
+	  return _extends$2.apply(this, arguments);
+	}
+	var version = "4.3.4";
+	var isBrowser$1 = typeof window !== 'undefined' && typeof document !== 'undefined';
+	var ua = isBrowser$1 ? navigator.userAgent : '';
+	var isIE$1 = /MSIE |Trident\//.test(ua);
+	var isUCBrowser = /UCBrowser\//.test(ua);
+	var isIOS = isBrowser$1 && /iPhone|iPad|iPod/.test(navigator.platform) && !window.MSStream;
+	var defaultProps = {
+	  a11y: true,
+	  allowHTML: true,
+	  animateFill: true,
+	  animation: 'shift-away',
+	  appendTo: function appendTo() {
+	    return document.body;
+	  },
+	  aria: 'describedby',
+	  arrow: false,
+	  arrowType: 'sharp',
+	  boundary: 'scrollParent',
+	  content: '',
+	  delay: 0,
+	  distance: 10,
+	  duration: [325, 275],
+	  flip: true,
+	  flipBehavior: 'flip',
+	  flipOnUpdate: false,
+	  followCursor: false,
+	  hideOnClick: true,
+	  ignoreAttributes: false,
+	  inertia: false,
+	  interactive: false,
+	  interactiveBorder: 2,
+	  interactiveDebounce: 0,
+	  lazy: true,
+	  width: 'auto',
+	  maxWidth: 'auto',
+	  multiple: false,
+	  offset: 0,
+	  onHidden: function onHidden() {},
+	  onHide: function onHide() {},
+	  onMount: function onMount() {},
+	  onShow: function onShow() {},
+	  onShown: function onShown() {},
+	  onTrigger: function onTrigger() {},
+	  placement: 'top',
+	  popperOptions: {},
+	  role: 'tooltip',
+	  showOnInit: false,
+	  size: 'regular',
+	  sticky: false,
+	  target: '',
+	  theme: 'dark',
+	  touch: true,
+	  touchHold: false,
+	  trigger: 'mouseenter focus',
+	  triggerTarget: null,
+	  updateDuration: 0,
+	  wait: null,
+	  zIndex: 9999,
+	  extCls: ''
+	};
+	var POPPER_INSTANCE_DEPENDENCIES = ['arrow', 'arrowType', 'boundary', 'distance', 'flip', 'flipBehavior', 'flipOnUpdate', 'offset', 'placement', 'popperOptions'];
+	var elementProto = isBrowser$1 ? Element.prototype : {};
+	var matches = elementProto.matches || elementProto.matchesSelector || elementProto.webkitMatchesSelector || elementProto.mozMatchesSelector || elementProto.msMatchesSelector;
+	function arrayFrom(value) {
+	  return [].slice.call(value);
+	}
+	function closest(element, selector) {
+	  return closestCallback(element, function (el) {
+	    return matches.call(el, selector);
+	  });
+	}
+	function closestCallback(element, callback) {
+	  while (element) {
+	    if (callback(element)) {
+	      return element;
+	    }
+	    element = element.parentElement;
+	  }
+	  return null;
+	}
+	var PASSIVE = {
+	  passive: true
+	};
+	var PADDING = 4;
+	var PLACEMENT_ATTRIBUTE = 'x-placement';
+	var OUT_OF_BOUNDARIES_ATTRIBUTE = 'x-out-of-boundaries';
+	var IOS_CLASS = "tippy-iOS";
+	var ACTIVE_CLASS = "tippy-active";
+	var POPPER_CLASS = "tippy-popper";
+	var TOOLTIP_CLASS = "tippy-tooltip";
+	var CONTENT_CLASS = "tippy-content";
+	var BACKDROP_CLASS = "tippy-backdrop";
+	var ARROW_CLASS = "tippy-arrow";
+	var ROUND_ARROW_CLASS = "tippy-roundarrow";
+	var POPPER_SELECTOR = ".".concat(POPPER_CLASS);
+	var TOOLTIP_SELECTOR = ".".concat(TOOLTIP_CLASS);
+	var CONTENT_SELECTOR = ".".concat(CONTENT_CLASS);
+	var BACKDROP_SELECTOR = ".".concat(BACKDROP_CLASS);
+	var ARROW_SELECTOR = ".".concat(ARROW_CLASS);
+	var ROUND_ARROW_SELECTOR = ".".concat(ROUND_ARROW_CLASS);
+	var isUsingTouch = false;
+	function onDocumentTouch() {
+	  if (isUsingTouch) {
+	    return;
+	  }
+	  isUsingTouch = true;
+	  if (isIOS) {
+	    document.body.classList.add(IOS_CLASS);
+	  }
+	  if (window.performance) {
+	    document.addEventListener('mousemove', onDocumentMouseMove);
+	  }
+	}
+	var lastMouseMoveTime = 0;
+	function onDocumentMouseMove() {
+	  var now = performance.now();
+	  if (now - lastMouseMoveTime < 20) {
+	    isUsingTouch = false;
+	    document.removeEventListener('mousemove', onDocumentMouseMove);
+	    if (!isIOS) {
+	      document.body.classList.remove(IOS_CLASS);
+	    }
+	  }
+	  lastMouseMoveTime = now;
+	}
+	function onWindowBlur() {
+	  var _document = document,
+	    activeElement = _document.activeElement;
+	  if (activeElement && activeElement.blur && activeElement._tippy) {
+	    activeElement.blur();
+	  }
+	}
+	function bindGlobalEventListeners() {
+	  document.addEventListener('touchstart', onDocumentTouch, PASSIVE);
+	  window.addEventListener('blur', onWindowBlur);
+	}
+	var keys$2 = keys$1(defaultProps);
+	function getDataAttributeOptions(reference) {
+	  return keys$2.reduce(function (acc, key) {
+	    var valueAsString = (reference.getAttribute("data-tippy-".concat(key)) || '').trim();
+	    if (!valueAsString) {
+	      return acc;
+	    }
+	    if (key === 'content') {
+	      acc[key] = valueAsString;
+	    } else {
+	      try {
+	        acc[key] = JSON.parse(valueAsString);
+	      } catch (e) {
+	        acc[key] = valueAsString;
+	      }
+	    }
+	    return acc;
+	  }, {});
+	}
+	function polyfillElementPrototypeProperties(virtualReference) {
+	  var polyfills = {
+	    isVirtual: true,
+	    attributes: virtualReference.attributes || {},
+	    contains: function contains() {},
+	    setAttribute: function setAttribute(key, value) {
+	      virtualReference.attributes[key] = value;
+	    },
+	    getAttribute: function getAttribute(key) {
+	      return virtualReference.attributes[key];
+	    },
+	    removeAttribute: function removeAttribute(key) {
+	      delete virtualReference.attributes[key];
+	    },
+	    hasAttribute: function hasAttribute(key) {
+	      return key in virtualReference.attributes;
+	    },
+	    addEventListener: function addEventListener() {},
+	    removeEventListener: function removeEventListener() {},
+	    classList: {
+	      classNames: {},
+	      add: function add(key) {
+	        virtualReference.classList.classNames[key] = true;
+	      },
+	      remove: function remove(key) {
+	        delete virtualReference.classList.classNames[key];
+	      },
+	      contains: function contains(key) {
+	        return key in virtualReference.classList.classNames;
+	      }
+	    }
+	  };
+	  for (var key in polyfills) {
+	    virtualReference[key] = polyfills[key];
+	  }
+	}
+	function isBareVirtualElement(value) {
+	  return {}.toString.call(value) === '[object Object]' && !value.addEventListener;
+	}
+	function isReferenceElement(value) {
+	  return !!value._tippy && !matches.call(value, POPPER_SELECTOR);
+	}
+	function hasOwnProperty$1(obj, key) {
+	  return {}.hasOwnProperty.call(obj, key);
+	}
+	function getArrayOfElements(value) {
+	  if (isSingular(value)) {
+	    return [value];
+	  }
+	  if (value instanceof NodeList) {
+	    return arrayFrom(value);
+	  }
+	  if (isArray$1(value)) {
+	    return value;
+	  }
+	  try {
+	    return arrayFrom(document.querySelectorAll(value));
+	  } catch (e) {
+	    return [];
+	  }
+	}
+	function getValue(value, index, defaultValue) {
+	  if (isArray$1(value)) {
+	    var v = value[index];
+	    return v == null ? defaultValue : v;
+	  }
+	  return value;
+	}
+	function debounce$1(fn, ms) {
+	  if (ms === 0) {
+	    return fn;
+	  }
+	  var timeout;
+	  return function (arg) {
+	    clearTimeout(timeout);
+	    timeout = setTimeout(function () {
+	      fn(arg);
+	    }, ms);
+	  };
+	}
+	function getModifier(obj, key) {
+	  return obj && obj.modifiers && obj.modifiers[key];
+	}
+	function includes(a, b) {
+	  return a.indexOf(b) > -1;
+	}
+	function isRealElement(value) {
+	  return value instanceof Element;
+	}
+	function isSingular(value) {
+	  return !!(value && hasOwnProperty$1(value, 'isVirtual')) || isRealElement(value);
+	}
+	function innerHTML() {
+	  return 'innerHTML';
+	}
+	function invokeWithArgsOrReturn(value, args) {
+	  return typeof value === 'function' ? value.apply(null, args) : value;
+	}
+	function setFlipModifierEnabled(modifiers, value) {
+	  modifiers.filter(function (m) {
+	    return m.name === 'flip';
+	  })[0].enabled = value;
+	}
+	function canReceiveFocus(element) {
+	  return isRealElement(element) ? matches.call(element, 'a[href],area[href],button,details,input,textarea,select,iframe,[tabindex]') && !element.hasAttribute('disabled') : true;
+	}
+	function div() {
+	  return document.createElement('div');
+	}
+	function setTransitionDuration(els, value) {
+	  els.forEach(function (el) {
+	    if (el) {
+	      el.style.transitionDuration = "".concat(value, "ms");
+	    }
+	  });
+	}
+	function setVisibilityState(els, state) {
+	  els.forEach(function (el) {
+	    if (el) {
+	      el.setAttribute('data-state', state);
+	    }
+	  });
+	}
+	function evaluateProps(reference, props) {
+	  var out = _extends$2({}, props, {
+	    content: invokeWithArgsOrReturn(props.content, [reference])
+	  }, props.ignoreAttributes ? {} : getDataAttributeOptions(reference));
+	  if (out.arrow || isUCBrowser) {
+	    out.animateFill = false;
+	  }
+	  return out;
+	}
+	function validateOptions(options, defaultProps) {
+	  keys$1(options).forEach(function (option) {
+	    if (!hasOwnProperty$1(defaultProps, option)) {
+	      throw new Error("[tippy]: `".concat(option, "` is not a valid option"));
+	    }
+	  });
+	}
+	function setInnerHTML(element, html) {
+	  element[innerHTML()] = isRealElement(html) ? html[innerHTML()] : html;
+	}
+	function setContent(contentEl, props) {
+	  if (isRealElement(props.content)) {
+	    setInnerHTML(contentEl, '');
+	    contentEl.appendChild(props.content);
+	  } else if (typeof props.content !== 'function') {
+	    var key = props.allowHTML ? 'innerHTML' : 'textContent';
+	    contentEl[key] = props.content;
+	  }
+	}
+	function getChildren(popper) {
+	  return {
+	    tooltip: popper.querySelector(TOOLTIP_SELECTOR),
+	    backdrop: popper.querySelector(BACKDROP_SELECTOR),
+	    content: popper.querySelector(CONTENT_SELECTOR),
+	    arrow: popper.querySelector(ARROW_SELECTOR) || popper.querySelector(ROUND_ARROW_SELECTOR)
+	  };
+	}
+	function addInertia(tooltip) {
+	  tooltip.setAttribute('data-inertia', '');
+	}
+	function removeInertia(tooltip) {
+	  tooltip.removeAttribute('data-inertia');
+	}
+	function createArrowElement(arrowType) {
+	  var arrow = div();
+	  if (arrowType === 'round') {
+	    arrow.className = ROUND_ARROW_CLASS;
+	    setInnerHTML(arrow, '<svg viewBox="0 0 18 7" xmlns="http://www.w3.org/2000/svg"><path d="M0 7s2.021-.015 5.253-4.218C6.584 1.051 7.797.007 9 0c1.203-.007 2.416 1.035 3.761 2.782C16.012 7.005 18 7 18 7H0z"/></svg>');
+	  } else {
+	    arrow.className = ARROW_CLASS;
+	  }
+	  return arrow;
+	}
+	function createBackdropElement() {
+	  var backdrop = div();
+	  backdrop.className = BACKDROP_CLASS;
+	  backdrop.setAttribute('data-state', 'hidden');
+	  return backdrop;
+	}
+	function addInteractive(popper, tooltip) {
+	  popper.setAttribute('tabindex', '-1');
+	  tooltip.setAttribute('data-interactive', '');
+	}
+	function removeInteractive(popper, tooltip) {
+	  popper.removeAttribute('tabindex');
+	  tooltip.removeAttribute('data-interactive');
+	}
+	function updateTransitionEndListener(tooltip, action, listener) {
+	  var eventName = isUCBrowser && document.body.style.webkitTransition !== undefined ? 'webkitTransitionEnd' : 'transitionend';
+	  tooltip[action + 'EventListener'](eventName, listener);
+	}
+	function getBasicPlacement(popper) {
+	  var fullPlacement = popper.getAttribute(PLACEMENT_ATTRIBUTE);
+	  return fullPlacement ? fullPlacement.split('-')[0] : '';
+	}
+	function reflow(popper) {
+	  void popper.offsetHeight;
+	}
+	function updateTheme(tooltip, action, theme) {
+	  theme.split(' ').forEach(function (themeName) {
+	    tooltip.classList[action](themeName + '-theme');
+	  });
+	}
+	function setWidth(tooltip, props, key) {
+	  var width = props[key];
+	  var parsedWidth = _parseInt$2(width);
+	  if (typeof width === 'number') {
+	    tooltip.style[key] = width + 'px';
+	  } else if (isNaN(parsedWidth)) {
+	    tooltip.style[key] = width;
+	  } else {
+	    tooltip.style[key] = parsedWidth + 'px';
+	  }
+	}
+	function createPopperElement(id, props) {
+	  var popper = div();
+	  popper.className = POPPER_CLASS + (props.extCls ? " ".concat(props.extCls) : '');
+	  popper.id = "tippy-".concat(id);
+	  popper.style.zIndex = '' + props.zIndex;
+	  popper.style.position = 'absolute';
+	  popper.style.top = '0';
+	  popper.style.left = '0';
+	  if (props.role) {
+	    popper.setAttribute('role', props.role);
+	  }
+	  var tooltip = div();
+	  tooltip.className = TOOLTIP_CLASS;
+	  setWidth(tooltip, props, 'maxWidth');
+	  setWidth(tooltip, props, 'width');
+	  tooltip.setAttribute('data-size', props.size);
+	  tooltip.setAttribute('data-animation', props.animation);
+	  tooltip.setAttribute('data-state', 'hidden');
+	  updateTheme(tooltip, 'add', props.theme);
+	  var content = div();
+	  content.className = CONTENT_CLASS;
+	  content.setAttribute('data-state', 'hidden');
+	  if (props.interactive) {
+	    addInteractive(popper, tooltip);
+	  }
+	  if (props.arrow) {
+	    tooltip.appendChild(createArrowElement(props.arrowType));
+	  }
+	  if (props.animateFill) {
+	    tooltip.appendChild(createBackdropElement());
+	    tooltip.setAttribute('data-animatefill', '');
+	  }
+	  if (props.inertia) {
+	    addInertia(tooltip);
+	  }
+	  setContent(content, props);
+	  tooltip.appendChild(content);
+	  popper.appendChild(tooltip);
+	  return popper;
+	}
+	function updatePopperElement(popper, prevProps, nextProps) {
+	  var _getChildren = getChildren(popper),
+	    tooltip = _getChildren.tooltip,
+	    content = _getChildren.content,
+	    backdrop = _getChildren.backdrop,
+	    arrow = _getChildren.arrow;
+	  popper.style.zIndex = '' + nextProps.zIndex;
+	  tooltip.setAttribute('data-size', nextProps.size);
+	  tooltip.setAttribute('data-animation', nextProps.animation);
+	  tooltip.style.maxWidth = nextProps.maxWidth + (typeof nextProps.maxWidth === 'number' ? 'px' : '');
+	  if (nextProps.role) {
+	    popper.setAttribute('role', nextProps.role);
+	  } else {
+	    popper.removeAttribute('role');
+	  }
+	  if (prevProps.content !== nextProps.content) {
+	    setContent(content, nextProps);
+	  }
+	  if (!prevProps.animateFill && nextProps.animateFill) {
+	    tooltip.appendChild(createBackdropElement());
+	    tooltip.setAttribute('data-animatefill', '');
+	  } else if (prevProps.animateFill && !nextProps.animateFill) {
+	    tooltip.removeChild(backdrop);
+	    tooltip.removeAttribute('data-animatefill');
+	  }
+	  if (!prevProps.arrow && nextProps.arrow) {
+	    tooltip.appendChild(createArrowElement(nextProps.arrowType));
+	  } else if (prevProps.arrow && !nextProps.arrow) {
+	    tooltip.removeChild(arrow);
+	  }
+	  if (prevProps.arrow && nextProps.arrow && prevProps.arrowType !== nextProps.arrowType) {
+	    tooltip.replaceChild(createArrowElement(nextProps.arrowType), arrow);
+	  }
+	  if (!prevProps.interactive && nextProps.interactive) {
+	    addInteractive(popper, tooltip);
+	  } else if (prevProps.interactive && !nextProps.interactive) {
+	    removeInteractive(popper, tooltip);
+	  }
+	  if (!prevProps.inertia && nextProps.inertia) {
+	    addInertia(tooltip);
+	  } else if (prevProps.inertia && !nextProps.inertia) {
+	    removeInertia(tooltip);
+	  }
+	  if (prevProps.theme !== nextProps.theme) {
+	    updateTheme(tooltip, 'remove', prevProps.theme);
+	    updateTheme(tooltip, 'add', nextProps.theme);
+	  }
+	}
+	function hideAll() {
+	  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+	    excludedReferenceOrInstance = _ref.exclude,
+	    duration = _ref.duration;
+	  arrayFrom(document.querySelectorAll(POPPER_SELECTOR)).forEach(function (popper) {
+	    var instance = popper._tippy;
+	    if (instance) {
+	      var isExcluded = false;
+	      if (excludedReferenceOrInstance) {
+	        isExcluded = isReferenceElement(excludedReferenceOrInstance) ? instance.reference === excludedReferenceOrInstance : popper === excludedReferenceOrInstance.popper;
+	      }
+	      if (!isExcluded) {
+	        instance.hide(duration);
+	      }
+	    }
+	  });
+	}
+	function isCursorOutsideInteractiveBorder(popperPlacement, popperRect, event, props) {
+	  if (!popperPlacement) {
+	    return true;
+	  }
+	  var x = event.clientX,
+	    y = event.clientY;
+	  var interactiveBorder = props.interactiveBorder,
+	    distance = props.distance;
+	  var exceedsTop = popperRect.top - y > (popperPlacement === 'top' ? interactiveBorder + distance : interactiveBorder);
+	  var exceedsBottom = y - popperRect.bottom > (popperPlacement === 'bottom' ? interactiveBorder + distance : interactiveBorder);
+	  var exceedsLeft = popperRect.left - x > (popperPlacement === 'left' ? interactiveBorder + distance : interactiveBorder);
+	  var exceedsRight = x - popperRect.right > (popperPlacement === 'right' ? interactiveBorder + distance : interactiveBorder);
+	  return exceedsTop || exceedsBottom || exceedsLeft || exceedsRight;
+	}
+	function getOffsetDistanceInPx(distance) {
+	  return -(distance - 10) + 'px';
+	}
+	var idCounter = 1;
+	var mouseMoveListeners = [];
+	function createTippy(reference, collectionProps) {
+	  var props = evaluateProps(reference, collectionProps);
+	  if (!props.multiple && reference._tippy) {
+	    return null;
+	  }
+	  var lastTriggerEventType;
+	  var lastMouseMoveEvent;
+	  var showTimeoutId;
+	  var hideTimeoutId;
+	  var scheduleHideAnimationFrameId;
+	  var isScheduledToShow = false;
+	  var isBeingDestroyed = false;
+	  var previousPlacement;
+	  var wasVisibleDuringPreviousUpdate = false;
+	  var hasMountCallbackRun = false;
+	  var currentMountCallback;
+	  var currentTransitionEndListener;
+	  var listeners = [];
+	  var currentComputedPadding;
+	  var debouncedOnMouseMove = debounce$1(onMouseMove, props.interactiveDebounce);
+	  var id = idCounter++;
+	  var popper = createPopperElement(id, props);
+	  var popperChildren = getChildren(popper);
+	  var popperInstance = null;
+	  var state = {
+	    isEnabled: true,
+	    isVisible: false,
+	    isDestroyed: false,
+	    isMounted: false,
+	    isShown: false
+	  };
+	  var instance = {
+	    id: id,
+	    reference: reference,
+	    popper: popper,
+	    popperChildren: popperChildren,
+	    popperInstance: popperInstance,
+	    props: props,
+	    state: state,
+	    clearDelayTimeouts: clearDelayTimeouts,
+	    set: set,
+	    setContent: setContent,
+	    show: show,
+	    hide: hide,
+	    enable: enable,
+	    disable: disable,
+	    destroy: destroy
+	  };
+	  reference._tippy = instance;
+	  popper._tippy = instance;
+	  addTriggersToReference();
+	  if (!props.lazy) {
+	    createPopperInstance();
+	  }
+	  if (props.showOnInit) {
+	    scheduleShow();
+	  }
+	  if (props.a11y && !props.target && !canReceiveFocus(getEventListenersTarget())) {
+	    getEventListenersTarget().setAttribute('tabindex', '0');
+	  }
+	  popper.addEventListener('mouseenter', function (event) {
+	    if (instance.props.interactive && instance.state.isVisible && lastTriggerEventType === 'mouseenter') {
+	      scheduleShow(event, true);
+	    }
+	  });
+	  popper.addEventListener('mouseleave', function () {
+	    if (instance.props.interactive && lastTriggerEventType === 'mouseenter') {
+	      document.addEventListener('mousemove', debouncedOnMouseMove);
+	    }
+	  });
+	  return instance;
+	  function removeFollowCursorListener() {
+	    document.removeEventListener('mousemove', positionVirtualReferenceNearCursor);
+	  }
+	  function cleanupInteractiveMouseListeners() {
+	    document.body.removeEventListener('mouseleave', scheduleHide);
+	    document.removeEventListener('mousemove', debouncedOnMouseMove);
+	    mouseMoveListeners = mouseMoveListeners.filter(function (listener) {
+	      return listener !== debouncedOnMouseMove;
+	    });
+	  }
+	  function getEventListenersTarget() {
+	    return instance.props.triggerTarget || reference;
+	  }
+	  function addDocumentClickListener() {
+	    document.addEventListener('click', onDocumentClick, true);
+	  }
+	  function removeDocumentClickListener() {
+	    document.removeEventListener('click', onDocumentClick, true);
+	  }
+	  function getTransitionableElements() {
+	    return [instance.popperChildren.tooltip, instance.popperChildren.backdrop, instance.popperChildren.content];
+	  }
+	  function getIsInLooseFollowCursorMode() {
+	    var followCursor = instance.props.followCursor;
+	    return followCursor && lastTriggerEventType !== 'focus' || isUsingTouch && followCursor === 'initial';
+	  }
+	  function makeSticky() {
+	    setTransitionDuration([popper], isIE$1 ? 0 : instance.props.updateDuration);
+	    function updatePosition() {
+	      instance.popperInstance.scheduleUpdate();
+	      if (instance.state.isMounted) {
+	        requestAnimationFrame(updatePosition);
+	      } else {
+	        setTransitionDuration([popper], 0);
+	      }
+	    }
+	    updatePosition();
+	  }
+	  function onTransitionedOut(duration, callback) {
+	    onTransitionEnd(duration, function () {
+	      if (!instance.state.isVisible && popper.parentNode && popper.parentNode.contains(popper)) {
+	        callback();
+	      }
+	    });
+	  }
+	  function onTransitionedIn(duration, callback) {
+	    onTransitionEnd(duration, callback);
+	  }
+	  function onTransitionEnd(duration, callback) {
+	    var tooltip = instance.popperChildren.tooltip;
+	    function listener(event) {
+	      if (event.target === tooltip) {
+	        updateTransitionEndListener(tooltip, 'remove', listener);
+	        callback();
+	      }
+	    }
+	    if (duration === 0) {
+	      return callback();
+	    }
+	    updateTransitionEndListener(tooltip, 'remove', currentTransitionEndListener);
+	    updateTransitionEndListener(tooltip, 'add', listener);
+	    currentTransitionEndListener = listener;
+	  }
+	  function on(eventType, handler) {
+	    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+	    getEventListenersTarget().addEventListener(eventType, handler, options);
+	    listeners.push({
+	      eventType: eventType,
+	      handler: handler,
+	      options: options
+	    });
+	  }
+	  function addTriggersToReference() {
+	    if (instance.props.touchHold && !instance.props.target) {
+	      on('touchstart', onTrigger, PASSIVE);
+	      on('touchend', onMouseLeave, PASSIVE);
+	    }
+	    instance.props.trigger.trim().split(' ').forEach(function (eventType) {
+	      if (eventType === 'manual') {
+	        return;
+	      }
+	      if (!instance.props.target) {
+	        on(eventType, onTrigger);
+	        switch (eventType) {
+	          case 'mouseenter':
+	            on('mouseleave', onMouseLeave);
+	            break;
+	          case 'focus':
+	            on(isIE$1 ? 'focusout' : 'blur', onBlur);
+	            break;
+	        }
+	      } else {
+	        switch (eventType) {
+	          case 'mouseenter':
+	            on('mouseover', onDelegateShow);
+	            on('mouseout', onDelegateHide);
+	            break;
+	          case 'focus':
+	            on('focusin', onDelegateShow);
+	            on('focusout', onDelegateHide);
+	            break;
+	          case 'click':
+	            on(eventType, onDelegateShow);
+	            break;
+	        }
+	      }
+	    });
+	  }
+	  function removeTriggersFromReference() {
+	    listeners.forEach(function (_ref) {
+	      var eventType = _ref.eventType,
+	        handler = _ref.handler,
+	        options = _ref.options;
+	      getEventListenersTarget().removeEventListener(eventType, handler, options);
+	    });
+	    listeners = [];
+	  }
+	  function positionVirtualReferenceNearCursor(event) {
+	    var _lastMouseMoveEvent = lastMouseMoveEvent = event,
+	      x = _lastMouseMoveEvent.clientX,
+	      y = _lastMouseMoveEvent.clientY;
+	    if (!currentComputedPadding) {
+	      return;
+	    }
+	    var isCursorOverReference = closestCallback(event.target, function (el) {
+	      return el === reference;
+	    });
+	    var rect = reference.getBoundingClientRect();
+	    var followCursor = instance.props.followCursor;
+	    var isHorizontal = followCursor === 'horizontal';
+	    var isVertical = followCursor === 'vertical';
+	    var isVerticalPlacement = includes(['top', 'bottom'], getBasicPlacement(popper));
+	    var fullPlacement = popper.getAttribute(PLACEMENT_ATTRIBUTE);
+	    var isVariation = fullPlacement ? !!fullPlacement.split('-')[1] : false;
+	    var size = isVerticalPlacement ? popper.offsetWidth : popper.offsetHeight;
+	    var halfSize = size / 2;
+	    var verticalIncrease = isVerticalPlacement ? 0 : isVariation ? size : halfSize;
+	    var horizontalIncrease = isVerticalPlacement ? isVariation ? size : halfSize : 0;
+	    if (isCursorOverReference || !instance.props.interactive) {
+	      instance.popperInstance.reference = _extends$2({}, instance.popperInstance.reference, {
+	        clientWidth: 0,
+	        clientHeight: 0,
+	        getBoundingClientRect: function getBoundingClientRect() {
+	          return {
+	            width: isVerticalPlacement ? size : 0,
+	            height: isVerticalPlacement ? 0 : size,
+	            top: (isHorizontal ? rect.top : y) - verticalIncrease,
+	            bottom: (isHorizontal ? rect.bottom : y) + verticalIncrease,
+	            left: (isVertical ? rect.left : x) - horizontalIncrease,
+	            right: (isVertical ? rect.right : x) + horizontalIncrease
+	          };
+	        }
+	      });
+	      instance.popperInstance.update();
+	    }
+	    if (followCursor === 'initial' && instance.state.isVisible) {
+	      removeFollowCursorListener();
+	    }
+	  }
+	  function createDelegateChildTippy(event) {
+	    if (event) {
+	      var targetEl = closest(event.target, instance.props.target);
+	      if (targetEl && !targetEl._tippy) {
+	        createTippy(targetEl, _extends$2({}, instance.props, {
+	          content: invokeWithArgsOrReturn(collectionProps.content, [targetEl]),
+	          appendTo: collectionProps.appendTo,
+	          target: '',
+	          showOnInit: true
+	        }));
+	      }
+	    }
+	  }
+	  function onTrigger(event) {
+	    if (!instance.state.isEnabled || isEventListenerStopped(event)) {
+	      return;
+	    }
+	    if (!instance.state.isVisible) {
+	      lastTriggerEventType = event.type;
+	      if (event instanceof MouseEvent) {
+	        lastMouseMoveEvent = event;
+	        mouseMoveListeners.forEach(function (listener) {
+	          return listener(event);
+	        });
+	      }
+	    }
+	    if (event.type === 'click' && instance.props.hideOnClick !== false && instance.state.isVisible) {
+	      scheduleHide();
+	    } else {
+	      scheduleShow(event);
+	    }
+	  }
+	  function onMouseMove(event) {
+	    var isCursorOverPopper = closest(event.target, POPPER_SELECTOR) === popper;
+	    var isCursorOverReference = closestCallback(event.target, function (el) {
+	      return el === reference;
+	    });
+	    if (isCursorOverPopper || isCursorOverReference) {
+	      return;
+	    }
+	    if (isCursorOutsideInteractiveBorder(getBasicPlacement(popper), popper.getBoundingClientRect(), event, instance.props)) {
+	      cleanupInteractiveMouseListeners();
+	      scheduleHide();
+	    }
+	  }
+	  function onMouseLeave(event) {
+	    if (isEventListenerStopped(event)) {
+	      return;
+	    }
+	    if (instance.props.interactive) {
+	      document.body.addEventListener('mouseleave', scheduleHide);
+	      document.addEventListener('mousemove', debouncedOnMouseMove);
+	      mouseMoveListeners.push(debouncedOnMouseMove);
+	      return;
+	    }
+	    scheduleHide();
+	  }
+	  function onBlur(event) {
+	    if (event.target !== getEventListenersTarget()) {
+	      return;
+	    }
+	    if (instance.props.interactive && event.relatedTarget && popper.contains(event.relatedTarget)) {
+	      return;
+	    }
+	    scheduleHide();
+	  }
+	  function onDelegateShow(event) {
+	    if (closest(event.target, instance.props.target)) {
+	      scheduleShow(event);
+	    }
+	  }
+	  function onDelegateHide(event) {
+	    if (closest(event.target, instance.props.target)) {
+	      scheduleHide();
+	    }
+	  }
+	  function isEventListenerStopped(event) {
+	    var supportsTouch = ('ontouchstart' in window);
+	    var isTouchEvent = includes(event.type, 'touch');
+	    var touchHold = instance.props.touchHold;
+	    return supportsTouch && isUsingTouch && touchHold && !isTouchEvent || isUsingTouch && !touchHold && isTouchEvent;
+	  }
+	  function runMountCallback() {
+	    if (!hasMountCallbackRun && currentMountCallback) {
+	      hasMountCallbackRun = true;
+	      reflow(popper);
+	      currentMountCallback();
+	    }
+	  }
+	  function createPopperInstance() {
+	    var popperOptions = instance.props.popperOptions;
+	    var _instance$popperChild = instance.popperChildren,
+	      tooltip = _instance$popperChild.tooltip,
+	      arrow = _instance$popperChild.arrow;
+	    var preventOverflowModifier = getModifier(popperOptions, 'preventOverflow');
+	    function applyMutations(data) {
+	      if (instance.props.flip && !instance.props.flipOnUpdate) {
+	        if (data.flipped) {
+	          instance.popperInstance.options.placement = data.placement;
+	        }
+	        setFlipModifierEnabled(instance.popperInstance.modifiers, false);
+	      }
+	      tooltip.setAttribute(PLACEMENT_ATTRIBUTE, data.placement);
+	      if (data.attributes[OUT_OF_BOUNDARIES_ATTRIBUTE] !== false) {
+	        tooltip.setAttribute(OUT_OF_BOUNDARIES_ATTRIBUTE, '');
+	      } else {
+	        tooltip.removeAttribute(OUT_OF_BOUNDARIES_ATTRIBUTE);
+	      }
+	      if (previousPlacement && previousPlacement !== data.placement && wasVisibleDuringPreviousUpdate) {
+	        tooltip.style.transition = 'none';
+	        requestAnimationFrame(function () {
+	          tooltip.style.transition = '';
+	        });
+	      }
+	      previousPlacement = data.placement;
+	      wasVisibleDuringPreviousUpdate = instance.state.isVisible;
+	      var basicPlacement = getBasicPlacement(popper);
+	      var styles = tooltip.style;
+	      styles.top = styles.bottom = styles.left = styles.right = '';
+	      styles[basicPlacement] = getOffsetDistanceInPx(instance.props.distance);
+	      var padding = preventOverflowModifier && preventOverflowModifier.padding !== undefined ? preventOverflowModifier.padding : PADDING;
+	      var isPaddingNumber = typeof padding === 'number';
+	      var computedPadding = _extends$2({
+	        top: isPaddingNumber ? padding : padding.top,
+	        bottom: isPaddingNumber ? padding : padding.bottom,
+	        left: isPaddingNumber ? padding : padding.left,
+	        right: isPaddingNumber ? padding : padding.right
+	      }, !isPaddingNumber && padding);
+	      computedPadding[basicPlacement] = isPaddingNumber ? padding + instance.props.distance : (padding[basicPlacement] || 0) + instance.props.distance;
+	      instance.popperInstance.modifiers.filter(function (m) {
+	        return m.name === 'preventOverflow';
+	      })[0].padding = computedPadding;
+	      currentComputedPadding = computedPadding;
+	    }
+	    var config = _extends$2({
+	      eventsEnabled: false,
+	      placement: instance.props.placement
+	    }, popperOptions, {
+	      modifiers: _extends$2({}, popperOptions ? popperOptions.modifiers : {}, {
+	        preventOverflow: _extends$2({
+	          boundariesElement: instance.props.boundary,
+	          padding: PADDING
+	        }, preventOverflowModifier),
+	        arrow: _extends$2({
+	          element: arrow,
+	          enabled: !!arrow
+	        }, getModifier(popperOptions, 'arrow')),
+	        flip: _extends$2({
+	          enabled: instance.props.flip,
+	          padding: instance.props.distance + PADDING,
+	          behavior: instance.props.flipBehavior
+	        }, getModifier(popperOptions, 'flip')),
+	        offset: _extends$2({
+	          offset: instance.props.offset
+	        }, getModifier(popperOptions, 'offset'))
+	      }),
+	      onCreate: function onCreate(data) {
+	        applyMutations(data);
+	        runMountCallback();
+	        if (popperOptions && popperOptions.onCreate) {
+	          popperOptions.onCreate(data);
+	        }
+	      },
+	      onUpdate: function onUpdate(data) {
+	        applyMutations(data);
+	        runMountCallback();
+	        if (popperOptions && popperOptions.onUpdate) {
+	          popperOptions.onUpdate(data);
+	        }
+	      }
+	    });
+	    instance.popperInstance = new Popper(reference, popper, config);
+	  }
+	  function mount() {
+	    hasMountCallbackRun = false;
+	    var isInLooseFollowCursorMode = getIsInLooseFollowCursorMode();
+	    if (instance.popperInstance) {
+	      setFlipModifierEnabled(instance.popperInstance.modifiers, instance.props.flip);
+	      if (!isInLooseFollowCursorMode) {
+	        instance.popperInstance.reference = reference;
+	        instance.popperInstance.enableEventListeners();
+	      }
+	      instance.popperInstance.scheduleUpdate();
+	    } else {
+	      createPopperInstance();
+	      if (!isInLooseFollowCursorMode) {
+	        instance.popperInstance.enableEventListeners();
+	      }
+	    }
+	    var appendTo = instance.props.appendTo;
+	    var parentNode = appendTo === 'parent' ? reference.parentNode : invokeWithArgsOrReturn(appendTo, [reference]);
+	    if (!parentNode.contains(popper)) {
+	      parentNode.appendChild(popper);
+	      instance.props.onMount(instance);
+	      instance.state.isMounted = true;
+	    }
+	  }
+	  function scheduleShow(event, shouldAvoidCallingOnTrigger) {
+	    clearDelayTimeouts();
+	    if (instance.state.isVisible) {
+	      return;
+	    }
+	    if (instance.props.target) {
+	      return createDelegateChildTippy(event);
+	    }
+	    isScheduledToShow = true;
+	    if (event && !shouldAvoidCallingOnTrigger) {
+	      instance.props.onTrigger(instance, event);
+	    }
+	    if (instance.props.wait) {
+	      return instance.props.wait(instance, event);
+	    }
+	    if (getIsInLooseFollowCursorMode() && !instance.state.isMounted) {
+	      if (!instance.popperInstance) {
+	        createPopperInstance();
+	      }
+	      document.addEventListener('mousemove', positionVirtualReferenceNearCursor);
+	    }
+	    addDocumentClickListener();
+	    var delay = getValue(instance.props.delay, 0, defaultProps.delay);
+	    if (delay) {
+	      showTimeoutId = setTimeout(function () {
+	        show();
+	      }, delay);
+	    } else {
+	      show();
+	    }
+	  }
+	  function scheduleHide() {
+	    clearDelayTimeouts();
+	    if (!instance.state.isVisible) {
+	      return removeFollowCursorListener();
+	    }
+	    isScheduledToShow = false;
+	    var delay = getValue(instance.props.delay, 1, defaultProps.delay);
+	    if (delay) {
+	      hideTimeoutId = setTimeout(function () {
+	        if (instance.state.isVisible) {
+	          hide();
+	        }
+	      }, delay);
+	    } else {
+	      scheduleHideAnimationFrameId = requestAnimationFrame(function () {
+	        hide();
+	      });
+	    }
+	  }
+	  function onDocumentClick(event) {
+	    if (instance.props.interactive && popper.contains(event.target)) {
+	      return;
+	    }
+	    if (getEventListenersTarget().contains(event.target)) {
+	      if (isUsingTouch) {
+	        return;
+	      }
+	      if (instance.state.isVisible && includes(instance.props.trigger, 'click')) {
+	        return;
+	      }
+	    }
+	    if (instance.props.hideOnClick === true) {
+	      clearDelayTimeouts();
+	      hide();
+	    }
+	  }
+	  function enable() {
+	    instance.state.isEnabled = true;
+	  }
+	  function disable() {
+	    instance.state.isEnabled = false;
+	  }
+	  function clearDelayTimeouts() {
+	    clearTimeout(showTimeoutId);
+	    clearTimeout(hideTimeoutId);
+	    cancelAnimationFrame(scheduleHideAnimationFrameId);
+	  }
+	  function set(options) {
+	    options = options || {};
+	    validateOptions(options, defaultProps);
+	    removeTriggersFromReference();
+	    var prevProps = instance.props;
+	    var nextProps = evaluateProps(reference, _extends$2({}, instance.props, options, {
+	      ignoreAttributes: true
+	    }));
+	    nextProps.ignoreAttributes = hasOwnProperty$1(options, 'ignoreAttributes') ? options.ignoreAttributes || false : prevProps.ignoreAttributes;
+	    instance.props = nextProps;
+	    addTriggersToReference();
+	    cleanupInteractiveMouseListeners();
+	    debouncedOnMouseMove = debounce$1(onMouseMove, nextProps.interactiveDebounce);
+	    updatePopperElement(popper, prevProps, nextProps);
+	    instance.popperChildren = getChildren(popper);
+	    if (instance.popperInstance) {
+	      if (POPPER_INSTANCE_DEPENDENCIES.some(function (prop) {
+	        return hasOwnProperty$1(options, prop) && options[prop] !== prevProps[prop];
+	      })) {
+	        instance.popperInstance.destroy();
+	        createPopperInstance();
+	        if (instance.state.isVisible) {
+	          instance.popperInstance.enableEventListeners();
+	        }
+	        if (instance.props.followCursor && lastMouseMoveEvent) {
+	          positionVirtualReferenceNearCursor(lastMouseMoveEvent);
+	        }
+	      } else {
+	        instance.popperInstance.update();
+	      }
+	    }
+	  }
+	  function setContent(content) {
+	    set({
+	      content: content
+	    });
+	  }
+	  function show() {
+	    var duration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getValue(instance.props.duration, 0, defaultProps.duration[1]);
+	    if (instance.state.isDestroyed || !instance.state.isEnabled || isUsingTouch && !instance.props.touch) {
+	      return;
+	    }
+	    if (getEventListenersTarget().hasAttribute('disabled')) {
+	      return;
+	    }
+	    if (instance.props.onShow(instance) === false) {
+	      return;
+	    }
+	    addDocumentClickListener();
+	    popper.style.visibility = 'visible';
+	    instance.state.isVisible = true;
+	    if (instance.props.interactive) {
+	      getEventListenersTarget().classList.add(ACTIVE_CLASS);
+	    }
+	    var transitionableElements = getTransitionableElements();
+	    setTransitionDuration(transitionableElements.concat(popper), 0);
+	    currentMountCallback = function currentMountCallback() {
+	      if (!instance.state.isVisible) {
+	        return;
+	      }
+	      var isInLooseFollowCursorMode = getIsInLooseFollowCursorMode();
+	      if (isInLooseFollowCursorMode && lastMouseMoveEvent) {
+	        positionVirtualReferenceNearCursor(lastMouseMoveEvent);
+	      } else if (!isInLooseFollowCursorMode) {
+	        instance.popperInstance.update();
+	      }
+	      if (instance.popperChildren.backdrop) {
+	        instance.popperChildren.content.style.transitionDelay = Math.round(duration / 12) + 'ms';
+	      }
+	      if (instance.props.sticky) {
+	        makeSticky();
+	      }
+	      setTransitionDuration([popper], instance.props.updateDuration);
+	      setTransitionDuration(transitionableElements, duration);
+	      setVisibilityState(transitionableElements, 'visible');
+	      onTransitionedIn(duration, function () {
+	        if (instance.props.aria) {
+	          getEventListenersTarget().setAttribute("aria-".concat(instance.props.aria), popper.id);
+	        }
+	        instance.props.onShown(instance);
+	        instance.state.isShown = true;
+	      });
+	    };
+	    mount();
+	  }
+	  function hide() {
+	    var duration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getValue(instance.props.duration, 1, defaultProps.duration[1]);
+	    if (instance.state.isDestroyed || !instance.state.isEnabled && !isBeingDestroyed) {
+	      return;
+	    }
+	    if (instance.props.onHide(instance) === false && !isBeingDestroyed) {
+	      return;
+	    }
+	    removeDocumentClickListener();
+	    popper.style.visibility = 'hidden';
+	    instance.state.isVisible = false;
+	    instance.state.isShown = false;
+	    wasVisibleDuringPreviousUpdate = false;
+	    if (instance.props.interactive) {
+	      getEventListenersTarget().classList.remove(ACTIVE_CLASS);
+	    }
+	    var transitionableElements = getTransitionableElements();
+	    setTransitionDuration(transitionableElements, duration);
+	    setVisibilityState(transitionableElements, 'hidden');
+	    onTransitionedOut(duration, function () {
+	      if (!isScheduledToShow) {
+	        removeFollowCursorListener();
+	      }
+	      if (instance.props.aria) {
+	        getEventListenersTarget().removeAttribute("aria-".concat(instance.props.aria));
+	      }
+	      instance.popperInstance.disableEventListeners();
+	      instance.popperInstance.options.placement = instance.props.placement;
+	      popper.parentNode.removeChild(popper);
+	      instance.props.onHidden(instance);
+	      instance.state.isMounted = false;
+	    });
+	  }
+	  function destroy(destroyTargetInstances) {
+	    if (instance.state.isDestroyed) {
+	      return;
+	    }
+	    isBeingDestroyed = true;
+	    if (instance.state.isMounted) {
+	      hide(0);
+	    }
+	    removeTriggersFromReference();
+	    delete reference._tippy;
+	    var target = instance.props.target;
+	    if (target && destroyTargetInstances && isRealElement(reference)) {
+	      arrayFrom(reference.querySelectorAll(target)).forEach(function (child) {
+	        if (child._tippy) {
+	          child._tippy.destroy();
+	        }
+	      });
+	    }
+	    if (instance.popperInstance) {
+	      instance.popperInstance.destroy();
+	    }
+	    isBeingDestroyed = false;
+	    instance.state.isDestroyed = true;
+	  }
+	}
+	function group(instances) {
+	  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+	    _ref$delay = _ref.delay,
+	    delay = _ref$delay === void 0 ? instances[0].props.delay : _ref$delay,
+	    _ref$duration = _ref.duration,
+	    duration = _ref$duration === void 0 ? 0 : _ref$duration;
+	  var isAnyTippyOpen = false;
+	  instances.forEach(function (instance) {
+	    if (instance._originalProps) {
+	      instance.set(instance._originalProps);
+	    } else {
+	      instance._originalProps = _extends$2({}, instance.props);
+	    }
+	  });
+	  function setIsAnyTippyOpen(value) {
+	    isAnyTippyOpen = value;
+	    updateInstances();
+	  }
+	  function onShow(instance) {
+	    instance._originalProps.onShow(instance);
+	    instances.forEach(function (instance) {
+	      instance.set({
+	        duration: duration
+	      });
+	      if (instance.state.isVisible) {
+	        instance.hide();
+	      }
+	    });
+	    setIsAnyTippyOpen(true);
+	  }
+	  function onHide(instance) {
+	    instance._originalProps.onHide(instance);
+	    setIsAnyTippyOpen(false);
+	  }
+	  function onShown(instance) {
+	    instance._originalProps.onShown(instance);
+	    instance.set({
+	      duration: instance._originalProps.duration
+	    });
+	  }
+	  function updateInstances() {
+	    instances.forEach(function (instance) {
+	      instance.set({
+	        onShow: onShow,
+	        onShown: onShown,
+	        onHide: onHide,
+	        delay: isAnyTippyOpen ? [0, isArray$1(delay) ? delay[1] : delay] : delay,
+	        duration: isAnyTippyOpen ? duration : instance._originalProps.duration
+	      });
+	    });
+	  }
+	  updateInstances();
+	}
+	var globalEventListenersBound = false;
+	function tippy(targets, options) {
+	  validateOptions(options || {}, defaultProps);
+	  if (!globalEventListenersBound) {
+	    bindGlobalEventListeners();
+	    globalEventListenersBound = true;
+	  }
+	  var props = _extends$2({}, defaultProps, options);
+	  if (isBareVirtualElement(targets)) {
+	    polyfillElementPrototypeProperties(targets);
+	  }
+	  var instances = getArrayOfElements(targets).reduce(function (acc, reference) {
+	    var instance = reference && createTippy(reference, props);
+	    if (instance) {
+	      acc.push(instance);
+	    }
+	    return acc;
+	  }, []);
+	  return isSingular(targets) ? instances[0] : instances;
+	}
+	tippy.version = version;
+	tippy.defaults = defaultProps;
+	tippy.setDefaults = function (partialDefaults) {
+	  keys$1(partialDefaults).forEach(function (key) {
+	    defaultProps[key] = partialDefaults[key];
+	  });
+	};
+	tippy.hideAll = hideAll;
+	tippy.group = group;
+	function autoInit() {
+	  arrayFrom(document.querySelectorAll('[data-tippy]')).forEach(function (el) {
+	    var content = el.getAttribute('data-tippy');
+	    if (content) {
+	      tippy(el, {
+	        content: content
+	      });
+	    }
+	  });
+	}
+	if (isBrowser$1) {
+	  setTimeout(autoInit);
+	}
+	var getValidTippyProps = function getValidTippyProps(props) {
+	  var validProps = {};
+	  for (var key in props) {
+	    if (defaultProps.hasOwnProperty(key)) {
+	      validProps[key] = props[key];
+	    }
+	  }
+	  return validProps;
+	};
+
+	var defaultOptions = {
+	  duration: 0,
+	  arrow: true,
+	  size: 'small',
+	  trigger: 'mouseenter focus',
+	  theme: 'dark',
+	  interactive: true,
+	  boundary: 'window',
+	  content: '',
+	  allowHTML: true,
+	  extCls: ''
 	};
-	function hasClass(el, cls) {
-	  if (!el || !cls) return false;
-	  if (cls.indexOf(' ') !== -1) throw new Error('className should not contain space.');
-	  if (el.classList) {
-	    return el.classList.contains(cls);
+	var validPlacements$1 = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start'];
+	var createTippy$1 = function createTippy(el, binding) {
+	  var value = binding.value;
+	  var options = _objectSpread({}, defaultOptions);
+	  if (_typeof(value) === 'object') {
+	    if (value.allowHtml || value.allowHTML) {
+	      value.allowHTML = true;
+	    }
+	    _extends(options, value);
 	  } else {
-	    return (' ' + el.className + ' ').indexOf(' ' + cls + ' ') > -1;
+	    options.content = value;
 	  }
-	}
-	function addClass(el, cls) {
-	  if (!el) return;
-	  var curClass = el.className;
-	  var classes = (cls || '').split(' ');
-	  for (var i = 0, j = classes.length; i < j; i++) {
-	    var clsName = classes[i];
-	    if (!clsName) continue;
-	    if (el.classList) {
-	      el.classList.add(clsName);
-	    } else if (!hasClass(el, clsName)) {
-	      curClass += ' ' + clsName;
-	    }
+	  var placement = validPlacements$1.find(function (placement) {
+	    return binding.modifiers[placement];
+	  });
+	  options.placement = options.placement || placement || (options.placements || ['top'])[0];
+	  var _binding$modifiers = binding.modifiers,
+	    click = _binding$modifiers.click,
+	    light = _binding$modifiers.light;
+	  if (click) {
+	    options.trigger = 'click';
 	  }
-	  if (!el.classList) {
-	    el.className = curClass;
+	  if (light) {
+	    options.theme = 'light';
 	  }
-	}
-	function removeClass(el, cls) {
-	  if (!el || !cls) return;
-	  var classes = cls.split(' ');
-	  var curClass = ' ' + el.className + ' ';
-	  for (var i = 0, j = classes.length; i < j; i++) {
-	    var clsName = classes[i];
-	    if (!clsName) continue;
-	    if (el.classList) {
-	      el.classList.remove(clsName);
-	    } else if (hasClass(el, clsName)) {
-	      curClass = curClass.replace(' ' + clsName + ' ', ' ');
+	  if (options.allowHTML) {
+	    var selector = options.content;
+	    if (selector instanceof Vue) {
+	      options.content = selector.$el;
+	    } else if (typeof selector === 'string') {
+	      try {
+	        var element = document.querySelector(selector);
+	        if (element) {
+	          options.content = element;
+	        }
+	      } catch (e) {
+	        var _element = document.createElement('div');
+	        _element.innerHTML = selector;
+	      }
 	    }
 	  }
-	  if (!el.classList) {
-	    el.className = trim$1(curClass);
+	  if (options.html) {
+	    options.content = options.html;
 	  }
-	}
-	var getStyle = Number(document.documentMode) < 9 ? function (element, styleName) {
-	  if (!element || !styleName) return null;
-	  styleName = camelCase(styleName);
-	  if (styleName === 'float') {
-	    styleName = 'styleFloat';
+	  if (typeof options.onClose === 'function') {
+	    options.onHide = options.onClose;
 	  }
-	  try {
-	    switch (styleName) {
-	      case 'opacity':
-	        try {
-	          return element.filters.item('alpha').opacity / 100;
-	        } catch (e) {
-	          return 1.0;
+	  var validOptions = getValidTippyProps(options);
+	  return tippy(el, validOptions);
+	};
+	var bkTooltips = {
+	  inserted: function inserted(el, binding) {
+	    var disabled = _typeof(binding.value) === 'object' ? binding.value.disabled : false;
+	    if (!disabled) {
+	      el.tippyInstance = createTippy$1(el, binding);
+	    }
+	  },
+	  unbind: function unbind(el) {
+	    el._tippy && el._tippy.destroy();
+	    el.tippyInstance = null;
+	  },
+	  update: function update(el, binding) {
+	    var value = binding.value;
+	    var isObject = _typeof(value) === 'object';
+	    var content = isObject ? value.content : value;
+	    var disabled = isObject ? value.disabled : false;
+	    if (disabled || !content) {
+	      el._tippy && el._tippy.destroy();
+	      el.tippyInstance = null;
+	    } else if (content) {
+	      if (!el._tippy) {
+	        el.tippyInstance = createTippy$1(el, binding);
+	      } else {
+	        if (_typeof(value) === 'object' && (binding.value.allowHtml || binding.value.allowHTML)) {
+	          el.tippyInstance = createTippy$1(el, binding);
+	        } else {
+	          el._tippy.setContent(content);
 	        }
-	      default:
-	        return element.style[styleName] || element.currentStyle ? element.currentStyle[styleName] : null;
+	      }
 	    }
-	  } catch (e) {
-	    return element.style[styleName];
-	  }
-	} : function (element, styleName) {
-	  if (!element || !styleName) return null;
-	  styleName = camelCase(styleName);
-	  if (styleName === 'float') {
-	    styleName = 'cssFloat';
-	  }
-	  try {
-	    var computed = document.defaultView.getComputedStyle(element, '');
-	    return element.style[styleName] || computed ? computed[styleName] : null;
-	  } catch (e) {
-	    return element.style[styleName];
 	  }
 	};
+	bkTooltips.install = function (Vue) {
+	  Vue.directive('bkTooltips', bkTooltips);
+	};
 
 	var script = {
 	  name: 'bk-input',
+	  directives: {
+	    bkTooltips: bkTooltips
+	  },
 	  mixins: [emitter, locale.mixin],
 	  props: {
 	    type: {
@@ -542,7 +3367,12 @@
 	    allowNumberPaste: {
 	      type: Boolean,
 	      default: false
-	    }
+	    },
+	    showOverflowTooltips: {
+	      type: Boolean,
+	      default: false
+	    },
+	    initialControlValue: Number
 	  },
 	  data: function data() {
 	    return {
@@ -563,6 +3393,9 @@
 	      inputPasswordIcon: this.passwordIcon,
 	      inputRightPadding: '10px',
 	      iconAreaSizeObserver: null,
+	      inputResizeObserver: null,
+	      isInputOverflow: false,
+	      inputClientWidth: null,
 	      validKeyCodeList: [48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
 	      96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
 	      8,
@@ -634,6 +3467,13 @@
 	        return "bk-input-".concat(this.inputSize);
 	      }
 	      return '';
+	    },
+	    inputTooltips: function inputTooltips() {
+	      return {
+	        content: this.curValue,
+	        disabled: !this.showOverflowTooltips || this.type === 'password' || !this.isInputOverflow,
+	        width: this.inputClientWidth && this.inputClientWidth
+	      };
 	    }
 	  },
 	  watch: {
@@ -641,6 +3481,7 @@
 	      handler: function handler(val, old) {
 	        this.setCurValue(val);
 	        old === undefined && this.updateNumberValue(val);
+	        this.setOverflow();
 	      },
 	      immediate: true
 	    },
@@ -675,10 +3516,13 @@
 	      };
 	    }
 	    this.observerIconSize();
+	    this.observerInputSize();
 	  },
 	  beforeDestroy: function beforeDestroy() {
 	    this.iconAreaSizeObserver && typeof this.iconAreaSizeObserver.disconnect === 'function' && this.iconAreaSizeObserver.disconnect();
 	    this.iconAreaSizeObserver = null;
+	    this.inputResizeObserver && this.inputResizeObserver.disconnect();
+	    this.inputResizeObserver = null;
 	  },
 	  methods: {
 	    observerIconSize: function observerIconSize() {
@@ -705,6 +3549,41 @@
 	        this.iconAreaSizeObserver.observe(element);
 	      }
 	    },
+	    observerInputSize: function observerInputSize() {
+	      var _this3 = this;
+	      var element = this.$refs.input;
+	      if (!element) return;
+	      this.inputResizeObserver = new ResizeObserver(function (entries) {
+	        var _iterator2 = _createForOfIteratorHelper(entries),
+	          _step2;
+	        try {
+	          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+	            var entry = _step2.value;
+	            if (entry.target === element) {
+	              _this3.setOverflow();
+	            }
+	          }
+	        } catch (err) {
+	          _iterator2.e(err);
+	        } finally {
+	          _iterator2.f();
+	        }
+	      });
+	      this.inputResizeObserver.observe(element);
+	    },
+	    setOverflow: function setOverflow() {
+	      var _this4 = this;
+	      setTimeout(function () {
+	        var inputEl = _this4.$refs.input;
+	        if (inputEl) {
+	          _this4.isInputOverflow = inputEl.scrollWidth > inputEl.clientWidth + 2;
+	          if (inputEl.clientWidth !== _this4.inputClientWidth) {
+	            _this4.$refs.inputWrapper._tippy && _this4.$refs.inputWrapper._tippy.destroy();
+	          }
+	          _this4.inputClientWidth = inputEl.clientWidth;
+	        }
+	      });
+	    },
 	    getAttributeByType: function getAttributeByType() {
 	      var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
 	      var defaultAttr = {
@@ -790,7 +3669,9 @@
 	      }
 	    },
 	    handleNumberDelete: function handleNumberDelete(event) {
-	      this.curValue === '' && (this.curValue = this.max);
+	      if (this.curValue === '') {
+	        this.curValue = this.initialControlValue === undefined ? this.max : Math.min(this.initialControlValue, this.max);
+	      }
 	      var curNumberValue = Number(this.curValue);
 	      if (curNumberValue - 1 >= this.min) {
 	        var curLenAfterDot = (String(curNumberValue) || '').split('.')[1] || '';
@@ -805,7 +3686,9 @@
 	      }
 	    },
 	    handleNumberAdd: function handleNumberAdd(event) {
-	      this.curValue === '' && (this.curValue = this.min);
+	      if (this.curValue === '') {
+	        this.curValue = this.initialControlValue === undefined ? this.min : Math.max(this.initialControlValue, this.min);
+	      }
 	      var curNumberValue = Number(this.curValue);
 	      if (curNumberValue <= this.max - 1) {
 	        var curLenAfterDot = (String(curNumberValue) || '').split('.')[1] || '';
@@ -959,16 +3842,16 @@
 	      }
 	    },
 	    handlerInput: function handlerInput(event) {
-	      var _this3 = this;
+	      var _this5 = this;
 	      if (this.inputType === 'number' && this.isOnComposition) {
 	        return;
 	      }
 	      this.$nextTick(function () {
 	        var value = event.target.value;
-	        _this3.setCurValue(value);
-	        _this3.$emit('input', value, event);
-	        _this3.$emit('change', value, event);
-	        _this3.dispatch('bk-form-item', 'form-change');
+	        _this5.setCurValue(value);
+	        _this5.$emit('input', value, event);
+	        _this5.$emit('change', value, event);
+	        _this5.dispatch('bk-form-item', 'form-change');
 	      });
 	    },
 	    handlerClear: function handlerClear(event) {
@@ -1132,6 +4015,13 @@
 	  }, [_c('span', {
 	    staticClass: "strong"
 	  }, [_vm._v(_vm._s(_vm.curValue && _vm.curValue.length || 0))]), _vm._v("/"), _c('span', [_vm._v(_vm._s(_vm.maxlength))])])] : _vm._e()], 2)] : [_c('div', {
+	    directives: [{
+	      name: "bk-tooltips",
+	      rawName: "v-bk-tooltips",
+	      value: _vm.inputTooltips,
+	      expression: "inputTooltips"
+	    }],
+	    ref: "inputWrapper",
 	    class: ["bk-input-" + _vm.type]
 	  }, [_c('input', _vm._b({
 	    ref: "input",
@@ -1553,118 +4443,6 @@
 	  staticRenderFns: __vue_staticRenderFns__$2
 	}, __vue_inject_styles__$2, __vue_script__$2, __vue_scope_id__$2, __vue_is_functional_template__$2, __vue_module_identifier__$2, false, undefined, undefined, undefined);
 
-	var _toObject = function (it) {
-	  return Object(_defined(it));
-	};
-
-	var toString = {}.toString;
-	var _cof = function (it) {
-	  return toString.call(it).slice(8, -1);
-	};
-
-	var _iobject = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
-	  return _cof(it) == 'String' ? it.split('') : Object(it);
-	};
-
-	var _toIobject = function (it) {
-	  return _iobject(_defined(it));
-	};
-
-	var ceil = Math.ceil;
-	var floor = Math.floor;
-	var _toInteger = function (it) {
-	  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
-	};
-
-	var min = Math.min;
-	var _toLength = function (it) {
-	  return it > 0 ? min(_toInteger(it), 0x1fffffffffffff) : 0;
-	};
-
-	var max = Math.max;
-	var min$1 = Math.min;
-	var _toAbsoluteIndex = function (index, length) {
-	  index = _toInteger(index);
-	  return index < 0 ? max(index + length, 0) : min$1(index, length);
-	};
-
-	var _arrayIncludes = function (IS_INCLUDES) {
-	  return function ($this, el, fromIndex) {
-	    var O = _toIobject($this);
-	    var length = _toLength(O.length);
-	    var index = _toAbsoluteIndex(fromIndex, length);
-	    var value;
-	    if (IS_INCLUDES && el != el) while (length > index) {
-	      value = O[index++];
-	      if (value != value) return true;
-	    } else for (;length > index; index++) if (IS_INCLUDES || index in O) {
-	      if (O[index] === el) return IS_INCLUDES || index || 0;
-	    } return !IS_INCLUDES && -1;
-	  };
-	};
-
-	var _shared = createCommonjsModule(function (module) {
-	var SHARED = '__core-js_shared__';
-	var store = _global[SHARED] || (_global[SHARED] = {});
-	(module.exports = function (key, value) {
-	  return store[key] || (store[key] = value !== undefined ? value : {});
-	})('versions', []).push({
-	  version: _core.version,
-	  mode:  'pure' ,
-	  copyright: '© 2020 Denis Pushkarev (zloirock.ru)'
-	});
-	});
-
-	var id = 0;
-	var px = Math.random();
-	var _uid = function (key) {
-	  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
-	};
-
-	var shared = _shared('keys');
-	var _sharedKey = function (key) {
-	  return shared[key] || (shared[key] = _uid(key));
-	};
-
-	var arrayIndexOf = _arrayIncludes(false);
-	var IE_PROTO = _sharedKey('IE_PROTO');
-	var _objectKeysInternal = function (object, names) {
-	  var O = _toIobject(object);
-	  var i = 0;
-	  var result = [];
-	  var key;
-	  for (key in O) if (key != IE_PROTO) _has(O, key) && result.push(key);
-	  while (names.length > i) if (_has(O, key = names[i++])) {
-	    ~arrayIndexOf(result, key) || result.push(key);
-	  }
-	  return result;
-	};
-
-	var _enumBugKeys = (
-	  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
-	).split(',');
-
-	var _objectKeys = Object.keys || function keys(O) {
-	  return _objectKeysInternal(O, _enumBugKeys);
-	};
-
-	var _objectSap = function (KEY, exec) {
-	  var fn = (_core.Object || {})[KEY] || Object[KEY];
-	  var exp = {};
-	  exp[KEY] = exec(fn);
-	  _export(_export.S + _export.F * _fails(function () { fn(1); }), 'Object', exp);
-	};
-
-	_objectSap('keys', function () {
-	  return function keys(it) {
-	    return _objectKeys(_toObject(it));
-	  };
-	});
-
-	var keys = _core.Object.keys;
-
-	var keys$1 = keys;
-
 	function setInstaller (component, afterInstall) {
 	  component.install = function (Vue) {
 	    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};