@asante-org/atlascopco-vt-litesitegenerator 3.0.1 → 3.0.7

package/dist/index.esm.js

@@ -1,4 +1,4 @@
-import React, { useState, useRef, useId, useEffect } from 'react';
+import React, { useState, useRef, useId, useEffect, useCallback, useMemo, forwardRef, useImperativeHandle } from 'react';
 
 function _extends() {
   return _extends = Object.assign ? Object.assign.bind() : function (n) {
@@ -1333,6 +1333,2159 @@ var LsgFooter = function (_a) {
   }))))), bottomBar);
 };
 
+function isNumber$1(subject) {
+  return typeof subject === 'number';
+}
+function isString(subject) {
+  return typeof subject === 'string';
+}
+function isBoolean(subject) {
+  return typeof subject === 'boolean';
+}
+function isObject(subject) {
+  return Object.prototype.toString.call(subject) === '[object Object]';
+}
+function mathAbs(n) {
+  return Math.abs(n);
+}
+function mathSign(n) {
+  return Math.sign(n);
+}
+function deltaAbs(valueB, valueA) {
+  return mathAbs(valueB - valueA);
+}
+function factorAbs(valueB, valueA) {
+  if (valueB === 0 || valueA === 0) return 0;
+  if (mathAbs(valueB) <= mathAbs(valueA)) return 0;
+  const diff = deltaAbs(mathAbs(valueB), mathAbs(valueA));
+  return mathAbs(diff / valueB);
+}
+function roundToTwoDecimals(num) {
+  return Math.round(num * 100) / 100;
+}
+function arrayKeys(array) {
+  return objectKeys(array).map(Number);
+}
+function arrayLast(array) {
+  return array[arrayLastIndex(array)];
+}
+function arrayLastIndex(array) {
+  return Math.max(0, array.length - 1);
+}
+function arrayIsLastIndex(array, index) {
+  return index === arrayLastIndex(array);
+}
+function arrayFromNumber(n, startAt = 0) {
+  return Array.from(Array(n), (_, i) => startAt + i);
+}
+function objectKeys(object) {
+  return Object.keys(object);
+}
+function objectsMergeDeep(objectA, objectB) {
+  return [objectA, objectB].reduce((mergedObjects, currentObject) => {
+    objectKeys(currentObject).forEach(key => {
+      const valueA = mergedObjects[key];
+      const valueB = currentObject[key];
+      const areObjects = isObject(valueA) && isObject(valueB);
+      mergedObjects[key] = areObjects ? objectsMergeDeep(valueA, valueB) : valueB;
+    });
+    return mergedObjects;
+  }, {});
+}
+function isMouseEvent(evt, ownerWindow) {
+  return typeof ownerWindow.MouseEvent !== 'undefined' && evt instanceof ownerWindow.MouseEvent;
+}
+function Alignment(align, viewSize) {
+  const predefined = {
+    start,
+    center,
+    end
+  };
+  function start() {
+    return 0;
+  }
+  function center(n) {
+    return end(n) / 2;
+  }
+  function end(n) {
+    return viewSize - n;
+  }
+  function measure(n, index) {
+    if (isString(align)) return predefined[align](n);
+    return align(viewSize, n, index);
+  }
+  const self = {
+    measure
+  };
+  return self;
+}
+function EventStore() {
+  let listeners = [];
+  function add(node, type, handler, options = {
+    passive: true
+  }) {
+    let removeListener;
+    if ('addEventListener' in node) {
+      node.addEventListener(type, handler, options);
+      removeListener = () => node.removeEventListener(type, handler, options);
+    } else {
+      const legacyMediaQueryList = node;
+      legacyMediaQueryList.addListener(handler);
+      removeListener = () => legacyMediaQueryList.removeListener(handler);
+    }
+    listeners.push(removeListener);
+    return self;
+  }
+  function clear() {
+    listeners = listeners.filter(remove => remove());
+  }
+  const self = {
+    add,
+    clear
+  };
+  return self;
+}
+function Animations(ownerDocument, ownerWindow, update, render) {
+  const documentVisibleHandler = EventStore();
+  const fixedTimeStep = 1000 / 60;
+  let lastTimeStamp = null;
+  let accumulatedTime = 0;
+  let animationId = 0;
+  function init() {
+    documentVisibleHandler.add(ownerDocument, 'visibilitychange', () => {
+      if (ownerDocument.hidden) reset();
+    });
+  }
+  function destroy() {
+    stop();
+    documentVisibleHandler.clear();
+  }
+  function animate(timeStamp) {
+    if (!animationId) return;
+    if (!lastTimeStamp) {
+      lastTimeStamp = timeStamp;
+      update();
+      update();
+    }
+    const timeElapsed = timeStamp - lastTimeStamp;
+    lastTimeStamp = timeStamp;
+    accumulatedTime += timeElapsed;
+    while (accumulatedTime >= fixedTimeStep) {
+      update();
+      accumulatedTime -= fixedTimeStep;
+    }
+    const alpha = accumulatedTime / fixedTimeStep;
+    render(alpha);
+    if (animationId) {
+      animationId = ownerWindow.requestAnimationFrame(animate);
+    }
+  }
+  function start() {
+    if (animationId) return;
+    animationId = ownerWindow.requestAnimationFrame(animate);
+  }
+  function stop() {
+    ownerWindow.cancelAnimationFrame(animationId);
+    lastTimeStamp = null;
+    accumulatedTime = 0;
+    animationId = 0;
+  }
+  function reset() {
+    lastTimeStamp = null;
+    accumulatedTime = 0;
+  }
+  const self = {
+    init,
+    destroy,
+    start,
+    stop,
+    update,
+    render
+  };
+  return self;
+}
+function Axis(axis, contentDirection) {
+  const isRightToLeft = contentDirection === 'rtl';
+  const isVertical = axis === 'y';
+  const scroll = isVertical ? 'y' : 'x';
+  const cross = isVertical ? 'x' : 'y';
+  const sign = !isVertical && isRightToLeft ? -1 : 1;
+  const startEdge = getStartEdge();
+  const endEdge = getEndEdge();
+  function measureSize(nodeRect) {
+    const {
+      height,
+      width
+    } = nodeRect;
+    return isVertical ? height : width;
+  }
+  function getStartEdge() {
+    if (isVertical) return 'top';
+    return isRightToLeft ? 'right' : 'left';
+  }
+  function getEndEdge() {
+    if (isVertical) return 'bottom';
+    return isRightToLeft ? 'left' : 'right';
+  }
+  function direction(n) {
+    return n * sign;
+  }
+  const self = {
+    scroll,
+    cross,
+    startEdge,
+    endEdge,
+    measureSize,
+    direction
+  };
+  return self;
+}
+function Limit(min = 0, max = 0) {
+  const length = mathAbs(min - max);
+  function reachedMin(n) {
+    return n < min;
+  }
+  function reachedMax(n) {
+    return n > max;
+  }
+  function reachedAny(n) {
+    return reachedMin(n) || reachedMax(n);
+  }
+  function constrain(n) {
+    if (!reachedAny(n)) return n;
+    return reachedMin(n) ? min : max;
+  }
+  function removeOffset(n) {
+    if (!length) return n;
+    return n - length * Math.ceil((n - max) / length);
+  }
+  const self = {
+    length,
+    max,
+    min,
+    constrain,
+    reachedAny,
+    reachedMax,
+    reachedMin,
+    removeOffset
+  };
+  return self;
+}
+function Counter(max, start, loop) {
+  const {
+    constrain
+  } = Limit(0, max);
+  const loopEnd = max + 1;
+  let counter = withinLimit(start);
+  function withinLimit(n) {
+    return !loop ? constrain(n) : mathAbs((loopEnd + n) % loopEnd);
+  }
+  function get() {
+    return counter;
+  }
+  function set(n) {
+    counter = withinLimit(n);
+    return self;
+  }
+  function add(n) {
+    return clone().set(get() + n);
+  }
+  function clone() {
+    return Counter(max, get(), loop);
+  }
+  const self = {
+    get,
+    set,
+    add,
+    clone
+  };
+  return self;
+}
+function DragHandler(axis, rootNode, ownerDocument, ownerWindow, target, dragTracker, location, animation, scrollTo, scrollBody, scrollTarget, index, eventHandler, percentOfView, dragFree, dragThreshold, skipSnaps, baseFriction, watchDrag) {
+  const {
+    cross: crossAxis,
+    direction
+  } = axis;
+  const focusNodes = ['INPUT', 'SELECT', 'TEXTAREA'];
+  const nonPassiveEvent = {
+    passive: false
+  };
+  const initEvents = EventStore();
+  const dragEvents = EventStore();
+  const goToNextThreshold = Limit(50, 225).constrain(percentOfView.measure(20));
+  const snapForceBoost = {
+    mouse: 300,
+    touch: 400
+  };
+  const freeForceBoost = {
+    mouse: 500,
+    touch: 600
+  };
+  const baseSpeed = dragFree ? 43 : 25;
+  let isMoving = false;
+  let startScroll = 0;
+  let startCross = 0;
+  let pointerIsDown = false;
+  let preventScroll = false;
+  let preventClick = false;
+  let isMouse = false;
+  function init(emblaApi) {
+    if (!watchDrag) return;
+    function downIfAllowed(evt) {
+      if (isBoolean(watchDrag) || watchDrag(emblaApi, evt)) down(evt);
+    }
+    const node = rootNode;
+    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);
+  }
+  function destroy() {
+    initEvents.clear();
+    dragEvents.clear();
+  }
+  function addDragEvents() {
+    const node = isMouse ? ownerDocument : rootNode;
+    dragEvents.add(node, 'touchmove', move, nonPassiveEvent).add(node, 'touchend', up).add(node, 'mousemove', move, nonPassiveEvent).add(node, 'mouseup', up);
+  }
+  function isFocusNode(node) {
+    const nodeName = node.nodeName || '';
+    return focusNodes.includes(nodeName);
+  }
+  function forceBoost() {
+    const boost = dragFree ? freeForceBoost : snapForceBoost;
+    const type = isMouse ? 'mouse' : 'touch';
+    return boost[type];
+  }
+  function allowedForce(force, targetChanged) {
+    const next = index.add(mathSign(force) * -1);
+    const baseForce = scrollTarget.byDistance(force, !dragFree).distance;
+    if (dragFree || mathAbs(force) < goToNextThreshold) return baseForce;
+    if (skipSnaps && targetChanged) return baseForce * 0.5;
+    return scrollTarget.byIndex(next.get(), 0).distance;
+  }
+  function down(evt) {
+    const isMouseEvt = isMouseEvent(evt, ownerWindow);
+    isMouse = isMouseEvt;
+    preventClick = dragFree && isMouseEvt && !evt.buttons && isMoving;
+    isMoving = deltaAbs(target.get(), location.get()) >= 2;
+    if (isMouseEvt && evt.button !== 0) return;
+    if (isFocusNode(evt.target)) return;
+    pointerIsDown = true;
+    dragTracker.pointerDown(evt);
+    scrollBody.useFriction(0).useDuration(0);
+    target.set(location);
+    addDragEvents();
+    startScroll = dragTracker.readPoint(evt);
+    startCross = dragTracker.readPoint(evt, crossAxis);
+    eventHandler.emit('pointerDown');
+  }
+  function move(evt) {
+    const isTouchEvt = !isMouseEvent(evt, ownerWindow);
+    if (isTouchEvt && evt.touches.length >= 2) return up(evt);
+    const lastScroll = dragTracker.readPoint(evt);
+    const lastCross = dragTracker.readPoint(evt, crossAxis);
+    const diffScroll = deltaAbs(lastScroll, startScroll);
+    const diffCross = deltaAbs(lastCross, startCross);
+    if (!preventScroll && !isMouse) {
+      if (!evt.cancelable) return up(evt);
+      preventScroll = diffScroll > diffCross;
+      if (!preventScroll) return up(evt);
+    }
+    const diff = dragTracker.pointerMove(evt);
+    if (diffScroll > dragThreshold) preventClick = true;
+    scrollBody.useFriction(0.3).useDuration(0.75);
+    animation.start();
+    target.add(direction(diff));
+    evt.preventDefault();
+  }
+  function up(evt) {
+    const currentLocation = scrollTarget.byDistance(0, false);
+    const targetChanged = currentLocation.index !== index.get();
+    const rawForce = dragTracker.pointerUp(evt) * forceBoost();
+    const force = allowedForce(direction(rawForce), targetChanged);
+    const forceFactor = factorAbs(rawForce, force);
+    const speed = baseSpeed - 10 * forceFactor;
+    const friction = baseFriction + forceFactor / 50;
+    preventScroll = false;
+    pointerIsDown = false;
+    dragEvents.clear();
+    scrollBody.useDuration(speed).useFriction(friction);
+    scrollTo.distance(force, !dragFree);
+    isMouse = false;
+    eventHandler.emit('pointerUp');
+  }
+  function click(evt) {
+    if (preventClick) {
+      evt.stopPropagation();
+      evt.preventDefault();
+      preventClick = false;
+    }
+  }
+  function pointerDown() {
+    return pointerIsDown;
+  }
+  const self = {
+    init,
+    destroy,
+    pointerDown
+  };
+  return self;
+}
+function DragTracker(axis, ownerWindow) {
+  const logInterval = 170;
+  let startEvent;
+  let lastEvent;
+  function readTime(evt) {
+    return evt.timeStamp;
+  }
+  function readPoint(evt, evtAxis) {
+    const property = evtAxis || axis.scroll;
+    const coord = `client${property === 'x' ? 'X' : 'Y'}`;
+    return (isMouseEvent(evt, ownerWindow) ? evt : evt.touches[0])[coord];
+  }
+  function pointerDown(evt) {
+    startEvent = evt;
+    lastEvent = evt;
+    return readPoint(evt);
+  }
+  function pointerMove(evt) {
+    const diff = readPoint(evt) - readPoint(lastEvent);
+    const expired = readTime(evt) - readTime(startEvent) > logInterval;
+    lastEvent = evt;
+    if (expired) startEvent = evt;
+    return diff;
+  }
+  function pointerUp(evt) {
+    if (!startEvent || !lastEvent) return 0;
+    const diffDrag = readPoint(lastEvent) - readPoint(startEvent);
+    const diffTime = readTime(evt) - readTime(startEvent);
+    const expired = readTime(evt) - readTime(lastEvent) > logInterval;
+    const force = diffDrag / diffTime;
+    const isFlick = diffTime && !expired && mathAbs(force) > 0.1;
+    return isFlick ? force : 0;
+  }
+  const self = {
+    pointerDown,
+    pointerMove,
+    pointerUp,
+    readPoint
+  };
+  return self;
+}
+function NodeRects() {
+  function measure(node) {
+    const {
+      offsetTop,
+      offsetLeft,
+      offsetWidth,
+      offsetHeight
+    } = node;
+    const offset = {
+      top: offsetTop,
+      right: offsetLeft + offsetWidth,
+      bottom: offsetTop + offsetHeight,
+      left: offsetLeft,
+      width: offsetWidth,
+      height: offsetHeight
+    };
+    return offset;
+  }
+  const self = {
+    measure
+  };
+  return self;
+}
+function PercentOfView(viewSize) {
+  function measure(n) {
+    return viewSize * (n / 100);
+  }
+  const self = {
+    measure
+  };
+  return self;
+}
+function ResizeHandler(container, eventHandler, ownerWindow, slides, axis, watchResize, nodeRects) {
+  const observeNodes = [container].concat(slides);
+  let resizeObserver;
+  let containerSize;
+  let slideSizes = [];
+  let destroyed = false;
+  function readSize(node) {
+    return axis.measureSize(nodeRects.measure(node));
+  }
+  function init(emblaApi) {
+    if (!watchResize) return;
+    containerSize = readSize(container);
+    slideSizes = slides.map(readSize);
+    function defaultCallback(entries) {
+      for (const entry of entries) {
+        if (destroyed) return;
+        const isContainer = entry.target === container;
+        const slideIndex = slides.indexOf(entry.target);
+        const lastSize = isContainer ? containerSize : slideSizes[slideIndex];
+        const newSize = readSize(isContainer ? container : slides[slideIndex]);
+        const diffSize = mathAbs(newSize - lastSize);
+        if (diffSize >= 0.5) {
+          emblaApi.reInit();
+          eventHandler.emit('resize');
+          break;
+        }
+      }
+    }
+    resizeObserver = new ResizeObserver(entries => {
+      if (isBoolean(watchResize) || watchResize(emblaApi, entries)) {
+        defaultCallback(entries);
+      }
+    });
+    ownerWindow.requestAnimationFrame(() => {
+      observeNodes.forEach(node => resizeObserver.observe(node));
+    });
+  }
+  function destroy() {
+    destroyed = true;
+    if (resizeObserver) resizeObserver.disconnect();
+  }
+  const self = {
+    init,
+    destroy
+  };
+  return self;
+}
+function ScrollBody(location, offsetLocation, previousLocation, target, baseDuration, baseFriction) {
+  let scrollVelocity = 0;
+  let scrollDirection = 0;
+  let scrollDuration = baseDuration;
+  let scrollFriction = baseFriction;
+  let rawLocation = location.get();
+  let rawLocationPrevious = 0;
+  function seek() {
+    const displacement = target.get() - location.get();
+    const isInstant = !scrollDuration;
+    let scrollDistance = 0;
+    if (isInstant) {
+      scrollVelocity = 0;
+      previousLocation.set(target);
+      location.set(target);
+      scrollDistance = displacement;
+    } else {
+      previousLocation.set(location);
+      scrollVelocity += displacement / scrollDuration;
+      scrollVelocity *= scrollFriction;
+      rawLocation += scrollVelocity;
+      location.add(scrollVelocity);
+      scrollDistance = rawLocation - rawLocationPrevious;
+    }
+    scrollDirection = mathSign(scrollDistance);
+    rawLocationPrevious = rawLocation;
+    return self;
+  }
+  function settled() {
+    const diff = target.get() - offsetLocation.get();
+    return mathAbs(diff) < 0.001;
+  }
+  function duration() {
+    return scrollDuration;
+  }
+  function direction() {
+    return scrollDirection;
+  }
+  function velocity() {
+    return scrollVelocity;
+  }
+  function useBaseDuration() {
+    return useDuration(baseDuration);
+  }
+  function useBaseFriction() {
+    return useFriction(baseFriction);
+  }
+  function useDuration(n) {
+    scrollDuration = n;
+    return self;
+  }
+  function useFriction(n) {
+    scrollFriction = n;
+    return self;
+  }
+  const self = {
+    direction,
+    duration,
+    velocity,
+    seek,
+    settled,
+    useBaseFriction,
+    useBaseDuration,
+    useFriction,
+    useDuration
+  };
+  return self;
+}
+function ScrollBounds(limit, location, target, scrollBody, percentOfView) {
+  const pullBackThreshold = percentOfView.measure(10);
+  const edgeOffsetTolerance = percentOfView.measure(50);
+  const frictionLimit = Limit(0.1, 0.99);
+  let disabled = false;
+  function shouldConstrain() {
+    if (disabled) return false;
+    if (!limit.reachedAny(target.get())) return false;
+    if (!limit.reachedAny(location.get())) return false;
+    return true;
+  }
+  function constrain(pointerDown) {
+    if (!shouldConstrain()) return;
+    const edge = limit.reachedMin(location.get()) ? 'min' : 'max';
+    const diffToEdge = mathAbs(limit[edge] - location.get());
+    const diffToTarget = target.get() - location.get();
+    const friction = frictionLimit.constrain(diffToEdge / edgeOffsetTolerance);
+    target.subtract(diffToTarget * friction);
+    if (!pointerDown && mathAbs(diffToTarget) < pullBackThreshold) {
+      target.set(limit.constrain(target.get()));
+      scrollBody.useDuration(25).useBaseFriction();
+    }
+  }
+  function toggleActive(active) {
+    disabled = !active;
+  }
+  const self = {
+    shouldConstrain,
+    constrain,
+    toggleActive
+  };
+  return self;
+}
+function ScrollContain(viewSize, contentSize, snapsAligned, containScroll, pixelTolerance) {
+  const scrollBounds = Limit(-contentSize + viewSize, 0);
+  const snapsBounded = measureBounded();
+  const scrollContainLimit = findScrollContainLimit();
+  const snapsContained = measureContained();
+  function usePixelTolerance(bound, snap) {
+    return deltaAbs(bound, snap) <= 1;
+  }
+  function findScrollContainLimit() {
+    const startSnap = snapsBounded[0];
+    const endSnap = arrayLast(snapsBounded);
+    const min = snapsBounded.lastIndexOf(startSnap);
+    const max = snapsBounded.indexOf(endSnap) + 1;
+    return Limit(min, max);
+  }
+  function measureBounded() {
+    return snapsAligned.map((snapAligned, index) => {
+      const {
+        min,
+        max
+      } = scrollBounds;
+      const snap = scrollBounds.constrain(snapAligned);
+      const isFirst = !index;
+      const isLast = arrayIsLastIndex(snapsAligned, index);
+      if (isFirst) return max;
+      if (isLast) return min;
+      if (usePixelTolerance(min, snap)) return min;
+      if (usePixelTolerance(max, snap)) return max;
+      return snap;
+    }).map(scrollBound => parseFloat(scrollBound.toFixed(3)));
+  }
+  function measureContained() {
+    if (contentSize <= viewSize + pixelTolerance) return [scrollBounds.max];
+    if (containScroll === 'keepSnaps') return snapsBounded;
+    const {
+      min,
+      max
+    } = scrollContainLimit;
+    return snapsBounded.slice(min, max);
+  }
+  const self = {
+    snapsContained,
+    scrollContainLimit
+  };
+  return self;
+}
+function ScrollLimit(contentSize, scrollSnaps, loop) {
+  const max = scrollSnaps[0];
+  const min = loop ? max - contentSize : arrayLast(scrollSnaps);
+  const limit = Limit(min, max);
+  const self = {
+    limit
+  };
+  return self;
+}
+function ScrollLooper(contentSize, limit, location, vectors) {
+  const jointSafety = 0.1;
+  const min = limit.min + jointSafety;
+  const max = limit.max + jointSafety;
+  const {
+    reachedMin,
+    reachedMax
+  } = Limit(min, max);
+  function shouldLoop(direction) {
+    if (direction === 1) return reachedMax(location.get());
+    if (direction === -1) return reachedMin(location.get());
+    return false;
+  }
+  function loop(direction) {
+    if (!shouldLoop(direction)) return;
+    const loopDistance = contentSize * (direction * -1);
+    vectors.forEach(v => v.add(loopDistance));
+  }
+  const self = {
+    loop
+  };
+  return self;
+}
+function ScrollProgress(limit) {
+  const {
+    max,
+    length
+  } = limit;
+  function get(n) {
+    const currentLocation = n - max;
+    return length ? currentLocation / -length : 0;
+  }
+  const self = {
+    get
+  };
+  return self;
+}
+function ScrollSnaps(axis, alignment, containerRect, slideRects, slidesToScroll) {
+  const {
+    startEdge,
+    endEdge
+  } = axis;
+  const {
+    groupSlides
+  } = slidesToScroll;
+  const alignments = measureSizes().map(alignment.measure);
+  const snaps = measureUnaligned();
+  const snapsAligned = measureAligned();
+  function measureSizes() {
+    return groupSlides(slideRects).map(rects => arrayLast(rects)[endEdge] - rects[0][startEdge]).map(mathAbs);
+  }
+  function measureUnaligned() {
+    return slideRects.map(rect => containerRect[startEdge] - rect[startEdge]).map(snap => -mathAbs(snap));
+  }
+  function measureAligned() {
+    return groupSlides(snaps).map(g => g[0]).map((snap, index) => snap + alignments[index]);
+  }
+  const self = {
+    snaps,
+    snapsAligned
+  };
+  return self;
+}
+function SlideRegistry(containSnaps, containScroll, scrollSnaps, scrollContainLimit, slidesToScroll, slideIndexes) {
+  const {
+    groupSlides
+  } = slidesToScroll;
+  const {
+    min,
+    max
+  } = scrollContainLimit;
+  const slideRegistry = createSlideRegistry();
+  function createSlideRegistry() {
+    const groupedSlideIndexes = groupSlides(slideIndexes);
+    const doNotContain = !containSnaps || containScroll === 'keepSnaps';
+    if (scrollSnaps.length === 1) return [slideIndexes];
+    if (doNotContain) return groupedSlideIndexes;
+    return groupedSlideIndexes.slice(min, max).map((group, index, groups) => {
+      const isFirst = !index;
+      const isLast = arrayIsLastIndex(groups, index);
+      if (isFirst) {
+        const range = arrayLast(groups[0]) + 1;
+        return arrayFromNumber(range);
+      }
+      if (isLast) {
+        const range = arrayLastIndex(slideIndexes) - arrayLast(groups)[0] + 1;
+        return arrayFromNumber(range, arrayLast(groups)[0]);
+      }
+      return group;
+    });
+  }
+  const self = {
+    slideRegistry
+  };
+  return self;
+}
+function ScrollTarget(loop, scrollSnaps, contentSize, limit, targetVector) {
+  const {
+    reachedAny,
+    removeOffset,
+    constrain
+  } = limit;
+  function minDistance(distances) {
+    return distances.concat().sort((a, b) => mathAbs(a) - mathAbs(b))[0];
+  }
+  function findTargetSnap(target) {
+    const distance = loop ? removeOffset(target) : constrain(target);
+    const ascDiffsToSnaps = scrollSnaps.map((snap, index) => ({
+      diff: shortcut(snap - distance, 0),
+      index
+    })).sort((d1, d2) => mathAbs(d1.diff) - mathAbs(d2.diff));
+    const {
+      index
+    } = ascDiffsToSnaps[0];
+    return {
+      index,
+      distance
+    };
+  }
+  function shortcut(target, direction) {
+    const targets = [target, target + contentSize, target - contentSize];
+    if (!loop) return target;
+    if (!direction) return minDistance(targets);
+    const matchingTargets = targets.filter(t => mathSign(t) === direction);
+    if (matchingTargets.length) return minDistance(matchingTargets);
+    return arrayLast(targets) - contentSize;
+  }
+  function byIndex(index, direction) {
+    const diffToSnap = scrollSnaps[index] - targetVector.get();
+    const distance = shortcut(diffToSnap, direction);
+    return {
+      index,
+      distance
+    };
+  }
+  function byDistance(distance, snap) {
+    const target = targetVector.get() + distance;
+    const {
+      index,
+      distance: targetSnapDistance
+    } = findTargetSnap(target);
+    const reachedBound = !loop && reachedAny(target);
+    if (!snap || reachedBound) return {
+      index,
+      distance
+    };
+    const diffToSnap = scrollSnaps[index] - targetSnapDistance;
+    const snapDistance = distance + shortcut(diffToSnap, 0);
+    return {
+      index,
+      distance: snapDistance
+    };
+  }
+  const self = {
+    byDistance,
+    byIndex,
+    shortcut
+  };
+  return self;
+}
+function ScrollTo(animation, indexCurrent, indexPrevious, scrollBody, scrollTarget, targetVector, eventHandler) {
+  function scrollTo(target) {
+    const distanceDiff = target.distance;
+    const indexDiff = target.index !== indexCurrent.get();
+    targetVector.add(distanceDiff);
+    if (distanceDiff) {
+      if (scrollBody.duration()) {
+        animation.start();
+      } else {
+        animation.update();
+        animation.render(1);
+        animation.update();
+      }
+    }
+    if (indexDiff) {
+      indexPrevious.set(indexCurrent.get());
+      indexCurrent.set(target.index);
+      eventHandler.emit('select');
+    }
+  }
+  function distance(n, snap) {
+    const target = scrollTarget.byDistance(n, snap);
+    scrollTo(target);
+  }
+  function index(n, direction) {
+    const targetIndex = indexCurrent.clone().set(n);
+    const target = scrollTarget.byIndex(targetIndex.get(), direction);
+    scrollTo(target);
+  }
+  const self = {
+    distance,
+    index
+  };
+  return self;
+}
+function SlideFocus(root, slides, slideRegistry, scrollTo, scrollBody, eventStore, eventHandler, watchFocus) {
+  const focusListenerOptions = {
+    passive: true,
+    capture: true
+  };
+  let lastTabPressTime = 0;
+  function init(emblaApi) {
+    if (!watchFocus) return;
+    function defaultCallback(index) {
+      const nowTime = new Date().getTime();
+      const diffTime = nowTime - lastTabPressTime;
+      if (diffTime > 10) return;
+      eventHandler.emit('slideFocusStart');
+      root.scrollLeft = 0;
+      const group = slideRegistry.findIndex(group => group.includes(index));
+      if (!isNumber$1(group)) return;
+      scrollBody.useDuration(0);
+      scrollTo.index(group, 0);
+      eventHandler.emit('slideFocus');
+    }
+    eventStore.add(document, 'keydown', registerTabPress, false);
+    slides.forEach((slide, slideIndex) => {
+      eventStore.add(slide, 'focus', evt => {
+        if (isBoolean(watchFocus) || watchFocus(emblaApi, evt)) {
+          defaultCallback(slideIndex);
+        }
+      }, focusListenerOptions);
+    });
+  }
+  function registerTabPress(event) {
+    if (event.code === 'Tab') lastTabPressTime = new Date().getTime();
+  }
+  const self = {
+    init
+  };
+  return self;
+}
+function Vector1D(initialValue) {
+  let value = initialValue;
+  function get() {
+    return value;
+  }
+  function set(n) {
+    value = normalizeInput(n);
+  }
+  function add(n) {
+    value += normalizeInput(n);
+  }
+  function subtract(n) {
+    value -= normalizeInput(n);
+  }
+  function normalizeInput(n) {
+    return isNumber$1(n) ? n : n.get();
+  }
+  const self = {
+    get,
+    set,
+    add,
+    subtract
+  };
+  return self;
+}
+function Translate(axis, container) {
+  const translate = axis.scroll === 'x' ? x : y;
+  const containerStyle = container.style;
+  let previousTarget = null;
+  let disabled = false;
+  function x(n) {
+    return `translate3d(${n}px,0px,0px)`;
+  }
+  function y(n) {
+    return `translate3d(0px,${n}px,0px)`;
+  }
+  function to(target) {
+    if (disabled) return;
+    const newTarget = roundToTwoDecimals(axis.direction(target));
+    if (newTarget === previousTarget) return;
+    containerStyle.transform = translate(newTarget);
+    previousTarget = newTarget;
+  }
+  function toggleActive(active) {
+    disabled = !active;
+  }
+  function clear() {
+    if (disabled) return;
+    containerStyle.transform = '';
+    if (!container.getAttribute('style')) container.removeAttribute('style');
+  }
+  const self = {
+    clear,
+    to,
+    toggleActive
+  };
+  return self;
+}
+function SlideLooper(axis, viewSize, contentSize, slideSizes, slideSizesWithGaps, snaps, scrollSnaps, location, slides) {
+  const roundingSafety = 0.5;
+  const ascItems = arrayKeys(slideSizesWithGaps);
+  const descItems = arrayKeys(slideSizesWithGaps).reverse();
+  const loopPoints = startPoints().concat(endPoints());
+  function removeSlideSizes(indexes, from) {
+    return indexes.reduce((a, i) => {
+      return a - slideSizesWithGaps[i];
+    }, from);
+  }
+  function slidesInGap(indexes, gap) {
+    return indexes.reduce((a, i) => {
+      const remainingGap = removeSlideSizes(a, gap);
+      return remainingGap > 0 ? a.concat([i]) : a;
+    }, []);
+  }
+  function findSlideBounds(offset) {
+    return snaps.map((snap, index) => ({
+      start: snap - slideSizes[index] + roundingSafety + offset,
+      end: snap + viewSize - roundingSafety + offset
+    }));
+  }
+  function findLoopPoints(indexes, offset, isEndEdge) {
+    const slideBounds = findSlideBounds(offset);
+    return indexes.map(index => {
+      const initial = isEndEdge ? 0 : -contentSize;
+      const altered = isEndEdge ? contentSize : 0;
+      const boundEdge = isEndEdge ? 'end' : 'start';
+      const loopPoint = slideBounds[index][boundEdge];
+      return {
+        index,
+        loopPoint,
+        slideLocation: Vector1D(-1),
+        translate: Translate(axis, slides[index]),
+        target: () => location.get() > loopPoint ? initial : altered
+      };
+    });
+  }
+  function startPoints() {
+    const gap = scrollSnaps[0];
+    const indexes = slidesInGap(descItems, gap);
+    return findLoopPoints(indexes, contentSize, false);
+  }
+  function endPoints() {
+    const gap = viewSize - scrollSnaps[0] - 1;
+    const indexes = slidesInGap(ascItems, gap);
+    return findLoopPoints(indexes, -contentSize, true);
+  }
+  function canLoop() {
+    return loopPoints.every(({
+      index
+    }) => {
+      const otherIndexes = ascItems.filter(i => i !== index);
+      return removeSlideSizes(otherIndexes, viewSize) <= 0.1;
+    });
+  }
+  function loop() {
+    loopPoints.forEach(loopPoint => {
+      const {
+        target,
+        translate,
+        slideLocation
+      } = loopPoint;
+      const shiftLocation = target();
+      if (shiftLocation === slideLocation.get()) return;
+      translate.to(shiftLocation);
+      slideLocation.set(shiftLocation);
+    });
+  }
+  function clear() {
+    loopPoints.forEach(loopPoint => loopPoint.translate.clear());
+  }
+  const self = {
+    canLoop,
+    clear,
+    loop,
+    loopPoints
+  };
+  return self;
+}
+function SlidesHandler(container, eventHandler, watchSlides) {
+  let mutationObserver;
+  let destroyed = false;
+  function init(emblaApi) {
+    if (!watchSlides) return;
+    function defaultCallback(mutations) {
+      for (const mutation of mutations) {
+        if (mutation.type === 'childList') {
+          emblaApi.reInit();
+          eventHandler.emit('slidesChanged');
+          break;
+        }
+      }
+    }
+    mutationObserver = new MutationObserver(mutations => {
+      if (destroyed) return;
+      if (isBoolean(watchSlides) || watchSlides(emblaApi, mutations)) {
+        defaultCallback(mutations);
+      }
+    });
+    mutationObserver.observe(container, {
+      childList: true
+    });
+  }
+  function destroy() {
+    if (mutationObserver) mutationObserver.disconnect();
+    destroyed = true;
+  }
+  const self = {
+    init,
+    destroy
+  };
+  return self;
+}
+function SlidesInView(container, slides, eventHandler, threshold) {
+  const intersectionEntryMap = {};
+  let inViewCache = null;
+  let notInViewCache = null;
+  let intersectionObserver;
+  let destroyed = false;
+  function init() {
+    intersectionObserver = new IntersectionObserver(entries => {
+      if (destroyed) return;
+      entries.forEach(entry => {
+        const index = slides.indexOf(entry.target);
+        intersectionEntryMap[index] = entry;
+      });
+      inViewCache = null;
+      notInViewCache = null;
+      eventHandler.emit('slidesInView');
+    }, {
+      root: container.parentElement,
+      threshold
+    });
+    slides.forEach(slide => intersectionObserver.observe(slide));
+  }
+  function destroy() {
+    if (intersectionObserver) intersectionObserver.disconnect();
+    destroyed = true;
+  }
+  function createInViewList(inView) {
+    return objectKeys(intersectionEntryMap).reduce((list, slideIndex) => {
+      const index = parseInt(slideIndex);
+      const {
+        isIntersecting
+      } = intersectionEntryMap[index];
+      const inViewMatch = inView && isIntersecting;
+      const notInViewMatch = !inView && !isIntersecting;
+      if (inViewMatch || notInViewMatch) list.push(index);
+      return list;
+    }, []);
+  }
+  function get(inView = true) {
+    if (inView && inViewCache) return inViewCache;
+    if (!inView && notInViewCache) return notInViewCache;
+    const slideIndexes = createInViewList(inView);
+    if (inView) inViewCache = slideIndexes;
+    if (!inView) notInViewCache = slideIndexes;
+    return slideIndexes;
+  }
+  const self = {
+    init,
+    destroy,
+    get
+  };
+  return self;
+}
+function SlideSizes(axis, containerRect, slideRects, slides, readEdgeGap, ownerWindow) {
+  const {
+    measureSize,
+    startEdge,
+    endEdge
+  } = axis;
+  const withEdgeGap = slideRects[0] && readEdgeGap;
+  const startGap = measureStartGap();
+  const endGap = measureEndGap();
+  const slideSizes = slideRects.map(measureSize);
+  const slideSizesWithGaps = measureWithGaps();
+  function measureStartGap() {
+    if (!withEdgeGap) return 0;
+    const slideRect = slideRects[0];
+    return mathAbs(containerRect[startEdge] - slideRect[startEdge]);
+  }
+  function measureEndGap() {
+    if (!withEdgeGap) return 0;
+    const style = ownerWindow.getComputedStyle(arrayLast(slides));
+    return parseFloat(style.getPropertyValue(`margin-${endEdge}`));
+  }
+  function measureWithGaps() {
+    return slideRects.map((rect, index, rects) => {
+      const isFirst = !index;
+      const isLast = arrayIsLastIndex(rects, index);
+      if (isFirst) return slideSizes[index] + startGap;
+      if (isLast) return slideSizes[index] + endGap;
+      return rects[index + 1][startEdge] - rect[startEdge];
+    }).map(mathAbs);
+  }
+  const self = {
+    slideSizes,
+    slideSizesWithGaps,
+    startGap,
+    endGap
+  };
+  return self;
+}
+function SlidesToScroll(axis, viewSize, slidesToScroll, loop, containerRect, slideRects, startGap, endGap, pixelTolerance) {
+  const {
+    startEdge,
+    endEdge,
+    direction
+  } = axis;
+  const groupByNumber = isNumber$1(slidesToScroll);
+  function byNumber(array, groupSize) {
+    return arrayKeys(array).filter(i => i % groupSize === 0).map(i => array.slice(i, i + groupSize));
+  }
+  function bySize(array) {
+    if (!array.length) return [];
+    return arrayKeys(array).reduce((groups, rectB, index) => {
+      const rectA = arrayLast(groups) || 0;
+      const isFirst = rectA === 0;
+      const isLast = rectB === arrayLastIndex(array);
+      const edgeA = containerRect[startEdge] - slideRects[rectA][startEdge];
+      const edgeB = containerRect[startEdge] - slideRects[rectB][endEdge];
+      const gapA = !loop && isFirst ? direction(startGap) : 0;
+      const gapB = !loop && isLast ? direction(endGap) : 0;
+      const chunkSize = mathAbs(edgeB - gapB - (edgeA + gapA));
+      if (index && chunkSize > viewSize + pixelTolerance) groups.push(rectB);
+      if (isLast) groups.push(array.length);
+      return groups;
+    }, []).map((currentSize, index, groups) => {
+      const previousSize = Math.max(groups[index - 1] || 0);
+      return array.slice(previousSize, currentSize);
+    });
+  }
+  function groupSlides(array) {
+    return groupByNumber ? byNumber(array, slidesToScroll) : bySize(array);
+  }
+  const self = {
+    groupSlides
+  };
+  return self;
+}
+function Engine(root, container, slides, ownerDocument, ownerWindow, options, eventHandler) {
+  // Options
+  const {
+    align,
+    axis: scrollAxis,
+    direction,
+    startIndex,
+    loop,
+    duration,
+    dragFree,
+    dragThreshold,
+    inViewThreshold,
+    slidesToScroll: groupSlides,
+    skipSnaps,
+    containScroll,
+    watchResize,
+    watchSlides,
+    watchDrag,
+    watchFocus
+  } = options;
+  // Measurements
+  const pixelTolerance = 2;
+  const nodeRects = NodeRects();
+  const containerRect = nodeRects.measure(container);
+  const slideRects = slides.map(nodeRects.measure);
+  const axis = Axis(scrollAxis, direction);
+  const viewSize = axis.measureSize(containerRect);
+  const percentOfView = PercentOfView(viewSize);
+  const alignment = Alignment(align, viewSize);
+  const containSnaps = !loop && !!containScroll;
+  const readEdgeGap = loop || !!containScroll;
+  const {
+    slideSizes,
+    slideSizesWithGaps,
+    startGap,
+    endGap
+  } = SlideSizes(axis, containerRect, slideRects, slides, readEdgeGap, ownerWindow);
+  const slidesToScroll = SlidesToScroll(axis, viewSize, groupSlides, loop, containerRect, slideRects, startGap, endGap, pixelTolerance);
+  const {
+    snaps,
+    snapsAligned
+  } = ScrollSnaps(axis, alignment, containerRect, slideRects, slidesToScroll);
+  const contentSize = -arrayLast(snaps) + arrayLast(slideSizesWithGaps);
+  const {
+    snapsContained,
+    scrollContainLimit
+  } = ScrollContain(viewSize, contentSize, snapsAligned, containScroll, pixelTolerance);
+  const scrollSnaps = containSnaps ? snapsContained : snapsAligned;
+  const {
+    limit
+  } = ScrollLimit(contentSize, scrollSnaps, loop);
+  // Indexes
+  const index = Counter(arrayLastIndex(scrollSnaps), startIndex, loop);
+  const indexPrevious = index.clone();
+  const slideIndexes = arrayKeys(slides);
+  // Animation
+  const update = ({
+    dragHandler,
+    scrollBody,
+    scrollBounds,
+    options: {
+      loop
+    }
+  }) => {
+    if (!loop) scrollBounds.constrain(dragHandler.pointerDown());
+    scrollBody.seek();
+  };
+  const render = ({
+    scrollBody,
+    translate,
+    location,
+    offsetLocation,
+    previousLocation,
+    scrollLooper,
+    slideLooper,
+    dragHandler,
+    animation,
+    eventHandler,
+    scrollBounds,
+    options: {
+      loop
+    }
+  }, alpha) => {
+    const shouldSettle = scrollBody.settled();
+    const withinBounds = !scrollBounds.shouldConstrain();
+    const hasSettled = loop ? shouldSettle : shouldSettle && withinBounds;
+    const hasSettledAndIdle = hasSettled && !dragHandler.pointerDown();
+    if (hasSettledAndIdle) animation.stop();
+    const interpolatedLocation = location.get() * alpha + previousLocation.get() * (1 - alpha);
+    offsetLocation.set(interpolatedLocation);
+    if (loop) {
+      scrollLooper.loop(scrollBody.direction());
+      slideLooper.loop();
+    }
+    translate.to(offsetLocation.get());
+    if (hasSettledAndIdle) eventHandler.emit('settle');
+    if (!hasSettled) eventHandler.emit('scroll');
+  };
+  const animation = Animations(ownerDocument, ownerWindow, () => update(engine), alpha => render(engine, alpha));
+  // Shared
+  const friction = 0.68;
+  const startLocation = scrollSnaps[index.get()];
+  const location = Vector1D(startLocation);
+  const previousLocation = Vector1D(startLocation);
+  const offsetLocation = Vector1D(startLocation);
+  const target = Vector1D(startLocation);
+  const scrollBody = ScrollBody(location, offsetLocation, previousLocation, target, duration, friction);
+  const scrollTarget = ScrollTarget(loop, scrollSnaps, contentSize, limit, target);
+  const scrollTo = ScrollTo(animation, index, indexPrevious, scrollBody, scrollTarget, target, eventHandler);
+  const scrollProgress = ScrollProgress(limit);
+  const eventStore = EventStore();
+  const slidesInView = SlidesInView(container, slides, eventHandler, inViewThreshold);
+  const {
+    slideRegistry
+  } = SlideRegistry(containSnaps, containScroll, scrollSnaps, scrollContainLimit, slidesToScroll, slideIndexes);
+  const slideFocus = SlideFocus(root, slides, slideRegistry, scrollTo, scrollBody, eventStore, eventHandler, watchFocus);
+  // Engine
+  const engine = {
+    ownerDocument,
+    ownerWindow,
+    eventHandler,
+    containerRect,
+    slideRects,
+    animation,
+    axis,
+    dragHandler: DragHandler(axis, root, ownerDocument, ownerWindow, target, DragTracker(axis, ownerWindow), location, animation, scrollTo, scrollBody, scrollTarget, index, eventHandler, percentOfView, dragFree, dragThreshold, skipSnaps, friction, watchDrag),
+    eventStore,
+    percentOfView,
+    index,
+    indexPrevious,
+    limit,
+    location,
+    offsetLocation,
+    previousLocation,
+    options,
+    resizeHandler: ResizeHandler(container, eventHandler, ownerWindow, slides, axis, watchResize, nodeRects),
+    scrollBody,
+    scrollBounds: ScrollBounds(limit, offsetLocation, target, scrollBody, percentOfView),
+    scrollLooper: ScrollLooper(contentSize, limit, offsetLocation, [location, offsetLocation, previousLocation, target]),
+    scrollProgress,
+    scrollSnapList: scrollSnaps.map(scrollProgress.get),
+    scrollSnaps,
+    scrollTarget,
+    scrollTo,
+    slideLooper: SlideLooper(axis, viewSize, contentSize, slideSizes, slideSizesWithGaps, snaps, scrollSnaps, offsetLocation, slides),
+    slideFocus,
+    slidesHandler: SlidesHandler(container, eventHandler, watchSlides),
+    slidesInView,
+    slideIndexes,
+    slideRegistry,
+    slidesToScroll,
+    target,
+    translate: Translate(axis, container)
+  };
+  return engine;
+}
+function EventHandler() {
+  let listeners = {};
+  let api;
+  function init(emblaApi) {
+    api = emblaApi;
+  }
+  function getListeners(evt) {
+    return listeners[evt] || [];
+  }
+  function emit(evt) {
+    getListeners(evt).forEach(e => e(api, evt));
+    return self;
+  }
+  function on(evt, cb) {
+    listeners[evt] = getListeners(evt).concat([cb]);
+    return self;
+  }
+  function off(evt, cb) {
+    listeners[evt] = getListeners(evt).filter(e => e !== cb);
+    return self;
+  }
+  function clear() {
+    listeners = {};
+  }
+  const self = {
+    init,
+    emit,
+    off,
+    on,
+    clear
+  };
+  return self;
+}
+const defaultOptions = {
+  align: 'center',
+  axis: 'x',
+  container: null,
+  slides: null,
+  containScroll: 'trimSnaps',
+  direction: 'ltr',
+  slidesToScroll: 1,
+  inViewThreshold: 0,
+  breakpoints: {},
+  dragFree: false,
+  dragThreshold: 10,
+  loop: false,
+  skipSnaps: false,
+  duration: 25,
+  startIndex: 0,
+  active: true,
+  watchDrag: true,
+  watchResize: true,
+  watchSlides: true,
+  watchFocus: true
+};
+function OptionsHandler(ownerWindow) {
+  function mergeOptions(optionsA, optionsB) {
+    return objectsMergeDeep(optionsA, optionsB || {});
+  }
+  function optionsAtMedia(options) {
+    const optionsAtMedia = options.breakpoints || {};
+    const matchedMediaOptions = objectKeys(optionsAtMedia).filter(media => ownerWindow.matchMedia(media).matches).map(media => optionsAtMedia[media]).reduce((a, mediaOption) => mergeOptions(a, mediaOption), {});
+    return mergeOptions(options, matchedMediaOptions);
+  }
+  function optionsMediaQueries(optionsList) {
+    return optionsList.map(options => objectKeys(options.breakpoints || {})).reduce((acc, mediaQueries) => acc.concat(mediaQueries), []).map(ownerWindow.matchMedia);
+  }
+  const self = {
+    mergeOptions,
+    optionsAtMedia,
+    optionsMediaQueries
+  };
+  return self;
+}
+function PluginsHandler(optionsHandler) {
+  let activePlugins = [];
+  function init(emblaApi, plugins) {
+    activePlugins = plugins.filter(({
+      options
+    }) => optionsHandler.optionsAtMedia(options).active !== false);
+    activePlugins.forEach(plugin => plugin.init(emblaApi, optionsHandler));
+    return plugins.reduce((map, plugin) => Object.assign(map, {
+      [plugin.name]: plugin
+    }), {});
+  }
+  function destroy() {
+    activePlugins = activePlugins.filter(plugin => plugin.destroy());
+  }
+  const self = {
+    init,
+    destroy
+  };
+  return self;
+}
+function EmblaCarousel(root, userOptions, userPlugins) {
+  const ownerDocument = root.ownerDocument;
+  const ownerWindow = ownerDocument.defaultView;
+  const optionsHandler = OptionsHandler(ownerWindow);
+  const pluginsHandler = PluginsHandler(optionsHandler);
+  const mediaHandlers = EventStore();
+  const eventHandler = EventHandler();
+  const {
+    mergeOptions,
+    optionsAtMedia,
+    optionsMediaQueries
+  } = optionsHandler;
+  const {
+    on,
+    off,
+    emit
+  } = eventHandler;
+  const reInit = reActivate;
+  let destroyed = false;
+  let engine;
+  let optionsBase = mergeOptions(defaultOptions, EmblaCarousel.globalOptions);
+  let options = mergeOptions(optionsBase);
+  let pluginList = [];
+  let pluginApis;
+  let container;
+  let slides;
+  function storeElements() {
+    const {
+      container: userContainer,
+      slides: userSlides
+    } = options;
+    const customContainer = isString(userContainer) ? root.querySelector(userContainer) : userContainer;
+    container = customContainer || root.children[0];
+    const customSlides = isString(userSlides) ? container.querySelectorAll(userSlides) : userSlides;
+    slides = [].slice.call(customSlides || container.children);
+  }
+  function createEngine(options) {
+    const engine = Engine(root, container, slides, ownerDocument, ownerWindow, options, eventHandler);
+    if (options.loop && !engine.slideLooper.canLoop()) {
+      const optionsWithoutLoop = Object.assign({}, options, {
+        loop: false
+      });
+      return createEngine(optionsWithoutLoop);
+    }
+    return engine;
+  }
+  function activate(withOptions, withPlugins) {
+    if (destroyed) return;
+    optionsBase = mergeOptions(optionsBase, withOptions);
+    options = optionsAtMedia(optionsBase);
+    pluginList = withPlugins || pluginList;
+    storeElements();
+    engine = createEngine(options);
+    optionsMediaQueries([optionsBase, ...pluginList.map(({
+      options
+    }) => options)]).forEach(query => mediaHandlers.add(query, 'change', reActivate));
+    if (!options.active) return;
+    engine.translate.to(engine.location.get());
+    engine.animation.init();
+    engine.slidesInView.init();
+    engine.slideFocus.init(self);
+    engine.eventHandler.init(self);
+    engine.resizeHandler.init(self);
+    engine.slidesHandler.init(self);
+    if (engine.options.loop) engine.slideLooper.loop();
+    if (container.offsetParent && slides.length) engine.dragHandler.init(self);
+    pluginApis = pluginsHandler.init(self, pluginList);
+  }
+  function reActivate(withOptions, withPlugins) {
+    const startIndex = selectedScrollSnap();
+    deActivate();
+    activate(mergeOptions({
+      startIndex
+    }, withOptions), withPlugins);
+    eventHandler.emit('reInit');
+  }
+  function deActivate() {
+    engine.dragHandler.destroy();
+    engine.eventStore.clear();
+    engine.translate.clear();
+    engine.slideLooper.clear();
+    engine.resizeHandler.destroy();
+    engine.slidesHandler.destroy();
+    engine.slidesInView.destroy();
+    engine.animation.destroy();
+    pluginsHandler.destroy();
+    mediaHandlers.clear();
+  }
+  function destroy() {
+    if (destroyed) return;
+    destroyed = true;
+    mediaHandlers.clear();
+    deActivate();
+    eventHandler.emit('destroy');
+    eventHandler.clear();
+  }
+  function scrollTo(index, jump, direction) {
+    if (!options.active || destroyed) return;
+    engine.scrollBody.useBaseFriction().useDuration(jump === true ? 0 : options.duration);
+    engine.scrollTo.index(index, direction || 0);
+  }
+  function scrollNext(jump) {
+    const next = engine.index.add(1).get();
+    scrollTo(next, jump, -1);
+  }
+  function scrollPrev(jump) {
+    const prev = engine.index.add(-1).get();
+    scrollTo(prev, jump, 1);
+  }
+  function canScrollNext() {
+    const next = engine.index.add(1).get();
+    return next !== selectedScrollSnap();
+  }
+  function canScrollPrev() {
+    const prev = engine.index.add(-1).get();
+    return prev !== selectedScrollSnap();
+  }
+  function scrollSnapList() {
+    return engine.scrollSnapList;
+  }
+  function scrollProgress() {
+    return engine.scrollProgress.get(engine.offsetLocation.get());
+  }
+  function selectedScrollSnap() {
+    return engine.index.get();
+  }
+  function previousScrollSnap() {
+    return engine.indexPrevious.get();
+  }
+  function slidesInView() {
+    return engine.slidesInView.get();
+  }
+  function slidesNotInView() {
+    return engine.slidesInView.get(false);
+  }
+  function plugins() {
+    return pluginApis;
+  }
+  function internalEngine() {
+    return engine;
+  }
+  function rootNode() {
+    return root;
+  }
+  function containerNode() {
+    return container;
+  }
+  function slideNodes() {
+    return slides;
+  }
+  const self = {
+    canScrollNext,
+    canScrollPrev,
+    containerNode,
+    internalEngine,
+    destroy,
+    off,
+    on,
+    emit,
+    plugins,
+    previousScrollSnap,
+    reInit,
+    rootNode,
+    scrollNext,
+    scrollPrev,
+    scrollProgress,
+    scrollSnapList,
+    scrollTo,
+    selectedScrollSnap,
+    slideNodes,
+    slidesInView,
+    slidesNotInView
+  };
+  activate(userOptions, userPlugins);
+  setTimeout(() => eventHandler.emit('init'), 0);
+  return self;
+}
+EmblaCarousel.globalOptions = undefined;
+
+function clampNumber(number, min, max) {
+  return Math.min(Math.max(number, min), max);
+}
+function isNumber(value) {
+  return typeof value === 'number' && !isNaN(value);
+}
+function Fade(userOptions = {}) {
+  const fullOpacity = 1;
+  const noOpacity = 0;
+  const fadeFriction = 0.68;
+  let emblaApi;
+  let opacities = [];
+  let fadeToNextDistance;
+  let distanceFromPointerDown = 0;
+  let fadeVelocity = 0;
+  let progress = 0;
+  let shouldFadePair = false;
+  let defaultSettledBehaviour;
+  let defaultProgressBehaviour;
+  function init(emblaApiInstance) {
+    emblaApi = emblaApiInstance;
+    const selectedSnap = emblaApi.selectedScrollSnap();
+    const {
+      scrollBody,
+      containerRect,
+      axis
+    } = emblaApi.internalEngine();
+    const containerSize = axis.measureSize(containerRect);
+    fadeToNextDistance = clampNumber(containerSize * 0.75, 200, 500);
+    shouldFadePair = false;
+    opacities = emblaApi.scrollSnapList().map((_, index) => index === selectedSnap ? fullOpacity : noOpacity);
+    defaultSettledBehaviour = scrollBody.settled;
+    defaultProgressBehaviour = emblaApi.scrollProgress;
+    scrollBody.settled = settled;
+    emblaApi.scrollProgress = scrollProgress;
+    emblaApi.on('select', select).on('slideFocus', fadeToSelectedSnapInstantly).on('pointerDown', pointerDown).on('pointerUp', pointerUp);
+    disableScroll();
+    fadeToSelectedSnapInstantly();
+  }
+  function destroy() {
+    const {
+      scrollBody
+    } = emblaApi.internalEngine();
+    scrollBody.settled = defaultSettledBehaviour;
+    emblaApi.scrollProgress = defaultProgressBehaviour;
+    emblaApi.off('select', select).off('slideFocus', fadeToSelectedSnapInstantly).off('pointerDown', pointerDown).off('pointerUp', pointerUp);
+    emblaApi.slideNodes().forEach(slideNode => {
+      const slideStyle = slideNode.style;
+      slideStyle.opacity = '';
+      slideStyle.transform = '';
+      slideStyle.pointerEvents = '';
+      if (!slideNode.getAttribute('style')) slideNode.removeAttribute('style');
+    });
+  }
+  function fadeToSelectedSnapInstantly() {
+    const selectedSnap = emblaApi.selectedScrollSnap();
+    setOpacities(selectedSnap, fullOpacity);
+  }
+  function pointerUp() {
+    shouldFadePair = false;
+  }
+  function pointerDown() {
+    shouldFadePair = false;
+    distanceFromPointerDown = 0;
+    fadeVelocity = 0;
+  }
+  function select() {
+    const duration = emblaApi.internalEngine().scrollBody.duration();
+    fadeVelocity = duration ? 0 : fullOpacity;
+    shouldFadePair = true;
+    if (!duration) fadeToSelectedSnapInstantly();
+  }
+  function getSlideTransform(position) {
+    const {
+      axis
+    } = emblaApi.internalEngine();
+    const translateAxis = axis.scroll.toUpperCase();
+    return `translate${translateAxis}(${axis.direction(position)}px)`;
+  }
+  function disableScroll() {
+    const {
+      translate,
+      slideLooper
+    } = emblaApi.internalEngine();
+    translate.clear();
+    translate.toggleActive(false);
+    slideLooper.loopPoints.forEach(({
+      translate
+    }) => {
+      translate.clear();
+      translate.toggleActive(false);
+    });
+  }
+  function lockExcessiveScroll(fadeIndex) {
+    const {
+      scrollSnaps,
+      location,
+      target
+    } = emblaApi.internalEngine();
+    if (!isNumber(fadeIndex) || opacities[fadeIndex] < 0.5) return;
+    location.set(scrollSnaps[fadeIndex]);
+    target.set(location);
+  }
+  function setOpacities(fadeIndex, velocity) {
+    const scrollSnaps = emblaApi.scrollSnapList();
+    scrollSnaps.forEach((_, indexA) => {
+      const absVelocity = Math.abs(velocity);
+      const currentOpacity = opacities[indexA];
+      const isFadeIndex = indexA === fadeIndex;
+      const nextOpacity = isFadeIndex ? currentOpacity + absVelocity : currentOpacity - absVelocity;
+      const clampedOpacity = clampNumber(nextOpacity, noOpacity, fullOpacity);
+      opacities[indexA] = clampedOpacity;
+      const fadePair = isFadeIndex && shouldFadePair;
+      const indexB = emblaApi.previousScrollSnap();
+      if (fadePair) opacities[indexB] = 1 - clampedOpacity;
+      if (isFadeIndex) setProgress(fadeIndex, clampedOpacity);
+      setOpacity(indexA);
+    });
+  }
+  function setOpacity(index) {
+    const slidesInSnap = emblaApi.internalEngine().slideRegistry[index];
+    const {
+      scrollSnaps,
+      containerRect
+    } = emblaApi.internalEngine();
+    const opacity = opacities[index];
+    slidesInSnap.forEach(slideIndex => {
+      const slideStyle = emblaApi.slideNodes()[slideIndex].style;
+      const roundedOpacity = parseFloat(opacity.toFixed(2));
+      const hasOpacity = roundedOpacity > noOpacity;
+      const position = hasOpacity ? scrollSnaps[index] : containerRect.width + 2;
+      const transform = getSlideTransform(position);
+      if (hasOpacity) slideStyle.transform = transform;
+      slideStyle.opacity = roundedOpacity.toString();
+      slideStyle.pointerEvents = opacity > 0.5 ? 'auto' : 'none';
+      if (!hasOpacity) slideStyle.transform = transform;
+    });
+  }
+  function setProgress(fadeIndex, opacity) {
+    const {
+      index,
+      dragHandler,
+      scrollSnaps
+    } = emblaApi.internalEngine();
+    const pointerDown = dragHandler.pointerDown();
+    const snapFraction = 1 / (scrollSnaps.length - 1);
+    let indexA = fadeIndex;
+    let indexB = pointerDown ? emblaApi.selectedScrollSnap() : emblaApi.previousScrollSnap();
+    if (pointerDown && indexA === indexB) {
+      const reverseSign = Math.sign(distanceFromPointerDown) * -1;
+      indexA = indexB;
+      indexB = index.clone().set(indexB).add(reverseSign).get();
+    }
+    const currentPosition = indexB * snapFraction;
+    const diffPosition = (indexA - indexB) * snapFraction;
+    progress = currentPosition + diffPosition * opacity;
+  }
+  function getFadeIndex() {
+    const {
+      dragHandler,
+      index,
+      scrollBody
+    } = emblaApi.internalEngine();
+    const selectedSnap = emblaApi.selectedScrollSnap();
+    if (!dragHandler.pointerDown()) return selectedSnap;
+    const directionSign = Math.sign(scrollBody.velocity());
+    const distanceSign = Math.sign(distanceFromPointerDown);
+    const nextSnap = index.clone().set(selectedSnap).add(directionSign * -1).get();
+    if (!directionSign || !distanceSign) return null;
+    return distanceSign === directionSign ? nextSnap : selectedSnap;
+  }
+  function fade(emblaApi) {
+    const {
+      dragHandler,
+      scrollBody
+    } = emblaApi.internalEngine();
+    const pointerDown = dragHandler.pointerDown();
+    const velocity = scrollBody.velocity();
+    const duration = scrollBody.duration();
+    const fadeIndex = getFadeIndex();
+    const noFadeIndex = !isNumber(fadeIndex);
+    if (pointerDown) {
+      if (!velocity) return;
+      distanceFromPointerDown += velocity;
+      fadeVelocity = Math.abs(velocity / fadeToNextDistance);
+      lockExcessiveScroll(fadeIndex);
+    }
+    if (!pointerDown) {
+      if (!duration || noFadeIndex) return;
+      fadeVelocity += (fullOpacity - opacities[fadeIndex]) / duration;
+      fadeVelocity *= fadeFriction;
+    }
+    if (noFadeIndex) return;
+    setOpacities(fadeIndex, fadeVelocity);
+  }
+  function settled() {
+    const {
+      target,
+      location
+    } = emblaApi.internalEngine();
+    const diffToTarget = target.get() - location.get();
+    const notReachedTarget = Math.abs(diffToTarget) >= 1;
+    const fadeIndex = getFadeIndex();
+    const noFadeIndex = !isNumber(fadeIndex);
+    fade(emblaApi);
+    if (noFadeIndex || notReachedTarget) return false;
+    return opacities[fadeIndex] > 0.999;
+  }
+  function scrollProgress() {
+    return progress;
+  }
+  const self = {
+    name: 'fade',
+    options: userOptions,
+    init,
+    destroy
+  };
+  return self;
+}
+Fade.globalOptions = undefined;
+
+var LsgHeroController = /** @class */function () {
+  function LsgHeroController(viewport, elements, options) {
+    if (elements === void 0) {
+      elements = {};
+    }
+    if (options === void 0) {
+      options = {};
+    }
+    var _this = this;
+    var _a, _b, _c;
+    this.embla = null;
+    this.autoplayTimer = null;
+    this.contentObserver = null;
+    this.scrollPrev = function () {
+      var _a;
+      (_a = _this.embla) === null || _a === void 0 ? void 0 : _a.scrollPrev();
+      if (_this.opts.autoplay) _this.startAutoplay();
+    };
+    this.scrollNext = function () {
+      var _a;
+      (_a = _this.embla) === null || _a === void 0 ? void 0 : _a.scrollNext();
+      if (_this.opts.autoplay) _this.startAutoplay();
+    };
+    this.handleScrollDown = function () {
+      var _a;
+      (_a = _this.els.scrollDownTarget) === null || _a === void 0 ? void 0 : _a.scrollIntoView({
+        behavior: "smooth"
+      });
+    };
+    /** Start the autoplay interval (resets any existing timer). */
+    this.startAutoplay = function () {
+      _this.stopAutoplay();
+      _this.autoplayTimer = setInterval(_this.scrollNext, _this.opts.autoplayInterval);
+    };
+    /** Clear the autoplay interval. */
+    this.stopAutoplay = function () {
+      if (_this.autoplayTimer !== null) {
+        clearInterval(_this.autoplayTimer);
+        _this.autoplayTimer = null;
+      }
+    };
+    this.opts = {
+      transition: (_a = options.transition) !== null && _a !== void 0 ? _a : "slide",
+      autoplay: (_b = options.autoplay) !== null && _b !== void 0 ? _b : true,
+      autoplayInterval: (_c = options.autoplayInterval) !== null && _c !== void 0 ? _c : 5000
+    };
+    this.els = elements;
+    this.mount(viewport);
+  }
+  LsgHeroController.prototype.mount = function (viewport) {
+    var _a, _b, _c;
+    var plugins = this.opts.transition === "fade" ? [Fade()] : [];
+    this.embla = EmblaCarousel(viewport, {
+      loop: true
+    }, plugins);
+    if (this.opts.autoplay) {
+      this.startAutoplay();
+      this.embla.on("pointerDown", this.stopAutoplay);
+      this.embla.on("pointerUp", this.startAutoplay);
+    }
+    (_a = this.els.prevBtn) === null || _a === void 0 ? void 0 : _a.addEventListener("click", this.scrollPrev);
+    (_b = this.els.nextBtn) === null || _b === void 0 ? void 0 : _b.addEventListener("click", this.scrollNext);
+    (_c = this.els.scrollDownBtn) === null || _c === void 0 ? void 0 : _c.addEventListener("click", this.handleScrollDown);
+    // Sync the first slide's content-wrapper height to a CSS custom property
+    // on the section root so the controls column can match it dynamically.
+    var section = viewport.closest("[data-lsg-is='hero']");
+    var contentWrapper = section === null || section === void 0 ? void 0 : section.querySelector(".lsg-hero-card__content-wrapper");
+    if (section && contentWrapper && typeof ResizeObserver !== "undefined") {
+      var setHeight_1 = function (el) {
+        section.style.setProperty("--lsg-hero-content-height", "".concat(el.offsetHeight, "px"));
+      };
+      setHeight_1(contentWrapper);
+      this.contentObserver = new ResizeObserver(function (entries) {
+        setHeight_1(entries[0].target);
+      });
+      this.contentObserver.observe(contentWrapper);
+    }
+  };
+  Object.defineProperty(LsgHeroController.prototype, "emblaApi", {
+    /** Direct access to the underlying Embla instance for advanced usage. */
+    get: function () {
+      return this.embla;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  /** Tear down event listeners, autoplay, and the Embla instance. */
+  LsgHeroController.prototype.destroy = function () {
+    var _a, _b, _c, _d;
+    this.stopAutoplay();
+    (_a = this.contentObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+    this.contentObserver = null;
+    if (this.embla) {
+      this.embla.off("pointerDown", this.stopAutoplay);
+      this.embla.off("pointerUp", this.startAutoplay);
+      this.embla.destroy();
+      this.embla = null;
+    }
+    (_b = this.els.prevBtn) === null || _b === void 0 ? void 0 : _b.removeEventListener("click", this.scrollPrev);
+    (_c = this.els.nextBtn) === null || _c === void 0 ? void 0 : _c.removeEventListener("click", this.scrollNext);
+    (_d = this.els.scrollDownBtn) === null || _d === void 0 ? void 0 : _d.removeEventListener("click", this.handleScrollDown);
+  };
+  return LsgHeroController;
+}();
+
+// ─────────────────────────────────────────────────────────────────────────────
+// LsgHeroCard
+// ─────────────────────────────────────────────────────────────────────────────
+var LsgHeroCard = function (_a) {
+  var imageSrc = _a.imageSrc,
+    _b = _a.imageAlt,
+    imageAlt = _b === void 0 ? "" : _b,
+    videoSrc = _a.videoSrc,
+    youtubeId = _a.youtubeId,
+    vimeoId = _a.vimeoId,
+    cardBackground = _a.cardBackground,
+    cardColor = _a.cardColor,
+    children = _a.children,
+    index = _a.index,
+    total = _a.total,
+    _c = _a.className,
+    className = _c === void 0 ? "" : _c;
+  var _d = useState(false),
+    videoReady = _d[0],
+    setVideoReady = _d[1];
+  // Video source priority: YouTube > Vimeo > DAM
+  var hasYoutube = Boolean(youtubeId);
+  var hasVimeo = !hasYoutube && Boolean(vimeoId);
+  var hasDam = !hasYoutube && !hasVimeo && Boolean(videoSrc);
+  // No image/video → the card renders as a solid colour (fill) instead of a
+  // media backdrop; with media, cardBackground tints the content text-box.
+  var hasMedia = Boolean(imageSrc || videoSrc || youtubeId || vimeoId);
+  var youtubeEmbedSrc = youtubeId ? "https://www.youtube.com/embed/".concat(youtubeId, "?autoplay=1&mute=1&loop=1&controls=0&disablekb=1&fs=0&iv_load_policy=3&modestbranding=1&playlist=").concat(youtubeId, "&rel=0") : undefined;
+  var vimeoEmbedSrc = vimeoId ? "https://player.vimeo.com/video/".concat(vimeoId, "?autoplay=1&loop=1&background=1&muted=1") : undefined;
+  var ariaLabel = index !== undefined && total !== undefined ? "Slide ".concat(index + 1, " of ").concat(total) : undefined;
+  var articleClasses = ["lsg-hero-card",
+  // Background: tint the content box when there's media; fill the whole card when there isn't.
+  cardBackground && (hasMedia ? "lsg-hero-card--bg-".concat(cardBackground) : "lsg-hero-card--fill-".concat(cardBackground)), cardColor && "lsg-hero-card--color-".concat(cardColor), className].filter(Boolean).join(" ");
+  return /*#__PURE__*/React.createElement("article", {
+    className: articleClasses,
+    role: "listitem",
+    "aria-label": ariaLabel
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "lsg-hero-card__media",
+    "aria-hidden": "true"
+  }, imageSrc &&
+  /*#__PURE__*/
+  // eslint-disable-next-line @next/next/no-img-element
+  React.createElement("img", {
+    className: "lsg-hero-card__image",
+    src: imageSrc,
+    alt: imageAlt,
+    loading: "eager"
+  }), hasDam && /*#__PURE__*/React.createElement("video", {
+    className: "lsg-hero-card__video".concat(videoReady ? " lsg-hero-card__video--ready" : ""),
+    autoPlay: true,
+    muted: true,
+    loop: true,
+    playsInline: true,
+    onCanPlay: function () {
+      return setVideoReady(true);
+    }
+  }, /*#__PURE__*/React.createElement("source", {
+    src: videoSrc
+  })), hasYoutube && /*#__PURE__*/React.createElement("div", {
+    className: "lsg-hero-card__video-embed lsg-hero-card__video-embed--youtube"
+  }, /*#__PURE__*/React.createElement("iframe", {
+    src: youtubeEmbedSrc,
+    title: "Hero background video",
+    allow: "autoplay",
+    "aria-hidden": "true",
+    tabIndex: -1
+  })), hasVimeo && /*#__PURE__*/React.createElement("div", {
+    className: "lsg-hero-card__video-embed lsg-hero-card__video-embed--vimeo"
+  }, /*#__PURE__*/React.createElement("iframe", {
+    src: vimeoEmbedSrc,
+    title: "Hero background video",
+    allow: "autoplay",
+    "aria-hidden": "true",
+    tabIndex: -1
+  }))), /*#__PURE__*/React.createElement("div", {
+    className: "lsg-hero-card__content layout-container--medium"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "lsg-hero-card__content-wrapper"
+  }, children)));
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// LsgHero
+// ─────────────────────────────────────────────────────────────────────────────
+var LsgHero = function (_a) {
+  var _b = _a.slides,
+    slides = _b === void 0 ? [] : _b,
+    _c = _a.height,
+    height = _c === void 0 ? "full" : _c,
+    _d = _a.showArrows,
+    showArrows = _d === void 0 ? true : _d,
+    _e = _a.transition,
+    transition = _e === void 0 ? "slide" : _e,
+    _f = _a.enableScrollDown,
+    enableScrollDown = _f === void 0 ? false : _f,
+    scrollDownText = _a.scrollDownText,
+    _g = _a.autoplay,
+    autoplay = _g === void 0 ? true : _g,
+    _h = _a.autoplayInterval,
+    autoplayInterval = _h === void 0 ? 5000 : _h,
+    _j = _a.className,
+    className = _j === void 0 ? "" : _j;
+  var isCarousel = slides.length > 1;
+  // ── Refs ──────────────────────────────────────────────────────────────────
+  var sectionRef = useRef(null);
+  var viewportRef = useRef(null);
+  var prevBtnRef = useRef(null);
+  var nextBtnRef = useRef(null);
+  var controllerRef = useRef(null);
+  // ── Controller init (vanilla JS — same logic as AEM clientlib) ────────────
+  useEffect(function () {
+    if (!viewportRef.current || !isCarousel) return;
+    controllerRef.current = new LsgHeroController(viewportRef.current, {
+      prevBtn: showArrows ? prevBtnRef.current : undefined,
+      nextBtn: showArrows ? nextBtnRef.current : undefined
+    }, {
+      transition: transition,
+      autoplay: autoplay,
+      autoplayInterval: autoplayInterval
+    });
+    return function () {
+      var _a;
+      (_a = controllerRef.current) === null || _a === void 0 ? void 0 : _a.destroy();
+      controllerRef.current = null;
+    };
+  }, [isCarousel, showArrows, transition, autoplay, autoplayInterval]);
+  // ── Scroll-down ───────────────────────────────────────────────────────────
+  var handleScrollDown = useCallback(function () {
+    var _a;
+    var next = (_a = sectionRef.current) === null || _a === void 0 ? void 0 : _a.nextElementSibling;
+    next === null || next === void 0 ? void 0 : next.scrollIntoView({
+      behavior: "smooth"
+    });
+  }, []);
+  // ── Class names ───────────────────────────────────────────────────────────
+  var sectionClasses = ["lsg-hero", "lsg-hero--".concat(height), "lsg-hero--".concat(transition), className].filter(Boolean).join(" ");
+  // ── Render ────────────────────────────────────────────────────────────────
+  return /*#__PURE__*/React.createElement("section", {
+    ref: sectionRef,
+    className: sectionClasses,
+    "data-lsg-is": "hero",
+    "data-lsg-carousel": String(isCarousel),
+    "data-lsg-transition": transition,
+    "data-lsg-arrows": String(showArrows)
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "lsg-hero__viewport",
+    ref: viewportRef
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "lsg-hero__slides",
+    role: "list"
+  }, slides.map(function (slide, index) {
+    return /*#__PURE__*/React.createElement(LsgHeroCard, _extends({
+      key: index
+    }, slide, {
+      index: index,
+      total: slides.length
+    }));
+  }))), isCarousel && showArrows && /*#__PURE__*/React.createElement("div", {
+    className: "lsg-hero__controls-wrap"
+  }, /*#__PURE__*/React.createElement("nav", {
+    className: "lsg-hero__controls",
+    "aria-label": "Hero navigation"
+  }, /*#__PURE__*/React.createElement("button", {
+    ref: prevBtnRef,
+    className: "lsg-hero__prev",
+    type: "button",
+    "aria-label": "Previous slide"
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "lsg-hero__arrow-icon",
+    "aria-hidden": "true"
+  })), /*#__PURE__*/React.createElement("button", {
+    ref: nextBtnRef,
+    className: "lsg-hero__next",
+    type: "button",
+    "aria-label": "Next slide"
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "lsg-hero__arrow-icon",
+    "aria-hidden": "true"
+  })))), enableScrollDown && /*#__PURE__*/React.createElement("div", {
+    className: "lsg-hero__scroll-down"
+  }, /*#__PURE__*/React.createElement("button", {
+    className: "lsg-hero__scroll-down-btn",
+    type: "button",
+    "aria-label": scrollDownText !== null && scrollDownText !== void 0 ? scrollDownText : "Scroll down",
+    onClick: handleScrollDown
+  }, scrollDownText && /*#__PURE__*/React.createElement("span", {
+    className: "lsg-hero__scroll-down-text"
+  }, scrollDownText), /*#__PURE__*/React.createElement("span", {
+    className: "lsg-hero__scroll-down-icon",
+    "aria-hidden": "true"
+  }))));
+};
+
 var LsgFormFieldText = function (_a) {
   var _b = _a.id,
     id = _b === void 0 ? "field-text" : _b,
@@ -1438,6 +3591,238 @@ var LsgFormFieldEmail = function (_a) {
   }, error));
 };
 
+var M=[["Afghanistan","af","93"],["Albania","al","355"],["Algeria","dz","213"],["Andorra","ad","376"],["Angola","ao","244"],["Antigua and Barbuda","ag","1268"],["Argentina","ar","54",{default:"(..) .... ....","/^11/":"(..) .... ....","/^15/":"(..) ... ....","/^(2|3|4|5)/":"(.) .... ....","/^9/":"(.) .... ....."},0],["Armenia","am","374",".. ......"],["Aruba","aw","297"],["Australia","au","61",{default:". .... ....","/^4/":"... ... ...","/^5(?!50)/":"... ... ...","/^1(3|8)00/":".... ... ...","/^13/":".. .. ..","/^180/":"... ...."},0,[]],["Austria","at","43"],["Azerbaijan","az","994","(..) ... .. .."],["Bahamas","bs","1242"],["Bahrain","bh","973",".... ...."],["Bangladesh","bd","880"],["Barbados","bb","1246"],["Belarus","by","375","(..) ... .. .."],["Belgium","be","32","... .. .. .."],["Belize","bz","501"],["Benin","bj","229"],["Bhutan","bt","975"],["Bolivia","bo","591"],["Bosnia and Herzegovina","ba","387"],["Botswana","bw","267"],["Brazil","br","55","(..) .....-...."],["British Indian Ocean Territory","io","246"],["Brunei","bn","673"],["Bulgaria","bg","359"],["Burkina Faso","bf","226"],["Burundi","bi","257"],["Cambodia","kh","855"],["Cameroon","cm","237"],["Canada","ca","1","(...) ...-....",1,["204","226","236","249","250","289","306","343","365","387","403","416","418","431","437","438","450","506","514","519","548","579","581","587","604","613","639","647","672","705","709","742","778","780","782","807","819","825","867","873","902","905"]],["Cape Verde","cv","238"],["Caribbean Netherlands","bq","599","",1],["Cayman Islands","ky","1","... ... ....",4,["345"]],["Central African Republic","cf","236"],["Chad","td","235"],["Chile","cl","56"],["China","cn","86","... .... ...."],["Colombia","co","57","... ... ...."],["Comoros","km","269"],["Congo","cd","243"],["Congo","cg","242"],["Costa Rica","cr","506","....-...."],["C\xF4te d'Ivoire","ci","225",".. .. .. .. .."],["Croatia","hr","385"],["Cuba","cu","53"],["Cura\xE7ao","cw","599","",0],["Cyprus","cy","357",".. ......"],["Czech Republic","cz","420","... ... ..."],["Denmark","dk","45",".. .. .. .."],["Djibouti","dj","253",".. .. ...."],["Dominica","dm","1767"],["Dominican Republic","do","1","(...) ...-....",2,["809","829","849"]],["Ecuador","ec","593"],["Egypt","eg","20"],["El Salvador","sv","503","....-...."],["Equatorial Guinea","gq","240"],["Eritrea","er","291"],["Estonia","ee","372",".... ......"],["Ethiopia","et","251",".. ... ...."],["Faroe Islands","fo","298",".. .. .."],["Fiji","fj","679"],["Finland","fi","358",".. ... .. .."],["France","fr","33",". .. .. .. .."],["French Guiana","gf","594","... .. .. .."],["French Polynesia","pf","689",{"/^44/":".. .. ..","/^80[0-5]/":"... .. .. ..",default:".. .. .. .."}],["Gabon","ga","241"],["Gambia","gm","220"],["Georgia","ge","995"],["Germany","de","49","... ........."],["Ghana","gh","233"],["Gibraltar","gi","350"],["Greece","gr","30"],["Greenland","gl","299",".. .. .."],["Grenada","gd","1473"],["Guadeloupe","gp","590","... .. .. ..",0],["Guam","gu","1671"],["Guatemala","gt","502","....-...."],["Guinea","gn","224"],["Guinea-Bissau","gw","245"],["Guyana","gy","592"],["Haiti","ht","509","....-...."],["Honduras","hn","504"],["Hong Kong","hk","852",".... ...."],["Hungary","hu","36"],["Iceland","is","354","... ...."],["India","in","91",".....-....."],["Indonesia","id","62"],["Iran","ir","98","... ... ...."],["Iraq","iq","964"],["Ireland","ie","353",".. ......."],["Israel","il","972","... ... ...."],["Italy","it","39","... .......",0],["Jamaica","jm","1876"],["Japan","jp","81",".. .... ...."],["Jordan","jo","962"],["Kazakhstan","kz","7","... ...-..-..",0],["Kenya","ke","254"],["Kiribati","ki","686"],["Kosovo","xk","383"],["Kuwait","kw","965",".... ...."],["Kyrgyzstan","kg","996","... ... ..."],["Laos","la","856"],["Latvia","lv","371",".. ... ..."],["Lebanon","lb","961"],["Lesotho","ls","266"],["Liberia","lr","231"],["Libya","ly","218"],["Liechtenstein","li","423"],["Lithuania","lt","370"],["Luxembourg","lu","352"],["Macau","mo","853"],["Macedonia","mk","389"],["Madagascar","mg","261"],["Malawi","mw","265"],["Malaysia","my","60","..-....-...."],["Maldives","mv","960"],["Mali","ml","223"],["Malta","mt","356"],["Marshall Islands","mh","692"],["Martinique","mq","596","... .. .. .."],["Mauritania","mr","222"],["Mauritius","mu","230"],["Mayotte","yt","262","... .. .. ..",1,["269","639"]],["Mexico","mx","52","... ... ....",0],["Micronesia","fm","691"],["Moldova","md","373","(..) ..-..-.."],["Monaco","mc","377"],["Mongolia","mn","976"],["Montenegro","me","382"],["Morocco","ma","212"],["Mozambique","mz","258"],["Myanmar","mm","95"],["Namibia","na","264"],["Nauru","nr","674"],["Nepal","np","977"],["Netherlands","nl","31",{"/^06/":"(.). .........","/^6/":". .........","/^0(10|13|14|15|20|23|24|26|30|33|35|36|38|40|43|44|45|46|50|53|55|58|70|71|72|73|74|75|76|77|78|79|82|84|85|87|88|91)/":"(.).. ........","/^(10|13|14|15|20|23|24|26|30|33|35|36|38|40|43|44|45|46|50|53|55|58|70|71|72|73|74|75|76|77|78|79|82|84|85|87|88|91)/":".. ........","/^0/":"(.)... .......",default:"... ......."}],["New Caledonia","nc","687"],["New Zealand","nz","64","...-...-...."],["Nicaragua","ni","505"],["Niger","ne","227"],["Nigeria","ng","234"],["North Korea","kp","850"],["Norway","no","47","... .. ..."],["Oman","om","968",".... ...."],["Pakistan","pk","92","...-......."],["Palau","pw","680"],["Palestine","ps","970"],["Panama","pa","507"],["Papua New Guinea","pg","675"],["Paraguay","py","595"],["Peru","pe","51"],["Philippines","ph","63","... ... ...."],["Poland","pl","48","...-...-..."],["Portugal","pt","351"],["Puerto Rico","pr","1","(...) ...-....",3,["787","939"]],["Qatar","qa","974",".... ...."],["R\xE9union","re","262","... .. .. ..",0],["Romania","ro","40"],["Russia","ru","7","(...) ...-..-..",1],["Rwanda","rw","250"],["Saint Kitts and Nevis","kn","1869"],["Saint Lucia","lc","1758"],["Saint Pierre & Miquelon","pm","508",{"/^708/":"... ... ...","/^8/":"... .. .. ..",default:".. .. .."}],["Saint Vincent and the Grenadines","vc","1784"],["Samoa","ws","685"],["San Marino","sm","378"],["S\xE3o Tom\xE9 and Pr\xEDncipe","st","239"],["Saudi Arabia","sa","966",".. ... ...."],["Senegal","sn","221"],["Serbia","rs","381"],["Seychelles","sc","248"],["Sierra Leone","sl","232"],["Singapore","sg","65","....-...."],["Slovakia","sk","421"],["Slovenia","si","386"],["Solomon Islands","sb","677"],["Somalia","so","252"],["South Africa","za","27"],["South Korea","kr","82","... .... ...."],["South Sudan","ss","211"],["Spain","es","34","... ... ..."],["Sri Lanka","lk","94"],["Sudan","sd","249"],["Suriname","sr","597"],["Swaziland","sz","268"],["Sweden","se","46","... ... ..."],["Switzerland","ch","41",".. ... .. .."],["Syria","sy","963"],["Taiwan","tw","886"],["Tajikistan","tj","992"],["Tanzania","tz","255"],["Thailand","th","66"],["Timor-Leste","tl","670"],["Togo","tg","228"],["Tonga","to","676"],["Trinidad and Tobago","tt","1868"],["Tunisia","tn","216"],["Turkey","tr","90","... ... .. .."],["Turkmenistan","tm","993"],["Tuvalu","tv","688"],["Uganda","ug","256"],["Ukraine","ua","380","(..) ... .. .."],["United Arab Emirates","ae","971",{default:".. ... ....","/^5[024568]/":".. ... ....","/^[234679]/":". ... ...."}],["United Kingdom","gb","44",".... ......"],["United States","us","1","(...) ...-....",0],["Uruguay","uy","598"],["Uzbekistan","uz","998",".. ... .. .."],["Vanuatu","vu","678"],["Vatican City","va","39",".. .... ....",1],["Venezuela","ve","58"],["Vietnam","vn","84"],["Wallis & Futuna","wf","681",".. .. .."],["Yemen","ye","967"],["Zambia","zm","260"],["Zimbabwe","zw","263"]];var Ne="react-international-phone-",de=(...t)=>t.filter(e=>!!e).join(" ").trim(),Me=(...t)=>de(...t).split(" ").map(e=>`${Ne}${e}`).join(" "),S=({addPrefix:t,rawClassNames:e})=>de(Me(...t),...e);var ce=({value:t,mask:e,maskSymbol:n,offset:s=0,trimNonMaskCharsLeftover:r=false,allowMaskOverflow:a=false})=>{if(t.length<s)return t;let p=t.slice(0,s),i=t.slice(s),o=e.split("").filter(d=>d===n).length,u=i.slice(0,o),l=a?i.slice(o):"",m=p,y=0;for(let d of e.split("")){if(y>=u.length){if(!r&&d!==n){m+=d;continue}break}d===n?(m+=u[y],y+=1):m+=d;}return m+l};var O=t=>t?/^\d+$/.test(t):false;var V=t=>t.replace(/\D/g,"");var pe=(t,e)=>{let n=t.style.display;n!=="block"&&(t.style.display="block");let s=t.getBoundingClientRect(),r=e.getBoundingClientRect(),a=r.top-s.top,p=s.bottom-r.bottom;a>=0&&p>=0||(Math.abs(a)<Math.abs(p)?t.scrollTop+=a:t.scrollTop-=p),t.style.display=n;};var me=()=>typeof window>"u"?false:window.navigator.userAgent.toLowerCase().includes("macintosh");var Ce=(t,e)=>{let n=e.disableDialCodeAndPrefix?false:e.forceDialCode,s=e.disableDialCodeAndPrefix?false:e.insertDialCodeOnEmpty,r=t,a=u=>e.trimNonDigitsEnd?u.trim():u;if(!r)return s&&!r.length||n?a(`${e.prefix}${e.dialCode}${e.charAfterDialCode}`):a(r);if(r=V(r),r===e.dialCode&&!e.disableDialCodeAndPrefix)return a(`${e.prefix}${e.dialCode}${e.charAfterDialCode}`);if(e.dialCode.startsWith(r)&&!e.disableDialCodeAndPrefix)return a(n?`${e.prefix}${e.dialCode}${e.charAfterDialCode}`:`${e.prefix}${r}`);if(!r.startsWith(e.dialCode)&&!e.disableDialCodeAndPrefix){if(n)return a(`${e.prefix}${e.dialCode}${e.charAfterDialCode}`);if(r.length<e.dialCode.length)return a(`${e.prefix}${r}`)}let p=()=>{let u=e.dialCode.length,l=r.slice(0,u),m=r.slice(u);return {phoneLeftSide:l,phoneRightSide:m}},{phoneLeftSide:i,phoneRightSide:o}=p();return i=`${e.prefix}${i}${e.charAfterDialCode}`,o=ce({value:o,mask:e.mask,maskSymbol:e.maskChar,trimNonMaskCharsLeftover:e.trimNonDigitsEnd||e.disableDialCodeAndPrefix&&o.length===0,allowMaskOverflow:e.allowMaskOverflow}),e.disableDialCodeAndPrefix&&(i=""),a(`${i}${o}`)};var he=({phoneBeforeInput:t,phoneAfterInput:e,phoneAfterFormatted:n,cursorPositionAfterInput:s,leftOffset:r=0,deletion:a})=>{if(s<r)return r;if(!t)return n.length;let p=null;for(let l=s-1;l>=0;l-=1)if(O(e[l])){p=l;break}if(p===null){for(let l=0;l<e.length;l+=1)if(O(n[l]))return l;return e.length}let i=0;for(let l=0;l<p;l+=1)O(e[l])&&(i+=1);let o=0,u=0;for(let l=0;l<n.length&&(o+=1,O(n[l])&&(u+=1),!(u>=i+1));l+=1);if(a!=="backward")for(;!O(n[o])&&o<n.length;)o+=1;return o};var G=({phone:t,prefix:e})=>t?`${e}${V(t)}`:"";function W({value:t,country:e,insertDialCodeOnEmpty:n,trimNonDigitsEnd:s,countries:r,prefix:a,charAfterDialCode:p,forceDialCode:i,disableDialCodeAndPrefix:o,defaultMask:u,countryGuessingEnabled:l,disableFormatting:m,allowMaskOverflow:y}){let d=t;o&&(d=d.startsWith(`${a}`)?d:`${a}${e.dialCode}${d}`);let w=l?ee({phone:d,countries:r,currentCountryIso2:e?.iso2}):void 0,f=w?.country??e,v=Ce(d,{prefix:a,mask:Y({phone:d,country:f,defaultMask:u,disableFormatting:m}),maskChar:J,dialCode:f.dialCode,trimNonDigitsEnd:s,charAfterDialCode:p,forceDialCode:i,insertDialCodeOnEmpty:n,disableDialCodeAndPrefix:o,allowMaskOverflow:y}),g=l&&!w?.fullDialCodeMatch?e:f;return {phone:G({phone:o?`${g.dialCode}${v}`:v,prefix:a}),inputValue:v,country:g}}var _e=t=>{if(t?.toLocaleLowerCase().includes("delete")??false)return t?.toLocaleLowerCase().includes("forward")?"forward":"backward"},ye=(t,{country:e,insertDialCodeOnEmpty:n,phoneBeforeInput:s,prefix:r,charAfterDialCode:a,forceDialCode:p,disableDialCodeAndPrefix:i,countryGuessingEnabled:o,defaultMask:u,disableFormatting:l,countries:m,allowMaskOverflow:y})=>{let d=t.nativeEvent,w=d.inputType,f=_e(w),v=!!w?.startsWith("insertFrom"),g=w==="insertText",D=d?.data||void 0,I=t.target.value,_=t.target.selectionStart??0;if(w?.includes("history"))return {inputValue:s,phone:G({phone:s,prefix:r}),cursorPosition:s.length,country:e};if(g&&!O(D)&&I!==r)return {inputValue:s,phone:G({phone:i?`${e.dialCode}${s}`:s,prefix:r}),cursorPosition:_-(D?.length??0),country:e};if(p&&!I.startsWith(`${r}${e.dialCode}`)&&!v){let b=I?s:`${r}${e.dialCode}${a}`;return {inputValue:b,phone:G({phone:b,prefix:r}),cursorPosition:r.length+e.dialCode.length+a.length,country:e}}let{phone:c,inputValue:C,country:h}=W({value:I,country:e,trimNonDigitsEnd:f==="backward",insertDialCodeOnEmpty:n,countryGuessingEnabled:o,countries:m,prefix:r,charAfterDialCode:a,forceDialCode:p,disableDialCodeAndPrefix:i,disableFormatting:l,defaultMask:u,allowMaskOverflow:y}),P=he({cursorPositionAfterInput:_,phoneBeforeInput:s,phoneAfterInput:I,phoneAfterFormatted:C,leftOffset:p?r.length+e.dialCode.length+a.length:0,deletion:f});return {phone:c,inputValue:C,cursorPosition:P,country:h}};var ge=(t,e)=>{let n=Object.keys(t),s=Object.keys(e);if(n.length!==s.length)return  false;for(let r of n)if(t[r]!==e[r])return  false;return  true};var we=()=>{let t=useRef(),e=useRef(Date.now()),n=useCallback(()=>{let s=Date.now(),r=t.current?s-e.current:void 0;return t.current=e.current,e.current=s,r},[]);return useMemo(()=>({check:n}),[n])};var Le={size:20,overrideLastItemDebounceMS:-1};function Pe(t,e){let{size:n,overrideLastItemDebounceMS:s,onChange:r}={...Le,...e},[a,p]=useState(t),i=useRef([a]),o=useRef(0),u=we(),l=useCallback((d,w)=>{let f=i.current[o.current];if(d===f||typeof d=="object"&&typeof f=="object"&&ge(d,f))return;let v=s>0,g=u.check(),E=v&&g!==void 0?g>s:true;if(w?.overrideLastItem!==void 0?w.overrideLastItem:!E)i.current=[...i.current.slice(0,o.current),d];else {let I=i.current.length>=n;i.current=[...i.current.slice(I?1:0,o.current+1),d],I||(o.current+=1);}p(d),r?.(d);},[r,s,n,u]),m=useCallback(()=>{if(o.current<=0)return {success:false};let d=i.current[o.current-1];return p(d),o.current-=1,r?.(d),{success:true,value:d}},[r]),y=useCallback(()=>{if(o.current+1>=i.current.length)return {success:false};let d=i.current[o.current+1];return p(d),o.current+=1,r?.(d),{success:true,value:d}},[r]);return [a,l,m,y]}var J=".",R={defaultCountry:"us",value:"",prefix:"+",defaultMask:"............",charAfterDialCode:" ",historySaveDebounceMS:200,disableCountryGuess:false,disableDialCodePrefill:false,forceDialCode:false,disableDialCodeAndPrefix:false,disableFormatting:false,allowMaskOverflow:false,countries:M},oe=({defaultCountry:t=R.defaultCountry,value:e=R.value,countries:n=R.countries,prefix:s=R.prefix,defaultMask:r=R.defaultMask,charAfterDialCode:a=R.charAfterDialCode,historySaveDebounceMS:p=R.historySaveDebounceMS,disableCountryGuess:i=R.disableCountryGuess,disableDialCodePrefill:o=R.disableDialCodePrefill,forceDialCode:u=R.forceDialCode,disableDialCodeAndPrefix:l=R.disableDialCodeAndPrefix,disableFormatting:m=R.disableFormatting,allowMaskOverflow:y=R.allowMaskOverflow,onChange:d,inputRef:w})=>{let g={countries:n,prefix:s,charAfterDialCode:a,forceDialCode:l?false:u,disableDialCodeAndPrefix:l,defaultMask:r,countryGuessingEnabled:!i,disableFormatting:m,allowMaskOverflow:y},E=useRef(null),D=w||E,I=x=>{Promise.resolve().then(()=>{typeof window>"u"||D.current!==document?.activeElement||D.current?.setSelectionRange(x,x);});},_=useCallback(x=>z({value:x,field:"iso2",countries:n}),[n]),c=useCallback(({inputValue:x,phone:T,country:k})=>{if(!d)return;let F=_(k);d({phone:T,inputValue:x,country:F});},[_,d]),[{phone:C,inputValue:h,country:P},b,L,$]=Pe(()=>{let x=z({value:t,field:"iso2",countries:n});x||console.error(`[react-international-phone]: can not find a country with "${t}" iso2 code`);let T=x||z({value:"us",field:"iso2",countries:n}),{phone:k,inputValue:F,country:U}=W({value:e,country:T,insertDialCodeOnEmpty:!o,...g});return I(F.length),{phone:k,inputValue:F,country:U.iso2}},{overrideLastItemDebounceMS:p,onChange:c}),A=useMemo(()=>_(P),[P,_]);useEffect(()=>{let x=D.current;if(!x)return;let T=k=>{if(!k.key)return;let F=k.ctrlKey,U=k.metaKey,Ie=k.shiftKey;if(k.key.toLowerCase()==="z"){if(me()){if(!U)return}else if(!F)return;Ie?$():L();}};return x.addEventListener("keydown",T),()=>{x.removeEventListener("keydown",T);}},[D,L,$]);let K=x=>{x.preventDefault();let{phone:T,inputValue:k,country:F,cursorPosition:U}=ye(x,{country:A,phoneBeforeInput:h,insertDialCodeOnEmpty:false,...g});return b({inputValue:k,phone:T,country:F.iso2}),I(U),e},Q=useCallback((x,T={focusOnInput:false})=>{let k=z({value:x,field:"iso2",countries:n});if(!k){console.error(`[react-international-phone]: can not find a country with "${x}" iso2 code`);return}let F=l?"":`${s}${k.dialCode}${a}`;b({inputValue:F,phone:`${s}${k.dialCode}`,country:k.iso2}),T.focusOnInput&&Promise.resolve().then(()=>{D.current?.focus();});},[n,l,s,a,b,D]),[X,j]=useState(false);return useEffect(()=>{if(!X){j(true),e!==C&&d?.({inputValue:h,phone:C,country:A});return}if(e===C)return;let{phone:x,inputValue:T,country:k}=W({value:e,country:A,insertDialCodeOnEmpty:!o,...g});b({phone:x,inputValue:T,country:k.iso2});},[e]),{phone:C,inputValue:h,country:A,setCountry:Q,handlePhoneValueChange:K,inputRef:D}};var Y=({phone:t,country:e,defaultMask:n="............",disableFormatting:s=false})=>{let r=e.format,a=i=>s?i.replace(new RegExp(`[^${J}]`,"g"),""):i;if(!r)return a(n);if(typeof r=="string")return a(r);if(!r.default)return console.error(`[react-international-phone]: default mask for ${e.iso2} is not provided`),a(n);let p=Object.keys(r).find(i=>{if(i==="default")return  false;if(!(i.charAt(0)==="/"&&i.charAt(i.length-1)==="/"))return console.error(`[react-international-phone]: format regex "${i}" for ${e.iso2} is not valid`),false;let u=new RegExp(i.substring(1,i.length-1)),l=t.replace(e.dialCode,"");return u.test(V(l))});return a(p?r[p]:r.default)};var N=t=>{let[e,n,s,r,a,p]=t;return {name:e,iso2:n,dialCode:s,format:r,priority:a,areaCodes:p}};var Oe=t=>`Field "${t}" is not supported`,z=({field:t,value:e,countries:n=M})=>{if(["priority"].includes(t))throw new Error(Oe(t));let s=n.find(r=>{let a=N(r);return e===a[t]});if(s)return N(s)};var ee=({phone:t,countries:e=M,currentCountryIso2:n})=>{let s={country:void 0,fullDialCodeMatch:false};if(!t)return s;let r=V(t);if(!r)return s;let a=s,p=({country:i,fullDialCodeMatch:o})=>{let u=i.dialCode===a.country?.dialCode,l=(i.priority??0)<(a.country?.priority??0);(!u||l)&&(a={country:i,fullDialCodeMatch:o});};for(let i of e){let o=N(i),{dialCode:u,areaCodes:l}=o;if(r.startsWith(u)){let m=a.country?Number(u)>=Number(a.country.dialCode):true;if(l){let y=r.substring(u.length);for(let d of l)if(y.startsWith(d))return {country:o,fullDialCodeMatch:true}}(m||u===r||!a.fullDialCodeMatch)&&p({country:o,fullDialCodeMatch:true});}a.fullDialCodeMatch||r.length<u.length&&u.startsWith(r)&&(!a.country||Number(u)<=Number(a.country.dialCode))&&p({country:o,fullDialCodeMatch:false});}if(n){let i=z({value:n,field:"iso2",countries:e});if(!i)return a;let u=i?(m=>{if(!m?.areaCodes)return  false;let y=r.substring(m.dialCode.length);return m.areaCodes.some(d=>d.startsWith(y))})(i):false;!!a&&a.country?.dialCode===i.dialCode&&a.country!==i&&a.fullDialCodeMatch&&(!i.areaCodes||u)&&(a={country:i,fullDialCodeMatch:true});}return a};var Ve=(t,e)=>{let n=parseInt(t,16);return Number(n+e).toString(16)},He="abcdefghijklmnopqrstuvwxyz",je="1f1e6",De=He.split("").reduce((t,e,n)=>({...t,[e]:Ve(je,n)}),{}),Be=t=>[De[t[0]],De[t[1]]].join("-"),q=({iso2:t,size:e,src:n,protocol:s="https",disableLazyLoading:r,className:a,style:p,...i})=>{if(!t)return React.createElement("img",{className:S({addPrefix:["flag-emoji"],rawClassNames:[a]}),width:e,height:e,...i});let o=()=>{if(n)return n;let u=Be(t);return `${s}://cdnjs.cloudflare.com/ajax/libs/twemoji/14.0.2/svg/${u}.svg`};return React.createElement("img",{className:S({addPrefix:["flag-emoji"],rawClassNames:[a]}),src:o(),width:e,height:e,draggable:false,"data-country":t,loading:r?void 0:"lazy",style:{width:e,height:e,...p},alt:"",...i})};var Ue=1e3,se=({show:t,dialCodePrefix:e="+",selectedCountry:n,countries:s=M,preferredCountries:r=[],flags:a,onSelect:p,onClose:i,...o})=>{let u=useRef(null),l=useRef(),m=useMemo(()=>{if(!r||!r.length)return s;let c=[],C=[...s];for(let h of r){let P=C.findIndex(b=>N(b).iso2===h);if(P!==-1){let b=C.splice(P,1)[0];c.push(b);}}return c.concat(C)},[s,r]),y=useRef({updatedAt:void 0,value:""}),d=c=>{let C=y.current.updatedAt&&new Date().getTime()-y.current.updatedAt.getTime()>Ue;y.current={value:C?c:`${y.current.value}${c}`,updatedAt:new Date};let h=m.findIndex(P=>N(P).name.toLowerCase().startsWith(y.current.value));h!==-1&&v(h);},w=useCallback(c=>m.findIndex(C=>N(C).iso2===c),[m]),[f,v]=useState(w(n)),g=()=>{l.current!==n&&v(w(n));},E=useCallback(c=>{v(w(c.iso2)),p?.(c);},[p,w]),D=c=>{let C=m.length-1,h=P=>c==="prev"?P-1:c==="next"?P+1:c==="last"?C:0;v(P=>{let b=h(P);return b<0?0:b>C?C:b});},I=c=>{if(c.stopPropagation(),c.key==="Enter"){c.preventDefault();let C=N(m[f]);E(C);return}if(c.key==="Escape"){i?.();return}if(c.key==="ArrowUp"){c.preventDefault(),D("prev");return}if(c.key==="ArrowDown"){c.preventDefault(),D("next");return}if(c.key==="PageUp"){c.preventDefault(),D("first");return}if(c.key==="PageDown"){c.preventDefault(),D("last");return}c.key===" "&&c.preventDefault(),c.key.length===1&&!c.altKey&&!c.ctrlKey&&!c.metaKey&&d(c.key.toLocaleLowerCase());},_=useCallback(()=>{if(!u.current||f===void 0)return;let c=N(m[f]).iso2;if(c===l.current)return;let C=u.current.querySelector(`[data-country="${c}"]`);C&&(pe(u.current,C),l.current=c);},[f,m]);return useEffect(()=>{_();},[f,_]),useEffect(()=>{u.current&&(t?u.current.focus():g());},[t]),useEffect(()=>{g();},[n]),React.createElement("ul",{ref:u,role:"listbox",className:S({addPrefix:["country-selector-dropdown"],rawClassNames:[o.className]}),style:{display:t?"block":"none",...o.style},onKeyDown:I,onBlur:i,tabIndex:-1,"aria-activedescendant":`react-international-phone__${N(m[f]).iso2}-option`},m.map((c,C)=>{let h=N(c),P=h.iso2===n,b=C===f,L=r.includes(h.iso2),$=C===r.length-1,A=a?.find(K=>K.iso2===h.iso2);return React.createElement(React.Fragment,{key:h.iso2},React.createElement("li",{"data-country":h.iso2,role:"option","aria-selected":P,"aria-label":`${h.name} ${e}${h.dialCode}`,id:`react-international-phone__${h.iso2}-option`,className:S({addPrefix:["country-selector-dropdown__list-item",L&&"country-selector-dropdown__list-item--preferred",P&&"country-selector-dropdown__list-item--selected",b&&"country-selector-dropdown__list-item--focused"],rawClassNames:[o.listItemClassName,L&&o.listItemPreferredClassName,P&&o.listItemSelectedClassName,b&&o.listItemFocusedClassName]}),onClick:()=>E(h),style:o.listItemStyle,title:h.name},React.createElement(q,{iso2:h.iso2,src:A?.src,className:S({addPrefix:["country-selector-dropdown__list-item-flag-emoji"],rawClassNames:[o.listItemFlagClassName]}),style:o.listItemFlagStyle}),React.createElement("span",{className:S({addPrefix:["country-selector-dropdown__list-item-country-name"],rawClassNames:[o.listItemCountryNameClassName]}),style:o.listItemCountryNameStyle},h.name),React.createElement("span",{className:S({addPrefix:["country-selector-dropdown__list-item-dial-code"],rawClassNames:[o.listItemDialCodeClassName]}),style:o.listItemDialCodeStyle},e,h.dialCode)),$?React.createElement("hr",{className:S({addPrefix:["country-selector-dropdown__preferred-list-divider"],rawClassNames:[o.preferredListDividerClassName]}),style:o.preferredListDividerStyle}):null)}))};var le=React.memo(({selectedCountry:t,onSelect:e,disabled:n,hideDropdown:s,countries:r=M,preferredCountries:a=[],flags:p,renderButtonWrapper:i,...o})=>{let[u,l]=useState(false),m=useMemo(()=>{if(t)return z({value:t,field:"iso2",countries:r})},[r,t]),y=useRef(null),d=f=>{f.key&&["ArrowUp","ArrowDown"].includes(f.key)&&(f.preventDefault(),l(true));},w=()=>{let f={title:m?.name,onClick:()=>l(g=>!g),onMouseDown:g=>g.preventDefault(),onKeyDown:d,disabled:s||n,role:"combobox","aria-label":"Country selector","aria-haspopup":"listbox","aria-expanded":u},v=React.createElement("div",{className:S({addPrefix:["country-selector-button__button-content"],rawClassNames:[o.buttonContentWrapperClassName]}),style:o.buttonContentWrapperStyle},React.createElement(q,{iso2:t,src:p?.find(g=>g.iso2===t)?.src,className:S({addPrefix:["country-selector-button__flag-emoji",n&&"country-selector-button__flag-emoji--disabled"],rawClassNames:[o.flagClassName]}),style:{visibility:t?"visible":"hidden",...o.flagStyle}}),!s&&React.createElement("div",{className:S({addPrefix:["country-selector-button__dropdown-arrow",n&&"country-selector-button__dropdown-arrow--disabled",u&&"country-selector-button__dropdown-arrow--active"],rawClassNames:[o.dropdownArrowClassName]}),style:o.dropdownArrowStyle}));return i?i({children:v,rootProps:f}):React.createElement("button",{...f,type:"button",className:S({addPrefix:["country-selector-button",u&&"country-selector-button--active",n&&"country-selector-button--disabled",s&&"country-selector-button--hide-dropdown"],rawClassNames:[o.buttonClassName]}),"data-country":t,style:o.buttonStyle},v)};return React.createElement("div",{className:S({addPrefix:["country-selector"],rawClassNames:[o.className]}),style:o.style,ref:y},w(),React.createElement(se,{show:u,countries:r,preferredCountries:a,flags:p,onSelect:f=>{l(false),e?.(f);},selectedCountry:t,onClose:()=>{l(false);},...o.dropdownStyleProps}))});var ue=({dialCode:t,prefix:e,disabled:n,style:s,className:r})=>React.createElement("div",{className:S({addPrefix:["dial-code-preview",n&&"dial-code-preview--disabled"],rawClassNames:[r]}),style:s},`${e}${t}`);forwardRef(({value:t,onChange:e,countries:n=M,preferredCountries:s,hideDropdown:r,showDisabledDialCodeAndPrefix:a,disableFocusAfterCountrySelect:p,flags:i,style:o,className:u,inputStyle:l,inputClassName:m,countrySelectorStyleProps:y,dialCodePreviewStyleProps:d,inputProps:w,placeholder:f,disabled:v,name:g,onFocus:E,onBlur:D,required:I,autoFocus:_,...c},C)=>{let h=useCallback(j=>{e?.(j.phone,{country:j.country,inputValue:j.inputValue});},[e]),{phone:P,inputValue:b,inputRef:L,country:$,setCountry:A,handlePhoneValueChange:K}=oe({value:t,countries:n,...c,onChange:h}),Q=c.disableDialCodeAndPrefix&&a&&$?.dialCode,X=useCallback(j=>{A(j.iso2,{focusOnInput:!p});},[A,p]);return useImperativeHandle(C,()=>L.current?Object.assign(L.current,{setCountry:A,state:{phone:P,inputValue:b,country:$}}):null,[L,A,P,b,$]),React.createElement("div",{ref:C,className:S({addPrefix:["input-container"],rawClassNames:[u]}),style:o},React.createElement(le,{onSelect:X,flags:i,selectedCountry:$?.iso2,countries:n,preferredCountries:s,disabled:v,hideDropdown:r,...y}),Q&&React.createElement(ue,{dialCode:$.dialCode,prefix:c.prefix??"+",disabled:v,...d}),React.createElement("input",{onChange:K,value:b,type:"tel",ref:L,className:S({addPrefix:["input",v&&"input--disabled"],rawClassNames:[m]}),placeholder:f,disabled:v,style:l,name:g,onFocus:E,onBlur:D,autoFocus:_,required:I,...w}))});
+
+/**
+ * Vanilla emoji-flag + dial-code picker for VTBA form tel fields.
+ *
+ * Framework-agnostic: this is the single source of truth for the phone flag
+ * picker. It is used two ways:
+ *   1. In AEM (server-rendered HTL) via the ac-react-app form runtime, which
+ *      calls {@link initTelPickers} on DOM-ready.
+ *   2. In Storybook via the React {@link ../LsgFormFieldTel} component, which
+ *      calls it from a `useEffect`.
+ *
+ * It enhances `.cmp-vtba-form__field--tel input[type="tel"]` with a country
+ * toggle (Unicode emoji flag + dial code) and a searchable dropdown. Emoji flags
+ * mean no image assets to ship. Country/dial-code data is reused from
+ * `react-international-phone` (data only — no React needed at runtime here).
+ *
+ * DOM strategy (so it is safe inside React too): if the input already sits in a
+ * `.cmp-vtba-tel` wrapper (React renders one), the picker only *appends* the
+ * toggle + dropdown and never moves the React-managed input. Otherwise (plain
+ * AEM markup) it creates the wrapper and moves the input in.
+ *
+ * On submit, the field value is the full international number
+ * (`+<dialCode><nationalDigits>`) via {@link getTelValue}.
+ */
+/** `defaultCountries` items are tuples `[name, iso2, dialCode, format?, ...]`. */
+var COUNTRIES = M.map(function (c) {
+  var t = c;
+  return {
+    name: t[0],
+    iso2: t[1],
+    dialCode: t[2]
+  };
+}).filter(function (c) {
+  return !!c.iso2 && !!c.dialCode;
+});
+var DEFAULT_ISO2 = "gb";
+/** Converts an ISO-2 country code to its Unicode regional-indicator flag emoji. */
+function flagEmoji(iso2) {
+  return iso2.toUpperCase().replace(/[A-Z]/g, function (ch) {
+    return String.fromCodePoint(0x1f1e6 + ch.charCodeAt(0) - 65);
+  });
+}
+function findCountry(iso2) {
+  var target = (iso2 || "").toLowerCase();
+  for (var i = 0; i < COUNTRIES.length; i++) {
+    if (COUNTRIES[i].iso2 === target) {
+      return COUNTRIES[i];
+    }
+  }
+  return undefined;
+}
+/**
+ * Enhances every tel field under {@code root} (or {@code root} itself when it is
+ * a tel field). Idempotent per input. Works whether {@code root} is the whole
+ * form (AEM) or a single field element (React component).
+ */
+function initTelPickers(root) {
+  if (!root) {
+    return;
+  }
+  var inputs = root.querySelectorAll("input[type='tel']");
+  for (var i = 0; i < inputs.length; i++) {
+    var input = inputs[i];
+    if (input.closest(".cmp-vtba-form__field--tel")) {
+      enhance(input);
+    }
+  }
+}
+/**
+ * Full international number for a picker-enhanced tel input:
+ * `+<dialCode><nationalDigits>`. Falls back to the raw value if not enhanced.
+ */
+function getTelValue(input) {
+  var dial = input.getAttribute("data-dial-code");
+  if (!dial) {
+    return input.value;
+  }
+  var national = (input.value || "").replace(/\D/g, "");
+  return national ? "+" + dial + national : "";
+}
+function enhance(input) {
+  if (input.getAttribute("data-tel-picker") === "true" || !input.parentElement) {
+    return;
+  }
+  input.setAttribute("data-tel-picker", "true");
+  var initialIso2 = (input.getAttribute("data-country") || DEFAULT_ISO2).toLowerCase();
+  var selected = findCountry(initialIso2) || findCountry(DEFAULT_ISO2) || COUNTRIES[0];
+  // Reuse a pre-rendered wrapper (React) — append-only, never move the input.
+  // Otherwise create the wrapper and move the input (plain vanilla markup).
+  var wrapper;
+  if (input.parentElement.classList.contains("cmp-vtba-tel")) {
+    wrapper = input.parentElement;
+  } else {
+    wrapper = document.createElement("div");
+    wrapper.className = "cmp-vtba-tel";
+    input.parentElement.insertBefore(wrapper, input);
+    wrapper.appendChild(input);
+  }
+  var toggle = document.createElement("button");
+  toggle.type = "button";
+  toggle.className = "cmp-vtba-tel__toggle";
+  toggle.setAttribute("aria-haspopup", "listbox");
+  toggle.setAttribute("aria-expanded", "false");
+  var dropdown = document.createElement("div");
+  dropdown.className = "cmp-vtba-tel__dropdown";
+  dropdown.hidden = true;
+  var search = document.createElement("input");
+  search.type = "text";
+  search.className = "cmp-vtba-tel__search";
+  search.placeholder = "Search";
+  search.setAttribute("aria-label", "Search countries");
+  var list = document.createElement("ul");
+  list.className = "cmp-vtba-tel__list";
+  list.setAttribute("role", "listbox");
+  dropdown.appendChild(search);
+  dropdown.appendChild(list);
+  // Toggle goes before the input; dropdown after — both inside the wrapper.
+  wrapper.insertBefore(toggle, input);
+  wrapper.appendChild(dropdown);
+  function applySelected(country) {
+    selected = country;
+    input.setAttribute("data-dial-code", country.dialCode);
+    input.setAttribute("data-iso2", country.iso2);
+    toggle.textContent = "";
+    var flag = document.createElement("span");
+    flag.className = "cmp-vtba-tel__flag";
+    flag.setAttribute("aria-hidden", "true");
+    flag.textContent = flagEmoji(country.iso2);
+    var code = document.createElement("span");
+    code.className = "cmp-vtba-tel__code";
+    code.textContent = "+" + country.dialCode;
+    toggle.appendChild(flag);
+    toggle.appendChild(code);
+    toggle.setAttribute("aria-label", "Country calling code: " + country.name + " +" + country.dialCode);
+  }
+  function renderList(filter) {
+    list.textContent = "";
+    var f = filter.trim().toLowerCase();
+    var digits = f.replace(/[^0-9]/g, "");
+    var _loop_1 = function (i) {
+      var c = COUNTRIES[i];
+      var match = !f || c.name.toLowerCase().indexOf(f) !== -1 || c.iso2 === f || !!digits && c.dialCode.indexOf(digits) === 0;
+      if (!match) {
+        return "continue";
+      }
+      var li = document.createElement("li");
+      li.className = "cmp-vtba-tel__option";
+      li.setAttribute("role", "option");
+      li.tabIndex = -1;
+      li.setAttribute("data-iso2", c.iso2);
+      li.setAttribute("aria-selected", c.iso2 === selected.iso2 ? "true" : "false");
+      li.textContent = flagEmoji(c.iso2) + "  " + c.name + "  +" + c.dialCode;
+      li.addEventListener("click", function () {
+        applySelected(c);
+        close();
+        input.focus();
+      });
+      list.appendChild(li);
+    };
+    for (var i = 0; i < COUNTRIES.length; i++) {
+      _loop_1(i);
+    }
+  }
+  function open() {
+    dropdown.hidden = false;
+    toggle.setAttribute("aria-expanded", "true");
+    search.value = "";
+    renderList("");
+    search.focus();
+  }
+  function close() {
+    dropdown.hidden = true;
+    toggle.setAttribute("aria-expanded", "false");
+  }
+  toggle.addEventListener("click", function () {
+    if (dropdown.hidden) {
+      open();
+    } else {
+      close();
+    }
+  });
+  search.addEventListener("input", function () {
+    return renderList(search.value);
+  });
+  search.addEventListener("keydown", function (e) {
+    if (e.key === "Escape") {
+      close();
+      toggle.focus();
+    } else if (e.key === "ArrowDown") {
+      e.preventDefault();
+      var first = list.querySelector(".cmp-vtba-tel__option");
+      if (first) {
+        first.focus();
+      }
+    }
+  });
+  list.addEventListener("keydown", function (e) {
+    var opts = Array.prototype.slice.call(list.querySelectorAll(".cmp-vtba-tel__option"));
+    var idx = opts.indexOf(document.activeElement);
+    if (e.key === "ArrowDown") {
+      e.preventDefault();
+      (opts[idx + 1] || opts[0]).focus();
+    } else if (e.key === "ArrowUp") {
+      e.preventDefault();
+      if (idx <= 0) {
+        search.focus();
+      } else {
+        opts[idx - 1].focus();
+      }
+    } else if (e.key === "Enter" || e.key === " ") {
+      e.preventDefault();
+      var iso2 = document.activeElement.getAttribute("data-iso2");
+      var c = iso2 ? findCountry(iso2) : undefined;
+      if (c) {
+        applySelected(c);
+        close();
+        input.focus();
+      }
+    } else if (e.key === "Escape") {
+      close();
+      toggle.focus();
+    }
+  });
+  document.addEventListener("click", function (e) {
+    if (!wrapper.contains(e.target)) {
+      close();
+    }
+  });
+  applySelected(selected);
+}
+
 var LsgFormFieldTel = function (_a) {
   var _b = _a.id,
     id = _b === void 0 ? "field-tel" : _b,
@@ -1454,19 +3839,30 @@ var LsgFormFieldTel = function (_a) {
     minLength = _a.minLength,
     maxLength = _a.maxLength,
     pattern = _a.pattern,
-    name = _a.name;
+    name = _a.name,
+    defaultCountry = _a.defaultCountry;
+  var fieldRef = useRef(null);
   var helpId = helpText ? "".concat(id, "-help") : undefined;
   var errorId = "".concat(id, "-error");
   var ariaDescribedBy = [helpId, error ? errorId : undefined].filter(Boolean).join(" ") || undefined;
+  // Enhance the tel input with the shared emoji-flag + dial-code picker.
+  // The input is pre-wrapped in `.cmp-vtba-tel`, so the picker appends its
+  // toggle/dropdown without moving the React-managed input.
+  useEffect(function () {
+    initTelPickers(fieldRef.current);
+  }, []);
   return /*#__PURE__*/React.createElement("div", {
-    className: "cmp-vtba-form__field cmp-vtba-form__field--tel"
+    className: "cmp-vtba-form__field cmp-vtba-form__field--tel",
+    ref: fieldRef
   }, /*#__PURE__*/React.createElement("label", {
     className: "cmp-vtba-form__label",
     htmlFor: id
   }, label, required && /*#__PURE__*/React.createElement("abbr", {
     className: "cmp-vtba-form__required",
     title: "required"
-  }, "*")), /*#__PURE__*/React.createElement("input", {
+  }, "*")), /*#__PURE__*/React.createElement("span", {
+    className: "cmp-vtba-tel"
+  }, /*#__PURE__*/React.createElement("input", {
     type: "tel",
     className: "cmp-vtba-form__input",
     id: id,
@@ -1477,11 +3873,12 @@ var LsgFormFieldTel = function (_a) {
     minLength: minLength,
     maxLength: maxLength,
     pattern: pattern,
+    "data-country": defaultCountry,
     "aria-describedby": ariaDescribedBy,
     "aria-invalid": error ? "true" : undefined,
     required: required,
     disabled: disabled
-  }), helpText && /*#__PURE__*/React.createElement("span", {
+  })), helpText && /*#__PURE__*/React.createElement("span", {
     className: "cmp-vtba-form__help",
     id: helpId
   }, helpText), /*#__PURE__*/React.createElement("span", {
@@ -1831,6 +4228,7 @@ var BASE_COMPONENTS = {
   LsgQuickLinks: LsgQuickLinks,
   LsgSocialMediaIcons: LsgSocialMediaIcons,
   LsgFooter: LsgFooter,
+  LsgHero: LsgHero,
   LsgFormContainer: LsgFormContainer,
   LsgFormFieldText: LsgFormFieldText,
   LsgFormFieldEmail: LsgFormFieldEmail,
@@ -1865,6 +4263,7 @@ function createThemeComponents(themeName) {
     LsgQuickLinks: createThemeComponent(themeName, "quick-links", BASE_COMPONENTS.LsgQuickLinks),
     LsgSocialMediaIcons: createThemeComponent(themeName, "social-media-icons", BASE_COMPONENTS.LsgSocialMediaIcons),
     LsgFooter: createThemeComponent(themeName, "footer", BASE_COMPONENTS.LsgFooter),
+    LsgHero: createThemeComponent(themeName, "hero", BASE_COMPONENTS.LsgHero),
     LsgFormContainer: createThemeComponent(themeName, "form-container", BASE_COMPONENTS.LsgFormContainer),
     LsgFormFieldText: createThemeComponent(themeName, "form-field-text", BASE_COMPONENTS.LsgFormFieldText),
     LsgFormFieldEmail: createThemeComponent(themeName, "form-field-email", BASE_COMPONENTS.LsgFormFieldEmail),
@@ -1890,7 +4289,8 @@ var Theme1LsgButton = theme1Components.LsgButton,
   Theme1LsgHeader = theme1Components.LsgHeader,
   Theme1LsgQuickLinks = theme1Components.LsgQuickLinks,
   Theme1LsgSocialMediaIcons = theme1Components.LsgSocialMediaIcons,
-  Theme1LsgFooter = theme1Components.LsgFooter;
+  Theme1LsgFooter = theme1Components.LsgFooter,
+  Theme1LsgHero = theme1Components.LsgHero;
   // Form components
   theme1Components.LsgFormContainer;
   theme1Components.LsgFormFieldText;
@@ -1915,7 +4315,8 @@ var Theme2LsgButton = theme2Components.LsgButton,
   Theme2LsgHeader = theme2Components.LsgHeader,
   Theme2LsgQuickLinks = theme2Components.LsgQuickLinks,
   Theme2LsgSocialMediaIcons = theme2Components.LsgSocialMediaIcons,
-  Theme2LsgFooter = theme2Components.LsgFooter;
+  Theme2LsgFooter = theme2Components.LsgFooter,
+  Theme2LsgHero = theme2Components.LsgHero;
   // Form components
   theme2Components.LsgFormContainer;
   theme2Components.LsgFormFieldText;
@@ -1940,7 +4341,8 @@ var Theme3LsgButton = theme3Components.LsgButton,
   Theme3LsgHeader = theme3Components.LsgHeader,
   Theme3LsgQuickLinks = theme3Components.LsgQuickLinks,
   Theme3LsgSocialMediaIcons = theme3Components.LsgSocialMediaIcons,
-  Theme3LsgFooter = theme3Components.LsgFooter;
+  Theme3LsgFooter = theme3Components.LsgFooter,
+  Theme3LsgHero = theme3Components.LsgHero;
   // Form components
   theme3Components.LsgFormContainer;
   theme3Components.LsgFormFieldText;
@@ -1952,5 +4354,5 @@ var Theme3LsgButton = theme3Components.LsgButton,
   theme3Components.LsgFormFieldConsent;
   theme3Components.LsgFormStep;
 
-export { LsgBanner, LsgButton, LsgCard, LsgCards, LsgFooter, LsgHeader, LsgLanguageSwitcher, LsgLogo, LsgNavigation, LsgQuickLinks, LsgSearchOverlay, LsgSearchTrigger, LsgSocialMediaIcons, Theme1LsgBanner, Theme1LsgButton, Theme1LsgCard, Theme1LsgCards, Theme1LsgFooter, Theme1LsgHeader, Theme1LsgLanguageSwitcher, Theme1LsgLogo, Theme1LsgNavigation, Theme1LsgQuickLinks, Theme1LsgSearchOverlay, Theme1LsgSearchTrigger, Theme1LsgSocialMediaIcons, Theme2LsgBanner, Theme2LsgButton, Theme2LsgCard, Theme2LsgCards, Theme2LsgFooter, Theme2LsgHeader, Theme2LsgLanguageSwitcher, Theme2LsgLogo, Theme2LsgNavigation, Theme2LsgQuickLinks, Theme2LsgSearchOverlay, Theme2LsgSearchTrigger, Theme2LsgSocialMediaIcons, Theme3LsgBanner, Theme3LsgButton, Theme3LsgCard, Theme3LsgCards, Theme3LsgFooter, Theme3LsgHeader, Theme3LsgLanguageSwitcher, Theme3LsgLogo, Theme3LsgNavigation, Theme3LsgQuickLinks, Theme3LsgSearchOverlay, Theme3LsgSearchTrigger, Theme3LsgSocialMediaIcons, theme1Components, theme2Components, theme3Components };
+export { LsgBanner, LsgButton, LsgCard, LsgCards, LsgFooter, LsgHeader, LsgHero, LsgHeroCard, LsgHeroController, LsgLanguageSwitcher, LsgLogo, LsgNavigation, LsgQuickLinks, LsgSearchOverlay, LsgSearchTrigger, LsgSocialMediaIcons, Theme1LsgBanner, Theme1LsgButton, Theme1LsgCard, Theme1LsgCards, Theme1LsgFooter, Theme1LsgHeader, Theme1LsgHero, Theme1LsgLanguageSwitcher, Theme1LsgLogo, Theme1LsgNavigation, Theme1LsgQuickLinks, Theme1LsgSearchOverlay, Theme1LsgSearchTrigger, Theme1LsgSocialMediaIcons, Theme2LsgBanner, Theme2LsgButton, Theme2LsgCard, Theme2LsgCards, Theme2LsgFooter, Theme2LsgHeader, Theme2LsgHero, Theme2LsgLanguageSwitcher, Theme2LsgLogo, Theme2LsgNavigation, Theme2LsgQuickLinks, Theme2LsgSearchOverlay, Theme2LsgSearchTrigger, Theme2LsgSocialMediaIcons, Theme3LsgBanner, Theme3LsgButton, Theme3LsgCard, Theme3LsgCards, Theme3LsgFooter, Theme3LsgHeader, Theme3LsgHero, Theme3LsgLanguageSwitcher, Theme3LsgLogo, Theme3LsgNavigation, Theme3LsgQuickLinks, Theme3LsgSearchOverlay, Theme3LsgSearchTrigger, Theme3LsgSocialMediaIcons, getTelValue, initTelPickers, theme1Components, theme2Components, theme3Components };
 //# sourceMappingURL=index.esm.js.map