dbbdfb320c5007a40fa91453221d77dae72f3b83-00be99e431fb904367c1.js.map

{"version":3,"file":"dbbdfb320c5007a40fa91453221d77dae72f3b83-00be99e431fb904367c1.js","mappings":"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","sources":["webpack://code-cave/./node_modules/embla-carousel-react/node_modules/embla-carousel-reactive-utils/esm/embla-carousel-reactive-utils.esm.js","webpack://code-cave/./node_modules/embla-carousel/esm/embla-carousel.esm.js","webpack://code-cave/./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 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 timeStep = 1000 / 60;\n  let lastTimeStamp = null;\n  let lag = 0;\n  let animationFrame = 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 (!animationFrame) return;\n    if (!lastTimeStamp) lastTimeStamp = timeStamp;\n    const elapsed = timeStamp - lastTimeStamp;\n    lastTimeStamp = timeStamp;\n    lag += elapsed;\n    while (lag >= timeStep) {\n      update();\n      lag -= timeStep;\n    }\n    const lagOffset = mathAbs(lag / timeStep);\n    render(lagOffset);\n    if (animationFrame) ownerWindow.requestAnimationFrame(animate);\n  }\n  function start() {\n    if (animationFrame) return;\n    animationFrame = ownerWindow.requestAnimationFrame(animate);\n  }\n  function stop() {\n    ownerWindow.cancelAnimationFrame(animationFrame);\n    lastTimeStamp = null;\n    lag = 0;\n    animationFrame = 0;\n  }\n  function reset() {\n    lastTimeStamp = null;\n    lag = 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  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        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          ownerWindow.requestAnimationFrame(() => {\n            emblaApi.reInit();\n            eventHandler.emit('resize');\n          });\n          break;\n        }\n      }\n    }\n    resizeObserver = new ResizeObserver(entries => {\n      if (destroyed) return;\n      if (isBoolean(watchResize) || watchResize(emblaApi, entries)) {\n        defaultCallback(entries);\n      }\n    });\n    const observeNodes = [container].concat(slides);\n    observeNodes.forEach(node => resizeObserver.observe(node));\n  }\n  function destroy() {\n    if (resizeObserver) resizeObserver.disconnect();\n    destroyed = true;\n  }\n  const self = {\n    init,\n    destroy\n  };\n  return self;\n}\n\nfunction ScrollBody(location, offsetLocation, target, baseDuration, baseFriction) {\n  let bodyVelocity = 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 diff = target.get() - location.get();\n    const isInstant = !scrollDuration;\n    let directionDiff = 0;\n    if (isInstant) {\n      bodyVelocity = 0;\n      location.set(target);\n      directionDiff = diff;\n    } else {\n      bodyVelocity += diff / scrollDuration;\n      bodyVelocity *= scrollFriction;\n      rawLocation += bodyVelocity;\n      location.add(bodyVelocity);\n      directionDiff = rawLocation - rawLocationPrevious;\n    }\n    scrollDirection = mathSign(directionDiff);\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 bodyVelocity;\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, offsetLocation, 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(offsetLocation.get())) return false;\n    return true;\n  }\n  function constrain(pointerDown) {\n    if (!shouldConstrain()) return;\n    const edge = limit.reachedMin(offsetLocation.get()) ? 'min' : 'max';\n    const diffToEdge = mathAbs(limit[edge] - offsetLocation.get());\n    const diffToTarget = target.get() - offsetLocation.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, offsetLocation, 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(offsetLocation.get());\n    if (direction === -1) return reachedMin(offsetLocation.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) {\n  let lastTabPressTime = 0;\n  function init() {\n    eventStore.add(document, 'keydown', registerTabPress, false);\n    slides.forEach(addSlideFocusEvent);\n  }\n  function registerTabPress(event) {\n    if (event.code === 'Tab') lastTabPressTime = new Date().getTime();\n  }\n  function addSlideFocusEvent(slide) {\n    const focus = () => {\n      const nowTime = new Date().getTime();\n      const diffTime = nowTime - lastTabPressTime;\n      if (diffTime > 10) return;\n      root.scrollLeft = 0;\n      const index = slides.indexOf(slide);\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(slide, 'focus', focus, {\n      passive: true,\n      capture: true\n    });\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 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    containerStyle.transform = translate(axis.direction(target));\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, offsetLocation, 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: () => offsetLocation.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  } = 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    scrollLooper,\n    slideLooper,\n    dragHandler,\n    animation,\n    eventHandler,\n    scrollBounds,\n    options: {\n      loop\n    }\n  }, lagOffset) => {\n    const velocity = scrollBody.velocity();\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    offsetLocation.set(location.get() - velocity + velocity * lagOffset);\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), lagOffset => render(engine, lagOffset));\n  // Shared\n  const friction = 0.68;\n  const startLocation = scrollSnaps[index.get()];\n  const location = Vector1D(startLocation);\n  const offsetLocation = Vector1D(startLocation);\n  const target = Vector1D(startLocation);\n  const scrollBody = ScrollBody(location, offsetLocation, 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);\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    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, 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};\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();\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 { canUseDOM, areOptionsEqual, arePluginsEqual } 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 (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  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  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","timeStep","lastTimeStamp","lag","animationFrame","animate","timeStamp","elapsed","lagOffset","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","resizeObserver","containerSize","slideSizes","destroyed","readSize","measureSize","ResizeObserver","entries","entry","isContainer","slideIndex","indexOf","lastSize","reInit","defaultCallback","observe","disconnect","ScrollBounds","limit","offsetLocation","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","Vector1D","initialValue","value","normalizeInput","Translate","translate","containerStyle","style","transform","getAttribute","removeAttribute","to","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","root","parentElement","slide","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","scrollLooper","slideLooper","velocity","shouldSettle","settled","withinBounds","hasSettled","startLocation","baseDuration","bodyVelocity","scrollDirection","scrollDuration","scrollFriction","rawLocation","rawLocationPrevious","directionDiff","useBaseDuration","ScrollBody","indexCurrent","distanceDiff","indexDiff","targetIndex","ScrollTo","scrollProgress","ScrollProgress","eventStore","slidesInView","slideRegistry","groupedSlideIndexes","doNotContain","group","createSlideRegistry","SlideRegistry","slideFocus","lastTabPressTime","registerTabPress","event","code","Date","getTime","addSlideFocusEvent","scrollLeft","findIndex","capture","document","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","window","createElement","newEmblaApi","undefined","pluginsA","pluginsB","optionA","arePluginsEqual"],"sourceRoot":""}