{"version":3,"file":"colicare.4661789b5710da3a0d94.js","mappings":"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","sources":["webpack://front-end-build-system/./jsscripts/jquery/swipe_2.2.js","webpack://front-end-build-system/./src/api/apiclient.js","webpack://front-end-build-system/./src/api/product.js","webpack://front-end-build-system/./src/colicare/colicarechart.js","webpack://front-end-build-system/./src/smartpak/httpstatus.js","webpack://front-end-build-system/./src/smartpak/tooltip.js","webpack://front-end-build-system/./src/views/colicare/colicare.js","webpack://front-end-build-system/./src/views/colicare/colicarecomparechart.js","webpack://front-end-build-system/./src/views/colicare/index.js","webpack://front-end-build-system/external var \"jQuery\"","webpack://front-end-build-system/./node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs","webpack://front-end-build-system/./node_modules/@floating-ui/core/dist/floating-ui.core.mjs","webpack://front-end-build-system/./node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs","webpack://front-end-build-system/./node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs"],"sourcesContent":["/*!\n * Swipe 2.2.11\n *\n * Brad Birdsall\n * Copyright 2013, MIT License\n *\n*/\n\n// if the module has no dependencies, the above pattern can be simplified to\n// eslint-disable-next-line no-extra-semi\n;(function (root, factory) {\n  // eslint-disable-next-line no-undef\n  if (typeof define === 'function' && define.amd) {\n    // AMD. Register as an anonymous module.\n    // eslint-disable-next-line no-undef\n    define([], function(){\n      root.Swipe = factory();\n      return root.Swipe;\n    });\n  } else if (typeof module === 'object' && module.exports) {\n    // Node. Does not work with strict CommonJS, but\n    // only CommonJS-like environments that support module.exports,\n    // like Node.\n    module.exports = factory();\n  } else {\n    // Browser globals\n    root.Swipe = factory();\n  }\n}(this, function () {\n  // Establish the root object, `window` (`self`) in the browser, `global`\n  // on the server, or `this` in some virtual machines. We use `self`\n  // instead of `window` for `WebWorker` support.\n  var root = typeof self == 'object' && self.self === self && self ||\n             typeof global == 'object' && global.global === global && global ||\n             this;\n\n  var _document = root.document;\n\n  function Swipe(container, options) {\n\n    'use strict';\n\n    options = options || {};\n\n    // setup initial vars\n    var start = {};\n    var delta = {};\n    var isScrolling;\n\n    // setup auto slideshow\n    var delay = options.auto || 0;\n    var interval;\n\n    var disabled = false;\n\n    // utilities\n    // simple no operation function\n    var noop = function() {};\n    // offload a functions execution\n    var offloadFn = function(fn) { setTimeout(fn || noop, 0); };\n    // Returns a function, that, as long as it continues to be invoked, will not\n    // be triggered.\n    var throttle = function (fn, threshhold) {\n      threshhold = threshhold || 100;\n      var timeout = null;\n\n      function cancel() {\n        if (timeout) clearTimeout(timeout);\n      }\n\n      function throttledFn() {\n        var context = this;\n        var args = arguments;\n        cancel();\n        timeout = setTimeout(function() {\n          timeout = null;\n          fn.apply(context, args);\n        }, threshhold);\n      }\n\n      // allow remove throttled timeout\n      throttledFn.cancel = cancel;\n\n      return throttledFn;\n    };\n\n    // check browser capabilities\n    var browser = {\n      addEventListener: !!root.addEventListener,\n      // eslint-disable-next-line no-undef\n      touch: ('ontouchstart' in root) || root.DocumentTouch && _document instanceof DocumentTouch,\n      transitions: (function(temp) {\n        var props = ['transitionProperty', 'WebkitTransition', 'MozTransition', 'OTransition', 'msTransition'];\n        for ( var i in props ) {\n          if (temp.style[ props[i] ] !== undefined){\n            return true;\n          }\n        }\n        return false;\n      })(_document.createElement('swipe'))\n    };\n\n    // quit if no root element\n    if (!container) return;\n\n    var element = container.children[0];\n    var slides, slidePos, width, length;\n    var index = parseInt(options.startSlide, 10) || 0;\n    var speed = options.speed || 300;\n    options.continuous = options.continuous !== undefined ? options.continuous : true;\n\n    // AutoRestart option: auto restart slideshow after user's touch event\n    options.autoRestart = options.autoRestart !== undefined ? options.autoRestart : false;\n\n    // throttled setup\n    var throttledSetup = throttle(setup);\n\n    // setup event capturing\n    var events = {\n\n      handleEvent: function(event) {\n        if (disabled) return;\n\n        switch (event.type) {\n          case 'mousedown':\n          case 'touchstart': this.start(event); break;\n          case 'mousemove':\n          case 'touchmove': this.move(event); break;\n          case 'mouseup':\n          case 'mouseleave':\n          case 'touchend': this.end(event); break;\n          case 'webkitTransitionEnd':\n          case 'msTransitionEnd':\n          case 'oTransitionEnd':\n          case 'otransitionend':\n          case 'transitionend': this.transitionEnd(event); break;\n          case 'resize': throttledSetup(); break;\n        }\n\n        if (options.stopPropagation) {\n          event.stopPropagation();\n        }\n      },\n\n      start: function(event) {\n        var touches;\n\n        if (isMouseEvent(event)) {\n          touches = event;\n          event.preventDefault(); // For desktop Safari drag\n        } else {\n          touches = event.touches[0];\n        }\n\n        // measure start values\n        start = {\n\n          // get initial touch coords\n          x: touches.pageX,\n          y: touches.pageY,\n\n          // store time to determine touch duration\n          time: +new Date()\n\n        };\n\n        // used for testing first move event\n        isScrolling = undefined;\n\n        // reset delta and end measurements\n        delta = {};\n\n        // attach touchmove and touchend listeners\n        if (isMouseEvent(event)) {\n          element.addEventListener('mousemove', this, false);\n          element.addEventListener('mouseup', this, false);\n          element.addEventListener('mouseleave', this, false);\n        } else {\n          element.addEventListener('touchmove', this, false);\n          element.addEventListener('touchend', this, false);\n        }\n\n      },\n\n      move: function(event) {\n        var touches;\n\n        if (isMouseEvent(event)) {\n          touches = event;\n        } else {\n          // ensure swiping with one touch and not pinching\n          if ( event.touches.length > 1 || event.scale && event.scale !== 1) {\n            return;\n          }\n\n          if (options.disableScroll) {\n            event.preventDefault();\n          }\n\n          touches = event.touches[0];\n        }\n\n        // measure change in x and y\n        delta = {\n          x: touches.pageX - start.x,\n          y: touches.pageY - start.y\n        };\n\n        // determine if scrolling test has run - one time test\n        if ( typeof isScrolling === 'undefined') {\n          isScrolling = !!( isScrolling || Math.abs(delta.x) < Math.abs(delta.y) );\n        }\n\n        // if user is not trying to scroll vertically\n        if (!isScrolling) {\n\n          // prevent native scrolling\n          event.preventDefault();\n\n          // stop slideshow\n          stop();\n\n          // increase resistance if first or last slide\n          if (options.continuous) { // we don't add resistance at the end\n\n            translate(circle(index-1), delta.x + slidePos[circle(index-1)], 0);\n            translate(index, delta.x + slidePos[index], 0);\n            translate(circle(index+1), delta.x + slidePos[circle(index+1)], 0);\n\n          } else {\n\n            delta.x =\n              delta.x /\n              ( (!index && delta.x > 0 ||             // if first slide and sliding left\n                 index === slides.length - 1 &&        // or if last slide and sliding right\n                 delta.x < 0                           // and if sliding at all\n                ) ?\n               ( Math.abs(delta.x) / width + 1 )      // determine resistance level\n               : 1 );                                 // no resistance if false\n\n            // translate 1:1\n            translate(index-1, delta.x + slidePos[index-1], 0);\n            translate(index, delta.x + slidePos[index], 0);\n            translate(index+1, delta.x + slidePos[index+1], 0);\n          }\n        }\n      },\n\n      end: function(event) {\n\n        // measure duration\n        var duration = +new Date() - start.time;\n\n        // determine if slide attempt triggers next/prev slide\n        var isValidSlide =\n            Number(duration) < 250 &&         // if slide duration is less than 250ms\n            Math.abs(delta.x) > 20 ||         // and if slide amt is greater than 20px\n            Math.abs(delta.x) > width/2;      // or if slide amt is greater than half the width\n\n        // determine if slide attempt is past start and end\n        var isPastBounds =\n            !index && delta.x > 0 ||                      // if first slide and slide amt is greater than 0\n            index === slides.length - 1 && delta.x < 0;   // or if last slide and slide amt is less than 0\n\n        if (options.continuous) {\n          isPastBounds = false;\n        }\n\n        // OLD determine direction of swipe (true:right, false:left)\n        // determine direction of swipe (1: backward, -1: forward)\n        var direction = Math.abs(delta.x) / delta.x;\n\n        // if not scrolling vertically\n        if (!isScrolling) {\n\n          if (isValidSlide && !isPastBounds) {\n\n            // if we're moving right\n            if (direction < 0) {\n\n              if (options.continuous) { // we need to get the next in this direction in place\n\n                move(circle(index-1), -width, 0);\n                move(circle(index+2), width, 0);\n\n              } else {\n                move(index-1, -width, 0);\n              }\n\n              move(index, slidePos[index]-width, speed);\n              move(circle(index+1), slidePos[circle(index+1)]-width, speed);\n              index = circle(index+1);\n\n            } else {\n              if (options.continuous) { // we need to get the next in this direction in place\n\n                move(circle(index+1), width, 0);\n                move(circle(index-2), -width, 0);\n\n              } else {\n                move(index+1, width, 0);\n              }\n\n              move(index, slidePos[index]+width, speed);\n              move(circle(index-1), slidePos[circle(index-1)]+width, speed);\n              index = circle(index-1);\n            }\n\n            runCallback(getPos(), slides[index], direction);\n\n          } else {\n\n            if (options.continuous) {\n\n              move(circle(index-1), -width, speed);\n              move(index, 0, speed);\n              move(circle(index+1), width, speed);\n\n            } else {\n\n              move(index-1, -width, speed);\n              move(index, 0, speed);\n              move(index+1, width, speed);\n            }\n          }\n        }\n\n        // kill touchmove and touchend event listeners until touchstart called again\n        if (isMouseEvent(event)) {\n          element.removeEventListener('mousemove', events, false);\n          element.removeEventListener('mouseup', events, false);\n          element.removeEventListener('mouseleave', events, false);\n        } else {\n          element.removeEventListener('touchmove', events, false);\n          element.removeEventListener('touchend', events, false);\n        }\n\n      },\n\n      transitionEnd: function(event) {\n        var currentIndex = parseInt(event.target.getAttribute('data-index'), 10);\n        if (currentIndex === index) {\n          if (delay || options.autoRestart) restart();\n\n          runTransitionEnd(getPos(), slides[index]);\n        }\n      }\n    };\n\n    // trigger setup\n    setup();\n\n    // start auto slideshow if applicable\n    begin();\n\n    // Expose the Swipe API\n    return {\n      // initialize\n      setup: setup,\n\n      // go to slide\n      slide: function(to, speed) {\n        stop();\n        slide(to, speed);\n      },\n\n      // move to previous\n      prev: function() {\n        stop();\n        prev();\n      },\n\n      // move to next\n      next: function() {\n        stop();\n        next();\n      },\n\n      // Restart slideshow\n      restart: restart,\n\n      // cancel slideshow\n      stop: stop,\n\n      // return current index position\n      getPos: getPos,\n\n      // disable slideshow\n      disable: disable,\n\n      // enable slideshow\n      enable: enable,\n\n      // return total number of slides\n      getNumSlides: function() { return length; },\n\n      // completely remove swipe\n      kill: kill\n    };\n\n    // remove all event listeners\n    function detachEvents() {\n      if (browser.addEventListener) {\n        // remove current event listeners\n        element.removeEventListener('touchstart', events, false);\n        element.removeEventListener('mousedown', events, false);\n        element.removeEventListener('webkitTransitionEnd', events, false);\n        element.removeEventListener('msTransitionEnd', events, false);\n        element.removeEventListener('oTransitionEnd', events, false);\n        element.removeEventListener('otransitionend', events, false);\n        element.removeEventListener('transitionend', events, false);\n        root.removeEventListener('resize', events, false);\n      } else {\n        root.onresize = null;\n      }\n    }\n\n    // add event listeners\n    function attachEvents() {\n      if (browser.addEventListener) {\n\n        // set touchstart event on element\n        if (browser.touch) {\n          element.addEventListener('touchstart', events, false);\n        }\n\n        if (options.draggable) {\n          element.addEventListener('mousedown', events, false);\n        }\n\n        if (browser.transitions) {\n          element.addEventListener('webkitTransitionEnd', events, false);\n          element.addEventListener('msTransitionEnd', events, false);\n          element.addEventListener('oTransitionEnd', events, false);\n          element.addEventListener('otransitionend', events, false);\n          element.addEventListener('transitionend', events, false);\n        }\n\n        // set resize event on window\n        root.addEventListener('resize', events, false);\n\n      } else {\n        root.onresize = throttledSetup; // to play nice with old IE\n      }\n    }\n\n    // clone nodes when there is only two slides\n    function cloneNode(el) {\n      var clone = el.cloneNode(true);\n      element.appendChild(clone);\n\n      // tag these slides as clones (to remove them on kill)\n      clone.setAttribute('data-cloned', true);\n\n      // Remove id from element\n      clone.removeAttribute('id');\n    }\n\n    function setup(opts) {\n      // Overwrite options if necessary\n      if (opts != null) {\n        for (var prop in opts) {\n          options[prop] = opts[prop];\n        }\n      }\n\n      // cache slides\n      slides = element.children;\n      length = slides.length;\n\n      // slides length correction, minus cloned slides\n      for (var i = 0; i < slides.length; i++) {\n        if (slides[i].getAttribute('data-cloned')) length--;\n      }\n\n      // set continuous to false if only one slide\n      if (slides.length < 2) {\n        options.continuous = false;\n      }\n\n      // special case if two slides\n      if (browser.transitions && options.continuous && slides.length < 3) {\n        cloneNode(slides[0]);\n        cloneNode(slides[1]);\n\n        slides = element.children;\n      }\n\n      // create an array to store current positions of each slide\n      slidePos = new Array(slides.length);\n\n      // determine width of each slide\n      width = container.getBoundingClientRect().width || container.offsetWidth;\n\n      element.style.width = (slides.length * width * 2) + 'px';\n\n      // stack elements\n      var pos = slides.length;\n      while(pos--) {\n        var slide = slides[pos];\n\n        slide.style.width = width + 'px';\n        slide.setAttribute('data-index', pos);\n\n        if (browser.transitions) {\n          slide.style.left = (pos * -width) + 'px';\n          move(pos, index > pos ? -width : (index < pos ? width : 0), 0);\n        }\n      }\n\n      // reposition elements before and after index\n      if (options.continuous && browser.transitions) {\n        move(circle(index-1), -width, 0);\n        move(circle(index+1), width, 0);\n      }\n\n      if (!browser.transitions) {\n        element.style.left = (index * -width) + 'px';\n      }\n\n      container.style.visibility = 'visible';\n\n      // reinitialize events\n      detachEvents();\n      attachEvents();\n    }\n\n    function prev() {\n      if (disabled) return;\n\n      if (options.continuous) {\n        slide(index-1);\n      } else if (index) {\n        slide(index-1);\n      }\n    }\n\n    function next() {\n      if (disabled) return;\n\n      if (options.continuous) {\n        slide(index+1);\n      } else if (index < slides.length - 1) {\n        slide(index+1);\n      }\n    }\n\n    function runCallback(pos, index, dir) {\n      if (options.callback) {\n        options.callback(pos, index, dir);\n      }\n    }\n\n    function runTransitionEnd(pos, index) {\n      if (options.transitionEnd) {\n        options.transitionEnd(pos, index);\n      }\n    }\n\n    function circle(index) {\n\n      // a simple positive modulo using slides.length\n      return (slides.length + (index % slides.length)) % slides.length;\n    }\n\n    function getPos() {\n      // Fix for the clone issue in the event of 2 slides\n      var currentIndex = index;\n\n      if (currentIndex >= length) {\n        currentIndex = currentIndex - length;\n      }\n\n      return currentIndex;\n    }\n\n    function slide(to, slideSpeed) {\n\n      // ensure to is of type 'number'\n      to = typeof to !== 'number' ? parseInt(to, 10) : to;\n\n      // do nothing if already on requested slide\n      if (index === to) return;\n\n      if (browser.transitions) {\n\n        var direction = Math.abs(index-to) / (index-to); // 1: backward, -1: forward\n\n        // get the actual position of the slide\n        if (options.continuous) {\n          var natural_direction = direction;\n          direction = -slidePos[circle(to)] / width;\n\n          // if going forward but to < index, use to = slides.length + to\n          // if going backward but to > index, use to = -slides.length + to\n          if (direction !== natural_direction) {\n            to = -direction * slides.length + to;\n          }\n\n        }\n\n        var diff = Math.abs(index-to) - 1;\n\n        // move all the slides between index and to in the right direction\n        while (diff--) {\n          move( circle((to > index ? to : index) - diff - 1), width * direction, 0);\n        }\n\n        to = circle(to);\n\n        move(index, width * direction, slideSpeed || speed);\n        move(to, 0, slideSpeed || speed);\n\n        if (options.continuous) { // we need to get the next in place\n          move(circle(to - direction), -(width * direction), 0);\n        }\n\n      } else {\n\n        to = circle(to);\n        animate(index * -width, to * -width, slideSpeed || speed);\n        // no fallback for a circular continuous if the browser does not accept transitions\n      }\n\n      index = to;\n      offloadFn(function() {\n        runCallback(getPos(), slides[index], direction);\n      });\n    }\n\n    function move(index, dist, speed) {\n      translate(index, dist, speed);\n      slidePos[index] = dist;\n    }\n\n    function translate(index, dist, speed) {\n\n      var slide = slides[index];\n      var style = slide && slide.style;\n\n      if (!style) return;\n\n      style.webkitTransitionDuration =\n        style.MozTransitionDuration =\n        style.msTransitionDuration =\n        style.OTransitionDuration =\n        style.transitionDuration = speed + 'ms';\n\n      style.webkitTransform = 'translate(' + dist + 'px,0)' + 'translateZ(0)';\n      style.msTransform =\n        style.MozTransform =\n        style.OTransform = 'translateX(' + dist + 'px)';\n\n    }\n\n    function animate(from, to, speed) {\n\n      // if not an animation, just reposition\n      if (!speed) {\n        element.style.left = to + 'px';\n        return;\n      }\n\n      var start = +new Date();\n\n      var timer = setInterval(function() {\n        var timeElap = +new Date() - start;\n\n        if (timeElap > speed) {\n\n          element.style.left = to + 'px';\n\n          if (delay || options.autoRestart) restart();\n\n          runTransitionEnd(getPos(), slides[index]);\n\n          clearInterval(timer);\n\n          return;\n        }\n\n        element.style.left = (( (to - from) * (Math.floor((timeElap / speed) * 100) / 100) ) + from) + 'px';\n      }, 4);\n\n    }\n\n    function begin() {\n      delay = options.auto || 0;\n      if (delay) interval = setTimeout(next, delay);\n    }\n\n    function stop() {\n      delay = 0;\n      clearTimeout(interval);\n    }\n\n    function restart() {\n      stop();\n      begin();\n    }\n\n    function disable() {\n      stop();\n      disabled = true;\n    }\n\n    function enable() {\n      disabled = false;\n      restart();\n    }\n\n    function isMouseEvent(e) {\n      return /^mouse/.test(e.type);\n    }\n\n    function kill() {\n      // cancel slideshow\n      stop();\n\n      // remove inline styles\n      container.style.visibility = '';\n\n      // reset element\n      element.style.width = '';\n      element.style.left = '';\n\n      // reset slides\n      var pos = slides.length;\n      while (pos--) {\n\n        if (browser.transitions) {\n          translate(pos, 0, 0);\n        }\n\n        var slide = slides[pos];\n\n        // if the slide is tagged as clone, remove it\n        if (slide.getAttribute('data-cloned')) {\n          var _parent = slide.parentElement;\n          _parent.removeChild(slide);\n        }\n\n        // remove styles\n        slide.style.width = '';\n        slide.style.left = '';\n\n        slide.style.webkitTransitionDuration =\n          slide.style.MozTransitionDuration =\n          slide.style.msTransitionDuration =\n          slide.style.OTransitionDuration =\n          slide.style.transitionDuration = '';\n\n        slide.style.webkitTransform =\n          slide.style.msTransform =\n          slide.style.MozTransform =\n          slide.style.OTransform = '';\n\n        // remove custom attributes (?)\n        // slide.removeAttribute('data-index');\n      }\n\n      // remove all events\n      detachEvents();\n\n      // remove throttled function timeout\n      throttledSetup.cancel();\n    }\n  }\n\n  if ( root.jQuery || root.Zepto ) {\n    (function($) {\n      $.fn.Swipe = function(params) {\n        return this.each(function() {\n          $(this).data('Swipe', new Swipe($(this)[0], params));\n        });\n      };\n    })( root.jQuery || root.Zepto );\n  }\n\n  return Swipe;\n}));\n","import $ from 'jquery';\r\nimport {HTTP_STATUS_UNAUTHORIZED} from '../smartpak/httpstatus.js';\r\n\r\nfunction onSuccess(callback) {\r\n    return function(response) {\r\n        if ($.isFunction(callback)) {\r\n            callback(response);\r\n        }\r\n    };\r\n}\r\n\r\nfunction onFail(callback, url, context) {\r\n    return function(response) {\r\n        if ($.isFunction(callback)) {\r\n            callback(response);\r\n        } else {\r\n            context.alertFailure(url, response);\r\n        }\r\n    };\r\n}\r\n\r\nfunction slice(args) {\r\n    return [].slice.call(args);\r\n}\r\n\r\nconst client = {\r\n    get: function(url, success, fail) {\r\n        return $.ajax({\r\n            url: url,\r\n            type: 'GET',\r\n            contentType: 'application/json',\r\n            cache: true\r\n        })\r\n            .done(onSuccess(success))\r\n            .fail(onFail(fail, url, this));\r\n    },\r\n    post: function(url, data, success, fail) {\r\n        return $.ajax({\r\n            url: url,\r\n            type: 'POST',\r\n            data: data,\r\n            contentType: 'application/json'\r\n        })\r\n            .done(onSuccess(success))\r\n            .fail(onFail(fail, url, this));\r\n    },\r\n    put: function(url, data, success, fail) {\r\n        return $.ajax({\r\n            url: url,\r\n            type: 'PUT',\r\n            data: data,\r\n            contentType: 'application/json'\r\n        })\r\n            .done(onSuccess(success))\r\n            .fail(onFail(fail, url, this));\r\n    },\r\n    loadDataWithoutCache: function(url, success, fail) {\r\n        return $.ajax({\r\n            url: url,\r\n            dataType: 'html',\r\n            cache: false\r\n        })\r\n            .done(onSuccess(success))\r\n            .fail(onFail(fail, url, this));\r\n    },\r\n    alertFailure: function(url, response) {\r\n        if (window.console && window.console.log && response.statusText !== 'abort') {\r\n            window.console.log('API failure:' + url, response);\r\n        }\r\n\r\n        if (response.status && response.status === HTTP_STATUS_UNAUTHORIZED) {\r\n            this.redirectToLogin(response);\r\n        }\r\n    },\r\n    redirectToLogin: function() {\r\n        window.location.href = '/account/login?returnUrl=' + window.location.href;\r\n    },\r\n    createConcatRequestMethod: function(type, url) {\r\n        return function() {\r\n            var args = slice(arguments);\r\n\r\n            return client[type].apply(client, [url + args.shift()].concat(args));\r\n        };\r\n    },\r\n    createRequestMethod: function(type, url) {\r\n        return function() {\r\n            var args = slice(arguments);\r\n            return client[type].apply(client, [url].concat(args));\r\n        };\r\n    }\r\n};\r\n\r\nexport default client;\r\n","import $ from 'jquery';\r\nimport { HTTP_STATUS_OK } from '../smartpak/httpstatus';\r\nimport client from './apiclient.js';\r\n\r\nfunction combineResponses(responses) {\r\n    return $.grep(responses, function(response) {\r\n        return response.Status === HTTP_STATUS_OK;\r\n    }).map(function(response) {\r\n        return response.Content;\r\n    });\r\n}\r\n\r\nfunction getResponses(responses) {\r\n    return $.map(responses, function(response) {\r\n        if (response.Content) {\r\n            return response;\r\n        }\r\n        return response[0];\r\n    });\r\n}\r\n\r\nfunction getPromises(productIds, api) {\r\n    return $.map(productIds, function(id) {\r\n        return api(id);\r\n    });\r\n}\r\n\r\nfunction makeArray(collection) {\r\n    return [].slice.call(collection);\r\n}\r\n\r\nfunction getDataForMultipleAPICalls(productIds, api) {\r\n    var dfd = new $.Deferred();\r\n\r\n    $.when.apply($, getPromises(productIds, api)).done(function() {\r\n        dfd.resolve(combineResponses(getResponses(makeArray(arguments))));\r\n    });\r\n\r\n    return dfd.promise();\r\n}\r\n\r\nconst product = {\r\n    getProductClass: client.createConcatRequestMethod('get', '/api/product/getProductClass/'),\r\n    getProductClassWithAttributes: client.createConcatRequestMethod(\r\n        'get',\r\n        '/api/product/getProductClassWithAttributes/'\r\n    ),\r\n    getProductsByProductClass: client.createConcatRequestMethod('get', '/api/product/getProductsByProductClass/'),\r\n    get: function(productId, isAutoShip) {\r\n        return client.get(\r\n            '/api/product/getProductById?productId=' +\r\n                productId +\r\n                '&isAutoShip=' +\r\n                (typeof isAutoShip !== 'undefined' ? isAutoShip : false)\r\n        );\r\n    },\r\n    getProductClassDTOList: function(productIds) {\r\n        return getDataForMultipleAPICalls(productIds, this.getProductClass);\r\n    }\r\n};\r\n\r\nexport default product;\r\n","import $ from 'jquery';\r\nimport product from '../api/product';\r\n\r\nconst ccChart = {\r\n    updateChartPrices: function() {\r\n        $('#ccModal table tr:last td').each(function(index, element) {\r\n            var $cell = $(element),\r\n                prodid = $cell.data('prodid');\r\n            if (prodid !== undefined) {\r\n                product.getProductClassWithAttributes(prodid).done(function(data) {\r\n                    var price = data.Content.Price.substr(data.Content.Price.lastIndexOf('$') + 1);\r\n                    $cell.html('$' + (price / 28).toFixed(2));\r\n                });\r\n            }\r\n        });\r\n    }\r\n};\r\nexport default ccChart;\r\n"," \nexport const HTTP_STATUS_OK = 200;\nexport const HTTP_STATUS_CREATED = 201;\nexport const HTTP_STATUS_NOCONTENT = 204;\nexport const HTTP_STATUS_BADREQUEST = 400;\nexport const HTTP_STATUS_UNAUTHORIZED = 401;\nexport const HTTP_STATUS_NOTFOUND = 404;\nexport const HTTP_STATUS_INTERNALSERVERERROR = 500;\nexport const HTTP_STATUS_SERVICEUNAVAILABLE = 503;\n","import { arrow, autoPlacement, computePosition, offset, shift } from '@floating-ui/dom';\n\nconst defaults = {\n    trigger: 'click'\n},\n    NO_TRIGGERS = 'Manual';\n\nfunction uniqueId() {\n    return `tooltip-${Math.random().toString(36).substring(2)}`;\n}\n\nexport class Tooltip {\n    constructor($trigger, opts = {}) {\n        if (!$trigger) {\n            throw new Error('Tooltip requires an element as a parameter');\n        }\n\n        this.$trigger = $trigger;\n\n        this.options = {\n            ...defaults,\n            ...opts\n        };\n\n        this.content = '';\n\n        if (!this.$trigger.hasAttribute('tabindex')) {\n            this.$trigger.setAttribute('tabindex', '0');\n        }\n\n        if (typeof this.options.content === 'object') {\n            let contentElement, contentArray;\n\n            if (this.options.content.innerHTML) {\n                contentElement = this.options.content;\n            } else {\n                contentArray = [].slice.call(this.options.content);\n                if (contentArray.length) {\n                    contentElement = contentArray[0];\n                }\n            }\n            this.content = contentElement ? contentElement.innerHTML : '';\n        } else if (typeof this.options.content === 'string') {\n            this.content = this.options.content;\n        } else if (typeof this.options.content === 'undefined' && this.$trigger.title) {\n            this.content = this.$trigger.title;\n        }\n\n        if (this.options.trigger !== NO_TRIGGERS) {\n            let listeners = [\n                ['blur', () => this.hide()],\n                ['mouseenter', () => this.show()],\n                ['mouseleave', () => this.hide()],\n                [\n                    'keydown',\n                    e => {\n                        const SPACE_BAR = 32,\n                            ENTER = 13;\n                        if (e.keyCode === SPACE_BAR || e.keyCode === ENTER) {\n                            e.preventDefault();\n                            this.toggle();\n                        }\n                    }\n                ],\n                [\n                    'click', e => e.preventDefault()\n                ]\n            ];\n\n            if (this.options.trigger === 'click') {\n                //remove mouse enter / leave\n                listeners.splice(1, 2);\n\n                listeners.push([\n                    'click',\n                    e => {\n                        e.preventDefault();\n                        this.toggle();\n                    }\n                ]);\n            }\n\n            listeners.forEach(([event, listener]) => {\n                this.$trigger.addEventListener(event, listener);\n\n                document.addEventListener(listener, e => {\n                    if (e.target !== this.$trigger) {\n                        this.hide();\n                    }\n                });\n            });\n        }\n\n        this._isShown = false;\n    }\n\n    toggle() {\n        if (!this._isShown) {\n            this.show();\n        } else {\n            this.hide();\n        }\n    }\n\n    show() {\n        if (!this.$tooltip) {\n            this.build();\n        }\n\n        this.$tooltip.style.display = 'block';\n        this.$tooltip.setAttribute('aria-hidden', 'false');\n        this.update();\n        this._isShown = true;\n    }\n\n    hide() {\n        if (!this._isShown) {\n            return;\n        }\n\n        this.$tooltip.style.removeProperty('display');\n        this.$tooltip.setAttribute('aria-hidden', 'true');\n        this._isShown = false;\n    }\n\n    update() {\n        computePosition(this.$trigger, this.$tooltip, {\n            middleware: [\n                autoPlacement(),\n                offset(10),\n                shift({\n                    padding: 8\n                }),\n                arrow({\n                    element: this.$arrow\n                })\n            ]\n        }).then(({ x, y, placement, middlewareData }) => {\n            Object.assign(this.$tooltip.style, {\n                left: `${x}px`,\n                top: `${y}px`\n            });\n\n            // Accessing the data\n            const { x: arrowX, y: arrowY } = middlewareData.arrow,\n                staticSide = {\n                    top: 'bottom',\n                    right: 'left',\n                    bottom: 'top',\n                    left: 'right'\n                }[placement.split('-')[0]];\n\n            Object.assign(this.$arrow.style, {\n                left: arrowX != null ? `${arrowX}px` : '',\n                top: arrowY != null ? `${arrowY}px` : '',\n                right: '',\n                bottom: '',\n                [staticSide]: `-${this.$arrow.clientWidth / 2}px`\n            });\n        });\n    }\n\n    build() {\n        const id = uniqueId();\n        this.$tooltip = document.createElement('div');\n        this.$tooltip.id = id;\n        this.$tooltip.setAttribute('role', 'tooltip');\n        this.$tooltip.setAttribute('aria-hidden', 'true');\n        this.$tooltip.classList.add('sp-tooltip');\n\n        this.$content = document.createElement('div');\n        this.$content.classList.add('sp-tooltip-inner');\n        this.$content.innerHTML = this.content;\n\n        this.$arrow = document.createElement('div');\n        this.$arrow.classList.add('sp-tooltip-arrow');\n\n        if (this.options.width) {\n            this.$tooltip.style.width = `${this.options.width.toString().replace(/px/gi, '')}px`;\n        }\n        this.$tooltip.appendChild(this.$content);\n        this.$tooltip.appendChild(this.$arrow);\n\n        this.$trigger.setAttribute('aria-describedby', id);\n        document.body.appendChild(this.$tooltip);\n    }\n}\n\nexport function tooltip($triggers, options) {\n    var triggers = [].slice.call('length' in $triggers ? $triggers : [$triggers]);\n\n    if (triggers.length) {\n        triggers.forEach($trigger => new Tooltip($trigger, options));\n    }\n}\n","import $ from 'jquery';\r\n\r\nconst colicare = {\r\n    _toggleColicareTab: function($click, animationOff) {\r\n        var $tabDown = $click.find('.tabDown'),\r\n            $tabUp = $click.find('.tabUp'),\r\n            $tabs = $('.tabWrapper').find('.tabUp');\r\n\r\n        if ($tabDown.length) {\r\n            $tabs.addClass('tabDown');\r\n            $tabs.removeClass('tabUp');\r\n            $('.tabWrapper')\r\n                .find('.content')\r\n                .hide();\r\n\r\n            $tabDown.addClass('tabUp');\r\n            $tabDown.removeClass('tabDown');\r\n        } else {\r\n            $tabUp.addClass('tabDown');\r\n            $tabUp.removeClass('tabUp');\r\n        }\r\n\r\n        if (!animationOff) {\r\n            $click\r\n                .parent()\r\n                .find('.content')\r\n                .slideToggle(900);\r\n        } else {\r\n            $click\r\n                .parent()\r\n                .find('.content')\r\n                .show();\r\n        }\r\n    },\r\n\r\n    _getHash: function(){\r\n        return location.hash;\r\n    },\r\n    _handleBuyClick: function(e) {\r\n        var link = $(e.target).attr('href');\r\n        if (link) {\r\n            window.location = link;\r\n        }\r\n    },\r\n\r\n    _bindColicareCompareClick: function() {\r\n        $('.compare').on('click', '#ccCompare', this._doColicareCompare);\r\n    },\r\n\r\n    _bindColicareClick: function() {\r\n        $('.ccTitle').on('click', (e) => {\r\n            this._toggleColicareTab($(e.target));\r\n        });\r\n\r\n        if (this._getHash()) {\r\n            var $div = $(this._getHash());\r\n\r\n            if ($div.length) {\r\n                this._toggleColicareTab($div.find('.ccTitle'), true);\r\n            }\r\n        }\r\n    },\r\n\r\n    _bindBuyButtonClick: function() {\r\n        $('.ccBtn .RedButton').on('click', this._handleBuyClick);\r\n    },\r\n\r\n    _bindFaqParameter: function() {\r\n        var hash = this._getHash(),\r\n            $faqClick,\r\n            $tabDown;\r\n\r\n        if (hash === '#faq') {\r\n            $faqClick = $(hash + ' .ccTitle');\r\n            $tabDown = $faqClick.find('.tabDown');\r\n\r\n            $tabDown.addClass('tabUp');\r\n            $tabDown.removeClass('tabDown');\r\n            $(hash + ' .content').show();\r\n            document.documentElement.scrollTo(0, 700);\r\n        }\r\n    },\r\n\r\n    init: function() {\r\n        this._bindColicareClick();\r\n        this._bindBuyButtonClick();\r\n        this._bindFaqParameter();\r\n    }\r\n};\r\n\r\nexport default colicare;\r\n\r\n"," \r\nimport $ from 'jquery';\r\nimport '../../../jsscripts/jquery/swipe_2.2';\r\nimport { tooltip } from '../../smartpak/tooltip';\r\n\r\nconst ccCompare = {\r\n    _chartOpen: false,\r\n    _calcSwipeWrapWidth: function() {\r\n        var swipeColumnWidth = this._calcColumnWidths(),\r\n            totalColumns = $('.colStrip').length,\r\n            fullWidth = totalColumns * swipeColumnWidth;\r\n\r\n        return fullWidth;\r\n    },\r\n\r\n    _calcColumnWidths: function() {\r\n        var winWidth = this._getWindowOuterWidth(),\r\n            staticWidth = $('#staticLeftColumn').outerWidth();\r\n        return winWidth - staticWidth;\r\n    },\r\n\r\n    _calcTableHeight: function() {\r\n        var $close = $('.closeBar'),\r\n            closeHeight = $close.length ? $close.outerHeight() : 0;\r\n        return window.innerHeight - closeHeight;\r\n    },\r\n\r\n    _getStyleValue: function($element, style) {\r\n        return Number($element.css(style).replace('px', ''));\r\n    },\r\n\r\n    _calcStyleOffset: function() {\r\n        var $vertCell = $('.vertCell'),\r\n            padTop = this._getStyleValue($vertCell, 'padding-top'),\r\n            padBot = this._getStyleValue($vertCell, 'padding-bottom'),\r\n            border = this._getStyleValue($vertCell, 'border-bottom-width');\r\n        return padTop + padBot + border;\r\n    },\r\n\r\n    _calcRowHeights: function() {\r\n        var styleOffset = this._calcStyleOffset(),\r\n            rows = $('#staticLeftColumn').children().length,\r\n            rowHeight = this._calcTableHeight() / (rows + 2) - styleOffset;\r\n\r\n        return rowHeight;\r\n    },\r\n\r\n    _centerLabels: function() {\r\n        var $parentCell = $('.vertCell');\r\n        $('.prodHeadCell').css({width: $parentCell.width(), height: $parentCell.height()});\r\n    },\r\n\r\n    _sizeHeadImage: function() {\r\n        var screenHeight = screen.height,\r\n            iPhone4Height = 481,\r\n            iPhone5Height = 569;\r\n        if (screenHeight < iPhone4Height) {\r\n            return '0%';\r\n        } else if (screenHeight < iPhone5Height) {\r\n            return '33%';\r\n        }\r\n        return '55%';\r\n    },\r\n\r\n    _doiPhone4Sizing: function() {\r\n        if (screen.height > 480) {\r\n            return;\r\n        }\r\n        var $headCell = $('.columnHeadCell'),\r\n            $vertCell = $('.vertCell'),\r\n            headCellHeight = $headCell.height(),\r\n            vertCellHeight = $vertCell.height();\r\n\r\n        $('.prodHeadImage').remove();\r\n        $headCell.css({'max-height': headCellHeight - 24 + 'px', 'min-height': headCellHeight - 24 + 'px'});\r\n        $vertCell.css({'max-height': vertCellHeight + 4 + 'px', 'min-height': vertCellHeight + 4 + 'px'});\r\n        $('#chartTitle').css('bottom', '0px');\r\n        $('.prodHeadContent').css('bottom', '7px');\r\n        $('.prodHeadLink').css({'line-height': '18px'});\r\n        $('.prodHeadCell').css('font-size', '13px');\r\n    },\r\n\r\n    initChart: function() {\r\n        var cellHeight = this._calcRowHeights(),\r\n            headHeight = cellHeight * 3;\r\n        $('#tableWrapper').height(this._calcTableHeight());\r\n        $('.vertCell').css({'max-height': cellHeight + 'px', 'min-height': cellHeight + 'px'});\r\n        $('.columnHeadCell').css({'max-height': headHeight + 'px', 'min-height': headHeight + 'px'});\r\n        $('.prodHeadImage').css('width', this._sizeHeadImage());\r\n        $('.colStrip').width(this._calcColumnWidths());\r\n        $('.swipe-wrap').width(this._calcSwipeWrapWidth());\r\n        this._doiPhone4Sizing();\r\n        this._centerLabels();\r\n        \r\n        new window.Swipe(document.getElementById('slider'), {continuous: false});\r\n    },\r\n\r\n    _showChart: function() {\r\n        smartPak.ui.modal($('#chartWrapper').get(0));\r\n        $('body').css('overflow', 'hidden');\r\n    },\r\n\r\n    _bindChartOpen: function() {\r\n        $('.ccChartLaunch').on('click', this._showChart);\r\n    },\r\n\r\n    // ORIENTATION\r\n\r\n    _initHandleOrientation: function() {\r\n        setTimeout(this._handleOrientationChange, 200);\r\n    },\r\n\r\n    _handleOrientationChange: function() {\r\n        var oriented = window.matchMedia('(orientation: portrait)'),\r\n            hider = () => {\r\n                $('#compareLaunchBar').show();\r\n                if (this._chartOpen) {\r\n                    this._hideOrientationWarning();\r\n                }\r\n            },\r\n            shower = () => {\r\n                $('#compareLaunchBar').hide();\r\n                if (this._chartOpen) {\r\n                    this._showOrientationWarning();\r\n                }\r\n            };\r\n\r\n        if (!oriented.matches) {\r\n            shower();\r\n        } else {\r\n            hider();\r\n        }\r\n    },\r\n\r\n    _showOrientationWarning: function() {\r\n        if ($('#landscapeWarning').length) {\r\n            return;\r\n        }\r\n        var screenHeight = window.innerHeight,\r\n            screenWidth = window.innerWidth;\r\n        $(\r\n            '<div id=\"landscapeWarning\" style=\"height:' +\r\n                screenHeight +\r\n                '; width:' +\r\n                screenWidth +\r\n                '\">This feature is only available in portrait view.<br>Please rotate your device<img id=\"rotateIcon\" src=\"/images/mobile/rotate.png\" /></div>'\r\n        ).insertBefore('.closeBar');\r\n    },\r\n\r\n    _hideOrientationWarning: function() {\r\n        this.initChart();\r\n        $('#landscapeWarning').remove();\r\n    },\r\n\r\n    // INSTRUCTIONAL TOOLTIP\r\n\r\n    _showInstructionsToolTip: function() {\r\n        if (sessionStorage.ccChartTipDisplayed === 'true') {\r\n            return;\r\n        }\r\n\r\n        var $ttElement = $('#chartInstructions').length\r\n            ? $('#chartInstructions')\r\n            : $(\r\n                    \"<a href='#' class='tooltipTrigger jsHide' id='chartInstructions' title='Simply swipe the right column left or right to compare ColiCare supplements ingredient by ingredient.'></a>\"\r\n                ).appendTo('body');\r\n        \r\n        $('.mobileModal').css('z-index', '90');\r\n\r\n        tooltip([$ttElement.get(0)]);\r\n\r\n        $ttElement.trigger('click');\r\n\r\n        sessionStorage.ccChartTipDisplayed = true;\r\n    },\r\n\r\n    _doAfterOpen: function() {\r\n        this._chartOpen = true;\r\n        this._handleOrientationChange();\r\n        this._showInstructionsToolTip();\r\n        this.initChart();\r\n    },\r\n\r\n    // for jasmine testing:\r\n\r\n    _getChartOpenValue: function() {\r\n        return this._chartOpen;\r\n    },\r\n\r\n    _getWindowOuterWidth: function() {\r\n        return window.outerWidth;\r\n    },\r\n\r\n    // INITIALIZE\r\n\r\n    init: function() {\r\n        var $win = $(window);\r\n        this._bindChartOpen();\r\n        $win.on('orientationchange', this._initHandleOrientation); // add 'resize' event to test in emulator //\r\n        $win.trigger('orientationchange');\r\n    }\r\n};\r\n\r\nexport default ccCompare;","import ccChart from '../../colicare/colicarechart';\nimport ccCompare from './colicarecomparechart';\nimport colicare from './colicare';\n\ncolicare.init();\nccCompare.init();\nccChart.updateChartPrices();\n","module.exports = jQuery;","/**\n * Custom positioning reference element.\n * @see https://floating-ui.com/docs/virtual-elements\n */\n\nconst sides = ['top', 'right', 'bottom', 'left'];\nconst alignments = ['start', 'end'];\nconst placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + \"-\" + alignments[0], side + \"-\" + alignments[1]), []);\nconst min = Math.min;\nconst max = Math.max;\nconst round = Math.round;\nconst floor = Math.floor;\nconst createCoords = v => ({\n  x: v,\n  y: v\n});\nconst oppositeSideMap = {\n  left: 'right',\n  right: 'left',\n  bottom: 'top',\n  top: 'bottom'\n};\nconst oppositeAlignmentMap = {\n  start: 'end',\n  end: 'start'\n};\nfunction clamp(start, value, end) {\n  return max(start, min(value, end));\n}\nfunction evaluate(value, param) {\n  return typeof value === 'function' ? value(param) : value;\n}\nfunction getSide(placement) {\n  return placement.split('-')[0];\n}\nfunction getAlignment(placement) {\n  return placement.split('-')[1];\n}\nfunction getOppositeAxis(axis) {\n  return axis === 'x' ? 'y' : 'x';\n}\nfunction getAxisLength(axis) {\n  return axis === 'y' ? 'height' : 'width';\n}\nfunction getSideAxis(placement) {\n  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';\n}\nfunction getAlignmentAxis(placement) {\n  return getOppositeAxis(getSideAxis(placement));\n}\nfunction getAlignmentSides(placement, rects, rtl) {\n  if (rtl === void 0) {\n    rtl = false;\n  }\n  const alignment = getAlignment(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const length = getAxisLength(alignmentAxis);\n  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';\n  if (rects.reference[length] > rects.floating[length]) {\n    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);\n  }\n  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];\n}\nfunction getExpandedPlacements(placement) {\n  const oppositePlacement = getOppositePlacement(placement);\n  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];\n}\nfunction getOppositeAlignmentPlacement(placement) {\n  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);\n}\nfunction getSideList(side, isStart, rtl) {\n  const lr = ['left', 'right'];\n  const rl = ['right', 'left'];\n  const tb = ['top', 'bottom'];\n  const bt = ['bottom', 'top'];\n  switch (side) {\n    case 'top':\n    case 'bottom':\n      if (rtl) return isStart ? rl : lr;\n      return isStart ? lr : rl;\n    case 'left':\n    case 'right':\n      return isStart ? tb : bt;\n    default:\n      return [];\n  }\n}\nfunction getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {\n  const alignment = getAlignment(placement);\n  let list = getSideList(getSide(placement), direction === 'start', rtl);\n  if (alignment) {\n    list = list.map(side => side + \"-\" + alignment);\n    if (flipAlignment) {\n      list = list.concat(list.map(getOppositeAlignmentPlacement));\n    }\n  }\n  return list;\n}\nfunction getOppositePlacement(placement) {\n  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);\n}\nfunction expandPaddingObject(padding) {\n  return {\n    top: 0,\n    right: 0,\n    bottom: 0,\n    left: 0,\n    ...padding\n  };\n}\nfunction getPaddingObject(padding) {\n  return typeof padding !== 'number' ? expandPaddingObject(padding) : {\n    top: padding,\n    right: padding,\n    bottom: padding,\n    left: padding\n  };\n}\nfunction rectToClientRect(rect) {\n  const {\n    x,\n    y,\n    width,\n    height\n  } = rect;\n  return {\n    width,\n    height,\n    top: y,\n    left: x,\n    right: x + width,\n    bottom: y + height,\n    x,\n    y\n  };\n}\n\nexport { alignments, clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round, sides };\n","import { getSideAxis, getAlignmentAxis, getAxisLength, getSide, getAlignment, evaluate, getPaddingObject, rectToClientRect, min, clamp, placements, getAlignmentSides, getOppositeAlignmentPlacement, getOppositePlacement, getExpandedPlacements, getOppositeAxisPlacements, sides, max, getOppositeAxis } from '@floating-ui/utils';\nexport { rectToClientRect } from '@floating-ui/utils';\n\nfunction computeCoordsFromPlacement(_ref, placement, rtl) {\n  let {\n    reference,\n    floating\n  } = _ref;\n  const sideAxis = getSideAxis(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const alignLength = getAxisLength(alignmentAxis);\n  const side = getSide(placement);\n  const isVertical = sideAxis === 'y';\n  const commonX = reference.x + reference.width / 2 - floating.width / 2;\n  const commonY = reference.y + reference.height / 2 - floating.height / 2;\n  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;\n  let coords;\n  switch (side) {\n    case 'top':\n      coords = {\n        x: commonX,\n        y: reference.y - floating.height\n      };\n      break;\n    case 'bottom':\n      coords = {\n        x: commonX,\n        y: reference.y + reference.height\n      };\n      break;\n    case 'right':\n      coords = {\n        x: reference.x + reference.width,\n        y: commonY\n      };\n      break;\n    case 'left':\n      coords = {\n        x: reference.x - floating.width,\n        y: commonY\n      };\n      break;\n    default:\n      coords = {\n        x: reference.x,\n        y: reference.y\n      };\n  }\n  switch (getAlignment(placement)) {\n    case 'start':\n      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n    case 'end':\n      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n  }\n  return coords;\n}\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n *\n * This export does not have any `platform` interface logic. You will need to\n * write one for the platform you are using Floating UI with.\n */\nconst computePosition = async (reference, floating, config) => {\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform\n  } = config;\n  const validMiddleware = middleware.filter(Boolean);\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));\n  let rects = await platform.getElementRects({\n    reference,\n    floating,\n    strategy\n  });\n  let {\n    x,\n    y\n  } = computeCoordsFromPlacement(rects, placement, rtl);\n  let statefulPlacement = placement;\n  let middlewareData = {};\n  let resetCount = 0;\n  for (let i = 0; i < validMiddleware.length; i++) {\n    const {\n      name,\n      fn\n    } = validMiddleware[i];\n    const {\n      x: nextX,\n      y: nextY,\n      data,\n      reset\n    } = await fn({\n      x,\n      y,\n      initialPlacement: placement,\n      placement: statefulPlacement,\n      strategy,\n      middlewareData,\n      rects,\n      platform,\n      elements: {\n        reference,\n        floating\n      }\n    });\n    x = nextX != null ? nextX : x;\n    y = nextY != null ? nextY : y;\n    middlewareData = {\n      ...middlewareData,\n      [name]: {\n        ...middlewareData[name],\n        ...data\n      }\n    };\n    if (reset && resetCount <= 50) {\n      resetCount++;\n      if (typeof reset === 'object') {\n        if (reset.placement) {\n          statefulPlacement = reset.placement;\n        }\n        if (reset.rects) {\n          rects = reset.rects === true ? await platform.getElementRects({\n            reference,\n            floating,\n            strategy\n          }) : reset.rects;\n        }\n        ({\n          x,\n          y\n        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));\n      }\n      i = -1;\n    }\n  }\n  return {\n    x,\n    y,\n    placement: statefulPlacement,\n    strategy,\n    middlewareData\n  };\n};\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nasync function detectOverflow(state, options) {\n  var _await$platform$isEle;\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    x,\n    y,\n    platform,\n    rects,\n    elements,\n    strategy\n  } = state;\n  const {\n    boundary = 'clippingAncestors',\n    rootBoundary = 'viewport',\n    elementContext = 'floating',\n    altBoundary = false,\n    padding = 0\n  } = evaluate(options, state);\n  const paddingObject = getPaddingObject(padding);\n  const altContext = elementContext === 'floating' ? 'reference' : 'floating';\n  const element = elements[altBoundary ? altContext : elementContext];\n  const clippingClientRect = rectToClientRect(await platform.getClippingRect({\n    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),\n    boundary,\n    rootBoundary,\n    strategy\n  }));\n  const rect = elementContext === 'floating' ? {\n    x,\n    y,\n    width: rects.floating.width,\n    height: rects.floating.height\n  } : rects.reference;\n  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));\n  const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {\n    x: 1,\n    y: 1\n  } : {\n    x: 1,\n    y: 1\n  };\n  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  }) : rect);\n  return {\n    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,\n    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,\n    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,\n    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x\n  };\n}\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => ({\n  name: 'arrow',\n  options,\n  async fn(state) {\n    const {\n      x,\n      y,\n      placement,\n      rects,\n      platform,\n      elements,\n      middlewareData\n    } = state;\n    // Since `element` is required, we don't Partial<> the type.\n    const {\n      element,\n      padding = 0\n    } = evaluate(options, state) || {};\n    if (element == null) {\n      return {};\n    }\n    const paddingObject = getPaddingObject(padding);\n    const coords = {\n      x,\n      y\n    };\n    const axis = getAlignmentAxis(placement);\n    const length = getAxisLength(axis);\n    const arrowDimensions = await platform.getDimensions(element);\n    const isYAxis = axis === 'y';\n    const minProp = isYAxis ? 'top' : 'left';\n    const maxProp = isYAxis ? 'bottom' : 'right';\n    const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';\n    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];\n    const startDiff = coords[axis] - rects.reference[axis];\n    const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));\n    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;\n\n    // DOM platform can return `window` as the `offsetParent`.\n    if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {\n      clientSize = elements.floating[clientProp] || rects.floating[length];\n    }\n    const centerToReference = endDiff / 2 - startDiff / 2;\n\n    // If the padding is large enough that it causes the arrow to no longer be\n    // centered, modify the padding so that it is centered.\n    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;\n    const minPadding = min(paddingObject[minProp], largestPossiblePadding);\n    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);\n\n    // Make sure the arrow doesn't overflow the floating element if the center\n    // point is outside the floating element's bounds.\n    const min$1 = minPadding;\n    const max = clientSize - arrowDimensions[length] - maxPadding;\n    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;\n    const offset = clamp(min$1, center, max);\n\n    // If the reference is small enough that the arrow's padding causes it to\n    // to point to nothing for an aligned placement, adjust the offset of the\n    // floating element itself. To ensure `shift()` continues to take action,\n    // a single reset is performed when this is true.\n    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;\n    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;\n    return {\n      [axis]: coords[axis] + alignmentOffset,\n      data: {\n        [axis]: offset,\n        centerOffset: center - offset - alignmentOffset,\n        ...(shouldAddOffset && {\n          alignmentOffset\n        })\n      },\n      reset: shouldAddOffset\n    };\n  }\n});\n\nfunction getPlacementList(alignment, autoAlignment, allowedPlacements) {\n  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);\n  return allowedPlacementsSortedByAlignment.filter(placement => {\n    if (alignment) {\n      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);\n    }\n    return true;\n  });\n}\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'autoPlacement',\n    options,\n    async fn(state) {\n      var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;\n      const {\n        rects,\n        middlewareData,\n        placement,\n        platform,\n        elements\n      } = state;\n      const {\n        crossAxis = false,\n        alignment,\n        allowedPlacements = placements,\n        autoAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;\n      const currentPlacement = placements$1[currentIndex];\n      if (currentPlacement == null) {\n        return {};\n      }\n      const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));\n\n      // Make `computeCoords` start from the right place.\n      if (placement !== currentPlacement) {\n        return {\n          reset: {\n            placement: placements$1[0]\n          }\n        };\n      }\n      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];\n      const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {\n        placement: currentPlacement,\n        overflows: currentOverflows\n      }];\n      const nextPlacement = placements$1[currentIndex + 1];\n\n      // There are more placements to check.\n      if (nextPlacement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: nextPlacement\n          }\n        };\n      }\n      const placementsSortedByMostSpace = allOverflows.map(d => {\n        const alignment = getAlignment(d.placement);\n        return [d.placement, alignment && crossAxis ?\n        // Check along the mainAxis and main crossAxis side.\n        d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :\n        // Check only the mainAxis.\n        d.overflows[0], d.overflows];\n      }).sort((a, b) => a[1] - b[1]);\n      const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,\n      // Aligned placements should not check their opposite crossAxis\n      // side.\n      getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));\n      const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];\n      if (resetPlacement !== placement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: resetPlacement\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'flip',\n    options,\n    async fn(state) {\n      var _middlewareData$arrow, _middlewareData$flip;\n      const {\n        placement,\n        middlewareData,\n        rects,\n        initialPlacement,\n        platform,\n        elements\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true,\n        fallbackPlacements: specifiedFallbackPlacements,\n        fallbackStrategy = 'bestFit',\n        fallbackAxisSideDirection = 'none',\n        flipAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n\n      // If a reset by the arrow was caused due to an alignment offset being\n      // added, we should skip any logic now since `flip()` has already done its\n      // work.\n      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643\n      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      const side = getSide(placement);\n      const initialSideAxis = getSideAxis(initialPlacement);\n      const isBasePlacement = getSide(initialPlacement) === initialPlacement;\n      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));\n      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';\n      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {\n        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));\n      }\n      const placements = [initialPlacement, ...fallbackPlacements];\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const overflows = [];\n      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];\n      if (checkMainAxis) {\n        overflows.push(overflow[side]);\n      }\n      if (checkCrossAxis) {\n        const sides = getAlignmentSides(placement, rects, rtl);\n        overflows.push(overflow[sides[0]], overflow[sides[1]]);\n      }\n      overflowsData = [...overflowsData, {\n        placement,\n        overflows\n      }];\n\n      // One or more sides is overflowing.\n      if (!overflows.every(side => side <= 0)) {\n        var _middlewareData$flip2, _overflowsData$filter;\n        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;\n        const nextPlacement = placements[nextIndex];\n        if (nextPlacement) {\n          // Try next placement and re-run the lifecycle.\n          return {\n            data: {\n              index: nextIndex,\n              overflows: overflowsData\n            },\n            reset: {\n              placement: nextPlacement\n            }\n          };\n        }\n\n        // First, find the candidates that fit on the mainAxis side of overflow,\n        // then find the placement that fits the best on the main crossAxis side.\n        let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;\n\n        // Otherwise fallback.\n        if (!resetPlacement) {\n          switch (fallbackStrategy) {\n            case 'bestFit':\n              {\n                var _overflowsData$filter2;\n                const placement = (_overflowsData$filter2 = overflowsData.filter(d => {\n                  if (hasFallbackAxisSideDirection) {\n                    const currentSideAxis = getSideAxis(d.placement);\n                    return currentSideAxis === initialSideAxis ||\n                    // Create a bias to the `y` side axis due to horizontal\n                    // reading directions favoring greater width.\n                    currentSideAxis === 'y';\n                  }\n                  return true;\n                }).map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];\n                if (placement) {\n                  resetPlacement = placement;\n                }\n                break;\n              }\n            case 'initialPlacement':\n              resetPlacement = initialPlacement;\n              break;\n          }\n        }\n        if (placement !== resetPlacement) {\n          return {\n            reset: {\n              placement: resetPlacement\n            }\n          };\n        }\n      }\n      return {};\n    }\n  };\n};\n\nfunction getSideOffsets(overflow, rect) {\n  return {\n    top: overflow.top - rect.height,\n    right: overflow.right - rect.width,\n    bottom: overflow.bottom - rect.height,\n    left: overflow.left - rect.width\n  };\n}\nfunction isAnySideFullyClipped(overflow) {\n  return sides.some(side => overflow[side] >= 0);\n}\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'hide',\n    options,\n    async fn(state) {\n      const {\n        rects\n      } = state;\n      const {\n        strategy = 'referenceHidden',\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      switch (strategy) {\n        case 'referenceHidden':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              elementContext: 'reference'\n            });\n            const offsets = getSideOffsets(overflow, rects.reference);\n            return {\n              data: {\n                referenceHiddenOffsets: offsets,\n                referenceHidden: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        case 'escaped':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              altBoundary: true\n            });\n            const offsets = getSideOffsets(overflow, rects.floating);\n            return {\n              data: {\n                escapedOffsets: offsets,\n                escaped: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        default:\n          {\n            return {};\n          }\n      }\n    }\n  };\n};\n\nfunction getBoundingRect(rects) {\n  const minX = min(...rects.map(rect => rect.left));\n  const minY = min(...rects.map(rect => rect.top));\n  const maxX = max(...rects.map(rect => rect.right));\n  const maxY = max(...rects.map(rect => rect.bottom));\n  return {\n    x: minX,\n    y: minY,\n    width: maxX - minX,\n    height: maxY - minY\n  };\n}\nfunction getRectsByLine(rects) {\n  const sortedRects = rects.slice().sort((a, b) => a.y - b.y);\n  const groups = [];\n  let prevRect = null;\n  for (let i = 0; i < sortedRects.length; i++) {\n    const rect = sortedRects[i];\n    if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {\n      groups.push([rect]);\n    } else {\n      groups[groups.length - 1].push(rect);\n    }\n    prevRect = rect;\n  }\n  return groups.map(rect => rectToClientRect(getBoundingRect(rect)));\n}\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'inline',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        elements,\n        rects,\n        platform,\n        strategy\n      } = state;\n      // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a\n      // ClientRect's bounds, despite the event listener being triggered. A\n      // padding of 2 seems to handle this issue.\n      const {\n        padding = 2,\n        x,\n        y\n      } = evaluate(options, state);\n      const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []);\n      const clientRects = getRectsByLine(nativeClientRects);\n      const fallback = rectToClientRect(getBoundingRect(nativeClientRects));\n      const paddingObject = getPaddingObject(padding);\n      function getBoundingClientRect() {\n        // There are two rects and they are disjoined.\n        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {\n          // Find the first rect in which the point is fully inside.\n          return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;\n        }\n\n        // There are 2 or more connected rects.\n        if (clientRects.length >= 2) {\n          if (getSideAxis(placement) === 'y') {\n            const firstRect = clientRects[0];\n            const lastRect = clientRects[clientRects.length - 1];\n            const isTop = getSide(placement) === 'top';\n            const top = firstRect.top;\n            const bottom = lastRect.bottom;\n            const left = isTop ? firstRect.left : lastRect.left;\n            const right = isTop ? firstRect.right : lastRect.right;\n            const width = right - left;\n            const height = bottom - top;\n            return {\n              top,\n              bottom,\n              left,\n              right,\n              width,\n              height,\n              x: left,\n              y: top\n            };\n          }\n          const isLeftSide = getSide(placement) === 'left';\n          const maxRight = max(...clientRects.map(rect => rect.right));\n          const minLeft = min(...clientRects.map(rect => rect.left));\n          const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight);\n          const top = measureRects[0].top;\n          const bottom = measureRects[measureRects.length - 1].bottom;\n          const left = minLeft;\n          const right = maxRight;\n          const width = right - left;\n          const height = bottom - top;\n          return {\n            top,\n            bottom,\n            left,\n            right,\n            width,\n            height,\n            x: left,\n            y: top\n          };\n        }\n        return fallback;\n      }\n      const resetRects = await platform.getElementRects({\n        reference: {\n          getBoundingClientRect\n        },\n        floating: elements.floating,\n        strategy\n      });\n      if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {\n        return {\n          reset: {\n            rects: resetRects\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n// For type backwards-compatibility, the `OffsetOptions` type was also\n// Derivable.\n\nasync function convertValueToCoords(state, options) {\n  const {\n    placement,\n    platform,\n    elements\n  } = state;\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n  const side = getSide(placement);\n  const alignment = getAlignment(placement);\n  const isVertical = getSideAxis(placement) === 'y';\n  const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;\n  const crossAxisMulti = rtl && isVertical ? -1 : 1;\n  const rawValue = evaluate(options, state);\n\n  // eslint-disable-next-line prefer-const\n  let {\n    mainAxis,\n    crossAxis,\n    alignmentAxis\n  } = typeof rawValue === 'number' ? {\n    mainAxis: rawValue,\n    crossAxis: 0,\n    alignmentAxis: null\n  } : {\n    mainAxis: 0,\n    crossAxis: 0,\n    alignmentAxis: null,\n    ...rawValue\n  };\n  if (alignment && typeof alignmentAxis === 'number') {\n    crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;\n  }\n  return isVertical ? {\n    x: crossAxis * crossAxisMulti,\n    y: mainAxis * mainAxisMulti\n  } : {\n    x: mainAxis * mainAxisMulti,\n    y: crossAxis * crossAxisMulti\n  };\n}\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = function (options) {\n  if (options === void 0) {\n    options = 0;\n  }\n  return {\n    name: 'offset',\n    options,\n    async fn(state) {\n      var _middlewareData$offse, _middlewareData$arrow;\n      const {\n        x,\n        y,\n        placement,\n        middlewareData\n      } = state;\n      const diffCoords = await convertValueToCoords(state, options);\n\n      // If the placement is the same and the arrow caused an alignment offset\n      // then we don't need to change the positioning coordinates.\n      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      return {\n        x: x + diffCoords.x,\n        y: y + diffCoords.y,\n        data: {\n          ...diffCoords,\n          placement\n        }\n      };\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'shift',\n    options,\n    async fn(state) {\n      const {\n        x,\n        y,\n        placement\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = false,\n        limiter = {\n          fn: _ref => {\n            let {\n              x,\n              y\n            } = _ref;\n            return {\n              x,\n              y\n            };\n          }\n        },\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const crossAxis = getSideAxis(getSide(placement));\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      if (checkMainAxis) {\n        const minSide = mainAxis === 'y' ? 'top' : 'left';\n        const maxSide = mainAxis === 'y' ? 'bottom' : 'right';\n        const min = mainAxisCoord + overflow[minSide];\n        const max = mainAxisCoord - overflow[maxSide];\n        mainAxisCoord = clamp(min, mainAxisCoord, max);\n      }\n      if (checkCrossAxis) {\n        const minSide = crossAxis === 'y' ? 'top' : 'left';\n        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';\n        const min = crossAxisCoord + overflow[minSide];\n        const max = crossAxisCoord - overflow[maxSide];\n        crossAxisCoord = clamp(min, crossAxisCoord, max);\n      }\n      const limitedCoords = limiter.fn({\n        ...state,\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      });\n      return {\n        ...limitedCoords,\n        data: {\n          x: limitedCoords.x - x,\n          y: limitedCoords.y - y\n        }\n      };\n    }\n  };\n};\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    options,\n    fn(state) {\n      const {\n        x,\n        y,\n        placement,\n        rects,\n        middlewareData\n      } = state;\n      const {\n        offset = 0,\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const crossAxis = getSideAxis(placement);\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      const rawOffset = evaluate(offset, state);\n      const computedOffset = typeof rawOffset === 'number' ? {\n        mainAxis: rawOffset,\n        crossAxis: 0\n      } : {\n        mainAxis: 0,\n        crossAxis: 0,\n        ...rawOffset\n      };\n      if (checkMainAxis) {\n        const len = mainAxis === 'y' ? 'height' : 'width';\n        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;\n        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;\n        if (mainAxisCoord < limitMin) {\n          mainAxisCoord = limitMin;\n        } else if (mainAxisCoord > limitMax) {\n          mainAxisCoord = limitMax;\n        }\n      }\n      if (checkCrossAxis) {\n        var _middlewareData$offse, _middlewareData$offse2;\n        const len = mainAxis === 'y' ? 'width' : 'height';\n        const isOriginSide = ['top', 'left'].includes(getSide(placement));\n        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);\n        const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);\n        if (crossAxisCoord < limitMin) {\n          crossAxisCoord = limitMin;\n        } else if (crossAxisCoord > limitMax) {\n          crossAxisCoord = limitMax;\n        }\n      }\n      return {\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      };\n    }\n  };\n};\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'size',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        rects,\n        platform,\n        elements\n      } = state;\n      const {\n        apply = () => {},\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const side = getSide(placement);\n      const alignment = getAlignment(placement);\n      const isYAxis = getSideAxis(placement) === 'y';\n      const {\n        width,\n        height\n      } = rects.floating;\n      let heightSide;\n      let widthSide;\n      if (side === 'top' || side === 'bottom') {\n        heightSide = side;\n        widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right';\n      } else {\n        widthSide = side;\n        heightSide = alignment === 'end' ? 'top' : 'bottom';\n      }\n      const maximumClippingHeight = height - overflow.top - overflow.bottom;\n      const maximumClippingWidth = width - overflow.left - overflow.right;\n      const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);\n      const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);\n      const noShift = !state.middlewareData.shift;\n      let availableHeight = overflowAvailableHeight;\n      let availableWidth = overflowAvailableWidth;\n      if (isYAxis) {\n        availableWidth = alignment || noShift ? min(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;\n      } else {\n        availableHeight = alignment || noShift ? min(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight;\n      }\n      if (noShift && !alignment) {\n        const xMin = max(overflow.left, 0);\n        const xMax = max(overflow.right, 0);\n        const yMin = max(overflow.top, 0);\n        const yMax = max(overflow.bottom, 0);\n        if (isYAxis) {\n          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));\n        } else {\n          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));\n        }\n      }\n      await apply({\n        ...state,\n        availableWidth,\n        availableHeight\n      });\n      const nextDimensions = await platform.getDimensions(elements.floating);\n      if (width !== nextDimensions.width || height !== nextDimensions.height) {\n        return {\n          reset: {\n            rects: true\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\nexport { arrow, autoPlacement, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, shift, size };\n","function getNodeName(node) {\n  if (isNode(node)) {\n    return (node.nodeName || '').toLowerCase();\n  }\n  // Mocked nodes in testing environments may not be instances of Node. By\n  // returning `#document` an infinite loop won't occur.\n  // https://github.com/floating-ui/floating-ui/issues/2317\n  return '#document';\n}\nfunction getWindow(node) {\n  var _node$ownerDocument;\n  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;\n}\nfunction getDocumentElement(node) {\n  var _ref;\n  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;\n}\nfunction isNode(value) {\n  return value instanceof Node || value instanceof getWindow(value).Node;\n}\nfunction isElement(value) {\n  return value instanceof Element || value instanceof getWindow(value).Element;\n}\nfunction isHTMLElement(value) {\n  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;\n}\nfunction isShadowRoot(value) {\n  // Browsers without `ShadowRoot` support.\n  if (typeof ShadowRoot === 'undefined') {\n    return false;\n  }\n  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;\n}\nfunction isOverflowElement(element) {\n  const {\n    overflow,\n    overflowX,\n    overflowY,\n    display\n  } = getComputedStyle(element);\n  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);\n}\nfunction isTableElement(element) {\n  return ['table', 'td', 'th'].includes(getNodeName(element));\n}\nfunction isTopLayer(element) {\n  return [':popover-open', ':modal'].some(selector => {\n    try {\n      return element.matches(selector);\n    } catch (e) {\n      return false;\n    }\n  });\n}\nfunction isContainingBlock(elementOrCss) {\n  const webkit = isWebKit();\n  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));\n}\nfunction getContainingBlock(element) {\n  let currentNode = getParentNode(element);\n  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    if (isContainingBlock(currentNode)) {\n      return currentNode;\n    } else if (isTopLayer(currentNode)) {\n      return null;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  return null;\n}\nfunction isWebKit() {\n  if (typeof CSS === 'undefined' || !CSS.supports) return false;\n  return CSS.supports('-webkit-backdrop-filter', 'none');\n}\nfunction isLastTraversableNode(node) {\n  return ['html', 'body', '#document'].includes(getNodeName(node));\n}\nfunction getComputedStyle(element) {\n  return getWindow(element).getComputedStyle(element);\n}\nfunction getNodeScroll(element) {\n  if (isElement(element)) {\n    return {\n      scrollLeft: element.scrollLeft,\n      scrollTop: element.scrollTop\n    };\n  }\n  return {\n    scrollLeft: element.scrollX,\n    scrollTop: element.scrollY\n  };\n}\nfunction getParentNode(node) {\n  if (getNodeName(node) === 'html') {\n    return node;\n  }\n  const result =\n  // Step into the shadow DOM of the parent of a slotted node.\n  node.assignedSlot ||\n  // DOM Element detected.\n  node.parentNode ||\n  // ShadowRoot detected.\n  isShadowRoot(node) && node.host ||\n  // Fallback.\n  getDocumentElement(node);\n  return isShadowRoot(result) ? result.host : result;\n}\nfunction getNearestOverflowAncestor(node) {\n  const parentNode = getParentNode(node);\n  if (isLastTraversableNode(parentNode)) {\n    return node.ownerDocument ? node.ownerDocument.body : node.body;\n  }\n  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {\n    return parentNode;\n  }\n  return getNearestOverflowAncestor(parentNode);\n}\nfunction getOverflowAncestors(node, list, traverseIframes) {\n  var _node$ownerDocument2;\n  if (list === void 0) {\n    list = [];\n  }\n  if (traverseIframes === void 0) {\n    traverseIframes = true;\n  }\n  const scrollableAncestor = getNearestOverflowAncestor(node);\n  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);\n  const win = getWindow(scrollableAncestor);\n  if (isBody) {\n    const frameElement = getFrameElement(win);\n    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);\n  }\n  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));\n}\nfunction getFrameElement(win) {\n  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;\n}\n\nexport { getComputedStyle, getContainingBlock, getDocumentElement, getFrameElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isTopLayer, isWebKit };\n","import { rectToClientRect, detectOverflow as detectOverflow$1, offset as offset$1, autoPlacement as autoPlacement$1, shift as shift$1, flip as flip$1, size as size$1, hide as hide$1, arrow as arrow$1, inline as inline$1, limitShift as limitShift$1, computePosition as computePosition$1 } from '@floating-ui/core';\nimport { round, createCoords, max, min, floor } from '@floating-ui/utils';\nimport { getComputedStyle, isHTMLElement, isElement, getWindow, isWebKit, getFrameElement, getDocumentElement, isTopLayer, getNodeName, isOverflowElement, getNodeScroll, getOverflowAncestors, getParentNode, isLastTraversableNode, isContainingBlock, isTableElement, getContainingBlock } from '@floating-ui/utils/dom';\nexport { getOverflowAncestors } from '@floating-ui/utils/dom';\n\nfunction getCssDimensions(element) {\n  const css = getComputedStyle(element);\n  // In testing environments, the `width` and `height` properties are empty\n  // strings for SVG elements, returning NaN. Fallback to `0` in this case.\n  let width = parseFloat(css.width) || 0;\n  let height = parseFloat(css.height) || 0;\n  const hasOffset = isHTMLElement(element);\n  const offsetWidth = hasOffset ? element.offsetWidth : width;\n  const offsetHeight = hasOffset ? element.offsetHeight : height;\n  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;\n  if (shouldFallback) {\n    width = offsetWidth;\n    height = offsetHeight;\n  }\n  return {\n    width,\n    height,\n    $: shouldFallback\n  };\n}\n\nfunction unwrapElement(element) {\n  return !isElement(element) ? element.contextElement : element;\n}\n\nfunction getScale(element) {\n  const domElement = unwrapElement(element);\n  if (!isHTMLElement(domElement)) {\n    return createCoords(1);\n  }\n  const rect = domElement.getBoundingClientRect();\n  const {\n    width,\n    height,\n    $\n  } = getCssDimensions(domElement);\n  let x = ($ ? round(rect.width) : rect.width) / width;\n  let y = ($ ? round(rect.height) : rect.height) / height;\n\n  // 0, NaN, or Infinity should always fallback to 1.\n\n  if (!x || !Number.isFinite(x)) {\n    x = 1;\n  }\n  if (!y || !Number.isFinite(y)) {\n    y = 1;\n  }\n  return {\n    x,\n    y\n  };\n}\n\nconst noOffsets = /*#__PURE__*/createCoords(0);\nfunction getVisualOffsets(element) {\n  const win = getWindow(element);\n  if (!isWebKit() || !win.visualViewport) {\n    return noOffsets;\n  }\n  return {\n    x: win.visualViewport.offsetLeft,\n    y: win.visualViewport.offsetTop\n  };\n}\nfunction shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {\n  if (isFixed === void 0) {\n    isFixed = false;\n  }\n  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {\n    return false;\n  }\n  return isFixed;\n}\n\nfunction getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {\n  if (includeScale === void 0) {\n    includeScale = false;\n  }\n  if (isFixedStrategy === void 0) {\n    isFixedStrategy = false;\n  }\n  const clientRect = element.getBoundingClientRect();\n  const domElement = unwrapElement(element);\n  let scale = createCoords(1);\n  if (includeScale) {\n    if (offsetParent) {\n      if (isElement(offsetParent)) {\n        scale = getScale(offsetParent);\n      }\n    } else {\n      scale = getScale(element);\n    }\n  }\n  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);\n  let x = (clientRect.left + visualOffsets.x) / scale.x;\n  let y = (clientRect.top + visualOffsets.y) / scale.y;\n  let width = clientRect.width / scale.x;\n  let height = clientRect.height / scale.y;\n  if (domElement) {\n    const win = getWindow(domElement);\n    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;\n    let currentWin = win;\n    let currentIFrame = getFrameElement(currentWin);\n    while (currentIFrame && offsetParent && offsetWin !== currentWin) {\n      const iframeScale = getScale(currentIFrame);\n      const iframeRect = currentIFrame.getBoundingClientRect();\n      const css = getComputedStyle(currentIFrame);\n      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;\n      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;\n      x *= iframeScale.x;\n      y *= iframeScale.y;\n      width *= iframeScale.x;\n      height *= iframeScale.y;\n      x += left;\n      y += top;\n      currentWin = getWindow(currentIFrame);\n      currentIFrame = getFrameElement(currentWin);\n    }\n  }\n  return rectToClientRect({\n    width,\n    height,\n    x,\n    y\n  });\n}\n\nfunction convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {\n  let {\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  } = _ref;\n  const isFixed = strategy === 'fixed';\n  const documentElement = getDocumentElement(offsetParent);\n  const topLayer = elements ? isTopLayer(elements.floating) : false;\n  if (offsetParent === documentElement || topLayer && isFixed) {\n    return rect;\n  }\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  let scale = createCoords(1);\n  const offsets = createCoords(0);\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isHTMLElement(offsetParent)) {\n      const offsetRect = getBoundingClientRect(offsetParent);\n      scale = getScale(offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    }\n  }\n  return {\n    width: rect.width * scale.x,\n    height: rect.height * scale.y,\n    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,\n    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y\n  };\n}\n\nfunction getClientRects(element) {\n  return Array.from(element.getClientRects());\n}\n\nfunction getWindowScrollBarX(element) {\n  // If <html> has a CSS width greater than the viewport, then this will be\n  // incorrect for RTL.\n  return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;\n}\n\n// Gets the entire size of the scrollable document area, even extending outside\n// of the `<html>` and `<body>` rect bounds if horizontally scrollable.\nfunction getDocumentRect(element) {\n  const html = getDocumentElement(element);\n  const scroll = getNodeScroll(element);\n  const body = element.ownerDocument.body;\n  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);\n  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);\n  let x = -scroll.scrollLeft + getWindowScrollBarX(element);\n  const y = -scroll.scrollTop;\n  if (getComputedStyle(body).direction === 'rtl') {\n    x += max(html.clientWidth, body.clientWidth) - width;\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\nfunction getViewportRect(element, strategy) {\n  const win = getWindow(element);\n  const html = getDocumentElement(element);\n  const visualViewport = win.visualViewport;\n  let width = html.clientWidth;\n  let height = html.clientHeight;\n  let x = 0;\n  let y = 0;\n  if (visualViewport) {\n    width = visualViewport.width;\n    height = visualViewport.height;\n    const visualViewportBased = isWebKit();\n    if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {\n      x = visualViewport.offsetLeft;\n      y = visualViewport.offsetTop;\n    }\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\n// Returns the inner client rect, subtracting scrollbars if present.\nfunction getInnerBoundingClientRect(element, strategy) {\n  const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');\n  const top = clientRect.top + element.clientTop;\n  const left = clientRect.left + element.clientLeft;\n  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);\n  const width = element.clientWidth * scale.x;\n  const height = element.clientHeight * scale.y;\n  const x = left * scale.x;\n  const y = top * scale.y;\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\nfunction getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {\n  let rect;\n  if (clippingAncestor === 'viewport') {\n    rect = getViewportRect(element, strategy);\n  } else if (clippingAncestor === 'document') {\n    rect = getDocumentRect(getDocumentElement(element));\n  } else if (isElement(clippingAncestor)) {\n    rect = getInnerBoundingClientRect(clippingAncestor, strategy);\n  } else {\n    const visualOffsets = getVisualOffsets(element);\n    rect = {\n      ...clippingAncestor,\n      x: clippingAncestor.x - visualOffsets.x,\n      y: clippingAncestor.y - visualOffsets.y\n    };\n  }\n  return rectToClientRect(rect);\n}\nfunction hasFixedPositionAncestor(element, stopNode) {\n  const parentNode = getParentNode(element);\n  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {\n    return false;\n  }\n  return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);\n}\n\n// A \"clipping ancestor\" is an `overflow` element with the characteristic of\n// clipping (or hiding) child elements. This returns all clipping ancestors\n// of the given element up the tree.\nfunction getClippingElementAncestors(element, cache) {\n  const cachedResult = cache.get(element);\n  if (cachedResult) {\n    return cachedResult;\n  }\n  let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');\n  let currentContainingBlockComputedStyle = null;\n  const elementIsFixed = getComputedStyle(element).position === 'fixed';\n  let currentNode = elementIsFixed ? getParentNode(element) : element;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    const computedStyle = getComputedStyle(currentNode);\n    const currentNodeIsContaining = isContainingBlock(currentNode);\n    if (!currentNodeIsContaining && computedStyle.position === 'fixed') {\n      currentContainingBlockComputedStyle = null;\n    }\n    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);\n    if (shouldDropCurrentNode) {\n      // Drop non-containing blocks.\n      result = result.filter(ancestor => ancestor !== currentNode);\n    } else {\n      // Record last containing block for next iteration.\n      currentContainingBlockComputedStyle = computedStyle;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  cache.set(element, result);\n  return result;\n}\n\n// Gets the maximum area that the element is visible in due to any number of\n// clipping ancestors.\nfunction getClippingRect(_ref) {\n  let {\n    element,\n    boundary,\n    rootBoundary,\n    strategy\n  } = _ref;\n  const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);\n  const clippingAncestors = [...elementClippingAncestors, rootBoundary];\n  const firstClippingAncestor = clippingAncestors[0];\n  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {\n    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);\n    accRect.top = max(rect.top, accRect.top);\n    accRect.right = min(rect.right, accRect.right);\n    accRect.bottom = min(rect.bottom, accRect.bottom);\n    accRect.left = max(rect.left, accRect.left);\n    return accRect;\n  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));\n  return {\n    width: clippingRect.right - clippingRect.left,\n    height: clippingRect.bottom - clippingRect.top,\n    x: clippingRect.left,\n    y: clippingRect.top\n  };\n}\n\nfunction getDimensions(element) {\n  const {\n    width,\n    height\n  } = getCssDimensions(element);\n  return {\n    width,\n    height\n  };\n}\n\nfunction getRectRelativeToOffsetParent(element, offsetParent, strategy) {\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  const documentElement = getDocumentElement(offsetParent);\n  const isFixed = strategy === 'fixed';\n  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  const offsets = createCoords(0);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isOffsetParentAnElement) {\n      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    } else if (documentElement) {\n      offsets.x = getWindowScrollBarX(documentElement);\n    }\n  }\n  const x = rect.left + scroll.scrollLeft - offsets.x;\n  const y = rect.top + scroll.scrollTop - offsets.y;\n  return {\n    x,\n    y,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\nfunction isStaticPositioned(element) {\n  return getComputedStyle(element).position === 'static';\n}\n\nfunction getTrueOffsetParent(element, polyfill) {\n  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {\n    return null;\n  }\n  if (polyfill) {\n    return polyfill(element);\n  }\n  return element.offsetParent;\n}\n\n// Gets the closest ancestor positioned element. Handles some edge cases,\n// such as table ancestors and cross browser bugs.\nfunction getOffsetParent(element, polyfill) {\n  const win = getWindow(element);\n  if (isTopLayer(element)) {\n    return win;\n  }\n  if (!isHTMLElement(element)) {\n    let svgOffsetParent = getParentNode(element);\n    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {\n      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {\n        return svgOffsetParent;\n      }\n      svgOffsetParent = getParentNode(svgOffsetParent);\n    }\n    return win;\n  }\n  let offsetParent = getTrueOffsetParent(element, polyfill);\n  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {\n    offsetParent = getTrueOffsetParent(offsetParent, polyfill);\n  }\n  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {\n    return win;\n  }\n  return offsetParent || getContainingBlock(element) || win;\n}\n\nconst getElementRects = async function (data) {\n  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;\n  const getDimensionsFn = this.getDimensions;\n  const floatingDimensions = await getDimensionsFn(data.floating);\n  return {\n    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),\n    floating: {\n      x: 0,\n      y: 0,\n      width: floatingDimensions.width,\n      height: floatingDimensions.height\n    }\n  };\n};\n\nfunction isRTL(element) {\n  return getComputedStyle(element).direction === 'rtl';\n}\n\nconst platform = {\n  convertOffsetParentRelativeRectToViewportRelativeRect,\n  getDocumentElement,\n  getClippingRect,\n  getOffsetParent,\n  getElementRects,\n  getClientRects,\n  getDimensions,\n  getScale,\n  isElement,\n  isRTL\n};\n\n// https://samthor.au/2021/observing-dom/\nfunction observeMove(element, onMove) {\n  let io = null;\n  let timeoutId;\n  const root = getDocumentElement(element);\n  function cleanup() {\n    var _io;\n    clearTimeout(timeoutId);\n    (_io = io) == null || _io.disconnect();\n    io = null;\n  }\n  function refresh(skip, threshold) {\n    if (skip === void 0) {\n      skip = false;\n    }\n    if (threshold === void 0) {\n      threshold = 1;\n    }\n    cleanup();\n    const {\n      left,\n      top,\n      width,\n      height\n    } = element.getBoundingClientRect();\n    if (!skip) {\n      onMove();\n    }\n    if (!width || !height) {\n      return;\n    }\n    const insetTop = floor(top);\n    const insetRight = floor(root.clientWidth - (left + width));\n    const insetBottom = floor(root.clientHeight - (top + height));\n    const insetLeft = floor(left);\n    const rootMargin = -insetTop + \"px \" + -insetRight + \"px \" + -insetBottom + \"px \" + -insetLeft + \"px\";\n    const options = {\n      rootMargin,\n      threshold: max(0, min(1, threshold)) || 1\n    };\n    let isFirstUpdate = true;\n    function handleObserve(entries) {\n      const ratio = entries[0].intersectionRatio;\n      if (ratio !== threshold) {\n        if (!isFirstUpdate) {\n          return refresh();\n        }\n        if (!ratio) {\n          // If the reference is clipped, the ratio is 0. Throttle the refresh\n          // to prevent an infinite loop of updates.\n          timeoutId = setTimeout(() => {\n            refresh(false, 1e-7);\n          }, 1000);\n        } else {\n          refresh(false, ratio);\n        }\n      }\n      isFirstUpdate = false;\n    }\n\n    // Older browsers don't support a `document` as the root and will throw an\n    // error.\n    try {\n      io = new IntersectionObserver(handleObserve, {\n        ...options,\n        // Handle <iframe>s\n        root: root.ownerDocument\n      });\n    } catch (e) {\n      io = new IntersectionObserver(handleObserve, options);\n    }\n    io.observe(element);\n  }\n  refresh(true);\n  return cleanup;\n}\n\n/**\n * Automatically updates the position of the floating element when necessary.\n * Should only be called when the floating element is mounted on the DOM or\n * visible on the screen.\n * @returns cleanup function that should be invoked when the floating element is\n * removed from the DOM or hidden from the screen.\n * @see https://floating-ui.com/docs/autoUpdate\n */\nfunction autoUpdate(reference, floating, update, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    ancestorScroll = true,\n    ancestorResize = true,\n    elementResize = typeof ResizeObserver === 'function',\n    layoutShift = typeof IntersectionObserver === 'function',\n    animationFrame = false\n  } = options;\n  const referenceEl = unwrapElement(reference);\n  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];\n  ancestors.forEach(ancestor => {\n    ancestorScroll && ancestor.addEventListener('scroll', update, {\n      passive: true\n    });\n    ancestorResize && ancestor.addEventListener('resize', update);\n  });\n  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;\n  let reobserveFrame = -1;\n  let resizeObserver = null;\n  if (elementResize) {\n    resizeObserver = new ResizeObserver(_ref => {\n      let [firstEntry] = _ref;\n      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {\n        // Prevent update loops when using the `size` middleware.\n        // https://github.com/floating-ui/floating-ui/issues/1740\n        resizeObserver.unobserve(floating);\n        cancelAnimationFrame(reobserveFrame);\n        reobserveFrame = requestAnimationFrame(() => {\n          var _resizeObserver;\n          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);\n        });\n      }\n      update();\n    });\n    if (referenceEl && !animationFrame) {\n      resizeObserver.observe(referenceEl);\n    }\n    resizeObserver.observe(floating);\n  }\n  let frameId;\n  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;\n  if (animationFrame) {\n    frameLoop();\n  }\n  function frameLoop() {\n    const nextRefRect = getBoundingClientRect(reference);\n    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {\n      update();\n    }\n    prevRefRect = nextRefRect;\n    frameId = requestAnimationFrame(frameLoop);\n  }\n  update();\n  return () => {\n    var _resizeObserver2;\n    ancestors.forEach(ancestor => {\n      ancestorScroll && ancestor.removeEventListener('scroll', update);\n      ancestorResize && ancestor.removeEventListener('resize', update);\n    });\n    cleanupIo == null || cleanupIo();\n    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();\n    resizeObserver = null;\n    if (animationFrame) {\n      cancelAnimationFrame(frameId);\n    }\n  };\n}\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nconst detectOverflow = detectOverflow$1;\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = offset$1;\n\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = autoPlacement$1;\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = shift$1;\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = flip$1;\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = size$1;\n\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = hide$1;\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = arrow$1;\n\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = inline$1;\n\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = limitShift$1;\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n */\nconst computePosition = (reference, floating, options) => {\n  // This caches the expensive `getClippingElementAncestors` function so that\n  // multiple lifecycle resets re-use the same result. It only lives for a\n  // single call. If other functions become expensive, we can add them as well.\n  const cache = new Map();\n  const mergedOptions = {\n    platform,\n    ...options\n  };\n  const platformWithCache = {\n    ...mergedOptions.platform,\n    _c: cache\n  };\n  return computePosition$1(reference, floating, {\n    ...mergedOptions,\n    platform: platformWithCache\n  });\n};\n\nexport { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, platform, shift, size };\n"],"names":["root","this","Swipe","$","self","_typeof","global","_document","document","container","options","isScrolling","interval","start","delta","delay","auto","disabled","noop","offloadFn","fn","setTimeout","browser","addEventListener","touch","DocumentTouch","transitions","temp","props","i","undefined","style","createElement","slides","slidePos","width","length","element","children","index","parseInt","startSlide","speed","continuous","autoRestart","throttledSetup","threshhold","timeout","cancel","clearTimeout","throttledFn","context","args","arguments","apply","throttle","setup","events","handleEvent","event","type","move","end","transitionEnd","stopPropagation","touches","isMouseEvent","preventDefault","x","pageX","y","pageY","time","Date","scale","disableScroll","Math","abs","stop","translate","circle","duration","isValidSlide","Number","isPastBounds","direction","runCallback","getPos","removeEventListener","target","getAttribute","restart","runTransitionEnd","begin","slide","to","prev","next","disable","enable","getNumSlides","kill","visibility","left","pos","parentElement","removeChild","webkitTransitionDuration","MozTransitionDuration","msTransitionDuration","OTransitionDuration","transitionDuration","webkitTransform","msTransform","MozTransform","OTransform","detachEvents","onresize","cloneNode","el","clone","appendChild","setAttribute","removeAttribute","opts","prop","Array","getBoundingClientRect","offsetWidth","draggable","dir","callback","currentIndex","slideSpeed","natural_direction","diff","from","timer","setInterval","timeElap","clearInterval","floor","animate","dist","e","test","jQuery","Zepto","params","each","data","factory","onSuccess","response","onFail","url","alertFailure","slice","call","client","get","success","fail","contentType","cache","done","post","put","loadDataWithoutCache","dataType","window","console","log","statusText","status","HTTP_STATUS_UNAUTHORIZED","redirectToLogin","location","href","createConcatRequestMethod","shift","concat","createRequestMethod","getProductClass","getProductClassWithAttributes","getProductsByProductClass","productId","isAutoShip","getProductClassDTOList","productIds","api","dfd","id","getPromises","responses","collection","resolve","Status","HTTP_STATUS_OK","map","Content","combineResponses","promise","getDataForMultipleAPICalls","updateChartPrices","$cell","prodid","product","price","Price","substr","lastIndexOf","html","toFixed","HTTP_STATUS_CREATED","HTTP_STATUS_NOCONTENT","HTTP_STATUS_BADREQUEST","HTTP_STATUS_NOTFOUND","HTTP_STATUS_INTERNALSERVERERROR","HTTP_STATUS_SERVICEUNAVAILABLE","defaults","trigger","Tooltip","$trigger","contentElement","contentArray","_this","_classCallCheck","Error","_objectSpread","content","hasAttribute","innerHTML","title","listeners","hide","show","keyCode","toggle","splice","push","forEach","_ref","_ref2","_slicedToArray","listener","_isShown","key","value","$tooltip","build","display","update","removeProperty","_this2","computePosition","middleware","autoPlacement","offset","padding","arrow","$arrow","then","_ref3","placement","middlewareData","Object","assign","top","_middlewareData$arrow","arrowX","arrowY","staticSide","right","bottom","split","_defineProperty","clientWidth","random","toString","substring","classList","add","$content","replace","body","tooltip","$triggers","triggers","_toggleColicareTab","$click","animationOff","$tabDown","find","$tabUp","$tabs","addClass","removeClass","parent","slideToggle","_getHash","hash","_handleBuyClick","link","attr","_bindColicareCompareClick","on","_doColicareCompare","_bindColicareClick","$div","_bindBuyButtonClick","_bindFaqParameter","documentElement","scrollTo","init","_chartOpen","_calcSwipeWrapWidth","swipeColumnWidth","_calcColumnWidths","_getWindowOuterWidth","outerWidth","_calcTableHeight","$close","closeHeight","outerHeight","innerHeight","_getStyleValue","$element","css","_calcStyleOffset","$vertCell","_calcRowHeights","styleOffset","rows","_centerLabels","$parentCell","height","_sizeHeadImage","screenHeight","screen","_doiPhone4Sizing","$headCell","headCellHeight","vertCellHeight","remove","initChart","cellHeight","headHeight","getElementById","_showChart","smartPak","ui","modal","_bindChartOpen","_initHandleOrientation","_handleOrientationChange","matchMedia","matches","_hideOrientationWarning","_showOrientationWarning","screenWidth","innerWidth","insertBefore","_showInstructionsToolTip","sessionStorage","ccChartTipDisplayed","$ttElement","appendTo","_doAfterOpen","_getChartOpenValue","$win","colicare","ccCompare","ccChart","module","exports","alignments","placements","reduce","acc","side","min","max","round","createCoords","v","oppositeSideMap","oppositeAlignmentMap","clamp","param","axis","getAxisLength","includes","getAlignmentAxis","expandPaddingObject","rect","computeCoordsFromPlacement","rtl","reference","floating","sideAxis","alignmentAxis","alignLength","isVertical","commonX","commonY","commonAlign","coords","async","detectOverflow","state","_await$platform$isEle","platform","rects","elements","strategy","boundary","rootBoundary","elementContext","altBoundary","paddingObject","clippingClientRect","getClippingRect","isElement","contextElement","getDocumentElement","offsetParent","getOffsetParent","offsetScale","getScale","elementClientRect","convertOffsetParentRelativeRectToViewportRelativeRect","getNodeName","node","isNode","nodeName","toLowerCase","getWindow","_node$ownerDocument","ownerDocument","defaultView","Node","Element","isHTMLElement","HTMLElement","isShadowRoot","ShadowRoot","isOverflowElement","overflow","overflowX","overflowY","getComputedStyle","isTableElement","isTopLayer","some","selector","isContainingBlock","elementOrCss","webkit","isWebKit","transform","perspective","containerType","backdropFilter","filter","willChange","contain","CSS","supports","isLastTraversableNode","getNodeScroll","scrollLeft","scrollTop","scrollX","scrollY","getParentNode","result","assignedSlot","parentNode","host","getNearestOverflowAncestor","list","traverseIframes","_node$ownerDocument2","scrollableAncestor","isBody","win","frameElement","getFrameElement","visualViewport","getPrototypeOf","getCssDimensions","parseFloat","hasOffset","offsetHeight","shouldFallback","unwrapElement","domElement","isFinite","noOffsets","getVisualOffsets","offsetLeft","offsetTop","includeScale","isFixedStrategy","clientRect","visualOffsets","isFixed","floatingOffsetParent","shouldAddVisualOffsets","offsetWin","currentWin","currentIFrame","iframeScale","iframeRect","clientLeft","paddingLeft","clientTop","paddingTop","getWindowScrollBarX","getClientRectFromClippingAncestor","clippingAncestor","clientHeight","visualViewportBased","getViewportRect","scroll","scrollWidth","scrollHeight","getDocumentRect","getInnerBoundingClientRect","hasFixedPositionAncestor","stopNode","position","getRectRelativeToOffsetParent","isOffsetParentAnElement","offsets","offsetRect","isStaticPositioned","getTrueOffsetParent","polyfill","svgOffsetParent","currentNode","getContainingBlock","topLayer","clippingAncestors","cachedResult","currentContainingBlockComputedStyle","elementIsFixed","computedStyle","currentNodeIsContaining","ancestor","set","getClippingElementAncestors","_c","firstClippingAncestor","clippingRect","accRect","getElementRects","getOffsetParentFn","getDimensionsFn","getDimensions","floatingDimensions","getClientRects","isRTL","name","_middlewareData$offse","diffCoords","alignment","mainAxisMulti","crossAxisMulti","rawValue","mainAxis","crossAxis","convertValueToCoords","alignmentOffset","_middlewareData$autoP","_middlewareData$autoP2","_placementsThatFitOnE","allowedPlacements","autoAlignment","detectOverflowOptions","placements$1","getOppositeAlignmentPlacement","getPlacementList","currentPlacement","alignmentSides","mainAlignmentSide","reset","currentOverflows","allOverflows","overflows","nextPlacement","placementsSortedByMostSpace","d","sort","a","b","resetPlacement","every","checkMainAxis","checkCrossAxis","limiter","mainAxisCoord","crossAxisCoord","maxSide","limitedCoords","arrowDimensions","isYAxis","minProp","maxProp","clientProp","endDiff","startDiff","arrowOffsetParent","clientSize","centerToReference","largestPossiblePadding","minPadding","maxPadding","min$1","center","shouldAddOffset","centerOffset","Map","mergedOptions","platformWithCache","config","validMiddleware","Boolean","statefulPlacement","resetCount","nextX","initialPlacement","nextY"],"sourceRoot":""}