{"version":3,"sources":["webpack:///./node_modules/outlayer/outlayer.js","webpack:///./node_modules/outlayer/item.js","webpack:///./node_modules/portal-vue/dist/portal-vue.common.js","webpack:///./node_modules/popper.js/dist/esm/popper.js"],"names":["window","factory","EvEmitter","getSize","utils","Item","console","jQuery","noop","GUID","instances","Outlayer","element","options","queryElement","getQueryElement","this","$element","extend","constructor","defaults","option","id","outlayerGUID","_create","isInitLayout","_getOption","layout","error","namespace","containerStyle","position","initLayout","originLeft","originTop","resize","resizeContainer","transitionDuration","hiddenStyle","opacity","transform","visibleStyle","proto","prototype","subclass","Parent","SubClass","apply","arguments","Object","create","opts","oldOption","compatOptions","undefined","horizontal","layoutInstant","reloadItems","stamps","stamp","style","canBindResize","bindResize","items","_itemize","children","elems","itemElems","_filterFindItemElements","i","length","elem","item","push","filterFindElements","itemSelector","getItemElements","map","_resetLayout","_manageStamps","isInstant","_isLayoutInited","layoutItems","_init","size","_getMeasurement","measurement","querySelector","HTMLElement","_getItemsForLayout","_layoutItems","_postLayout","filter","isIgnored","_emitCompleteOnItems","queue","forEach","_getItemLayoutPosition","isLayoutInstant","_processLayoutQueue","x","y","updateStagger","obj","_positionItem","stagger","getMilliseconds","goTo","moveTo","isResizingContainer","_getContainerSize","_setContainerMeasure","width","height","measure","isWidth","elemSize","isBorderBox","paddingLeft","paddingRight","borderLeftWidth","borderRightWidth","paddingBottom","paddingTop","borderTopWidth","borderBottomWidth","Math","max","eventName","_this","onComplete","dispatchEvent","count","doneCount","once","tick","type","event","args","emitArgs","concat","emitEvent","$event","Event","trigger","ignore","getItem","unignore","_find","unstamp","removeFrom","querySelectorAll","makeArray","_getBoundingRect","_manageStamp","boundingRect","getBoundingClientRect","_boundingRect","left","top","right","bottom","_getElementOffset","thisRect","offset","marginLeft","marginTop","marginRight","marginBottom","handleEvent","addEventListener","isResizeBound","unbindResize","removeEventListener","onresize","debounceMethod","needsResizeLayout","hasSizes","innerWidth","addItems","appended","reveal","prepended","previousItems","slice","hide","revealItemElements","getItems","hideItemElements","remove","removeItems","destroy","removeData","data","Layout","htmlInit","bridget","msUnits","ms","s","time","matches","match","num","unit","parseFloat","mult","isEmptyObj","prop","docElemStyle","document","documentElement","transitionProperty","transition","transformProperty","transitionEndEvent","WebkitTransition","vendorProperties","transitionDelay","toDashedAll","str","replace","$1","toLowerCase","_transn","ingProperties","clean","onEnd","css","method","elemStyle","supportedProp","getPosition","getComputedStyle","isOriginLeft","isOriginTop","xValue","yValue","layoutSize","indexOf","isNaN","layoutPosition","xPadding","xProperty","xResetProperty","getXValue","yPadding","yProperty","yResetProperty","getYValue","isHorizontal","percentPosition","_transitionTo","curX","curY","didNotMove","setPosition","isTransitioning","transX","transY","transitionStyle","getTranslate","to","onTransitionEnd","isCleaning","_nonTransition","_removeStyles","call","_transition","from","offsetHeight","enableTransition","transitionProps","duration","staggerDelay","onwebkitTransitionEnd","ontransitionend","onotransitionend","dashedVendorProperties","target","propertyName","disableTransition","removeTransitionStyles","cleanStyle","cleanTransitionStyle","delay","removeElem","parentNode","removeChild","display","isHidden","transitionEndProperty","getHideRevealTransitionEndProperty","onRevealTransitionEnd","styleProperty","optionStyle","onHideTransitionEnd","_interopDefault","ex","defineProperty","exports","value","Vue","_typeof","Symbol","iterator","_toConsumableArray","arr","_arrayWithoutHoles","_iterableToArray","_nonIterableSpread","Array","isArray","arr2","iter","toString","TypeError","inBrowser","freeze","combinePassengers","transports","slotProps","reduce","passengers","transport","temp","newPassengers","stableSort","array","compareFn","v","idx","sort","a","b","c","pick","keys","acc","key","hasOwnProperty","targets","sources","Wormhole","trackInstances","methods","open","_transport$order","order","Infinity","newTransport","set","currentIndex","$_getTransportIndex","newTransports","close","force","index","splice","registerTarget","vm","warn","$set","unregisterTarget","$delete","registerSource","source","unregisterSource","hasTarget","hasSource","hasContentFor","_ref","wormhole","_id","Portal","name","props","disabled","Boolean","String","default","Number","slim","tag","round","random","created","$nextTick","mounted","sendUpdate","updated","clear","beforeDestroy","watch","newValue","oldValue","closer","normalizeSlots","$scopedSlots","$slots","normalizeOwnChildren","slotContent","render","h","Tag","class","PortalTarget","multiple","required","Function","firstRender","ownTransports","$emit","newVal","oldVal","_this2","computed","noWrapper","_id$1","portalProps","targetProps","MountingPortal","inheritAttrs","append","bail","mountTo","targetSlim","targetSlotProps","targetTag","el","$props","portalTarget","mountEl","createElement","appendChild","_props","parent","$parent","propsData","$el","$destroy","manual","attrs","$attrs","on","$listeners","scopedSlots","content","install","Vue$$1","component","portalName","portalTargetName","MountingPortalName","isBrowser","navigator","timeoutDuration","longerTimeoutBrowsers","userAgent","microtaskDebounce","fn","called","Promise","resolve","then","taskDebounce","scheduled","setTimeout","supportsMicroTasks","debounce","isFunction","functionToCheck","getType","getStyleComputedProperty","property","nodeType","ownerDocument","defaultView","getParentNode","nodeName","host","getScrollParent","body","_getStyleComputedProp","overflow","overflowX","overflowY","test","getReferenceNode","reference","referenceNode","isIE11","MSInputMethodContext","documentMode","isIE10","isIE","version","getOffsetParent","noOffsetParent","offsetParent","nextElementSibling","isOffsetContainer","firstElementChild","getRoot","node","findCommonOffsetParent","element1","element2","compareDocumentPosition","Node","DOCUMENT_POSITION_FOLLOWING","start","end","range","createRange","setStart","setEnd","commonAncestorContainer","contains","element1root","getScroll","side","upperSide","html","scrollingElement","includeScroll","rect","subtract","scrollTop","scrollLeft","modifier","getBordersSize","styles","axis","sideA","sideB","computedStyle","parseInt","getWindowSizes","classCallCheck","instance","Constructor","createClass","defineProperties","descriptor","enumerable","configurable","writable","protoProps","staticProps","_extends","assign","getClientRect","offsets","e","result","sizes","clientWidth","clientHeight","horizScrollbar","offsetWidth","vertScrollbar","getOffsetRectRelativeToArbitraryNode","fixedPosition","isHTML","childrenRect","parentRect","scrollParent","getViewportOffsetRectRelativeToArtbitraryNode","excludeScroll","relativeOffset","innerHeight","isFixed","getFixedPositionOffsetParent","parentElement","getBoundaries","popper","padding","boundariesElement","boundaries","boundariesNode","_getWindowSizes","isPaddingNumber","getArea","computeAutoPlacement","placement","refRect","rects","sortedAreas","area","filteredAreas","_ref2","computedPlacement","variation","split","getReferenceOffsets","state","commonOffsetParent","getOuterSizes","getOppositePlacement","hash","matched","getPopperOffsets","referenceOffsets","popperRect","popperOffsets","isHoriz","mainSide","secondarySide","secondaryMeasurement","find","check","findIndex","cur","runModifiers","modifiers","ends","modifiersToRun","enabled","update","isDestroyed","arrowStyles","attributes","flipped","positionFixed","flip","originalPlacement","isCreated","onUpdate","onCreate","isModifierEnabled","modifierName","some","getSupportedPropertyName","prefixes","upperProp","charAt","toUpperCase","prefix","toCheck","removeAttribute","willChange","disableEventListeners","removeOnDestroy","getWindow","attachToScrollParents","callback","scrollParents","isBody","passive","setupEventListeners","updateBound","scrollElement","eventsEnabled","enableEventListeners","scheduleUpdate","removeEventListeners","cancelAnimationFrame","isNumeric","n","isFinite","setStyles","setAttributes","setAttribute","applyStyle","arrowElement","applyStyleOnLoad","modifierOptions","getRoundedOffsets","shouldRound","_data$offsets","floor","noRound","referenceWidth","popperWidth","isVertical","isVariation","sameWidthParity","bothOddWidth","horizontalToInteger","verticalToInteger","isFirefox","computeStyle","legacyGpuAccelerationOption","gpuAcceleration","offsetParentRect","devicePixelRatio","prefixedProperty","invertTop","invertLeft","arrow","isModifierRequired","requestingName","requestedName","requesting","isRequired","_requesting","requested","_data$offsets$arrow","len","sideCapitalized","altSide","opSide","arrowElementSize","center","popperMarginSide","popperBorderSide","sideValue","min","getOppositeVariation","placements","validPlacements","clockwise","counter","reverse","BEHAVIORS","FLIP","CLOCKWISE","COUNTERCLOCKWISE","placementOpposite","flipOrder","behavior","step","refOffsets","overlapsRef","overflowsLeft","overflowsRight","overflowsTop","overflowsBottom","overflowsBoundaries","flippedVariationByRef","flipVariations","flippedVariationByContent","flipVariationsByContent","flippedVariation","keepTogether","toValue","parseOffset","basePlacement","useHeight","fragments","frag","trim","divider","search","splitRegex","ops","op","mergeWithPrevious","index2","preventOverflow","transformProp","popperStyles","priority","primary","escapeWithReference","secondary","shift","shiftvariation","shiftOffsets","bound","inner","subtractLength","onLoad","Defaults","Popper","requestAnimationFrame","bind","jquery","Utils","global","PopperUtils"],"mappings":"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","file":"js/chunk-vendors~c1dd23ef.6a875c75.js","sourcesContent":["/*!\n * Outlayer v2.1.1\n * the brains and guts of a layout library\n * MIT license\n */\n\n( function( window, factory ) {\n  'use strict';\n  // universal module definition\n  /* jshint strict: false */ /* globals define, module, require */\n  if ( typeof define == 'function' && define.amd ) {\n    // AMD - RequireJS\n    define( [\n        'ev-emitter/ev-emitter',\n        'get-size/get-size',\n        'fizzy-ui-utils/utils',\n        './item'\n      ],\n      function( EvEmitter, getSize, utils, Item ) {\n        return factory( window, EvEmitter, getSize, utils, Item);\n      }\n    );\n  } else if ( typeof module == 'object' && module.exports ) {\n    // CommonJS - Browserify, Webpack\n    module.exports = factory(\n      window,\n      require('ev-emitter'),\n      require('get-size'),\n      require('fizzy-ui-utils'),\n      require('./item')\n    );\n  } else {\n    // browser global\n    window.Outlayer = factory(\n      window,\n      window.EvEmitter,\n      window.getSize,\n      window.fizzyUIUtils,\n      window.Outlayer.Item\n    );\n  }\n\n}( window, function factory( window, EvEmitter, getSize, utils, Item ) {\n'use strict';\n\n// ----- vars ----- //\n\nvar console = window.console;\nvar jQuery = window.jQuery;\nvar noop = function() {};\n\n// -------------------------- Outlayer -------------------------- //\n\n// globally unique identifiers\nvar GUID = 0;\n// internal store of all Outlayer intances\nvar instances = {};\n\n\n/**\n * @param {Element, String} element\n * @param {Object} options\n * @constructor\n */\nfunction Outlayer( element, options ) {\n  var queryElement = utils.getQueryElement( element );\n  if ( !queryElement ) {\n    if ( console ) {\n      console.error( 'Bad element for ' + this.constructor.namespace +\n        ': ' + ( queryElement || element ) );\n    }\n    return;\n  }\n  this.element = queryElement;\n  // add jQuery\n  if ( jQuery ) {\n    this.$element = jQuery( this.element );\n  }\n\n  // options\n  this.options = utils.extend( {}, this.constructor.defaults );\n  this.option( options );\n\n  // add id for Outlayer.getFromElement\n  var id = ++GUID;\n  this.element.outlayerGUID = id; // expando\n  instances[ id ] = this; // associate via id\n\n  // kick it off\n  this._create();\n\n  var isInitLayout = this._getOption('initLayout');\n  if ( isInitLayout ) {\n    this.layout();\n  }\n}\n\n// settings are for internal use only\nOutlayer.namespace = 'outlayer';\nOutlayer.Item = Item;\n\n// default options\nOutlayer.defaults = {\n  containerStyle: {\n    position: 'relative'\n  },\n  initLayout: true,\n  originLeft: true,\n  originTop: true,\n  resize: true,\n  resizeContainer: true,\n  // item options\n  transitionDuration: '0.4s',\n  hiddenStyle: {\n    opacity: 0,\n    transform: 'scale(0.001)'\n  },\n  visibleStyle: {\n    opacity: 1,\n    transform: 'scale(1)'\n  }\n};\n\nvar proto = Outlayer.prototype;\n// inherit EvEmitter\nutils.extend( proto, EvEmitter.prototype );\n\n/**\n * set options\n * @param {Object} opts\n */\nproto.option = function( opts ) {\n  utils.extend( this.options, opts );\n};\n\n/**\n * get backwards compatible option value, check old name\n */\nproto._getOption = function( option ) {\n  var oldOption = this.constructor.compatOptions[ option ];\n  return oldOption && this.options[ oldOption ] !== undefined ?\n    this.options[ oldOption ] : this.options[ option ];\n};\n\nOutlayer.compatOptions = {\n  // currentName: oldName\n  initLayout: 'isInitLayout',\n  horizontal: 'isHorizontal',\n  layoutInstant: 'isLayoutInstant',\n  originLeft: 'isOriginLeft',\n  originTop: 'isOriginTop',\n  resize: 'isResizeBound',\n  resizeContainer: 'isResizingContainer'\n};\n\nproto._create = function() {\n  // get items from children\n  this.reloadItems();\n  // elements that affect layout, but are not laid out\n  this.stamps = [];\n  this.stamp( this.options.stamp );\n  // set container style\n  utils.extend( this.element.style, this.options.containerStyle );\n\n  // bind resize method\n  var canBindResize = this._getOption('resize');\n  if ( canBindResize ) {\n    this.bindResize();\n  }\n};\n\n// goes through all children again and gets bricks in proper order\nproto.reloadItems = function() {\n  // collection of item elements\n  this.items = this._itemize( this.element.children );\n};\n\n\n/**\n * turn elements into Outlayer.Items to be used in layout\n * @param {Array or NodeList or HTMLElement} elems\n * @returns {Array} items - collection of new Outlayer Items\n */\nproto._itemize = function( elems ) {\n\n  var itemElems = this._filterFindItemElements( elems );\n  var Item = this.constructor.Item;\n\n  // create new Outlayer Items for collection\n  var items = [];\n  for ( var i=0; i < itemElems.length; i++ ) {\n    var elem = itemElems[i];\n    var item = new Item( elem, this );\n    items.push( item );\n  }\n\n  return items;\n};\n\n/**\n * get item elements to be used in layout\n * @param {Array or NodeList or HTMLElement} elems\n * @returns {Array} items - item elements\n */\nproto._filterFindItemElements = function( elems ) {\n  return utils.filterFindElements( elems, this.options.itemSelector );\n};\n\n/**\n * getter method for getting item elements\n * @returns {Array} elems - collection of item elements\n */\nproto.getItemElements = function() {\n  return this.items.map( function( item ) {\n    return item.element;\n  });\n};\n\n// ----- init & layout ----- //\n\n/**\n * lays out all items\n */\nproto.layout = function() {\n  this._resetLayout();\n  this._manageStamps();\n\n  // don't animate first layout\n  var layoutInstant = this._getOption('layoutInstant');\n  var isInstant = layoutInstant !== undefined ?\n    layoutInstant : !this._isLayoutInited;\n  this.layoutItems( this.items, isInstant );\n\n  // flag for initalized\n  this._isLayoutInited = true;\n};\n\n// _init is alias for layout\nproto._init = proto.layout;\n\n/**\n * logic before any new layout\n */\nproto._resetLayout = function() {\n  this.getSize();\n};\n\n\nproto.getSize = function() {\n  this.size = getSize( this.element );\n};\n\n/**\n * get measurement from option, for columnWidth, rowHeight, gutter\n * if option is String -> get element from selector string, & get size of element\n * if option is Element -> get size of element\n * else use option as a number\n *\n * @param {String} measurement\n * @param {String} size - width or height\n * @private\n */\nproto._getMeasurement = function( measurement, size ) {\n  var option = this.options[ measurement ];\n  var elem;\n  if ( !option ) {\n    // default to 0\n    this[ measurement ] = 0;\n  } else {\n    // use option as an element\n    if ( typeof option == 'string' ) {\n      elem = this.element.querySelector( option );\n    } else if ( option instanceof HTMLElement ) {\n      elem = option;\n    }\n    // use size of element, if element\n    this[ measurement ] = elem ? getSize( elem )[ size ] : option;\n  }\n};\n\n/**\n * layout a collection of item elements\n * @api public\n */\nproto.layoutItems = function( items, isInstant ) {\n  items = this._getItemsForLayout( items );\n\n  this._layoutItems( items, isInstant );\n\n  this._postLayout();\n};\n\n/**\n * get the items to be laid out\n * you may want to skip over some items\n * @param {Array} items\n * @returns {Array} items\n */\nproto._getItemsForLayout = function( items ) {\n  return items.filter( function( item ) {\n    return !item.isIgnored;\n  });\n};\n\n/**\n * layout items\n * @param {Array} items\n * @param {Boolean} isInstant\n */\nproto._layoutItems = function( items, isInstant ) {\n  this._emitCompleteOnItems( 'layout', items );\n\n  if ( !items || !items.length ) {\n    // no items, emit event with empty array\n    return;\n  }\n\n  var queue = [];\n\n  items.forEach( function( item ) {\n    // get x/y object from method\n    var position = this._getItemLayoutPosition( item );\n    // enqueue\n    position.item = item;\n    position.isInstant = isInstant || item.isLayoutInstant;\n    queue.push( position );\n  }, this );\n\n  this._processLayoutQueue( queue );\n};\n\n/**\n * get item layout position\n * @param {Outlayer.Item} item\n * @returns {Object} x and y position\n */\nproto._getItemLayoutPosition = function( /* item */ ) {\n  return {\n    x: 0,\n    y: 0\n  };\n};\n\n/**\n * iterate over array and position each item\n * Reason being - separating this logic prevents 'layout invalidation'\n * thx @paul_irish\n * @param {Array} queue\n */\nproto._processLayoutQueue = function( queue ) {\n  this.updateStagger();\n  queue.forEach( function( obj, i ) {\n    this._positionItem( obj.item, obj.x, obj.y, obj.isInstant, i );\n  }, this );\n};\n\n// set stagger from option in milliseconds number\nproto.updateStagger = function() {\n  var stagger = this.options.stagger;\n  if ( stagger === null || stagger === undefined ) {\n    this.stagger = 0;\n    return;\n  }\n  this.stagger = getMilliseconds( stagger );\n  return this.stagger;\n};\n\n/**\n * Sets position of item in DOM\n * @param {Outlayer.Item} item\n * @param {Number} x - horizontal position\n * @param {Number} y - vertical position\n * @param {Boolean} isInstant - disables transitions\n */\nproto._positionItem = function( item, x, y, isInstant, i ) {\n  if ( isInstant ) {\n    // if not transition, just set CSS\n    item.goTo( x, y );\n  } else {\n    item.stagger( i * this.stagger );\n    item.moveTo( x, y );\n  }\n};\n\n/**\n * Any logic you want to do after each layout,\n * i.e. size the container\n */\nproto._postLayout = function() {\n  this.resizeContainer();\n};\n\nproto.resizeContainer = function() {\n  var isResizingContainer = this._getOption('resizeContainer');\n  if ( !isResizingContainer ) {\n    return;\n  }\n  var size = this._getContainerSize();\n  if ( size ) {\n    this._setContainerMeasure( size.width, true );\n    this._setContainerMeasure( size.height, false );\n  }\n};\n\n/**\n * Sets width or height of container if returned\n * @returns {Object} size\n *   @param {Number} width\n *   @param {Number} height\n */\nproto._getContainerSize = noop;\n\n/**\n * @param {Number} measure - size of width or height\n * @param {Boolean} isWidth\n */\nproto._setContainerMeasure = function( measure, isWidth ) {\n  if ( measure === undefined ) {\n    return;\n  }\n\n  var elemSize = this.size;\n  // add padding and border width if border box\n  if ( elemSize.isBorderBox ) {\n    measure += isWidth ? elemSize.paddingLeft + elemSize.paddingRight +\n      elemSize.borderLeftWidth + elemSize.borderRightWidth :\n      elemSize.paddingBottom + elemSize.paddingTop +\n      elemSize.borderTopWidth + elemSize.borderBottomWidth;\n  }\n\n  measure = Math.max( measure, 0 );\n  this.element.style[ isWidth ? 'width' : 'height' ] = measure + 'px';\n};\n\n/**\n * emit eventComplete on a collection of items events\n * @param {String} eventName\n * @param {Array} items - Outlayer.Items\n */\nproto._emitCompleteOnItems = function( eventName, items ) {\n  var _this = this;\n  function onComplete() {\n    _this.dispatchEvent( eventName + 'Complete', null, [ items ] );\n  }\n\n  var count = items.length;\n  if ( !items || !count ) {\n    onComplete();\n    return;\n  }\n\n  var doneCount = 0;\n  function tick() {\n    doneCount++;\n    if ( doneCount == count ) {\n      onComplete();\n    }\n  }\n\n  // bind callback\n  items.forEach( function( item ) {\n    item.once( eventName, tick );\n  });\n};\n\n/**\n * emits events via EvEmitter and jQuery events\n * @param {String} type - name of event\n * @param {Event} event - original event\n * @param {Array} args - extra arguments\n */\nproto.dispatchEvent = function( type, event, args ) {\n  // add original event to arguments\n  var emitArgs = event ? [ event ].concat( args ) : args;\n  this.emitEvent( type, emitArgs );\n\n  if ( jQuery ) {\n    // set this.$element\n    this.$element = this.$element || jQuery( this.element );\n    if ( event ) {\n      // create jQuery event\n      var $event = jQuery.Event( event );\n      $event.type = type;\n      this.$element.trigger( $event, args );\n    } else {\n      // just trigger with type if no event available\n      this.$element.trigger( type, args );\n    }\n  }\n};\n\n// -------------------------- ignore & stamps -------------------------- //\n\n\n/**\n * keep item in collection, but do not lay it out\n * ignored items do not get skipped in layout\n * @param {Element} elem\n */\nproto.ignore = function( elem ) {\n  var item = this.getItem( elem );\n  if ( item ) {\n    item.isIgnored = true;\n  }\n};\n\n/**\n * return item to layout collection\n * @param {Element} elem\n */\nproto.unignore = function( elem ) {\n  var item = this.getItem( elem );\n  if ( item ) {\n    delete item.isIgnored;\n  }\n};\n\n/**\n * adds elements to stamps\n * @param {NodeList, Array, Element, or String} elems\n */\nproto.stamp = function( elems ) {\n  elems = this._find( elems );\n  if ( !elems ) {\n    return;\n  }\n\n  this.stamps = this.stamps.concat( elems );\n  // ignore\n  elems.forEach( this.ignore, this );\n};\n\n/**\n * removes elements to stamps\n * @param {NodeList, Array, or Element} elems\n */\nproto.unstamp = function( elems ) {\n  elems = this._find( elems );\n  if ( !elems ){\n    return;\n  }\n\n  elems.forEach( function( elem ) {\n    // filter out removed stamp elements\n    utils.removeFrom( this.stamps, elem );\n    this.unignore( elem );\n  }, this );\n};\n\n/**\n * finds child elements\n * @param {NodeList, Array, Element, or String} elems\n * @returns {Array} elems\n */\nproto._find = function( elems ) {\n  if ( !elems ) {\n    return;\n  }\n  // if string, use argument as selector string\n  if ( typeof elems == 'string' ) {\n    elems = this.element.querySelectorAll( elems );\n  }\n  elems = utils.makeArray( elems );\n  return elems;\n};\n\nproto._manageStamps = function() {\n  if ( !this.stamps || !this.stamps.length ) {\n    return;\n  }\n\n  this._getBoundingRect();\n\n  this.stamps.forEach( this._manageStamp, this );\n};\n\n// update boundingLeft / Top\nproto._getBoundingRect = function() {\n  // get bounding rect for container element\n  var boundingRect = this.element.getBoundingClientRect();\n  var size = this.size;\n  this._boundingRect = {\n    left: boundingRect.left + size.paddingLeft + size.borderLeftWidth,\n    top: boundingRect.top + size.paddingTop + size.borderTopWidth,\n    right: boundingRect.right - ( size.paddingRight + size.borderRightWidth ),\n    bottom: boundingRect.bottom - ( size.paddingBottom + size.borderBottomWidth )\n  };\n};\n\n/**\n * @param {Element} stamp\n**/\nproto._manageStamp = noop;\n\n/**\n * get x/y position of element relative to container element\n * @param {Element} elem\n * @returns {Object} offset - has left, top, right, bottom\n */\nproto._getElementOffset = function( elem ) {\n  var boundingRect = elem.getBoundingClientRect();\n  var thisRect = this._boundingRect;\n  var size = getSize( elem );\n  var offset = {\n    left: boundingRect.left - thisRect.left - size.marginLeft,\n    top: boundingRect.top - thisRect.top - size.marginTop,\n    right: thisRect.right - boundingRect.right - size.marginRight,\n    bottom: thisRect.bottom - boundingRect.bottom - size.marginBottom\n  };\n  return offset;\n};\n\n// -------------------------- resize -------------------------- //\n\n// enable event handlers for listeners\n// i.e. resize -> onresize\nproto.handleEvent = utils.handleEvent;\n\n/**\n * Bind layout to window resizing\n */\nproto.bindResize = function() {\n  window.addEventListener( 'resize', this );\n  this.isResizeBound = true;\n};\n\n/**\n * Unbind layout to window resizing\n */\nproto.unbindResize = function() {\n  window.removeEventListener( 'resize', this );\n  this.isResizeBound = false;\n};\n\nproto.onresize = function() {\n  this.resize();\n};\n\nutils.debounceMethod( Outlayer, 'onresize', 100 );\n\nproto.resize = function() {\n  // don't trigger if size did not change\n  // or if resize was unbound. See #9\n  if ( !this.isResizeBound || !this.needsResizeLayout() ) {\n    return;\n  }\n\n  this.layout();\n};\n\n/**\n * check if layout is needed post layout\n * @returns Boolean\n */\nproto.needsResizeLayout = function() {\n  var size = getSize( this.element );\n  // check that this.size and size are there\n  // IE8 triggers resize on body size change, so they might not be\n  var hasSizes = this.size && size;\n  return hasSizes && size.innerWidth !== this.size.innerWidth;\n};\n\n// -------------------------- methods -------------------------- //\n\n/**\n * add items to Outlayer instance\n * @param {Array or NodeList or Element} elems\n * @returns {Array} items - Outlayer.Items\n**/\nproto.addItems = function( elems ) {\n  var items = this._itemize( elems );\n  // add items to collection\n  if ( items.length ) {\n    this.items = this.items.concat( items );\n  }\n  return items;\n};\n\n/**\n * Layout newly-appended item elements\n * @param {Array or NodeList or Element} elems\n */\nproto.appended = function( elems ) {\n  var items = this.addItems( elems );\n  if ( !items.length ) {\n    return;\n  }\n  // layout and reveal just the new items\n  this.layoutItems( items, true );\n  this.reveal( items );\n};\n\n/**\n * Layout prepended elements\n * @param {Array or NodeList or Element} elems\n */\nproto.prepended = function( elems ) {\n  var items = this._itemize( elems );\n  if ( !items.length ) {\n    return;\n  }\n  // add items to beginning of collection\n  var previousItems = this.items.slice(0);\n  this.items = items.concat( previousItems );\n  // start new layout\n  this._resetLayout();\n  this._manageStamps();\n  // layout new stuff without transition\n  this.layoutItems( items, true );\n  this.reveal( items );\n  // layout previous items\n  this.layoutItems( previousItems );\n};\n\n/**\n * reveal a collection of items\n * @param {Array of Outlayer.Items} items\n */\nproto.reveal = function( items ) {\n  this._emitCompleteOnItems( 'reveal', items );\n  if ( !items || !items.length ) {\n    return;\n  }\n  var stagger = this.updateStagger();\n  items.forEach( function( item, i ) {\n    item.stagger( i * stagger );\n    item.reveal();\n  });\n};\n\n/**\n * hide a collection of items\n * @param {Array of Outlayer.Items} items\n */\nproto.hide = function( items ) {\n  this._emitCompleteOnItems( 'hide', items );\n  if ( !items || !items.length ) {\n    return;\n  }\n  var stagger = this.updateStagger();\n  items.forEach( function( item, i ) {\n    item.stagger( i * stagger );\n    item.hide();\n  });\n};\n\n/**\n * reveal item elements\n * @param {Array}, {Element}, {NodeList} items\n */\nproto.revealItemElements = function( elems ) {\n  var items = this.getItems( elems );\n  this.reveal( items );\n};\n\n/**\n * hide item elements\n * @param {Array}, {Element}, {NodeList} items\n */\nproto.hideItemElements = function( elems ) {\n  var items = this.getItems( elems );\n  this.hide( items );\n};\n\n/**\n * get Outlayer.Item, given an Element\n * @param {Element} elem\n * @param {Function} callback\n * @returns {Outlayer.Item} item\n */\nproto.getItem = function( elem ) {\n  // loop through items to get the one that matches\n  for ( var i=0; i < this.items.length; i++ ) {\n    var item = this.items[i];\n    if ( item.element == elem ) {\n      // return item\n      return item;\n    }\n  }\n};\n\n/**\n * get collection of Outlayer.Items, given Elements\n * @param {Array} elems\n * @returns {Array} items - Outlayer.Items\n */\nproto.getItems = function( elems ) {\n  elems = utils.makeArray( elems );\n  var items = [];\n  elems.forEach( function( elem ) {\n    var item = this.getItem( elem );\n    if ( item ) {\n      items.push( item );\n    }\n  }, this );\n\n  return items;\n};\n\n/**\n * remove element(s) from instance and DOM\n * @param {Array or NodeList or Element} elems\n */\nproto.remove = function( elems ) {\n  var removeItems = this.getItems( elems );\n\n  this._emitCompleteOnItems( 'remove', removeItems );\n\n  // bail if no items to remove\n  if ( !removeItems || !removeItems.length ) {\n    return;\n  }\n\n  removeItems.forEach( function( item ) {\n    item.remove();\n    // remove item from collection\n    utils.removeFrom( this.items, item );\n  }, this );\n};\n\n// ----- destroy ----- //\n\n// remove and disable Outlayer instance\nproto.destroy = function() {\n  // clean up dynamic styles\n  var style = this.element.style;\n  style.height = '';\n  style.position = '';\n  style.width = '';\n  // destroy items\n  this.items.forEach( function( item ) {\n    item.destroy();\n  });\n\n  this.unbindResize();\n\n  var id = this.element.outlayerGUID;\n  delete instances[ id ]; // remove reference to instance by id\n  delete this.element.outlayerGUID;\n  // remove data for jQuery\n  if ( jQuery ) {\n    jQuery.removeData( this.element, this.constructor.namespace );\n  }\n\n};\n\n// -------------------------- data -------------------------- //\n\n/**\n * get Outlayer instance from element\n * @param {Element} elem\n * @returns {Outlayer}\n */\nOutlayer.data = function( elem ) {\n  elem = utils.getQueryElement( elem );\n  var id = elem && elem.outlayerGUID;\n  return id && instances[ id ];\n};\n\n\n// -------------------------- create Outlayer class -------------------------- //\n\n/**\n * create a layout class\n * @param {String} namespace\n */\nOutlayer.create = function( namespace, options ) {\n  // sub-class Outlayer\n  var Layout = subclass( Outlayer );\n  // apply new options and compatOptions\n  Layout.defaults = utils.extend( {}, Outlayer.defaults );\n  utils.extend( Layout.defaults, options );\n  Layout.compatOptions = utils.extend( {}, Outlayer.compatOptions  );\n\n  Layout.namespace = namespace;\n\n  Layout.data = Outlayer.data;\n\n  // sub-class Item\n  Layout.Item = subclass( Item );\n\n  // -------------------------- declarative -------------------------- //\n\n  utils.htmlInit( Layout, namespace );\n\n  // -------------------------- jQuery bridge -------------------------- //\n\n  // make into jQuery plugin\n  if ( jQuery && jQuery.bridget ) {\n    jQuery.bridget( namespace, Layout );\n  }\n\n  return Layout;\n};\n\nfunction subclass( Parent ) {\n  function SubClass() {\n    Parent.apply( this, arguments );\n  }\n\n  SubClass.prototype = Object.create( Parent.prototype );\n  SubClass.prototype.constructor = SubClass;\n\n  return SubClass;\n}\n\n// ----- helpers ----- //\n\n// how many milliseconds are in each unit\nvar msUnits = {\n  ms: 1,\n  s: 1000\n};\n\n// munge time-like parameter into millisecond number\n// '0.4s' -> 40\nfunction getMilliseconds( time ) {\n  if ( typeof time == 'number' ) {\n    return time;\n  }\n  var matches = time.match( /(^\\d*\\.?\\d*)(\\w*)/ );\n  var num = matches && matches[1];\n  var unit = matches && matches[2];\n  if ( !num.length ) {\n    return 0;\n  }\n  num = parseFloat( num );\n  var mult = msUnits[ unit ] || 1;\n  return num * mult;\n}\n\n// ----- fin ----- //\n\n// back in global\nOutlayer.Item = Item;\n\nreturn Outlayer;\n\n}));\n","/**\n * Outlayer Item\n */\n\n( function( window, factory ) {\n  // universal module definition\n  /* jshint strict: false */ /* globals define, module, require */\n  if ( typeof define == 'function' && define.amd ) {\n    // AMD - RequireJS\n    define( [\n        'ev-emitter/ev-emitter',\n        'get-size/get-size'\n      ],\n      factory\n    );\n  } else if ( typeof module == 'object' && module.exports ) {\n    // CommonJS - Browserify, Webpack\n    module.exports = factory(\n      require('ev-emitter'),\n      require('get-size')\n    );\n  } else {\n    // browser global\n    window.Outlayer = {};\n    window.Outlayer.Item = factory(\n      window.EvEmitter,\n      window.getSize\n    );\n  }\n\n}( window, function factory( EvEmitter, getSize ) {\n'use strict';\n\n// ----- helpers ----- //\n\nfunction isEmptyObj( obj ) {\n  for ( var prop in obj ) {\n    return false;\n  }\n  prop = null;\n  return true;\n}\n\n// -------------------------- CSS3 support -------------------------- //\n\n\nvar docElemStyle = document.documentElement.style;\n\nvar transitionProperty = typeof docElemStyle.transition == 'string' ?\n  'transition' : 'WebkitTransition';\nvar transformProperty = typeof docElemStyle.transform == 'string' ?\n  'transform' : 'WebkitTransform';\n\nvar transitionEndEvent = {\n  WebkitTransition: 'webkitTransitionEnd',\n  transition: 'transitionend'\n}[ transitionProperty ];\n\n// cache all vendor properties that could have vendor prefix\nvar vendorProperties = {\n  transform: transformProperty,\n  transition: transitionProperty,\n  transitionDuration: transitionProperty + 'Duration',\n  transitionProperty: transitionProperty + 'Property',\n  transitionDelay: transitionProperty + 'Delay'\n};\n\n// -------------------------- Item -------------------------- //\n\nfunction Item( element, layout ) {\n  if ( !element ) {\n    return;\n  }\n\n  this.element = element;\n  // parent layout class, i.e. Masonry, Isotope, or Packery\n  this.layout = layout;\n  this.position = {\n    x: 0,\n    y: 0\n  };\n\n  this._create();\n}\n\n// inherit EvEmitter\nvar proto = Item.prototype = Object.create( EvEmitter.prototype );\nproto.constructor = Item;\n\nproto._create = function() {\n  // transition objects\n  this._transn = {\n    ingProperties: {},\n    clean: {},\n    onEnd: {}\n  };\n\n  this.css({\n    position: 'absolute'\n  });\n};\n\n// trigger specified handler for event type\nproto.handleEvent = function( event ) {\n  var method = 'on' + event.type;\n  if ( this[ method ] ) {\n    this[ method ]( event );\n  }\n};\n\nproto.getSize = function() {\n  this.size = getSize( this.element );\n};\n\n/**\n * apply CSS styles to element\n * @param {Object} style\n */\nproto.css = function( style ) {\n  var elemStyle = this.element.style;\n\n  for ( var prop in style ) {\n    // use vendor property if available\n    var supportedProp = vendorProperties[ prop ] || prop;\n    elemStyle[ supportedProp ] = style[ prop ];\n  }\n};\n\n // measure position, and sets it\nproto.getPosition = function() {\n  var style = getComputedStyle( this.element );\n  var isOriginLeft = this.layout._getOption('originLeft');\n  var isOriginTop = this.layout._getOption('originTop');\n  var xValue = style[ isOriginLeft ? 'left' : 'right' ];\n  var yValue = style[ isOriginTop ? 'top' : 'bottom' ];\n  var x = parseFloat( xValue );\n  var y = parseFloat( yValue );\n  // convert percent to pixels\n  var layoutSize = this.layout.size;\n  if ( xValue.indexOf('%') != -1 ) {\n    x = ( x / 100 ) * layoutSize.width;\n  }\n  if ( yValue.indexOf('%') != -1 ) {\n    y = ( y / 100 ) * layoutSize.height;\n  }\n  // clean up 'auto' or other non-integer values\n  x = isNaN( x ) ? 0 : x;\n  y = isNaN( y ) ? 0 : y;\n  // remove padding from measurement\n  x -= isOriginLeft ? layoutSize.paddingLeft : layoutSize.paddingRight;\n  y -= isOriginTop ? layoutSize.paddingTop : layoutSize.paddingBottom;\n\n  this.position.x = x;\n  this.position.y = y;\n};\n\n// set settled position, apply padding\nproto.layoutPosition = function() {\n  var layoutSize = this.layout.size;\n  var style = {};\n  var isOriginLeft = this.layout._getOption('originLeft');\n  var isOriginTop = this.layout._getOption('originTop');\n\n  // x\n  var xPadding = isOriginLeft ? 'paddingLeft' : 'paddingRight';\n  var xProperty = isOriginLeft ? 'left' : 'right';\n  var xResetProperty = isOriginLeft ? 'right' : 'left';\n\n  var x = this.position.x + layoutSize[ xPadding ];\n  // set in percentage or pixels\n  style[ xProperty ] = this.getXValue( x );\n  // reset other property\n  style[ xResetProperty ] = '';\n\n  // y\n  var yPadding = isOriginTop ? 'paddingTop' : 'paddingBottom';\n  var yProperty = isOriginTop ? 'top' : 'bottom';\n  var yResetProperty = isOriginTop ? 'bottom' : 'top';\n\n  var y = this.position.y + layoutSize[ yPadding ];\n  // set in percentage or pixels\n  style[ yProperty ] = this.getYValue( y );\n  // reset other property\n  style[ yResetProperty ] = '';\n\n  this.css( style );\n  this.emitEvent( 'layout', [ this ] );\n};\n\nproto.getXValue = function( x ) {\n  var isHorizontal = this.layout._getOption('horizontal');\n  return this.layout.options.percentPosition && !isHorizontal ?\n    ( ( x / this.layout.size.width ) * 100 ) + '%' : x + 'px';\n};\n\nproto.getYValue = function( y ) {\n  var isHorizontal = this.layout._getOption('horizontal');\n  return this.layout.options.percentPosition && isHorizontal ?\n    ( ( y / this.layout.size.height ) * 100 ) + '%' : y + 'px';\n};\n\nproto._transitionTo = function( x, y ) {\n  this.getPosition();\n  // get current x & y from top/left\n  var curX = this.position.x;\n  var curY = this.position.y;\n\n  var didNotMove = x == this.position.x && y == this.position.y;\n\n  // save end position\n  this.setPosition( x, y );\n\n  // if did not move and not transitioning, just go to layout\n  if ( didNotMove && !this.isTransitioning ) {\n    this.layoutPosition();\n    return;\n  }\n\n  var transX = x - curX;\n  var transY = y - curY;\n  var transitionStyle = {};\n  transitionStyle.transform = this.getTranslate( transX, transY );\n\n  this.transition({\n    to: transitionStyle,\n    onTransitionEnd: {\n      transform: this.layoutPosition\n    },\n    isCleaning: true\n  });\n};\n\nproto.getTranslate = function( x, y ) {\n  // flip cooridinates if origin on right or bottom\n  var isOriginLeft = this.layout._getOption('originLeft');\n  var isOriginTop = this.layout._getOption('originTop');\n  x = isOriginLeft ? x : -x;\n  y = isOriginTop ? y : -y;\n  return 'translate3d(' + x + 'px, ' + y + 'px, 0)';\n};\n\n// non transition + transform support\nproto.goTo = function( x, y ) {\n  this.setPosition( x, y );\n  this.layoutPosition();\n};\n\nproto.moveTo = proto._transitionTo;\n\nproto.setPosition = function( x, y ) {\n  this.position.x = parseFloat( x );\n  this.position.y = parseFloat( y );\n};\n\n// ----- transition ----- //\n\n/**\n * @param {Object} style - CSS\n * @param {Function} onTransitionEnd\n */\n\n// non transition, just trigger callback\nproto._nonTransition = function( args ) {\n  this.css( args.to );\n  if ( args.isCleaning ) {\n    this._removeStyles( args.to );\n  }\n  for ( var prop in args.onTransitionEnd ) {\n    args.onTransitionEnd[ prop ].call( this );\n  }\n};\n\n/**\n * proper transition\n * @param {Object} args - arguments\n *   @param {Object} to - style to transition to\n *   @param {Object} from - style to start transition from\n *   @param {Boolean} isCleaning - removes transition styles after transition\n *   @param {Function} onTransitionEnd - callback\n */\nproto.transition = function( args ) {\n  // redirect to nonTransition if no transition duration\n  if ( !parseFloat( this.layout.options.transitionDuration ) ) {\n    this._nonTransition( args );\n    return;\n  }\n\n  var _transition = this._transn;\n  // keep track of onTransitionEnd callback by css property\n  for ( var prop in args.onTransitionEnd ) {\n    _transition.onEnd[ prop ] = args.onTransitionEnd[ prop ];\n  }\n  // keep track of properties that are transitioning\n  for ( prop in args.to ) {\n    _transition.ingProperties[ prop ] = true;\n    // keep track of properties to clean up when transition is done\n    if ( args.isCleaning ) {\n      _transition.clean[ prop ] = true;\n    }\n  }\n\n  // set from styles\n  if ( args.from ) {\n    this.css( args.from );\n    // force redraw. http://blog.alexmaccaw.com/css-transitions\n    var h = this.element.offsetHeight;\n    // hack for JSHint to hush about unused var\n    h = null;\n  }\n  // enable transition\n  this.enableTransition( args.to );\n  // set styles that are transitioning\n  this.css( args.to );\n\n  this.isTransitioning = true;\n\n};\n\n// dash before all cap letters, including first for\n// WebkitTransform => -webkit-transform\nfunction toDashedAll( str ) {\n  return str.replace( /([A-Z])/g, function( $1 ) {\n    return '-' + $1.toLowerCase();\n  });\n}\n\nvar transitionProps = 'opacity,' + toDashedAll( transformProperty );\n\nproto.enableTransition = function(/* style */) {\n  // HACK changing transitionProperty during a transition\n  // will cause transition to jump\n  if ( this.isTransitioning ) {\n    return;\n  }\n\n  // make `transition: foo, bar, baz` from style object\n  // HACK un-comment this when enableTransition can work\n  // while a transition is happening\n  // var transitionValues = [];\n  // for ( var prop in style ) {\n  //   // dash-ify camelCased properties like WebkitTransition\n  //   prop = vendorProperties[ prop ] || prop;\n  //   transitionValues.push( toDashedAll( prop ) );\n  // }\n  // munge number to millisecond, to match stagger\n  var duration = this.layout.options.transitionDuration;\n  duration = typeof duration == 'number' ? duration + 'ms' : duration;\n  // enable transition styles\n  this.css({\n    transitionProperty: transitionProps,\n    transitionDuration: duration,\n    transitionDelay: this.staggerDelay || 0\n  });\n  // listen for transition end event\n  this.element.addEventListener( transitionEndEvent, this, false );\n};\n\n// ----- events ----- //\n\nproto.onwebkitTransitionEnd = function( event ) {\n  this.ontransitionend( event );\n};\n\nproto.onotransitionend = function( event ) {\n  this.ontransitionend( event );\n};\n\n// properties that I munge to make my life easier\nvar dashedVendorProperties = {\n  '-webkit-transform': 'transform'\n};\n\nproto.ontransitionend = function( event ) {\n  // disregard bubbled events from children\n  if ( event.target !== this.element ) {\n    return;\n  }\n  var _transition = this._transn;\n  // get property name of transitioned property, convert to prefix-free\n  var propertyName = dashedVendorProperties[ event.propertyName ] || event.propertyName;\n\n  // remove property that has completed transitioning\n  delete _transition.ingProperties[ propertyName ];\n  // check if any properties are still transitioning\n  if ( isEmptyObj( _transition.ingProperties ) ) {\n    // all properties have completed transitioning\n    this.disableTransition();\n  }\n  // clean style\n  if ( propertyName in _transition.clean ) {\n    // clean up style\n    this.element.style[ event.propertyName ] = '';\n    delete _transition.clean[ propertyName ];\n  }\n  // trigger onTransitionEnd callback\n  if ( propertyName in _transition.onEnd ) {\n    var onTransitionEnd = _transition.onEnd[ propertyName ];\n    onTransitionEnd.call( this );\n    delete _transition.onEnd[ propertyName ];\n  }\n\n  this.emitEvent( 'transitionEnd', [ this ] );\n};\n\nproto.disableTransition = function() {\n  this.removeTransitionStyles();\n  this.element.removeEventListener( transitionEndEvent, this, false );\n  this.isTransitioning = false;\n};\n\n/**\n * removes style property from element\n * @param {Object} style\n**/\nproto._removeStyles = function( style ) {\n  // clean up transition styles\n  var cleanStyle = {};\n  for ( var prop in style ) {\n    cleanStyle[ prop ] = '';\n  }\n  this.css( cleanStyle );\n};\n\nvar cleanTransitionStyle = {\n  transitionProperty: '',\n  transitionDuration: '',\n  transitionDelay: ''\n};\n\nproto.removeTransitionStyles = function() {\n  // remove transition\n  this.css( cleanTransitionStyle );\n};\n\n// ----- stagger ----- //\n\nproto.stagger = function( delay ) {\n  delay = isNaN( delay ) ? 0 : delay;\n  this.staggerDelay = delay + 'ms';\n};\n\n// ----- show/hide/remove ----- //\n\n// remove element from DOM\nproto.removeElem = function() {\n  this.element.parentNode.removeChild( this.element );\n  // remove display: none\n  this.css({ display: '' });\n  this.emitEvent( 'remove', [ this ] );\n};\n\nproto.remove = function() {\n  // just remove element if no transition support or no transition\n  if ( !transitionProperty || !parseFloat( this.layout.options.transitionDuration ) ) {\n    this.removeElem();\n    return;\n  }\n\n  // start transition\n  this.once( 'transitionEnd', function() {\n    this.removeElem();\n  });\n  this.hide();\n};\n\nproto.reveal = function() {\n  delete this.isHidden;\n  // remove display: none\n  this.css({ display: '' });\n\n  var options = this.layout.options;\n\n  var onTransitionEnd = {};\n  var transitionEndProperty = this.getHideRevealTransitionEndProperty('visibleStyle');\n  onTransitionEnd[ transitionEndProperty ] = this.onRevealTransitionEnd;\n\n  this.transition({\n    from: options.hiddenStyle,\n    to: options.visibleStyle,\n    isCleaning: true,\n    onTransitionEnd: onTransitionEnd\n  });\n};\n\nproto.onRevealTransitionEnd = function() {\n  // check if still visible\n  // during transition, item may have been hidden\n  if ( !this.isHidden ) {\n    this.emitEvent('reveal');\n  }\n};\n\n/**\n * get style property use for hide/reveal transition end\n * @param {String} styleProperty - hiddenStyle/visibleStyle\n * @returns {String}\n */\nproto.getHideRevealTransitionEndProperty = function( styleProperty ) {\n  var optionStyle = this.layout.options[ styleProperty ];\n  // use opacity\n  if ( optionStyle.opacity ) {\n    return 'opacity';\n  }\n  // get first property\n  for ( var prop in optionStyle ) {\n    return prop;\n  }\n};\n\nproto.hide = function() {\n  // set flag\n  this.isHidden = true;\n  // remove display: none\n  this.css({ display: '' });\n\n  var options = this.layout.options;\n\n  var onTransitionEnd = {};\n  var transitionEndProperty = this.getHideRevealTransitionEndProperty('hiddenStyle');\n  onTransitionEnd[ transitionEndProperty ] = this.onHideTransitionEnd;\n\n  this.transition({\n    from: options.visibleStyle,\n    to: options.hiddenStyle,\n    // keep hidden stuff hidden\n    isCleaning: true,\n    onTransitionEnd: onTransitionEnd\n  });\n};\n\nproto.onHideTransitionEnd = function() {\n  // check if still hidden\n  // during transition, item may have been un-hidden\n  if ( this.isHidden ) {\n    this.css({ display: 'none' });\n    this.emitEvent('hide');\n  }\n};\n\nproto.destroy = function() {\n  this.css({\n    position: '',\n    left: '',\n    right: '',\n    top: '',\n    bottom: '',\n    transition: '',\n    transform: ''\n  });\n};\n\nreturn Item;\n\n}));\n","\n /*! \n  * portal-vue © Thorsten Lünborg, 2019 \n  * \n  * Version: 2.1.7\n  * \n  * LICENCE: MIT \n  * \n  * https://github.com/linusborg/portal-vue\n  * \n */\n\n'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nfunction _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }\n\nvar Vue = _interopDefault(require('vue'));\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 _toConsumableArray(arr) {\n  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n    return arr2;\n  }\n}\n\nfunction _iterableToArray(iter) {\n  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\n\nfunction _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\n\nvar inBrowser = typeof window !== 'undefined';\nfunction freeze(item) {\n  if (Array.isArray(item) || _typeof(item) === 'object') {\n    return Object.freeze(item);\n  }\n\n  return item;\n}\nfunction combinePassengers(transports) {\n  var slotProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  return transports.reduce(function (passengers, transport) {\n    var temp = transport.passengers[0];\n    var newPassengers = typeof temp === 'function' ? temp(slotProps) : transport.passengers;\n    return passengers.concat(newPassengers);\n  }, []);\n}\nfunction stableSort(array, compareFn) {\n  return array.map(function (v, idx) {\n    return [idx, v];\n  }).sort(function (a, b) {\n    return compareFn(a[1], b[1]) || a[0] - b[0];\n  }).map(function (c) {\n    return c[1];\n  });\n}\nfunction pick(obj, keys) {\n  return keys.reduce(function (acc, key) {\n    if (obj.hasOwnProperty(key)) {\n      acc[key] = obj[key];\n    }\n\n    return acc;\n  }, {});\n}\n\nvar transports = {};\nvar targets = {};\nvar sources = {};\nvar Wormhole = Vue.extend({\n  data: function data() {\n    return {\n      transports: transports,\n      targets: targets,\n      sources: sources,\n      trackInstances: inBrowser\n    };\n  },\n  methods: {\n    open: function open(transport) {\n      if (!inBrowser) return;\n      var to = transport.to,\n          from = transport.from,\n          passengers = transport.passengers,\n          _transport$order = transport.order,\n          order = _transport$order === void 0 ? Infinity : _transport$order;\n      if (!to || !from || !passengers) return;\n      var newTransport = {\n        to: to,\n        from: from,\n        passengers: freeze(passengers),\n        order: order\n      };\n      var keys = Object.keys(this.transports);\n\n      if (keys.indexOf(to) === -1) {\n        Vue.set(this.transports, to, []);\n      }\n\n      var currentIndex = this.$_getTransportIndex(newTransport); // Copying the array here so that the PortalTarget change event will actually contain two distinct arrays\n\n      var newTransports = this.transports[to].slice(0);\n\n      if (currentIndex === -1) {\n        newTransports.push(newTransport);\n      } else {\n        newTransports[currentIndex] = newTransport;\n      }\n\n      this.transports[to] = stableSort(newTransports, function (a, b) {\n        return a.order - b.order;\n      });\n    },\n    close: function close(transport) {\n      var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n      var to = transport.to,\n          from = transport.from;\n      if (!to || !from && force === false) return;\n\n      if (!this.transports[to]) {\n        return;\n      }\n\n      if (force) {\n        this.transports[to] = [];\n      } else {\n        var index = this.$_getTransportIndex(transport);\n\n        if (index >= 0) {\n          // Copying the array here so that the PortalTarget change event will actually contain two distinct arrays\n          var newTransports = this.transports[to].slice(0);\n          newTransports.splice(index, 1);\n          this.transports[to] = newTransports;\n        }\n      }\n    },\n    registerTarget: function registerTarget(target, vm, force) {\n      if (!inBrowser) return;\n\n      if (this.trackInstances && !force && this.targets[target]) {\n        console.warn(\"[portal-vue]: Target \".concat(target, \" already exists\"));\n      }\n\n      this.$set(this.targets, target, Object.freeze([vm]));\n    },\n    unregisterTarget: function unregisterTarget(target) {\n      this.$delete(this.targets, target);\n    },\n    registerSource: function registerSource(source, vm, force) {\n      if (!inBrowser) return;\n\n      if (this.trackInstances && !force && this.sources[source]) {\n        console.warn(\"[portal-vue]: source \".concat(source, \" already exists\"));\n      }\n\n      this.$set(this.sources, source, Object.freeze([vm]));\n    },\n    unregisterSource: function unregisterSource(source) {\n      this.$delete(this.sources, source);\n    },\n    hasTarget: function hasTarget(to) {\n      return !!(this.targets[to] && this.targets[to][0]);\n    },\n    hasSource: function hasSource(to) {\n      return !!(this.sources[to] && this.sources[to][0]);\n    },\n    hasContentFor: function hasContentFor(to) {\n      return !!this.transports[to] && !!this.transports[to].length;\n    },\n    // Internal\n    $_getTransportIndex: function $_getTransportIndex(_ref) {\n      var to = _ref.to,\n          from = _ref.from;\n\n      for (var i in this.transports[to]) {\n        if (this.transports[to][i].from === from) {\n          return +i;\n        }\n      }\n\n      return -1;\n    }\n  }\n});\nvar wormhole = new Wormhole(transports);\n\nvar _id = 1;\nvar Portal = Vue.extend({\n  name: 'portal',\n  props: {\n    disabled: {\n      type: Boolean\n    },\n    name: {\n      type: String,\n      default: function _default() {\n        return String(_id++);\n      }\n    },\n    order: {\n      type: Number,\n      default: 0\n    },\n    slim: {\n      type: Boolean\n    },\n    slotProps: {\n      type: Object,\n      default: function _default() {\n        return {};\n      }\n    },\n    tag: {\n      type: String,\n      default: 'DIV'\n    },\n    to: {\n      type: String,\n      default: function _default() {\n        return String(Math.round(Math.random() * 10000000));\n      }\n    }\n  },\n  created: function created() {\n    var _this = this;\n\n    this.$nextTick(function () {\n      wormhole.registerSource(_this.name, _this);\n    });\n  },\n  mounted: function mounted() {\n    if (!this.disabled) {\n      this.sendUpdate();\n    }\n  },\n  updated: function updated() {\n    if (this.disabled) {\n      this.clear();\n    } else {\n      this.sendUpdate();\n    }\n  },\n  beforeDestroy: function beforeDestroy() {\n    wormhole.unregisterSource(this.name);\n    this.clear();\n  },\n  watch: {\n    to: function to(newValue, oldValue) {\n      oldValue && oldValue !== newValue && this.clear(oldValue);\n      this.sendUpdate();\n    }\n  },\n  methods: {\n    clear: function clear(target) {\n      var closer = {\n        from: this.name,\n        to: target || this.to\n      };\n      wormhole.close(closer);\n    },\n    normalizeSlots: function normalizeSlots() {\n      return this.$scopedSlots.default ? [this.$scopedSlots.default] : this.$slots.default;\n    },\n    normalizeOwnChildren: function normalizeOwnChildren(children) {\n      return typeof children === 'function' ? children(this.slotProps) : children;\n    },\n    sendUpdate: function sendUpdate() {\n      var slotContent = this.normalizeSlots();\n\n      if (slotContent) {\n        var transport = {\n          from: this.name,\n          to: this.to,\n          passengers: _toConsumableArray(slotContent),\n          order: this.order\n        };\n        wormhole.open(transport);\n      } else {\n        this.clear();\n      }\n    }\n  },\n  render: function render(h) {\n    var children = this.$slots.default || this.$scopedSlots.default || [];\n    var Tag = this.tag;\n\n    if (children && this.disabled) {\n      return children.length <= 1 && this.slim ? this.normalizeOwnChildren(children)[0] : h(Tag, [this.normalizeOwnChildren(children)]);\n    } else {\n      return this.slim ? h() : h(Tag, {\n        class: {\n          'v-portal': true\n        },\n        style: {\n          display: 'none'\n        },\n        key: 'v-portal-placeholder'\n      });\n    }\n  }\n});\n\nvar PortalTarget = Vue.extend({\n  name: 'portalTarget',\n  props: {\n    multiple: {\n      type: Boolean,\n      default: false\n    },\n    name: {\n      type: String,\n      required: true\n    },\n    slim: {\n      type: Boolean,\n      default: false\n    },\n    slotProps: {\n      type: Object,\n      default: function _default() {\n        return {};\n      }\n    },\n    tag: {\n      type: String,\n      default: 'div'\n    },\n    transition: {\n      type: [String, Object, Function]\n    }\n  },\n  data: function data() {\n    return {\n      transports: wormhole.transports,\n      firstRender: true\n    };\n  },\n  created: function created() {\n    var _this = this;\n\n    this.$nextTick(function () {\n      wormhole.registerTarget(_this.name, _this);\n    });\n  },\n  watch: {\n    ownTransports: function ownTransports() {\n      this.$emit('change', this.children().length > 0);\n    },\n    name: function name(newVal, oldVal) {\n      /**\r\n       * TODO\r\n       * This should warn as well ...\r\n       */\n      wormhole.unregisterTarget(oldVal);\n      wormhole.registerTarget(newVal, this);\n    }\n  },\n  mounted: function mounted() {\n    var _this2 = this;\n\n    if (this.transition) {\n      this.$nextTick(function () {\n        // only when we have a transition, because it causes a re-render\n        _this2.firstRender = false;\n      });\n    }\n  },\n  beforeDestroy: function beforeDestroy() {\n    wormhole.unregisterTarget(this.name);\n  },\n  computed: {\n    ownTransports: function ownTransports() {\n      var transports = this.transports[this.name] || [];\n\n      if (this.multiple) {\n        return transports;\n      }\n\n      return transports.length === 0 ? [] : [transports[transports.length - 1]];\n    },\n    passengers: function passengers() {\n      return combinePassengers(this.ownTransports, this.slotProps);\n    }\n  },\n  methods: {\n    // can't be a computed prop because it has to \"react\" to $slot changes.\n    children: function children() {\n      return this.passengers.length !== 0 ? this.passengers : this.$scopedSlots.default ? this.$scopedSlots.default(this.slotProps) : this.$slots.default || [];\n    },\n    // can't be a computed prop because it has to \"react\" to this.children().\n    noWrapper: function noWrapper() {\n      var noWrapper = this.slim && !this.transition;\n\n      if (noWrapper && this.children().length > 1) {\n        console.warn('[portal-vue]: PortalTarget with `slim` option received more than one child element.');\n      }\n\n      return noWrapper;\n    }\n  },\n  render: function render(h) {\n    var noWrapper = this.noWrapper();\n    var children = this.children();\n    var Tag = this.transition || this.tag;\n    return noWrapper ? children[0] : this.slim && !Tag ? h() : h(Tag, {\n      props: {\n        // if we have a transition component, pass the tag if it exists\n        tag: this.transition && this.tag ? this.tag : undefined\n      },\n      class: {\n        'vue-portal-target': true\n      }\n    }, children);\n  }\n});\n\nvar _id$1 = 0;\nvar portalProps = ['disabled', 'name', 'order', 'slim', 'slotProps', 'tag', 'to'];\nvar targetProps = ['multiple', 'transition'];\nvar MountingPortal = Vue.extend({\n  name: 'MountingPortal',\n  inheritAttrs: false,\n  props: {\n    append: {\n      type: [Boolean, String]\n    },\n    bail: {\n      type: Boolean\n    },\n    mountTo: {\n      type: String,\n      required: true\n    },\n    // Portal\n    disabled: {\n      type: Boolean\n    },\n    // name for the portal\n    name: {\n      type: String,\n      default: function _default() {\n        return 'mounted_' + String(_id$1++);\n      }\n    },\n    order: {\n      type: Number,\n      default: 0\n    },\n    slim: {\n      type: Boolean\n    },\n    slotProps: {\n      type: Object,\n      default: function _default() {\n        return {};\n      }\n    },\n    tag: {\n      type: String,\n      default: 'DIV'\n    },\n    // name for the target\n    to: {\n      type: String,\n      default: function _default() {\n        return String(Math.round(Math.random() * 10000000));\n      }\n    },\n    // Target\n    multiple: {\n      type: Boolean,\n      default: false\n    },\n    targetSlim: {\n      type: Boolean\n    },\n    targetSlotProps: {\n      type: Object,\n      default: function _default() {\n        return {};\n      }\n    },\n    targetTag: {\n      type: String,\n      default: 'div'\n    },\n    transition: {\n      type: [String, Object, Function]\n    }\n  },\n  created: function created() {\n    if (typeof document === 'undefined') return;\n    var el = document.querySelector(this.mountTo);\n\n    if (!el) {\n      console.error(\"[portal-vue]: Mount Point '\".concat(this.mountTo, \"' not found in document\"));\n      return;\n    }\n\n    var props = this.$props; // Target already exists\n\n    if (wormhole.targets[props.name]) {\n      if (props.bail) {\n        console.warn(\"[portal-vue]: Target \".concat(props.name, \" is already mounted.\\n        Aborting because 'bail: true' is set\"));\n      } else {\n        this.portalTarget = wormhole.targets[props.name];\n      }\n\n      return;\n    }\n\n    var append = props.append;\n\n    if (append) {\n      var type = typeof append === 'string' ? append : 'DIV';\n      var mountEl = document.createElement(type);\n      el.appendChild(mountEl);\n      el = mountEl;\n    } // get props for target from $props\n    // we have to rename a few of them\n\n\n    var _props = pick(this.$props, targetProps);\n\n    _props.slim = this.targetSlim;\n    _props.tag = this.targetTag;\n    _props.slotProps = this.targetSlotProps;\n    _props.name = this.to;\n    this.portalTarget = new PortalTarget({\n      el: el,\n      parent: this.$parent || this,\n      propsData: _props\n    });\n  },\n  beforeDestroy: function beforeDestroy() {\n    var target = this.portalTarget;\n\n    if (this.append) {\n      var el = target.$el;\n      el.parentNode.removeChild(el);\n    }\n\n    target.$destroy();\n  },\n  render: function render(h) {\n    if (!this.portalTarget) {\n      console.warn(\"[portal-vue] Target wasn't mounted\");\n      return h();\n    } // if there's no \"manual\" scoped slot, so we create a <Portal> ourselves\n\n\n    if (!this.$scopedSlots.manual) {\n      var props = pick(this.$props, portalProps);\n      return h(Portal, {\n        props: props,\n        attrs: this.$attrs,\n        on: this.$listeners,\n        scopedSlots: this.$scopedSlots\n      }, this.$slots.default);\n    } // else, we render the scoped slot\n\n\n    var content = this.$scopedSlots.manual({\n      to: this.to\n    }); // if user used <template> for the scoped slot\n    // content will be an array\n\n    if (Array.isArray(content)) {\n      content = content[0];\n    }\n\n    if (!content) return h();\n    return content;\n  }\n});\n\nfunction install(Vue$$1) {\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  Vue$$1.component(options.portalName || 'Portal', Portal);\n  Vue$$1.component(options.portalTargetName || 'PortalTarget', PortalTarget);\n  Vue$$1.component(options.MountingPortalName || 'MountingPortal', MountingPortal);\n}\n\nvar index = {\n  install: install\n};\n\nexports.default = index;\nexports.Portal = Portal;\nexports.PortalTarget = PortalTarget;\nexports.MountingPortal = MountingPortal;\nexports.Wormhole = wormhole;\n//# sourceMappingURL=portal-vue.common.js.map\n","/**!\n * @fileOverview Kickass library to create and place poppers near their reference elements.\n * @version 1.16.1\n * @license\n * Copyright (c) 2016 Federico Zivolo and contributors\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\nvar isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && typeof navigator !== 'undefined';\n\nvar timeoutDuration = function () {\n  var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];\n  for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {\n    if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {\n      return 1;\n    }\n  }\n  return 0;\n}();\n\nfunction microtaskDebounce(fn) {\n  var called = false;\n  return function () {\n    if (called) {\n      return;\n    }\n    called = true;\n    window.Promise.resolve().then(function () {\n      called = false;\n      fn();\n    });\n  };\n}\n\nfunction taskDebounce(fn) {\n  var scheduled = false;\n  return function () {\n    if (!scheduled) {\n      scheduled = true;\n      setTimeout(function () {\n        scheduled = false;\n        fn();\n      }, timeoutDuration);\n    }\n  };\n}\n\nvar supportsMicroTasks = isBrowser && window.Promise;\n\n/**\n* Create a debounced version of a method, that's asynchronously deferred\n* but called in the minimum time possible.\n*\n* @method\n* @memberof Popper.Utils\n* @argument {Function} fn\n* @returns {Function}\n*/\nvar debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;\n\n/**\n * Check if the given variable is a function\n * @method\n * @memberof Popper.Utils\n * @argument {Any} functionToCheck - variable to check\n * @returns {Boolean} answer to: is a function?\n */\nfunction isFunction(functionToCheck) {\n  var getType = {};\n  return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';\n}\n\n/**\n * Get CSS computed property of the given element\n * @method\n * @memberof Popper.Utils\n * @argument {Eement} element\n * @argument {String} property\n */\nfunction getStyleComputedProperty(element, property) {\n  if (element.nodeType !== 1) {\n    return [];\n  }\n  // NOTE: 1 DOM access here\n  var window = element.ownerDocument.defaultView;\n  var css = window.getComputedStyle(element, null);\n  return property ? css[property] : css;\n}\n\n/**\n * Returns the parentNode or the host of the element\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Element} parent\n */\nfunction getParentNode(element) {\n  if (element.nodeName === 'HTML') {\n    return element;\n  }\n  return element.parentNode || element.host;\n}\n\n/**\n * Returns the scrolling parent of the given element\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Element} scroll parent\n */\nfunction getScrollParent(element) {\n  // Return body, `getScroll` will take care to get the correct `scrollTop` from it\n  if (!element) {\n    return document.body;\n  }\n\n  switch (element.nodeName) {\n    case 'HTML':\n    case 'BODY':\n      return element.ownerDocument.body;\n    case '#document':\n      return element.body;\n  }\n\n  // Firefox want us to check `-x` and `-y` variations as well\n\n  var _getStyleComputedProp = getStyleComputedProperty(element),\n      overflow = _getStyleComputedProp.overflow,\n      overflowX = _getStyleComputedProp.overflowX,\n      overflowY = _getStyleComputedProp.overflowY;\n\n  if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {\n    return element;\n  }\n\n  return getScrollParent(getParentNode(element));\n}\n\n/**\n * Returns the reference node of the reference object, or the reference object itself.\n * @method\n * @memberof Popper.Utils\n * @param {Element|Object} reference - the reference element (the popper will be relative to this)\n * @returns {Element} parent\n */\nfunction getReferenceNode(reference) {\n  return reference && reference.referenceNode ? reference.referenceNode : reference;\n}\n\nvar isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);\nvar isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);\n\n/**\n * Determines if the browser is Internet Explorer\n * @method\n * @memberof Popper.Utils\n * @param {Number} version to check\n * @returns {Boolean} isIE\n */\nfunction isIE(version) {\n  if (version === 11) {\n    return isIE11;\n  }\n  if (version === 10) {\n    return isIE10;\n  }\n  return isIE11 || isIE10;\n}\n\n/**\n * Returns the offset parent of the given element\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Element} offset parent\n */\nfunction getOffsetParent(element) {\n  if (!element) {\n    return document.documentElement;\n  }\n\n  var noOffsetParent = isIE(10) ? document.body : null;\n\n  // NOTE: 1 DOM access here\n  var offsetParent = element.offsetParent || null;\n  // Skip hidden elements which don't have an offsetParent\n  while (offsetParent === noOffsetParent && element.nextElementSibling) {\n    offsetParent = (element = element.nextElementSibling).offsetParent;\n  }\n\n  var nodeName = offsetParent && offsetParent.nodeName;\n\n  if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {\n    return element ? element.ownerDocument.documentElement : document.documentElement;\n  }\n\n  // .offsetParent will return the closest TH, TD or TABLE in case\n  // no offsetParent is present, I hate this job...\n  if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {\n    return getOffsetParent(offsetParent);\n  }\n\n  return offsetParent;\n}\n\nfunction isOffsetContainer(element) {\n  var nodeName = element.nodeName;\n\n  if (nodeName === 'BODY') {\n    return false;\n  }\n  return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;\n}\n\n/**\n * Finds the root node (document, shadowDOM root) of the given element\n * @method\n * @memberof Popper.Utils\n * @argument {Element} node\n * @returns {Element} root node\n */\nfunction getRoot(node) {\n  if (node.parentNode !== null) {\n    return getRoot(node.parentNode);\n  }\n\n  return node;\n}\n\n/**\n * Finds the offset parent common to the two provided nodes\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element1\n * @argument {Element} element2\n * @returns {Element} common offset parent\n */\nfunction findCommonOffsetParent(element1, element2) {\n  // This check is needed to avoid errors in case one of the elements isn't defined for any reason\n  if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {\n    return document.documentElement;\n  }\n\n  // Here we make sure to give as \"start\" the element that comes first in the DOM\n  var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;\n  var start = order ? element1 : element2;\n  var end = order ? element2 : element1;\n\n  // Get common ancestor container\n  var range = document.createRange();\n  range.setStart(start, 0);\n  range.setEnd(end, 0);\n  var commonAncestorContainer = range.commonAncestorContainer;\n\n  // Both nodes are inside #document\n\n  if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {\n    if (isOffsetContainer(commonAncestorContainer)) {\n      return commonAncestorContainer;\n    }\n\n    return getOffsetParent(commonAncestorContainer);\n  }\n\n  // one of the nodes is inside shadowDOM, find which one\n  var element1root = getRoot(element1);\n  if (element1root.host) {\n    return findCommonOffsetParent(element1root.host, element2);\n  } else {\n    return findCommonOffsetParent(element1, getRoot(element2).host);\n  }\n}\n\n/**\n * Gets the scroll value of the given element in the given side (top and left)\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @argument {String} side `top` or `left`\n * @returns {number} amount of scrolled pixels\n */\nfunction getScroll(element) {\n  var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';\n\n  var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';\n  var nodeName = element.nodeName;\n\n  if (nodeName === 'BODY' || nodeName === 'HTML') {\n    var html = element.ownerDocument.documentElement;\n    var scrollingElement = element.ownerDocument.scrollingElement || html;\n    return scrollingElement[upperSide];\n  }\n\n  return element[upperSide];\n}\n\n/*\n * Sum or subtract the element scroll values (left and top) from a given rect object\n * @method\n * @memberof Popper.Utils\n * @param {Object} rect - Rect object you want to change\n * @param {HTMLElement} element - The element from the function reads the scroll values\n * @param {Boolean} subtract - set to true if you want to subtract the scroll values\n * @return {Object} rect - The modifier rect object\n */\nfunction includeScroll(rect, element) {\n  var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n  var scrollTop = getScroll(element, 'top');\n  var scrollLeft = getScroll(element, 'left');\n  var modifier = subtract ? -1 : 1;\n  rect.top += scrollTop * modifier;\n  rect.bottom += scrollTop * modifier;\n  rect.left += scrollLeft * modifier;\n  rect.right += scrollLeft * modifier;\n  return rect;\n}\n\n/*\n * Helper to detect borders of a given element\n * @method\n * @memberof Popper.Utils\n * @param {CSSStyleDeclaration} styles\n * Result of `getStyleComputedProperty` on the given element\n * @param {String} axis - `x` or `y`\n * @return {number} borders - The borders size of the given axis\n */\n\nfunction getBordersSize(styles, axis) {\n  var sideA = axis === 'x' ? 'Left' : 'Top';\n  var sideB = sideA === 'Left' ? 'Right' : 'Bottom';\n\n  return parseFloat(styles['border' + sideA + 'Width']) + parseFloat(styles['border' + sideB + 'Width']);\n}\n\nfunction getSize(axis, body, html, computedStyle) {\n  return Math.max(body['offset' + axis], body['scroll' + axis], html['client' + axis], html['offset' + axis], html['scroll' + axis], isIE(10) ? parseInt(html['offset' + axis]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Top' : 'Left')]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Bottom' : 'Right')]) : 0);\n}\n\nfunction getWindowSizes(document) {\n  var body = document.body;\n  var html = document.documentElement;\n  var computedStyle = isIE(10) && getComputedStyle(html);\n\n  return {\n    height: getSize('Height', body, html, computedStyle),\n    width: getSize('Width', body, html, computedStyle)\n  };\n}\n\nvar classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\nvar createClass = function () {\n  function 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\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\n\n\n\n\nvar defineProperty = function (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\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\n/**\n * Given element offsets, generate an output similar to getBoundingClientRect\n * @method\n * @memberof Popper.Utils\n * @argument {Object} offsets\n * @returns {Object} ClientRect like output\n */\nfunction getClientRect(offsets) {\n  return _extends({}, offsets, {\n    right: offsets.left + offsets.width,\n    bottom: offsets.top + offsets.height\n  });\n}\n\n/**\n * Get bounding client rect of given element\n * @method\n * @memberof Popper.Utils\n * @param {HTMLElement} element\n * @return {Object} client rect\n */\nfunction getBoundingClientRect(element) {\n  var rect = {};\n\n  // IE10 10 FIX: Please, don't ask, the element isn't\n  // considered in DOM in some circumstances...\n  // This isn't reproducible in IE10 compatibility mode of IE11\n  try {\n    if (isIE(10)) {\n      rect = element.getBoundingClientRect();\n      var scrollTop = getScroll(element, 'top');\n      var scrollLeft = getScroll(element, 'left');\n      rect.top += scrollTop;\n      rect.left += scrollLeft;\n      rect.bottom += scrollTop;\n      rect.right += scrollLeft;\n    } else {\n      rect = element.getBoundingClientRect();\n    }\n  } catch (e) {}\n\n  var result = {\n    left: rect.left,\n    top: rect.top,\n    width: rect.right - rect.left,\n    height: rect.bottom - rect.top\n  };\n\n  // subtract scrollbar size from sizes\n  var sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {};\n  var width = sizes.width || element.clientWidth || result.width;\n  var height = sizes.height || element.clientHeight || result.height;\n\n  var horizScrollbar = element.offsetWidth - width;\n  var vertScrollbar = element.offsetHeight - height;\n\n  // if an hypothetical scrollbar is detected, we must be sure it's not a `border`\n  // we make this check conditional for performance reasons\n  if (horizScrollbar || vertScrollbar) {\n    var styles = getStyleComputedProperty(element);\n    horizScrollbar -= getBordersSize(styles, 'x');\n    vertScrollbar -= getBordersSize(styles, 'y');\n\n    result.width -= horizScrollbar;\n    result.height -= vertScrollbar;\n  }\n\n  return getClientRect(result);\n}\n\nfunction getOffsetRectRelativeToArbitraryNode(children, parent) {\n  var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n  var isIE10 = isIE(10);\n  var isHTML = parent.nodeName === 'HTML';\n  var childrenRect = getBoundingClientRect(children);\n  var parentRect = getBoundingClientRect(parent);\n  var scrollParent = getScrollParent(children);\n\n  var styles = getStyleComputedProperty(parent);\n  var borderTopWidth = parseFloat(styles.borderTopWidth);\n  var borderLeftWidth = parseFloat(styles.borderLeftWidth);\n\n  // In cases where the parent is fixed, we must ignore negative scroll in offset calc\n  if (fixedPosition && isHTML) {\n    parentRect.top = Math.max(parentRect.top, 0);\n    parentRect.left = Math.max(parentRect.left, 0);\n  }\n  var offsets = getClientRect({\n    top: childrenRect.top - parentRect.top - borderTopWidth,\n    left: childrenRect.left - parentRect.left - borderLeftWidth,\n    width: childrenRect.width,\n    height: childrenRect.height\n  });\n  offsets.marginTop = 0;\n  offsets.marginLeft = 0;\n\n  // Subtract margins of documentElement in case it's being used as parent\n  // we do this only on HTML because it's the only element that behaves\n  // differently when margins are applied to it. The margins are included in\n  // the box of the documentElement, in the other cases not.\n  if (!isIE10 && isHTML) {\n    var marginTop = parseFloat(styles.marginTop);\n    var marginLeft = parseFloat(styles.marginLeft);\n\n    offsets.top -= borderTopWidth - marginTop;\n    offsets.bottom -= borderTopWidth - marginTop;\n    offsets.left -= borderLeftWidth - marginLeft;\n    offsets.right -= borderLeftWidth - marginLeft;\n\n    // Attach marginTop and marginLeft because in some circumstances we may need them\n    offsets.marginTop = marginTop;\n    offsets.marginLeft = marginLeft;\n  }\n\n  if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {\n    offsets = includeScroll(offsets, parent);\n  }\n\n  return offsets;\n}\n\nfunction getViewportOffsetRectRelativeToArtbitraryNode(element) {\n  var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n  var html = element.ownerDocument.documentElement;\n  var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);\n  var width = Math.max(html.clientWidth, window.innerWidth || 0);\n  var height = Math.max(html.clientHeight, window.innerHeight || 0);\n\n  var scrollTop = !excludeScroll ? getScroll(html) : 0;\n  var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;\n\n  var offset = {\n    top: scrollTop - relativeOffset.top + relativeOffset.marginTop,\n    left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,\n    width: width,\n    height: height\n  };\n\n  return getClientRect(offset);\n}\n\n/**\n * Check if the given element is fixed or is inside a fixed parent\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @argument {Element} customContainer\n * @returns {Boolean} answer to \"isFixed?\"\n */\nfunction isFixed(element) {\n  var nodeName = element.nodeName;\n  if (nodeName === 'BODY' || nodeName === 'HTML') {\n    return false;\n  }\n  if (getStyleComputedProperty(element, 'position') === 'fixed') {\n    return true;\n  }\n  var parentNode = getParentNode(element);\n  if (!parentNode) {\n    return false;\n  }\n  return isFixed(parentNode);\n}\n\n/**\n * Finds the first parent of an element that has a transformed property defined\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Element} first transformed parent or documentElement\n */\n\nfunction getFixedPositionOffsetParent(element) {\n  // This check is needed to avoid errors in case one of the elements isn't defined for any reason\n  if (!element || !element.parentElement || isIE()) {\n    return document.documentElement;\n  }\n  var el = element.parentElement;\n  while (el && getStyleComputedProperty(el, 'transform') === 'none') {\n    el = el.parentElement;\n  }\n  return el || document.documentElement;\n}\n\n/**\n * Computed the boundaries limits and return them\n * @method\n * @memberof Popper.Utils\n * @param {HTMLElement} popper\n * @param {HTMLElement} reference\n * @param {number} padding\n * @param {HTMLElement} boundariesElement - Element used to define the boundaries\n * @param {Boolean} fixedPosition - Is in fixed position mode\n * @returns {Object} Coordinates of the boundaries\n */\nfunction getBoundaries(popper, reference, padding, boundariesElement) {\n  var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n\n  // NOTE: 1 DOM access here\n\n  var boundaries = { top: 0, left: 0 };\n  var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));\n\n  // Handle viewport case\n  if (boundariesElement === 'viewport') {\n    boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);\n  } else {\n    // Handle other cases based on DOM element used as boundaries\n    var boundariesNode = void 0;\n    if (boundariesElement === 'scrollParent') {\n      boundariesNode = getScrollParent(getParentNode(reference));\n      if (boundariesNode.nodeName === 'BODY') {\n        boundariesNode = popper.ownerDocument.documentElement;\n      }\n    } else if (boundariesElement === 'window') {\n      boundariesNode = popper.ownerDocument.documentElement;\n    } else {\n      boundariesNode = boundariesElement;\n    }\n\n    var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);\n\n    // In case of HTML, we need a different computation\n    if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {\n      var _getWindowSizes = getWindowSizes(popper.ownerDocument),\n          height = _getWindowSizes.height,\n          width = _getWindowSizes.width;\n\n      boundaries.top += offsets.top - offsets.marginTop;\n      boundaries.bottom = height + offsets.top;\n      boundaries.left += offsets.left - offsets.marginLeft;\n      boundaries.right = width + offsets.left;\n    } else {\n      // for all the other DOM elements, this one is good\n      boundaries = offsets;\n    }\n  }\n\n  // Add paddings\n  padding = padding || 0;\n  var isPaddingNumber = typeof padding === 'number';\n  boundaries.left += isPaddingNumber ? padding : padding.left || 0;\n  boundaries.top += isPaddingNumber ? padding : padding.top || 0;\n  boundaries.right -= isPaddingNumber ? padding : padding.right || 0;\n  boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0;\n\n  return boundaries;\n}\n\nfunction getArea(_ref) {\n  var width = _ref.width,\n      height = _ref.height;\n\n  return width * height;\n}\n\n/**\n * Utility used to transform the `auto` placement to the placement with more\n * available space.\n * @method\n * @memberof Popper.Utils\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {\n  var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;\n\n  if (placement.indexOf('auto') === -1) {\n    return placement;\n  }\n\n  var boundaries = getBoundaries(popper, reference, padding, boundariesElement);\n\n  var rects = {\n    top: {\n      width: boundaries.width,\n      height: refRect.top - boundaries.top\n    },\n    right: {\n      width: boundaries.right - refRect.right,\n      height: boundaries.height\n    },\n    bottom: {\n      width: boundaries.width,\n      height: boundaries.bottom - refRect.bottom\n    },\n    left: {\n      width: refRect.left - boundaries.left,\n      height: boundaries.height\n    }\n  };\n\n  var sortedAreas = Object.keys(rects).map(function (key) {\n    return _extends({\n      key: key\n    }, rects[key], {\n      area: getArea(rects[key])\n    });\n  }).sort(function (a, b) {\n    return b.area - a.area;\n  });\n\n  var filteredAreas = sortedAreas.filter(function (_ref2) {\n    var width = _ref2.width,\n        height = _ref2.height;\n    return width >= popper.clientWidth && height >= popper.clientHeight;\n  });\n\n  var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;\n\n  var variation = placement.split('-')[1];\n\n  return computedPlacement + (variation ? '-' + variation : '');\n}\n\n/**\n * Get offsets to the reference element\n * @method\n * @memberof Popper.Utils\n * @param {Object} state\n * @param {Element} popper - the popper element\n * @param {Element} reference - the reference element (the popper will be relative to this)\n * @param {Element} fixedPosition - is in fixed position mode\n * @returns {Object} An object containing the offsets which will be applied to the popper\n */\nfunction getReferenceOffsets(state, popper, reference) {\n  var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n\n  var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));\n  return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);\n}\n\n/**\n * Get the outer sizes of the given element (offset size + margins)\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Object} object containing width and height properties\n */\nfunction getOuterSizes(element) {\n  var window = element.ownerDocument.defaultView;\n  var styles = window.getComputedStyle(element);\n  var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);\n  var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);\n  var result = {\n    width: element.offsetWidth + y,\n    height: element.offsetHeight + x\n  };\n  return result;\n}\n\n/**\n * Get the opposite placement of the given one\n * @method\n * @memberof Popper.Utils\n * @argument {String} placement\n * @returns {String} flipped placement\n */\nfunction getOppositePlacement(placement) {\n  var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };\n  return placement.replace(/left|right|bottom|top/g, function (matched) {\n    return hash[matched];\n  });\n}\n\n/**\n * Get offsets to the popper\n * @method\n * @memberof Popper.Utils\n * @param {Object} position - CSS position the Popper will get applied\n * @param {HTMLElement} popper - the popper element\n * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)\n * @param {String} placement - one of the valid placement options\n * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper\n */\nfunction getPopperOffsets(popper, referenceOffsets, placement) {\n  placement = placement.split('-')[0];\n\n  // Get popper node sizes\n  var popperRect = getOuterSizes(popper);\n\n  // Add position, width and height to our offsets object\n  var popperOffsets = {\n    width: popperRect.width,\n    height: popperRect.height\n  };\n\n  // depending by the popper placement we have to compute its offsets slightly differently\n  var isHoriz = ['right', 'left'].indexOf(placement) !== -1;\n  var mainSide = isHoriz ? 'top' : 'left';\n  var secondarySide = isHoriz ? 'left' : 'top';\n  var measurement = isHoriz ? 'height' : 'width';\n  var secondaryMeasurement = !isHoriz ? 'height' : 'width';\n\n  popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;\n  if (placement === secondarySide) {\n    popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];\n  } else {\n    popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];\n  }\n\n  return popperOffsets;\n}\n\n/**\n * Mimics the `find` method of Array\n * @method\n * @memberof Popper.Utils\n * @argument {Array} arr\n * @argument prop\n * @argument value\n * @returns index or -1\n */\nfunction find(arr, check) {\n  // use native find if supported\n  if (Array.prototype.find) {\n    return arr.find(check);\n  }\n\n  // use `filter` to obtain the same behavior of `find`\n  return arr.filter(check)[0];\n}\n\n/**\n * Return the index of the matching object\n * @method\n * @memberof Popper.Utils\n * @argument {Array} arr\n * @argument prop\n * @argument value\n * @returns index or -1\n */\nfunction findIndex(arr, prop, value) {\n  // use native findIndex if supported\n  if (Array.prototype.findIndex) {\n    return arr.findIndex(function (cur) {\n      return cur[prop] === value;\n    });\n  }\n\n  // use `find` + `indexOf` if `findIndex` isn't supported\n  var match = find(arr, function (obj) {\n    return obj[prop] === value;\n  });\n  return arr.indexOf(match);\n}\n\n/**\n * Loop trough the list of modifiers and run them in order,\n * each of them will then edit the data object.\n * @method\n * @memberof Popper.Utils\n * @param {dataObject} data\n * @param {Array} modifiers\n * @param {String} ends - Optional modifier name used as stopper\n * @returns {dataObject}\n */\nfunction runModifiers(modifiers, data, ends) {\n  var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));\n\n  modifiersToRun.forEach(function (modifier) {\n    if (modifier['function']) {\n      // eslint-disable-line dot-notation\n      console.warn('`modifier.function` is deprecated, use `modifier.fn`!');\n    }\n    var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation\n    if (modifier.enabled && isFunction(fn)) {\n      // Add properties to offsets to make them a complete clientRect object\n      // we do this before each modifier to make sure the previous one doesn't\n      // mess with these values\n      data.offsets.popper = getClientRect(data.offsets.popper);\n      data.offsets.reference = getClientRect(data.offsets.reference);\n\n      data = fn(data, modifier);\n    }\n  });\n\n  return data;\n}\n\n/**\n * Updates the position of the popper, computing the new offsets and applying\n * the new style.<br />\n * Prefer `scheduleUpdate` over `update` because of performance reasons.\n * @method\n * @memberof Popper\n */\nfunction update() {\n  // if popper is destroyed, don't perform any further update\n  if (this.state.isDestroyed) {\n    return;\n  }\n\n  var data = {\n    instance: this,\n    styles: {},\n    arrowStyles: {},\n    attributes: {},\n    flipped: false,\n    offsets: {}\n  };\n\n  // compute reference element offsets\n  data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed);\n\n  // compute auto placement, store placement inside the data object,\n  // modifiers will be able to edit `placement` if needed\n  // and refer to originalPlacement to know the original value\n  data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);\n\n  // store the computed placement inside `originalPlacement`\n  data.originalPlacement = data.placement;\n\n  data.positionFixed = this.options.positionFixed;\n\n  // compute the popper offsets\n  data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);\n\n  data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute';\n\n  // run the modifiers\n  data = runModifiers(this.modifiers, data);\n\n  // the first `update` will call `onCreate` callback\n  // the other ones will call `onUpdate` callback\n  if (!this.state.isCreated) {\n    this.state.isCreated = true;\n    this.options.onCreate(data);\n  } else {\n    this.options.onUpdate(data);\n  }\n}\n\n/**\n * Helper used to know if the given modifier is enabled.\n * @method\n * @memberof Popper.Utils\n * @returns {Boolean}\n */\nfunction isModifierEnabled(modifiers, modifierName) {\n  return modifiers.some(function (_ref) {\n    var name = _ref.name,\n        enabled = _ref.enabled;\n    return enabled && name === modifierName;\n  });\n}\n\n/**\n * Get the prefixed supported property name\n * @method\n * @memberof Popper.Utils\n * @argument {String} property (camelCase)\n * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)\n */\nfunction getSupportedPropertyName(property) {\n  var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];\n  var upperProp = property.charAt(0).toUpperCase() + property.slice(1);\n\n  for (var i = 0; i < prefixes.length; i++) {\n    var prefix = prefixes[i];\n    var toCheck = prefix ? '' + prefix + upperProp : property;\n    if (typeof document.body.style[toCheck] !== 'undefined') {\n      return toCheck;\n    }\n  }\n  return null;\n}\n\n/**\n * Destroys the popper.\n * @method\n * @memberof Popper\n */\nfunction destroy() {\n  this.state.isDestroyed = true;\n\n  // touch DOM only if `applyStyle` modifier is enabled\n  if (isModifierEnabled(this.modifiers, 'applyStyle')) {\n    this.popper.removeAttribute('x-placement');\n    this.popper.style.position = '';\n    this.popper.style.top = '';\n    this.popper.style.left = '';\n    this.popper.style.right = '';\n    this.popper.style.bottom = '';\n    this.popper.style.willChange = '';\n    this.popper.style[getSupportedPropertyName('transform')] = '';\n  }\n\n  this.disableEventListeners();\n\n  // remove the popper if user explicitly asked for the deletion on destroy\n  // do not use `remove` because IE11 doesn't support it\n  if (this.options.removeOnDestroy) {\n    this.popper.parentNode.removeChild(this.popper);\n  }\n  return this;\n}\n\n/**\n * Get the window associated with the element\n * @argument {Element} element\n * @returns {Window}\n */\nfunction getWindow(element) {\n  var ownerDocument = element.ownerDocument;\n  return ownerDocument ? ownerDocument.defaultView : window;\n}\n\nfunction attachToScrollParents(scrollParent, event, callback, scrollParents) {\n  var isBody = scrollParent.nodeName === 'BODY';\n  var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;\n  target.addEventListener(event, callback, { passive: true });\n\n  if (!isBody) {\n    attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);\n  }\n  scrollParents.push(target);\n}\n\n/**\n * Setup needed event listeners used to update the popper position\n * @method\n * @memberof Popper.Utils\n * @private\n */\nfunction setupEventListeners(reference, options, state, updateBound) {\n  // Resize event listener on window\n  state.updateBound = updateBound;\n  getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });\n\n  // Scroll event listener on scroll parents\n  var scrollElement = getScrollParent(reference);\n  attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);\n  state.scrollElement = scrollElement;\n  state.eventsEnabled = true;\n\n  return state;\n}\n\n/**\n * It will add resize/scroll events and start recalculating\n * position of the popper element when they are triggered.\n * @method\n * @memberof Popper\n */\nfunction enableEventListeners() {\n  if (!this.state.eventsEnabled) {\n    this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);\n  }\n}\n\n/**\n * Remove event listeners used to update the popper position\n * @method\n * @memberof Popper.Utils\n * @private\n */\nfunction removeEventListeners(reference, state) {\n  // Remove resize event listener on window\n  getWindow(reference).removeEventListener('resize', state.updateBound);\n\n  // Remove scroll event listener on scroll parents\n  state.scrollParents.forEach(function (target) {\n    target.removeEventListener('scroll', state.updateBound);\n  });\n\n  // Reset state\n  state.updateBound = null;\n  state.scrollParents = [];\n  state.scrollElement = null;\n  state.eventsEnabled = false;\n  return state;\n}\n\n/**\n * It will remove resize/scroll events and won't recalculate popper position\n * when they are triggered. It also won't trigger `onUpdate` callback anymore,\n * unless you call `update` method manually.\n * @method\n * @memberof Popper\n */\nfunction disableEventListeners() {\n  if (this.state.eventsEnabled) {\n    cancelAnimationFrame(this.scheduleUpdate);\n    this.state = removeEventListeners(this.reference, this.state);\n  }\n}\n\n/**\n * Tells if a given input is a number\n * @method\n * @memberof Popper.Utils\n * @param {*} input to check\n * @return {Boolean}\n */\nfunction isNumeric(n) {\n  return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);\n}\n\n/**\n * Set the style to the given popper\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element - Element to apply the style to\n * @argument {Object} styles\n * Object with a list of properties and values which will be applied to the element\n */\nfunction setStyles(element, styles) {\n  Object.keys(styles).forEach(function (prop) {\n    var unit = '';\n    // add unit if the value is numeric and is one of the following\n    if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {\n      unit = 'px';\n    }\n    element.style[prop] = styles[prop] + unit;\n  });\n}\n\n/**\n * Set the attributes to the given popper\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element - Element to apply the attributes to\n * @argument {Object} styles\n * Object with a list of properties and values which will be applied to the element\n */\nfunction setAttributes(element, attributes) {\n  Object.keys(attributes).forEach(function (prop) {\n    var value = attributes[prop];\n    if (value !== false) {\n      element.setAttribute(prop, attributes[prop]);\n    } else {\n      element.removeAttribute(prop);\n    }\n  });\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} data.styles - List of style properties - values to apply to popper element\n * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The same data object\n */\nfunction applyStyle(data) {\n  // any property present in `data.styles` will be applied to the popper,\n  // in this way we can make the 3rd party modifiers add custom styles to it\n  // Be aware, modifiers could override the properties defined in the previous\n  // lines of this modifier!\n  setStyles(data.instance.popper, data.styles);\n\n  // any property present in `data.attributes` will be applied to the popper,\n  // they will be set as HTML attributes of the element\n  setAttributes(data.instance.popper, data.attributes);\n\n  // if arrowElement is defined and arrowStyles has some properties\n  if (data.arrowElement && Object.keys(data.arrowStyles).length) {\n    setStyles(data.arrowElement, data.arrowStyles);\n  }\n\n  return data;\n}\n\n/**\n * Set the x-placement attribute before everything else because it could be used\n * to add margins to the popper margins needs to be calculated to get the\n * correct popper offsets.\n * @method\n * @memberof Popper.modifiers\n * @param {HTMLElement} reference - The reference element used to position the popper\n * @param {HTMLElement} popper - The HTML element used as popper\n * @param {Object} options - Popper.js options\n */\nfunction applyStyleOnLoad(reference, popper, options, modifierOptions, state) {\n  // compute reference element offsets\n  var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);\n\n  // compute auto placement, store placement inside the data object,\n  // modifiers will be able to edit `placement` if needed\n  // and refer to originalPlacement to know the original value\n  var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);\n\n  popper.setAttribute('x-placement', placement);\n\n  // Apply `position` to popper before anything else because\n  // without the position applied we can't guarantee correct computations\n  setStyles(popper, { position: options.positionFixed ? 'fixed' : 'absolute' });\n\n  return options;\n}\n\n/**\n * @function\n * @memberof Popper.Utils\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Boolean} shouldRound - If the offsets should be rounded at all\n * @returns {Object} The popper's position offsets rounded\n *\n * The tale of pixel-perfect positioning. It's still not 100% perfect, but as\n * good as it can be within reason.\n * Discussion here: https://github.com/FezVrasta/popper.js/pull/715\n *\n * Low DPI screens cause a popper to be blurry if not using full pixels (Safari\n * as well on High DPI screens).\n *\n * Firefox prefers no rounding for positioning and does not have blurriness on\n * high DPI screens.\n *\n * Only horizontal placement and left/right values need to be considered.\n */\nfunction getRoundedOffsets(data, shouldRound) {\n  var _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n  var round = Math.round,\n      floor = Math.floor;\n\n  var noRound = function noRound(v) {\n    return v;\n  };\n\n  var referenceWidth = round(reference.width);\n  var popperWidth = round(popper.width);\n\n  var isVertical = ['left', 'right'].indexOf(data.placement) !== -1;\n  var isVariation = data.placement.indexOf('-') !== -1;\n  var sameWidthParity = referenceWidth % 2 === popperWidth % 2;\n  var bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1;\n\n  var horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor;\n  var verticalToInteger = !shouldRound ? noRound : round;\n\n  return {\n    left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left),\n    top: verticalToInteger(popper.top),\n    bottom: verticalToInteger(popper.bottom),\n    right: horizontalToInteger(popper.right)\n  };\n}\n\nvar isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent);\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction computeStyle(data, options) {\n  var x = options.x,\n      y = options.y;\n  var popper = data.offsets.popper;\n\n  // Remove this legacy support in Popper.js v2\n\n  var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) {\n    return modifier.name === 'applyStyle';\n  }).gpuAcceleration;\n  if (legacyGpuAccelerationOption !== undefined) {\n    console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');\n  }\n  var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration;\n\n  var offsetParent = getOffsetParent(data.instance.popper);\n  var offsetParentRect = getBoundingClientRect(offsetParent);\n\n  // Styles\n  var styles = {\n    position: popper.position\n  };\n\n  var offsets = getRoundedOffsets(data, window.devicePixelRatio < 2 || !isFirefox);\n\n  var sideA = x === 'bottom' ? 'top' : 'bottom';\n  var sideB = y === 'right' ? 'left' : 'right';\n\n  // if gpuAcceleration is set to `true` and transform is supported,\n  //  we use `translate3d` to apply the position to the popper we\n  // automatically use the supported prefixed version if needed\n  var prefixedProperty = getSupportedPropertyName('transform');\n\n  // now, let's make a step back and look at this code closely (wtf?)\n  // If the content of the popper grows once it's been positioned, it\n  // may happen that the popper gets misplaced because of the new content\n  // overflowing its reference element\n  // To avoid this problem, we provide two options (x and y), which allow\n  // the consumer to define the offset origin.\n  // If we position a popper on top of a reference element, we can set\n  // `x` to `top` to make the popper grow towards its top instead of\n  // its bottom.\n  var left = void 0,\n      top = void 0;\n  if (sideA === 'bottom') {\n    // when offsetParent is <html> the positioning is relative to the bottom of the screen (excluding the scrollbar)\n    // and not the bottom of the html element\n    if (offsetParent.nodeName === 'HTML') {\n      top = -offsetParent.clientHeight + offsets.bottom;\n    } else {\n      top = -offsetParentRect.height + offsets.bottom;\n    }\n  } else {\n    top = offsets.top;\n  }\n  if (sideB === 'right') {\n    if (offsetParent.nodeName === 'HTML') {\n      left = -offsetParent.clientWidth + offsets.right;\n    } else {\n      left = -offsetParentRect.width + offsets.right;\n    }\n  } else {\n    left = offsets.left;\n  }\n  if (gpuAcceleration && prefixedProperty) {\n    styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)';\n    styles[sideA] = 0;\n    styles[sideB] = 0;\n    styles.willChange = 'transform';\n  } else {\n    // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties\n    var invertTop = sideA === 'bottom' ? -1 : 1;\n    var invertLeft = sideB === 'right' ? -1 : 1;\n    styles[sideA] = top * invertTop;\n    styles[sideB] = left * invertLeft;\n    styles.willChange = sideA + ', ' + sideB;\n  }\n\n  // Attributes\n  var attributes = {\n    'x-placement': data.placement\n  };\n\n  // Update `data` attributes, styles and arrowStyles\n  data.attributes = _extends({}, attributes, data.attributes);\n  data.styles = _extends({}, styles, data.styles);\n  data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles);\n\n  return data;\n}\n\n/**\n * Helper used to know if the given modifier depends from another one.<br />\n * It checks if the needed modifier is listed and enabled.\n * @method\n * @memberof Popper.Utils\n * @param {Array} modifiers - list of modifiers\n * @param {String} requestingName - name of requesting modifier\n * @param {String} requestedName - name of requested modifier\n * @returns {Boolean}\n */\nfunction isModifierRequired(modifiers, requestingName, requestedName) {\n  var requesting = find(modifiers, function (_ref) {\n    var name = _ref.name;\n    return name === requestingName;\n  });\n\n  var isRequired = !!requesting && modifiers.some(function (modifier) {\n    return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;\n  });\n\n  if (!isRequired) {\n    var _requesting = '`' + requestingName + '`';\n    var requested = '`' + requestedName + '`';\n    console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!');\n  }\n  return isRequired;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction arrow(data, options) {\n  var _data$offsets$arrow;\n\n  // arrow depends on keepTogether in order to work\n  if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {\n    return data;\n  }\n\n  var arrowElement = options.element;\n\n  // if arrowElement is a string, suppose it's a CSS selector\n  if (typeof arrowElement === 'string') {\n    arrowElement = data.instance.popper.querySelector(arrowElement);\n\n    // if arrowElement is not found, don't run the modifier\n    if (!arrowElement) {\n      return data;\n    }\n  } else {\n    // if the arrowElement isn't a query selector we must check that the\n    // provided DOM node is child of its popper node\n    if (!data.instance.popper.contains(arrowElement)) {\n      console.warn('WARNING: `arrow.element` must be child of its popper element!');\n      return data;\n    }\n  }\n\n  var placement = data.placement.split('-')[0];\n  var _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n\n  var isVertical = ['left', 'right'].indexOf(placement) !== -1;\n\n  var len = isVertical ? 'height' : 'width';\n  var sideCapitalized = isVertical ? 'Top' : 'Left';\n  var side = sideCapitalized.toLowerCase();\n  var altSide = isVertical ? 'left' : 'top';\n  var opSide = isVertical ? 'bottom' : 'right';\n  var arrowElementSize = getOuterSizes(arrowElement)[len];\n\n  //\n  // extends keepTogether behavior making sure the popper and its\n  // reference have enough pixels in conjunction\n  //\n\n  // top/left side\n  if (reference[opSide] - arrowElementSize < popper[side]) {\n    data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize);\n  }\n  // bottom/right side\n  if (reference[side] + arrowElementSize > popper[opSide]) {\n    data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide];\n  }\n  data.offsets.popper = getClientRect(data.offsets.popper);\n\n  // compute center of the popper\n  var center = reference[side] + reference[len] / 2 - arrowElementSize / 2;\n\n  // Compute the sideValue using the updated popper offsets\n  // take popper margin in account because we don't have this info available\n  var css = getStyleComputedProperty(data.instance.popper);\n  var popperMarginSide = parseFloat(css['margin' + sideCapitalized]);\n  var popperBorderSide = parseFloat(css['border' + sideCapitalized + 'Width']);\n  var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide;\n\n  // prevent arrowElement from being placed not contiguously to its popper\n  sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0);\n\n  data.arrowElement = arrowElement;\n  data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ''), _data$offsets$arrow);\n\n  return data;\n}\n\n/**\n * Get the opposite placement variation of the given one\n * @method\n * @memberof Popper.Utils\n * @argument {String} placement variation\n * @returns {String} flipped placement variation\n */\nfunction getOppositeVariation(variation) {\n  if (variation === 'end') {\n    return 'start';\n  } else if (variation === 'start') {\n    return 'end';\n  }\n  return variation;\n}\n\n/**\n * List of accepted placements to use as values of the `placement` option.<br />\n * Valid placements are:\n * - `auto`\n * - `top`\n * - `right`\n * - `bottom`\n * - `left`\n *\n * Each placement can have a variation from this list:\n * - `-start`\n * - `-end`\n *\n * Variations are interpreted easily if you think of them as the left to right\n * written languages. Horizontally (`top` and `bottom`), `start` is left and `end`\n * is right.<br />\n * Vertically (`left` and `right`), `start` is top and `end` is bottom.\n *\n * Some valid examples are:\n * - `top-end` (on top of reference, right aligned)\n * - `right-start` (on right of reference, top aligned)\n * - `bottom` (on bottom, centered)\n * - `auto-end` (on the side with more space available, alignment depends by placement)\n *\n * @static\n * @type {Array}\n * @enum {String}\n * @readonly\n * @method placements\n * @memberof Popper\n */\nvar placements = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start'];\n\n// Get rid of `auto` `auto-start` and `auto-end`\nvar validPlacements = placements.slice(3);\n\n/**\n * Given an initial placement, returns all the subsequent placements\n * clockwise (or counter-clockwise).\n *\n * @method\n * @memberof Popper.Utils\n * @argument {String} placement - A valid placement (it accepts variations)\n * @argument {Boolean} counter - Set to true to walk the placements counterclockwise\n * @returns {Array} placements including their variations\n */\nfunction clockwise(placement) {\n  var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n  var index = validPlacements.indexOf(placement);\n  var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index));\n  return counter ? arr.reverse() : arr;\n}\n\nvar BEHAVIORS = {\n  FLIP: 'flip',\n  CLOCKWISE: 'clockwise',\n  COUNTERCLOCKWISE: 'counterclockwise'\n};\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction flip(data, options) {\n  // if `inner` modifier is enabled, we can't use the `flip` modifier\n  if (isModifierEnabled(data.instance.modifiers, 'inner')) {\n    return data;\n  }\n\n  if (data.flipped && data.placement === data.originalPlacement) {\n    // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides\n    return data;\n  }\n\n  var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed);\n\n  var placement = data.placement.split('-')[0];\n  var placementOpposite = getOppositePlacement(placement);\n  var variation = data.placement.split('-')[1] || '';\n\n  var flipOrder = [];\n\n  switch (options.behavior) {\n    case BEHAVIORS.FLIP:\n      flipOrder = [placement, placementOpposite];\n      break;\n    case BEHAVIORS.CLOCKWISE:\n      flipOrder = clockwise(placement);\n      break;\n    case BEHAVIORS.COUNTERCLOCKWISE:\n      flipOrder = clockwise(placement, true);\n      break;\n    default:\n      flipOrder = options.behavior;\n  }\n\n  flipOrder.forEach(function (step, index) {\n    if (placement !== step || flipOrder.length === index + 1) {\n      return data;\n    }\n\n    placement = data.placement.split('-')[0];\n    placementOpposite = getOppositePlacement(placement);\n\n    var popperOffsets = data.offsets.popper;\n    var refOffsets = data.offsets.reference;\n\n    // using floor because the reference offsets may contain decimals we are not going to consider here\n    var floor = Math.floor;\n    var overlapsRef = placement === 'left' && floor(popperOffsets.right) > floor(refOffsets.left) || placement === 'right' && floor(popperOffsets.left) < floor(refOffsets.right) || placement === 'top' && floor(popperOffsets.bottom) > floor(refOffsets.top) || placement === 'bottom' && floor(popperOffsets.top) < floor(refOffsets.bottom);\n\n    var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);\n    var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);\n    var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);\n    var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom);\n\n    var overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom;\n\n    // flip the variation if required\n    var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;\n\n    // flips variation if reference element overflows boundaries\n    var flippedVariationByRef = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom);\n\n    // flips variation if popper content overflows boundaries\n    var flippedVariationByContent = !!options.flipVariationsByContent && (isVertical && variation === 'start' && overflowsRight || isVertical && variation === 'end' && overflowsLeft || !isVertical && variation === 'start' && overflowsBottom || !isVertical && variation === 'end' && overflowsTop);\n\n    var flippedVariation = flippedVariationByRef || flippedVariationByContent;\n\n    if (overlapsRef || overflowsBoundaries || flippedVariation) {\n      // this boolean to detect any flip loop\n      data.flipped = true;\n\n      if (overlapsRef || overflowsBoundaries) {\n        placement = flipOrder[index + 1];\n      }\n\n      if (flippedVariation) {\n        variation = getOppositeVariation(variation);\n      }\n\n      data.placement = placement + (variation ? '-' + variation : '');\n\n      // this object contains `position`, we want to preserve it along with\n      // any additional property we may add in the future\n      data.offsets.popper = _extends({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement));\n\n      data = runModifiers(data.instance.modifiers, data, 'flip');\n    }\n  });\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction keepTogether(data) {\n  var _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n\n  var placement = data.placement.split('-')[0];\n  var floor = Math.floor;\n  var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;\n  var side = isVertical ? 'right' : 'bottom';\n  var opSide = isVertical ? 'left' : 'top';\n  var measurement = isVertical ? 'width' : 'height';\n\n  if (popper[side] < floor(reference[opSide])) {\n    data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement];\n  }\n  if (popper[opSide] > floor(reference[side])) {\n    data.offsets.popper[opSide] = floor(reference[side]);\n  }\n\n  return data;\n}\n\n/**\n * Converts a string containing value + unit into a px value number\n * @function\n * @memberof {modifiers~offset}\n * @private\n * @argument {String} str - Value + unit string\n * @argument {String} measurement - `height` or `width`\n * @argument {Object} popperOffsets\n * @argument {Object} referenceOffsets\n * @returns {Number|String}\n * Value in pixels, or original string if no values were extracted\n */\nfunction toValue(str, measurement, popperOffsets, referenceOffsets) {\n  // separate value from unit\n  var split = str.match(/((?:\\-|\\+)?\\d*\\.?\\d*)(.*)/);\n  var value = +split[1];\n  var unit = split[2];\n\n  // If it's not a number it's an operator, I guess\n  if (!value) {\n    return str;\n  }\n\n  if (unit.indexOf('%') === 0) {\n    var element = void 0;\n    switch (unit) {\n      case '%p':\n        element = popperOffsets;\n        break;\n      case '%':\n      case '%r':\n      default:\n        element = referenceOffsets;\n    }\n\n    var rect = getClientRect(element);\n    return rect[measurement] / 100 * value;\n  } else if (unit === 'vh' || unit === 'vw') {\n    // if is a vh or vw, we calculate the size based on the viewport\n    var size = void 0;\n    if (unit === 'vh') {\n      size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);\n    } else {\n      size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);\n    }\n    return size / 100 * value;\n  } else {\n    // if is an explicit pixel unit, we get rid of the unit and keep the value\n    // if is an implicit unit, it's px, and we return just the value\n    return value;\n  }\n}\n\n/**\n * Parse an `offset` string to extrapolate `x` and `y` numeric offsets.\n * @function\n * @memberof {modifiers~offset}\n * @private\n * @argument {String} offset\n * @argument {Object} popperOffsets\n * @argument {Object} referenceOffsets\n * @argument {String} basePlacement\n * @returns {Array} a two cells array with x and y offsets in numbers\n */\nfunction parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {\n  var offsets = [0, 0];\n\n  // Use height if placement is left or right and index is 0 otherwise use width\n  // in this way the first offset will use an axis and the second one\n  // will use the other one\n  var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1;\n\n  // Split the offset string to obtain a list of values and operands\n  // The regex addresses values with the plus or minus sign in front (+10, -20, etc)\n  var fragments = offset.split(/(\\+|\\-)/).map(function (frag) {\n    return frag.trim();\n  });\n\n  // Detect if the offset string contains a pair of values or a single one\n  // they could be separated by comma or space\n  var divider = fragments.indexOf(find(fragments, function (frag) {\n    return frag.search(/,|\\s/) !== -1;\n  }));\n\n  if (fragments[divider] && fragments[divider].indexOf(',') === -1) {\n    console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.');\n  }\n\n  // If divider is found, we divide the list of values and operands to divide\n  // them by ofset X and Y.\n  var splitRegex = /\\s*,\\s*|\\s+/;\n  var ops = divider !== -1 ? [fragments.slice(0, divider).concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat(fragments.slice(divider + 1))] : [fragments];\n\n  // Convert the values with units to absolute pixels to allow our computations\n  ops = ops.map(function (op, index) {\n    // Most of the units rely on the orientation of the popper\n    var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width';\n    var mergeWithPrevious = false;\n    return op\n    // This aggregates any `+` or `-` sign that aren't considered operators\n    // e.g.: 10 + +5 => [10, +, +5]\n    .reduce(function (a, b) {\n      if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) {\n        a[a.length - 1] = b;\n        mergeWithPrevious = true;\n        return a;\n      } else if (mergeWithPrevious) {\n        a[a.length - 1] += b;\n        mergeWithPrevious = false;\n        return a;\n      } else {\n        return a.concat(b);\n      }\n    }, [])\n    // Here we convert the string values into number values (in px)\n    .map(function (str) {\n      return toValue(str, measurement, popperOffsets, referenceOffsets);\n    });\n  });\n\n  // Loop trough the offsets arrays and execute the operations\n  ops.forEach(function (op, index) {\n    op.forEach(function (frag, index2) {\n      if (isNumeric(frag)) {\n        offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1);\n      }\n    });\n  });\n  return offsets;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @argument {Number|String} options.offset=0\n * The offset value as described in the modifier description\n * @returns {Object} The data object, properly modified\n */\nfunction offset(data, _ref) {\n  var offset = _ref.offset;\n  var placement = data.placement,\n      _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n\n  var basePlacement = placement.split('-')[0];\n\n  var offsets = void 0;\n  if (isNumeric(+offset)) {\n    offsets = [+offset, 0];\n  } else {\n    offsets = parseOffset(offset, popper, reference, basePlacement);\n  }\n\n  if (basePlacement === 'left') {\n    popper.top += offsets[0];\n    popper.left -= offsets[1];\n  } else if (basePlacement === 'right') {\n    popper.top += offsets[0];\n    popper.left += offsets[1];\n  } else if (basePlacement === 'top') {\n    popper.left += offsets[0];\n    popper.top -= offsets[1];\n  } else if (basePlacement === 'bottom') {\n    popper.left += offsets[0];\n    popper.top += offsets[1];\n  }\n\n  data.popper = popper;\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction preventOverflow(data, options) {\n  var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);\n\n  // If offsetParent is the reference element, we really want to\n  // go one step up and use the next offsetParent as reference to\n  // avoid to make this modifier completely useless and look like broken\n  if (data.instance.reference === boundariesElement) {\n    boundariesElement = getOffsetParent(boundariesElement);\n  }\n\n  // NOTE: DOM access here\n  // resets the popper's position so that the document size can be calculated excluding\n  // the size of the popper element itself\n  var transformProp = getSupportedPropertyName('transform');\n  var popperStyles = data.instance.popper.style; // assignment to help minification\n  var top = popperStyles.top,\n      left = popperStyles.left,\n      transform = popperStyles[transformProp];\n\n  popperStyles.top = '';\n  popperStyles.left = '';\n  popperStyles[transformProp] = '';\n\n  var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed);\n\n  // NOTE: DOM access here\n  // restores the original style properties after the offsets have been computed\n  popperStyles.top = top;\n  popperStyles.left = left;\n  popperStyles[transformProp] = transform;\n\n  options.boundaries = boundaries;\n\n  var order = options.priority;\n  var popper = data.offsets.popper;\n\n  var check = {\n    primary: function primary(placement) {\n      var value = popper[placement];\n      if (popper[placement] < boundaries[placement] && !options.escapeWithReference) {\n        value = Math.max(popper[placement], boundaries[placement]);\n      }\n      return defineProperty({}, placement, value);\n    },\n    secondary: function secondary(placement) {\n      var mainSide = placement === 'right' ? 'left' : 'top';\n      var value = popper[mainSide];\n      if (popper[placement] > boundaries[placement] && !options.escapeWithReference) {\n        value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height));\n      }\n      return defineProperty({}, mainSide, value);\n    }\n  };\n\n  order.forEach(function (placement) {\n    var side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary';\n    popper = _extends({}, popper, check[side](placement));\n  });\n\n  data.offsets.popper = popper;\n\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction shift(data) {\n  var placement = data.placement;\n  var basePlacement = placement.split('-')[0];\n  var shiftvariation = placement.split('-')[1];\n\n  // if shift shiftvariation is specified, run the modifier\n  if (shiftvariation) {\n    var _data$offsets = data.offsets,\n        reference = _data$offsets.reference,\n        popper = _data$offsets.popper;\n\n    var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;\n    var side = isVertical ? 'left' : 'top';\n    var measurement = isVertical ? 'width' : 'height';\n\n    var shiftOffsets = {\n      start: defineProperty({}, side, reference[side]),\n      end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement])\n    };\n\n    data.offsets.popper = _extends({}, popper, shiftOffsets[shiftvariation]);\n  }\n\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction hide(data) {\n  if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {\n    return data;\n  }\n\n  var refRect = data.offsets.reference;\n  var bound = find(data.instance.modifiers, function (modifier) {\n    return modifier.name === 'preventOverflow';\n  }).boundaries;\n\n  if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) {\n    // Avoid unnecessary DOM access if visibility hasn't changed\n    if (data.hide === true) {\n      return data;\n    }\n\n    data.hide = true;\n    data.attributes['x-out-of-boundaries'] = '';\n  } else {\n    // Avoid unnecessary DOM access if visibility hasn't changed\n    if (data.hide === false) {\n      return data;\n    }\n\n    data.hide = false;\n    data.attributes['x-out-of-boundaries'] = false;\n  }\n\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction inner(data) {\n  var placement = data.placement;\n  var basePlacement = placement.split('-')[0];\n  var _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n\n  var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;\n\n  var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;\n\n  popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);\n\n  data.placement = getOppositePlacement(placement);\n  data.offsets.popper = getClientRect(popper);\n\n  return data;\n}\n\n/**\n * Modifier function, each modifier can have a function of this type assigned\n * to its `fn` property.<br />\n * These functions will be called on each update, this means that you must\n * make sure they are performant enough to avoid performance bottlenecks.\n *\n * @function ModifierFn\n * @argument {dataObject} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {dataObject} The data object, properly modified\n */\n\n/**\n * Modifiers are plugins used to alter the behavior of your poppers.<br />\n * Popper.js uses a set of 9 modifiers to provide all the basic functionalities\n * needed by the library.\n *\n * Usually you don't want to override the `order`, `fn` and `onLoad` props.\n * All the other properties are configurations that could be tweaked.\n * @namespace modifiers\n */\nvar modifiers = {\n  /**\n   * Modifier used to shift the popper on the start or end of its reference\n   * element.<br />\n   * It will read the variation of the `placement` property.<br />\n   * It can be one either `-end` or `-start`.\n   * @memberof modifiers\n   * @inner\n   */\n  shift: {\n    /** @prop {number} order=100 - Index used to define the order of execution */\n    order: 100,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: shift\n  },\n\n  /**\n   * The `offset` modifier can shift your popper on both its axis.\n   *\n   * It accepts the following units:\n   * - `px` or unit-less, interpreted as pixels\n   * - `%` or `%r`, percentage relative to the length of the reference element\n   * - `%p`, percentage relative to the length of the popper element\n   * - `vw`, CSS viewport width unit\n   * - `vh`, CSS viewport height unit\n   *\n   * For length is intended the main axis relative to the placement of the popper.<br />\n   * This means that if the placement is `top` or `bottom`, the length will be the\n   * `width`. In case of `left` or `right`, it will be the `height`.\n   *\n   * You can provide a single value (as `Number` or `String`), or a pair of values\n   * as `String` divided by a comma or one (or more) white spaces.<br />\n   * The latter is a deprecated method because it leads to confusion and will be\n   * removed in v2.<br />\n   * Additionally, it accepts additions and subtractions between different units.\n   * Note that multiplications and divisions aren't supported.\n   *\n   * Valid examples are:\n   * ```\n   * 10\n   * '10%'\n   * '10, 10'\n   * '10%, 10'\n   * '10 + 10%'\n   * '10 - 5vh + 3%'\n   * '-10px + 5vh, 5px - 6%'\n   * ```\n   * > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap\n   * > with their reference element, unfortunately, you will have to disable the `flip` modifier.\n   * > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373).\n   *\n   * @memberof modifiers\n   * @inner\n   */\n  offset: {\n    /** @prop {number} order=200 - Index used to define the order of execution */\n    order: 200,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: offset,\n    /** @prop {Number|String} offset=0\n     * The offset value as described in the modifier description\n     */\n    offset: 0\n  },\n\n  /**\n   * Modifier used to prevent the popper from being positioned outside the boundary.\n   *\n   * A scenario exists where the reference itself is not within the boundaries.<br />\n   * We can say it has \"escaped the boundaries\" — or just \"escaped\".<br />\n   * In this case we need to decide whether the popper should either:\n   *\n   * - detach from the reference and remain \"trapped\" in the boundaries, or\n   * - if it should ignore the boundary and \"escape with its reference\"\n   *\n   * When `escapeWithReference` is set to`true` and reference is completely\n   * outside its boundaries, the popper will overflow (or completely leave)\n   * the boundaries in order to remain attached to the edge of the reference.\n   *\n   * @memberof modifiers\n   * @inner\n   */\n  preventOverflow: {\n    /** @prop {number} order=300 - Index used to define the order of execution */\n    order: 300,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: preventOverflow,\n    /**\n     * @prop {Array} [priority=['left','right','top','bottom']]\n     * Popper will try to prevent overflow following these priorities by default,\n     * then, it could overflow on the left and on top of the `boundariesElement`\n     */\n    priority: ['left', 'right', 'top', 'bottom'],\n    /**\n     * @prop {number} padding=5\n     * Amount of pixel used to define a minimum distance between the boundaries\n     * and the popper. This makes sure the popper always has a little padding\n     * between the edges of its container\n     */\n    padding: 5,\n    /**\n     * @prop {String|HTMLElement} boundariesElement='scrollParent'\n     * Boundaries used by the modifier. Can be `scrollParent`, `window`,\n     * `viewport` or any DOM element.\n     */\n    boundariesElement: 'scrollParent'\n  },\n\n  /**\n   * Modifier used to make sure the reference and its popper stay near each other\n   * without leaving any gap between the two. Especially useful when the arrow is\n   * enabled and you want to ensure that it points to its reference element.\n   * It cares only about the first axis. You can still have poppers with margin\n   * between the popper and its reference element.\n   * @memberof modifiers\n   * @inner\n   */\n  keepTogether: {\n    /** @prop {number} order=400 - Index used to define the order of execution */\n    order: 400,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: keepTogether\n  },\n\n  /**\n   * This modifier is used to move the `arrowElement` of the popper to make\n   * sure it is positioned between the reference element and its popper element.\n   * It will read the outer size of the `arrowElement` node to detect how many\n   * pixels of conjunction are needed.\n   *\n   * It has no effect if no `arrowElement` is provided.\n   * @memberof modifiers\n   * @inner\n   */\n  arrow: {\n    /** @prop {number} order=500 - Index used to define the order of execution */\n    order: 500,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: arrow,\n    /** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */\n    element: '[x-arrow]'\n  },\n\n  /**\n   * Modifier used to flip the popper's placement when it starts to overlap its\n   * reference element.\n   *\n   * Requires the `preventOverflow` modifier before it in order to work.\n   *\n   * **NOTE:** this modifier will interrupt the current update cycle and will\n   * restart it if it detects the need to flip the placement.\n   * @memberof modifiers\n   * @inner\n   */\n  flip: {\n    /** @prop {number} order=600 - Index used to define the order of execution */\n    order: 600,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: flip,\n    /**\n     * @prop {String|Array} behavior='flip'\n     * The behavior used to change the popper's placement. It can be one of\n     * `flip`, `clockwise`, `counterclockwise` or an array with a list of valid\n     * placements (with optional variations)\n     */\n    behavior: 'flip',\n    /**\n     * @prop {number} padding=5\n     * The popper will flip if it hits the edges of the `boundariesElement`\n     */\n    padding: 5,\n    /**\n     * @prop {String|HTMLElement} boundariesElement='viewport'\n     * The element which will define the boundaries of the popper position.\n     * The popper will never be placed outside of the defined boundaries\n     * (except if `keepTogether` is enabled)\n     */\n    boundariesElement: 'viewport',\n    /**\n     * @prop {Boolean} flipVariations=false\n     * The popper will switch placement variation between `-start` and `-end` when\n     * the reference element overlaps its boundaries.\n     *\n     * The original placement should have a set variation.\n     */\n    flipVariations: false,\n    /**\n     * @prop {Boolean} flipVariationsByContent=false\n     * The popper will switch placement variation between `-start` and `-end` when\n     * the popper element overlaps its reference boundaries.\n     *\n     * The original placement should have a set variation.\n     */\n    flipVariationsByContent: false\n  },\n\n  /**\n   * Modifier used to make the popper flow toward the inner of the reference element.\n   * By default, when this modifier is disabled, the popper will be placed outside\n   * the reference element.\n   * @memberof modifiers\n   * @inner\n   */\n  inner: {\n    /** @prop {number} order=700 - Index used to define the order of execution */\n    order: 700,\n    /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */\n    enabled: false,\n    /** @prop {ModifierFn} */\n    fn: inner\n  },\n\n  /**\n   * Modifier used to hide the popper when its reference element is outside of the\n   * popper boundaries. It will set a `x-out-of-boundaries` attribute which can\n   * be used to hide with a CSS selector the popper when its reference is\n   * out of boundaries.\n   *\n   * Requires the `preventOverflow` modifier before it in order to work.\n   * @memberof modifiers\n   * @inner\n   */\n  hide: {\n    /** @prop {number} order=800 - Index used to define the order of execution */\n    order: 800,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: hide\n  },\n\n  /**\n   * Computes the style that will be applied to the popper element to gets\n   * properly positioned.\n   *\n   * Note that this modifier will not touch the DOM, it just prepares the styles\n   * so that `applyStyle` modifier can apply it. This separation is useful\n   * in case you need to replace `applyStyle` with a custom implementation.\n   *\n   * This modifier has `850` as `order` value to maintain backward compatibility\n   * with previous versions of Popper.js. Expect the modifiers ordering method\n   * to change in future major versions of the library.\n   *\n   * @memberof modifiers\n   * @inner\n   */\n  computeStyle: {\n    /** @prop {number} order=850 - Index used to define the order of execution */\n    order: 850,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: computeStyle,\n    /**\n     * @prop {Boolean} gpuAcceleration=true\n     * If true, it uses the CSS 3D transformation to position the popper.\n     * Otherwise, it will use the `top` and `left` properties\n     */\n    gpuAcceleration: true,\n    /**\n     * @prop {string} [x='bottom']\n     * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.\n     * Change this if your popper should grow in a direction different from `bottom`\n     */\n    x: 'bottom',\n    /**\n     * @prop {string} [x='left']\n     * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.\n     * Change this if your popper should grow in a direction different from `right`\n     */\n    y: 'right'\n  },\n\n  /**\n   * Applies the computed styles to the popper element.\n   *\n   * All the DOM manipulations are limited to this modifier. This is useful in case\n   * you want to integrate Popper.js inside a framework or view library and you\n   * want to delegate all the DOM manipulations to it.\n   *\n   * Note that if you disable this modifier, you must make sure the popper element\n   * has its position set to `absolute` before Popper.js can do its work!\n   *\n   * Just disable this modifier and define your own to achieve the desired effect.\n   *\n   * @memberof modifiers\n   * @inner\n   */\n  applyStyle: {\n    /** @prop {number} order=900 - Index used to define the order of execution */\n    order: 900,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: applyStyle,\n    /** @prop {Function} */\n    onLoad: applyStyleOnLoad,\n    /**\n     * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier\n     * @prop {Boolean} gpuAcceleration=true\n     * If true, it uses the CSS 3D transformation to position the popper.\n     * Otherwise, it will use the `top` and `left` properties\n     */\n    gpuAcceleration: undefined\n  }\n};\n\n/**\n * The `dataObject` is an object containing all the information used by Popper.js.\n * This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks.\n * @name dataObject\n * @property {Object} data.instance The Popper.js instance\n * @property {String} data.placement Placement applied to popper\n * @property {String} data.originalPlacement Placement originally defined on init\n * @property {Boolean} data.flipped True if popper has been flipped by flip modifier\n * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper\n * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier\n * @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`)\n * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`)\n * @property {Object} data.boundaries Offsets of the popper boundaries\n * @property {Object} data.offsets The measurements of popper, reference and arrow elements\n * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values\n * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values\n * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0\n */\n\n/**\n * Default options provided to Popper.js constructor.<br />\n * These can be overridden using the `options` argument of Popper.js.<br />\n * To override an option, simply pass an object with the same\n * structure of the `options` object, as the 3rd argument. For example:\n * ```\n * new Popper(ref, pop, {\n *   modifiers: {\n *     preventOverflow: { enabled: false }\n *   }\n * })\n * ```\n * @type {Object}\n * @static\n * @memberof Popper\n */\nvar Defaults = {\n  /**\n   * Popper's placement.\n   * @prop {Popper.placements} placement='bottom'\n   */\n  placement: 'bottom',\n\n  /**\n   * Set this to true if you want popper to position it self in 'fixed' mode\n   * @prop {Boolean} positionFixed=false\n   */\n  positionFixed: false,\n\n  /**\n   * Whether events (resize, scroll) are initially enabled.\n   * @prop {Boolean} eventsEnabled=true\n   */\n  eventsEnabled: true,\n\n  /**\n   * Set to true if you want to automatically remove the popper when\n   * you call the `destroy` method.\n   * @prop {Boolean} removeOnDestroy=false\n   */\n  removeOnDestroy: false,\n\n  /**\n   * Callback called when the popper is created.<br />\n   * By default, it is set to no-op.<br />\n   * Access Popper.js instance with `data.instance`.\n   * @prop {onCreate}\n   */\n  onCreate: function onCreate() {},\n\n  /**\n   * Callback called when the popper is updated. This callback is not called\n   * on the initialization/creation of the popper, but only on subsequent\n   * updates.<br />\n   * By default, it is set to no-op.<br />\n   * Access Popper.js instance with `data.instance`.\n   * @prop {onUpdate}\n   */\n  onUpdate: function onUpdate() {},\n\n  /**\n   * List of modifiers used to modify the offsets before they are applied to the popper.\n   * They provide most of the functionalities of Popper.js.\n   * @prop {modifiers}\n   */\n  modifiers: modifiers\n};\n\n/**\n * @callback onCreate\n * @param {dataObject} data\n */\n\n/**\n * @callback onUpdate\n * @param {dataObject} data\n */\n\n// Utils\n// Methods\nvar Popper = function () {\n  /**\n   * Creates a new Popper.js instance.\n   * @class Popper\n   * @param {Element|referenceObject} reference - The reference element used to position the popper\n   * @param {Element} popper - The HTML / XML element used as the popper\n   * @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)\n   * @return {Object} instance - The generated Popper.js instance\n   */\n  function Popper(reference, popper) {\n    var _this = this;\n\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    classCallCheck(this, Popper);\n\n    this.scheduleUpdate = function () {\n      return requestAnimationFrame(_this.update);\n    };\n\n    // make update() debounced, so that it only runs at most once-per-tick\n    this.update = debounce(this.update.bind(this));\n\n    // with {} we create a new object with the options inside it\n    this.options = _extends({}, Popper.Defaults, options);\n\n    // init state\n    this.state = {\n      isDestroyed: false,\n      isCreated: false,\n      scrollParents: []\n    };\n\n    // get reference and popper elements (allow jQuery wrappers)\n    this.reference = reference && reference.jquery ? reference[0] : reference;\n    this.popper = popper && popper.jquery ? popper[0] : popper;\n\n    // Deep merge modifiers options\n    this.options.modifiers = {};\n    Object.keys(_extends({}, Popper.Defaults.modifiers, options.modifiers)).forEach(function (name) {\n      _this.options.modifiers[name] = _extends({}, Popper.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {});\n    });\n\n    // Refactoring modifiers' list (Object => Array)\n    this.modifiers = Object.keys(this.options.modifiers).map(function (name) {\n      return _extends({\n        name: name\n      }, _this.options.modifiers[name]);\n    })\n    // sort the modifiers by order\n    .sort(function (a, b) {\n      return a.order - b.order;\n    });\n\n    // modifiers have the ability to execute arbitrary code when Popper.js get inited\n    // such code is executed in the same order of its modifier\n    // they could add new properties to their options configuration\n    // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`!\n    this.modifiers.forEach(function (modifierOptions) {\n      if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {\n        modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state);\n      }\n    });\n\n    // fire the first update to position the popper in the right place\n    this.update();\n\n    var eventsEnabled = this.options.eventsEnabled;\n    if (eventsEnabled) {\n      // setup event listeners, they will take care of update the position in specific situations\n      this.enableEventListeners();\n    }\n\n    this.state.eventsEnabled = eventsEnabled;\n  }\n\n  // We can't use class properties because they don't get listed in the\n  // class prototype and break stuff like Sinon stubs\n\n\n  createClass(Popper, [{\n    key: 'update',\n    value: function update$$1() {\n      return update.call(this);\n    }\n  }, {\n    key: 'destroy',\n    value: function destroy$$1() {\n      return destroy.call(this);\n    }\n  }, {\n    key: 'enableEventListeners',\n    value: function enableEventListeners$$1() {\n      return enableEventListeners.call(this);\n    }\n  }, {\n    key: 'disableEventListeners',\n    value: function disableEventListeners$$1() {\n      return disableEventListeners.call(this);\n    }\n\n    /**\n     * Schedules an update. It will run on the next UI update available.\n     * @method scheduleUpdate\n     * @memberof Popper\n     */\n\n\n    /**\n     * Collection of utilities useful when writing custom modifiers.\n     * Starting from version 1.7, this method is available only if you\n     * include `popper-utils.js` before `popper.js`.\n     *\n     * **DEPRECATION**: This way to access PopperUtils is deprecated\n     * and will be removed in v2! Use the PopperUtils module directly instead.\n     * Due to the high instability of the methods contained in Utils, we can't\n     * guarantee them to follow semver. Use them at your own risk!\n     * @static\n     * @private\n     * @type {Object}\n     * @deprecated since version 1.8\n     * @member Utils\n     * @memberof Popper\n     */\n\n  }]);\n  return Popper;\n}();\n\n/**\n * The `referenceObject` is an object that provides an interface compatible with Popper.js\n * and lets you use it as replacement of a real DOM node.<br />\n * You can use this method to position a popper relatively to a set of coordinates\n * in case you don't have a DOM node to use as reference.\n *\n * ```\n * new Popper(referenceObject, popperNode);\n * ```\n *\n * NB: This feature isn't supported in Internet Explorer 10.\n * @name referenceObject\n * @property {Function} data.getBoundingClientRect\n * A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method.\n * @property {number} data.clientWidth\n * An ES6 getter that will return the width of the virtual reference element.\n * @property {number} data.clientHeight\n * An ES6 getter that will return the height of the virtual reference element.\n */\n\n\nPopper.Utils = (typeof window !== 'undefined' ? window : global).PopperUtils;\nPopper.placements = placements;\nPopper.Defaults = Defaults;\n\nexport default Popper;\n//# sourceMappingURL=popper.js.map\n"],"sourceRoot":""}