@lumx/react 4.17.1-alpha.2 → 4.17.1-alpha.3

package/_internal/node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.js

@@ -0,0 +1,209 @@
+import "../../utils/dist/floating-ui.utils.dom.js";
+import { computePosition, offset as offset$1 } from "../../dom/dist/floating-ui.dom.js";
+import * as React$1 from "react";
+import { useLayoutEffect } from "react";
+import * as ReactDOM$1 from "react-dom";
+//#region ../../node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs
+var index = typeof document !== "undefined" ? useLayoutEffect : function noop() {};
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (typeof a === "function" && a.toString() === b.toString()) return true;
+	let length;
+	let i;
+	let keys;
+	if (a && b && typeof a === "object") {
+		if (Array.isArray(a)) {
+			length = a.length;
+			if (length !== b.length) return false;
+			for (i = length; i-- !== 0;) if (!deepEqual(a[i], b[i])) return false;
+			return true;
+		}
+		keys = Object.keys(a);
+		length = keys.length;
+		if (length !== Object.keys(b).length) return false;
+		for (i = length; i-- !== 0;) if (!{}.hasOwnProperty.call(b, keys[i])) return false;
+		for (i = length; i-- !== 0;) {
+			const key = keys[i];
+			if (key === "_owner" && a.$$typeof) continue;
+			if (!deepEqual(a[key], b[key])) return false;
+		}
+		return true;
+	}
+	return a !== a && b !== b;
+}
+function getDPR(element) {
+	if (typeof window === "undefined") return 1;
+	return (element.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function roundByDPR(element, value) {
+	const dpr = getDPR(element);
+	return Math.round(value * dpr) / dpr;
+}
+function useLatestRef(value) {
+	const ref = React$1.useRef(value);
+	index(() => {
+		ref.current = value;
+	});
+	return ref;
+}
+/**
+* Provides data to position a floating element.
+* @see https://floating-ui.com/docs/useFloating
+*/
+function useFloating(options) {
+	if (options === void 0) options = {};
+	const { placement = "bottom", strategy = "absolute", middleware = [], platform, elements: { reference: externalReference, floating: externalFloating } = {}, transform = true, whileElementsMounted, open } = options;
+	const [data, setData] = React$1.useState({
+		x: 0,
+		y: 0,
+		strategy,
+		placement,
+		middlewareData: {},
+		isPositioned: false
+	});
+	const [latestMiddleware, setLatestMiddleware] = React$1.useState(middleware);
+	if (!deepEqual(latestMiddleware, middleware)) setLatestMiddleware(middleware);
+	const [_reference, _setReference] = React$1.useState(null);
+	const [_floating, _setFloating] = React$1.useState(null);
+	const setReference = React$1.useCallback((node) => {
+		if (node !== referenceRef.current) {
+			referenceRef.current = node;
+			_setReference(node);
+		}
+	}, []);
+	const setFloating = React$1.useCallback((node) => {
+		if (node !== floatingRef.current) {
+			floatingRef.current = node;
+			_setFloating(node);
+		}
+	}, []);
+	const referenceEl = externalReference || _reference;
+	const floatingEl = externalFloating || _floating;
+	const referenceRef = React$1.useRef(null);
+	const floatingRef = React$1.useRef(null);
+	const dataRef = React$1.useRef(data);
+	const hasWhileElementsMounted = whileElementsMounted != null;
+	const whileElementsMountedRef = useLatestRef(whileElementsMounted);
+	const platformRef = useLatestRef(platform);
+	const openRef = useLatestRef(open);
+	const update = React$1.useCallback(() => {
+		if (!referenceRef.current || !floatingRef.current) return;
+		const config = {
+			placement,
+			strategy,
+			middleware: latestMiddleware
+		};
+		if (platformRef.current) config.platform = platformRef.current;
+		computePosition(referenceRef.current, floatingRef.current, config).then((data) => {
+			const fullData = {
+				...data,
+				isPositioned: openRef.current !== false
+			};
+			if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
+				dataRef.current = fullData;
+				ReactDOM$1.flushSync(() => {
+					setData(fullData);
+				});
+			}
+		});
+	}, [
+		latestMiddleware,
+		placement,
+		strategy,
+		platformRef,
+		openRef
+	]);
+	index(() => {
+		if (open === false && dataRef.current.isPositioned) {
+			dataRef.current.isPositioned = false;
+			setData((data) => ({
+				...data,
+				isPositioned: false
+			}));
+		}
+	}, [open]);
+	const isMountedRef = React$1.useRef(false);
+	index(() => {
+		isMountedRef.current = true;
+		return () => {
+			isMountedRef.current = false;
+		};
+	}, []);
+	index(() => {
+		if (referenceEl) referenceRef.current = referenceEl;
+		if (floatingEl) floatingRef.current = floatingEl;
+		if (referenceEl && floatingEl) {
+			if (whileElementsMountedRef.current) return whileElementsMountedRef.current(referenceEl, floatingEl, update);
+			update();
+		}
+	}, [
+		referenceEl,
+		floatingEl,
+		update,
+		whileElementsMountedRef,
+		hasWhileElementsMounted
+	]);
+	const refs = React$1.useMemo(() => ({
+		reference: referenceRef,
+		floating: floatingRef,
+		setReference,
+		setFloating
+	}), [setReference, setFloating]);
+	const elements = React$1.useMemo(() => ({
+		reference: referenceEl,
+		floating: floatingEl
+	}), [referenceEl, floatingEl]);
+	const floatingStyles = React$1.useMemo(() => {
+		const initialStyles = {
+			position: strategy,
+			left: 0,
+			top: 0
+		};
+		if (!elements.floating) return initialStyles;
+		const x = roundByDPR(elements.floating, data.x);
+		const y = roundByDPR(elements.floating, data.y);
+		if (transform) return {
+			...initialStyles,
+			transform: "translate(" + x + "px, " + y + "px)",
+			...getDPR(elements.floating) >= 1.5 && { willChange: "transform" }
+		};
+		return {
+			position: strategy,
+			left: x,
+			top: y
+		};
+	}, [
+		strategy,
+		transform,
+		elements.floating,
+		data.x,
+		data.y
+	]);
+	return React$1.useMemo(() => ({
+		...data,
+		update,
+		refs,
+		elements,
+		floatingStyles
+	}), [
+		data,
+		update,
+		refs,
+		elements,
+		floatingStyles
+	]);
+}
+/**
+* Modifies the placement by translating the floating element along the
+* specified axes.
+* A number (shorthand for `mainAxis` or distance), or an axes configuration
+* object may be passed.
+* @see https://floating-ui.com/docs/offset
+*/
+var offset = (options, deps) => ({
+	...offset$1(options),
+	options: [options, deps]
+});
+//#endregion
+export { offset, useFloating };

package/_internal/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js

@@ -0,0 +1,144 @@
+//#region ../../node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
+function hasWindow() {
+	return typeof window !== "undefined";
+}
+function getNodeName(node) {
+	if (isNode(node)) return (node.nodeName || "").toLowerCase();
+	return "#document";
+}
+function getWindow(node) {
+	var _node$ownerDocument;
+	return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+	var _ref;
+	return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+	if (!hasWindow()) return false;
+	return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+	if (!hasWindow()) return false;
+	return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+	if (!hasWindow()) return false;
+	return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+	if (!hasWindow() || typeof ShadowRoot === "undefined") return false;
+	return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+var invalidOverflowDisplayValues = /*#__PURE__*/ new Set(["inline", "contents"]);
+function isOverflowElement(element) {
+	const { overflow, overflowX, overflowY, display } = getComputedStyle(element);
+	return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !invalidOverflowDisplayValues.has(display);
+}
+var tableElements = /*#__PURE__*/ new Set([
+	"table",
+	"td",
+	"th"
+]);
+function isTableElement(element) {
+	return tableElements.has(getNodeName(element));
+}
+var topLayerSelectors = [":popover-open", ":modal"];
+function isTopLayer(element) {
+	return topLayerSelectors.some((selector) => {
+		try {
+			return element.matches(selector);
+		} catch (_e) {
+			return false;
+		}
+	});
+}
+var transformProperties = [
+	"transform",
+	"translate",
+	"scale",
+	"rotate",
+	"perspective"
+];
+var willChangeValues = [
+	"transform",
+	"translate",
+	"scale",
+	"rotate",
+	"perspective",
+	"filter"
+];
+var containValues = [
+	"paint",
+	"layout",
+	"strict",
+	"content"
+];
+function isContainingBlock(elementOrCss) {
+	const webkit = isWebKit();
+	const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
+	return transformProperties.some((value) => css[value] ? css[value] !== "none" : false) || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || willChangeValues.some((value) => (css.willChange || "").includes(value)) || containValues.some((value) => (css.contain || "").includes(value));
+}
+function getContainingBlock(element) {
+	let currentNode = getParentNode(element);
+	while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+		if (isContainingBlock(currentNode)) return currentNode;
+		else if (isTopLayer(currentNode)) return null;
+		currentNode = getParentNode(currentNode);
+	}
+	return null;
+}
+function isWebKit() {
+	if (typeof CSS === "undefined" || !CSS.supports) return false;
+	return CSS.supports("-webkit-backdrop-filter", "none");
+}
+var lastTraversableNodeNames = /*#__PURE__*/ new Set([
+	"html",
+	"body",
+	"#document"
+]);
+function isLastTraversableNode(node) {
+	return lastTraversableNodeNames.has(getNodeName(node));
+}
+function getComputedStyle(element) {
+	return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+	if (isElement(element)) return {
+		scrollLeft: element.scrollLeft,
+		scrollTop: element.scrollTop
+	};
+	return {
+		scrollLeft: element.scrollX,
+		scrollTop: element.scrollY
+	};
+}
+function getParentNode(node) {
+	if (getNodeName(node) === "html") return node;
+	const result = node.assignedSlot || node.parentNode || isShadowRoot(node) && node.host || getDocumentElement(node);
+	return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+	const parentNode = getParentNode(node);
+	if (isLastTraversableNode(parentNode)) return node.ownerDocument ? node.ownerDocument.body : node.body;
+	if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) return parentNode;
+	return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+	var _node$ownerDocument2;
+	if (list === void 0) list = [];
+	if (traverseIframes === void 0) traverseIframes = true;
+	const scrollableAncestor = getNearestOverflowAncestor(node);
+	const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+	const win = getWindow(scrollableAncestor);
+	if (isBody) {
+		const frameElement = getFrameElement(win);
+		return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+	}
+	return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getFrameElement(win) {
+	return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+//#endregion
+export { getComputedStyle, getContainingBlock, getDocumentElement, getFrameElement, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isOverflowElement, isTableElement, isTopLayer, isWebKit };

package/_internal/node_modules/@floating-ui/utils/dist/floating-ui.utils.js

@@ -0,0 +1,135 @@
+//#region ../../node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
+/**
+* Custom positioning reference element.
+* @see https://floating-ui.com/docs/virtual-elements
+*/
+var sides = [
+	"top",
+	"right",
+	"bottom",
+	"left"
+];
+var alignments = ["start", "end"];
+var placements = /*#__PURE__*/ sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
+var min = Math.min;
+var max = Math.max;
+var round = Math.round;
+var floor = Math.floor;
+var createCoords = (v) => ({
+	x: v,
+	y: v
+});
+var oppositeSideMap = {
+	left: "right",
+	right: "left",
+	bottom: "top",
+	top: "bottom"
+};
+var oppositeAlignmentMap = {
+	start: "end",
+	end: "start"
+};
+function clamp(start, value, end) {
+	return max(start, min(value, end));
+}
+function evaluate(value, param) {
+	return typeof value === "function" ? value(param) : value;
+}
+function getSide(placement) {
+	return placement.split("-")[0];
+}
+function getAlignment(placement) {
+	return placement.split("-")[1];
+}
+function getOppositeAxis(axis) {
+	return axis === "x" ? "y" : "x";
+}
+function getAxisLength(axis) {
+	return axis === "y" ? "height" : "width";
+}
+var yAxisSides = /*#__PURE__*/ new Set(["top", "bottom"]);
+function getSideAxis(placement) {
+	return yAxisSides.has(getSide(placement)) ? "y" : "x";
+}
+function getAlignmentAxis(placement) {
+	return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+	if (rtl === void 0) rtl = false;
+	const alignment = getAlignment(placement);
+	const alignmentAxis = getAlignmentAxis(placement);
+	const length = getAxisLength(alignmentAxis);
+	let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
+	if (rects.reference[length] > rects.floating[length]) mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+	return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+	const oppositePlacement = getOppositePlacement(placement);
+	return [
+		getOppositeAlignmentPlacement(placement),
+		oppositePlacement,
+		getOppositeAlignmentPlacement(oppositePlacement)
+	];
+}
+function getOppositeAlignmentPlacement(placement) {
+	return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
+}
+var lrPlacement = ["left", "right"];
+var rlPlacement = ["right", "left"];
+var tbPlacement = ["top", "bottom"];
+var btPlacement = ["bottom", "top"];
+function getSideList(side, isStart, rtl) {
+	switch (side) {
+		case "top":
+		case "bottom":
+			if (rtl) return isStart ? rlPlacement : lrPlacement;
+			return isStart ? lrPlacement : rlPlacement;
+		case "left":
+		case "right": return isStart ? tbPlacement : btPlacement;
+		default: return [];
+	}
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+	const alignment = getAlignment(placement);
+	let list = getSideList(getSide(placement), direction === "start", rtl);
+	if (alignment) {
+		list = list.map((side) => side + "-" + alignment);
+		if (flipAlignment) list = list.concat(list.map(getOppositeAlignmentPlacement));
+	}
+	return list;
+}
+function getOppositePlacement(placement) {
+	return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
+}
+function expandPaddingObject(padding) {
+	return {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0,
+		...padding
+	};
+}
+function getPaddingObject(padding) {
+	return typeof padding !== "number" ? expandPaddingObject(padding) : {
+		top: padding,
+		right: padding,
+		bottom: padding,
+		left: padding
+	};
+}
+function rectToClientRect(rect) {
+	const { x, y, width, height } = rect;
+	return {
+		width,
+		height,
+		top: y,
+		left: x,
+		right: x + width,
+		bottom: y + height,
+		x,
+		y
+	};
+}
+//#endregion
+export { clamp, createCoords, evaluate, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round };

package/_internal/node_modules/body-scroll-lock/lib/bodyScrollLock.esm.js

@@ -0,0 +1,114 @@
+//#region ../../node_modules/body-scroll-lock/lib/bodyScrollLock.esm.js
+function _toConsumableArray(arr) {
+	if (Array.isArray(arr)) {
+		for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+		return arr2;
+	} else return Array.from(arr);
+}
+var hasPassiveEvents = false;
+if (typeof window !== "undefined") {
+	var passiveTestOptions = { get passive() {
+		hasPassiveEvents = true;
+	} };
+	window.addEventListener("testPassive", null, passiveTestOptions);
+	window.removeEventListener("testPassive", null, passiveTestOptions);
+}
+var isIosDevice = typeof window !== "undefined" && window.navigator && window.navigator.platform && (/iP(ad|hone|od)/.test(window.navigator.platform) || window.navigator.platform === "MacIntel" && window.navigator.maxTouchPoints > 1);
+var locks = [];
+var documentListenerAdded = false;
+var initialClientY = -1;
+var previousBodyOverflowSetting = void 0;
+var previousBodyPaddingRight = void 0;
+var allowTouchMove = function allowTouchMove(el) {
+	return locks.some(function(lock) {
+		if (lock.options.allowTouchMove && lock.options.allowTouchMove(el)) return true;
+		return false;
+	});
+};
+var preventDefault = function preventDefault(rawEvent) {
+	var e = rawEvent || window.event;
+	if (allowTouchMove(e.target)) return true;
+	if (e.touches.length > 1) return true;
+	if (e.preventDefault) e.preventDefault();
+	return false;
+};
+var setOverflowHidden = function setOverflowHidden(options) {
+	if (previousBodyPaddingRight === void 0) {
+		var _reserveScrollBarGap = !!options && options.reserveScrollBarGap === true;
+		var scrollBarGap = window.innerWidth - document.documentElement.clientWidth;
+		if (_reserveScrollBarGap && scrollBarGap > 0) {
+			previousBodyPaddingRight = document.body.style.paddingRight;
+			document.body.style.paddingRight = scrollBarGap + "px";
+		}
+	}
+	if (previousBodyOverflowSetting === void 0) {
+		previousBodyOverflowSetting = document.body.style.overflow;
+		document.body.style.overflow = "hidden";
+	}
+};
+var restoreOverflowSetting = function restoreOverflowSetting() {
+	if (previousBodyPaddingRight !== void 0) {
+		document.body.style.paddingRight = previousBodyPaddingRight;
+		previousBodyPaddingRight = void 0;
+	}
+	if (previousBodyOverflowSetting !== void 0) {
+		document.body.style.overflow = previousBodyOverflowSetting;
+		previousBodyOverflowSetting = void 0;
+	}
+};
+var isTargetElementTotallyScrolled = function isTargetElementTotallyScrolled(targetElement) {
+	return targetElement ? targetElement.scrollHeight - targetElement.scrollTop <= targetElement.clientHeight : false;
+};
+var handleScroll = function handleScroll(event, targetElement) {
+	var clientY = event.targetTouches[0].clientY - initialClientY;
+	if (allowTouchMove(event.target)) return false;
+	if (targetElement && targetElement.scrollTop === 0 && clientY > 0) return preventDefault(event);
+	if (isTargetElementTotallyScrolled(targetElement) && clientY < 0) return preventDefault(event);
+	event.stopPropagation();
+	return true;
+};
+var disableBodyScroll = function disableBodyScroll(targetElement, options) {
+	if (!targetElement) {
+		console.error("disableBodyScroll unsuccessful - targetElement must be provided when calling disableBodyScroll on IOS devices.");
+		return;
+	}
+	if (locks.some(function(lock) {
+		return lock.targetElement === targetElement;
+	})) return;
+	var lock = {
+		targetElement,
+		options: options || {}
+	};
+	locks = [].concat(_toConsumableArray(locks), [lock]);
+	if (isIosDevice) {
+		targetElement.ontouchstart = function(event) {
+			if (event.targetTouches.length === 1) initialClientY = event.targetTouches[0].clientY;
+		};
+		targetElement.ontouchmove = function(event) {
+			if (event.targetTouches.length === 1) handleScroll(event, targetElement);
+		};
+		if (!documentListenerAdded) {
+			document.addEventListener("touchmove", preventDefault, hasPassiveEvents ? { passive: false } : void 0);
+			documentListenerAdded = true;
+		}
+	} else setOverflowHidden(options);
+};
+var enableBodyScroll = function enableBodyScroll(targetElement) {
+	if (!targetElement) {
+		console.error("enableBodyScroll unsuccessful - targetElement must be provided when calling enableBodyScroll on IOS devices.");
+		return;
+	}
+	locks = locks.filter(function(lock) {
+		return lock.targetElement !== targetElement;
+	});
+	if (isIosDevice) {
+		targetElement.ontouchstart = null;
+		targetElement.ontouchmove = null;
+		if (documentListenerAdded && locks.length === 0) {
+			document.removeEventListener("touchmove", preventDefault, hasPassiveEvents ? { passive: false } : void 0);
+			documentListenerAdded = false;
+		}
+	} else if (!locks.length) restoreOverflowSetting();
+};
+//#endregion
+export { disableBodyScroll, enableBodyScroll };

package/_internal/node_modules/classnames/index.js

@@ -0,0 +1,45 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/classnames/index.js
+var require_classnames = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/*!
+	Copyright (c) 2018 Jed Watson.
+	Licensed under the MIT License (MIT), see
+	http://jedwatson.github.io/classnames
+	*/
+	(function() {
+		"use strict";
+		var hasOwn = {}.hasOwnProperty;
+		function classNames() {
+			var classes = [];
+			for (var i = 0; i < arguments.length; i++) {
+				var arg = arguments[i];
+				if (!arg) continue;
+				var argType = typeof arg;
+				if (argType === "string" || argType === "number") classes.push(arg);
+				else if (Array.isArray(arg)) {
+					if (arg.length) {
+						var inner = classNames.apply(null, arg);
+						if (inner) classes.push(inner);
+					}
+				} else if (argType === "object") {
+					if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes("[native code]")) {
+						classes.push(arg.toString());
+						continue;
+					}
+					for (var key in arg) if (hasOwn.call(arg, key) && arg[key]) classes.push(key);
+				}
+			}
+			return classes.join(" ");
+		}
+		if (typeof module !== "undefined" && module.exports) {
+			classNames.default = classNames;
+			module.exports = classNames;
+		} else if (typeof define === "function" && typeof define.amd === "object" && define.amd) define("classnames", [], function() {
+			return classNames;
+		});
+		else window.classNames = classNames;
+	})();
+}));
+//#endregion
+export default require_classnames();
+export { require_classnames };

package/_internal/packages/lumx-core/src/js/components/AlertDialog/index.d.ts

@@ -0,0 +1,15 @@
+import { Kind } from "../../constants/enums/index.js";
+import { JSXElement } from "../../types/JSXElement.js";
+//#region ../lumx-core/src/js/components/AlertDialog/index.d.ts
+interface BaseAlertDialogProps {
+  /** Message variant. */
+  kind?: Kind;
+  /** Dialog title. */
+  title?: string;
+  /**
+   * Children
+   */
+  children?: JSXElement;
+}
+//#endregion
+export { BaseAlertDialogProps };