@janga/norna 0.7.17 → 0.7.22

package/examples/feature-demos/media-and-surfaces/node_modules/.vite/deps/embla-carousel.js

@@ -1,1389 +0,0 @@
-//#region ../../../node_modules/embla-carousel/esm/embla-carousel.esm.js
-function isNumber(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;
-	return mathAbs(deltaAbs(mathAbs(valueB), mathAbs(valueA)) / 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];
-			mergedObjects[key] = isObject(valueA) && isObject(valueB) ? 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);
-	}
-	return { measure };
-}
-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 = 1e3 / 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;
-		}
-		render(accumulatedTime / fixedTimeStep);
-		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;
-	}
-	return {
-		init,
-		destroy,
-		start,
-		stop,
-		update,
-		render
-	};
-}
-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;
-	}
-	return {
-		scroll,
-		cross,
-		startEdge,
-		endEdge,
-		measureSize,
-		direction
-	};
-}
-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);
-	}
-	return {
-		length,
-		max,
-		min,
-		constrain,
-		reachedAny,
-		reachedMax,
-		reachedMin,
-		removeOffset
-	};
-}
-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", () => void 0, nonPassiveEvent).add(node, "touchend", () => void 0).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() {
-		return (dragFree ? freeForceBoost : snapForceBoost)[isMouse ? "mouse" : "touch"];
-	}
-	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 * .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) {
-		if (!isMouseEvent(evt, ownerWindow) && 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(.3).useDuration(.75);
-		animation.start();
-		target.add(direction(diff));
-		evt.preventDefault();
-	}
-	function up(evt) {
-		const targetChanged = scrollTarget.byDistance(0, false).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;
-	}
-	return {
-		init,
-		destroy,
-		pointerDown
-	};
-}
-function DragTracker(axis, ownerWindow) {
-	const logInterval = 170;
-	let startEvent;
-	let lastEvent;
-	function readTime(evt) {
-		return evt.timeStamp;
-	}
-	function readPoint(evt, evtAxis) {
-		const coord = `client${(evtAxis || axis.scroll) === "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;
-		return diffTime && !expired && mathAbs(force) > .1 ? force : 0;
-	}
-	return {
-		pointerDown,
-		pointerMove,
-		pointerUp,
-		readPoint
-	};
-}
-function NodeRects() {
-	function measure(node) {
-		const { offsetTop, offsetLeft, offsetWidth, offsetHeight } = node;
-		return {
-			top: offsetTop,
-			right: offsetLeft + offsetWidth,
-			bottom: offsetTop + offsetHeight,
-			left: offsetLeft,
-			width: offsetWidth,
-			height: offsetHeight
-		};
-	}
-	return { measure };
-}
-function PercentOfView(viewSize) {
-	function measure(n) {
-		return viewSize * (n / 100);
-	}
-	return { measure };
-}
-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];
-				if (mathAbs(readSize(isContainer ? container : slides[slideIndex]) - lastSize) >= .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();
-	}
-	return {
-		init,
-		destroy
-	};
-}
-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() {
-		return mathAbs(target.get() - offsetLocation.get()) < .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(.1, .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 diffToEdge = mathAbs(limit[limit.reachedMin(location.get()) ? "min" : "max"] - 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;
-	}
-	return {
-		shouldConstrain,
-		constrain,
-		toggleActive
-	};
-}
-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);
-		return Limit(snapsBounded.lastIndexOf(startSnap), snapsBounded.indexOf(endSnap) + 1);
-	}
-	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);
-	}
-	return {
-		snapsContained,
-		scrollContainLimit
-	};
-}
-function ScrollLimit(contentSize, scrollSnaps, loop) {
-	const max = scrollSnaps[0];
-	return { limit: Limit(loop ? max - contentSize : arrayLast(scrollSnaps), max) };
-}
-function ScrollLooper(contentSize, limit, location, vectors) {
-	const jointSafety = .1;
-	const { reachedMin, reachedMax } = Limit(limit.min + jointSafety, limit.max + jointSafety);
-	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));
-	}
-	return { loop };
-}
-function ScrollProgress(limit) {
-	const { max, length } = limit;
-	function get(n) {
-		const currentLocation = n - max;
-		return length ? currentLocation / -length : 0;
-	}
-	return { get };
-}
-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]);
-	}
-	return {
-		snaps,
-		snapsAligned
-	};
-}
-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) return arrayFromNumber(arrayLast(groups[0]) + 1);
-			if (isLast) return arrayFromNumber(arrayLastIndex(slideIndexes) - arrayLast(groups)[0] + 1, arrayLast(groups)[0]);
-			return group;
-		});
-	}
-	return { slideRegistry };
-}
-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 { index } = scrollSnaps.map((snap, index) => ({
-			diff: shortcut(snap - distance, 0),
-			index
-		})).sort((d1, d2) => mathAbs(d1.diff) - mathAbs(d2.diff))[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) {
-		return {
-			index,
-			distance: shortcut(scrollSnaps[index] - targetVector.get(), direction)
-		};
-	}
-	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
-		};
-		return {
-			index,
-			distance: distance + shortcut(scrollSnaps[index] - targetSnapDistance, 0)
-		};
-	}
-	return {
-		byDistance,
-		byIndex,
-		shortcut
-	};
-}
-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) {
-		scrollTo(scrollTarget.byDistance(n, snap));
-	}
-	function index(n, direction) {
-		const targetIndex = indexCurrent.clone().set(n);
-		scrollTo(scrollTarget.byIndex(targetIndex.get(), direction));
-	}
-	return {
-		distance,
-		index
-	};
-}
-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) {
-			if ((/* @__PURE__ */ new Date()).getTime() - lastTabPressTime > 10) return;
-			eventHandler.emit("slideFocusStart");
-			root.scrollLeft = 0;
-			const group = slideRegistry.findIndex((group) => group.includes(index));
-			if (!isNumber(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 = (/* @__PURE__ */ new Date()).getTime();
-	}
-	return { init };
-}
-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(n) ? n : n.get();
-	}
-	return {
-		get,
-		set,
-		add,
-		subtract
-	};
-}
-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");
-	}
-	return {
-		clear,
-		to,
-		toggleActive
-	};
-}
-function SlideLooper(axis, viewSize, contentSize, slideSizes, slideSizesWithGaps, snaps, scrollSnaps, location, slides) {
-	const roundingSafety = .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) => {
-			return removeSlideSizes(a, gap) > 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];
-		return findLoopPoints(slidesInGap(descItems, gap), contentSize, false);
-	}
-	function endPoints() {
-		return findLoopPoints(slidesInGap(ascItems, viewSize - scrollSnaps[0] - 1), -contentSize, true);
-	}
-	function canLoop() {
-		return loopPoints.every(({ index }) => {
-			return removeSlideSizes(ascItems.filter((i) => i !== index), viewSize) <= .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());
-	}
-	return {
-		canLoop,
-		clear,
-		loop,
-		loopPoints
-	};
-}
-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;
-	}
-	return {
-		init,
-		destroy
-	};
-}
-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];
-			if (inView && isIntersecting || !inView && !isIntersecting) 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;
-	}
-	return {
-		init,
-		destroy,
-		get
-	};
-}
-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);
-	}
-	return {
-		slideSizes,
-		slideSizesWithGaps,
-		startGap,
-		endGap
-	};
-}
-function SlidesToScroll(axis, viewSize, slidesToScroll, loop, containerRect, slideRects, startGap, endGap, pixelTolerance) {
-	const { startEdge, endEdge, direction } = axis;
-	const groupByNumber = isNumber(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 chunkSize = mathAbs(edgeB - (!loop && isLast ? direction(endGap) : 0) - (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);
-	}
-	return { groupSlides };
-}
-function Engine(root, container, slides, ownerDocument, ownerWindow, options, eventHandler) {
-	const { align, axis: scrollAxis, direction, startIndex, loop, duration, dragFree, dragThreshold, inViewThreshold, slidesToScroll: groupSlides, skipSnaps, containScroll, watchResize, watchSlides, watchDrag, watchFocus } = options;
-	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 { slideSizes, slideSizesWithGaps, startGap, endGap } = SlideSizes(axis, containerRect, slideRects, slides, loop || !!containScroll, 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);
-	const index = Counter(arrayLastIndex(scrollSnaps), startIndex, loop);
-	const indexPrevious = index.clone();
-	const slideIndexes = arrayKeys(slides);
-	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));
-	const friction = .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);
-	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;
-}
-var 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 || {};
-		return mergeOptions(options, objectKeys(optionsAtMedia).filter((media) => ownerWindow.matchMedia(media).matches).map((media) => optionsAtMedia[media]).reduce((a, mediaOption) => mergeOptions(a, mediaOption), {}));
-	}
-	function optionsMediaQueries(optionsList) {
-		return optionsList.map((options) => objectKeys(options.breakpoints || {})).reduce((acc, mediaQueries) => acc.concat(mediaQueries), []).map(ownerWindow.matchMedia);
-	}
-	return {
-		mergeOptions,
-		optionsAtMedia,
-		optionsMediaQueries
-	};
-}
-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());
-	}
-	return {
-		init,
-		destroy
-	};
-}
-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;
-		container = (isString(userContainer) ? root.querySelector(userContainer) : userContainer) || 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()) return createEngine(Object.assign({}, options, { loop: false }));
-		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) {
-		scrollTo(engine.index.add(1).get(), jump, -1);
-	}
-	function scrollPrev(jump) {
-		scrollTo(engine.index.add(-1).get(), jump, 1);
-	}
-	function canScrollNext() {
-		return engine.index.add(1).get() !== selectedScrollSnap();
-	}
-	function canScrollPrev() {
-		return engine.index.add(-1).get() !== 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 = void 0;
-//#endregion
-export { EmblaCarousel as default };