{"version":3,"sources":["webpack:///./node_modules/v-tooltip/dist/v-tooltip.esm.js"],"names":["_typeof","obj","Symbol","iterator","constructor","prototype","_classCallCheck","instance","Constructor","TypeError","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","key","_createClass","protoProps","staticProps","_defineProperty","value","_objectSpread","arguments","source","ownKeys","keys","getOwnPropertySymbols","concat","filter","sym","getOwnPropertyDescriptor","forEach","SVGAnimatedString","convertToArray","split","addClasses","el","classes","classList","newClasses","className","baseVal","newClass","indexOf","push","SVGElement","setAttribute","join","removeClasses","index","splice","window","supportsPassive","opts","get","addEventListener","e","DEFAULT_OPTIONS","container","delay","html","placement","title","template","trigger","offset","openTooltips","Tooltip","_reference","_options","_this","this","evt","reference","options","relatedreference","toElement","relatedTarget","callback","evt2","relatedreference2","_tooltipNode","removeEventListener","type","contains","_scheduleHide","jquery","show","bind","hide","_isOpen","_init","_show","_hide","_dispose","_classes","content","_setContent","classesUpdated","directive","defaultClass","setClasses","getOptions","needPopperUpdate","needRestart","isOpen","dispose","popperInstance","update","events","_isDisposed","_enableDocumentTouch","_setEventListeners","$_originalTitle","getAttribute","removeAttribute","tooltipGenerator","document","createElement","innerHTML","trim","tooltipNode","childNodes","id","Math","random","toString","substr","autoHide","_this2","asyncContent","_applyContent","then","_this3","Promise","resolve","reject","allowHtml","rootNode","titleNode","querySelector","innerSelector","nodeType","firstChild","removeChild","appendChild","result","loadingClass","loadingContent","asyncResult","catch","innerText","clearTimeout","_disposeTimer","assign","updateClasses","_ensureShown","_this4","style","display","enableEventListeners","_create","_findContainer","_append","popperOptions","modifiers","arrow","element","arrowSelector","boundariesElement","preventOverflow","requestAnimationFrame","_this5","_noLongerOpen","disableEventListeners","disposeTime","disposeTimeout","setTimeout","_removeTooltipNode","parentNode","_this6","_events","_ref","func","event","destroy","removeOnDestroy","_this7","directEvents","oppositeEvents","hideOnTargetClick","usedByTooltip","_scheduleShow","_this8","computedDelay","_scheduleTimer","_this9","body","isSet","_setTooltipNodeEvent","_onDocumentTouch","passive","capture","state","enabled","positions","defaultOptions","defaultPlacement","defaultTargetClass","defaultHtml","defaultTemplate","defaultArrowSelector","defaultInnerSelector","defaultDelay","defaultTrigger","defaultOffset","defaultContainer","defaultBoundariesElement","undefined","defaultPopperOptions","defaultLoadingClass","defaultLoadingContent","defaultHideOnTargetClick","popover","defaultBaseClass","defaultWrapperClass","defaultInnerClass","defaultArrowClass","defaultOpenClass","defaultAutoHide","defaultHandleResize","typeofOffset","getPlacement","pos","getContent","createTooltip","tooltip","_tooltip","_vueEl","targetClasses","_tooltipTargetClasses","destroyTooltip","_tooltipOldShow","oldValue","setContent","setOptions","unbind","addListeners","onClick","onTouchStart","removeListeners","onTouchEnd","onTouchCancel","currentTarget","closePopover","$_vclosepopover_touch","closeAllPopover","$_closePopoverModifiers","all","changedTouches","touch","$_vclosepopover_touchPoint","firstTouch","abs","screenY","screenX","vclosepopover","_ref2","getDefault","isIOS","navigator","test","userAgent","MSStream","openPopovers","Element","script","name","components","ResizeObserver","open","Boolean","default","disabled","String","Number","popoverClass","Array","popoverBaseClass","popoverInnerClass","popoverWrapperClass","popoverArrowClass","handleResize","openGroup","openClass","data","computed","cssClass","popoverId","watch","val","oldVal","popoverNode","$refs","$_findContainer","console","warn","scheduleUpdate","$_removeEventListeners","$_addEventListeners","$_updatePopper","handler","deep","created","$_isDisposed","$_mounted","$_events","$_preventOpen","mounted","$_init","deactivated","beforeDestroy","methods","_ref2$force","skipDelay","force","$_scheduleShow","$emit","$_beingShowed","_ref3","$_scheduleHide","$_show","$_disposeTimer","$_getOffset","hidden","$_hide","$_scheduleTimer","parseInt","$_setTooltipNodeEvent","event2","_ref4","cb","$_restartPopper","$_handleGlobalClose","$_handleResize","handleGlobalClick","handleGlobalClose","handleGlobalTouchend","_loop","normalizeComponent","scopeId","isFunctionalTemplate","moduleIdentifier","shadowMode","createInjector","createInjectorSSR","createInjectorShadow","hook","render","staticRenderFns","_compiled","functional","_scopeId","context","$vnode","ssrContext","parent","__VUE_SSR_CONTEXT__","call","_registeredComponents","add","_ssrRegister","$root","$options","shadowRoot","originalRender","h","existing","beforeCreate","normalizeComponent_1","__vue_script__","__vue_render__","_vm","_h","$createElement","_c","_self","staticClass","class","ref","staticStyle","attrs","tabindex","_t","_v","visibility","on","keyup","$event","_k","keyCode","position","notify","_e","__vue_staticRenderFns__","_withStripped","__vue_inject_styles__","__vue_scope_id__","__vue_module_identifier__","__vue_is_functional_template__","Popover","listCacheClear","__data__","size","_listCacheClear","eq","other","eq_1","assocIndexOf","array","_assocIndexOf","arrayProto","listCacheDelete","lastIndex","pop","_listCacheDelete","listCacheGet","_listCacheGet","listCacheHas","_listCacheHas","listCacheSet","_listCacheSet","ListCache","entries","clear","entry","set","has","_ListCache","stackClear","_stackClear","stackDelete","_stackDelete","stackGet","_stackGet","stackHas","_stackHas","commonjsGlobal","globalThis","global","self","createCommonjsModule","fn","module","exports","freeGlobal","_freeGlobal","freeSelf","root","Function","_root","Symbol$1","_Symbol","objectProto","hasOwnProperty","nativeObjectToString","symToStringTag","toStringTag","getRawTag","isOwn","tag","unmasked","_getRawTag","objectProto$1","nativeObjectToString$1","objectToString","_objectToString","nullTag","undefinedTag","symToStringTag$1","baseGetTag","_baseGetTag","isObject","isObject_1","asyncTag","funcTag","genTag","proxyTag","isFunction","isFunction_1","coreJsData","_coreJsData","maskSrcKey","uid","exec","IE_PROTO","isMasked","_isMasked","funcProto","funcToString","toSource","_toSource","reRegExpChar","reIsHostCtor","funcProto$1","objectProto$2","funcToString$1","hasOwnProperty$1","reIsNative","RegExp","replace","baseIsNative","pattern","_baseIsNative","getValue","object","_getValue","getNative","_getNative","Map","_Map","nativeCreate","_nativeCreate","hashClear","_hashClear","hashDelete","_hashDelete","HASH_UNDEFINED","objectProto$3","hasOwnProperty$2","hashGet","_hashGet","objectProto$4","hasOwnProperty$3","hashHas","_hashHas","HASH_UNDEFINED$1","hashSet","_hashSet","Hash","_Hash","mapCacheClear","_mapCacheClear","isKeyable","_isKeyable","getMapData","map","_getMapData","mapCacheDelete","_mapCacheDelete","mapCacheGet","_mapCacheGet","mapCacheHas","_mapCacheHas","mapCacheSet","_mapCacheSet","MapCache","_MapCache","LARGE_ARRAY_SIZE","stackSet","pairs","_stackSet","Stack","_Stack","_defineProperty$1","baseAssignValue","_baseAssignValue","assignMergeValue","_assignMergeValue","createBaseFor","fromRight","iteratee","keysFunc","iterable","_createBaseFor","baseFor","_baseFor","_cloneBuffer","freeExports","freeModule","moduleExports","Buffer","allocUnsafe","cloneBuffer","buffer","isDeep","slice","copy","Uint8Array","_Uint8Array","cloneArrayBuffer","arrayBuffer","byteLength","_cloneArrayBuffer","cloneTypedArray","typedArray","byteOffset","_cloneTypedArray","copyArray","_copyArray","objectCreate","create","baseCreate","proto","_baseCreate","overArg","transform","arg","_overArg","getPrototype","getPrototypeOf","_getPrototype","objectProto$5","isPrototype","Ctor","_isPrototype","initCloneObject","_initCloneObject","isObjectLike","isObjectLike_1","argsTag","baseIsArguments","_baseIsArguments","objectProto$6","hasOwnProperty$4","propertyIsEnumerable","isArguments","isArguments_1","isArray","isArray_1","MAX_SAFE_INTEGER","isLength","isLength_1","isArrayLike","isArrayLike_1","isArrayLikeObject","isArrayLikeObject_1","stubFalse","stubFalse_1","isBuffer_1","nativeIsBuffer","isBuffer","objectTag","funcProto$2","objectProto$7","funcToString$2","hasOwnProperty$5","objectCtorString","isPlainObject","isPlainObject_1","argsTag$1","arrayTag","boolTag","dateTag","errorTag","funcTag$1","mapTag","numberTag","objectTag$1","regexpTag","setTag","stringTag","weakMapTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","typedArrayTags","baseIsTypedArray","_baseIsTypedArray","baseUnary","_baseUnary","_nodeUtil","freeProcess","process","nodeUtil","types","require","binding","nodeIsTypedArray","isTypedArray","isTypedArray_1","safeGet","_safeGet","objectProto$8","hasOwnProperty$6","assignValue","objValue","_assignValue","copyObject","customizer","isNew","newValue","_copyObject","baseTimes","n","_baseTimes","MAX_SAFE_INTEGER$1","reIsUint","isIndex","_isIndex","objectProto$9","hasOwnProperty$7","arrayLikeKeys","inherited","isArr","isArg","isBuff","isType","skipIndexes","_arrayLikeKeys","nativeKeysIn","_nativeKeysIn","objectProto$a","hasOwnProperty$8","baseKeysIn","isProto","_baseKeysIn","keysIn","keysIn_1","toPlainObject","toPlainObject_1","baseMergeDeep","srcIndex","mergeFunc","stack","srcValue","stacked","isCommon","isTyped","_baseMergeDeep","baseMerge","_baseMerge","identity","identity_1","apply","thisArg","args","_apply","nativeMax","max","overRest","start","otherArgs","_overRest","constant","constant_1","baseSetToString","string","_baseSetToString","HOT_COUNT","HOT_SPAN","nativeNow","Date","now","shortOut","count","lastCalled","stamp","remaining","_shortOut","setToString","_setToString","baseRest","_baseRest","isIterateeCall","_isIterateeCall","createAssigner","assigner","sources","guard","_createAssigner","merge","merge_1","styleInject","css","insertAt","head","getElementsByTagName","insertBefore","styleSheet","cssText","createTextNode","install","Vue","installed","finalOptions","plugin","component","GlobalVue","use"],"mappings":"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","file":"js/chunk-vendors~8d0797fd-legacy.9ea6212c.js","sourcesContent":["import Popper from 'popper.js';\nimport { ResizeObserver } from 'vue-resize';\n\nfunction _typeof(obj) {\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function (obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function (obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n    var ownKeys = Object.keys(source);\n\n    if (typeof Object.getOwnPropertySymbols === 'function') {\n      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {\n        return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n      }));\n    }\n\n    ownKeys.forEach(function (key) {\n      _defineProperty(target, key, source[key]);\n    });\n  }\n\n  return target;\n}\n\nvar SVGAnimatedString = function SVGAnimatedString() {};\n\nif (typeof window !== 'undefined') {\n  SVGAnimatedString = window.SVGAnimatedString;\n}\n\nfunction convertToArray(value) {\n  if (typeof value === 'string') {\n    value = value.split(' ');\n  }\n\n  return value;\n}\n/**\n * Add classes to an element.\n * This method checks to ensure that the classes don't already exist before adding them.\n * It uses el.className rather than classList in order to be IE friendly.\n * @param {object} el - The element to add the classes to.\n * @param {classes} string - List of space separated classes to be added to the element.\n */\n\nfunction addClasses(el, classes) {\n  var newClasses = convertToArray(classes);\n  var classList;\n\n  if (el.className instanceof SVGAnimatedString) {\n    classList = convertToArray(el.className.baseVal);\n  } else {\n    classList = convertToArray(el.className);\n  }\n\n  newClasses.forEach(function (newClass) {\n    if (classList.indexOf(newClass) === -1) {\n      classList.push(newClass);\n    }\n  });\n\n  if (el instanceof SVGElement) {\n    el.setAttribute('class', classList.join(' '));\n  } else {\n    el.className = classList.join(' ');\n  }\n}\n/**\n * Remove classes from an element.\n * It uses el.className rather than classList in order to be IE friendly.\n * @export\n * @param {any} el The element to remove the classes from.\n * @param {any} classes List of space separated classes to be removed from the element.\n */\n\nfunction removeClasses(el, classes) {\n  var newClasses = convertToArray(classes);\n  var classList;\n\n  if (el.className instanceof SVGAnimatedString) {\n    classList = convertToArray(el.className.baseVal);\n  } else {\n    classList = convertToArray(el.className);\n  }\n\n  newClasses.forEach(function (newClass) {\n    var index = classList.indexOf(newClass);\n\n    if (index !== -1) {\n      classList.splice(index, 1);\n    }\n  });\n\n  if (el instanceof SVGElement) {\n    el.setAttribute('class', classList.join(' '));\n  } else {\n    el.className = classList.join(' ');\n  }\n}\nvar supportsPassive = false;\n\nif (typeof window !== 'undefined') {\n  supportsPassive = false;\n\n  try {\n    var opts = Object.defineProperty({}, 'passive', {\n      get: function get() {\n        supportsPassive = true;\n      }\n    });\n    window.addEventListener('test', null, opts);\n  } catch (e) {}\n}\n\nvar DEFAULT_OPTIONS = {\n  container: false,\n  delay: 0,\n  html: false,\n  placement: 'top',\n  title: '',\n  template: '<div class=\"tooltip\" role=\"tooltip\"><div class=\"tooltip-arrow\"></div><div class=\"tooltip-inner\"></div></div>',\n  trigger: 'hover focus',\n  offset: 0\n};\nvar openTooltips = [];\n\nvar Tooltip =\n/*#__PURE__*/\nfunction () {\n  /**\n   * Create a new Tooltip.js instance\n   * @class Tooltip\n   * @param {HTMLElement} reference - The DOM node used as reference of the tooltip (it can be a jQuery element).\n   * @param {Object} options\n   * @param {String} options.placement=bottom\n   *      Placement of the popper accepted values: `top(-start, -end), right(-start, -end), bottom(-start, -end),\n   *      left(-start, -end)`\n   * @param {HTMLElement|String|false} options.container=false - Append the tooltip to a specific element.\n   * @param {Number|Object} options.delay=0\n   *      Delay showing and hiding the tooltip (ms) - does not apply to manual trigger type.\n   *      If a number is supplied, delay is applied to both hide/show.\n   *      Object structure is: `{ show: 500, hide: 100 }`\n   * @param {Boolean} options.html=false - Insert HTML into the tooltip. If false, the content will inserted with `innerText`.\n   * @param {String|PlacementFunction} options.placement='top' - One of the allowed placements, or a function returning one of them.\n   * @param {String} [options.template='<div class=\"tooltip\" role=\"tooltip\"><div class=\"tooltip-arrow\"></div><div class=\"tooltip-inner\"></div></div>']\n   *      Base HTML to used when creating the tooltip.\n   *      The tooltip's `title` will be injected into the `.tooltip-inner` or `.tooltip__inner`.\n   *      `.tooltip-arrow` or `.tooltip__arrow` will become the tooltip's arrow.\n   *      The outermost wrapper element should have the `.tooltip` class.\n   * @param {String|HTMLElement|TitleFunction} options.title='' - Default title value if `title` attribute isn't present.\n   * @param {String} [options.trigger='hover focus']\n   *      How tooltip is triggered - click, hover, focus, manual.\n   *      You may pass multiple triggers; separate them with a space. `manual` cannot be combined with any other trigger.\n   * @param {HTMLElement} options.boundariesElement\n   *      The element used as boundaries for the tooltip. For more information refer to Popper.js'\n   *      [boundariesElement docs](https://popper.js.org/popper-documentation.html)\n   * @param {Number|String} options.offset=0 - Offset of the tooltip relative to its reference. For more information refer to Popper.js'\n   *      [offset docs](https://popper.js.org/popper-documentation.html)\n   * @param {Object} options.popperOptions={} - Popper options, will be passed directly to popper instance. For more information refer to Popper.js'\n   *      [options docs](https://popper.js.org/popper-documentation.html)\n   * @return {Object} instance - The generated tooltip instance\n   */\n  function Tooltip(_reference, _options) {\n    var _this = this;\n\n    _classCallCheck(this, Tooltip);\n\n    _defineProperty(this, \"_events\", []);\n\n    _defineProperty(this, \"_setTooltipNodeEvent\", function (evt, reference, delay, options) {\n      var relatedreference = evt.relatedreference || evt.toElement || evt.relatedTarget;\n\n      var callback = function callback(evt2) {\n        var relatedreference2 = evt2.relatedreference || evt2.toElement || evt2.relatedTarget; // Remove event listener after call\n\n        _this._tooltipNode.removeEventListener(evt.type, callback); // If the new reference is not the reference element\n\n\n        if (!reference.contains(relatedreference2)) {\n          // Schedule to hide tooltip\n          _this._scheduleHide(reference, options.delay, options, evt2);\n        }\n      };\n\n      if (_this._tooltipNode.contains(relatedreference)) {\n        // listen to mouseleave on the tooltip element to be able to hide the tooltip\n        _this._tooltipNode.addEventListener(evt.type, callback);\n\n        return true;\n      }\n\n      return false;\n    });\n\n    // apply user options over default ones\n    _options = _objectSpread({}, DEFAULT_OPTIONS, _options);\n    _reference.jquery && (_reference = _reference[0]);\n    this.show = this.show.bind(this);\n    this.hide = this.hide.bind(this); // cache reference and options\n\n    this.reference = _reference;\n    this.options = _options; // set initial state\n\n    this._isOpen = false;\n\n    this._init();\n  } //\n  // Public methods\n  //\n\n  /**\n   * Reveals an element's tooltip. This is considered a \"manual\" triggering of the tooltip.\n   * Tooltips with zero-length titles are never displayed.\n   * @method Tooltip#show\n   * @memberof Tooltip\n   */\n\n\n  _createClass(Tooltip, [{\n    key: \"show\",\n    value: function show() {\n      this._show(this.reference, this.options);\n    }\n    /**\n     * Hides an element’s tooltip. This is considered a “manual” triggering of the tooltip.\n     * @method Tooltip#hide\n     * @memberof Tooltip\n     */\n\n  }, {\n    key: \"hide\",\n    value: function hide() {\n      this._hide();\n    }\n    /**\n     * Hides and destroys an element’s tooltip.\n     * @method Tooltip#dispose\n     * @memberof Tooltip\n     */\n\n  }, {\n    key: \"dispose\",\n    value: function dispose() {\n      this._dispose();\n    }\n    /**\n     * Toggles an element’s tooltip. This is considered a “manual” triggering of the tooltip.\n     * @method Tooltip#toggle\n     * @memberof Tooltip\n     */\n\n  }, {\n    key: \"toggle\",\n    value: function toggle() {\n      if (this._isOpen) {\n        return this.hide();\n      } else {\n        return this.show();\n      }\n    }\n  }, {\n    key: \"setClasses\",\n    value: function setClasses(classes) {\n      this._classes = classes;\n    }\n  }, {\n    key: \"setContent\",\n    value: function setContent(content) {\n      this.options.title = content;\n\n      if (this._tooltipNode) {\n        this._setContent(content, this.options);\n      }\n    }\n  }, {\n    key: \"setOptions\",\n    value: function setOptions(options) {\n      var classesUpdated = false;\n      var classes = options && options.classes || directive.options.defaultClass;\n\n      if (this._classes !== classes) {\n        this.setClasses(classes);\n        classesUpdated = true;\n      }\n\n      options = getOptions(options);\n      var needPopperUpdate = false;\n      var needRestart = false;\n\n      if (this.options.offset !== options.offset || this.options.placement !== options.placement) {\n        needPopperUpdate = true;\n      }\n\n      if (this.options.template !== options.template || this.options.trigger !== options.trigger || this.options.container !== options.container || classesUpdated) {\n        needRestart = true;\n      }\n\n      for (var key in options) {\n        this.options[key] = options[key];\n      }\n\n      if (this._tooltipNode) {\n        if (needRestart) {\n          var isOpen = this._isOpen;\n          this.dispose();\n\n          this._init();\n\n          if (isOpen) {\n            this.show();\n          }\n        } else if (needPopperUpdate) {\n          this.popperInstance.update();\n        }\n      }\n    } //\n    // Private methods\n    //\n\n  }, {\n    key: \"_init\",\n    value: function _init() {\n      // get events list\n      var events = typeof this.options.trigger === 'string' ? this.options.trigger.split(' ') : [];\n      this._isDisposed = false;\n      this._enableDocumentTouch = events.indexOf('manual') === -1;\n      events = events.filter(function (trigger) {\n        return ['click', 'hover', 'focus'].indexOf(trigger) !== -1;\n      }); // set event listeners\n\n      this._setEventListeners(this.reference, events, this.options); // title attribute\n\n\n      this.$_originalTitle = this.reference.getAttribute('title');\n      this.reference.removeAttribute('title');\n      this.reference.setAttribute('data-original-title', this.$_originalTitle);\n    }\n    /**\n     * Creates a new tooltip node\n     * @memberof Tooltip\n     * @private\n     * @param {HTMLElement} reference\n     * @param {String} template\n     * @param {String|HTMLElement|TitleFunction} title\n     * @param {Boolean} allowHtml\n     * @return {HTMLelement} tooltipNode\n     */\n\n  }, {\n    key: \"_create\",\n    value: function _create(reference, template) {\n      // create tooltip element\n      var tooltipGenerator = window.document.createElement('div');\n      tooltipGenerator.innerHTML = template.trim();\n      var tooltipNode = tooltipGenerator.childNodes[0]; // add unique ID to our tooltip (needed for accessibility reasons)\n\n      tooltipNode.id = \"tooltip_\".concat(Math.random().toString(36).substr(2, 10)); // Initially hide the tooltip\n      // The attribute will be switched in a next frame so\n      // CSS transitions can play\n\n      tooltipNode.setAttribute('aria-hidden', 'true');\n\n      if (this.options.autoHide && this.options.trigger.indexOf('hover') !== -1) {\n        tooltipNode.addEventListener('mouseenter', this.hide);\n        tooltipNode.addEventListener('click', this.hide);\n      } // return the generated tooltip node\n\n\n      return tooltipNode;\n    }\n  }, {\n    key: \"_setContent\",\n    value: function _setContent(content, options) {\n      var _this2 = this;\n\n      this.asyncContent = false;\n\n      this._applyContent(content, options).then(function () {\n        _this2.popperInstance.update();\n      });\n    }\n  }, {\n    key: \"_applyContent\",\n    value: function _applyContent(title, options) {\n      var _this3 = this;\n\n      return new Promise(function (resolve, reject) {\n        var allowHtml = options.html;\n        var rootNode = _this3._tooltipNode;\n        if (!rootNode) return;\n        var titleNode = rootNode.querySelector(_this3.options.innerSelector);\n\n        if (title.nodeType === 1) {\n          // if title is a node, append it only if allowHtml is true\n          if (allowHtml) {\n            while (titleNode.firstChild) {\n              titleNode.removeChild(titleNode.firstChild);\n            }\n\n            titleNode.appendChild(title);\n          }\n        } else if (typeof title === 'function') {\n          // if title is a function, call it and set innerText or innerHtml depending by `allowHtml` value\n          var result = title();\n\n          if (result && typeof result.then === 'function') {\n            _this3.asyncContent = true;\n            options.loadingClass && addClasses(rootNode, options.loadingClass);\n\n            if (options.loadingContent) {\n              _this3._applyContent(options.loadingContent, options);\n            }\n\n            result.then(function (asyncResult) {\n              options.loadingClass && removeClasses(rootNode, options.loadingClass);\n              return _this3._applyContent(asyncResult, options);\n            }).then(resolve).catch(reject);\n          } else {\n            _this3._applyContent(result, options).then(resolve).catch(reject);\n          }\n\n          return;\n        } else {\n          // if it's just a simple text, set innerText or innerHtml depending by `allowHtml` value\n          allowHtml ? titleNode.innerHTML = title : titleNode.innerText = title;\n        }\n\n        resolve();\n      });\n    }\n  }, {\n    key: \"_show\",\n    value: function _show(reference, options) {\n      if (options && typeof options.container === 'string') {\n        var container = document.querySelector(options.container);\n        if (!container) return;\n      }\n\n      clearTimeout(this._disposeTimer);\n      options = Object.assign({}, options);\n      delete options.offset;\n      var updateClasses = true;\n\n      if (this._tooltipNode) {\n        addClasses(this._tooltipNode, this._classes);\n        updateClasses = false;\n      }\n\n      var result = this._ensureShown(reference, options);\n\n      if (updateClasses && this._tooltipNode) {\n        addClasses(this._tooltipNode, this._classes);\n      }\n\n      addClasses(reference, ['v-tooltip-open']);\n      return result;\n    }\n  }, {\n    key: \"_ensureShown\",\n    value: function _ensureShown(reference, options) {\n      var _this4 = this;\n\n      // don't show if it's already visible\n      if (this._isOpen) {\n        return this;\n      }\n\n      this._isOpen = true;\n      openTooltips.push(this); // if the tooltipNode already exists, just show it\n\n      if (this._tooltipNode) {\n        this._tooltipNode.style.display = '';\n\n        this._tooltipNode.setAttribute('aria-hidden', 'false');\n\n        this.popperInstance.enableEventListeners();\n        this.popperInstance.update();\n\n        if (this.asyncContent) {\n          this._setContent(options.title, options);\n        }\n\n        return this;\n      } // get title\n\n\n      var title = reference.getAttribute('title') || options.title; // don't show tooltip if no title is defined\n\n      if (!title) {\n        return this;\n      } // create tooltip node\n\n\n      var tooltipNode = this._create(reference, options.template);\n\n      this._tooltipNode = tooltipNode; // Add `aria-describedby` to our reference element for accessibility reasons\n\n      reference.setAttribute('aria-describedby', tooltipNode.id); // append tooltip to container\n\n      var container = this._findContainer(options.container, reference);\n\n      this._append(tooltipNode, container);\n\n      var popperOptions = _objectSpread({}, options.popperOptions, {\n        placement: options.placement\n      });\n\n      popperOptions.modifiers = _objectSpread({}, popperOptions.modifiers, {\n        arrow: {\n          element: this.options.arrowSelector\n        }\n      });\n\n      if (options.boundariesElement) {\n        popperOptions.modifiers.preventOverflow = {\n          boundariesElement: options.boundariesElement\n        };\n      }\n\n      this.popperInstance = new Popper(reference, tooltipNode, popperOptions);\n\n      this._setContent(title, options); // Fix position\n\n\n      requestAnimationFrame(function () {\n        if (!_this4._isDisposed && _this4.popperInstance) {\n          _this4.popperInstance.update(); // Show the tooltip\n\n\n          requestAnimationFrame(function () {\n            if (!_this4._isDisposed) {\n              _this4._isOpen && tooltipNode.setAttribute('aria-hidden', 'false');\n            } else {\n              _this4.dispose();\n            }\n          });\n        } else {\n          _this4.dispose();\n        }\n      });\n      return this;\n    }\n  }, {\n    key: \"_noLongerOpen\",\n    value: function _noLongerOpen() {\n      var index = openTooltips.indexOf(this);\n\n      if (index !== -1) {\n        openTooltips.splice(index, 1);\n      }\n    }\n  }, {\n    key: \"_hide\",\n    value: function _hide()\n    /* reference, options */\n    {\n      var _this5 = this;\n\n      // don't hide if it's already hidden\n      if (!this._isOpen) {\n        return this;\n      }\n\n      this._isOpen = false;\n\n      this._noLongerOpen(); // hide tooltipNode\n\n\n      this._tooltipNode.style.display = 'none';\n\n      this._tooltipNode.setAttribute('aria-hidden', 'true');\n\n      this.popperInstance.disableEventListeners();\n      clearTimeout(this._disposeTimer);\n      var disposeTime = directive.options.disposeTimeout;\n\n      if (disposeTime !== null) {\n        this._disposeTimer = setTimeout(function () {\n          if (_this5._tooltipNode) {\n            _this5._tooltipNode.removeEventListener('mouseenter', _this5.hide);\n\n            _this5._tooltipNode.removeEventListener('click', _this5.hide); // Don't remove popper instance, just the HTML element\n\n\n            _this5._removeTooltipNode();\n          }\n        }, disposeTime);\n      }\n\n      removeClasses(this.reference, ['v-tooltip-open']);\n      return this;\n    }\n  }, {\n    key: \"_removeTooltipNode\",\n    value: function _removeTooltipNode() {\n      if (!this._tooltipNode) return;\n      var parentNode = this._tooltipNode.parentNode;\n\n      if (parentNode) {\n        parentNode.removeChild(this._tooltipNode);\n        this.reference.removeAttribute('aria-describedby');\n      }\n\n      this._tooltipNode = null;\n    }\n  }, {\n    key: \"_dispose\",\n    value: function _dispose() {\n      var _this6 = this;\n\n      this._isDisposed = true;\n      this.reference.removeAttribute('data-original-title');\n\n      if (this.$_originalTitle) {\n        this.reference.setAttribute('title', this.$_originalTitle);\n      } // remove event listeners first to prevent any unexpected behaviour\n\n\n      this._events.forEach(function (_ref) {\n        var func = _ref.func,\n            event = _ref.event;\n\n        _this6.reference.removeEventListener(event, func);\n      });\n\n      this._events = [];\n\n      if (this._tooltipNode) {\n        this._hide();\n\n        this._tooltipNode.removeEventListener('mouseenter', this.hide);\n\n        this._tooltipNode.removeEventListener('click', this.hide); // destroy instance\n\n\n        this.popperInstance.destroy(); // destroy tooltipNode if removeOnDestroy is not set, as popperInstance.destroy() already removes the element\n\n        if (!this.popperInstance.options.removeOnDestroy) {\n          this._removeTooltipNode();\n        }\n      } else {\n        this._noLongerOpen();\n      }\n\n      return this;\n    }\n  }, {\n    key: \"_findContainer\",\n    value: function _findContainer(container, reference) {\n      // if container is a query, get the relative element\n      if (typeof container === 'string') {\n        container = window.document.querySelector(container);\n      } else if (container === false) {\n        // if container is `false`, set it to reference parent\n        container = reference.parentNode;\n      }\n\n      return container;\n    }\n    /**\n     * Append tooltip to container\n     * @memberof Tooltip\n     * @private\n     * @param {HTMLElement} tooltip\n     * @param {HTMLElement|String|false} container\n     */\n\n  }, {\n    key: \"_append\",\n    value: function _append(tooltipNode, container) {\n      container.appendChild(tooltipNode);\n    }\n  }, {\n    key: \"_setEventListeners\",\n    value: function _setEventListeners(reference, events, options) {\n      var _this7 = this;\n\n      var directEvents = [];\n      var oppositeEvents = [];\n      events.forEach(function (event) {\n        switch (event) {\n          case 'hover':\n            directEvents.push('mouseenter');\n            oppositeEvents.push('mouseleave');\n            if (_this7.options.hideOnTargetClick) oppositeEvents.push('click');\n            break;\n\n          case 'focus':\n            directEvents.push('focus');\n            oppositeEvents.push('blur');\n            if (_this7.options.hideOnTargetClick) oppositeEvents.push('click');\n            break;\n\n          case 'click':\n            directEvents.push('click');\n            oppositeEvents.push('click');\n            break;\n        }\n      }); // schedule show tooltip\n\n      directEvents.forEach(function (event) {\n        var func = function func(evt) {\n          if (_this7._isOpen === true) {\n            return;\n          }\n\n          evt.usedByTooltip = true;\n\n          _this7._scheduleShow(reference, options.delay, options, evt);\n        };\n\n        _this7._events.push({\n          event: event,\n          func: func\n        });\n\n        reference.addEventListener(event, func);\n      }); // schedule hide tooltip\n\n      oppositeEvents.forEach(function (event) {\n        var func = function func(evt) {\n          if (evt.usedByTooltip === true) {\n            return;\n          }\n\n          _this7._scheduleHide(reference, options.delay, options, evt);\n        };\n\n        _this7._events.push({\n          event: event,\n          func: func\n        });\n\n        reference.addEventListener(event, func);\n      });\n    }\n  }, {\n    key: \"_onDocumentTouch\",\n    value: function _onDocumentTouch(event) {\n      if (this._enableDocumentTouch) {\n        this._scheduleHide(this.reference, this.options.delay, this.options, event);\n      }\n    }\n  }, {\n    key: \"_scheduleShow\",\n    value: function _scheduleShow(reference, delay, options\n    /*, evt */\n    ) {\n      var _this8 = this;\n\n      // defaults to 0\n      var computedDelay = delay && delay.show || delay || 0;\n      clearTimeout(this._scheduleTimer);\n      this._scheduleTimer = window.setTimeout(function () {\n        return _this8._show(reference, options);\n      }, computedDelay);\n    }\n  }, {\n    key: \"_scheduleHide\",\n    value: function _scheduleHide(reference, delay, options, evt) {\n      var _this9 = this;\n\n      // defaults to 0\n      var computedDelay = delay && delay.hide || delay || 0;\n      clearTimeout(this._scheduleTimer);\n      this._scheduleTimer = window.setTimeout(function () {\n        if (_this9._isOpen === false) {\n          return;\n        }\n\n        if (!document.body.contains(_this9._tooltipNode)) {\n          return;\n        } // if we are hiding because of a mouseleave, we must check that the new\n        // reference isn't the tooltip, because in this case we don't want to hide it\n\n\n        if (evt.type === 'mouseleave') {\n          var isSet = _this9._setTooltipNodeEvent(evt, reference, delay, options); // if we set the new event, don't hide the tooltip yet\n          // the new event will take care to hide it if necessary\n\n\n          if (isSet) {\n            return;\n          }\n        }\n\n        _this9._hide(reference, options);\n      }, computedDelay);\n    }\n  }]);\n\n  return Tooltip;\n}(); // Hide tooltips on touch devices\n\nif (typeof document !== 'undefined') {\n  document.addEventListener('touchstart', function (event) {\n    for (var i = 0; i < openTooltips.length; i++) {\n      openTooltips[i]._onDocumentTouch(event);\n    }\n  }, supportsPassive ? {\n    passive: true,\n    capture: true\n  } : true);\n}\n/**\n * Placement function, its context is the Tooltip instance.\n * @memberof Tooltip\n * @callback PlacementFunction\n * @param {HTMLElement} tooltip - tooltip DOM node.\n * @param {HTMLElement} reference - reference DOM node.\n * @return {String} placement - One of the allowed placement options.\n */\n\n/**\n * Title function, its context is the Tooltip instance.\n * @memberof Tooltip\n * @callback TitleFunction\n * @return {String} placement - The desired title.\n */\n\nvar state = {\n  enabled: true\n};\nvar positions = ['top', 'top-start', 'top-end', 'right', 'right-start', 'right-end', 'bottom', 'bottom-start', 'bottom-end', 'left', 'left-start', 'left-end'];\nvar defaultOptions = {\n  // Default tooltip placement relative to target element\n  defaultPlacement: 'top',\n  // Default CSS classes applied to the tooltip element\n  defaultClass: 'vue-tooltip-theme',\n  // Default CSS classes applied to the target element of the tooltip\n  defaultTargetClass: 'has-tooltip',\n  // Is the content HTML by default?\n  defaultHtml: true,\n  // Default HTML template of the tooltip element\n  // It must include `tooltip-arrow` & `tooltip-inner` CSS classes (can be configured, see below)\n  // Change if the classes conflict with other libraries (for example bootstrap)\n  defaultTemplate: '<div class=\"tooltip\" role=\"tooltip\"><div class=\"tooltip-arrow\"></div><div class=\"tooltip-inner\"></div></div>',\n  // Selector used to get the arrow element in the tooltip template\n  defaultArrowSelector: '.tooltip-arrow, .tooltip__arrow',\n  // Selector used to get the inner content element in the tooltip template\n  defaultInnerSelector: '.tooltip-inner, .tooltip__inner',\n  // Delay (ms)\n  defaultDelay: 0,\n  // Default events that trigger the tooltip\n  defaultTrigger: 'hover focus',\n  // Default position offset (px)\n  defaultOffset: 0,\n  // Default container where the tooltip will be appended\n  defaultContainer: 'body',\n  defaultBoundariesElement: undefined,\n  defaultPopperOptions: {},\n  // Class added when content is loading\n  defaultLoadingClass: 'tooltip-loading',\n  // Displayed when tooltip content is loading\n  defaultLoadingContent: '...',\n  // Hide on mouseover tooltip\n  autoHide: true,\n  // Close tooltip on click on tooltip target?\n  defaultHideOnTargetClick: true,\n  // Auto destroy tooltip DOM nodes (ms)\n  disposeTimeout: 5000,\n  // Options for popover\n  popover: {\n    defaultPlacement: 'bottom',\n    // Use the `popoverClass` prop for theming\n    defaultClass: 'vue-popover-theme',\n    // Base class (change if conflicts with other libraries)\n    defaultBaseClass: 'tooltip popover',\n    // Wrapper class (contains arrow and inner)\n    defaultWrapperClass: 'wrapper',\n    // Inner content class\n    defaultInnerClass: 'tooltip-inner popover-inner',\n    // Arrow class\n    defaultArrowClass: 'tooltip-arrow popover-arrow',\n    // Class added when popover is open\n    defaultOpenClass: 'open',\n    defaultDelay: 0,\n    defaultTrigger: 'click',\n    defaultOffset: 0,\n    defaultContainer: 'body',\n    defaultBoundariesElement: undefined,\n    defaultPopperOptions: {},\n    // Hides if clicked outside of popover\n    defaultAutoHide: true,\n    // Update popper on content resize\n    defaultHandleResize: true\n  }\n};\nfunction getOptions(options) {\n  var result = {\n    placement: typeof options.placement !== 'undefined' ? options.placement : directive.options.defaultPlacement,\n    delay: typeof options.delay !== 'undefined' ? options.delay : directive.options.defaultDelay,\n    html: typeof options.html !== 'undefined' ? options.html : directive.options.defaultHtml,\n    template: typeof options.template !== 'undefined' ? options.template : directive.options.defaultTemplate,\n    arrowSelector: typeof options.arrowSelector !== 'undefined' ? options.arrowSelector : directive.options.defaultArrowSelector,\n    innerSelector: typeof options.innerSelector !== 'undefined' ? options.innerSelector : directive.options.defaultInnerSelector,\n    trigger: typeof options.trigger !== 'undefined' ? options.trigger : directive.options.defaultTrigger,\n    offset: typeof options.offset !== 'undefined' ? options.offset : directive.options.defaultOffset,\n    container: typeof options.container !== 'undefined' ? options.container : directive.options.defaultContainer,\n    boundariesElement: typeof options.boundariesElement !== 'undefined' ? options.boundariesElement : directive.options.defaultBoundariesElement,\n    autoHide: typeof options.autoHide !== 'undefined' ? options.autoHide : directive.options.autoHide,\n    hideOnTargetClick: typeof options.hideOnTargetClick !== 'undefined' ? options.hideOnTargetClick : directive.options.defaultHideOnTargetClick,\n    loadingClass: typeof options.loadingClass !== 'undefined' ? options.loadingClass : directive.options.defaultLoadingClass,\n    loadingContent: typeof options.loadingContent !== 'undefined' ? options.loadingContent : directive.options.defaultLoadingContent,\n    popperOptions: _objectSpread({}, typeof options.popperOptions !== 'undefined' ? options.popperOptions : directive.options.defaultPopperOptions)\n  };\n\n  if (result.offset) {\n    var typeofOffset = _typeof(result.offset);\n\n    var offset = result.offset; // One value -> switch\n\n    if (typeofOffset === 'number' || typeofOffset === 'string' && offset.indexOf(',') === -1) {\n      offset = \"0, \".concat(offset);\n    }\n\n    if (!result.popperOptions.modifiers) {\n      result.popperOptions.modifiers = {};\n    }\n\n    result.popperOptions.modifiers.offset = {\n      offset: offset\n    };\n  }\n\n  if (result.trigger && result.trigger.indexOf('click') !== -1) {\n    result.hideOnTargetClick = false;\n  }\n\n  return result;\n}\nfunction getPlacement(value, modifiers) {\n  var placement = value.placement;\n\n  for (var i = 0; i < positions.length; i++) {\n    var pos = positions[i];\n\n    if (modifiers[pos]) {\n      placement = pos;\n    }\n  }\n\n  return placement;\n}\nfunction getContent(value) {\n  var type = _typeof(value);\n\n  if (type === 'string') {\n    return value;\n  } else if (value && type === 'object') {\n    return value.content;\n  } else {\n    return false;\n  }\n}\nfunction createTooltip(el, value) {\n  var modifiers = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var content = getContent(value);\n  var classes = typeof value.classes !== 'undefined' ? value.classes : directive.options.defaultClass;\n\n  var opts = _objectSpread({\n    title: content\n  }, getOptions(_objectSpread({}, value, {\n    placement: getPlacement(value, modifiers)\n  })));\n\n  var tooltip = el._tooltip = new Tooltip(el, opts);\n  tooltip.setClasses(classes);\n  tooltip._vueEl = el; // Class on target\n\n  var targetClasses = typeof value.targetClasses !== 'undefined' ? value.targetClasses : directive.options.defaultTargetClass;\n  el._tooltipTargetClasses = targetClasses;\n  addClasses(el, targetClasses);\n  return tooltip;\n}\nfunction destroyTooltip(el) {\n  if (el._tooltip) {\n    el._tooltip.dispose();\n\n    delete el._tooltip;\n    delete el._tooltipOldShow;\n  }\n\n  if (el._tooltipTargetClasses) {\n    removeClasses(el, el._tooltipTargetClasses);\n    delete el._tooltipTargetClasses;\n  }\n}\nfunction bind(el, _ref) {\n  var value = _ref.value,\n      oldValue = _ref.oldValue,\n      modifiers = _ref.modifiers;\n  var content = getContent(value);\n\n  if (!content || !state.enabled) {\n    destroyTooltip(el);\n  } else {\n    var tooltip;\n\n    if (el._tooltip) {\n      tooltip = el._tooltip; // Content\n\n      tooltip.setContent(content); // Options\n\n      tooltip.setOptions(_objectSpread({}, value, {\n        placement: getPlacement(value, modifiers)\n      }));\n    } else {\n      tooltip = createTooltip(el, value, modifiers);\n    } // Manual show\n\n\n    if (typeof value.show !== 'undefined' && value.show !== el._tooltipOldShow) {\n      el._tooltipOldShow = value.show;\n      value.show ? tooltip.show() : tooltip.hide();\n    }\n  }\n}\nvar directive = {\n  options: defaultOptions,\n  bind: bind,\n  update: bind,\n  unbind: function unbind(el) {\n    destroyTooltip(el);\n  }\n};\n\nfunction addListeners(el) {\n  el.addEventListener('click', onClick);\n  el.addEventListener('touchstart', onTouchStart, supportsPassive ? {\n    passive: true\n  } : false);\n}\n\nfunction removeListeners(el) {\n  el.removeEventListener('click', onClick);\n  el.removeEventListener('touchstart', onTouchStart);\n  el.removeEventListener('touchend', onTouchEnd);\n  el.removeEventListener('touchcancel', onTouchCancel);\n}\n\nfunction onClick(event) {\n  var el = event.currentTarget;\n  event.closePopover = !el.$_vclosepopover_touch;\n  event.closeAllPopover = el.$_closePopoverModifiers && !!el.$_closePopoverModifiers.all;\n}\n\nfunction onTouchStart(event) {\n  if (event.changedTouches.length === 1) {\n    var el = event.currentTarget;\n    el.$_vclosepopover_touch = true;\n    var touch = event.changedTouches[0];\n    el.$_vclosepopover_touchPoint = touch;\n    el.addEventListener('touchend', onTouchEnd);\n    el.addEventListener('touchcancel', onTouchCancel);\n  }\n}\n\nfunction onTouchEnd(event) {\n  var el = event.currentTarget;\n  el.$_vclosepopover_touch = false;\n\n  if (event.changedTouches.length === 1) {\n    var touch = event.changedTouches[0];\n    var firstTouch = el.$_vclosepopover_touchPoint;\n    event.closePopover = Math.abs(touch.screenY - firstTouch.screenY) < 20 && Math.abs(touch.screenX - firstTouch.screenX) < 20;\n    event.closeAllPopover = el.$_closePopoverModifiers && !!el.$_closePopoverModifiers.all;\n  }\n}\n\nfunction onTouchCancel(event) {\n  var el = event.currentTarget;\n  el.$_vclosepopover_touch = false;\n}\n\nvar vclosepopover = {\n  bind: function bind(el, _ref) {\n    var value = _ref.value,\n        modifiers = _ref.modifiers;\n    el.$_closePopoverModifiers = modifiers;\n\n    if (typeof value === 'undefined' || value) {\n      addListeners(el);\n    }\n  },\n  update: function update(el, _ref2) {\n    var value = _ref2.value,\n        oldValue = _ref2.oldValue,\n        modifiers = _ref2.modifiers;\n    el.$_closePopoverModifiers = modifiers;\n\n    if (value !== oldValue) {\n      if (typeof value === 'undefined' || value) {\n        addListeners(el);\n      } else {\n        removeListeners(el);\n      }\n    }\n  },\n  unbind: function unbind(el) {\n    removeListeners(el);\n  }\n};\n\nfunction getDefault(key) {\n  var value = directive.options.popover[key];\n\n  if (typeof value === 'undefined') {\n    return directive.options[key];\n  }\n\n  return value;\n}\n\nvar isIOS = false;\n\nif (typeof window !== 'undefined' && typeof navigator !== 'undefined') {\n  isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;\n}\n\nvar openPopovers = [];\n\nvar Element = function Element() {};\n\nif (typeof window !== 'undefined') {\n  Element = window.Element;\n}\n\nvar script = {\n  name: 'VPopover',\n  components: {\n    ResizeObserver: ResizeObserver\n  },\n  props: {\n    open: {\n      type: Boolean,\n      default: false\n    },\n    disabled: {\n      type: Boolean,\n      default: false\n    },\n    placement: {\n      type: String,\n      default: function _default() {\n        return getDefault('defaultPlacement');\n      }\n    },\n    delay: {\n      type: [String, Number, Object],\n      default: function _default() {\n        return getDefault('defaultDelay');\n      }\n    },\n    offset: {\n      type: [String, Number],\n      default: function _default() {\n        return getDefault('defaultOffset');\n      }\n    },\n    trigger: {\n      type: String,\n      default: function _default() {\n        return getDefault('defaultTrigger');\n      }\n    },\n    container: {\n      type: [String, Object, Element, Boolean],\n      default: function _default() {\n        return getDefault('defaultContainer');\n      }\n    },\n    boundariesElement: {\n      type: [String, Element],\n      default: function _default() {\n        return getDefault('defaultBoundariesElement');\n      }\n    },\n    popperOptions: {\n      type: Object,\n      default: function _default() {\n        return getDefault('defaultPopperOptions');\n      }\n    },\n    popoverClass: {\n      type: [String, Array],\n      default: function _default() {\n        return getDefault('defaultClass');\n      }\n    },\n    popoverBaseClass: {\n      type: [String, Array],\n      default: function _default() {\n        return directive.options.popover.defaultBaseClass;\n      }\n    },\n    popoverInnerClass: {\n      type: [String, Array],\n      default: function _default() {\n        return directive.options.popover.defaultInnerClass;\n      }\n    },\n    popoverWrapperClass: {\n      type: [String, Array],\n      default: function _default() {\n        return directive.options.popover.defaultWrapperClass;\n      }\n    },\n    popoverArrowClass: {\n      type: [String, Array],\n      default: function _default() {\n        return directive.options.popover.defaultArrowClass;\n      }\n    },\n    autoHide: {\n      type: Boolean,\n      default: function _default() {\n        return directive.options.popover.defaultAutoHide;\n      }\n    },\n    handleResize: {\n      type: Boolean,\n      default: function _default() {\n        return directive.options.popover.defaultHandleResize;\n      }\n    },\n    openGroup: {\n      type: String,\n      default: null\n    },\n    openClass: {\n      type: [String, Array],\n      default: function _default() {\n        return directive.options.popover.defaultOpenClass;\n      }\n    }\n  },\n  data: function data() {\n    return {\n      isOpen: false,\n      id: Math.random().toString(36).substr(2, 10)\n    };\n  },\n  computed: {\n    cssClass: function cssClass() {\n      return _defineProperty({}, this.openClass, this.isOpen);\n    },\n    popoverId: function popoverId() {\n      return \"popover_\".concat(this.id);\n    }\n  },\n  watch: {\n    open: function open(val) {\n      if (val) {\n        this.show();\n      } else {\n        this.hide();\n      }\n    },\n    disabled: function disabled(val, oldVal) {\n      if (val !== oldVal) {\n        if (val) {\n          this.hide();\n        } else if (this.open) {\n          this.show();\n        }\n      }\n    },\n    container: function container(val) {\n      if (this.isOpen && this.popperInstance) {\n        var popoverNode = this.$refs.popover;\n        var reference = this.$refs.trigger;\n        var container = this.$_findContainer(this.container, reference);\n\n        if (!container) {\n          console.warn('No container for popover', this);\n          return;\n        }\n\n        container.appendChild(popoverNode);\n        this.popperInstance.scheduleUpdate();\n      }\n    },\n    trigger: function trigger(val) {\n      this.$_removeEventListeners();\n      this.$_addEventListeners();\n    },\n    placement: function placement(val) {\n      var _this = this;\n\n      this.$_updatePopper(function () {\n        _this.popperInstance.options.placement = val;\n      });\n    },\n    offset: '$_restartPopper',\n    boundariesElement: '$_restartPopper',\n    popperOptions: {\n      handler: '$_restartPopper',\n      deep: true\n    }\n  },\n  created: function created() {\n    this.$_isDisposed = false;\n    this.$_mounted = false;\n    this.$_events = [];\n    this.$_preventOpen = false;\n  },\n  mounted: function mounted() {\n    var popoverNode = this.$refs.popover;\n    popoverNode.parentNode && popoverNode.parentNode.removeChild(popoverNode);\n    this.$_init();\n\n    if (this.open) {\n      this.show();\n    }\n  },\n  deactivated: function deactivated() {\n    this.hide();\n  },\n  beforeDestroy: function beforeDestroy() {\n    this.dispose();\n  },\n  methods: {\n    show: function show() {\n      var _this2 = this;\n\n      var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          event = _ref2.event,\n          _ref2$skipDelay = _ref2.skipDelay,\n          _ref2$force = _ref2.force,\n          force = _ref2$force === void 0 ? false : _ref2$force;\n\n      if (force || !this.disabled) {\n        this.$_scheduleShow(event);\n        this.$emit('show');\n      }\n\n      this.$emit('update:open', true);\n      this.$_beingShowed = true;\n      requestAnimationFrame(function () {\n        _this2.$_beingShowed = false;\n      });\n    },\n    hide: function hide() {\n      var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          event = _ref3.event,\n          _ref3$skipDelay = _ref3.skipDelay;\n\n      this.$_scheduleHide(event);\n      this.$emit('hide');\n      this.$emit('update:open', false);\n    },\n    dispose: function dispose() {\n      this.$_isDisposed = true;\n      this.$_removeEventListeners();\n      this.hide({\n        skipDelay: true\n      });\n\n      if (this.popperInstance) {\n        this.popperInstance.destroy(); // destroy tooltipNode if removeOnDestroy is not set, as popperInstance.destroy() already removes the element\n\n        if (!this.popperInstance.options.removeOnDestroy) {\n          var popoverNode = this.$refs.popover;\n          popoverNode.parentNode && popoverNode.parentNode.removeChild(popoverNode);\n        }\n      }\n\n      this.$_mounted = false;\n      this.popperInstance = null;\n      this.isOpen = false;\n      this.$emit('dispose');\n    },\n    $_init: function $_init() {\n      if (this.trigger.indexOf('manual') === -1) {\n        this.$_addEventListeners();\n      }\n    },\n    $_show: function $_show() {\n      var _this3 = this;\n\n      var reference = this.$refs.trigger;\n      var popoverNode = this.$refs.popover;\n      clearTimeout(this.$_disposeTimer); // Already open\n\n      if (this.isOpen) {\n        return;\n      } // Popper is already initialized\n\n\n      if (this.popperInstance) {\n        this.isOpen = true;\n        this.popperInstance.enableEventListeners();\n        this.popperInstance.scheduleUpdate();\n      }\n\n      if (!this.$_mounted) {\n        var container = this.$_findContainer(this.container, reference);\n\n        if (!container) {\n          console.warn('No container for popover', this);\n          return;\n        }\n\n        container.appendChild(popoverNode);\n        this.$_mounted = true;\n      }\n\n      if (!this.popperInstance) {\n        var popperOptions = _objectSpread({}, this.popperOptions, {\n          placement: this.placement\n        });\n\n        popperOptions.modifiers = _objectSpread({}, popperOptions.modifiers, {\n          arrow: _objectSpread({}, popperOptions.modifiers && popperOptions.modifiers.arrow, {\n            element: this.$refs.arrow\n          })\n        });\n\n        if (this.offset) {\n          var offset = this.$_getOffset();\n          popperOptions.modifiers.offset = _objectSpread({}, popperOptions.modifiers && popperOptions.modifiers.offset, {\n            offset: offset\n          });\n        }\n\n        if (this.boundariesElement) {\n          popperOptions.modifiers.preventOverflow = _objectSpread({}, popperOptions.modifiers && popperOptions.modifiers.preventOverflow, {\n            boundariesElement: this.boundariesElement\n          });\n        }\n\n        this.popperInstance = new Popper(reference, popoverNode, popperOptions); // Fix position\n\n        requestAnimationFrame(function () {\n          if (_this3.hidden) {\n            _this3.hidden = false;\n\n            _this3.$_hide();\n\n            return;\n          }\n\n          if (!_this3.$_isDisposed && _this3.popperInstance) {\n            _this3.popperInstance.scheduleUpdate(); // Show the tooltip\n\n\n            requestAnimationFrame(function () {\n              if (_this3.hidden) {\n                _this3.hidden = false;\n\n                _this3.$_hide();\n\n                return;\n              }\n\n              if (!_this3.$_isDisposed) {\n                _this3.isOpen = true;\n              } else {\n                _this3.dispose();\n              }\n            });\n          } else {\n            _this3.dispose();\n          }\n        });\n      }\n\n      var openGroup = this.openGroup;\n\n      if (openGroup) {\n        var popover;\n\n        for (var i = 0; i < openPopovers.length; i++) {\n          popover = openPopovers[i];\n\n          if (popover.openGroup !== openGroup) {\n            popover.hide();\n            popover.$emit('close-group');\n          }\n        }\n      }\n\n      openPopovers.push(this);\n      this.$emit('apply-show');\n    },\n    $_hide: function $_hide() {\n      var _this4 = this;\n\n      // Already hidden\n      if (!this.isOpen) {\n        return;\n      }\n\n      var index = openPopovers.indexOf(this);\n\n      if (index !== -1) {\n        openPopovers.splice(index, 1);\n      }\n\n      this.isOpen = false;\n\n      if (this.popperInstance) {\n        this.popperInstance.disableEventListeners();\n      }\n\n      clearTimeout(this.$_disposeTimer);\n      var disposeTime = directive.options.popover.disposeTimeout || directive.options.disposeTimeout;\n\n      if (disposeTime !== null) {\n        this.$_disposeTimer = setTimeout(function () {\n          var popoverNode = _this4.$refs.popover;\n\n          if (popoverNode) {\n            // Don't remove popper instance, just the HTML element\n            popoverNode.parentNode && popoverNode.parentNode.removeChild(popoverNode);\n            _this4.$_mounted = false;\n          }\n        }, disposeTime);\n      }\n\n      this.$emit('apply-hide');\n    },\n    $_findContainer: function $_findContainer(container, reference) {\n      // if container is a query, get the relative element\n      if (typeof container === 'string') {\n        container = window.document.querySelector(container);\n      } else if (container === false) {\n        // if container is `false`, set it to reference parent\n        container = reference.parentNode;\n      }\n\n      return container;\n    },\n    $_getOffset: function $_getOffset() {\n      var typeofOffset = _typeof(this.offset);\n\n      var offset = this.offset; // One value -> switch\n\n      if (typeofOffset === 'number' || typeofOffset === 'string' && offset.indexOf(',') === -1) {\n        offset = \"0, \".concat(offset);\n      }\n\n      return offset;\n    },\n    $_addEventListeners: function $_addEventListeners() {\n      var _this5 = this;\n\n      var reference = this.$refs.trigger;\n      var directEvents = [];\n      var oppositeEvents = [];\n      var events = typeof this.trigger === 'string' ? this.trigger.split(' ').filter(function (trigger) {\n        return ['click', 'hover', 'focus'].indexOf(trigger) !== -1;\n      }) : [];\n      events.forEach(function (event) {\n        switch (event) {\n          case 'hover':\n            directEvents.push('mouseenter');\n            oppositeEvents.push('mouseleave');\n            break;\n\n          case 'focus':\n            directEvents.push('focus');\n            oppositeEvents.push('blur');\n            break;\n\n          case 'click':\n            directEvents.push('click');\n            oppositeEvents.push('click');\n            break;\n        }\n      }); // schedule show tooltip\n\n      directEvents.forEach(function (event) {\n        var func = function func(event) {\n          if (_this5.isOpen) {\n            return;\n          }\n\n          event.usedByTooltip = true;\n          !_this5.$_preventOpen && _this5.show({\n            event: event\n          });\n          _this5.hidden = false;\n        };\n\n        _this5.$_events.push({\n          event: event,\n          func: func\n        });\n\n        reference.addEventListener(event, func);\n      }); // schedule hide tooltip\n\n      oppositeEvents.forEach(function (event) {\n        var func = function func(event) {\n          if (event.usedByTooltip) {\n            return;\n          }\n\n          _this5.hide({\n            event: event\n          });\n\n          _this5.hidden = true;\n        };\n\n        _this5.$_events.push({\n          event: event,\n          func: func\n        });\n\n        reference.addEventListener(event, func);\n      });\n    },\n    $_scheduleShow: function $_scheduleShow() {\n      var skipDelay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n      clearTimeout(this.$_scheduleTimer);\n\n      if (skipDelay) {\n        this.$_show();\n      } else {\n        // defaults to 0\n        var computedDelay = parseInt(this.delay && this.delay.show || this.delay || 0);\n        this.$_scheduleTimer = setTimeout(this.$_show.bind(this), computedDelay);\n      }\n    },\n    $_scheduleHide: function $_scheduleHide() {\n      var _this6 = this;\n\n      var event = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n      var skipDelay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n      clearTimeout(this.$_scheduleTimer);\n\n      if (skipDelay) {\n        this.$_hide();\n      } else {\n        // defaults to 0\n        var computedDelay = parseInt(this.delay && this.delay.hide || this.delay || 0);\n        this.$_scheduleTimer = setTimeout(function () {\n          if (!_this6.isOpen) {\n            return;\n          } // if we are hiding because of a mouseleave, we must check that the new\n          // reference isn't the tooltip, because in this case we don't want to hide it\n\n\n          if (event && event.type === 'mouseleave') {\n            var isSet = _this6.$_setTooltipNodeEvent(event); // if we set the new event, don't hide the tooltip yet\n            // the new event will take care to hide it if necessary\n\n\n            if (isSet) {\n              return;\n            }\n          }\n\n          _this6.$_hide();\n        }, computedDelay);\n      }\n    },\n    $_setTooltipNodeEvent: function $_setTooltipNodeEvent(event) {\n      var _this7 = this;\n\n      var reference = this.$refs.trigger;\n      var popoverNode = this.$refs.popover;\n      var relatedreference = event.relatedreference || event.toElement || event.relatedTarget;\n\n      var callback = function callback(event2) {\n        var relatedreference2 = event2.relatedreference || event2.toElement || event2.relatedTarget; // Remove event listener after call\n\n        popoverNode.removeEventListener(event.type, callback); // If the new reference is not the reference element\n\n        if (!reference.contains(relatedreference2)) {\n          // Schedule to hide tooltip\n          _this7.hide({\n            event: event2\n          });\n        }\n      };\n\n      if (popoverNode.contains(relatedreference)) {\n        // listen to mouseleave on the tooltip element to be able to hide the tooltip\n        popoverNode.addEventListener(event.type, callback);\n        return true;\n      }\n\n      return false;\n    },\n    $_removeEventListeners: function $_removeEventListeners() {\n      var reference = this.$refs.trigger;\n      this.$_events.forEach(function (_ref4) {\n        var func = _ref4.func,\n            event = _ref4.event;\n        reference.removeEventListener(event, func);\n      });\n      this.$_events = [];\n    },\n    $_updatePopper: function $_updatePopper(cb) {\n      if (this.popperInstance) {\n        cb();\n        if (this.isOpen) this.popperInstance.scheduleUpdate();\n      }\n    },\n    $_restartPopper: function $_restartPopper() {\n      if (this.popperInstance) {\n        var isOpen = this.isOpen;\n        this.dispose();\n        this.$_isDisposed = false;\n        this.$_init();\n\n        if (isOpen) {\n          this.show({\n            skipDelay: true,\n            force: true\n          });\n        }\n      }\n    },\n    $_handleGlobalClose: function $_handleGlobalClose(event) {\n      var _this8 = this;\n\n      var touch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n      if (this.$_beingShowed) return;\n      this.hide({\n        event: event\n      });\n\n      if (event.closePopover) {\n        this.$emit('close-directive');\n      } else {\n        this.$emit('auto-hide');\n      }\n\n      if (touch) {\n        this.$_preventOpen = true;\n        setTimeout(function () {\n          _this8.$_preventOpen = false;\n        }, 300);\n      }\n    },\n    $_handleResize: function $_handleResize() {\n      if (this.isOpen && this.popperInstance) {\n        this.popperInstance.scheduleUpdate();\n        this.$emit('resize');\n      }\n    }\n  }\n};\n\nif (typeof document !== 'undefined' && typeof window !== 'undefined') {\n  if (isIOS) {\n    document.addEventListener('touchend', handleGlobalTouchend, supportsPassive ? {\n      passive: true,\n      capture: true\n    } : true);\n  } else {\n    window.addEventListener('click', handleGlobalClick, true);\n  }\n}\n\nfunction handleGlobalClick(event) {\n  handleGlobalClose(event);\n}\n\nfunction handleGlobalTouchend(event) {\n  handleGlobalClose(event, true);\n}\n\nfunction handleGlobalClose(event) {\n  var touch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n  var _loop = function _loop(i) {\n    var popover = openPopovers[i];\n\n    if (popover.$refs.popover) {\n      var contains = popover.$refs.popover.contains(event.target);\n      requestAnimationFrame(function () {\n        if (event.closeAllPopover || event.closePopover && contains || popover.autoHide && !contains) {\n          popover.$_handleGlobalClose(event, touch);\n        }\n      });\n    }\n  };\n\n  // Delay so that close directive has time to set values\n  for (var i = 0; i < openPopovers.length; i++) {\n    _loop(i);\n  }\n}\n\nfunction normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier\n/* server only */\n, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {\n  if (typeof shadowMode !== 'boolean') {\n    createInjectorSSR = createInjector;\n    createInjector = shadowMode;\n    shadowMode = false;\n  } // Vue.extend constructor export interop.\n\n\n  var options = typeof script === 'function' ? script.options : script; // render functions\n\n  if (template && template.render) {\n    options.render = template.render;\n    options.staticRenderFns = template.staticRenderFns;\n    options._compiled = true; // functional template\n\n    if (isFunctionalTemplate) {\n      options.functional = true;\n    }\n  } // scopedId\n\n\n  if (scopeId) {\n    options._scopeId = scopeId;\n  }\n\n  var hook;\n\n  if (moduleIdentifier) {\n    // server build\n    hook = function hook(context) {\n      // 2.3 injection\n      context = context || // cached call\n      this.$vnode && this.$vnode.ssrContext || // stateful\n      this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext; // functional\n      // 2.2 with runInNewContext: true\n\n      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\n        context = __VUE_SSR_CONTEXT__;\n      } // inject component styles\n\n\n      if (style) {\n        style.call(this, createInjectorSSR(context));\n      } // register component module identifier for async chunk inference\n\n\n      if (context && context._registeredComponents) {\n        context._registeredComponents.add(moduleIdentifier);\n      }\n    }; // used by ssr in case component is cached and beforeCreate\n    // never gets called\n\n\n    options._ssrRegister = hook;\n  } else if (style) {\n    hook = shadowMode ? function () {\n      style.call(this, createInjectorShadow(this.$root.$options.shadowRoot));\n    } : function (context) {\n      style.call(this, createInjector(context));\n    };\n  }\n\n  if (hook) {\n    if (options.functional) {\n      // register for functional component in vue file\n      var originalRender = options.render;\n\n      options.render = function renderWithStyleInjection(h, context) {\n        hook.call(context);\n        return originalRender(h, context);\n      };\n    } else {\n      // inject component registration as beforeCreate hook\n      var existing = options.beforeCreate;\n      options.beforeCreate = existing ? [].concat(existing, hook) : [hook];\n    }\n  }\n\n  return script;\n}\n\nvar normalizeComponent_1 = normalizeComponent;\n\n/* script */\nvar __vue_script__ = script;\n/* template */\n\nvar __vue_render__ = function __vue_render__() {\n  var _vm = this;\n\n  var _h = _vm.$createElement;\n\n  var _c = _vm._self._c || _h;\n\n  return _c(\"div\", {\n    staticClass: \"v-popover\",\n    class: _vm.cssClass\n  }, [_c(\"div\", {\n    ref: \"trigger\",\n    staticClass: \"trigger\",\n    staticStyle: {\n      display: \"inline-block\"\n    },\n    attrs: {\n      \"aria-describedby\": _vm.popoverId,\n      tabindex: _vm.trigger.indexOf(\"focus\") !== -1 ? 0 : undefined\n    }\n  }, [_vm._t(\"default\")], 2), _vm._v(\" \"), _c(\"div\", {\n    ref: \"popover\",\n    class: [_vm.popoverBaseClass, _vm.popoverClass, _vm.cssClass],\n    style: {\n      visibility: _vm.isOpen ? \"visible\" : \"hidden\"\n    },\n    attrs: {\n      id: _vm.popoverId,\n      \"aria-hidden\": _vm.isOpen ? \"false\" : \"true\",\n      tabindex: _vm.autoHide ? 0 : undefined\n    },\n    on: {\n      keyup: function keyup($event) {\n        if (!$event.type.indexOf(\"key\") && _vm._k($event.keyCode, \"esc\", 27, $event.key, [\"Esc\", \"Escape\"])) {\n          return null;\n        }\n\n        _vm.autoHide && _vm.hide();\n      }\n    }\n  }, [_c(\"div\", {\n    class: _vm.popoverWrapperClass\n  }, [_c(\"div\", {\n    ref: \"inner\",\n    class: _vm.popoverInnerClass,\n    staticStyle: {\n      position: \"relative\"\n    }\n  }, [_c(\"div\", [_vm._t(\"popover\")], 2), _vm._v(\" \"), _vm.handleResize ? _c(\"ResizeObserver\", {\n    on: {\n      notify: _vm.$_handleResize\n    }\n  }) : _vm._e()], 1), _vm._v(\" \"), _c(\"div\", {\n    ref: \"arrow\",\n    class: _vm.popoverArrowClass\n  })])])]);\n};\n\nvar __vue_staticRenderFns__ = [];\n__vue_render__._withStripped = true;\n/* style */\n\nvar __vue_inject_styles__ = undefined;\n/* scoped */\n\nvar __vue_scope_id__ = undefined;\n/* module identifier */\n\nvar __vue_module_identifier__ = undefined;\n/* functional template */\n\nvar __vue_is_functional_template__ = false;\n/* style inject */\n\n/* style inject SSR */\n\nvar Popover = normalizeComponent_1({\n  render: __vue_render__,\n  staticRenderFns: __vue_staticRenderFns__\n}, __vue_inject_styles__, __vue_script__, __vue_scope_id__, __vue_is_functional_template__, __vue_module_identifier__, undefined, undefined);\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\nvar _listCacheClear = listCacheClear;\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\nvar eq_1 = eq;\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq_1(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\nvar _assocIndexOf = assocIndexOf;\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = _assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\nvar _listCacheDelete = listCacheDelete;\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = _assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\nvar _listCacheGet = listCacheGet;\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return _assocIndexOf(this.__data__, key) > -1;\n}\n\nvar _listCacheHas = listCacheHas;\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = _assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\nvar _listCacheSet = listCacheSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = _listCacheClear;\nListCache.prototype['delete'] = _listCacheDelete;\nListCache.prototype.get = _listCacheGet;\nListCache.prototype.has = _listCacheHas;\nListCache.prototype.set = _listCacheSet;\n\nvar _ListCache = ListCache;\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new _ListCache;\n  this.size = 0;\n}\n\nvar _stackClear = stackClear;\n\n/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\n\nvar _stackDelete = stackDelete;\n\n/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\nvar _stackGet = stackGet;\n\n/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\nvar _stackHas = stackHas;\n\nvar commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};\n\nfunction createCommonjsModule(fn, module) {\n\treturn module = { exports: {} }, fn(module, module.exports), module.exports;\n}\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;\n\nvar _freeGlobal = freeGlobal;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = _freeGlobal || freeSelf || Function('return this')();\n\nvar _root = root;\n\n/** Built-in value references. */\nvar Symbol$1 = _root.Symbol;\n\nvar _Symbol = Symbol$1;\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nvar _getRawTag = getRawTag;\n\n/** Used for built-in method references. */\nvar objectProto$1 = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString$1 = objectProto$1.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString$1.call(value);\n}\n\nvar _objectToString = objectToString;\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag$1 = _Symbol ? _Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag$1 && symToStringTag$1 in Object(value))\n    ? _getRawTag(value)\n    : _objectToString(value);\n}\n\nvar _baseGetTag = baseGetTag;\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nvar isObject_1 = isObject;\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject_1(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = _baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nvar isFunction_1 = isFunction;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = _root['__core-js_shared__'];\n\nvar _coreJsData = coreJsData;\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(_coreJsData && _coreJsData.keys && _coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\nvar _isMasked = isMasked;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\nvar _toSource = toSource;\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto$1 = Function.prototype,\n    objectProto$2 = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString$1 = funcProto$1.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty$1 = objectProto$2.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString$1.call(hasOwnProperty$1).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject_1(value) || _isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction_1(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(_toSource(value));\n}\n\nvar _baseIsNative = baseIsNative;\n\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\nvar _getValue = getValue;\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = _getValue(object, key);\n  return _baseIsNative(value) ? value : undefined;\n}\n\nvar _getNative = getNative;\n\n/* Built-in method references that are verified to be native. */\nvar Map = _getNative(_root, 'Map');\n\nvar _Map = Map;\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = _getNative(Object, 'create');\n\nvar _nativeCreate = nativeCreate;\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = _nativeCreate ? _nativeCreate(null) : {};\n  this.size = 0;\n}\n\nvar _hashClear = hashClear;\n\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nvar _hashDelete = hashDelete;\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto$3 = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty$2 = objectProto$3.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (_nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty$2.call(data, key) ? data[key] : undefined;\n}\n\nvar _hashGet = hashGet;\n\n/** Used for built-in method references. */\nvar objectProto$4 = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty$3 = objectProto$4.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return _nativeCreate ? (data[key] !== undefined) : hasOwnProperty$3.call(data, key);\n}\n\nvar _hashHas = hashHas;\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED$1 = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = (_nativeCreate && value === undefined) ? HASH_UNDEFINED$1 : value;\n  return this;\n}\n\nvar _hashSet = hashSet;\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = _hashClear;\nHash.prototype['delete'] = _hashDelete;\nHash.prototype.get = _hashGet;\nHash.prototype.has = _hashHas;\nHash.prototype.set = _hashSet;\n\nvar _Hash = Hash;\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new _Hash,\n    'map': new (_Map || _ListCache),\n    'string': new _Hash\n  };\n}\n\nvar _mapCacheClear = mapCacheClear;\n\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\nvar _isKeyable = isKeyable;\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return _isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\nvar _getMapData = getMapData;\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = _getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nvar _mapCacheDelete = mapCacheDelete;\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return _getMapData(this, key).get(key);\n}\n\nvar _mapCacheGet = mapCacheGet;\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return _getMapData(this, key).has(key);\n}\n\nvar _mapCacheHas = mapCacheHas;\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = _getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\nvar _mapCacheSet = mapCacheSet;\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = _mapCacheClear;\nMapCache.prototype['delete'] = _mapCacheDelete;\nMapCache.prototype.get = _mapCacheGet;\nMapCache.prototype.has = _mapCacheHas;\nMapCache.prototype.set = _mapCacheSet;\n\nvar _MapCache = MapCache;\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof _ListCache) {\n    var pairs = data.__data__;\n    if (!_Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new _MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\nvar _stackSet = stackSet;\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new _ListCache(entries);\n  this.size = data.size;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = _stackClear;\nStack.prototype['delete'] = _stackDelete;\nStack.prototype.get = _stackGet;\nStack.prototype.has = _stackHas;\nStack.prototype.set = _stackSet;\n\nvar _Stack = Stack;\n\nvar defineProperty = (function() {\n  try {\n    var func = _getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}());\n\nvar _defineProperty$1 = defineProperty;\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n  if (key == '__proto__' && _defineProperty$1) {\n    _defineProperty$1(object, key, {\n      'configurable': true,\n      'enumerable': true,\n      'value': value,\n      'writable': true\n    });\n  } else {\n    object[key] = value;\n  }\n}\n\nvar _baseAssignValue = baseAssignValue;\n\n/**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignMergeValue(object, key, value) {\n  if ((value !== undefined && !eq_1(object[key], value)) ||\n      (value === undefined && !(key in object))) {\n    _baseAssignValue(object, key, value);\n  }\n}\n\nvar _assignMergeValue = assignMergeValue;\n\n/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n  return function(object, iteratee, keysFunc) {\n    var index = -1,\n        iterable = Object(object),\n        props = keysFunc(object),\n        length = props.length;\n\n    while (length--) {\n      var key = props[fromRight ? length : ++index];\n      if (iteratee(iterable[key], key, iterable) === false) {\n        break;\n      }\n    }\n    return object;\n  };\n}\n\nvar _createBaseFor = createBaseFor;\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = _createBaseFor();\n\nvar _baseFor = baseFor;\n\nvar _cloneBuffer = createCommonjsModule(function (module, exports) {\n/** Detect free variable `exports`. */\nvar freeExports = exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? _root.Buffer : undefined,\n    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var length = buffer.length,\n      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n  buffer.copy(result);\n  return result;\n}\n\nmodule.exports = cloneBuffer;\n});\n\n/** Built-in value references. */\nvar Uint8Array = _root.Uint8Array;\n\nvar _Uint8Array = Uint8Array;\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new _Uint8Array(result).set(new _Uint8Array(arrayBuffer));\n  return result;\n}\n\nvar _cloneArrayBuffer = cloneArrayBuffer;\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? _cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\nvar _cloneTypedArray = cloneTypedArray;\n\n/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n\n  array || (array = Array(length));\n  while (++index < length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\nvar _copyArray = copyArray;\n\n/** Built-in value references. */\nvar objectCreate = Object.create;\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n  function object() {}\n  return function(proto) {\n    if (!isObject_1(proto)) {\n      return {};\n    }\n    if (objectCreate) {\n      return objectCreate(proto);\n    }\n    object.prototype = proto;\n    var result = new object;\n    object.prototype = undefined;\n    return result;\n  };\n}());\n\nvar _baseCreate = baseCreate;\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\nvar _overArg = overArg;\n\n/** Built-in value references. */\nvar getPrototype = _overArg(Object.getPrototypeOf, Object);\n\nvar _getPrototype = getPrototype;\n\n/** Used for built-in method references. */\nvar objectProto$5 = Object.prototype;\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$5;\n\n  return value === proto;\n}\n\nvar _isPrototype = isPrototype;\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' && !_isPrototype(object))\n    ? _baseCreate(_getPrototype(object))\n    : {};\n}\n\nvar _initCloneObject = initCloneObject;\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nvar isObjectLike_1 = isObjectLike;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike_1(value) && _baseGetTag(value) == argsTag;\n}\n\nvar _baseIsArguments = baseIsArguments;\n\n/** Used for built-in method references. */\nvar objectProto$6 = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty$4 = objectProto$6.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto$6.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = _baseIsArguments(function() { return arguments; }()) ? _baseIsArguments : function(value) {\n  return isObjectLike_1(value) && hasOwnProperty$4.call(value, 'callee') &&\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\nvar isArguments_1 = isArguments;\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nvar isArray_1 = isArray;\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nvar isLength_1 = isLength;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength_1(value.length) && !isFunction_1(value);\n}\n\nvar isArrayLike_1 = isArrayLike;\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike_1(value) && isArrayLike_1(value);\n}\n\nvar isArrayLikeObject_1 = isArrayLikeObject;\n\n/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nvar stubFalse_1 = stubFalse;\n\nvar isBuffer_1 = createCommonjsModule(function (module, exports) {\n/** Detect free variable `exports`. */\nvar freeExports = exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? _root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse_1;\n\nmodule.exports = isBuffer;\n});\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar funcProto$2 = Function.prototype,\n    objectProto$7 = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString$2 = funcProto$2.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty$5 = objectProto$7.hasOwnProperty;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString$2.call(Object);\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n  if (!isObjectLike_1(value) || _baseGetTag(value) != objectTag) {\n    return false;\n  }\n  var proto = _getPrototype(value);\n  if (proto === null) {\n    return true;\n  }\n  var Ctor = hasOwnProperty$5.call(proto, 'constructor') && proto.constructor;\n  return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n    funcToString$2.call(Ctor) == objectCtorString;\n}\n\nvar isPlainObject_1 = isPlainObject;\n\n/** `Object#toString` result references. */\nvar argsTag$1 = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag$1 = '[object Function]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag$1 = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag$1] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag$1] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag$1] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike_1(value) &&\n    isLength_1(value.length) && !!typedArrayTags[_baseGetTag(value)];\n}\n\nvar _baseIsTypedArray = baseIsTypedArray;\n\n/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\nvar _baseUnary = baseUnary;\n\nvar _nodeUtil = createCommonjsModule(function (module, exports) {\n/** Detect free variable `exports`. */\nvar freeExports = exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && _freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n  try {\n    // Use `util.types` for Node.js 10+.\n    var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n    if (types) {\n      return types;\n    }\n\n    // Legacy `process.binding('util')` for Node.js < 10.\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}());\n\nmodule.exports = nodeUtil;\n});\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = _nodeUtil && _nodeUtil.isTypedArray;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? _baseUnary(nodeIsTypedArray) : _baseIsTypedArray;\n\nvar isTypedArray_1 = isTypedArray;\n\n/**\n * Gets the value at `key`, unless `key` is \"__proto__\".\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction safeGet(object, key) {\n  if (key == '__proto__') {\n    return;\n  }\n\n  return object[key];\n}\n\nvar _safeGet = safeGet;\n\n/** Used for built-in method references. */\nvar objectProto$8 = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty$6 = objectProto$8.hasOwnProperty;\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty$6.call(object, key) && eq_1(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    _baseAssignValue(object, key, value);\n  }\n}\n\nvar _assignValue = assignValue;\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  var isNew = !object;\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    if (newValue === undefined) {\n      newValue = source[key];\n    }\n    if (isNew) {\n      _baseAssignValue(object, key, newValue);\n    } else {\n      _assignValue(object, key, newValue);\n    }\n  }\n  return object;\n}\n\nvar _copyObject = copyObject;\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\nvar _baseTimes = baseTimes;\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER$1 = 9007199254740991;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  var type = typeof value;\n  length = length == null ? MAX_SAFE_INTEGER$1 : length;\n\n  return !!length &&\n    (type == 'number' ||\n      (type != 'symbol' && reIsUint.test(value))) &&\n        (value > -1 && value % 1 == 0 && value < length);\n}\n\nvar _isIndex = isIndex;\n\n/** Used for built-in method references. */\nvar objectProto$9 = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty$7 = objectProto$9.hasOwnProperty;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray_1(value),\n      isArg = !isArr && isArguments_1(value),\n      isBuff = !isArr && !isArg && isBuffer_1(value),\n      isType = !isArr && !isArg && !isBuff && isTypedArray_1(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? _baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty$7.call(value, key)) &&\n        !(skipIndexes && (\n           // Safari 9 has enumerable `arguments.length` in strict mode.\n           key == 'length' ||\n           // Node.js 0.10 has enumerable non-index properties on buffers.\n           (isBuff && (key == 'offset' || key == 'parent')) ||\n           // PhantomJS 2 has enumerable non-index properties on typed arrays.\n           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n           // Skip index properties.\n           _isIndex(key, length)\n        ))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nvar _arrayLikeKeys = arrayLikeKeys;\n\n/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n  var result = [];\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nvar _nativeKeysIn = nativeKeysIn;\n\n/** Used for built-in method references. */\nvar objectProto$a = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty$8 = objectProto$a.hasOwnProperty;\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n  if (!isObject_1(object)) {\n    return _nativeKeysIn(object);\n  }\n  var isProto = _isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty$8.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nvar _baseKeysIn = baseKeysIn;\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  return isArrayLike_1(object) ? _arrayLikeKeys(object, true) : _baseKeysIn(object);\n}\n\nvar keysIn_1 = keysIn;\n\n/**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\nfunction toPlainObject(value) {\n  return _copyObject(value, keysIn_1(value));\n}\n\nvar toPlainObject_1 = toPlainObject;\n\n/**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n  var objValue = _safeGet(object, key),\n      srcValue = _safeGet(source, key),\n      stacked = stack.get(srcValue);\n\n  if (stacked) {\n    _assignMergeValue(object, key, stacked);\n    return;\n  }\n  var newValue = customizer\n    ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n    : undefined;\n\n  var isCommon = newValue === undefined;\n\n  if (isCommon) {\n    var isArr = isArray_1(srcValue),\n        isBuff = !isArr && isBuffer_1(srcValue),\n        isTyped = !isArr && !isBuff && isTypedArray_1(srcValue);\n\n    newValue = srcValue;\n    if (isArr || isBuff || isTyped) {\n      if (isArray_1(objValue)) {\n        newValue = objValue;\n      }\n      else if (isArrayLikeObject_1(objValue)) {\n        newValue = _copyArray(objValue);\n      }\n      else if (isBuff) {\n        isCommon = false;\n        newValue = _cloneBuffer(srcValue, true);\n      }\n      else if (isTyped) {\n        isCommon = false;\n        newValue = _cloneTypedArray(srcValue, true);\n      }\n      else {\n        newValue = [];\n      }\n    }\n    else if (isPlainObject_1(srcValue) || isArguments_1(srcValue)) {\n      newValue = objValue;\n      if (isArguments_1(objValue)) {\n        newValue = toPlainObject_1(objValue);\n      }\n      else if (!isObject_1(objValue) || isFunction_1(objValue)) {\n        newValue = _initCloneObject(srcValue);\n      }\n    }\n    else {\n      isCommon = false;\n    }\n  }\n  if (isCommon) {\n    // Recursively merge objects and arrays (susceptible to call stack limits).\n    stack.set(srcValue, newValue);\n    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n    stack['delete'](srcValue);\n  }\n  _assignMergeValue(object, key, newValue);\n}\n\nvar _baseMergeDeep = baseMergeDeep;\n\n/**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMerge(object, source, srcIndex, customizer, stack) {\n  if (object === source) {\n    return;\n  }\n  _baseFor(source, function(srcValue, key) {\n    if (isObject_1(srcValue)) {\n      stack || (stack = new _Stack);\n      _baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n    }\n    else {\n      var newValue = customizer\n        ? customizer(_safeGet(object, key), srcValue, (key + ''), object, source, stack)\n        : undefined;\n\n      if (newValue === undefined) {\n        newValue = srcValue;\n      }\n      _assignMergeValue(object, key, newValue);\n    }\n  }, keysIn_1);\n}\n\nvar _baseMerge = baseMerge;\n\n/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n  return value;\n}\n\nvar identity_1 = identity;\n\n/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\n}\n\nvar _apply = apply;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = transform(array);\n    return _apply(func, this, otherArgs);\n  };\n}\n\nvar _overRest = overRest;\n\n/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n  return function() {\n    return value;\n  };\n}\n\nvar constant_1 = constant;\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !_defineProperty$1 ? identity_1 : function(func, string) {\n  return _defineProperty$1(func, 'toString', {\n    'configurable': true,\n    'enumerable': false,\n    'value': constant_1(string),\n    'writable': true\n  });\n};\n\nvar _baseSetToString = baseSetToString;\n\n/** Used to detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n    HOT_SPAN = 16;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeNow = Date.now;\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n  var count = 0,\n      lastCalled = 0;\n\n  return function() {\n    var stamp = nativeNow(),\n        remaining = HOT_SPAN - (stamp - lastCalled);\n\n    lastCalled = stamp;\n    if (remaining > 0) {\n      if (++count >= HOT_COUNT) {\n        return arguments[0];\n      }\n    } else {\n      count = 0;\n    }\n    return func.apply(undefined, arguments);\n  };\n}\n\nvar _shortOut = shortOut;\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = _shortOut(_baseSetToString);\n\nvar _setToString = setToString;\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  return _setToString(_overRest(func, start, identity_1), func + '');\n}\n\nvar _baseRest = baseRest;\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n *  else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n  if (!isObject_1(object)) {\n    return false;\n  }\n  var type = typeof index;\n  if (type == 'number'\n        ? (isArrayLike_1(object) && _isIndex(index, object.length))\n        : (type == 'string' && index in object)\n      ) {\n    return eq_1(object[index], value);\n  }\n  return false;\n}\n\nvar _isIterateeCall = isIterateeCall;\n\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n  return _baseRest(function(object, sources) {\n    var index = -1,\n        length = sources.length,\n        customizer = length > 1 ? sources[length - 1] : undefined,\n        guard = length > 2 ? sources[2] : undefined;\n\n    customizer = (assigner.length > 3 && typeof customizer == 'function')\n      ? (length--, customizer)\n      : undefined;\n\n    if (guard && _isIterateeCall(sources[0], sources[1], guard)) {\n      customizer = length < 3 ? undefined : customizer;\n      length = 1;\n    }\n    object = Object(object);\n    while (++index < length) {\n      var source = sources[index];\n      if (source) {\n        assigner(object, source, index, customizer);\n      }\n    }\n    return object;\n  });\n}\n\nvar _createAssigner = createAssigner;\n\n/**\n * This method is like `_.assign` except that it recursively merges own and\n * inherited enumerable string keyed properties of source objects into the\n * destination object. Source properties that resolve to `undefined` are\n * skipped if a destination value exists. Array and plain object properties\n * are merged recursively. Other objects and value types are overridden by\n * assignment. Source objects are applied from left to right. Subsequent\n * sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = {\n *   'a': [{ 'b': 2 }, { 'd': 4 }]\n * };\n *\n * var other = {\n *   'a': [{ 'c': 3 }, { 'e': 5 }]\n * };\n *\n * _.merge(object, other);\n * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n */\nvar merge = _createAssigner(function(object, source, srcIndex) {\n  _baseMerge(object, source, srcIndex);\n});\n\nvar merge_1 = merge;\n\nfunction styleInject(css, ref) {\n  if ( ref === void 0 ) ref = {};\n  var insertAt = ref.insertAt;\n\n  if (!css || typeof document === 'undefined') { return; }\n\n  var head = document.head || document.getElementsByTagName('head')[0];\n  var style = document.createElement('style');\n  style.type = 'text/css';\n\n  if (insertAt === 'top') {\n    if (head.firstChild) {\n      head.insertBefore(style, head.firstChild);\n    } else {\n      head.appendChild(style);\n    }\n  } else {\n    head.appendChild(style);\n  }\n\n  if (style.styleSheet) {\n    style.styleSheet.cssText = css;\n  } else {\n    style.appendChild(document.createTextNode(css));\n  }\n}\n\nvar css = \".resize-observer[data-v-b329ee4c]{position:absolute;top:0;left:0;z-index:-1;width:100%;height:100%;border:none;background-color:transparent;pointer-events:none;display:block;overflow:hidden;opacity:0}.resize-observer[data-v-b329ee4c] object{display:block;position:absolute;top:0;left:0;height:100%;width:100%;overflow:hidden;pointer-events:none;z-index:-1}\";\nstyleInject(css);\n\nfunction install(Vue) {\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  if (install.installed) return;\n  install.installed = true;\n  var finalOptions = {};\n  merge_1(finalOptions, defaultOptions, options);\n  plugin.options = finalOptions;\n  directive.options = finalOptions;\n  Vue.directive('tooltip', directive);\n  Vue.directive('close-popover', vclosepopover);\n  Vue.component('v-popover', Popover);\n}\nvar VTooltip = directive;\nvar VClosePopover = vclosepopover;\nvar VPopover = Popover;\nvar plugin = {\n  install: install,\n\n  get enabled() {\n    return state.enabled;\n  },\n\n  set enabled(value) {\n    state.enabled = value;\n  }\n\n}; // Auto-install\n\nvar GlobalVue = null;\n\nif (typeof window !== 'undefined') {\n  GlobalVue = window.Vue;\n} else if (typeof global !== 'undefined') {\n  GlobalVue = global.Vue;\n}\n\nif (GlobalVue) {\n  GlobalVue.use(plugin);\n}\n\nexport default plugin;\nexport { VClosePopover, VPopover, VTooltip, createTooltip, destroyTooltip, install };\n"],"sourceRoot":""}