{"version":3,"file":"colicare.5bb5eef556518606fecf.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/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","webpack://front-end-build-system/./node_modules/@floating-ui/utils/dist/floating-ui.utils.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","/* eslint-disable one-var */\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    // eslint-disable-next-line newline-per-chained-call\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","/* eslint-disable sort-imports */\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;","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    ...rects.floating,\n    x,\n    y\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 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      if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== 'none') {\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$map$so;\n                const placement = (_overflowsData$map$so = overflowsData.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$map$so[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  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 overflowAvailableHeight = height - overflow[heightSide];\n      const overflowAvailableWidth = width - overflow[widthSide];\n      const noShift = !state.middlewareData.shift;\n      let availableHeight = overflowAvailableHeight;\n      let availableWidth = overflowAvailableWidth;\n      if (isYAxis) {\n        const maximumClippingWidth = width - overflow.left - overflow.right;\n        availableWidth = alignment || noShift ? min(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;\n      } else {\n        const maximumClippingHeight = height - overflow.top - overflow.bottom;\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 isContainingBlock(element) {\n  const webkit = isWebKit();\n  const css = getComputedStyle(element);\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 {\n      currentNode = getParentNode(currentNode);\n    }\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.pageXOffset,\n    scrollTop: element.pageYOffset\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    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);\n  }\n  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));\n}\n\nexport { getComputedStyle, getContainingBlock, getDocumentElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isWebKit };\n","import { rectToClientRect, 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';\nexport { detectOverflow, offset } from '@floating-ui/core';\nimport { round, createCoords, max, min, floor } from '@floating-ui/utils';\nimport { getComputedStyle, isHTMLElement, isElement, getWindow, isWebKit, getDocumentElement, 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 = currentWin.frameElement;\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 = currentWin.frameElement;\n    }\n  }\n  return rectToClientRect({\n    width,\n    height,\n    x,\n    y\n  });\n}\n\nconst topLayerSelectors = [':popover-open', ':modal'];\nfunction isTopLayer(floating) {\n  return topLayerSelectors.some(selector => {\n    try {\n      return floating.matches(selector);\n    } catch (e) {\n      return false;\n    }\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' ? 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 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 window = getWindow(element);\n  if (!isHTMLElement(element) || isTopLayer(element)) {\n    return window;\n  }\n  let offsetParent = getTrueOffsetParent(element, polyfill);\n  while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === 'static') {\n    offsetParent = getTrueOffsetParent(offsetParent, polyfill);\n  }\n  if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle(offsetParent).position === 'static' && !isContainingBlock(offsetParent))) {\n    return window;\n  }\n  return offsetParent || getContainingBlock(element) || window;\n}\n\nconst getElementRects = async function (data) {\n  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;\n  const getDimensionsFn = this.getDimensions;\n  return {\n    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),\n    floating: {\n      x: 0,\n      y: 0,\n      ...(await getDimensionsFn(data.floating))\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          timeoutId = setTimeout(() => {\n            refresh(false, 1e-7);\n          }, 100);\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 * 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, flip, hide, inline, limitShift, platform, shift, size };\n","/**\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  return {\n    ...rect,\n    top: rect.y,\n    left: rect.x,\n    right: rect.x + rect.width,\n    bottom: rect.y + rect.height\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"],"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","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","computeCoordsFromPlacement","rtl","reference","floating","sideAxis","alignmentAxis","alignLength","side","isVertical","commonX","commonY","commonAlign","coords","async","config","strategy","platform","validMiddleware","filter","Boolean","isRTL","rects","getElementRects","statefulPlacement","resetCount","name","nextX","nextY","reset","initialPlacement","elements","detectOverflow","state","_await$platform$isEle","boundary","rootBoundary","elementContext","altBoundary","paddingObject","clippingClientRect","getClippingRect","isElement","contextElement","getDocumentElement","rect","offsetParent","getOffsetParent","offsetScale","getScale","elementClientRect","convertOffsetParentRelativeRectToViewportRelativeRect","axis","arrowDimensions","getDimensions","isYAxis","minProp","maxProp","clientProp","endDiff","startDiff","arrowOffsetParent","clientSize","centerToReference","largestPossiblePadding","minPadding","maxPadding","min$1","max","center","shouldAddOffset","alignmentOffset","centerOffset","_middlewareData$autoP","_middlewareData$autoP2","_placementsThatFitOnE","crossAxis","alignment","allowedPlacements","autoAlignment","detectOverflowOptions","placements$1","getPlacementList","overflow","currentPlacement","alignmentSides","currentOverflows","allOverflows","overflows","nextPlacement","placementsSortedByMostSpace","d","reduce","acc","v","sort","a","b","resetPlacement","every","_middlewareData$offse","diffCoords","mainAxisMulti","includes","crossAxisMulti","rawValue","mainAxis","convertValueToCoords","checkMainAxis","checkCrossAxis","limiter","mainAxisCoord","crossAxisCoord","maxSide","min","limitedCoords","getNodeName","node","isNode","nodeName","toLowerCase","getWindow","_node$ownerDocument","ownerDocument","defaultView","Node","Element","isHTMLElement","HTMLElement","isShadowRoot","ShadowRoot","isOverflowElement","overflowX","overflowY","getComputedStyle","isTableElement","isContainingBlock","webkit","isWebKit","transform","perspective","containerType","backdropFilter","some","willChange","contain","CSS","supports","isLastTraversableNode","getNodeScroll","scrollLeft","scrollTop","pageXOffset","pageYOffset","getParentNode","result","assignedSlot","parentNode","host","getNearestOverflowAncestor","list","traverseIframes","_node$ownerDocument2","scrollableAncestor","isBody","win","visualViewport","frameElement","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","topLayerSelectors","isTopLayer","selector","getWindowScrollBarX","getClientRectFromClippingAncestor","clippingAncestor","clientHeight","visualViewportBased","getViewportRect","scroll","scrollWidth","scrollHeight","getDocumentRect","getInnerBoundingClientRect","hasFixedPositionAncestor","stopNode","position","getRectRelativeToOffsetParent","isOffsetParentAnElement","offsets","offsetRect","getTrueOffsetParent","polyfill","currentNode","getContainingBlock","topLayer","clippingAncestors","cachedResult","currentContainingBlockComputedStyle","elementIsFixed","computedStyle","currentNodeIsContaining","ancestor","set","getClippingElementAncestors","_c","firstClippingAncestor","clippingRect","accRect","getOffsetParentFn","getDimensionsFn","getClientRects","Map","mergedOptions","platformWithCache","alignments","placements","round","createCoords","oppositeSideMap","oppositeAlignmentMap","clamp","evaluate","param","getSide","getAlignment","getOppositeAxis","getAxisLength","getSideAxis","getAlignmentAxis","getAlignmentSides","mainAlignmentSide","getOppositePlacement","getOppositeAlignmentPlacement","getPaddingObject","expandPaddingObject","rectToClientRect"],"sourceRoot":""}