{"version":3,"file":"static/chunks/444-shopping-cart-11102026949-d3ac76128a8f948a.js","mappings":"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","sources":["webpack://_N_E/../../node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs","webpack://_N_E/../../node_modules/@floating-ui/core/dist/floating-ui.core.mjs","webpack://_N_E/../../node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs","webpack://_N_E/../../node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs","webpack://_N_E/../../node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs","webpack://_N_E/../../node_modules/embla-carousel-reactive-utils/esm/embla-carousel-reactive-utils.esm.js","webpack://_N_E/../../node_modules/embla-carousel/esm/embla-carousel.esm.js","webpack://_N_E/../../node_modules/embla-carousel-react/esm/embla-carousel-react.esm.js","webpack://_N_E/../../node_modules/next/dist/compiled/@babel/runtime/helpers/esm/arrayWithoutHoles.js","webpack://_N_E/../../node_modules/next/dist/compiled/@babel/runtime/helpers/esm/iterableToArray.js","webpack://_N_E/../../node_modules/next/dist/compiled/@babel/runtime/helpers/esm/nonIterableSpread.js","webpack://_N_E/../../node_modules/next/dist/compiled/@babel/runtime/helpers/esm/toConsumableArray.js"],"sourcesContent":["/**\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}\nconst yAxisSides = /*#__PURE__*/new Set(['top', 'bottom']);\nfunction getSideAxis(placement) {\n  return yAxisSides.has(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}\nconst lrPlacement = ['left', 'right'];\nconst rlPlacement = ['right', 'left'];\nconst tbPlacement = ['top', 'bottom'];\nconst btPlacement = ['bottom', 'top'];\nfunction getSideList(side, isStart, rtl) {\n  switch (side) {\n    case 'top':\n    case 'bottom':\n      if (rtl) return isStart ? rlPlacement : lrPlacement;\n      return isStart ? lrPlacement : rlPlacement;\n    case 'left':\n    case 'right':\n      return isStart ? tbPlacement : btPlacement;\n    default:\n      return [];\n  }\n}\nfunction getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {\n  const alignment = getAlignment(placement);\n  let list = getSideList(getSide(placement), direction === 'start', rtl);\n  if (alignment) {\n    list = list.map(side => side + \"-\" + alignment);\n    if (flipAlignment) {\n      list = list.concat(list.map(getOppositeAlignmentPlacement));\n    }\n  }\n  return list;\n}\nfunction getOppositePlacement(placement) {\n  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);\n}\nfunction expandPaddingObject(padding) {\n  return {\n    top: 0,\n    right: 0,\n    bottom: 0,\n    left: 0,\n    ...padding\n  };\n}\nfunction getPaddingObject(padding) {\n  return typeof padding !== 'number' ? expandPaddingObject(padding) : {\n    top: padding,\n    right: padding,\n    bottom: padding,\n    left: padding\n  };\n}\nfunction rectToClientRect(rect) {\n  const {\n    x,\n    y,\n    width,\n    height\n  } = rect;\n  return {\n    width,\n    height,\n    top: y,\n    left: x,\n    right: x + width,\n    bottom: y + height,\n    x,\n    y\n  };\n}\n\nexport { alignments, clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round, sides };\n","import { getSideAxis, getAlignmentAxis, getAxisLength, getSide, getAlignment, evaluate, getPaddingObject, rectToClientRect, min, clamp, placements, getAlignmentSides, getOppositeAlignmentPlacement, getOppositePlacement, getExpandedPlacements, getOppositeAxisPlacements, sides, max, getOppositeAxis } from '@floating-ui/utils';\nexport { rectToClientRect } from '@floating-ui/utils';\n\nfunction computeCoordsFromPlacement(_ref, placement, rtl) {\n  let {\n    reference,\n    floating\n  } = _ref;\n  const sideAxis = getSideAxis(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const alignLength = getAxisLength(alignmentAxis);\n  const side = getSide(placement);\n  const isVertical = sideAxis === 'y';\n  const commonX = reference.x + reference.width / 2 - floating.width / 2;\n  const commonY = reference.y + reference.height / 2 - floating.height / 2;\n  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;\n  let coords;\n  switch (side) {\n    case 'top':\n      coords = {\n        x: commonX,\n        y: reference.y - floating.height\n      };\n      break;\n    case 'bottom':\n      coords = {\n        x: commonX,\n        y: reference.y + reference.height\n      };\n      break;\n    case 'right':\n      coords = {\n        x: reference.x + reference.width,\n        y: commonY\n      };\n      break;\n    case 'left':\n      coords = {\n        x: reference.x - floating.width,\n        y: commonY\n      };\n      break;\n    default:\n      coords = {\n        x: reference.x,\n        y: reference.y\n      };\n  }\n  switch (getAlignment(placement)) {\n    case 'start':\n      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n    case 'end':\n      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n  }\n  return coords;\n}\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n *\n * This export does not have any `platform` interface logic. You will need to\n * write one for the platform you are using Floating UI with.\n */\nconst computePosition = async (reference, floating, config) => {\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform\n  } = config;\n  const validMiddleware = middleware.filter(Boolean);\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));\n  let rects = await platform.getElementRects({\n    reference,\n    floating,\n    strategy\n  });\n  let {\n    x,\n    y\n  } = computeCoordsFromPlacement(rects, placement, rtl);\n  let statefulPlacement = placement;\n  let middlewareData = {};\n  let resetCount = 0;\n  for (let i = 0; i < validMiddleware.length; i++) {\n    const {\n      name,\n      fn\n    } = validMiddleware[i];\n    const {\n      x: nextX,\n      y: nextY,\n      data,\n      reset\n    } = await fn({\n      x,\n      y,\n      initialPlacement: placement,\n      placement: statefulPlacement,\n      strategy,\n      middlewareData,\n      rects,\n      platform,\n      elements: {\n        reference,\n        floating\n      }\n    });\n    x = nextX != null ? nextX : x;\n    y = nextY != null ? nextY : y;\n    middlewareData = {\n      ...middlewareData,\n      [name]: {\n        ...middlewareData[name],\n        ...data\n      }\n    };\n    if (reset && resetCount <= 50) {\n      resetCount++;\n      if (typeof reset === 'object') {\n        if (reset.placement) {\n          statefulPlacement = reset.placement;\n        }\n        if (reset.rects) {\n          rects = reset.rects === true ? await platform.getElementRects({\n            reference,\n            floating,\n            strategy\n          }) : reset.rects;\n        }\n        ({\n          x,\n          y\n        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));\n      }\n      i = -1;\n    }\n  }\n  return {\n    x,\n    y,\n    placement: statefulPlacement,\n    strategy,\n    middlewareData\n  };\n};\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nasync function detectOverflow(state, options) {\n  var _await$platform$isEle;\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    x,\n    y,\n    platform,\n    rects,\n    elements,\n    strategy\n  } = state;\n  const {\n    boundary = 'clippingAncestors',\n    rootBoundary = 'viewport',\n    elementContext = 'floating',\n    altBoundary = false,\n    padding = 0\n  } = evaluate(options, state);\n  const paddingObject = getPaddingObject(padding);\n  const altContext = elementContext === 'floating' ? 'reference' : 'floating';\n  const element = elements[altBoundary ? altContext : elementContext];\n  const clippingClientRect = rectToClientRect(await platform.getClippingRect({\n    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),\n    boundary,\n    rootBoundary,\n    strategy\n  }));\n  const rect = elementContext === 'floating' ? {\n    x,\n    y,\n    width: rects.floating.width,\n    height: rects.floating.height\n  } : rects.reference;\n  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));\n  const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {\n    x: 1,\n    y: 1\n  } : {\n    x: 1,\n    y: 1\n  };\n  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  }) : rect);\n  return {\n    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,\n    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,\n    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,\n    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x\n  };\n}\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => ({\n  name: 'arrow',\n  options,\n  async fn(state) {\n    const {\n      x,\n      y,\n      placement,\n      rects,\n      platform,\n      elements,\n      middlewareData\n    } = state;\n    // Since `element` is required, we don't Partial<> the type.\n    const {\n      element,\n      padding = 0\n    } = evaluate(options, state) || {};\n    if (element == null) {\n      return {};\n    }\n    const paddingObject = getPaddingObject(padding);\n    const coords = {\n      x,\n      y\n    };\n    const axis = getAlignmentAxis(placement);\n    const length = getAxisLength(axis);\n    const arrowDimensions = await platform.getDimensions(element);\n    const isYAxis = axis === 'y';\n    const minProp = isYAxis ? 'top' : 'left';\n    const maxProp = isYAxis ? 'bottom' : 'right';\n    const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';\n    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];\n    const startDiff = coords[axis] - rects.reference[axis];\n    const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));\n    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;\n\n    // DOM platform can return `window` as the `offsetParent`.\n    if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {\n      clientSize = elements.floating[clientProp] || rects.floating[length];\n    }\n    const centerToReference = endDiff / 2 - startDiff / 2;\n\n    // If the padding is large enough that it causes the arrow to no longer be\n    // centered, modify the padding so that it is centered.\n    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;\n    const minPadding = min(paddingObject[minProp], largestPossiblePadding);\n    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);\n\n    // Make sure the arrow doesn't overflow the floating element if the center\n    // point is outside the floating element's bounds.\n    const min$1 = minPadding;\n    const max = clientSize - arrowDimensions[length] - maxPadding;\n    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;\n    const offset = clamp(min$1, center, max);\n\n    // If the reference is small enough that the arrow's padding causes it to\n    // to point to nothing for an aligned placement, adjust the offset of the\n    // floating element itself. To ensure `shift()` continues to take action,\n    // a single reset is performed when this is true.\n    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;\n    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;\n    return {\n      [axis]: coords[axis] + alignmentOffset,\n      data: {\n        [axis]: offset,\n        centerOffset: center - offset - alignmentOffset,\n        ...(shouldAddOffset && {\n          alignmentOffset\n        })\n      },\n      reset: shouldAddOffset\n    };\n  }\n});\n\nfunction getPlacementList(alignment, autoAlignment, allowedPlacements) {\n  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);\n  return allowedPlacementsSortedByAlignment.filter(placement => {\n    if (alignment) {\n      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);\n    }\n    return true;\n  });\n}\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'autoPlacement',\n    options,\n    async fn(state) {\n      var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;\n      const {\n        rects,\n        middlewareData,\n        placement,\n        platform,\n        elements\n      } = state;\n      const {\n        crossAxis = false,\n        alignment,\n        allowedPlacements = placements,\n        autoAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;\n      const currentPlacement = placements$1[currentIndex];\n      if (currentPlacement == null) {\n        return {};\n      }\n      const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));\n\n      // Make `computeCoords` start from the right place.\n      if (placement !== currentPlacement) {\n        return {\n          reset: {\n            placement: placements$1[0]\n          }\n        };\n      }\n      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];\n      const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {\n        placement: currentPlacement,\n        overflows: currentOverflows\n      }];\n      const nextPlacement = placements$1[currentIndex + 1];\n\n      // There are more placements to check.\n      if (nextPlacement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: nextPlacement\n          }\n        };\n      }\n      const placementsSortedByMostSpace = allOverflows.map(d => {\n        const alignment = getAlignment(d.placement);\n        return [d.placement, alignment && crossAxis ?\n        // Check along the mainAxis and main crossAxis side.\n        d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :\n        // Check only the mainAxis.\n        d.overflows[0], d.overflows];\n      }).sort((a, b) => a[1] - b[1]);\n      const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,\n      // Aligned placements should not check their opposite crossAxis\n      // side.\n      getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));\n      const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];\n      if (resetPlacement !== placement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: resetPlacement\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'flip',\n    options,\n    async fn(state) {\n      var _middlewareData$arrow, _middlewareData$flip;\n      const {\n        placement,\n        middlewareData,\n        rects,\n        initialPlacement,\n        platform,\n        elements\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true,\n        fallbackPlacements: specifiedFallbackPlacements,\n        fallbackStrategy = 'bestFit',\n        fallbackAxisSideDirection = 'none',\n        flipAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n\n      // If a reset by the arrow was caused due to an alignment offset being\n      // added, we should skip any logic now since `flip()` has already done its\n      // work.\n      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643\n      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      const side = getSide(placement);\n      const initialSideAxis = getSideAxis(initialPlacement);\n      const isBasePlacement = getSide(initialPlacement) === initialPlacement;\n      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));\n      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';\n      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {\n        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));\n      }\n      const placements = [initialPlacement, ...fallbackPlacements];\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const overflows = [];\n      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];\n      if (checkMainAxis) {\n        overflows.push(overflow[side]);\n      }\n      if (checkCrossAxis) {\n        const sides = getAlignmentSides(placement, rects, rtl);\n        overflows.push(overflow[sides[0]], overflow[sides[1]]);\n      }\n      overflowsData = [...overflowsData, {\n        placement,\n        overflows\n      }];\n\n      // One or more sides is overflowing.\n      if (!overflows.every(side => side <= 0)) {\n        var _middlewareData$flip2, _overflowsData$filter;\n        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;\n        const nextPlacement = placements[nextIndex];\n        if (nextPlacement) {\n          const ignoreCrossAxisOverflow = checkCrossAxis === 'alignment' ? initialSideAxis !== getSideAxis(nextPlacement) : false;\n          if (!ignoreCrossAxisOverflow ||\n          // We leave the current main axis only if every placement on that axis\n          // overflows the main axis.\n          overflowsData.every(d => d.overflows[0] > 0 && getSideAxis(d.placement) === initialSideAxis)) {\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\n        // First, find the candidates that fit on the mainAxis side of overflow,\n        // then find the placement that fits the best on the main crossAxis side.\n        let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;\n\n        // Otherwise fallback.\n        if (!resetPlacement) {\n          switch (fallbackStrategy) {\n            case 'bestFit':\n              {\n                var _overflowsData$filter2;\n                const placement = (_overflowsData$filter2 = overflowsData.filter(d => {\n                  if (hasFallbackAxisSideDirection) {\n                    const currentSideAxis = getSideAxis(d.placement);\n                    return currentSideAxis === initialSideAxis ||\n                    // Create a bias to the `y` side axis due to horizontal\n                    // reading directions favoring greater width.\n                    currentSideAxis === 'y';\n                  }\n                  return true;\n                }).map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];\n                if (placement) {\n                  resetPlacement = placement;\n                }\n                break;\n              }\n            case 'initialPlacement':\n              resetPlacement = initialPlacement;\n              break;\n          }\n        }\n        if (placement !== resetPlacement) {\n          return {\n            reset: {\n              placement: resetPlacement\n            }\n          };\n        }\n      }\n      return {};\n    }\n  };\n};\n\nfunction getSideOffsets(overflow, rect) {\n  return {\n    top: overflow.top - rect.height,\n    right: overflow.right - rect.width,\n    bottom: overflow.bottom - rect.height,\n    left: overflow.left - rect.width\n  };\n}\nfunction isAnySideFullyClipped(overflow) {\n  return sides.some(side => overflow[side] >= 0);\n}\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'hide',\n    options,\n    async fn(state) {\n      const {\n        rects\n      } = state;\n      const {\n        strategy = 'referenceHidden',\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      switch (strategy) {\n        case 'referenceHidden':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              elementContext: 'reference'\n            });\n            const offsets = getSideOffsets(overflow, rects.reference);\n            return {\n              data: {\n                referenceHiddenOffsets: offsets,\n                referenceHidden: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        case 'escaped':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              altBoundary: true\n            });\n            const offsets = getSideOffsets(overflow, rects.floating);\n            return {\n              data: {\n                escapedOffsets: offsets,\n                escaped: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        default:\n          {\n            return {};\n          }\n      }\n    }\n  };\n};\n\nfunction getBoundingRect(rects) {\n  const minX = min(...rects.map(rect => rect.left));\n  const minY = min(...rects.map(rect => rect.top));\n  const maxX = max(...rects.map(rect => rect.right));\n  const maxY = max(...rects.map(rect => rect.bottom));\n  return {\n    x: minX,\n    y: minY,\n    width: maxX - minX,\n    height: maxY - minY\n  };\n}\nfunction getRectsByLine(rects) {\n  const sortedRects = rects.slice().sort((a, b) => a.y - b.y);\n  const groups = [];\n  let prevRect = null;\n  for (let i = 0; i < sortedRects.length; i++) {\n    const rect = sortedRects[i];\n    if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {\n      groups.push([rect]);\n    } else {\n      groups[groups.length - 1].push(rect);\n    }\n    prevRect = rect;\n  }\n  return groups.map(rect => rectToClientRect(getBoundingRect(rect)));\n}\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'inline',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        elements,\n        rects,\n        platform,\n        strategy\n      } = state;\n      // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a\n      // ClientRect's bounds, despite the event listener being triggered. A\n      // padding of 2 seems to handle this issue.\n      const {\n        padding = 2,\n        x,\n        y\n      } = evaluate(options, state);\n      const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []);\n      const clientRects = getRectsByLine(nativeClientRects);\n      const fallback = rectToClientRect(getBoundingRect(nativeClientRects));\n      const paddingObject = getPaddingObject(padding);\n      function getBoundingClientRect() {\n        // There are two rects and they are disjoined.\n        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {\n          // Find the first rect in which the point is fully inside.\n          return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;\n        }\n\n        // There are 2 or more connected rects.\n        if (clientRects.length >= 2) {\n          if (getSideAxis(placement) === 'y') {\n            const firstRect = clientRects[0];\n            const lastRect = clientRects[clientRects.length - 1];\n            const isTop = getSide(placement) === 'top';\n            const top = firstRect.top;\n            const bottom = lastRect.bottom;\n            const left = isTop ? firstRect.left : lastRect.left;\n            const right = isTop ? firstRect.right : lastRect.right;\n            const width = right - left;\n            const height = bottom - top;\n            return {\n              top,\n              bottom,\n              left,\n              right,\n              width,\n              height,\n              x: left,\n              y: top\n            };\n          }\n          const isLeftSide = getSide(placement) === 'left';\n          const maxRight = max(...clientRects.map(rect => rect.right));\n          const minLeft = min(...clientRects.map(rect => rect.left));\n          const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight);\n          const top = measureRects[0].top;\n          const bottom = measureRects[measureRects.length - 1].bottom;\n          const left = minLeft;\n          const right = maxRight;\n          const width = right - left;\n          const height = bottom - top;\n          return {\n            top,\n            bottom,\n            left,\n            right,\n            width,\n            height,\n            x: left,\n            y: top\n          };\n        }\n        return fallback;\n      }\n      const resetRects = await platform.getElementRects({\n        reference: {\n          getBoundingClientRect\n        },\n        floating: elements.floating,\n        strategy\n      });\n      if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {\n        return {\n          reset: {\n            rects: resetRects\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\nconst originSides = /*#__PURE__*/new Set(['left', 'top']);\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 = originSides.has(side) ? -1 : 1;\n  const crossAxisMulti = rtl && isVertical ? -1 : 1;\n  const rawValue = evaluate(options, state);\n\n  // eslint-disable-next-line prefer-const\n  let {\n    mainAxis,\n    crossAxis,\n    alignmentAxis\n  } = typeof rawValue === 'number' ? {\n    mainAxis: rawValue,\n    crossAxis: 0,\n    alignmentAxis: null\n  } : {\n    mainAxis: rawValue.mainAxis || 0,\n    crossAxis: rawValue.crossAxis || 0,\n    alignmentAxis: rawValue.alignmentAxis\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          enabled: {\n            [mainAxis]: checkMainAxis,\n            [crossAxis]: checkCrossAxis\n          }\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 = originSides.has(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      var _state$middlewareData, _state$middlewareData2;\n      const {\n        placement,\n        rects,\n        platform,\n        elements\n      } = state;\n      const {\n        apply = () => {},\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const side = getSide(placement);\n      const alignment = getAlignment(placement);\n      const isYAxis = getSideAxis(placement) === 'y';\n      const {\n        width,\n        height\n      } = rects.floating;\n      let heightSide;\n      let widthSide;\n      if (side === 'top' || side === 'bottom') {\n        heightSide = side;\n        widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right';\n      } else {\n        widthSide = side;\n        heightSide = alignment === 'end' ? 'top' : 'bottom';\n      }\n      const maximumClippingHeight = height - overflow.top - overflow.bottom;\n      const maximumClippingWidth = width - overflow.left - overflow.right;\n      const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);\n      const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);\n      const noShift = !state.middlewareData.shift;\n      let availableHeight = overflowAvailableHeight;\n      let availableWidth = overflowAvailableWidth;\n      if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) {\n        availableWidth = maximumClippingWidth;\n      }\n      if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) {\n        availableHeight = 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 hasWindow() {\n  return typeof window !== 'undefined';\n}\nfunction 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  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof Node || value instanceof getWindow(value).Node;\n}\nfunction isElement(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof Element || value instanceof getWindow(value).Element;\n}\nfunction isHTMLElement(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;\n}\nfunction isShadowRoot(value) {\n  if (!hasWindow() || typeof ShadowRoot === 'undefined') {\n    return false;\n  }\n  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;\n}\nconst invalidOverflowDisplayValues = /*#__PURE__*/new Set(['inline', 'contents']);\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) && !invalidOverflowDisplayValues.has(display);\n}\nconst tableElements = /*#__PURE__*/new Set(['table', 'td', 'th']);\nfunction isTableElement(element) {\n  return tableElements.has(getNodeName(element));\n}\nconst topLayerSelectors = [':popover-open', ':modal'];\nfunction isTopLayer(element) {\n  return topLayerSelectors.some(selector => {\n    try {\n      return element.matches(selector);\n    } catch (_e) {\n      return false;\n    }\n  });\n}\nconst transformProperties = ['transform', 'translate', 'scale', 'rotate', 'perspective'];\nconst willChangeValues = ['transform', 'translate', 'scale', 'rotate', 'perspective', 'filter'];\nconst containValues = ['paint', 'layout', 'strict', 'content'];\nfunction isContainingBlock(elementOrCss) {\n  const webkit = isWebKit();\n  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  // https://drafts.csswg.org/css-transforms-2/#individual-transforms\n  return transformProperties.some(value => css[value] ? css[value] !== 'none' : false) || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || willChangeValues.some(value => (css.willChange || '').includes(value)) || containValues.some(value => (css.contain || '').includes(value));\n}\nfunction getContainingBlock(element) {\n  let currentNode = getParentNode(element);\n  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    if (isContainingBlock(currentNode)) {\n      return currentNode;\n    } else if (isTopLayer(currentNode)) {\n      return null;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  return null;\n}\nfunction isWebKit() {\n  if (typeof CSS === 'undefined' || !CSS.supports) return false;\n  return CSS.supports('-webkit-backdrop-filter', 'none');\n}\nconst lastTraversableNodeNames = /*#__PURE__*/new Set(['html', 'body', '#document']);\nfunction isLastTraversableNode(node) {\n  return lastTraversableNodeNames.has(getNodeName(node));\n}\nfunction getComputedStyle(element) {\n  return getWindow(element).getComputedStyle(element);\n}\nfunction getNodeScroll(element) {\n  if (isElement(element)) {\n    return {\n      scrollLeft: element.scrollLeft,\n      scrollTop: element.scrollTop\n    };\n  }\n  return {\n    scrollLeft: element.scrollX,\n    scrollTop: element.scrollY\n  };\n}\nfunction getParentNode(node) {\n  if (getNodeName(node) === 'html') {\n    return node;\n  }\n  const result =\n  // Step into the shadow DOM of the parent of a slotted node.\n  node.assignedSlot ||\n  // DOM Element detected.\n  node.parentNode ||\n  // ShadowRoot detected.\n  isShadowRoot(node) && node.host ||\n  // Fallback.\n  getDocumentElement(node);\n  return isShadowRoot(result) ? result.host : result;\n}\nfunction getNearestOverflowAncestor(node) {\n  const parentNode = getParentNode(node);\n  if (isLastTraversableNode(parentNode)) {\n    return node.ownerDocument ? node.ownerDocument.body : node.body;\n  }\n  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {\n    return parentNode;\n  }\n  return getNearestOverflowAncestor(parentNode);\n}\nfunction getOverflowAncestors(node, list, traverseIframes) {\n  var _node$ownerDocument2;\n  if (list === void 0) {\n    list = [];\n  }\n  if (traverseIframes === void 0) {\n    traverseIframes = true;\n  }\n  const scrollableAncestor = getNearestOverflowAncestor(node);\n  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);\n  const win = getWindow(scrollableAncestor);\n  if (isBody) {\n    const frameElement = getFrameElement(win);\n    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);\n  }\n  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));\n}\nfunction getFrameElement(win) {\n  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;\n}\n\nexport { getComputedStyle, getContainingBlock, getDocumentElement, getFrameElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isTopLayer, isWebKit };\n","import { rectToClientRect, arrow as arrow$1, autoPlacement as autoPlacement$1, detectOverflow as detectOverflow$1, flip as flip$1, hide as hide$1, inline as inline$1, limitShift as limitShift$1, offset as offset$1, shift as shift$1, size as size$1, computePosition as computePosition$1 } from '@floating-ui/core';\nimport { round, createCoords, max, min, floor } from '@floating-ui/utils';\nimport { getComputedStyle, isHTMLElement, isElement, getWindow, isWebKit, getFrameElement, getNodeScroll, getDocumentElement, isTopLayer, getNodeName, isOverflowElement, getOverflowAncestors, getParentNode, isLastTraversableNode, isContainingBlock, isTableElement, getContainingBlock } from '@floating-ui/utils/dom';\nexport { getOverflowAncestors } from '@floating-ui/utils/dom';\n\nfunction getCssDimensions(element) {\n  const css = getComputedStyle(element);\n  // In testing environments, the `width` and `height` properties are empty\n  // strings for SVG elements, returning NaN. Fallback to `0` in this case.\n  let width = parseFloat(css.width) || 0;\n  let height = parseFloat(css.height) || 0;\n  const hasOffset = isHTMLElement(element);\n  const offsetWidth = hasOffset ? element.offsetWidth : width;\n  const offsetHeight = hasOffset ? element.offsetHeight : height;\n  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;\n  if (shouldFallback) {\n    width = offsetWidth;\n    height = offsetHeight;\n  }\n  return {\n    width,\n    height,\n    $: shouldFallback\n  };\n}\n\nfunction unwrapElement(element) {\n  return !isElement(element) ? element.contextElement : element;\n}\n\nfunction getScale(element) {\n  const domElement = unwrapElement(element);\n  if (!isHTMLElement(domElement)) {\n    return createCoords(1);\n  }\n  const rect = domElement.getBoundingClientRect();\n  const {\n    width,\n    height,\n    $\n  } = getCssDimensions(domElement);\n  let x = ($ ? round(rect.width) : rect.width) / width;\n  let y = ($ ? round(rect.height) : rect.height) / height;\n\n  // 0, NaN, or Infinity should always fallback to 1.\n\n  if (!x || !Number.isFinite(x)) {\n    x = 1;\n  }\n  if (!y || !Number.isFinite(y)) {\n    y = 1;\n  }\n  return {\n    x,\n    y\n  };\n}\n\nconst noOffsets = /*#__PURE__*/createCoords(0);\nfunction getVisualOffsets(element) {\n  const win = getWindow(element);\n  if (!isWebKit() || !win.visualViewport) {\n    return noOffsets;\n  }\n  return {\n    x: win.visualViewport.offsetLeft,\n    y: win.visualViewport.offsetTop\n  };\n}\nfunction shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {\n  if (isFixed === void 0) {\n    isFixed = false;\n  }\n  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {\n    return false;\n  }\n  return isFixed;\n}\n\nfunction getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {\n  if (includeScale === void 0) {\n    includeScale = false;\n  }\n  if (isFixedStrategy === void 0) {\n    isFixedStrategy = false;\n  }\n  const clientRect = element.getBoundingClientRect();\n  const domElement = unwrapElement(element);\n  let scale = createCoords(1);\n  if (includeScale) {\n    if (offsetParent) {\n      if (isElement(offsetParent)) {\n        scale = getScale(offsetParent);\n      }\n    } else {\n      scale = getScale(element);\n    }\n  }\n  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);\n  let x = (clientRect.left + visualOffsets.x) / scale.x;\n  let y = (clientRect.top + visualOffsets.y) / scale.y;\n  let width = clientRect.width / scale.x;\n  let height = clientRect.height / scale.y;\n  if (domElement) {\n    const win = getWindow(domElement);\n    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;\n    let currentWin = win;\n    let currentIFrame = getFrameElement(currentWin);\n    while (currentIFrame && offsetParent && offsetWin !== currentWin) {\n      const iframeScale = getScale(currentIFrame);\n      const iframeRect = currentIFrame.getBoundingClientRect();\n      const css = getComputedStyle(currentIFrame);\n      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;\n      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;\n      x *= iframeScale.x;\n      y *= iframeScale.y;\n      width *= iframeScale.x;\n      height *= iframeScale.y;\n      x += left;\n      y += top;\n      currentWin = getWindow(currentIFrame);\n      currentIFrame = getFrameElement(currentWin);\n    }\n  }\n  return rectToClientRect({\n    width,\n    height,\n    x,\n    y\n  });\n}\n\n// If <html> has a CSS width greater than the viewport, then this will be\n// incorrect for RTL.\nfunction getWindowScrollBarX(element, rect) {\n  const leftScroll = getNodeScroll(element).scrollLeft;\n  if (!rect) {\n    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;\n  }\n  return rect.left + leftScroll;\n}\n\nfunction getHTMLOffset(documentElement, scroll, ignoreScrollbarX) {\n  if (ignoreScrollbarX === void 0) {\n    ignoreScrollbarX = false;\n  }\n  const htmlRect = documentElement.getBoundingClientRect();\n  const x = htmlRect.left + scroll.scrollLeft - (ignoreScrollbarX ? 0 :\n  // RTL <body> scrollbar.\n  getWindowScrollBarX(documentElement, htmlRect));\n  const y = htmlRect.top + scroll.scrollTop;\n  return {\n    x,\n    y\n  };\n}\n\nfunction convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {\n  let {\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  } = _ref;\n  const isFixed = strategy === 'fixed';\n  const documentElement = getDocumentElement(offsetParent);\n  const topLayer = elements ? isTopLayer(elements.floating) : false;\n  if (offsetParent === documentElement || topLayer && isFixed) {\n    return rect;\n  }\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  let scale = createCoords(1);\n  const offsets = createCoords(0);\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isHTMLElement(offsetParent)) {\n      const offsetRect = getBoundingClientRect(offsetParent);\n      scale = getScale(offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    }\n  }\n  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll, true) : createCoords(0);\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 + htmlOffset.x,\n    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y\n  };\n}\n\nfunction getClientRects(element) {\n  return Array.from(element.getClientRects());\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\nconst absoluteOrFixed = /*#__PURE__*/new Set(['absolute', 'fixed']);\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      x: clippingAncestor.x - visualOffsets.x,\n      y: clippingAncestor.y - visualOffsets.y,\n      width: clippingAncestor.width,\n      height: clippingAncestor.height\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 && absoluteOrFixed.has(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);\n    if (shouldDropCurrentNode) {\n      // Drop non-containing blocks.\n      result = result.filter(ancestor => ancestor !== currentNode);\n    } else {\n      // Record last containing block for next iteration.\n      currentContainingBlockComputedStyle = computedStyle;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  cache.set(element, result);\n  return result;\n}\n\n// Gets the maximum area that the element is visible in due to any number of\n// clipping ancestors.\nfunction getClippingRect(_ref) {\n  let {\n    element,\n    boundary,\n    rootBoundary,\n    strategy\n  } = _ref;\n  const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);\n  const clippingAncestors = [...elementClippingAncestors, rootBoundary];\n  const firstClippingAncestor = clippingAncestors[0];\n  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {\n    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);\n    accRect.top = max(rect.top, accRect.top);\n    accRect.right = min(rect.right, accRect.right);\n    accRect.bottom = min(rect.bottom, accRect.bottom);\n    accRect.left = max(rect.left, accRect.left);\n    return accRect;\n  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));\n  return {\n    width: clippingRect.right - clippingRect.left,\n    height: clippingRect.bottom - clippingRect.top,\n    x: clippingRect.left,\n    y: clippingRect.top\n  };\n}\n\nfunction getDimensions(element) {\n  const {\n    width,\n    height\n  } = getCssDimensions(element);\n  return {\n    width,\n    height\n  };\n}\n\nfunction getRectRelativeToOffsetParent(element, offsetParent, strategy) {\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  const documentElement = getDocumentElement(offsetParent);\n  const isFixed = strategy === 'fixed';\n  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  const offsets = createCoords(0);\n\n  // If the <body> scrollbar appears on the left (e.g. RTL systems). Use\n  // Firefox with layout.scrollbar.side = 3 in about:config to test this.\n  function setLeftRTLScrollbarOffset() {\n    offsets.x = getWindowScrollBarX(documentElement);\n  }\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      setLeftRTLScrollbarOffset();\n    }\n  }\n  if (isFixed && !isOffsetParentAnElement && documentElement) {\n    setLeftRTLScrollbarOffset();\n  }\n  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);\n  const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;\n  const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;\n  return {\n    x,\n    y,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\nfunction isStaticPositioned(element) {\n  return getComputedStyle(element).position === 'static';\n}\n\nfunction getTrueOffsetParent(element, polyfill) {\n  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {\n    return null;\n  }\n  if (polyfill) {\n    return polyfill(element);\n  }\n  let rawOffsetParent = element.offsetParent;\n\n  // Firefox returns the <html> element as the offsetParent if it's non-static,\n  // while Chrome and Safari return the <body> element. The <body> element must\n  // be used to perform the correct calculations even if the <html> element is\n  // non-static.\n  if (getDocumentElement(element) === rawOffsetParent) {\n    rawOffsetParent = rawOffsetParent.ownerDocument.body;\n  }\n  return rawOffsetParent;\n}\n\n// Gets the closest ancestor positioned element. Handles some edge cases,\n// such as table ancestors and cross browser bugs.\nfunction getOffsetParent(element, polyfill) {\n  const win = getWindow(element);\n  if (isTopLayer(element)) {\n    return win;\n  }\n  if (!isHTMLElement(element)) {\n    let svgOffsetParent = getParentNode(element);\n    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {\n      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {\n        return svgOffsetParent;\n      }\n      svgOffsetParent = getParentNode(svgOffsetParent);\n    }\n    return win;\n  }\n  let offsetParent = getTrueOffsetParent(element, polyfill);\n  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {\n    offsetParent = getTrueOffsetParent(offsetParent, polyfill);\n  }\n  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {\n    return win;\n  }\n  return offsetParent || getContainingBlock(element) || win;\n}\n\nconst getElementRects = async function (data) {\n  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;\n  const getDimensionsFn = this.getDimensions;\n  const floatingDimensions = await getDimensionsFn(data.floating);\n  return {\n    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),\n    floating: {\n      x: 0,\n      y: 0,\n      width: floatingDimensions.width,\n      height: floatingDimensions.height\n    }\n  };\n};\n\nfunction isRTL(element) {\n  return getComputedStyle(element).direction === 'rtl';\n}\n\nconst platform = {\n  convertOffsetParentRelativeRectToViewportRelativeRect,\n  getDocumentElement,\n  getClippingRect,\n  getOffsetParent,\n  getElementRects,\n  getClientRects,\n  getDimensions,\n  getScale,\n  isElement,\n  isRTL\n};\n\nfunction rectsAreEqual(a, b) {\n  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;\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 elementRectForRootMargin = element.getBoundingClientRect();\n    const {\n      left,\n      top,\n      width,\n      height\n    } = elementRectForRootMargin;\n    if (!skip) {\n      onMove();\n    }\n    if (!width || !height) {\n      return;\n    }\n    const insetTop = floor(top);\n    const insetRight = floor(root.clientWidth - (left + width));\n    const insetBottom = floor(root.clientHeight - (top + height));\n    const insetLeft = floor(left);\n    const rootMargin = -insetTop + \"px \" + -insetRight + \"px \" + -insetBottom + \"px \" + -insetLeft + \"px\";\n    const options = {\n      rootMargin,\n      threshold: max(0, min(1, threshold)) || 1\n    };\n    let isFirstUpdate = true;\n    function handleObserve(entries) {\n      const ratio = entries[0].intersectionRatio;\n      if (ratio !== threshold) {\n        if (!isFirstUpdate) {\n          return refresh();\n        }\n        if (!ratio) {\n          // If the reference is clipped, the ratio is 0. Throttle the refresh\n          // to prevent an infinite loop of updates.\n          timeoutId = setTimeout(() => {\n            refresh(false, 1e-7);\n          }, 1000);\n        } else {\n          refresh(false, ratio);\n        }\n      }\n      if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {\n        // It's possible that even though the ratio is reported as 1, the\n        // element is not actually fully within the IntersectionObserver's root\n        // area anymore. This can happen under performance constraints. This may\n        // be a bug in the browser's IntersectionObserver implementation. To\n        // work around this, we compare the element's bounding rect now with\n        // what it was at the time we created the IntersectionObserver. If they\n        // are not equal then the element moved, so we refresh.\n        refresh();\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 && !rectsAreEqual(prevRefRect, nextRefRect)) {\n      update();\n    }\n    prevRefRect = nextRefRect;\n    frameId = requestAnimationFrame(frameLoop);\n  }\n  update();\n  return () => {\n    var _resizeObserver2;\n    ancestors.forEach(ancestor => {\n      ancestorScroll && ancestor.removeEventListener('scroll', update);\n      ancestorResize && ancestor.removeEventListener('resize', update);\n    });\n    cleanupIo == null || cleanupIo();\n    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();\n    resizeObserver = null;\n    if (animationFrame) {\n      cancelAnimationFrame(frameId);\n    }\n  };\n}\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nconst detectOverflow = detectOverflow$1;\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = offset$1;\n\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = autoPlacement$1;\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = shift$1;\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = flip$1;\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = size$1;\n\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = hide$1;\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = arrow$1;\n\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = inline$1;\n\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = limitShift$1;\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n */\nconst computePosition = (reference, floating, options) => {\n  // This caches the expensive `getClippingElementAncestors` function so that\n  // multiple lifecycle resets re-use the same result. It only lives for a\n  // single call. If other functions become expensive, we can add them as well.\n  const cache = new Map();\n  const mergedOptions = {\n    platform,\n    ...options\n  };\n  const platformWithCache = {\n    ...mergedOptions.platform,\n    _c: cache\n  };\n  return computePosition$1(reference, floating, {\n    ...mergedOptions,\n    platform: platformWithCache\n  });\n};\n\nexport { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, platform, shift, size };\n","import { computePosition, arrow as arrow$2, autoPlacement as autoPlacement$1, flip as flip$1, hide as hide$1, inline as inline$1, limitShift as limitShift$1, offset as offset$1, shift as shift$1, size as size$1 } from '@floating-ui/dom';\nexport { autoUpdate, computePosition, detectOverflow, getOverflowAncestors, platform } from '@floating-ui/dom';\nimport * as React from 'react';\nimport { useLayoutEffect } from 'react';\nimport * as ReactDOM from 'react-dom';\n\nvar isClient = typeof document !== 'undefined';\n\nvar noop = function noop() {};\nvar index = isClient ? useLayoutEffect : noop;\n\n// Fork of `fast-deep-equal` that only does the comparisons we need and compares\n// functions\nfunction deepEqual(a, b) {\n  if (a === b) {\n    return true;\n  }\n  if (typeof a !== typeof b) {\n    return false;\n  }\n  if (typeof a === 'function' && a.toString() === b.toString()) {\n    return true;\n  }\n  let length;\n  let i;\n  let keys;\n  if (a && b && typeof a === 'object') {\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length !== b.length) return false;\n      for (i = length; i-- !== 0;) {\n        if (!deepEqual(a[i], b[i])) {\n          return false;\n        }\n      }\n      return true;\n    }\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) {\n      return false;\n    }\n    for (i = length; i-- !== 0;) {\n      if (!{}.hasOwnProperty.call(b, keys[i])) {\n        return false;\n      }\n    }\n    for (i = length; i-- !== 0;) {\n      const key = keys[i];\n      if (key === '_owner' && a.$$typeof) {\n        continue;\n      }\n      if (!deepEqual(a[key], b[key])) {\n        return false;\n      }\n    }\n    return true;\n  }\n  return a !== a && b !== b;\n}\n\nfunction getDPR(element) {\n  if (typeof window === 'undefined') {\n    return 1;\n  }\n  const win = element.ownerDocument.defaultView || window;\n  return win.devicePixelRatio || 1;\n}\n\nfunction roundByDPR(element, value) {\n  const dpr = getDPR(element);\n  return Math.round(value * dpr) / dpr;\n}\n\nfunction useLatestRef(value) {\n  const ref = React.useRef(value);\n  index(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n\n/**\n * Provides data to position a floating element.\n * @see https://floating-ui.com/docs/useFloating\n */\nfunction useFloating(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform,\n    elements: {\n      reference: externalReference,\n      floating: externalFloating\n    } = {},\n    transform = true,\n    whileElementsMounted,\n    open\n  } = options;\n  const [data, setData] = React.useState({\n    x: 0,\n    y: 0,\n    strategy,\n    placement,\n    middlewareData: {},\n    isPositioned: false\n  });\n  const [latestMiddleware, setLatestMiddleware] = React.useState(middleware);\n  if (!deepEqual(latestMiddleware, middleware)) {\n    setLatestMiddleware(middleware);\n  }\n  const [_reference, _setReference] = React.useState(null);\n  const [_floating, _setFloating] = React.useState(null);\n  const setReference = React.useCallback(node => {\n    if (node !== referenceRef.current) {\n      referenceRef.current = node;\n      _setReference(node);\n    }\n  }, []);\n  const setFloating = React.useCallback(node => {\n    if (node !== floatingRef.current) {\n      floatingRef.current = node;\n      _setFloating(node);\n    }\n  }, []);\n  const referenceEl = externalReference || _reference;\n  const floatingEl = externalFloating || _floating;\n  const referenceRef = React.useRef(null);\n  const floatingRef = React.useRef(null);\n  const dataRef = React.useRef(data);\n  const hasWhileElementsMounted = whileElementsMounted != null;\n  const whileElementsMountedRef = useLatestRef(whileElementsMounted);\n  const platformRef = useLatestRef(platform);\n  const openRef = useLatestRef(open);\n  const update = React.useCallback(() => {\n    if (!referenceRef.current || !floatingRef.current) {\n      return;\n    }\n    const config = {\n      placement,\n      strategy,\n      middleware: latestMiddleware\n    };\n    if (platformRef.current) {\n      config.platform = platformRef.current;\n    }\n    computePosition(referenceRef.current, floatingRef.current, config).then(data => {\n      const fullData = {\n        ...data,\n        // The floating element's position may be recomputed while it's closed\n        // but still mounted (such as when transitioning out). To ensure\n        // `isPositioned` will be `false` initially on the next open, avoid\n        // setting it to `true` when `open === false` (must be specified).\n        isPositioned: openRef.current !== false\n      };\n      if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {\n        dataRef.current = fullData;\n        ReactDOM.flushSync(() => {\n          setData(fullData);\n        });\n      }\n    });\n  }, [latestMiddleware, placement, strategy, platformRef, openRef]);\n  index(() => {\n    if (open === false && dataRef.current.isPositioned) {\n      dataRef.current.isPositioned = false;\n      setData(data => ({\n        ...data,\n        isPositioned: false\n      }));\n    }\n  }, [open]);\n  const isMountedRef = React.useRef(false);\n  index(() => {\n    isMountedRef.current = true;\n    return () => {\n      isMountedRef.current = false;\n    };\n  }, []);\n  index(() => {\n    if (referenceEl) referenceRef.current = referenceEl;\n    if (floatingEl) floatingRef.current = floatingEl;\n    if (referenceEl && floatingEl) {\n      if (whileElementsMountedRef.current) {\n        return whileElementsMountedRef.current(referenceEl, floatingEl, update);\n      }\n      update();\n    }\n  }, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);\n  const refs = React.useMemo(() => ({\n    reference: referenceRef,\n    floating: floatingRef,\n    setReference,\n    setFloating\n  }), [setReference, setFloating]);\n  const elements = React.useMemo(() => ({\n    reference: referenceEl,\n    floating: floatingEl\n  }), [referenceEl, floatingEl]);\n  const floatingStyles = React.useMemo(() => {\n    const initialStyles = {\n      position: strategy,\n      left: 0,\n      top: 0\n    };\n    if (!elements.floating) {\n      return initialStyles;\n    }\n    const x = roundByDPR(elements.floating, data.x);\n    const y = roundByDPR(elements.floating, data.y);\n    if (transform) {\n      return {\n        ...initialStyles,\n        transform: \"translate(\" + x + \"px, \" + y + \"px)\",\n        ...(getDPR(elements.floating) >= 1.5 && {\n          willChange: 'transform'\n        })\n      };\n    }\n    return {\n      position: strategy,\n      left: x,\n      top: y\n    };\n  }, [strategy, transform, elements.floating, data.x, data.y]);\n  return React.useMemo(() => ({\n    ...data,\n    update,\n    refs,\n    elements,\n    floatingStyles\n  }), [data, update, refs, elements, floatingStyles]);\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 * This wraps the core `arrow` middleware to allow React refs as the element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow$1 = options => {\n  function isRef(value) {\n    return {}.hasOwnProperty.call(value, 'current');\n  }\n  return {\n    name: 'arrow',\n    options,\n    fn(state) {\n      const {\n        element,\n        padding\n      } = typeof options === 'function' ? options(state) : options;\n      if (element && isRef(element)) {\n        if (element.current != null) {\n          return arrow$2({\n            element: element.current,\n            padding\n          }).fn(state);\n        }\n        return {};\n      }\n      if (element) {\n        return arrow$2({\n          element,\n          padding\n        }).fn(state);\n      }\n      return {};\n    }\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 = (options, deps) => ({\n  ...offset$1(options),\n  options: [options, deps]\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 = (options, deps) => ({\n  ...shift$1(options),\n  options: [options, deps]\n});\n\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = (options, deps) => ({\n  ...limitShift$1(options),\n  options: [options, deps]\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 = (options, deps) => ({\n  ...flip$1(options),\n  options: [options, deps]\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 = (options, deps) => ({\n  ...size$1(options),\n  options: [options, deps]\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 = (options, deps) => ({\n  ...autoPlacement$1(options),\n  options: [options, deps]\n});\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 = (options, deps) => ({\n  ...hide$1(options),\n  options: [options, deps]\n});\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 = (options, deps) => ({\n  ...inline$1(options),\n  options: [options, deps]\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 * This wraps the core `arrow` middleware to allow React refs as the element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = (options, deps) => ({\n  ...arrow$1(options),\n  options: [options, deps]\n});\n\nexport { arrow, autoPlacement, flip, hide, inline, limitShift, offset, shift, size, useFloating };\n","function isObject(subject) {\n  return Object.prototype.toString.call(subject) === '[object Object]';\n}\nfunction isRecord(subject) {\n  return isObject(subject) || Array.isArray(subject);\n}\nfunction canUseDOM() {\n  return !!(typeof window !== 'undefined' && window.document && window.document.createElement);\n}\nfunction areOptionsEqual(optionsA, optionsB) {\n  const optionsAKeys = Object.keys(optionsA);\n  const optionsBKeys = Object.keys(optionsB);\n  if (optionsAKeys.length !== optionsBKeys.length) return false;\n  const breakpointsA = JSON.stringify(Object.keys(optionsA.breakpoints || {}));\n  const breakpointsB = JSON.stringify(Object.keys(optionsB.breakpoints || {}));\n  if (breakpointsA !== breakpointsB) return false;\n  return optionsAKeys.every(key => {\n    const valueA = optionsA[key];\n    const valueB = optionsB[key];\n    if (typeof valueA === 'function') return `${valueA}` === `${valueB}`;\n    if (!isRecord(valueA) || !isRecord(valueB)) return valueA === valueB;\n    return areOptionsEqual(valueA, valueB);\n  });\n}\nfunction sortAndMapPluginToOptions(plugins) {\n  return plugins.concat().sort((a, b) => a.name > b.name ? 1 : -1).map(plugin => plugin.options);\n}\nfunction arePluginsEqual(pluginsA, pluginsB) {\n  if (pluginsA.length !== pluginsB.length) return false;\n  const optionsA = sortAndMapPluginToOptions(pluginsA);\n  const optionsB = sortAndMapPluginToOptions(pluginsB);\n  return optionsA.every((optionA, index) => {\n    const optionB = optionsB[index];\n    return areOptionsEqual(optionA, optionB);\n  });\n}\n\nexport { areOptionsEqual, arePluginsEqual, canUseDOM, sortAndMapPluginToOptions };\n//# sourceMappingURL=embla-carousel-reactive-utils.esm.js.map\n","function isNumber(subject) {\n  return typeof subject === 'number';\n}\nfunction isString(subject) {\n  return typeof subject === 'string';\n}\nfunction isBoolean(subject) {\n  return typeof subject === 'boolean';\n}\nfunction isObject(subject) {\n  return Object.prototype.toString.call(subject) === '[object Object]';\n}\nfunction mathAbs(n) {\n  return Math.abs(n);\n}\nfunction mathSign(n) {\n  return Math.sign(n);\n}\nfunction deltaAbs(valueB, valueA) {\n  return mathAbs(valueB - valueA);\n}\nfunction factorAbs(valueB, valueA) {\n  if (valueB === 0 || valueA === 0) return 0;\n  if (mathAbs(valueB) <= mathAbs(valueA)) return 0;\n  const diff = deltaAbs(mathAbs(valueB), mathAbs(valueA));\n  return mathAbs(diff / valueB);\n}\nfunction roundToTwoDecimals(num) {\n  return Math.round(num * 100) / 100;\n}\nfunction arrayKeys(array) {\n  return objectKeys(array).map(Number);\n}\nfunction arrayLast(array) {\n  return array[arrayLastIndex(array)];\n}\nfunction arrayLastIndex(array) {\n  return Math.max(0, array.length - 1);\n}\nfunction arrayIsLastIndex(array, index) {\n  return index === arrayLastIndex(array);\n}\nfunction arrayFromNumber(n, startAt = 0) {\n  return Array.from(Array(n), (_, i) => startAt + i);\n}\nfunction objectKeys(object) {\n  return Object.keys(object);\n}\nfunction objectsMergeDeep(objectA, objectB) {\n  return [objectA, objectB].reduce((mergedObjects, currentObject) => {\n    objectKeys(currentObject).forEach(key => {\n      const valueA = mergedObjects[key];\n      const valueB = currentObject[key];\n      const areObjects = isObject(valueA) && isObject(valueB);\n      mergedObjects[key] = areObjects ? objectsMergeDeep(valueA, valueB) : valueB;\n    });\n    return mergedObjects;\n  }, {});\n}\nfunction isMouseEvent(evt, ownerWindow) {\n  return typeof ownerWindow.MouseEvent !== 'undefined' && evt instanceof ownerWindow.MouseEvent;\n}\n\nfunction Alignment(align, viewSize) {\n  const predefined = {\n    start,\n    center,\n    end\n  };\n  function start() {\n    return 0;\n  }\n  function center(n) {\n    return end(n) / 2;\n  }\n  function end(n) {\n    return viewSize - n;\n  }\n  function measure(n, index) {\n    if (isString(align)) return predefined[align](n);\n    return align(viewSize, n, index);\n  }\n  const self = {\n    measure\n  };\n  return self;\n}\n\nfunction EventStore() {\n  let listeners = [];\n  function add(node, type, handler, options = {\n    passive: true\n  }) {\n    let removeListener;\n    if ('addEventListener' in node) {\n      node.addEventListener(type, handler, options);\n      removeListener = () => node.removeEventListener(type, handler, options);\n    } else {\n      const legacyMediaQueryList = node;\n      legacyMediaQueryList.addListener(handler);\n      removeListener = () => legacyMediaQueryList.removeListener(handler);\n    }\n    listeners.push(removeListener);\n    return self;\n  }\n  function clear() {\n    listeners = listeners.filter(remove => remove());\n  }\n  const self = {\n    add,\n    clear\n  };\n  return self;\n}\n\nfunction Animations(ownerDocument, ownerWindow, update, render) {\n  const documentVisibleHandler = EventStore();\n  const fixedTimeStep = 1000 / 60;\n  let lastTimeStamp = null;\n  let accumulatedTime = 0;\n  let animationId = 0;\n  function init() {\n    documentVisibleHandler.add(ownerDocument, 'visibilitychange', () => {\n      if (ownerDocument.hidden) reset();\n    });\n  }\n  function destroy() {\n    stop();\n    documentVisibleHandler.clear();\n  }\n  function animate(timeStamp) {\n    if (!animationId) return;\n    if (!lastTimeStamp) {\n      lastTimeStamp = timeStamp;\n      update();\n      update();\n    }\n    const timeElapsed = timeStamp - lastTimeStamp;\n    lastTimeStamp = timeStamp;\n    accumulatedTime += timeElapsed;\n    while (accumulatedTime >= fixedTimeStep) {\n      update();\n      accumulatedTime -= fixedTimeStep;\n    }\n    const alpha = accumulatedTime / fixedTimeStep;\n    render(alpha);\n    if (animationId) {\n      animationId = ownerWindow.requestAnimationFrame(animate);\n    }\n  }\n  function start() {\n    if (animationId) return;\n    animationId = ownerWindow.requestAnimationFrame(animate);\n  }\n  function stop() {\n    ownerWindow.cancelAnimationFrame(animationId);\n    lastTimeStamp = null;\n    accumulatedTime = 0;\n    animationId = 0;\n  }\n  function reset() {\n    lastTimeStamp = null;\n    accumulatedTime = 0;\n  }\n  const self = {\n    init,\n    destroy,\n    start,\n    stop,\n    update,\n    render\n  };\n  return self;\n}\n\nfunction Axis(axis, contentDirection) {\n  const isRightToLeft = contentDirection === 'rtl';\n  const isVertical = axis === 'y';\n  const scroll = isVertical ? 'y' : 'x';\n  const cross = isVertical ? 'x' : 'y';\n  const sign = !isVertical && isRightToLeft ? -1 : 1;\n  const startEdge = getStartEdge();\n  const endEdge = getEndEdge();\n  function measureSize(nodeRect) {\n    const {\n      height,\n      width\n    } = nodeRect;\n    return isVertical ? height : width;\n  }\n  function getStartEdge() {\n    if (isVertical) return 'top';\n    return isRightToLeft ? 'right' : 'left';\n  }\n  function getEndEdge() {\n    if (isVertical) return 'bottom';\n    return isRightToLeft ? 'left' : 'right';\n  }\n  function direction(n) {\n    return n * sign;\n  }\n  const self = {\n    scroll,\n    cross,\n    startEdge,\n    endEdge,\n    measureSize,\n    direction\n  };\n  return self;\n}\n\nfunction Limit(min = 0, max = 0) {\n  const length = mathAbs(min - max);\n  function reachedMin(n) {\n    return n < min;\n  }\n  function reachedMax(n) {\n    return n > max;\n  }\n  function reachedAny(n) {\n    return reachedMin(n) || reachedMax(n);\n  }\n  function constrain(n) {\n    if (!reachedAny(n)) return n;\n    return reachedMin(n) ? min : max;\n  }\n  function removeOffset(n) {\n    if (!length) return n;\n    return n - length * Math.ceil((n - max) / length);\n  }\n  const self = {\n    length,\n    max,\n    min,\n    constrain,\n    reachedAny,\n    reachedMax,\n    reachedMin,\n    removeOffset\n  };\n  return self;\n}\n\nfunction Counter(max, start, loop) {\n  const {\n    constrain\n  } = Limit(0, max);\n  const loopEnd = max + 1;\n  let counter = withinLimit(start);\n  function withinLimit(n) {\n    return !loop ? constrain(n) : mathAbs((loopEnd + n) % loopEnd);\n  }\n  function get() {\n    return counter;\n  }\n  function set(n) {\n    counter = withinLimit(n);\n    return self;\n  }\n  function add(n) {\n    return clone().set(get() + n);\n  }\n  function clone() {\n    return Counter(max, get(), loop);\n  }\n  const self = {\n    get,\n    set,\n    add,\n    clone\n  };\n  return self;\n}\n\nfunction DragHandler(axis, rootNode, ownerDocument, ownerWindow, target, dragTracker, location, animation, scrollTo, scrollBody, scrollTarget, index, eventHandler, percentOfView, dragFree, dragThreshold, skipSnaps, baseFriction, watchDrag) {\n  const {\n    cross: crossAxis,\n    direction\n  } = axis;\n  const focusNodes = ['INPUT', 'SELECT', 'TEXTAREA'];\n  const nonPassiveEvent = {\n    passive: false\n  };\n  const initEvents = EventStore();\n  const dragEvents = EventStore();\n  const goToNextThreshold = Limit(50, 225).constrain(percentOfView.measure(20));\n  const snapForceBoost = {\n    mouse: 300,\n    touch: 400\n  };\n  const freeForceBoost = {\n    mouse: 500,\n    touch: 600\n  };\n  const baseSpeed = dragFree ? 43 : 25;\n  let isMoving = false;\n  let startScroll = 0;\n  let startCross = 0;\n  let pointerIsDown = false;\n  let preventScroll = false;\n  let preventClick = false;\n  let isMouse = false;\n  function init(emblaApi) {\n    if (!watchDrag) return;\n    function downIfAllowed(evt) {\n      if (isBoolean(watchDrag) || watchDrag(emblaApi, evt)) down(evt);\n    }\n    const node = rootNode;\n    initEvents.add(node, 'dragstart', evt => evt.preventDefault(), nonPassiveEvent).add(node, 'touchmove', () => undefined, nonPassiveEvent).add(node, 'touchend', () => undefined).add(node, 'touchstart', downIfAllowed).add(node, 'mousedown', downIfAllowed).add(node, 'touchcancel', up).add(node, 'contextmenu', up).add(node, 'click', click, true);\n  }\n  function destroy() {\n    initEvents.clear();\n    dragEvents.clear();\n  }\n  function addDragEvents() {\n    const node = isMouse ? ownerDocument : rootNode;\n    dragEvents.add(node, 'touchmove', move, nonPassiveEvent).add(node, 'touchend', up).add(node, 'mousemove', move, nonPassiveEvent).add(node, 'mouseup', up);\n  }\n  function isFocusNode(node) {\n    const nodeName = node.nodeName || '';\n    return focusNodes.includes(nodeName);\n  }\n  function forceBoost() {\n    const boost = dragFree ? freeForceBoost : snapForceBoost;\n    const type = isMouse ? 'mouse' : 'touch';\n    return boost[type];\n  }\n  function allowedForce(force, targetChanged) {\n    const next = index.add(mathSign(force) * -1);\n    const baseForce = scrollTarget.byDistance(force, !dragFree).distance;\n    if (dragFree || mathAbs(force) < goToNextThreshold) return baseForce;\n    if (skipSnaps && targetChanged) return baseForce * 0.5;\n    return scrollTarget.byIndex(next.get(), 0).distance;\n  }\n  function down(evt) {\n    const isMouseEvt = isMouseEvent(evt, ownerWindow);\n    isMouse = isMouseEvt;\n    preventClick = dragFree && isMouseEvt && !evt.buttons && isMoving;\n    isMoving = deltaAbs(target.get(), location.get()) >= 2;\n    if (isMouseEvt && evt.button !== 0) return;\n    if (isFocusNode(evt.target)) return;\n    pointerIsDown = true;\n    dragTracker.pointerDown(evt);\n    scrollBody.useFriction(0).useDuration(0);\n    target.set(location);\n    addDragEvents();\n    startScroll = dragTracker.readPoint(evt);\n    startCross = dragTracker.readPoint(evt, crossAxis);\n    eventHandler.emit('pointerDown');\n  }\n  function move(evt) {\n    const isTouchEvt = !isMouseEvent(evt, ownerWindow);\n    if (isTouchEvt && evt.touches.length >= 2) return up(evt);\n    const lastScroll = dragTracker.readPoint(evt);\n    const lastCross = dragTracker.readPoint(evt, crossAxis);\n    const diffScroll = deltaAbs(lastScroll, startScroll);\n    const diffCross = deltaAbs(lastCross, startCross);\n    if (!preventScroll && !isMouse) {\n      if (!evt.cancelable) return up(evt);\n      preventScroll = diffScroll > diffCross;\n      if (!preventScroll) return up(evt);\n    }\n    const diff = dragTracker.pointerMove(evt);\n    if (diffScroll > dragThreshold) preventClick = true;\n    scrollBody.useFriction(0.3).useDuration(0.75);\n    animation.start();\n    target.add(direction(diff));\n    evt.preventDefault();\n  }\n  function up(evt) {\n    const currentLocation = scrollTarget.byDistance(0, false);\n    const targetChanged = currentLocation.index !== index.get();\n    const rawForce = dragTracker.pointerUp(evt) * forceBoost();\n    const force = allowedForce(direction(rawForce), targetChanged);\n    const forceFactor = factorAbs(rawForce, force);\n    const speed = baseSpeed - 10 * forceFactor;\n    const friction = baseFriction + forceFactor / 50;\n    preventScroll = false;\n    pointerIsDown = false;\n    dragEvents.clear();\n    scrollBody.useDuration(speed).useFriction(friction);\n    scrollTo.distance(force, !dragFree);\n    isMouse = false;\n    eventHandler.emit('pointerUp');\n  }\n  function click(evt) {\n    if (preventClick) {\n      evt.stopPropagation();\n      evt.preventDefault();\n      preventClick = false;\n    }\n  }\n  function pointerDown() {\n    return pointerIsDown;\n  }\n  const self = {\n    init,\n    destroy,\n    pointerDown\n  };\n  return self;\n}\n\nfunction DragTracker(axis, ownerWindow) {\n  const logInterval = 170;\n  let startEvent;\n  let lastEvent;\n  function readTime(evt) {\n    return evt.timeStamp;\n  }\n  function readPoint(evt, evtAxis) {\n    const property = evtAxis || axis.scroll;\n    const coord = `client${property === 'x' ? 'X' : 'Y'}`;\n    return (isMouseEvent(evt, ownerWindow) ? evt : evt.touches[0])[coord];\n  }\n  function pointerDown(evt) {\n    startEvent = evt;\n    lastEvent = evt;\n    return readPoint(evt);\n  }\n  function pointerMove(evt) {\n    const diff = readPoint(evt) - readPoint(lastEvent);\n    const expired = readTime(evt) - readTime(startEvent) > logInterval;\n    lastEvent = evt;\n    if (expired) startEvent = evt;\n    return diff;\n  }\n  function pointerUp(evt) {\n    if (!startEvent || !lastEvent) return 0;\n    const diffDrag = readPoint(lastEvent) - readPoint(startEvent);\n    const diffTime = readTime(evt) - readTime(startEvent);\n    const expired = readTime(evt) - readTime(lastEvent) > logInterval;\n    const force = diffDrag / diffTime;\n    const isFlick = diffTime && !expired && mathAbs(force) > 0.1;\n    return isFlick ? force : 0;\n  }\n  const self = {\n    pointerDown,\n    pointerMove,\n    pointerUp,\n    readPoint\n  };\n  return self;\n}\n\nfunction NodeRects() {\n  function measure(node) {\n    const {\n      offsetTop,\n      offsetLeft,\n      offsetWidth,\n      offsetHeight\n    } = node;\n    const offset = {\n      top: offsetTop,\n      right: offsetLeft + offsetWidth,\n      bottom: offsetTop + offsetHeight,\n      left: offsetLeft,\n      width: offsetWidth,\n      height: offsetHeight\n    };\n    return offset;\n  }\n  const self = {\n    measure\n  };\n  return self;\n}\n\nfunction PercentOfView(viewSize) {\n  function measure(n) {\n    return viewSize * (n / 100);\n  }\n  const self = {\n    measure\n  };\n  return self;\n}\n\nfunction ResizeHandler(container, eventHandler, ownerWindow, slides, axis, watchResize, nodeRects) {\n  const observeNodes = [container].concat(slides);\n  let resizeObserver;\n  let containerSize;\n  let slideSizes = [];\n  let destroyed = false;\n  function readSize(node) {\n    return axis.measureSize(nodeRects.measure(node));\n  }\n  function init(emblaApi) {\n    if (!watchResize) return;\n    containerSize = readSize(container);\n    slideSizes = slides.map(readSize);\n    function defaultCallback(entries) {\n      for (const entry of entries) {\n        if (destroyed) return;\n        const isContainer = entry.target === container;\n        const slideIndex = slides.indexOf(entry.target);\n        const lastSize = isContainer ? containerSize : slideSizes[slideIndex];\n        const newSize = readSize(isContainer ? container : slides[slideIndex]);\n        const diffSize = mathAbs(newSize - lastSize);\n        if (diffSize >= 0.5) {\n          emblaApi.reInit();\n          eventHandler.emit('resize');\n          break;\n        }\n      }\n    }\n    resizeObserver = new ResizeObserver(entries => {\n      if (isBoolean(watchResize) || watchResize(emblaApi, entries)) {\n        defaultCallback(entries);\n      }\n    });\n    ownerWindow.requestAnimationFrame(() => {\n      observeNodes.forEach(node => resizeObserver.observe(node));\n    });\n  }\n  function destroy() {\n    destroyed = true;\n    if (resizeObserver) resizeObserver.disconnect();\n  }\n  const self = {\n    init,\n    destroy\n  };\n  return self;\n}\n\nfunction ScrollBody(location, offsetLocation, previousLocation, target, baseDuration, baseFriction) {\n  let scrollVelocity = 0;\n  let scrollDirection = 0;\n  let scrollDuration = baseDuration;\n  let scrollFriction = baseFriction;\n  let rawLocation = location.get();\n  let rawLocationPrevious = 0;\n  function seek() {\n    const displacement = target.get() - location.get();\n    const isInstant = !scrollDuration;\n    let scrollDistance = 0;\n    if (isInstant) {\n      scrollVelocity = 0;\n      previousLocation.set(target);\n      location.set(target);\n      scrollDistance = displacement;\n    } else {\n      previousLocation.set(location);\n      scrollVelocity += displacement / scrollDuration;\n      scrollVelocity *= scrollFriction;\n      rawLocation += scrollVelocity;\n      location.add(scrollVelocity);\n      scrollDistance = rawLocation - rawLocationPrevious;\n    }\n    scrollDirection = mathSign(scrollDistance);\n    rawLocationPrevious = rawLocation;\n    return self;\n  }\n  function settled() {\n    const diff = target.get() - offsetLocation.get();\n    return mathAbs(diff) < 0.001;\n  }\n  function duration() {\n    return scrollDuration;\n  }\n  function direction() {\n    return scrollDirection;\n  }\n  function velocity() {\n    return scrollVelocity;\n  }\n  function useBaseDuration() {\n    return useDuration(baseDuration);\n  }\n  function useBaseFriction() {\n    return useFriction(baseFriction);\n  }\n  function useDuration(n) {\n    scrollDuration = n;\n    return self;\n  }\n  function useFriction(n) {\n    scrollFriction = n;\n    return self;\n  }\n  const self = {\n    direction,\n    duration,\n    velocity,\n    seek,\n    settled,\n    useBaseFriction,\n    useBaseDuration,\n    useFriction,\n    useDuration\n  };\n  return self;\n}\n\nfunction ScrollBounds(limit, location, target, scrollBody, percentOfView) {\n  const pullBackThreshold = percentOfView.measure(10);\n  const edgeOffsetTolerance = percentOfView.measure(50);\n  const frictionLimit = Limit(0.1, 0.99);\n  let disabled = false;\n  function shouldConstrain() {\n    if (disabled) return false;\n    if (!limit.reachedAny(target.get())) return false;\n    if (!limit.reachedAny(location.get())) return false;\n    return true;\n  }\n  function constrain(pointerDown) {\n    if (!shouldConstrain()) return;\n    const edge = limit.reachedMin(location.get()) ? 'min' : 'max';\n    const diffToEdge = mathAbs(limit[edge] - location.get());\n    const diffToTarget = target.get() - location.get();\n    const friction = frictionLimit.constrain(diffToEdge / edgeOffsetTolerance);\n    target.subtract(diffToTarget * friction);\n    if (!pointerDown && mathAbs(diffToTarget) < pullBackThreshold) {\n      target.set(limit.constrain(target.get()));\n      scrollBody.useDuration(25).useBaseFriction();\n    }\n  }\n  function toggleActive(active) {\n    disabled = !active;\n  }\n  const self = {\n    shouldConstrain,\n    constrain,\n    toggleActive\n  };\n  return self;\n}\n\nfunction ScrollContain(viewSize, contentSize, snapsAligned, containScroll, pixelTolerance) {\n  const scrollBounds = Limit(-contentSize + viewSize, 0);\n  const snapsBounded = measureBounded();\n  const scrollContainLimit = findScrollContainLimit();\n  const snapsContained = measureContained();\n  function usePixelTolerance(bound, snap) {\n    return deltaAbs(bound, snap) <= 1;\n  }\n  function findScrollContainLimit() {\n    const startSnap = snapsBounded[0];\n    const endSnap = arrayLast(snapsBounded);\n    const min = snapsBounded.lastIndexOf(startSnap);\n    const max = snapsBounded.indexOf(endSnap) + 1;\n    return Limit(min, max);\n  }\n  function measureBounded() {\n    return snapsAligned.map((snapAligned, index) => {\n      const {\n        min,\n        max\n      } = scrollBounds;\n      const snap = scrollBounds.constrain(snapAligned);\n      const isFirst = !index;\n      const isLast = arrayIsLastIndex(snapsAligned, index);\n      if (isFirst) return max;\n      if (isLast) return min;\n      if (usePixelTolerance(min, snap)) return min;\n      if (usePixelTolerance(max, snap)) return max;\n      return snap;\n    }).map(scrollBound => parseFloat(scrollBound.toFixed(3)));\n  }\n  function measureContained() {\n    if (contentSize <= viewSize + pixelTolerance) return [scrollBounds.max];\n    if (containScroll === 'keepSnaps') return snapsBounded;\n    const {\n      min,\n      max\n    } = scrollContainLimit;\n    return snapsBounded.slice(min, max);\n  }\n  const self = {\n    snapsContained,\n    scrollContainLimit\n  };\n  return self;\n}\n\nfunction ScrollLimit(contentSize, scrollSnaps, loop) {\n  const max = scrollSnaps[0];\n  const min = loop ? max - contentSize : arrayLast(scrollSnaps);\n  const limit = Limit(min, max);\n  const self = {\n    limit\n  };\n  return self;\n}\n\nfunction ScrollLooper(contentSize, limit, location, vectors) {\n  const jointSafety = 0.1;\n  const min = limit.min + jointSafety;\n  const max = limit.max + jointSafety;\n  const {\n    reachedMin,\n    reachedMax\n  } = Limit(min, max);\n  function shouldLoop(direction) {\n    if (direction === 1) return reachedMax(location.get());\n    if (direction === -1) return reachedMin(location.get());\n    return false;\n  }\n  function loop(direction) {\n    if (!shouldLoop(direction)) return;\n    const loopDistance = contentSize * (direction * -1);\n    vectors.forEach(v => v.add(loopDistance));\n  }\n  const self = {\n    loop\n  };\n  return self;\n}\n\nfunction ScrollProgress(limit) {\n  const {\n    max,\n    length\n  } = limit;\n  function get(n) {\n    const currentLocation = n - max;\n    return length ? currentLocation / -length : 0;\n  }\n  const self = {\n    get\n  };\n  return self;\n}\n\nfunction ScrollSnaps(axis, alignment, containerRect, slideRects, slidesToScroll) {\n  const {\n    startEdge,\n    endEdge\n  } = axis;\n  const {\n    groupSlides\n  } = slidesToScroll;\n  const alignments = measureSizes().map(alignment.measure);\n  const snaps = measureUnaligned();\n  const snapsAligned = measureAligned();\n  function measureSizes() {\n    return groupSlides(slideRects).map(rects => arrayLast(rects)[endEdge] - rects[0][startEdge]).map(mathAbs);\n  }\n  function measureUnaligned() {\n    return slideRects.map(rect => containerRect[startEdge] - rect[startEdge]).map(snap => -mathAbs(snap));\n  }\n  function measureAligned() {\n    return groupSlides(snaps).map(g => g[0]).map((snap, index) => snap + alignments[index]);\n  }\n  const self = {\n    snaps,\n    snapsAligned\n  };\n  return self;\n}\n\nfunction SlideRegistry(containSnaps, containScroll, scrollSnaps, scrollContainLimit, slidesToScroll, slideIndexes) {\n  const {\n    groupSlides\n  } = slidesToScroll;\n  const {\n    min,\n    max\n  } = scrollContainLimit;\n  const slideRegistry = createSlideRegistry();\n  function createSlideRegistry() {\n    const groupedSlideIndexes = groupSlides(slideIndexes);\n    const doNotContain = !containSnaps || containScroll === 'keepSnaps';\n    if (scrollSnaps.length === 1) return [slideIndexes];\n    if (doNotContain) return groupedSlideIndexes;\n    return groupedSlideIndexes.slice(min, max).map((group, index, groups) => {\n      const isFirst = !index;\n      const isLast = arrayIsLastIndex(groups, index);\n      if (isFirst) {\n        const range = arrayLast(groups[0]) + 1;\n        return arrayFromNumber(range);\n      }\n      if (isLast) {\n        const range = arrayLastIndex(slideIndexes) - arrayLast(groups)[0] + 1;\n        return arrayFromNumber(range, arrayLast(groups)[0]);\n      }\n      return group;\n    });\n  }\n  const self = {\n    slideRegistry\n  };\n  return self;\n}\n\nfunction ScrollTarget(loop, scrollSnaps, contentSize, limit, targetVector) {\n  const {\n    reachedAny,\n    removeOffset,\n    constrain\n  } = limit;\n  function minDistance(distances) {\n    return distances.concat().sort((a, b) => mathAbs(a) - mathAbs(b))[0];\n  }\n  function findTargetSnap(target) {\n    const distance = loop ? removeOffset(target) : constrain(target);\n    const ascDiffsToSnaps = scrollSnaps.map((snap, index) => ({\n      diff: shortcut(snap - distance, 0),\n      index\n    })).sort((d1, d2) => mathAbs(d1.diff) - mathAbs(d2.diff));\n    const {\n      index\n    } = ascDiffsToSnaps[0];\n    return {\n      index,\n      distance\n    };\n  }\n  function shortcut(target, direction) {\n    const targets = [target, target + contentSize, target - contentSize];\n    if (!loop) return target;\n    if (!direction) return minDistance(targets);\n    const matchingTargets = targets.filter(t => mathSign(t) === direction);\n    if (matchingTargets.length) return minDistance(matchingTargets);\n    return arrayLast(targets) - contentSize;\n  }\n  function byIndex(index, direction) {\n    const diffToSnap = scrollSnaps[index] - targetVector.get();\n    const distance = shortcut(diffToSnap, direction);\n    return {\n      index,\n      distance\n    };\n  }\n  function byDistance(distance, snap) {\n    const target = targetVector.get() + distance;\n    const {\n      index,\n      distance: targetSnapDistance\n    } = findTargetSnap(target);\n    const reachedBound = !loop && reachedAny(target);\n    if (!snap || reachedBound) return {\n      index,\n      distance\n    };\n    const diffToSnap = scrollSnaps[index] - targetSnapDistance;\n    const snapDistance = distance + shortcut(diffToSnap, 0);\n    return {\n      index,\n      distance: snapDistance\n    };\n  }\n  const self = {\n    byDistance,\n    byIndex,\n    shortcut\n  };\n  return self;\n}\n\nfunction ScrollTo(animation, indexCurrent, indexPrevious, scrollBody, scrollTarget, targetVector, eventHandler) {\n  function scrollTo(target) {\n    const distanceDiff = target.distance;\n    const indexDiff = target.index !== indexCurrent.get();\n    targetVector.add(distanceDiff);\n    if (distanceDiff) {\n      if (scrollBody.duration()) {\n        animation.start();\n      } else {\n        animation.update();\n        animation.render(1);\n        animation.update();\n      }\n    }\n    if (indexDiff) {\n      indexPrevious.set(indexCurrent.get());\n      indexCurrent.set(target.index);\n      eventHandler.emit('select');\n    }\n  }\n  function distance(n, snap) {\n    const target = scrollTarget.byDistance(n, snap);\n    scrollTo(target);\n  }\n  function index(n, direction) {\n    const targetIndex = indexCurrent.clone().set(n);\n    const target = scrollTarget.byIndex(targetIndex.get(), direction);\n    scrollTo(target);\n  }\n  const self = {\n    distance,\n    index\n  };\n  return self;\n}\n\nfunction SlideFocus(root, slides, slideRegistry, scrollTo, scrollBody, eventStore, eventHandler, watchFocus) {\n  const focusListenerOptions = {\n    passive: true,\n    capture: true\n  };\n  let lastTabPressTime = 0;\n  function init(emblaApi) {\n    if (!watchFocus) return;\n    function defaultCallback(index) {\n      const nowTime = new Date().getTime();\n      const diffTime = nowTime - lastTabPressTime;\n      if (diffTime > 10) return;\n      eventHandler.emit('slideFocusStart');\n      root.scrollLeft = 0;\n      const group = slideRegistry.findIndex(group => group.includes(index));\n      if (!isNumber(group)) return;\n      scrollBody.useDuration(0);\n      scrollTo.index(group, 0);\n      eventHandler.emit('slideFocus');\n    }\n    eventStore.add(document, 'keydown', registerTabPress, false);\n    slides.forEach((slide, slideIndex) => {\n      eventStore.add(slide, 'focus', evt => {\n        if (isBoolean(watchFocus) || watchFocus(emblaApi, evt)) {\n          defaultCallback(slideIndex);\n        }\n      }, focusListenerOptions);\n    });\n  }\n  function registerTabPress(event) {\n    if (event.code === 'Tab') lastTabPressTime = new Date().getTime();\n  }\n  const self = {\n    init\n  };\n  return self;\n}\n\nfunction Vector1D(initialValue) {\n  let value = initialValue;\n  function get() {\n    return value;\n  }\n  function set(n) {\n    value = normalizeInput(n);\n  }\n  function add(n) {\n    value += normalizeInput(n);\n  }\n  function subtract(n) {\n    value -= normalizeInput(n);\n  }\n  function normalizeInput(n) {\n    return isNumber(n) ? n : n.get();\n  }\n  const self = {\n    get,\n    set,\n    add,\n    subtract\n  };\n  return self;\n}\n\nfunction Translate(axis, container) {\n  const translate = axis.scroll === 'x' ? x : y;\n  const containerStyle = container.style;\n  let previousTarget = null;\n  let disabled = false;\n  function x(n) {\n    return `translate3d(${n}px,0px,0px)`;\n  }\n  function y(n) {\n    return `translate3d(0px,${n}px,0px)`;\n  }\n  function to(target) {\n    if (disabled) return;\n    const newTarget = roundToTwoDecimals(axis.direction(target));\n    if (newTarget === previousTarget) return;\n    containerStyle.transform = translate(newTarget);\n    previousTarget = newTarget;\n  }\n  function toggleActive(active) {\n    disabled = !active;\n  }\n  function clear() {\n    if (disabled) return;\n    containerStyle.transform = '';\n    if (!container.getAttribute('style')) container.removeAttribute('style');\n  }\n  const self = {\n    clear,\n    to,\n    toggleActive\n  };\n  return self;\n}\n\nfunction SlideLooper(axis, viewSize, contentSize, slideSizes, slideSizesWithGaps, snaps, scrollSnaps, location, slides) {\n  const roundingSafety = 0.5;\n  const ascItems = arrayKeys(slideSizesWithGaps);\n  const descItems = arrayKeys(slideSizesWithGaps).reverse();\n  const loopPoints = startPoints().concat(endPoints());\n  function removeSlideSizes(indexes, from) {\n    return indexes.reduce((a, i) => {\n      return a - slideSizesWithGaps[i];\n    }, from);\n  }\n  function slidesInGap(indexes, gap) {\n    return indexes.reduce((a, i) => {\n      const remainingGap = removeSlideSizes(a, gap);\n      return remainingGap > 0 ? a.concat([i]) : a;\n    }, []);\n  }\n  function findSlideBounds(offset) {\n    return snaps.map((snap, index) => ({\n      start: snap - slideSizes[index] + roundingSafety + offset,\n      end: snap + viewSize - roundingSafety + offset\n    }));\n  }\n  function findLoopPoints(indexes, offset, isEndEdge) {\n    const slideBounds = findSlideBounds(offset);\n    return indexes.map(index => {\n      const initial = isEndEdge ? 0 : -contentSize;\n      const altered = isEndEdge ? contentSize : 0;\n      const boundEdge = isEndEdge ? 'end' : 'start';\n      const loopPoint = slideBounds[index][boundEdge];\n      return {\n        index,\n        loopPoint,\n        slideLocation: Vector1D(-1),\n        translate: Translate(axis, slides[index]),\n        target: () => location.get() > loopPoint ? initial : altered\n      };\n    });\n  }\n  function startPoints() {\n    const gap = scrollSnaps[0];\n    const indexes = slidesInGap(descItems, gap);\n    return findLoopPoints(indexes, contentSize, false);\n  }\n  function endPoints() {\n    const gap = viewSize - scrollSnaps[0] - 1;\n    const indexes = slidesInGap(ascItems, gap);\n    return findLoopPoints(indexes, -contentSize, true);\n  }\n  function canLoop() {\n    return loopPoints.every(({\n      index\n    }) => {\n      const otherIndexes = ascItems.filter(i => i !== index);\n      return removeSlideSizes(otherIndexes, viewSize) <= 0.1;\n    });\n  }\n  function loop() {\n    loopPoints.forEach(loopPoint => {\n      const {\n        target,\n        translate,\n        slideLocation\n      } = loopPoint;\n      const shiftLocation = target();\n      if (shiftLocation === slideLocation.get()) return;\n      translate.to(shiftLocation);\n      slideLocation.set(shiftLocation);\n    });\n  }\n  function clear() {\n    loopPoints.forEach(loopPoint => loopPoint.translate.clear());\n  }\n  const self = {\n    canLoop,\n    clear,\n    loop,\n    loopPoints\n  };\n  return self;\n}\n\nfunction SlidesHandler(container, eventHandler, watchSlides) {\n  let mutationObserver;\n  let destroyed = false;\n  function init(emblaApi) {\n    if (!watchSlides) return;\n    function defaultCallback(mutations) {\n      for (const mutation of mutations) {\n        if (mutation.type === 'childList') {\n          emblaApi.reInit();\n          eventHandler.emit('slidesChanged');\n          break;\n        }\n      }\n    }\n    mutationObserver = new MutationObserver(mutations => {\n      if (destroyed) return;\n      if (isBoolean(watchSlides) || watchSlides(emblaApi, mutations)) {\n        defaultCallback(mutations);\n      }\n    });\n    mutationObserver.observe(container, {\n      childList: true\n    });\n  }\n  function destroy() {\n    if (mutationObserver) mutationObserver.disconnect();\n    destroyed = true;\n  }\n  const self = {\n    init,\n    destroy\n  };\n  return self;\n}\n\nfunction SlidesInView(container, slides, eventHandler, threshold) {\n  const intersectionEntryMap = {};\n  let inViewCache = null;\n  let notInViewCache = null;\n  let intersectionObserver;\n  let destroyed = false;\n  function init() {\n    intersectionObserver = new IntersectionObserver(entries => {\n      if (destroyed) return;\n      entries.forEach(entry => {\n        const index = slides.indexOf(entry.target);\n        intersectionEntryMap[index] = entry;\n      });\n      inViewCache = null;\n      notInViewCache = null;\n      eventHandler.emit('slidesInView');\n    }, {\n      root: container.parentElement,\n      threshold\n    });\n    slides.forEach(slide => intersectionObserver.observe(slide));\n  }\n  function destroy() {\n    if (intersectionObserver) intersectionObserver.disconnect();\n    destroyed = true;\n  }\n  function createInViewList(inView) {\n    return objectKeys(intersectionEntryMap).reduce((list, slideIndex) => {\n      const index = parseInt(slideIndex);\n      const {\n        isIntersecting\n      } = intersectionEntryMap[index];\n      const inViewMatch = inView && isIntersecting;\n      const notInViewMatch = !inView && !isIntersecting;\n      if (inViewMatch || notInViewMatch) list.push(index);\n      return list;\n    }, []);\n  }\n  function get(inView = true) {\n    if (inView && inViewCache) return inViewCache;\n    if (!inView && notInViewCache) return notInViewCache;\n    const slideIndexes = createInViewList(inView);\n    if (inView) inViewCache = slideIndexes;\n    if (!inView) notInViewCache = slideIndexes;\n    return slideIndexes;\n  }\n  const self = {\n    init,\n    destroy,\n    get\n  };\n  return self;\n}\n\nfunction SlideSizes(axis, containerRect, slideRects, slides, readEdgeGap, ownerWindow) {\n  const {\n    measureSize,\n    startEdge,\n    endEdge\n  } = axis;\n  const withEdgeGap = slideRects[0] && readEdgeGap;\n  const startGap = measureStartGap();\n  const endGap = measureEndGap();\n  const slideSizes = slideRects.map(measureSize);\n  const slideSizesWithGaps = measureWithGaps();\n  function measureStartGap() {\n    if (!withEdgeGap) return 0;\n    const slideRect = slideRects[0];\n    return mathAbs(containerRect[startEdge] - slideRect[startEdge]);\n  }\n  function measureEndGap() {\n    if (!withEdgeGap) return 0;\n    const style = ownerWindow.getComputedStyle(arrayLast(slides));\n    return parseFloat(style.getPropertyValue(`margin-${endEdge}`));\n  }\n  function measureWithGaps() {\n    return slideRects.map((rect, index, rects) => {\n      const isFirst = !index;\n      const isLast = arrayIsLastIndex(rects, index);\n      if (isFirst) return slideSizes[index] + startGap;\n      if (isLast) return slideSizes[index] + endGap;\n      return rects[index + 1][startEdge] - rect[startEdge];\n    }).map(mathAbs);\n  }\n  const self = {\n    slideSizes,\n    slideSizesWithGaps,\n    startGap,\n    endGap\n  };\n  return self;\n}\n\nfunction SlidesToScroll(axis, viewSize, slidesToScroll, loop, containerRect, slideRects, startGap, endGap, pixelTolerance) {\n  const {\n    startEdge,\n    endEdge,\n    direction\n  } = axis;\n  const groupByNumber = isNumber(slidesToScroll);\n  function byNumber(array, groupSize) {\n    return arrayKeys(array).filter(i => i % groupSize === 0).map(i => array.slice(i, i + groupSize));\n  }\n  function bySize(array) {\n    if (!array.length) return [];\n    return arrayKeys(array).reduce((groups, rectB, index) => {\n      const rectA = arrayLast(groups) || 0;\n      const isFirst = rectA === 0;\n      const isLast = rectB === arrayLastIndex(array);\n      const edgeA = containerRect[startEdge] - slideRects[rectA][startEdge];\n      const edgeB = containerRect[startEdge] - slideRects[rectB][endEdge];\n      const gapA = !loop && isFirst ? direction(startGap) : 0;\n      const gapB = !loop && isLast ? direction(endGap) : 0;\n      const chunkSize = mathAbs(edgeB - gapB - (edgeA + gapA));\n      if (index && chunkSize > viewSize + pixelTolerance) groups.push(rectB);\n      if (isLast) groups.push(array.length);\n      return groups;\n    }, []).map((currentSize, index, groups) => {\n      const previousSize = Math.max(groups[index - 1] || 0);\n      return array.slice(previousSize, currentSize);\n    });\n  }\n  function groupSlides(array) {\n    return groupByNumber ? byNumber(array, slidesToScroll) : bySize(array);\n  }\n  const self = {\n    groupSlides\n  };\n  return self;\n}\n\nfunction Engine(root, container, slides, ownerDocument, ownerWindow, options, eventHandler) {\n  // Options\n  const {\n    align,\n    axis: scrollAxis,\n    direction,\n    startIndex,\n    loop,\n    duration,\n    dragFree,\n    dragThreshold,\n    inViewThreshold,\n    slidesToScroll: groupSlides,\n    skipSnaps,\n    containScroll,\n    watchResize,\n    watchSlides,\n    watchDrag,\n    watchFocus\n  } = options;\n  // Measurements\n  const pixelTolerance = 2;\n  const nodeRects = NodeRects();\n  const containerRect = nodeRects.measure(container);\n  const slideRects = slides.map(nodeRects.measure);\n  const axis = Axis(scrollAxis, direction);\n  const viewSize = axis.measureSize(containerRect);\n  const percentOfView = PercentOfView(viewSize);\n  const alignment = Alignment(align, viewSize);\n  const containSnaps = !loop && !!containScroll;\n  const readEdgeGap = loop || !!containScroll;\n  const {\n    slideSizes,\n    slideSizesWithGaps,\n    startGap,\n    endGap\n  } = SlideSizes(axis, containerRect, slideRects, slides, readEdgeGap, ownerWindow);\n  const slidesToScroll = SlidesToScroll(axis, viewSize, groupSlides, loop, containerRect, slideRects, startGap, endGap, pixelTolerance);\n  const {\n    snaps,\n    snapsAligned\n  } = ScrollSnaps(axis, alignment, containerRect, slideRects, slidesToScroll);\n  const contentSize = -arrayLast(snaps) + arrayLast(slideSizesWithGaps);\n  const {\n    snapsContained,\n    scrollContainLimit\n  } = ScrollContain(viewSize, contentSize, snapsAligned, containScroll, pixelTolerance);\n  const scrollSnaps = containSnaps ? snapsContained : snapsAligned;\n  const {\n    limit\n  } = ScrollLimit(contentSize, scrollSnaps, loop);\n  // Indexes\n  const index = Counter(arrayLastIndex(scrollSnaps), startIndex, loop);\n  const indexPrevious = index.clone();\n  const slideIndexes = arrayKeys(slides);\n  // Animation\n  const update = ({\n    dragHandler,\n    scrollBody,\n    scrollBounds,\n    options: {\n      loop\n    }\n  }) => {\n    if (!loop) scrollBounds.constrain(dragHandler.pointerDown());\n    scrollBody.seek();\n  };\n  const render = ({\n    scrollBody,\n    translate,\n    location,\n    offsetLocation,\n    previousLocation,\n    scrollLooper,\n    slideLooper,\n    dragHandler,\n    animation,\n    eventHandler,\n    scrollBounds,\n    options: {\n      loop\n    }\n  }, alpha) => {\n    const shouldSettle = scrollBody.settled();\n    const withinBounds = !scrollBounds.shouldConstrain();\n    const hasSettled = loop ? shouldSettle : shouldSettle && withinBounds;\n    const hasSettledAndIdle = hasSettled && !dragHandler.pointerDown();\n    if (hasSettledAndIdle) animation.stop();\n    const interpolatedLocation = location.get() * alpha + previousLocation.get() * (1 - alpha);\n    offsetLocation.set(interpolatedLocation);\n    if (loop) {\n      scrollLooper.loop(scrollBody.direction());\n      slideLooper.loop();\n    }\n    translate.to(offsetLocation.get());\n    if (hasSettledAndIdle) eventHandler.emit('settle');\n    if (!hasSettled) eventHandler.emit('scroll');\n  };\n  const animation = Animations(ownerDocument, ownerWindow, () => update(engine), alpha => render(engine, alpha));\n  // Shared\n  const friction = 0.68;\n  const startLocation = scrollSnaps[index.get()];\n  const location = Vector1D(startLocation);\n  const previousLocation = Vector1D(startLocation);\n  const offsetLocation = Vector1D(startLocation);\n  const target = Vector1D(startLocation);\n  const scrollBody = ScrollBody(location, offsetLocation, previousLocation, target, duration, friction);\n  const scrollTarget = ScrollTarget(loop, scrollSnaps, contentSize, limit, target);\n  const scrollTo = ScrollTo(animation, index, indexPrevious, scrollBody, scrollTarget, target, eventHandler);\n  const scrollProgress = ScrollProgress(limit);\n  const eventStore = EventStore();\n  const slidesInView = SlidesInView(container, slides, eventHandler, inViewThreshold);\n  const {\n    slideRegistry\n  } = SlideRegistry(containSnaps, containScroll, scrollSnaps, scrollContainLimit, slidesToScroll, slideIndexes);\n  const slideFocus = SlideFocus(root, slides, slideRegistry, scrollTo, scrollBody, eventStore, eventHandler, watchFocus);\n  // Engine\n  const engine = {\n    ownerDocument,\n    ownerWindow,\n    eventHandler,\n    containerRect,\n    slideRects,\n    animation,\n    axis,\n    dragHandler: DragHandler(axis, root, ownerDocument, ownerWindow, target, DragTracker(axis, ownerWindow), location, animation, scrollTo, scrollBody, scrollTarget, index, eventHandler, percentOfView, dragFree, dragThreshold, skipSnaps, friction, watchDrag),\n    eventStore,\n    percentOfView,\n    index,\n    indexPrevious,\n    limit,\n    location,\n    offsetLocation,\n    previousLocation,\n    options,\n    resizeHandler: ResizeHandler(container, eventHandler, ownerWindow, slides, axis, watchResize, nodeRects),\n    scrollBody,\n    scrollBounds: ScrollBounds(limit, offsetLocation, target, scrollBody, percentOfView),\n    scrollLooper: ScrollLooper(contentSize, limit, offsetLocation, [location, offsetLocation, previousLocation, target]),\n    scrollProgress,\n    scrollSnapList: scrollSnaps.map(scrollProgress.get),\n    scrollSnaps,\n    scrollTarget,\n    scrollTo,\n    slideLooper: SlideLooper(axis, viewSize, contentSize, slideSizes, slideSizesWithGaps, snaps, scrollSnaps, offsetLocation, slides),\n    slideFocus,\n    slidesHandler: SlidesHandler(container, eventHandler, watchSlides),\n    slidesInView,\n    slideIndexes,\n    slideRegistry,\n    slidesToScroll,\n    target,\n    translate: Translate(axis, container)\n  };\n  return engine;\n}\n\nfunction EventHandler() {\n  let listeners = {};\n  let api;\n  function init(emblaApi) {\n    api = emblaApi;\n  }\n  function getListeners(evt) {\n    return listeners[evt] || [];\n  }\n  function emit(evt) {\n    getListeners(evt).forEach(e => e(api, evt));\n    return self;\n  }\n  function on(evt, cb) {\n    listeners[evt] = getListeners(evt).concat([cb]);\n    return self;\n  }\n  function off(evt, cb) {\n    listeners[evt] = getListeners(evt).filter(e => e !== cb);\n    return self;\n  }\n  function clear() {\n    listeners = {};\n  }\n  const self = {\n    init,\n    emit,\n    off,\n    on,\n    clear\n  };\n  return self;\n}\n\nconst defaultOptions = {\n  align: 'center',\n  axis: 'x',\n  container: null,\n  slides: null,\n  containScroll: 'trimSnaps',\n  direction: 'ltr',\n  slidesToScroll: 1,\n  inViewThreshold: 0,\n  breakpoints: {},\n  dragFree: false,\n  dragThreshold: 10,\n  loop: false,\n  skipSnaps: false,\n  duration: 25,\n  startIndex: 0,\n  active: true,\n  watchDrag: true,\n  watchResize: true,\n  watchSlides: true,\n  watchFocus: true\n};\n\nfunction OptionsHandler(ownerWindow) {\n  function mergeOptions(optionsA, optionsB) {\n    return objectsMergeDeep(optionsA, optionsB || {});\n  }\n  function optionsAtMedia(options) {\n    const optionsAtMedia = options.breakpoints || {};\n    const matchedMediaOptions = objectKeys(optionsAtMedia).filter(media => ownerWindow.matchMedia(media).matches).map(media => optionsAtMedia[media]).reduce((a, mediaOption) => mergeOptions(a, mediaOption), {});\n    return mergeOptions(options, matchedMediaOptions);\n  }\n  function optionsMediaQueries(optionsList) {\n    return optionsList.map(options => objectKeys(options.breakpoints || {})).reduce((acc, mediaQueries) => acc.concat(mediaQueries), []).map(ownerWindow.matchMedia);\n  }\n  const self = {\n    mergeOptions,\n    optionsAtMedia,\n    optionsMediaQueries\n  };\n  return self;\n}\n\nfunction PluginsHandler(optionsHandler) {\n  let activePlugins = [];\n  function init(emblaApi, plugins) {\n    activePlugins = plugins.filter(({\n      options\n    }) => optionsHandler.optionsAtMedia(options).active !== false);\n    activePlugins.forEach(plugin => plugin.init(emblaApi, optionsHandler));\n    return plugins.reduce((map, plugin) => Object.assign(map, {\n      [plugin.name]: plugin\n    }), {});\n  }\n  function destroy() {\n    activePlugins = activePlugins.filter(plugin => plugin.destroy());\n  }\n  const self = {\n    init,\n    destroy\n  };\n  return self;\n}\n\nfunction EmblaCarousel(root, userOptions, userPlugins) {\n  const ownerDocument = root.ownerDocument;\n  const ownerWindow = ownerDocument.defaultView;\n  const optionsHandler = OptionsHandler(ownerWindow);\n  const pluginsHandler = PluginsHandler(optionsHandler);\n  const mediaHandlers = EventStore();\n  const eventHandler = EventHandler();\n  const {\n    mergeOptions,\n    optionsAtMedia,\n    optionsMediaQueries\n  } = optionsHandler;\n  const {\n    on,\n    off,\n    emit\n  } = eventHandler;\n  const reInit = reActivate;\n  let destroyed = false;\n  let engine;\n  let optionsBase = mergeOptions(defaultOptions, EmblaCarousel.globalOptions);\n  let options = mergeOptions(optionsBase);\n  let pluginList = [];\n  let pluginApis;\n  let container;\n  let slides;\n  function storeElements() {\n    const {\n      container: userContainer,\n      slides: userSlides\n    } = options;\n    const customContainer = isString(userContainer) ? root.querySelector(userContainer) : userContainer;\n    container = customContainer || root.children[0];\n    const customSlides = isString(userSlides) ? container.querySelectorAll(userSlides) : userSlides;\n    slides = [].slice.call(customSlides || container.children);\n  }\n  function createEngine(options) {\n    const engine = Engine(root, container, slides, ownerDocument, ownerWindow, options, eventHandler);\n    if (options.loop && !engine.slideLooper.canLoop()) {\n      const optionsWithoutLoop = Object.assign({}, options, {\n        loop: false\n      });\n      return createEngine(optionsWithoutLoop);\n    }\n    return engine;\n  }\n  function activate(withOptions, withPlugins) {\n    if (destroyed) return;\n    optionsBase = mergeOptions(optionsBase, withOptions);\n    options = optionsAtMedia(optionsBase);\n    pluginList = withPlugins || pluginList;\n    storeElements();\n    engine = createEngine(options);\n    optionsMediaQueries([optionsBase, ...pluginList.map(({\n      options\n    }) => options)]).forEach(query => mediaHandlers.add(query, 'change', reActivate));\n    if (!options.active) return;\n    engine.translate.to(engine.location.get());\n    engine.animation.init();\n    engine.slidesInView.init();\n    engine.slideFocus.init(self);\n    engine.eventHandler.init(self);\n    engine.resizeHandler.init(self);\n    engine.slidesHandler.init(self);\n    if (engine.options.loop) engine.slideLooper.loop();\n    if (container.offsetParent && slides.length) engine.dragHandler.init(self);\n    pluginApis = pluginsHandler.init(self, pluginList);\n  }\n  function reActivate(withOptions, withPlugins) {\n    const startIndex = selectedScrollSnap();\n    deActivate();\n    activate(mergeOptions({\n      startIndex\n    }, withOptions), withPlugins);\n    eventHandler.emit('reInit');\n  }\n  function deActivate() {\n    engine.dragHandler.destroy();\n    engine.eventStore.clear();\n    engine.translate.clear();\n    engine.slideLooper.clear();\n    engine.resizeHandler.destroy();\n    engine.slidesHandler.destroy();\n    engine.slidesInView.destroy();\n    engine.animation.destroy();\n    pluginsHandler.destroy();\n    mediaHandlers.clear();\n  }\n  function destroy() {\n    if (destroyed) return;\n    destroyed = true;\n    mediaHandlers.clear();\n    deActivate();\n    eventHandler.emit('destroy');\n    eventHandler.clear();\n  }\n  function scrollTo(index, jump, direction) {\n    if (!options.active || destroyed) return;\n    engine.scrollBody.useBaseFriction().useDuration(jump === true ? 0 : options.duration);\n    engine.scrollTo.index(index, direction || 0);\n  }\n  function scrollNext(jump) {\n    const next = engine.index.add(1).get();\n    scrollTo(next, jump, -1);\n  }\n  function scrollPrev(jump) {\n    const prev = engine.index.add(-1).get();\n    scrollTo(prev, jump, 1);\n  }\n  function canScrollNext() {\n    const next = engine.index.add(1).get();\n    return next !== selectedScrollSnap();\n  }\n  function canScrollPrev() {\n    const prev = engine.index.add(-1).get();\n    return prev !== selectedScrollSnap();\n  }\n  function scrollSnapList() {\n    return engine.scrollSnapList;\n  }\n  function scrollProgress() {\n    return engine.scrollProgress.get(engine.offsetLocation.get());\n  }\n  function selectedScrollSnap() {\n    return engine.index.get();\n  }\n  function previousScrollSnap() {\n    return engine.indexPrevious.get();\n  }\n  function slidesInView() {\n    return engine.slidesInView.get();\n  }\n  function slidesNotInView() {\n    return engine.slidesInView.get(false);\n  }\n  function plugins() {\n    return pluginApis;\n  }\n  function internalEngine() {\n    return engine;\n  }\n  function rootNode() {\n    return root;\n  }\n  function containerNode() {\n    return container;\n  }\n  function slideNodes() {\n    return slides;\n  }\n  const self = {\n    canScrollNext,\n    canScrollPrev,\n    containerNode,\n    internalEngine,\n    destroy,\n    off,\n    on,\n    emit,\n    plugins,\n    previousScrollSnap,\n    reInit,\n    rootNode,\n    scrollNext,\n    scrollPrev,\n    scrollProgress,\n    scrollSnapList,\n    scrollTo,\n    selectedScrollSnap,\n    slideNodes,\n    slidesInView,\n    slidesNotInView\n  };\n  activate(userOptions, userPlugins);\n  setTimeout(() => eventHandler.emit('init'), 0);\n  return self;\n}\nEmblaCarousel.globalOptions = undefined;\n\nexport { EmblaCarousel as default };\n//# sourceMappingURL=embla-carousel.esm.js.map\n","import { useRef, useState, useCallback, useEffect } from 'react';\nimport { areOptionsEqual, arePluginsEqual, canUseDOM } from 'embla-carousel-reactive-utils';\nimport EmblaCarousel from 'embla-carousel';\n\nfunction useEmblaCarousel(options = {}, plugins = []) {\n  const storedOptions = useRef(options);\n  const storedPlugins = useRef(plugins);\n  const [emblaApi, setEmblaApi] = useState();\n  const [viewport, setViewport] = useState();\n  const reInit = useCallback(() => {\n    if (emblaApi) emblaApi.reInit(storedOptions.current, storedPlugins.current);\n  }, [emblaApi]);\n  useEffect(() => {\n    if (areOptionsEqual(storedOptions.current, options)) return;\n    storedOptions.current = options;\n    reInit();\n  }, [options, reInit]);\n  useEffect(() => {\n    if (arePluginsEqual(storedPlugins.current, plugins)) return;\n    storedPlugins.current = plugins;\n    reInit();\n  }, [plugins, reInit]);\n  useEffect(() => {\n    if (canUseDOM() && viewport) {\n      EmblaCarousel.globalOptions = useEmblaCarousel.globalOptions;\n      const newEmblaApi = EmblaCarousel(viewport, storedOptions.current, storedPlugins.current);\n      setEmblaApi(newEmblaApi);\n      return () => newEmblaApi.destroy();\n    } else {\n      setEmblaApi(undefined);\n    }\n  }, [viewport, setEmblaApi]);\n  return [setViewport, emblaApi];\n}\nuseEmblaCarousel.globalOptions = undefined;\n\nexport { useEmblaCarousel as default };\n//# sourceMappingURL=embla-carousel-react.esm.js.map\n","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nexport default function _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}","export default function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}","export default function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","import arrayWithoutHoles from \"./arrayWithoutHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableSpread from \"./nonIterableSpread.js\";\nexport default function _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}"],"names":["floating_ui_utils_min","Math","min","floating_ui_utils_max","max","round","floor","createCoords","v","x","y","oppositeSideMap","left","right","bottom","top","oppositeAlignmentMap","start","end","floating_ui_utils_evaluate","value","param","floating_ui_utils_getSide","placement","split","floating_ui_utils_getAlignment","getOppositeAxis","axis","floating_ui_utils_getAxisLength","yAxisSides","Set","floating_ui_utils_getSideAxis","has","floating_ui_utils_getOppositeAlignmentPlacement","replace","alignment","lrPlacement","rlPlacement","tbPlacement","btPlacement","getOppositePlacement","side","floating_ui_utils_rectToClientRect","rect","width","height","computeCoordsFromPlacement","_ref","rtl","coords","reference","floating","sideAxis","alignmentAxis","alignLength","isVertical","commonX","commonY","commonAlign","computePosition","config","strategy","middleware","platform","validMiddleware","filter","Boolean","isRTL","rects","getElementRects","statefulPlacement","middlewareData","resetCount","i","length","name","fn","nextX","nextY","data","reset","initialPlacement","elements","detectOverflow","state","options","_await$platform$isEle","boundary","rootBoundary","elementContext","altBoundary","padding","paddingObject","element","clippingClientRect","getClippingRect","isElement","contextElement","getDocumentElement","offsetParent","getOffsetParent","offsetScale","getScale","elementClientRect","convertOffsetParentRelativeRectToViewportRelativeRect","originSides","convertValueToCoords","mainAxisMulti","crossAxisMulti","rawValue","mainAxis","crossAxis","hasWindow","window","getNodeName","node","nodeName","toLowerCase","getWindow","_node$ownerDocument","ownerDocument","defaultView","isNode","document","documentElement","Node","Element","isHTMLElement","HTMLElement","isShadowRoot","ShadowRoot","invalidOverflowDisplayValues","isOverflowElement","overflow","overflowX","overflowY","display","getComputedStyle","test","tableElements","topLayerSelectors","isTopLayer","some","selector","matches","_e","transformProperties","willChangeValues","containValues","isContainingBlock","elementOrCss","webkit","isWebKit","css","containerType","backdropFilter","willChange","includes","contain","CSS","supports","lastTraversableNodeNames","isLastTraversableNode","getNodeScroll","scrollLeft","scrollTop","scrollX","scrollY","getParentNode","result","assignedSlot","parentNode","host","getOverflowAncestors","list","traverseIframes","_node$ownerDocument2","scrollableAncestor","getNearestOverflowAncestor","body","isBody","win","frameElement","getFrameElement","concat","visualViewport","parent","Object","getPrototypeOf","getCssDimensions","parseFloat","hasOffset","offsetWidth","offsetHeight","shouldFallback","$","unwrapElement","domElement","getBoundingClientRect","Number","isFinite","noOffsets","getVisualOffsets","offsetLeft","offsetTop","includeScale","isFixedStrategy","isFixed","clientRect","scale","visualOffsets","shouldAddVisualOffsets","floatingOffsetParent","offsetWin","currentWin","currentIFrame","iframeScale","iframeRect","clientLeft","paddingLeft","clientTop","paddingTop","getWindowScrollBarX","leftScroll","getHTMLOffset","scroll","ignoreScrollbarX","htmlRect","absoluteOrFixed","getClientRectFromClippingAncestor","clippingAncestor","getViewportRect","html","clientWidth","clientHeight","visualViewportBased","getDocumentRect","scrollWidth","scrollHeight","direction","getInnerBoundingClientRect","isStaticPositioned","position","getTrueOffsetParent","polyfill","rawOffsetParent","svgOffsetParent","getContainingBlock","currentNode","getOffsetParentFn","getDimensionsFn","getDimensions","floatingDimensions","getRectRelativeToOffsetParent","isOffsetParentAnElement","offsets","offsetRect","htmlOffset","topLayer","clippingAncestors","getClippingElementAncestors","cache","cachedResult","get","el","currentContainingBlockComputedStyle","elementIsFixed","computedStyle","currentNodeIsContaining","hasFixedPositionAncestor","stopNode","ancestor","set","_c","firstClippingAncestor","clippingRect","reduce","accRect","getClientRects","Array","from","rectsAreEqual","a","b","autoUpdate","update","frameId","ancestorScroll","ancestorResize","elementResize","ResizeObserver","layoutShift","IntersectionObserver","animationFrame","referenceEl","ancestors","forEach","addEventListener","passive","cleanupIo","observeMove","onMove","timeoutId","io","root","cleanup","_io","clearTimeout","disconnect","refresh","skip","threshold","elementRectForRootMargin","insetTop","insetRight","rootMargin","isFirstUpdate","handleObserve","entries","ratio","intersectionRatio","setTimeout","observe","reobserveFrame","resizeObserver","firstEntry","target","unobserve","cancelAnimationFrame","requestAnimationFrame","_resizeObserver","prevRefRect","frameLoop","nextRefRect","_resizeObserver2","removeEventListener","floating_ui_dom_offset","_middlewareData$offse","_middlewareData$arrow","diffCoords","offset","arrow","alignmentOffset","floating_ui_dom_shift","checkMainAxis","checkCrossAxis","limiter","detectOverflowOptions","mainAxisCoord","crossAxisCoord","minSide","maxSide","limitedCoords","enabled","floating_ui_dom_flip","_middlewareData$flip","_middlewareData$flip2","_overflowsData$filter","_overflowsData$filter2","fallbackPlacements","specifiedFallbackPlacements","fallbackStrategy","fallbackAxisSideDirection","flipAlignment","initialSideAxis","isBasePlacement","getExpandedPlacements","oppositePlacement","hasFallbackAxisSideDirection","push","getOppositeAxisPlacements","getSideList","isStart","map","placements","overflows","overflowsData","flip","sides","floating_ui_utils_getAlignmentSides","mainAlignmentSide","every","nextIndex","index","nextPlacement","d","resetPlacement","sort","currentSideAxis","acc","floating_ui_dom_limitShift","rawOffset","computedOffset","len","limitMin","limitMax","_middlewareData$offse2","isOriginSide","floating_ui_dom_computePosition","Map","mergedOptions","platformWithCache","isClient","react__WEBPACK_IMPORTED_MODULE_0__","useLayoutEffect","deepEqual","keys","toString","isArray","hasOwnProperty","call","key","$$typeof","getDPR","devicePixelRatio","roundByDPR","dpr","useLatestRef","ref","useRef","current","useFloating","externalReference","externalFloating","transform","whileElementsMounted","open","setData","useState","isPositioned","latestMiddleware","setLatestMiddleware","_reference","_setReference","_floating","_setFloating","setReference","useCallback","referenceRef","setFloating","floatingRef","floatingEl","dataRef","hasWhileElementsMounted","whileElementsMountedRef","platformRef","openRef","_floating_ui_dom__WEBPACK_IMPORTED_MODULE_2__","oo","then","fullData","isMountedRef","react_dom__WEBPACK_IMPORTED_MODULE_1__","flushSync","refs","useMemo","floatingStyles","initialStyles","deps","cv","shift","uY","limitShift","dr","RR","isRecord","subject","prototype","areOptionsEqual","optionsA","optionsB","optionsAKeys","optionsBKeys","breakpointsA","stringify","breakpoints","JSON","valueA","valueB","sortAndMapPluginToOptions","plugins","plugin","isNumber","isString","isBoolean","embla_carousel_esm_isObject","mathAbs","n","abs","mathSign","sign","arrayKeys","array","objectKeys","arrayLast","arrayLastIndex","arrayFromNumber","startAt","_","object","isMouseEvent","evt","ownerWindow","MouseEvent","EventStore","listeners","self","add","type","handler","removeListener","legacyMediaQueryList","addListener","clear","remove","Limit","reachedAny","reachedMin","constrain","reachedMax","removeOffset","ceil","Vector1D","initialValue","normalizeInput","subtract","Translate","container","translate","containerStyle","style","previousTarget","disabled","getAttribute","removeAttribute","to","newTarget","num","toggleActive","active","defaultOptions","align","slides","containScroll","slidesToScroll","inViewThreshold","dragFree","dragThreshold","loop","skipSnaps","duration","startIndex","watchDrag","watchResize","watchSlides","watchFocus","EmblaCarousel","userOptions","userPlugins","engine","pluginApis","activePlugins","optionsHandler","OptionsHandler","mergeOptions","objectsMergeDeep","objectA","objectB","mergedObjects","currentObject","areObjects","optionsAtMedia","matchedMediaOptions","media","matchMedia","mediaOption","optionsMediaQueries","optionsList","mediaQueries","pluginsHandler","init","emblaApi","assign","destroy","mediaHandlers","eventHandler","EventHandler","api","emit","getListeners","e","off","cb","on","destroyed","optionsBase","globalOptions","pluginList","activate","withOptions","withPlugins","storeElements","userContainer","userSlides","customContainer","querySelector","children","customSlides","querySelectorAll","slice","createEngine","Engine","mutationObserver","scrollAxis","groupSlides","nodeRects","measure","containerRect","slideRects","Axis","contentDirection","isRightToLeft","cross","startEdge","endEdge","measureSize","nodeRect","viewSize","percentOfView","Alignment","predefined","center","containSnaps","slideSizes","slideSizesWithGaps","startGap","endGap","SlideSizes","readEdgeGap","withEdgeGap","measureStartGap","slideRect","getPropertyValue","isLast","SlidesToScroll","pixelTolerance","groupByNumber","groups","rectB","rectA","edgeA","edgeB","gapA","chunkSize","currentSize","previousSize","snaps","snapsAligned","ScrollSnaps","alignments","measureSizes","snap","g","contentSize","snapsContained","scrollContainLimit","ScrollContain","scrollBounds","snapsBounded","snapAligned","deltaAbs","scrollBound","toFixed","findScrollContainLimit","startSnap","endSnap","lastIndexOf","indexOf","measureContained","scrollSnaps","limit","ScrollLimit","Counter","loopEnd","counter","withinLimit","clone","indexPrevious","slideIndexes","dragHandler","scrollBody","pointerDown","seek","render","location","offsetLocation","previousLocation","scrollLooper","slideLooper","animation","alpha","shouldSettle","settled","withinBounds","shouldConstrain","hasSettled","hasSettledAndIdle","stop","interpolatedLocation","Animations","documentVisibleHandler","fixedTimeStep","lastTimeStamp","accumulatedTime","animationId","animate","timeStamp","timeElapsed","hidden","startLocation","ScrollBody","baseDuration","baseFriction","scrollVelocity","scrollDirection","scrollDuration","scrollFriction","rawLocation","rawLocationPrevious","useDuration","useFriction","velocity","displacement","scrollDistance","useBaseFriction","useBaseDuration","scrollTarget","ScrollTarget","targetVector","minDistance","distances","shortcut","targets","matchingTargets","t","byDistance","distance","targetSnapDistance","findTargetSnap","ascDiffsToSnaps","diff","d1","d2","reachedBound","snapDistance","byIndex","scrollTo","ScrollTo","indexCurrent","distanceDiff","indexDiff","targetIndex","scrollProgress","ScrollProgress","currentLocation","eventStore","slidesInView","SlidesInView","intersectionObserver","intersectionEntryMap","inViewCache","notInViewCache","entry","parentElement","slide","inView","slideIndex","parseInt","isIntersecting","inViewMatch","slideRegistry","SlideRegistry","createSlideRegistry","groupedSlideIndexes","group","slideFocus","SlideFocus","focusListenerOptions","capture","lastTabPressTime","registerTabPress","event","code","Date","getTime","defaultCallback","diffTime","findIndex","DragHandler","rootNode","dragTracker","focusNodes","nonPassiveEvent","initEvents","dragEvents","goToNextThreshold","snapForceBoost","mouse","touch","freeForceBoost","baseSpeed","isMoving","startScroll","startCross","pointerIsDown","preventScroll","preventClick","isMouse","move","isTouchEvt","touches","up","lastScroll","readPoint","lastCross","diffScroll","diffCross","cancelable","pointerMove","preventDefault","targetChanged","rawForce","pointerUp","boost","force","allowedForce","next","baseForce","forceFactor","factorAbs","click","stopPropagation","undefined","downIfAllowed","down","isMouseEvt","buttons","button","isFocusNode","addDragEvents","DragTracker","startEvent","lastEvent","readTime","evtAxis","property","coord","expired","diffDrag","isFlick","resizeHandler","ResizeHandler","containerSize","observeNodes","readSize","isContainer","lastSize","diffSize","newSize","reInit","ScrollBounds","pullBackThreshold","edgeOffsetTolerance","frictionLimit","edge","diffToEdge","diffToTarget","friction","ScrollLooper","vectors","loopDistance","scrollSnapList","SlideLooper","ascItems","loopPoints","startPoints","slidesInGap","reverse","findLoopPoints","removeSlideSizes","indexes","gap","remainingGap","isEndEdge","slideBounds","initial","altered","loopPoint","slideLocation","canLoop","shiftLocation","slidesHandler","MutationObserver","mutations","mutation","childList","query","reActivate","selectedScrollSnap","deActivate","jump","canScrollNext","canScrollPrev","prev","containerNode","internalEngine","previousScrollSnap","scrollNext","scrollPrev","slideNodes","slidesNotInView","useEmblaCarousel","storedOptions","react","storedPlugins","setEmblaApi","viewport","setViewport","useEffect","arePluginsEqual","pluginsA","pluginsB","optionA","canUseDOM","createElement","newEmblaApi","_toConsumableArray","arr","_arrayWithoutHoles","arrayLikeToArray","Z","_iterableToArray","iter","Symbol","iterator","unsupportedIterableToArray","_nonIterableSpread"],"sourceRoot":""}