{"version":3,"file":"js/4852-1d8272720a6ed0a84257.js","mappings":"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","sources":["webpack:///./node_modules/embla-carousel-reactive-utils/esm/embla-carousel-reactive-utils.esm.js","webpack:///./node_modules/embla-carousel/esm/embla-carousel.esm.js","webpack:///./node_modules/embla-carousel-react/esm/embla-carousel-react.esm.js"],"sourcesContent":["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    if (hasSettled && !dragHandler.pointerDown()) {\n      animation.stop();\n      eventHandler.emit('settle');\n    }\n    if (!hasSettled) eventHandler.emit('scroll');\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  };\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.location.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"],"names":["isRecord","subject","Object","prototype","toString","call","isObject","Array","isArray","areOptionsEqual","optionsA","optionsB","optionsAKeys","keys","optionsBKeys","length","JSON","stringify","breakpoints","every","key","valueA","valueB","sortAndMapPluginToOptions","plugins","concat","sort","a","b","name","map","plugin","options","isNumber","isString","isBoolean","mathAbs","n","Math","abs","mathSign","sign","deltaAbs","arrayKeys","array","objectKeys","Number","arrayLast","arrayLastIndex","max","arrayIsLastIndex","index","arrayFromNumber","startAt","from","_","i","object","objectsMergeDeep","objectA","objectB","reduce","mergedObjects","currentObject","forEach","areObjects","isMouseEvent","evt","ownerWindow","MouseEvent","EventStore","listeners","self","add","node","type","handler","passive","removeListener","addEventListener","removeEventListener","legacyMediaQueryList","addListener","push","clear","filter","remove","Animations","ownerDocument","update","render","documentVisibleHandler","fixedTimeStep","lastTimeStamp","accumulatedTime","animationId","animate","timeStamp","timeElapsed","requestAnimationFrame","stop","cancelAnimationFrame","init","hidden","destroy","start","Limit","min","reachedMin","reachedMax","reachedAny","constrain","removeOffset","ceil","Counter","loop","loopEnd","counter","withinLimit","get","clone","set","DragHandler","axis","rootNode","target","dragTracker","location","animation","scrollTo","scrollBody","scrollTarget","eventHandler","percentOfView","dragFree","dragThreshold","skipSnaps","baseFriction","watchDrag","cross","crossAxis","direction","focusNodes","nonPassiveEvent","initEvents","dragEvents","goToNextThreshold","measure","snapForceBoost","mouse","touch","freeForceBoost","baseSpeed","isMoving","startScroll","startCross","pointerIsDown","preventScroll","preventClick","isMouse","move","touches","up","lastScroll","readPoint","lastCross","diffScroll","diffCross","cancelable","diff","pointerMove","useFriction","useDuration","preventDefault","targetChanged","byDistance","rawForce","pointerUp","force","next","baseForce","distance","byIndex","allowedForce","forceFactor","factorAbs","speed","friction","emit","click","stopPropagation","emblaApi","downIfAllowed","isMouseEvt","buttons","button","nodeName","includes","isFocusNode","pointerDown","addDragEvents","down","DragTracker","startEvent","lastEvent","readTime","evtAxis","coord","scroll","expired","diffDrag","diffTime","ResizeHandler","container","slides","watchResize","nodeRects","observeNodes","resizeObserver","containerSize","slideSizes","destroyed","readSize","measureSize","ResizeObserver","entries","entry","isContainer","slideIndex","indexOf","lastSize","reInit","defaultCallback","observe","disconnect","ScrollBounds","limit","pullBackThreshold","edgeOffsetTolerance","frictionLimit","disabled","shouldConstrain","edge","diffToEdge","diffToTarget","subtract","useBaseFriction","toggleActive","active","ScrollLooper","contentSize","vectors","shouldLoop","loopDistance","v","ScrollTarget","scrollSnaps","targetVector","minDistance","distances","shortcut","targets","matchingTargets","t","snap","targetSnapDistance","ascDiffsToSnaps","d1","d2","findTargetSnap","reachedBound","SlideFocus","root","slideRegistry","eventStore","watchFocus","focusListenerOptions","capture","lastTabPressTime","registerTabPress","event","code","Date","getTime","document","slide","scrollLeft","group","findIndex","Vector1D","initialValue","value","normalizeInput","Translate","translate","containerStyle","style","previousTarget","transform","getAttribute","removeAttribute","to","newTarget","num","round","SlideLooper","viewSize","slideSizesWithGaps","snaps","roundingSafety","ascItems","descItems","reverse","loopPoints","gap","findLoopPoints","slidesInGap","startPoints","endPoints","removeSlideSizes","indexes","offset","isEndEdge","slideBounds","end","findSlideBounds","initial","altered","boundEdge","loopPoint","slideLocation","canLoop","shiftLocation","SlidesHandler","watchSlides","mutationObserver","MutationObserver","mutations","mutation","childList","SlidesInView","threshold","intersectionEntryMap","intersectionObserver","inViewCache","notInViewCache","IntersectionObserver","parentElement","inView","slideIndexes","list","parseInt","isIntersecting","createInViewList","SlidesToScroll","slidesToScroll","containerRect","slideRects","startGap","endGap","pixelTolerance","startEdge","endEdge","groupByNumber","groupSlides","groupSize","slice","byNumber","groups","rectB","rectA","isFirst","isLast","edgeA","edgeB","gapA","chunkSize","currentSize","previousSize","bySize","Engine","align","scrollAxis","startIndex","duration","inViewThreshold","containScroll","offsetTop","offsetLeft","offsetWidth","offsetHeight","top","right","bottom","left","width","height","contentDirection","isRightToLeft","isVertical","nodeRect","Axis","PercentOfView","alignment","predefined","center","Alignment","containSnaps","readEdgeGap","withEdgeGap","slideRect","measureStartGap","getComputedStyle","parseFloat","getPropertyValue","measureEndGap","rect","rects","SlideSizes","snapsAligned","alignments","g","ScrollSnaps","snapsContained","scrollContainLimit","scrollBounds","snapsBounded","snapAligned","usePixelTolerance","scrollBound","toFixed","startSnap","endSnap","lastIndexOf","findScrollContainLimit","bound","measureContained","ScrollContain","ScrollLimit","indexPrevious","dragHandler","seek","engine","alpha","offsetLocation","previousLocation","scrollLooper","slideLooper","shouldSettle","settled","withinBounds","hasSettled","interpolatedLocation","startLocation","baseDuration","scrollVelocity","scrollDirection","scrollDuration","scrollFriction","rawLocation","rawLocationPrevious","velocity","displacement","scrollDistance","useBaseDuration","ScrollBody","indexCurrent","distanceDiff","indexDiff","targetIndex","ScrollTo","scrollProgress","ScrollProgress","slidesInView","groupedSlideIndexes","doNotContain","createSlideRegistry","SlideRegistry","slideFocus","resizeHandler","scrollSnapList","slidesHandler","defaultOptions","OptionsHandler","mergeOptions","optionsAtMedia","matchedMediaOptions","media","matchMedia","matches","mediaOption","optionsMediaQueries","optionsList","acc","mediaQueries","EmblaCarousel","userOptions","userPlugins","defaultView","optionsHandler","pluginsHandler","activePlugins","assign","PluginsHandler","mediaHandlers","api","getListeners","e","off","cb","on","EventHandler","reActivate","pluginApis","optionsBase","globalOptions","pluginList","createEngine","activate","withOptions","withPlugins","userContainer","userSlides","customContainer","querySelector","children","customSlides","querySelectorAll","storeElements","query","offsetParent","selectedScrollSnap","deActivate","jump","canScrollNext","canScrollPrev","containerNode","internalEngine","previousScrollSnap","scrollNext","scrollPrev","slideNodes","slidesNotInView","setTimeout","useEmblaCarousel","storedOptions","useRef","storedPlugins","setEmblaApi","useState","viewport","setViewport","useCallback","current","useEffect","pluginsA","pluginsB","optionA","arePluginsEqual","window","createElement","newEmblaApi","undefined"],"sourceRoot":""}