@aussieljk/forkbook 0.0.1-3 → 0.0.1-5

package/dist/manager/_manager-chunks/globals-runtime-DDOIxI_l.js

@@ -0,0 +1,1584 @@
+import { n as __esmMin } from "./globals-runtime-BdGkqNEt.js";
+//#region ../../node_modules/@popperjs/core/lib/enums.js
+var bottom, right, left, auto, basePlacements, start, clippingParents, viewport, popper, reference, variationPlacements, placements, beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite, modifierPhases;
+function init_enums() {
+	return (init_enums = __esmMin((() => {
+		bottom = "bottom";
+		right = "right";
+		left = "left";
+		auto = "auto";
+		basePlacements = [
+			"top",
+			bottom,
+			right,
+			left
+		];
+		start = "start";
+		clippingParents = "clippingParents";
+		viewport = "viewport";
+		popper = "popper";
+		reference = "reference";
+		variationPlacements = /*#__PURE__*/ basePlacements.reduce(function(acc, placement) {
+			return acc.concat([placement + "-" + start, placement + "-end"]);
+		}, []);
+		placements = /*#__PURE__*/ [].concat(basePlacements, [auto]).reduce(function(acc, placement) {
+			return acc.concat([
+				placement,
+				placement + "-" + start,
+				placement + "-end"
+			]);
+		}, []);
+		beforeRead = "beforeRead";
+		read = "read";
+		afterRead = "afterRead";
+		beforeMain = "beforeMain";
+		main = "main";
+		afterMain = "afterMain";
+		beforeWrite = "beforeWrite";
+		write = "write";
+		afterWrite = "afterWrite";
+		modifierPhases = [
+			beforeRead,
+			read,
+			afterRead,
+			beforeMain,
+			main,
+			afterMain,
+			beforeWrite,
+			write,
+			afterWrite
+		];
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/getNodeName.js
+function getNodeName(element) {
+	return element ? (element.nodeName || "").toLowerCase() : null;
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/getWindow.js
+function getWindow(node) {
+	if (node == null) return window;
+	if (node.toString() !== "[object Window]") {
+		var ownerDocument = node.ownerDocument;
+		return ownerDocument ? ownerDocument.defaultView || window : window;
+	}
+	return node;
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/instanceOf.js
+function isElement(node) {
+	return node instanceof getWindow(node).Element || node instanceof Element;
+}
+function isHTMLElement(node) {
+	return node instanceof getWindow(node).HTMLElement || node instanceof HTMLElement;
+}
+function isShadowRoot(node) {
+	if (typeof ShadowRoot === "undefined") return false;
+	return node instanceof getWindow(node).ShadowRoot || node instanceof ShadowRoot;
+}
+function init_instanceOf() {
+	return (init_instanceOf = __esmMin((() => {})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/modifiers/applyStyles.js
+function applyStyles(_ref) {
+	var state = _ref.state;
+	Object.keys(state.elements).forEach(function(name) {
+		var style = state.styles[name] || {};
+		var attributes = state.attributes[name] || {};
+		var element = state.elements[name];
+		if (!isHTMLElement(element) || !getNodeName(element)) return;
+		Object.assign(element.style, style);
+		Object.keys(attributes).forEach(function(name) {
+			var value = attributes[name];
+			if (value === false) element.removeAttribute(name);
+			else element.setAttribute(name, value === true ? "" : value);
+		});
+	});
+}
+function effect$2(_ref2) {
+	var state = _ref2.state;
+	var initialStyles = {
+		popper: {
+			position: state.options.strategy,
+			left: "0",
+			top: "0",
+			margin: "0"
+		},
+		arrow: { position: "absolute" },
+		reference: {}
+	};
+	Object.assign(state.elements.popper.style, initialStyles.popper);
+	state.styles = initialStyles;
+	if (state.elements.arrow) Object.assign(state.elements.arrow.style, initialStyles.arrow);
+	return function() {
+		Object.keys(state.elements).forEach(function(name) {
+			var element = state.elements[name];
+			var attributes = state.attributes[name] || {};
+			var style = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]).reduce(function(style, property) {
+				style[property] = "";
+				return style;
+			}, {});
+			if (!isHTMLElement(element) || !getNodeName(element)) return;
+			Object.assign(element.style, style);
+			Object.keys(attributes).forEach(function(attribute) {
+				element.removeAttribute(attribute);
+			});
+		});
+	};
+}
+var applyStyles_default;
+function init_applyStyles() {
+	return (init_applyStyles = __esmMin((() => {
+		init_instanceOf();
+		applyStyles_default = {
+			name: "applyStyles",
+			enabled: true,
+			phase: "write",
+			fn: applyStyles,
+			effect: effect$2,
+			requires: ["computeStyles"]
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/getBasePlacement.js
+function getBasePlacement(placement) {
+	return placement.split("-")[0];
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/math.js
+var max, min, round;
+function init_math() {
+	return (init_math = __esmMin((() => {
+		max = Math.max;
+		min = Math.min;
+		round = Math.round;
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/userAgent.js
+function getUAString() {
+	var uaData = navigator.userAgentData;
+	if (uaData != null && uaData.brands && Array.isArray(uaData.brands)) return uaData.brands.map(function(item) {
+		return item.brand + "/" + item.version;
+	}).join(" ");
+	return navigator.userAgent;
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/isLayoutViewport.js
+function isLayoutViewport() {
+	return !/^((?!chrome|android).)*safari/i.test(getUAString());
+}
+function init_isLayoutViewport() {
+	return (init_isLayoutViewport = __esmMin((() => {})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/getBoundingClientRect.js
+function getBoundingClientRect(element, includeScale, isFixedStrategy) {
+	if (includeScale === void 0) includeScale = false;
+	if (isFixedStrategy === void 0) isFixedStrategy = false;
+	var clientRect = element.getBoundingClientRect();
+	var scaleX = 1;
+	var scaleY = 1;
+	if (includeScale && isHTMLElement(element)) {
+		scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1;
+		scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1;
+	}
+	var visualViewport = (isElement(element) ? getWindow(element) : window).visualViewport;
+	var addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
+	var x = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX;
+	var y = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY;
+	var width = clientRect.width / scaleX;
+	var height = clientRect.height / scaleY;
+	return {
+		width,
+		height,
+		top: y,
+		right: x + width,
+		bottom: y + height,
+		left: x,
+		x,
+		y
+	};
+}
+function init_getBoundingClientRect() {
+	return (init_getBoundingClientRect = __esmMin((() => {
+		init_instanceOf();
+		init_math();
+		init_isLayoutViewport();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/getLayoutRect.js
+function getLayoutRect(element) {
+	var clientRect = getBoundingClientRect(element);
+	var width = element.offsetWidth;
+	var height = element.offsetHeight;
+	if (Math.abs(clientRect.width - width) <= 1) width = clientRect.width;
+	if (Math.abs(clientRect.height - height) <= 1) height = clientRect.height;
+	return {
+		x: element.offsetLeft,
+		y: element.offsetTop,
+		width,
+		height
+	};
+}
+function init_getLayoutRect() {
+	return (init_getLayoutRect = __esmMin((() => {
+		init_getBoundingClientRect();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/contains.js
+function contains(parent, child) {
+	var rootNode = child.getRootNode && child.getRootNode();
+	if (parent.contains(child)) return true;
+	else if (rootNode && isShadowRoot(rootNode)) {
+		var next = child;
+		do {
+			if (next && parent.isSameNode(next)) return true;
+			next = next.parentNode || next.host;
+		} while (next);
+	}
+	return false;
+}
+function init_contains() {
+	return (init_contains = __esmMin((() => {
+		init_instanceOf();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/getComputedStyle.js
+function getComputedStyle(element) {
+	return getWindow(element).getComputedStyle(element);
+}
+function init_getComputedStyle() {
+	return (init_getComputedStyle = __esmMin((() => {})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/isTableElement.js
+function isTableElement(element) {
+	return [
+		"table",
+		"td",
+		"th"
+	].indexOf(getNodeName(element)) >= 0;
+}
+function init_isTableElement() {
+	return (init_isTableElement = __esmMin((() => {})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/getDocumentElement.js
+function getDocumentElement(element) {
+	return ((isElement(element) ? element.ownerDocument : element.document) || window.document).documentElement;
+}
+function init_getDocumentElement() {
+	return (init_getDocumentElement = __esmMin((() => {
+		init_instanceOf();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/getParentNode.js
+function getParentNode(element) {
+	if (getNodeName(element) === "html") return element;
+	return element.assignedSlot || element.parentNode || (isShadowRoot(element) ? element.host : null) || getDocumentElement(element);
+}
+function init_getParentNode() {
+	return (init_getParentNode = __esmMin((() => {
+		init_getDocumentElement();
+		init_instanceOf();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/getOffsetParent.js
+function getTrueOffsetParent(element) {
+	if (!isHTMLElement(element) || getComputedStyle(element).position === "fixed") return null;
+	return element.offsetParent;
+}
+function getContainingBlock(element) {
+	var isFirefox = /firefox/i.test(getUAString());
+	if (/Trident/i.test(getUAString()) && isHTMLElement(element)) {
+		if (getComputedStyle(element).position === "fixed") return null;
+	}
+	var currentNode = getParentNode(element);
+	if (isShadowRoot(currentNode)) currentNode = currentNode.host;
+	while (isHTMLElement(currentNode) && ["html", "body"].indexOf(getNodeName(currentNode)) < 0) {
+		var css = getComputedStyle(currentNode);
+		if (css.transform !== "none" || css.perspective !== "none" || css.contain === "paint" || ["transform", "perspective"].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === "filter" || isFirefox && css.filter && css.filter !== "none") return currentNode;
+		else currentNode = currentNode.parentNode;
+	}
+	return null;
+}
+function getOffsetParent(element) {
+	var window = getWindow(element);
+	var offsetParent = getTrueOffsetParent(element);
+	while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === "static") offsetParent = getTrueOffsetParent(offsetParent);
+	if (offsetParent && (getNodeName(offsetParent) === "html" || getNodeName(offsetParent) === "body" && getComputedStyle(offsetParent).position === "static")) return window;
+	return offsetParent || getContainingBlock(element) || window;
+}
+function init_getOffsetParent() {
+	return (init_getOffsetParent = __esmMin((() => {
+		init_getComputedStyle();
+		init_instanceOf();
+		init_isTableElement();
+		init_getParentNode();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/getMainAxisFromPlacement.js
+function getMainAxisFromPlacement(placement) {
+	return ["top", "bottom"].indexOf(placement) >= 0 ? "x" : "y";
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/within.js
+function within(min$2, value, max$2) {
+	return max(min$2, min(value, max$2));
+}
+function withinMaxClamp(min, value, max) {
+	var v = within(min, value, max);
+	return v > max ? max : v;
+}
+function init_within() {
+	return (init_within = __esmMin((() => {
+		init_math();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/getFreshSideObject.js
+function getFreshSideObject() {
+	return {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	};
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/mergePaddingObject.js
+function mergePaddingObject(paddingObject) {
+	return Object.assign({}, getFreshSideObject(), paddingObject);
+}
+function init_mergePaddingObject() {
+	return (init_mergePaddingObject = __esmMin((() => {})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/expandToHashMap.js
+function expandToHashMap(value, keys) {
+	return keys.reduce(function(hashMap, key) {
+		hashMap[key] = value;
+		return hashMap;
+	}, {});
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/modifiers/arrow.js
+function arrow(_ref) {
+	var _state$modifiersData$;
+	var state = _ref.state, name = _ref.name, options = _ref.options;
+	var arrowElement = state.elements.arrow;
+	var popperOffsets = state.modifiersData.popperOffsets;
+	var basePlacement = getBasePlacement(state.placement);
+	var axis = getMainAxisFromPlacement(basePlacement);
+	var len = ["left", "right"].indexOf(basePlacement) >= 0 ? "height" : "width";
+	if (!arrowElement || !popperOffsets) return;
+	var paddingObject = toPaddingObject(options.padding, state);
+	var arrowRect = getLayoutRect(arrowElement);
+	var minProp = axis === "y" ? "top" : left;
+	var maxProp = axis === "y" ? bottom : right;
+	var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len];
+	var startDiff = popperOffsets[axis] - state.rects.reference[axis];
+	var arrowOffsetParent = getOffsetParent(arrowElement);
+	var clientSize = arrowOffsetParent ? axis === "y" ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
+	var centerToReference = endDiff / 2 - startDiff / 2;
+	var min = paddingObject[minProp];
+	var max = clientSize - arrowRect[len] - paddingObject[maxProp];
+	var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
+	var offset = within(min, center, max);
+	var axisProp = axis;
+	state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$);
+}
+function effect$1(_ref2) {
+	var state = _ref2.state;
+	var _options$element = _ref2.options.element, arrowElement = _options$element === void 0 ? "[data-popper-arrow]" : _options$element;
+	if (arrowElement == null) return;
+	if (typeof arrowElement === "string") {
+		arrowElement = state.elements.popper.querySelector(arrowElement);
+		if (!arrowElement) return;
+	}
+	if (!contains(state.elements.popper, arrowElement)) return;
+	state.elements.arrow = arrowElement;
+}
+var toPaddingObject, arrow_default;
+function init_arrow() {
+	return (init_arrow = __esmMin((() => {
+		init_getLayoutRect();
+		init_contains();
+		init_getOffsetParent();
+		init_within();
+		init_mergePaddingObject();
+		init_enums();
+		toPaddingObject = function toPaddingObject(padding, state) {
+			padding = typeof padding === "function" ? padding(Object.assign({}, state.rects, { placement: state.placement })) : padding;
+			return mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements));
+		};
+		arrow_default = {
+			name: "arrow",
+			enabled: true,
+			phase: "main",
+			fn: arrow,
+			effect: effect$1,
+			requires: ["popperOffsets"],
+			requiresIfExists: ["preventOverflow"]
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/getVariation.js
+function getVariation(placement) {
+	return placement.split("-")[1];
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/modifiers/computeStyles.js
+function roundOffsetsByDPR(_ref, win) {
+	var x = _ref.x, y = _ref.y;
+	var dpr = win.devicePixelRatio || 1;
+	return {
+		x: round(x * dpr) / dpr || 0,
+		y: round(y * dpr) / dpr || 0
+	};
+}
+function mapToStyles(_ref2) {
+	var _Object$assign2;
+	var popper = _ref2.popper, popperRect = _ref2.popperRect, placement = _ref2.placement, variation = _ref2.variation, offsets = _ref2.offsets, position = _ref2.position, gpuAcceleration = _ref2.gpuAcceleration, adaptive = _ref2.adaptive, roundOffsets = _ref2.roundOffsets, isFixed = _ref2.isFixed;
+	var _offsets$x = offsets.x, x = _offsets$x === void 0 ? 0 : _offsets$x, _offsets$y = offsets.y, y = _offsets$y === void 0 ? 0 : _offsets$y;
+	var _ref3 = typeof roundOffsets === "function" ? roundOffsets({
+		x,
+		y
+	}) : {
+		x,
+		y
+	};
+	x = _ref3.x;
+	y = _ref3.y;
+	var hasX = offsets.hasOwnProperty("x");
+	var hasY = offsets.hasOwnProperty("y");
+	var sideX = left;
+	var sideY = "top";
+	var win = window;
+	if (adaptive) {
+		var offsetParent = getOffsetParent(popper);
+		var heightProp = "clientHeight";
+		var widthProp = "clientWidth";
+		if (offsetParent === getWindow(popper)) {
+			offsetParent = getDocumentElement(popper);
+			if (getComputedStyle(offsetParent).position !== "static" && position === "absolute") {
+				heightProp = "scrollHeight";
+				widthProp = "scrollWidth";
+			}
+		}
+		offsetParent = offsetParent;
+		if (placement === "top" || (placement === "left" || placement === "right") && variation === "end") {
+			sideY = bottom;
+			var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : offsetParent[heightProp];
+			y -= offsetY - popperRect.height;
+			y *= gpuAcceleration ? 1 : -1;
+		}
+		if (placement === "left" || (placement === "top" || placement === "bottom") && variation === "end") {
+			sideX = right;
+			var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : offsetParent[widthProp];
+			x -= offsetX - popperRect.width;
+			x *= gpuAcceleration ? 1 : -1;
+		}
+	}
+	var commonStyles = Object.assign({ position }, adaptive && unsetSides);
+	var _ref4 = roundOffsets === true ? roundOffsetsByDPR({
+		x,
+		y
+	}, getWindow(popper)) : {
+		x,
+		y
+	};
+	x = _ref4.x;
+	y = _ref4.y;
+	if (gpuAcceleration) {
+		var _Object$assign;
+		return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? "0" : "", _Object$assign[sideX] = hasX ? "0" : "", _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign));
+	}
+	return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : "", _Object$assign2[sideX] = hasX ? x + "px" : "", _Object$assign2.transform = "", _Object$assign2));
+}
+function computeStyles(_ref5) {
+	var state = _ref5.state, options = _ref5.options;
+	var _options$gpuAccelerat = options.gpuAcceleration, gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat, _options$adaptive = options.adaptive, adaptive = _options$adaptive === void 0 ? true : _options$adaptive, _options$roundOffsets = options.roundOffsets, roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
+	var commonStyles = {
+		placement: getBasePlacement(state.placement),
+		variation: getVariation(state.placement),
+		popper: state.elements.popper,
+		popperRect: state.rects.popper,
+		gpuAcceleration,
+		isFixed: state.options.strategy === "fixed"
+	};
+	if (state.modifiersData.popperOffsets != null) state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
+		offsets: state.modifiersData.popperOffsets,
+		position: state.options.strategy,
+		adaptive,
+		roundOffsets
+	})));
+	if (state.modifiersData.arrow != null) state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
+		offsets: state.modifiersData.arrow,
+		position: "absolute",
+		adaptive: false,
+		roundOffsets
+	})));
+	state.attributes.popper = Object.assign({}, state.attributes.popper, { "data-popper-placement": state.placement });
+}
+var unsetSides, computeStyles_default;
+function init_computeStyles() {
+	return (init_computeStyles = __esmMin((() => {
+		init_enums();
+		init_getOffsetParent();
+		init_getDocumentElement();
+		init_getComputedStyle();
+		init_math();
+		unsetSides = {
+			top: "auto",
+			right: "auto",
+			bottom: "auto",
+			left: "auto"
+		};
+		computeStyles_default = {
+			name: "computeStyles",
+			enabled: true,
+			phase: "beforeWrite",
+			fn: computeStyles,
+			data: {}
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/modifiers/eventListeners.js
+function effect(_ref) {
+	var state = _ref.state, instance = _ref.instance, options = _ref.options;
+	var _options$scroll = options.scroll, scroll = _options$scroll === void 0 ? true : _options$scroll, _options$resize = options.resize, resize = _options$resize === void 0 ? true : _options$resize;
+	var window = getWindow(state.elements.popper);
+	var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
+	if (scroll) scrollParents.forEach(function(scrollParent) {
+		scrollParent.addEventListener("scroll", instance.update, passive);
+	});
+	if (resize) window.addEventListener("resize", instance.update, passive);
+	return function() {
+		if (scroll) scrollParents.forEach(function(scrollParent) {
+			scrollParent.removeEventListener("scroll", instance.update, passive);
+		});
+		if (resize) window.removeEventListener("resize", instance.update, passive);
+	};
+}
+var passive, eventListeners_default;
+function init_eventListeners() {
+	return (init_eventListeners = __esmMin((() => {
+		passive = { passive: true };
+		eventListeners_default = {
+			name: "eventListeners",
+			enabled: true,
+			phase: "write",
+			fn: function fn() {},
+			effect,
+			data: {}
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/getOppositePlacement.js
+function getOppositePlacement(placement) {
+	return placement.replace(/left|right|bottom|top/g, function(matched) {
+		return hash$1[matched];
+	});
+}
+var hash$1;
+function init_getOppositePlacement() {
+	return (init_getOppositePlacement = __esmMin((() => {
+		hash$1 = {
+			left: "right",
+			right: "left",
+			bottom: "top",
+			top: "bottom"
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/getOppositeVariationPlacement.js
+function getOppositeVariationPlacement(placement) {
+	return placement.replace(/start|end/g, function(matched) {
+		return hash[matched];
+	});
+}
+var hash;
+function init_getOppositeVariationPlacement() {
+	return (init_getOppositeVariationPlacement = __esmMin((() => {
+		hash = {
+			start: "end",
+			end: "start"
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/getWindowScroll.js
+function getWindowScroll(node) {
+	var win = getWindow(node);
+	return {
+		scrollLeft: win.pageXOffset,
+		scrollTop: win.pageYOffset
+	};
+}
+function init_getWindowScroll() {
+	return (init_getWindowScroll = __esmMin((() => {})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/getWindowScrollBarX.js
+function getWindowScrollBarX(element) {
+	return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
+}
+function init_getWindowScrollBarX() {
+	return (init_getWindowScrollBarX = __esmMin((() => {
+		init_getBoundingClientRect();
+		init_getDocumentElement();
+		init_getWindowScroll();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/getViewportRect.js
+function getViewportRect(element, strategy) {
+	var win = getWindow(element);
+	var html = getDocumentElement(element);
+	var visualViewport = win.visualViewport;
+	var width = html.clientWidth;
+	var height = html.clientHeight;
+	var x = 0;
+	var y = 0;
+	if (visualViewport) {
+		width = visualViewport.width;
+		height = visualViewport.height;
+		var layoutViewport = isLayoutViewport();
+		if (layoutViewport || !layoutViewport && strategy === "fixed") {
+			x = visualViewport.offsetLeft;
+			y = visualViewport.offsetTop;
+		}
+	}
+	return {
+		width,
+		height,
+		x: x + getWindowScrollBarX(element),
+		y
+	};
+}
+function init_getViewportRect() {
+	return (init_getViewportRect = __esmMin((() => {
+		init_getDocumentElement();
+		init_getWindowScrollBarX();
+		init_isLayoutViewport();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/getDocumentRect.js
+function getDocumentRect(element) {
+	var _element$ownerDocumen;
+	var html = getDocumentElement(element);
+	var winScroll = getWindowScroll(element);
+	var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
+	var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
+	var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
+	var x = -winScroll.scrollLeft + getWindowScrollBarX(element);
+	var y = -winScroll.scrollTop;
+	if (getComputedStyle(body || html).direction === "rtl") x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
+	return {
+		width,
+		height,
+		x,
+		y
+	};
+}
+function init_getDocumentRect() {
+	return (init_getDocumentRect = __esmMin((() => {
+		init_getDocumentElement();
+		init_getComputedStyle();
+		init_getWindowScrollBarX();
+		init_getWindowScroll();
+		init_math();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/isScrollParent.js
+function isScrollParent(element) {
+	var _getComputedStyle = getComputedStyle(element), overflow = _getComputedStyle.overflow, overflowX = _getComputedStyle.overflowX, overflowY = _getComputedStyle.overflowY;
+	return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
+}
+function init_isScrollParent() {
+	return (init_isScrollParent = __esmMin((() => {
+		init_getComputedStyle();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/getScrollParent.js
+function getScrollParent(node) {
+	if ([
+		"html",
+		"body",
+		"#document"
+	].indexOf(getNodeName(node)) >= 0) return node.ownerDocument.body;
+	if (isHTMLElement(node) && isScrollParent(node)) return node;
+	return getScrollParent(getParentNode(node));
+}
+function init_getScrollParent() {
+	return (init_getScrollParent = __esmMin((() => {
+		init_getParentNode();
+		init_isScrollParent();
+		init_instanceOf();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/listScrollParents.js
+function listScrollParents(element, list) {
+	var _element$ownerDocumen;
+	if (list === void 0) list = [];
+	var scrollParent = getScrollParent(element);
+	var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
+	var win = getWindow(scrollParent);
+	var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
+	var updatedList = list.concat(target);
+	return isBody ? updatedList : updatedList.concat(listScrollParents(getParentNode(target)));
+}
+function init_listScrollParents() {
+	return (init_listScrollParents = __esmMin((() => {
+		init_getScrollParent();
+		init_getParentNode();
+		init_isScrollParent();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/rectToClientRect.js
+function rectToClientRect(rect) {
+	return Object.assign({}, rect, {
+		left: rect.x,
+		top: rect.y,
+		right: rect.x + rect.width,
+		bottom: rect.y + rect.height
+	});
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/getClippingRect.js
+function getInnerBoundingClientRect(element, strategy) {
+	var rect = getBoundingClientRect(element, false, strategy === "fixed");
+	rect.top = rect.top + element.clientTop;
+	rect.left = rect.left + element.clientLeft;
+	rect.bottom = rect.top + element.clientHeight;
+	rect.right = rect.left + element.clientWidth;
+	rect.width = element.clientWidth;
+	rect.height = element.clientHeight;
+	rect.x = rect.left;
+	rect.y = rect.top;
+	return rect;
+}
+function getClientRectFromMixedType(element, clippingParent, strategy) {
+	return clippingParent === "viewport" ? rectToClientRect(getViewportRect(element, strategy)) : isElement(clippingParent) ? getInnerBoundingClientRect(clippingParent, strategy) : rectToClientRect(getDocumentRect(getDocumentElement(element)));
+}
+function getClippingParents(element) {
+	var clippingParents = listScrollParents(getParentNode(element));
+	var clipperElement = ["absolute", "fixed"].indexOf(getComputedStyle(element).position) >= 0 && isHTMLElement(element) ? getOffsetParent(element) : element;
+	if (!isElement(clipperElement)) return [];
+	return clippingParents.filter(function(clippingParent) {
+		return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== "body";
+	});
+}
+function getClippingRect(element, boundary, rootBoundary, strategy) {
+	var mainClippingParents = boundary === "clippingParents" ? getClippingParents(element) : [].concat(boundary);
+	var clippingParents = [].concat(mainClippingParents, [rootBoundary]);
+	var firstClippingParent = clippingParents[0];
+	var clippingRect = clippingParents.reduce(function(accRect, clippingParent) {
+		var rect = getClientRectFromMixedType(element, clippingParent, strategy);
+		accRect.top = max(rect.top, accRect.top);
+		accRect.right = min(rect.right, accRect.right);
+		accRect.bottom = min(rect.bottom, accRect.bottom);
+		accRect.left = max(rect.left, accRect.left);
+		return accRect;
+	}, getClientRectFromMixedType(element, firstClippingParent, strategy));
+	clippingRect.width = clippingRect.right - clippingRect.left;
+	clippingRect.height = clippingRect.bottom - clippingRect.top;
+	clippingRect.x = clippingRect.left;
+	clippingRect.y = clippingRect.top;
+	return clippingRect;
+}
+function init_getClippingRect() {
+	return (init_getClippingRect = __esmMin((() => {
+		init_enums();
+		init_getViewportRect();
+		init_getDocumentRect();
+		init_listScrollParents();
+		init_getOffsetParent();
+		init_getDocumentElement();
+		init_getComputedStyle();
+		init_instanceOf();
+		init_getBoundingClientRect();
+		init_getParentNode();
+		init_contains();
+		init_math();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/computeOffsets.js
+function computeOffsets(_ref) {
+	var reference = _ref.reference, element = _ref.element, placement = _ref.placement;
+	var basePlacement = placement ? getBasePlacement(placement) : null;
+	var variation = placement ? getVariation(placement) : null;
+	var commonX = reference.x + reference.width / 2 - element.width / 2;
+	var commonY = reference.y + reference.height / 2 - element.height / 2;
+	var offsets;
+	switch (basePlacement) {
+		case "top":
+			offsets = {
+				x: commonX,
+				y: reference.y - element.height
+			};
+			break;
+		case bottom:
+			offsets = {
+				x: commonX,
+				y: reference.y + reference.height
+			};
+			break;
+		case right:
+			offsets = {
+				x: reference.x + reference.width,
+				y: commonY
+			};
+			break;
+		case left:
+			offsets = {
+				x: reference.x - element.width,
+				y: commonY
+			};
+			break;
+		default: offsets = {
+			x: reference.x,
+			y: reference.y
+		};
+	}
+	var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
+	if (mainAxis != null) {
+		var len = mainAxis === "y" ? "height" : "width";
+		switch (variation) {
+			case start:
+				offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2);
+				break;
+			case "end": offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2);
+		}
+	}
+	return offsets;
+}
+function init_computeOffsets() {
+	return (init_computeOffsets = __esmMin((() => {
+		init_enums();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/detectOverflow.js
+function detectOverflow(state, options) {
+	if (options === void 0) options = {};
+	var _options = options, _options$placement = _options.placement, placement = _options$placement === void 0 ? state.placement : _options$placement, _options$strategy = _options.strategy, strategy = _options$strategy === void 0 ? state.strategy : _options$strategy, _options$boundary = _options.boundary, boundary = _options$boundary === void 0 ? clippingParents : _options$boundary, _options$rootBoundary = _options.rootBoundary, rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary, _options$elementConte = _options.elementContext, elementContext = _options$elementConte === void 0 ? popper : _options$elementConte, _options$altBoundary = _options.altBoundary, altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary, _options$padding = _options.padding, padding = _options$padding === void 0 ? 0 : _options$padding;
+	var paddingObject = mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements));
+	var altContext = elementContext === "popper" ? reference : popper;
+	var popperRect = state.rects.popper;
+	var element = state.elements[altBoundary ? altContext : elementContext];
+	var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary, strategy);
+	var referenceClientRect = getBoundingClientRect(state.elements.reference);
+	var popperOffsets = computeOffsets({
+		reference: referenceClientRect,
+		element: popperRect,
+		strategy: "absolute",
+		placement
+	});
+	var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets));
+	var elementClientRect = elementContext === "popper" ? popperClientRect : referenceClientRect;
+	var overflowOffsets = {
+		top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
+		bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
+		left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
+		right: elementClientRect.right - clippingClientRect.right + paddingObject.right
+	};
+	var offsetData = state.modifiersData.offset;
+	if (elementContext === "popper" && offsetData) {
+		var offset = offsetData[placement];
+		Object.keys(overflowOffsets).forEach(function(key) {
+			var multiply = ["right", "bottom"].indexOf(key) >= 0 ? 1 : -1;
+			var axis = ["top", "bottom"].indexOf(key) >= 0 ? "y" : "x";
+			overflowOffsets[key] += offset[axis] * multiply;
+		});
+	}
+	return overflowOffsets;
+}
+function init_detectOverflow() {
+	return (init_detectOverflow = __esmMin((() => {
+		init_getClippingRect();
+		init_getDocumentElement();
+		init_getBoundingClientRect();
+		init_computeOffsets();
+		init_enums();
+		init_instanceOf();
+		init_mergePaddingObject();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/computeAutoPlacement.js
+function computeAutoPlacement(state, options) {
+	if (options === void 0) options = {};
+	var _options = options, placement = _options.placement, boundary = _options.boundary, rootBoundary = _options.rootBoundary, padding = _options.padding, flipVariations = _options.flipVariations, _options$allowedAutoP = _options.allowedAutoPlacements, allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP;
+	var variation = getVariation(placement);
+	var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function(placement) {
+		return getVariation(placement) === variation;
+	}) : basePlacements;
+	var allowedPlacements = placements$1.filter(function(placement) {
+		return allowedAutoPlacements.indexOf(placement) >= 0;
+	});
+	if (allowedPlacements.length === 0) allowedPlacements = placements$1;
+	var overflows = allowedPlacements.reduce(function(acc, placement) {
+		acc[placement] = detectOverflow(state, {
+			placement,
+			boundary,
+			rootBoundary,
+			padding
+		})[getBasePlacement(placement)];
+		return acc;
+	}, {});
+	return Object.keys(overflows).sort(function(a, b) {
+		return overflows[a] - overflows[b];
+	});
+}
+function init_computeAutoPlacement() {
+	return (init_computeAutoPlacement = __esmMin((() => {
+		init_enums();
+		init_detectOverflow();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/modifiers/flip.js
+function getExpandedFallbackPlacements(placement) {
+	if (getBasePlacement(placement) === "auto") return [];
+	var oppositePlacement = getOppositePlacement(placement);
+	return [
+		getOppositeVariationPlacement(placement),
+		oppositePlacement,
+		getOppositeVariationPlacement(oppositePlacement)
+	];
+}
+function flip(_ref) {
+	var state = _ref.state, options = _ref.options, name = _ref.name;
+	if (state.modifiersData[name]._skip) return;
+	var _options$mainAxis = options.mainAxis, checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis, specifiedFallbackPlacements = options.fallbackPlacements, padding = options.padding, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, _options$flipVariatio = options.flipVariations, flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio, allowedAutoPlacements = options.allowedAutoPlacements;
+	var preferredPlacement = state.options.placement;
+	var isBasePlacement = getBasePlacement(preferredPlacement) === preferredPlacement;
+	var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement));
+	var placements = [preferredPlacement].concat(fallbackPlacements).reduce(function(acc, placement) {
+		return acc.concat(getBasePlacement(placement) === "auto" ? computeAutoPlacement(state, {
+			placement,
+			boundary,
+			rootBoundary,
+			padding,
+			flipVariations,
+			allowedAutoPlacements
+		}) : placement);
+	}, []);
+	var referenceRect = state.rects.reference;
+	var popperRect = state.rects.popper;
+	var checksMap = /* @__PURE__ */ new Map();
+	var makeFallbackChecks = true;
+	var firstFittingPlacement = placements[0];
+	for (var i = 0; i < placements.length; i++) {
+		var placement = placements[i];
+		var _basePlacement = getBasePlacement(placement);
+		var isStartVariation = getVariation(placement) === start;
+		var isVertical = ["top", bottom].indexOf(_basePlacement) >= 0;
+		var len = isVertical ? "width" : "height";
+		var overflow = detectOverflow(state, {
+			placement,
+			boundary,
+			rootBoundary,
+			altBoundary,
+			padding
+		});
+		var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : "top";
+		if (referenceRect[len] > popperRect[len]) mainVariationSide = getOppositePlacement(mainVariationSide);
+		var altVariationSide = getOppositePlacement(mainVariationSide);
+		var checks = [];
+		if (checkMainAxis) checks.push(overflow[_basePlacement] <= 0);
+		if (checkAltAxis) checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
+		if (checks.every(function(check) {
+			return check;
+		})) {
+			firstFittingPlacement = placement;
+			makeFallbackChecks = false;
+			break;
+		}
+		checksMap.set(placement, checks);
+	}
+	if (makeFallbackChecks) {
+		var numberOfChecks = flipVariations ? 3 : 1;
+		var _loop = function _loop(_i) {
+			var fittingPlacement = placements.find(function(placement) {
+				var checks = checksMap.get(placement);
+				if (checks) return checks.slice(0, _i).every(function(check) {
+					return check;
+				});
+			});
+			if (fittingPlacement) {
+				firstFittingPlacement = fittingPlacement;
+				return "break";
+			}
+		};
+		for (var _i = numberOfChecks; _i > 0; _i--) if (_loop(_i) === "break") break;
+	}
+	if (state.placement !== firstFittingPlacement) {
+		state.modifiersData[name]._skip = true;
+		state.placement = firstFittingPlacement;
+		state.reset = true;
+	}
+}
+var flip_default;
+function init_flip() {
+	return (init_flip = __esmMin((() => {
+		init_getOppositePlacement();
+		init_getOppositeVariationPlacement();
+		init_detectOverflow();
+		init_computeAutoPlacement();
+		init_enums();
+		flip_default = {
+			name: "flip",
+			enabled: true,
+			phase: "main",
+			fn: flip,
+			requiresIfExists: ["offset"],
+			data: { _skip: false }
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/modifiers/hide.js
+function getSideOffsets(overflow, rect, preventedOffsets) {
+	if (preventedOffsets === void 0) preventedOffsets = {
+		x: 0,
+		y: 0
+	};
+	return {
+		top: overflow.top - rect.height - preventedOffsets.y,
+		right: overflow.right - rect.width + preventedOffsets.x,
+		bottom: overflow.bottom - rect.height + preventedOffsets.y,
+		left: overflow.left - rect.width - preventedOffsets.x
+	};
+}
+function isAnySideFullyClipped(overflow) {
+	return [
+		"top",
+		right,
+		bottom,
+		left
+	].some(function(side) {
+		return overflow[side] >= 0;
+	});
+}
+function hide(_ref) {
+	var state = _ref.state, name = _ref.name;
+	var referenceRect = state.rects.reference;
+	var popperRect = state.rects.popper;
+	var preventedOffsets = state.modifiersData.preventOverflow;
+	var referenceOverflow = detectOverflow(state, { elementContext: "reference" });
+	var popperAltOverflow = detectOverflow(state, { altBoundary: true });
+	var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);
+	var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);
+	var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);
+	var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);
+	state.modifiersData[name] = {
+		referenceClippingOffsets,
+		popperEscapeOffsets,
+		isReferenceHidden,
+		hasPopperEscaped
+	};
+	state.attributes.popper = Object.assign({}, state.attributes.popper, {
+		"data-popper-reference-hidden": isReferenceHidden,
+		"data-popper-escaped": hasPopperEscaped
+	});
+}
+var hide_default;
+function init_hide() {
+	return (init_hide = __esmMin((() => {
+		init_enums();
+		init_detectOverflow();
+		hide_default = {
+			name: "hide",
+			enabled: true,
+			phase: "main",
+			requiresIfExists: ["preventOverflow"],
+			fn: hide
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/modifiers/offset.js
+function distanceAndSkiddingToXY(placement, rects, offset) {
+	var basePlacement = getBasePlacement(placement);
+	var invertDistance = ["left", "top"].indexOf(basePlacement) >= 0 ? -1 : 1;
+	var _ref = typeof offset === "function" ? offset(Object.assign({}, rects, { placement })) : offset, skidding = _ref[0], distance = _ref[1];
+	skidding = skidding || 0;
+	distance = (distance || 0) * invertDistance;
+	return ["left", "right"].indexOf(basePlacement) >= 0 ? {
+		x: distance,
+		y: skidding
+	} : {
+		x: skidding,
+		y: distance
+	};
+}
+function offset(_ref2) {
+	var state = _ref2.state, options = _ref2.options, name = _ref2.name;
+	var _options$offset = options.offset, offset = _options$offset === void 0 ? [0, 0] : _options$offset;
+	var data = placements.reduce(function(acc, placement) {
+		acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset);
+		return acc;
+	}, {});
+	var _data$state$placement = data[state.placement], x = _data$state$placement.x, y = _data$state$placement.y;
+	if (state.modifiersData.popperOffsets != null) {
+		state.modifiersData.popperOffsets.x += x;
+		state.modifiersData.popperOffsets.y += y;
+	}
+	state.modifiersData[name] = data;
+}
+var offset_default;
+function init_offset() {
+	return (init_offset = __esmMin((() => {
+		init_enums();
+		offset_default = {
+			name: "offset",
+			enabled: true,
+			phase: "main",
+			requires: ["popperOffsets"],
+			fn: offset
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/modifiers/popperOffsets.js
+function popperOffsets(_ref) {
+	var state = _ref.state, name = _ref.name;
+	state.modifiersData[name] = computeOffsets({
+		reference: state.rects.reference,
+		element: state.rects.popper,
+		strategy: "absolute",
+		placement: state.placement
+	});
+}
+var popperOffsets_default;
+function init_popperOffsets() {
+	return (init_popperOffsets = __esmMin((() => {
+		init_computeOffsets();
+		popperOffsets_default = {
+			name: "popperOffsets",
+			enabled: true,
+			phase: "read",
+			fn: popperOffsets,
+			data: {}
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/getAltAxis.js
+function getAltAxis(axis) {
+	return axis === "x" ? "y" : "x";
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/modifiers/preventOverflow.js
+function preventOverflow(_ref) {
+	var state = _ref.state, options = _ref.options, name = _ref.name;
+	var _options$mainAxis = options.mainAxis, checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, padding = options.padding, _options$tether = options.tether, tether = _options$tether === void 0 ? true : _options$tether, _options$tetherOffset = options.tetherOffset, tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;
+	var overflow = detectOverflow(state, {
+		boundary,
+		rootBoundary,
+		padding,
+		altBoundary
+	});
+	var basePlacement = getBasePlacement(state.placement);
+	var variation = getVariation(state.placement);
+	var isBasePlacement = !variation;
+	var mainAxis = getMainAxisFromPlacement(basePlacement);
+	var altAxis = getAltAxis(mainAxis);
+	var popperOffsets = state.modifiersData.popperOffsets;
+	var referenceRect = state.rects.reference;
+	var popperRect = state.rects.popper;
+	var tetherOffsetValue = typeof tetherOffset === "function" ? tetherOffset(Object.assign({}, state.rects, { placement: state.placement })) : tetherOffset;
+	var normalizedTetherOffsetValue = typeof tetherOffsetValue === "number" ? {
+		mainAxis: tetherOffsetValue,
+		altAxis: tetherOffsetValue
+	} : Object.assign({
+		mainAxis: 0,
+		altAxis: 0
+	}, tetherOffsetValue);
+	var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null;
+	var data = {
+		x: 0,
+		y: 0
+	};
+	if (!popperOffsets) return;
+	if (checkMainAxis) {
+		var _offsetModifierState$;
+		var mainSide = mainAxis === "y" ? "top" : left;
+		var altSide = mainAxis === "y" ? bottom : right;
+		var len = mainAxis === "y" ? "height" : "width";
+		var offset = popperOffsets[mainAxis];
+		var min$1 = offset + overflow[mainSide];
+		var max$1 = offset - overflow[altSide];
+		var additive = tether ? -popperRect[len] / 2 : 0;
+		var minLen = variation === "start" ? referenceRect[len] : popperRect[len];
+		var maxLen = variation === "start" ? -popperRect[len] : -referenceRect[len];
+		var arrowElement = state.elements.arrow;
+		var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : {
+			width: 0,
+			height: 0
+		};
+		var arrowPaddingObject = state.modifiersData["arrow#persistent"] ? state.modifiersData["arrow#persistent"].padding : getFreshSideObject();
+		var arrowPaddingMin = arrowPaddingObject[mainSide];
+		var arrowPaddingMax = arrowPaddingObject[altSide];
+		var arrowLen = within(0, referenceRect[len], arrowRect[len]);
+		var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis;
+		var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis;
+		var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow);
+		var clientOffset = arrowOffsetParent ? mainAxis === "y" ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;
+		var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0;
+		var tetherMin = offset + minOffset - offsetModifierValue - clientOffset;
+		var tetherMax = offset + maxOffset - offsetModifierValue;
+		var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset, tether ? max(max$1, tetherMax) : max$1);
+		popperOffsets[mainAxis] = preventedOffset;
+		data[mainAxis] = preventedOffset - offset;
+	}
+	if (checkAltAxis) {
+		var _offsetModifierState$2;
+		var _mainSide = mainAxis === "x" ? "top" : left;
+		var _altSide = mainAxis === "x" ? bottom : right;
+		var _offset = popperOffsets[altAxis];
+		var _len = altAxis === "y" ? "height" : "width";
+		var _min = _offset + overflow[_mainSide];
+		var _max = _offset - overflow[_altSide];
+		var isOriginSide = ["top", left].indexOf(basePlacement) !== -1;
+		var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0;
+		var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis;
+		var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max;
+		var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max);
+		popperOffsets[altAxis] = _preventedOffset;
+		data[altAxis] = _preventedOffset - _offset;
+	}
+	state.modifiersData[name] = data;
+}
+var preventOverflow_default;
+function init_preventOverflow() {
+	return (init_preventOverflow = __esmMin((() => {
+		init_enums();
+		init_within();
+		init_getLayoutRect();
+		init_getOffsetParent();
+		init_detectOverflow();
+		init_math();
+		preventOverflow_default = {
+			name: "preventOverflow",
+			enabled: true,
+			phase: "main",
+			fn: preventOverflow,
+			requiresIfExists: ["offset"]
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/getHTMLElementScroll.js
+function getHTMLElementScroll(element) {
+	return {
+		scrollLeft: element.scrollLeft,
+		scrollTop: element.scrollTop
+	};
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/getNodeScroll.js
+function getNodeScroll(node) {
+	if (node === getWindow(node) || !isHTMLElement(node)) return getWindowScroll(node);
+	else return getHTMLElementScroll(node);
+}
+function init_getNodeScroll() {
+	return (init_getNodeScroll = __esmMin((() => {
+		init_getWindowScroll();
+		init_instanceOf();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/dom-utils/getCompositeRect.js
+function isElementScaled(element) {
+	var rect = element.getBoundingClientRect();
+	var scaleX = round(rect.width) / element.offsetWidth || 1;
+	var scaleY = round(rect.height) / element.offsetHeight || 1;
+	return scaleX !== 1 || scaleY !== 1;
+}
+function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
+	if (isFixed === void 0) isFixed = false;
+	var isOffsetParentAnElement = isHTMLElement(offsetParent);
+	var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent);
+	var documentElement = getDocumentElement(offsetParent);
+	var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled, isFixed);
+	var scroll = {
+		scrollLeft: 0,
+		scrollTop: 0
+	};
+	var offsets = {
+		x: 0,
+		y: 0
+	};
+	if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+		if (getNodeName(offsetParent) !== "body" || isScrollParent(documentElement)) scroll = getNodeScroll(offsetParent);
+		if (isHTMLElement(offsetParent)) {
+			offsets = getBoundingClientRect(offsetParent, true);
+			offsets.x += offsetParent.clientLeft;
+			offsets.y += offsetParent.clientTop;
+		} else if (documentElement) offsets.x = getWindowScrollBarX(documentElement);
+	}
+	return {
+		x: rect.left + scroll.scrollLeft - offsets.x,
+		y: rect.top + scroll.scrollTop - offsets.y,
+		width: rect.width,
+		height: rect.height
+	};
+}
+function init_getCompositeRect() {
+	return (init_getCompositeRect = __esmMin((() => {
+		init_getBoundingClientRect();
+		init_getNodeScroll();
+		init_instanceOf();
+		init_getWindowScrollBarX();
+		init_getDocumentElement();
+		init_isScrollParent();
+		init_math();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/orderModifiers.js
+function order(modifiers) {
+	var map = /* @__PURE__ */ new Map();
+	var visited = /* @__PURE__ */ new Set();
+	var result = [];
+	modifiers.forEach(function(modifier) {
+		map.set(modifier.name, modifier);
+	});
+	function sort(modifier) {
+		visited.add(modifier.name);
+		[].concat(modifier.requires || [], modifier.requiresIfExists || []).forEach(function(dep) {
+			if (!visited.has(dep)) {
+				var depModifier = map.get(dep);
+				if (depModifier) sort(depModifier);
+			}
+		});
+		result.push(modifier);
+	}
+	modifiers.forEach(function(modifier) {
+		if (!visited.has(modifier.name)) sort(modifier);
+	});
+	return result;
+}
+function orderModifiers(modifiers) {
+	var orderedModifiers = order(modifiers);
+	return modifierPhases.reduce(function(acc, phase) {
+		return acc.concat(orderedModifiers.filter(function(modifier) {
+			return modifier.phase === phase;
+		}));
+	}, []);
+}
+function init_orderModifiers() {
+	return (init_orderModifiers = __esmMin((() => {
+		init_enums();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/debounce.js
+function debounce(fn) {
+	var pending;
+	return function() {
+		if (!pending) pending = new Promise(function(resolve) {
+			Promise.resolve().then(function() {
+				pending = void 0;
+				resolve(fn());
+			});
+		});
+		return pending;
+	};
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/utils/mergeByName.js
+function mergeByName(modifiers) {
+	var merged = modifiers.reduce(function(merged, current) {
+		var existing = merged[current.name];
+		merged[current.name] = existing ? Object.assign({}, existing, current, {
+			options: Object.assign({}, existing.options, current.options),
+			data: Object.assign({}, existing.data, current.data)
+		}) : current;
+		return merged;
+	}, {});
+	return Object.keys(merged).map(function(key) {
+		return merged[key];
+	});
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/createPopper.js
+function areValidElements() {
+	for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+	return !args.some(function(element) {
+		return !(element && typeof element.getBoundingClientRect === "function");
+	});
+}
+function popperGenerator(generatorOptions) {
+	if (generatorOptions === void 0) generatorOptions = {};
+	var _generatorOptions = generatorOptions, _generatorOptions$def = _generatorOptions.defaultModifiers, defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, _generatorOptions$def2 = _generatorOptions.defaultOptions, defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
+	return function createPopper(reference, popper, options) {
+		if (options === void 0) options = defaultOptions;
+		var state = {
+			placement: "bottom",
+			orderedModifiers: [],
+			options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions),
+			modifiersData: {},
+			elements: {
+				reference,
+				popper
+			},
+			attributes: {},
+			styles: {}
+		};
+		var effectCleanupFns = [];
+		var isDestroyed = false;
+		var instance = {
+			state,
+			setOptions: function setOptions(setOptionsAction) {
+				var options = typeof setOptionsAction === "function" ? setOptionsAction(state.options) : setOptionsAction;
+				cleanupModifierEffects();
+				state.options = Object.assign({}, defaultOptions, state.options, options);
+				state.scrollParents = {
+					reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [],
+					popper: listScrollParents(popper)
+				};
+				var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers, state.options.modifiers)));
+				state.orderedModifiers = orderedModifiers.filter(function(m) {
+					return m.enabled;
+				});
+				runModifierEffects();
+				return instance.update();
+			},
+			forceUpdate: function forceUpdate() {
+				if (isDestroyed) return;
+				var _state$elements = state.elements, reference = _state$elements.reference, popper = _state$elements.popper;
+				if (!areValidElements(reference, popper)) return;
+				state.rects = {
+					reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === "fixed"),
+					popper: getLayoutRect(popper)
+				};
+				state.reset = false;
+				state.placement = state.options.placement;
+				state.orderedModifiers.forEach(function(modifier) {
+					return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
+				});
+				for (var index = 0; index < state.orderedModifiers.length; index++) {
+					if (state.reset === true) {
+						state.reset = false;
+						index = -1;
+						continue;
+					}
+					var _state$orderedModifie = state.orderedModifiers[index], fn = _state$orderedModifie.fn, _state$orderedModifie2 = _state$orderedModifie.options, _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, name = _state$orderedModifie.name;
+					if (typeof fn === "function") state = fn({
+						state,
+						options: _options,
+						name,
+						instance
+					}) || state;
+				}
+			},
+			update: debounce(function() {
+				return new Promise(function(resolve) {
+					instance.forceUpdate();
+					resolve(state);
+				});
+			}),
+			destroy: function destroy() {
+				cleanupModifierEffects();
+				isDestroyed = true;
+			}
+		};
+		if (!areValidElements(reference, popper)) return instance;
+		instance.setOptions(options).then(function(state) {
+			if (!isDestroyed && options.onFirstUpdate) options.onFirstUpdate(state);
+		});
+		function runModifierEffects() {
+			state.orderedModifiers.forEach(function(_ref) {
+				var name = _ref.name, _ref$options = _ref.options, options = _ref$options === void 0 ? {} : _ref$options, effect = _ref.effect;
+				if (typeof effect === "function") {
+					var cleanupFn = effect({
+						state,
+						name,
+						instance,
+						options
+					});
+					effectCleanupFns.push(cleanupFn || function noopFn() {});
+				}
+			});
+		}
+		function cleanupModifierEffects() {
+			effectCleanupFns.forEach(function(fn) {
+				return fn();
+			});
+			effectCleanupFns = [];
+		}
+		return instance;
+	};
+}
+var DEFAULT_OPTIONS;
+function init_createPopper() {
+	return (init_createPopper = __esmMin((() => {
+		init_getCompositeRect();
+		init_getLayoutRect();
+		init_listScrollParents();
+		init_getOffsetParent();
+		init_orderModifiers();
+		init_instanceOf();
+		DEFAULT_OPTIONS = {
+			placement: "bottom",
+			modifiers: [],
+			strategy: "absolute"
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/popper.js
+var defaultModifiers, createPopper;
+function init_popper() {
+	return (init_popper = __esmMin((() => {
+		init_createPopper();
+		init_eventListeners();
+		init_popperOffsets();
+		init_computeStyles();
+		init_applyStyles();
+		init_offset();
+		init_flip();
+		init_preventOverflow();
+		init_arrow();
+		init_hide();
+		defaultModifiers = [
+			eventListeners_default,
+			popperOffsets_default,
+			computeStyles_default,
+			applyStyles_default,
+			offset_default,
+			flip_default,
+			preventOverflow_default,
+			arrow_default,
+			hide_default
+		];
+		createPopper = /*#__PURE__*/ popperGenerator({ defaultModifiers });
+	})))();
+}
+//#endregion
+export { init_popper as n, createPopper as t };