claude-mux 0.7.0

package/dist/web/server/chunks/alert-dialog-description-DDA6u-nS.js

@@ -0,0 +1,2890 @@
+import { Z as props_id, b as bind_props, k as derived, lt as spread_props, t as ATTACHMENT_KEY, w as clsx, y as attributes } from "./index2-BQnysSj-.js";
+import { T as setContext, c as getAllContexts, f as hasContext, l as getContext, t as clsx$1, x as run } from "./clsx-FzI4_gi0.js";
+import { r as on } from "./events-BDBlYddw.js";
+import { c as tick, l as unmount, r as mount } from "./sessions.svelte-Ds82MvkB.js";
+import { n as buttonVariants, r as cn } from "./button-D6xS9rHt.js";
+
+//#region ../node_modules/tabbable/dist/index.esm.js
+/*!
+* tabbable 6.4.0
+* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
+*/
+var candidateSelectors = [
+	"input:not([inert]):not([inert] *)",
+	"select:not([inert]):not([inert] *)",
+	"textarea:not([inert]):not([inert] *)",
+	"a[href]:not([inert]):not([inert] *)",
+	"button:not([inert]):not([inert] *)",
+	"[tabindex]:not(slot):not([inert]):not([inert] *)",
+	"audio[controls]:not([inert]):not([inert] *)",
+	"video[controls]:not([inert]):not([inert] *)",
+	"[contenteditable]:not([contenteditable=\"false\"]):not([inert]):not([inert] *)",
+	"details>summary:first-of-type:not([inert]):not([inert] *)",
+	"details:not([inert]):not([inert] *)"
+];
+var candidateSelector = /* @__PURE__ */ candidateSelectors.join(",");
+var NoElement = typeof Element === "undefined";
+var matches = NoElement ? function() {} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
+var getRootNode = !NoElement && Element.prototype.getRootNode ? function(element) {
+	var _element$getRootNode;
+	return element === null || element === void 0 ? void 0 : (_element$getRootNode = element.getRootNode) === null || _element$getRootNode === void 0 ? void 0 : _element$getRootNode.call(element);
+} : function(element) {
+	return element === null || element === void 0 ? void 0 : element.ownerDocument;
+};
+/**
+* Determines if a node is inert or in an inert ancestor.
+* @param {Node} [node]
+* @param {boolean} [lookUp] If true and `node` is not inert, looks up at ancestors to
+*  see if any of them are inert. If false, only `node` itself is considered.
+* @returns {boolean} True if inert itself or by way of being in an inert ancestor.
+*  False if `node` is falsy.
+*/
+var _isInert = function isInert(node, lookUp) {
+	var _node$getAttribute;
+	if (lookUp === void 0) lookUp = true;
+	var inertAtt = node === null || node === void 0 ? void 0 : (_node$getAttribute = node.getAttribute) === null || _node$getAttribute === void 0 ? void 0 : _node$getAttribute.call(node, "inert");
+	return inertAtt === "" || inertAtt === "true" || lookUp && node && (typeof node.closest === "function" ? node.closest("[inert]") : _isInert(node.parentNode));
+};
+/**
+* Determines if a node's content is editable.
+* @param {Element} [node]
+* @returns True if it's content-editable; false if it's not or `node` is falsy.
+*/
+var isContentEditable = function isContentEditable(node) {
+	var _node$getAttribute2;
+	var attValue = node === null || node === void 0 ? void 0 : (_node$getAttribute2 = node.getAttribute) === null || _node$getAttribute2 === void 0 ? void 0 : _node$getAttribute2.call(node, "contenteditable");
+	return attValue === "" || attValue === "true";
+};
+/**
+* @param {Element} el container to check in
+* @param {boolean} includeContainer add container to check
+* @param {(node: Element) => boolean} filter filter candidates
+* @returns {Element[]}
+*/
+var getCandidates = function getCandidates(el, includeContainer, filter) {
+	if (_isInert(el)) return [];
+	var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));
+	if (includeContainer && matches.call(el, candidateSelector)) candidates.unshift(el);
+	candidates = candidates.filter(filter);
+	return candidates;
+};
+/**
+* @callback GetShadowRoot
+* @param {Element} element to check for shadow root
+* @returns {ShadowRoot|boolean} ShadowRoot if available or boolean indicating if a shadowRoot is attached but not available.
+*/
+/**
+* @callback ShadowRootFilter
+* @param {Element} shadowHostNode the element which contains shadow content
+* @returns {boolean} true if a shadow root could potentially contain valid candidates.
+*/
+/**
+* @typedef {Object} CandidateScope
+* @property {Element} scopeParent contains inner candidates
+* @property {Element[]} candidates list of candidates found in the scope parent
+*/
+/**
+* @typedef {Object} IterativeOptions
+* @property {GetShadowRoot|boolean} getShadowRoot true if shadow support is enabled; falsy if not;
+*  if a function, implies shadow support is enabled and either returns the shadow root of an element
+*  or a boolean stating if it has an undisclosed shadow root
+* @property {(node: Element) => boolean} filter filter candidates
+* @property {boolean} flatten if true then result will flatten any CandidateScope into the returned list
+* @property {ShadowRootFilter} shadowRootFilter filter shadow roots;
+*/
+/**
+* @param {Element[]} elements list of element containers to match candidates from
+* @param {boolean} includeContainer add container list to check
+* @param {IterativeOptions} options
+* @returns {Array.<Element|CandidateScope>}
+*/
+var _getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {
+	var candidates = [];
+	var elementsToCheck = Array.from(elements);
+	while (elementsToCheck.length) {
+		var element = elementsToCheck.shift();
+		if (_isInert(element, false)) continue;
+		if (element.tagName === "SLOT") {
+			var assigned = element.assignedElements();
+			var nestedCandidates = _getCandidatesIteratively(assigned.length ? assigned : element.children, true, options);
+			if (options.flatten) candidates.push.apply(candidates, nestedCandidates);
+			else candidates.push({
+				scopeParent: element,
+				candidates: nestedCandidates
+			});
+		} else {
+			if (matches.call(element, candidateSelector) && options.filter(element) && (includeContainer || !elements.includes(element))) candidates.push(element);
+			var shadowRoot = element.shadowRoot || typeof options.getShadowRoot === "function" && options.getShadowRoot(element);
+			var validShadowRoot = !_isInert(shadowRoot, false) && (!options.shadowRootFilter || options.shadowRootFilter(element));
+			if (shadowRoot && validShadowRoot) {
+				var _nestedCandidates = _getCandidatesIteratively(shadowRoot === true ? element.children : shadowRoot.children, true, options);
+				if (options.flatten) candidates.push.apply(candidates, _nestedCandidates);
+				else candidates.push({
+					scopeParent: element,
+					candidates: _nestedCandidates
+				});
+			} else elementsToCheck.unshift.apply(elementsToCheck, element.children);
+		}
+	}
+	return candidates;
+};
+/**
+* @private
+* Determines if the node has an explicitly specified `tabindex` attribute.
+* @param {HTMLElement} node
+* @returns {boolean} True if so; false if not.
+*/
+var hasTabIndex = function hasTabIndex(node) {
+	return !isNaN(parseInt(node.getAttribute("tabindex"), 10));
+};
+/**
+* Determine the tab index of a given node.
+* @param {HTMLElement} node
+* @returns {number} Tab order (negative, 0, or positive number).
+* @throws {Error} If `node` is falsy.
+*/
+var getTabIndex = function getTabIndex(node) {
+	if (!node) throw new Error("No node provided");
+	if (node.tabIndex < 0) {
+		if ((/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || isContentEditable(node)) && !hasTabIndex(node)) return 0;
+	}
+	return node.tabIndex;
+};
+/**
+* Determine the tab index of a given node __for sort order purposes__.
+* @param {HTMLElement} node
+* @param {boolean} [isScope] True for a custom element with shadow root or slot that, by default,
+*  has tabIndex -1, but needs to be sorted by document order in order for its content to be
+*  inserted into the correct sort position.
+* @returns {number} Tab order (negative, 0, or positive number).
+*/
+var getSortOrderTabIndex = function getSortOrderTabIndex(node, isScope) {
+	var tabIndex = getTabIndex(node);
+	if (tabIndex < 0 && isScope && !hasTabIndex(node)) return 0;
+	return tabIndex;
+};
+var sortOrderedTabbables = function sortOrderedTabbables(a, b) {
+	return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;
+};
+var isInput = function isInput(node) {
+	return node.tagName === "INPUT";
+};
+var isHiddenInput = function isHiddenInput(node) {
+	return isInput(node) && node.type === "hidden";
+};
+var isDetailsWithSummary = function isDetailsWithSummary(node) {
+	return node.tagName === "DETAILS" && Array.prototype.slice.apply(node.children).some(function(child) {
+		return child.tagName === "SUMMARY";
+	});
+};
+var getCheckedRadio = function getCheckedRadio(nodes, form) {
+	for (var i = 0; i < nodes.length; i++) if (nodes[i].checked && nodes[i].form === form) return nodes[i];
+};
+var isTabbableRadio = function isTabbableRadio(node) {
+	if (!node.name) return true;
+	var radioScope = node.form || getRootNode(node);
+	var queryRadios = function queryRadios(name) {
+		return radioScope.querySelectorAll("input[type=\"radio\"][name=\"" + name + "\"]");
+	};
+	var radioSet;
+	if (typeof window !== "undefined" && typeof window.CSS !== "undefined" && typeof window.CSS.escape === "function") radioSet = queryRadios(window.CSS.escape(node.name));
+	else try {
+		radioSet = queryRadios(node.name);
+	} catch (err) {
+		console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", err.message);
+		return false;
+	}
+	var checked = getCheckedRadio(radioSet, node.form);
+	return !checked || checked === node;
+};
+var isRadio = function isRadio(node) {
+	return isInput(node) && node.type === "radio";
+};
+var isNonTabbableRadio = function isNonTabbableRadio(node) {
+	return isRadio(node) && !isTabbableRadio(node);
+};
+var isNodeAttached = function isNodeAttached(node) {
+	var _nodeRoot;
+	var nodeRoot = node && getRootNode(node);
+	var nodeRootHost = (_nodeRoot = nodeRoot) === null || _nodeRoot === void 0 ? void 0 : _nodeRoot.host;
+	var attached = false;
+	if (nodeRoot && nodeRoot !== node) {
+		var _nodeRootHost, _nodeRootHost$ownerDo, _node$ownerDocument;
+		attached = !!((_nodeRootHost = nodeRootHost) !== null && _nodeRootHost !== void 0 && (_nodeRootHost$ownerDo = _nodeRootHost.ownerDocument) !== null && _nodeRootHost$ownerDo !== void 0 && _nodeRootHost$ownerDo.contains(nodeRootHost) || node !== null && node !== void 0 && (_node$ownerDocument = node.ownerDocument) !== null && _node$ownerDocument !== void 0 && _node$ownerDocument.contains(node));
+		while (!attached && nodeRootHost) {
+			var _nodeRoot2, _nodeRootHost2, _nodeRootHost2$ownerD;
+			nodeRoot = getRootNode(nodeRootHost);
+			nodeRootHost = (_nodeRoot2 = nodeRoot) === null || _nodeRoot2 === void 0 ? void 0 : _nodeRoot2.host;
+			attached = !!((_nodeRootHost2 = nodeRootHost) !== null && _nodeRootHost2 !== void 0 && (_nodeRootHost2$ownerD = _nodeRootHost2.ownerDocument) !== null && _nodeRootHost2$ownerD !== void 0 && _nodeRootHost2$ownerD.contains(nodeRootHost));
+		}
+	}
+	return attached;
+};
+var isZeroArea = function isZeroArea(node) {
+	var _node$getBoundingClie = node.getBoundingClientRect(), width = _node$getBoundingClie.width, height = _node$getBoundingClie.height;
+	return width === 0 && height === 0;
+};
+var isHidden = function isHidden(node, _ref) {
+	var displayCheck = _ref.displayCheck, getShadowRoot = _ref.getShadowRoot;
+	if (displayCheck === "full-native") {
+		if ("checkVisibility" in node) return !node.checkVisibility({
+			checkOpacity: false,
+			opacityProperty: false,
+			contentVisibilityAuto: true,
+			visibilityProperty: true,
+			checkVisibilityCSS: true
+		});
+	}
+	if (getComputedStyle(node).visibility === "hidden") return true;
+	var nodeUnderDetails = matches.call(node, "details>summary:first-of-type") ? node.parentElement : node;
+	if (matches.call(nodeUnderDetails, "details:not([open]) *")) return true;
+	if (!displayCheck || displayCheck === "full" || displayCheck === "full-native" || displayCheck === "legacy-full") {
+		if (typeof getShadowRoot === "function") {
+			var originalNode = node;
+			while (node) {
+				var parentElement = node.parentElement;
+				var rootNode = getRootNode(node);
+				if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true) return isZeroArea(node);
+				else if (node.assignedSlot) node = node.assignedSlot;
+				else if (!parentElement && rootNode !== node.ownerDocument) node = rootNode.host;
+				else node = parentElement;
+			}
+			node = originalNode;
+		}
+		if (isNodeAttached(node)) return !node.getClientRects().length;
+		if (displayCheck !== "legacy-full") return true;
+	} else if (displayCheck === "non-zero-area") return isZeroArea(node);
+	return false;
+};
+var isDisabledFromFieldset = function isDisabledFromFieldset(node) {
+	if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {
+		var parentNode = node.parentElement;
+		while (parentNode) {
+			if (parentNode.tagName === "FIELDSET" && parentNode.disabled) {
+				for (var i = 0; i < parentNode.children.length; i++) {
+					var child = parentNode.children.item(i);
+					if (child.tagName === "LEGEND") return matches.call(parentNode, "fieldset[disabled] *") ? true : !child.contains(node);
+				}
+				return true;
+			}
+			parentNode = parentNode.parentElement;
+		}
+	}
+	return false;
+};
+var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable(options, node) {
+	if (node.disabled || isHiddenInput(node) || isHidden(node, options) || isDetailsWithSummary(node) || isDisabledFromFieldset(node)) return false;
+	return true;
+};
+var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable(options, node) {
+	if (isNonTabbableRadio(node) || getTabIndex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) return false;
+	return true;
+};
+var isShadowRootTabbable = function isShadowRootTabbable(shadowHostNode) {
+	var tabIndex = parseInt(shadowHostNode.getAttribute("tabindex"), 10);
+	if (isNaN(tabIndex) || tabIndex >= 0) return true;
+	return false;
+};
+/**
+* @param {Array.<Element|CandidateScope>} candidates
+* @returns Element[]
+*/
+var _sortByOrder = function sortByOrder(candidates) {
+	var regularTabbables = [];
+	var orderedTabbables = [];
+	candidates.forEach(function(item, i) {
+		var isScope = !!item.scopeParent;
+		var element = isScope ? item.scopeParent : item;
+		var candidateTabindex = getSortOrderTabIndex(element, isScope);
+		var elements = isScope ? _sortByOrder(item.candidates) : element;
+		if (candidateTabindex === 0) isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element);
+		else orderedTabbables.push({
+			documentOrder: i,
+			tabIndex: candidateTabindex,
+			item,
+			isScope,
+			content: elements
+		});
+	});
+	return orderedTabbables.sort(sortOrderedTabbables).reduce(function(acc, sortable) {
+		sortable.isScope ? acc.push.apply(acc, sortable.content) : acc.push(sortable.content);
+		return acc;
+	}, []).concat(regularTabbables);
+};
+var tabbable = function tabbable(container, options) {
+	options = options || {};
+	var candidates;
+	if (options.getShadowRoot) candidates = _getCandidatesIteratively([container], options.includeContainer, {
+		filter: isNodeMatchingSelectorTabbable.bind(null, options),
+		flatten: false,
+		getShadowRoot: options.getShadowRoot,
+		shadowRootFilter: isShadowRootTabbable
+	});
+	else candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
+	return _sortByOrder(candidates);
+};
+var focusable = function focusable(container, options) {
+	options = options || {};
+	var candidates;
+	if (options.getShadowRoot) candidates = _getCandidatesIteratively([container], options.includeContainer, {
+		filter: isNodeMatchingSelectorFocusable.bind(null, options),
+		flatten: true,
+		getShadowRoot: options.getShadowRoot
+	});
+	else candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));
+	return candidates;
+};
+var focusableCandidateSelector = /* @__PURE__ */ candidateSelectors.concat("iframe:not([inert]):not([inert] *)").join(",");
+var isFocusable = function isFocusable(node, options) {
+	options = options || {};
+	if (!node) throw new Error("No node provided");
+	if (matches.call(node, focusableCandidateSelector) === false) return false;
+	return isNodeMatchingSelectorFocusable(options, node);
+};
+
+//#endregion
+//#region ../node_modules/inline-style-parser/esm/index.mjs
+var COMMENT_REGEX = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g;
+var NEWLINE_REGEX = /\n/g;
+var WHITESPACE_REGEX = /^\s*/;
+var PROPERTY_REGEX = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/;
+var COLON_REGEX = /^:\s*/;
+var VALUE_REGEX = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/;
+var SEMICOLON_REGEX = /^[;\s]*/;
+var TRIM_REGEX = /^\s+|\s+$/g;
+var NEWLINE = "\n";
+var FORWARD_SLASH = "/";
+var ASTERISK = "*";
+var EMPTY_STRING = "";
+var TYPE_COMMENT = "comment";
+var TYPE_DECLARATION = "declaration";
+/**
+* @param {String} style
+* @param {Object} [options]
+* @return {Object[]}
+* @throws {TypeError}
+* @throws {Error}
+*/
+function index(style, options) {
+	if (typeof style !== "string") throw new TypeError("First argument must be a string");
+	if (!style) return [];
+	options = options || {};
+	/**
+	* Positional.
+	*/
+	var lineno = 1;
+	var column = 1;
+	/**
+	* Update lineno and column based on `str`.
+	*
+	* @param {String} str
+	*/
+	function updatePosition(str) {
+		var lines = str.match(NEWLINE_REGEX);
+		if (lines) lineno += lines.length;
+		var i = str.lastIndexOf(NEWLINE);
+		column = ~i ? str.length - i : column + str.length;
+	}
+	/**
+	* Mark position and patch `node.position`.
+	*
+	* @return {Function}
+	*/
+	function position() {
+		var start = {
+			line: lineno,
+			column
+		};
+		return function(node) {
+			node.position = new Position(start);
+			whitespace();
+			return node;
+		};
+	}
+	/**
+	* Store position information for a node.
+	*
+	* @constructor
+	* @property {Object} start
+	* @property {Object} end
+	* @property {undefined|String} source
+	*/
+	function Position(start) {
+		this.start = start;
+		this.end = {
+			line: lineno,
+			column
+		};
+		this.source = options.source;
+	}
+	/**
+	* Non-enumerable source string.
+	*/
+	Position.prototype.content = style;
+	/**
+	* Error `msg`.
+	*
+	* @param {String} msg
+	* @throws {Error}
+	*/
+	function error(msg) {
+		var err = /* @__PURE__ */ new Error(options.source + ":" + lineno + ":" + column + ": " + msg);
+		err.reason = msg;
+		err.filename = options.source;
+		err.line = lineno;
+		err.column = column;
+		err.source = style;
+		if (options.silent);
+		else throw err;
+	}
+	/**
+	* Match `re` and return captures.
+	*
+	* @param {RegExp} re
+	* @return {undefined|Array}
+	*/
+	function match(re) {
+		var m = re.exec(style);
+		if (!m) return;
+		var str = m[0];
+		updatePosition(str);
+		style = style.slice(str.length);
+		return m;
+	}
+	/**
+	* Parse whitespace.
+	*/
+	function whitespace() {
+		match(WHITESPACE_REGEX);
+	}
+	/**
+	* Parse comments.
+	*
+	* @param {Object[]} [rules]
+	* @return {Object[]}
+	*/
+	function comments(rules) {
+		var c;
+		rules = rules || [];
+		while (c = comment()) if (c !== false) rules.push(c);
+		return rules;
+	}
+	/**
+	* Parse comment.
+	*
+	* @return {Object}
+	* @throws {Error}
+	*/
+	function comment() {
+		var pos = position();
+		if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1)) return;
+		var i = 2;
+		while (EMPTY_STRING != style.charAt(i) && (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))) ++i;
+		i += 2;
+		if (EMPTY_STRING === style.charAt(i - 1)) return error("End of comment missing");
+		var str = style.slice(2, i - 2);
+		column += 2;
+		updatePosition(str);
+		style = style.slice(i);
+		column += 2;
+		return pos({
+			type: TYPE_COMMENT,
+			comment: str
+		});
+	}
+	/**
+	* Parse declaration.
+	*
+	* @return {Object}
+	* @throws {Error}
+	*/
+	function declaration() {
+		var pos = position();
+		var prop = match(PROPERTY_REGEX);
+		if (!prop) return;
+		comment();
+		if (!match(COLON_REGEX)) return error("property missing ':'");
+		var val = match(VALUE_REGEX);
+		var ret = pos({
+			type: TYPE_DECLARATION,
+			property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),
+			value: val ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING)) : EMPTY_STRING
+		});
+		match(SEMICOLON_REGEX);
+		return ret;
+	}
+	/**
+	* Parse declarations.
+	*
+	* @return {Object[]}
+	*/
+	function declarations() {
+		var decls = [];
+		comments(decls);
+		var decl;
+		while (decl = declaration()) if (decl !== false) {
+			decls.push(decl);
+			comments(decls);
+		}
+		return decls;
+	}
+	whitespace();
+	return declarations();
+}
+/**
+* Trim `str`.
+*
+* @param {String} str
+* @return {String}
+*/
+function trim(str) {
+	return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;
+}
+
+//#endregion
+//#region ../node_modules/style-to-object/esm/index.mjs
+/**
+* Parses inline style to object.
+*
+* @param style - Inline style.
+* @param iterator - Iterator.
+* @returns - Style object or null.
+*
+* @example Parsing inline style to object:
+*
+* ```js
+* import parse from 'style-to-object';
+* parse('line-height: 42;'); // { 'line-height': '42' }
+* ```
+*/
+function StyleToObject(style, iterator) {
+	let styleObject = null;
+	if (!style || typeof style !== "string") return styleObject;
+	const declarations = index(style);
+	const hasIterator = typeof iterator === "function";
+	declarations.forEach((declaration) => {
+		if (declaration.type !== "declaration") return;
+		const { property, value } = declaration;
+		if (hasIterator) iterator(property, value, declaration);
+		else if (value) {
+			styleObject = styleObject || {};
+			styleObject[property] = value;
+		}
+	});
+	return styleObject;
+}
+
+//#endregion
+//#region .svelte-kit/adapter-bun/chunks/alert-dialog-description.js
+function createAttachmentKey() {
+	return Symbol(ATTACHMENT_KEY);
+}
+function isObject(value) {
+	return value !== null && typeof value === "object";
+}
+const CLASS_VALUE_PRIMITIVE_TYPES = [
+	"string",
+	"number",
+	"bigint",
+	"boolean"
+];
+function isClassValue(value) {
+	if (value === null || value === void 0) return true;
+	if (CLASS_VALUE_PRIMITIVE_TYPES.includes(typeof value)) return true;
+	if (Array.isArray(value)) return value.every((item) => isClassValue(item));
+	if (typeof value === "object") {
+		if (Object.getPrototypeOf(value) !== Object.prototype) return false;
+		return true;
+	}
+	return false;
+}
+const BoxSymbol = /* @__PURE__ */ Symbol("box");
+const isWritableSymbol = /* @__PURE__ */ Symbol("is-writable");
+function boxWith(getter, setter) {
+	const derived2 = getter();
+	if (setter) return {
+		[BoxSymbol]: true,
+		[isWritableSymbol]: true,
+		get current() {
+			return derived2;
+		},
+		set current(v) {
+			setter(v);
+		}
+	};
+	return {
+		[BoxSymbol]: true,
+		get current() {
+			return getter();
+		}
+	};
+}
+function isBox(value) {
+	return isObject(value) && BoxSymbol in value;
+}
+function simpleBox(initialValue) {
+	let current = initialValue;
+	return {
+		[BoxSymbol]: true,
+		[isWritableSymbol]: true,
+		get current() {
+			return current;
+		},
+		set current(v) {
+			current = v;
+		}
+	};
+}
+function composeHandlers(...handlers) {
+	return function(e) {
+		for (const handler of handlers) {
+			if (!handler) continue;
+			if (e.defaultPrevented) return;
+			if (typeof handler === "function") handler.call(this, e);
+			else handler.current?.call(this, e);
+		}
+	};
+}
+const NUMBER_CHAR_RE = /\d/;
+const STR_SPLITTERS = [
+	"-",
+	"_",
+	"/",
+	"."
+];
+function isUppercase(char = "") {
+	if (NUMBER_CHAR_RE.test(char)) return void 0;
+	return char !== char.toLowerCase();
+}
+function splitByCase(str) {
+	const parts = [];
+	let buff = "";
+	let previousUpper;
+	let previousSplitter;
+	for (const char of str) {
+		const isSplitter = STR_SPLITTERS.includes(char);
+		if (isSplitter === true) {
+			parts.push(buff);
+			buff = "";
+			previousUpper = void 0;
+			continue;
+		}
+		const isUpper = isUppercase(char);
+		if (previousSplitter === false) {
+			if (previousUpper === false && isUpper === true) {
+				parts.push(buff);
+				buff = char;
+				previousUpper = isUpper;
+				continue;
+			}
+			if (previousUpper === true && isUpper === false && buff.length > 1) {
+				const lastChar = buff.at(-1);
+				parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+				buff = lastChar + char;
+				previousUpper = isUpper;
+				continue;
+			}
+		}
+		buff += char;
+		previousUpper = isUpper;
+		previousSplitter = isSplitter;
+	}
+	parts.push(buff);
+	return parts;
+}
+function pascalCase(str) {
+	if (!str) return "";
+	return splitByCase(str).map((p) => upperFirst(p)).join("");
+}
+function camelCase(str) {
+	return lowerFirst(pascalCase(str || ""));
+}
+function upperFirst(str) {
+	return str ? str[0].toUpperCase() + str.slice(1) : "";
+}
+function lowerFirst(str) {
+	return str ? str[0].toLowerCase() + str.slice(1) : "";
+}
+function cssToStyleObj(css) {
+	if (!css) return {};
+	const styleObj = {};
+	function iterator(name, value) {
+		if (name.startsWith("-moz-") || name.startsWith("-webkit-") || name.startsWith("-ms-") || name.startsWith("-o-")) {
+			styleObj[pascalCase(name)] = value;
+			return;
+		}
+		if (name.startsWith("--")) {
+			styleObj[name] = value;
+			return;
+		}
+		styleObj[camelCase(name)] = value;
+	}
+	StyleToObject(css, iterator);
+	return styleObj;
+}
+function executeCallbacks(...callbacks) {
+	return (...args) => {
+		for (const callback of callbacks) if (typeof callback === "function") callback(...args);
+	};
+}
+function createParser(matcher, replacer) {
+	const regex = RegExp(matcher, "g");
+	return (str) => {
+		if (typeof str !== "string") throw new TypeError(`expected an argument of type string, but got ${typeof str}`);
+		if (!str.match(regex)) return str;
+		return str.replace(regex, replacer);
+	};
+}
+const camelToKebab = createParser(/[A-Z]/, (match) => `-${match.toLowerCase()}`);
+function styleToCSS(styleObj) {
+	if (!styleObj || typeof styleObj !== "object" || Array.isArray(styleObj)) throw new TypeError(`expected an argument of type object, but got ${typeof styleObj}`);
+	return Object.keys(styleObj).map((property) => `${camelToKebab(property)}: ${styleObj[property]};`).join("\n");
+}
+function styleToString(style = {}) {
+	return styleToCSS(style).replace("\n", " ");
+}
+const EVENT_LIST_SET = new Set([
+	"onabort",
+	"onanimationcancel",
+	"onanimationend",
+	"onanimationiteration",
+	"onanimationstart",
+	"onauxclick",
+	"onbeforeinput",
+	"onbeforetoggle",
+	"onblur",
+	"oncancel",
+	"oncanplay",
+	"oncanplaythrough",
+	"onchange",
+	"onclick",
+	"onclose",
+	"oncompositionend",
+	"oncompositionstart",
+	"oncompositionupdate",
+	"oncontextlost",
+	"oncontextmenu",
+	"oncontextrestored",
+	"oncopy",
+	"oncuechange",
+	"oncut",
+	"ondblclick",
+	"ondrag",
+	"ondragend",
+	"ondragenter",
+	"ondragleave",
+	"ondragover",
+	"ondragstart",
+	"ondrop",
+	"ondurationchange",
+	"onemptied",
+	"onended",
+	"onerror",
+	"onfocus",
+	"onfocusin",
+	"onfocusout",
+	"onformdata",
+	"ongotpointercapture",
+	"oninput",
+	"oninvalid",
+	"onkeydown",
+	"onkeypress",
+	"onkeyup",
+	"onload",
+	"onloadeddata",
+	"onloadedmetadata",
+	"onloadstart",
+	"onlostpointercapture",
+	"onmousedown",
+	"onmouseenter",
+	"onmouseleave",
+	"onmousemove",
+	"onmouseout",
+	"onmouseover",
+	"onmouseup",
+	"onpaste",
+	"onpause",
+	"onplay",
+	"onplaying",
+	"onpointercancel",
+	"onpointerdown",
+	"onpointerenter",
+	"onpointerleave",
+	"onpointermove",
+	"onpointerout",
+	"onpointerover",
+	"onpointerup",
+	"onprogress",
+	"onratechange",
+	"onreset",
+	"onresize",
+	"onscroll",
+	"onscrollend",
+	"onsecuritypolicyviolation",
+	"onseeked",
+	"onseeking",
+	"onselect",
+	"onselectionchange",
+	"onselectstart",
+	"onslotchange",
+	"onstalled",
+	"onsubmit",
+	"onsuspend",
+	"ontimeupdate",
+	"ontoggle",
+	"ontouchcancel",
+	"ontouchend",
+	"ontouchmove",
+	"ontouchstart",
+	"ontransitioncancel",
+	"ontransitionend",
+	"ontransitionrun",
+	"ontransitionstart",
+	"onvolumechange",
+	"onwaiting",
+	"onwebkitanimationend",
+	"onwebkitanimationiteration",
+	"onwebkitanimationstart",
+	"onwebkittransitionend",
+	"onwheel"
+]);
+function isEventHandler(key) {
+	return EVENT_LIST_SET.has(key);
+}
+function mergeProps(...args) {
+	const result = { ...args[0] };
+	for (let i = 1; i < args.length; i++) {
+		const props = args[i];
+		if (!props) continue;
+		for (const key of Object.keys(props)) {
+			const a = result[key];
+			const b = props[key];
+			const aIsFunction = typeof a === "function";
+			const bIsFunction = typeof b === "function";
+			if (aIsFunction && typeof bIsFunction && isEventHandler(key)) result[key] = composeHandlers(a, b);
+			else if (aIsFunction && bIsFunction) result[key] = executeCallbacks(a, b);
+			else if (key === "class") {
+				const aIsClassValue = isClassValue(a);
+				const bIsClassValue = isClassValue(b);
+				if (aIsClassValue && bIsClassValue) result[key] = clsx$1(a, b);
+				else if (aIsClassValue) result[key] = clsx$1(a);
+				else if (bIsClassValue) result[key] = clsx$1(b);
+			} else if (key === "style") {
+				const aIsObject = typeof a === "object";
+				const bIsObject = typeof b === "object";
+				const aIsString = typeof a === "string";
+				const bIsString = typeof b === "string";
+				if (aIsObject && bIsObject) result[key] = {
+					...a,
+					...b
+				};
+				else if (aIsObject && bIsString) {
+					const parsedStyle = cssToStyleObj(b);
+					result[key] = {
+						...a,
+						...parsedStyle
+					};
+				} else if (aIsString && bIsObject) result[key] = {
+					...cssToStyleObj(a),
+					...b
+				};
+				else if (aIsString && bIsString) {
+					const parsedStyleA = cssToStyleObj(a);
+					const parsedStyleB = cssToStyleObj(b);
+					result[key] = {
+						...parsedStyleA,
+						...parsedStyleB
+					};
+				} else if (aIsObject) result[key] = a;
+				else if (bIsObject) result[key] = b;
+				else if (aIsString) result[key] = a;
+				else if (bIsString) result[key] = b;
+			} else result[key] = b !== void 0 ? b : a;
+		}
+		for (const key of Object.getOwnPropertySymbols(props)) {
+			const a = result[key];
+			const b = props[key];
+			result[key] = b !== void 0 ? b : a;
+		}
+	}
+	if (typeof result.style === "object") result.style = styleToString(result.style).replaceAll("\n", " ");
+	if (result.hidden === false) {
+		result.hidden = void 0;
+		delete result.hidden;
+	}
+	if (result.disabled === false) {
+		result.disabled = void 0;
+		delete result.disabled;
+	}
+	return result;
+}
+const defaultWindow = void 0;
+function getActiveElement$1(document2) {
+	let activeElement = document2.activeElement;
+	while (activeElement?.shadowRoot) {
+		const node = activeElement.shadowRoot.activeElement;
+		if (node === activeElement) break;
+		else activeElement = node;
+	}
+	return activeElement;
+}
+const SvelteMap = globalThis.Map;
+function createSubscriber(_) {
+	return () => {};
+}
+var ActiveElement = class {
+	#document;
+	#subscribe;
+	constructor(options = {}) {
+		const { window: window2 = defaultWindow, document: document2 = window2?.document } = options;
+		if (window2 === void 0) return;
+		this.#document = document2;
+		this.#subscribe = createSubscriber();
+	}
+	get current() {
+		this.#subscribe?.();
+		if (!this.#document) return null;
+		return getActiveElement$1(this.#document);
+	}
+};
+new ActiveElement();
+var Context = class {
+	#name;
+	#key;
+	/**
+	* @param name The name of the context.
+	* This is used for generating the context key and error messages.
+	*/
+	constructor(name) {
+		this.#name = name;
+		this.#key = Symbol(name);
+	}
+	/**
+	* The key used to get and set the context.
+	*
+	* It is not recommended to use this value directly.
+	* Instead, use the methods provided by this class.
+	*/
+	get key() {
+		return this.#key;
+	}
+	/**
+	* Checks whether this has been set in the context of a parent component.
+	*
+	* Must be called during component initialisation.
+	*/
+	exists() {
+		return hasContext(this.#key);
+	}
+	/**
+	* Retrieves the context that belongs to the closest parent component.
+	*
+	* Must be called during component initialisation.
+	*
+	* @throws An error if the context does not exist.
+	*/
+	get() {
+		const context = getContext(this.#key);
+		if (context === void 0) throw new Error(`Context "${this.#name}" not found`);
+		return context;
+	}
+	/**
+	* Retrieves the context that belongs to the closest parent component,
+	* or the given fallback value if the context does not exist.
+	*
+	* Must be called during component initialisation.
+	*/
+	getOr(fallback) {
+		const context = getContext(this.#key);
+		if (context === void 0) return fallback;
+		return context;
+	}
+	/**
+	* Associates the given value with the current component and returns it.
+	*
+	* Must be called during component initialisation.
+	*/
+	set(context) {
+		return setContext(this.#key, context);
+	}
+};
+function runWatcher(sources, flush, effect, options = {}) {
+	const { lazy = false } = options;
+}
+function watch(sources, effect, options) {
+	runWatcher(sources, "post", effect, options);
+}
+function watchPre(sources, effect, options) {
+	runWatcher(sources, "pre", effect, options);
+}
+watch.pre = watchPre;
+function afterSleep(ms, cb) {
+	return setTimeout(cb, ms);
+}
+function afterTick(fn) {
+	tick().then(fn);
+}
+const ELEMENT_NODE = 1;
+const DOCUMENT_NODE = 9;
+const DOCUMENT_FRAGMENT_NODE = 11;
+function isHTMLElement$1(node) {
+	return isObject(node) && node.nodeType === ELEMENT_NODE && typeof node.nodeName === "string";
+}
+function isDocument(node) {
+	return isObject(node) && node.nodeType === DOCUMENT_NODE;
+}
+function isWindow(node) {
+	return isObject(node) && node.constructor?.name === "VisualViewport";
+}
+function isNode(node) {
+	return isObject(node) && node.nodeType !== void 0;
+}
+function isShadowRoot(node) {
+	return isNode(node) && node.nodeType === DOCUMENT_FRAGMENT_NODE && "host" in node;
+}
+function contains(parent, child) {
+	if (!parent || !child) return false;
+	if (!isHTMLElement$1(parent) || !isHTMLElement$1(child)) return false;
+	const rootNode = child.getRootNode?.();
+	if (parent === child) return true;
+	if (parent.contains(child)) return true;
+	if (rootNode && isShadowRoot(rootNode)) {
+		let next = child;
+		while (next) {
+			if (parent === next) return true;
+			next = next.parentNode || next.host;
+		}
+	}
+	return false;
+}
+function getDocument(node) {
+	if (isDocument(node)) return node;
+	if (isWindow(node)) return node.document;
+	return node?.ownerDocument ?? document;
+}
+function getActiveElement(rootNode) {
+	let activeElement = rootNode.activeElement;
+	while (activeElement?.shadowRoot) {
+		const el = activeElement.shadowRoot.activeElement;
+		if (el === activeElement) break;
+		else activeElement = el;
+	}
+	return activeElement;
+}
+var DOMContext = class {
+	element;
+	#root = derived(() => {
+		if (!this.element.current) return document;
+		return this.element.current.getRootNode() ?? document;
+	});
+	get root() {
+		return this.#root();
+	}
+	set root($$value) {
+		return this.#root($$value);
+	}
+	constructor(element) {
+		if (typeof element === "function") this.element = boxWith(element);
+		else this.element = element;
+	}
+	getDocument = () => {
+		return getDocument(this.root);
+	};
+	getWindow = () => {
+		return this.getDocument().defaultView ?? window;
+	};
+	getActiveElement = () => {
+		return getActiveElement(this.root);
+	};
+	isActiveElement = (node) => {
+		return node === this.getActiveElement();
+	};
+	getElementById(id) {
+		return this.root.getElementById(id);
+	}
+	querySelector = (selector) => {
+		if (!this.root) return null;
+		return this.root.querySelector(selector);
+	};
+	querySelectorAll = (selector) => {
+		if (!this.root) return [];
+		return this.root.querySelectorAll(selector);
+	};
+	setTimeout = (callback, delay) => {
+		return this.getWindow().setTimeout(callback, delay);
+	};
+	clearTimeout = (timeoutId) => {
+		return this.getWindow().clearTimeout(timeoutId);
+	};
+};
+function attachRef(ref, onChange) {
+	return { [createAttachmentKey()]: (node) => {
+		if (isBox(ref)) {
+			ref.current = node;
+			run(() => onChange?.(node));
+			return () => {
+				if ("isConnected" in node && node.isConnected) return;
+				ref.current = null;
+				onChange?.(null);
+			};
+		}
+		ref(node);
+		run(() => onChange?.(node));
+		return () => {
+			if ("isConnected" in node && node.isConnected) return;
+			ref(null);
+			onChange?.(null);
+		};
+	} };
+}
+function boolToStr(condition) {
+	return condition ? "true" : "false";
+}
+function boolToEmptyStrOrUndef(condition) {
+	return condition ? "" : void 0;
+}
+function getDataOpenClosed(condition) {
+	return condition ? "open" : "closed";
+}
+function getAriaChecked(checked, indeterminate) {
+	if (indeterminate) return "mixed";
+	return checked ? "true" : "false";
+}
+var BitsAttrs = class {
+	#variant;
+	#prefix;
+	attrs;
+	constructor(config) {
+		this.#variant = config.getVariant ? config.getVariant() : null;
+		this.#prefix = this.#variant ? `data-${this.#variant}-` : `data-${config.component}-`;
+		this.getAttr = this.getAttr.bind(this);
+		this.selector = this.selector.bind(this);
+		this.attrs = Object.fromEntries(config.parts.map((part) => [part, this.getAttr(part)]));
+	}
+	getAttr(part, variantOverride) {
+		if (variantOverride) return `data-${variantOverride}-${part}`;
+		return `${this.#prefix}${part}`;
+	}
+	selector(part, variantOverride) {
+		return `[${this.getAttr(part, variantOverride)}]`;
+	}
+};
+function createBitsAttrs(config) {
+	const bitsAttrs = new BitsAttrs(config);
+	return {
+		...bitsAttrs.attrs,
+		selector: bitsAttrs.selector,
+		getAttr: bitsAttrs.getAttr
+	};
+}
+const ENTER = "Enter";
+const ESCAPE = "Escape";
+const SPACE = " ";
+const isBrowser = typeof document !== "undefined";
+const isIOS = getIsIOS();
+function getIsIOS() {
+	return isBrowser && window?.navigator?.userAgent && (/iP(ad|hone|od)/.test(window.navigator.userAgent) || window?.navigator?.maxTouchPoints > 2 && /iPad|Macintosh/.test(window?.navigator.userAgent));
+}
+function isHTMLElement(element) {
+	return element instanceof HTMLElement;
+}
+function isElementOrSVGElement(element) {
+	return element instanceof Element || element instanceof SVGElement;
+}
+var AnimationsComplete = class {
+	#opts;
+	#currentFrame = null;
+	constructor(opts) {
+		this.#opts = opts;
+	}
+	#cleanup() {
+		if (!this.#currentFrame) return;
+		window.cancelAnimationFrame(this.#currentFrame);
+		this.#currentFrame = null;
+	}
+	run(fn) {
+		this.#cleanup();
+		const node = this.#opts.ref.current;
+		if (!node) return;
+		if (typeof node.getAnimations !== "function") {
+			this.#executeCallback(fn);
+			return;
+		}
+		this.#currentFrame = window.requestAnimationFrame(() => {
+			const animations = node.getAnimations();
+			if (animations.length === 0) {
+				this.#executeCallback(fn);
+				return;
+			}
+			Promise.allSettled(animations.map((animation) => animation.finished)).then(() => {
+				this.#executeCallback(fn);
+			});
+		});
+	}
+	#executeCallback(fn) {
+		const execute = () => {
+			fn();
+		};
+		if (this.#opts.afterTick) afterTick(execute);
+		else execute();
+	}
+};
+var PresenceManager = class {
+	#opts;
+	#enabled;
+	#afterAnimations;
+	#shouldRender = false;
+	constructor(opts) {
+		this.#opts = opts;
+		this.#shouldRender = opts.open.current;
+		this.#enabled = opts.enabled ?? true;
+		this.#afterAnimations = new AnimationsComplete({
+			ref: this.#opts.ref,
+			afterTick: this.#opts.open
+		});
+		watch(() => this.#opts.open.current, (isOpen) => {
+			if (isOpen) this.#shouldRender = true;
+			if (!this.#enabled) return;
+			this.#afterAnimations.run(() => {
+				if (isOpen === this.#opts.open.current) {
+					if (!this.#opts.open.current) this.#shouldRender = false;
+					this.#opts.onComplete?.();
+				}
+			});
+		});
+	}
+	get shouldRender() {
+		return this.#shouldRender;
+	}
+};
+function noop() {}
+function createId(prefixOrUid, uid) {
+	return `bits-${prefixOrUid}`;
+}
+const dialogAttrs = createBitsAttrs({
+	component: "dialog",
+	parts: [
+		"content",
+		"trigger",
+		"overlay",
+		"title",
+		"description",
+		"close",
+		"cancel",
+		"action"
+	]
+});
+const DialogRootContext = new Context("Dialog.Root | AlertDialog.Root");
+var DialogRootState = class DialogRootState {
+	static create(opts) {
+		const parent = DialogRootContext.getOr(null);
+		return DialogRootContext.set(new DialogRootState(opts, parent));
+	}
+	opts;
+	triggerNode = null;
+	contentNode = null;
+	overlayNode = null;
+	descriptionNode = null;
+	contentId = void 0;
+	titleId = void 0;
+	triggerId = void 0;
+	descriptionId = void 0;
+	cancelNode = null;
+	nestedOpenCount = 0;
+	depth;
+	parent;
+	contentPresence;
+	overlayPresence;
+	constructor(opts, parent) {
+		this.opts = opts;
+		this.parent = parent;
+		this.depth = parent ? parent.depth + 1 : 0;
+		this.handleOpen = this.handleOpen.bind(this);
+		this.handleClose = this.handleClose.bind(this);
+		this.contentPresence = new PresenceManager({
+			ref: boxWith(() => this.contentNode),
+			open: this.opts.open,
+			enabled: true,
+			onComplete: () => {
+				this.opts.onOpenChangeComplete.current(this.opts.open.current);
+			}
+		});
+		this.overlayPresence = new PresenceManager({
+			ref: boxWith(() => this.overlayNode),
+			open: this.opts.open,
+			enabled: true
+		});
+		watch(() => this.opts.open.current, (isOpen) => {
+			if (!this.parent) return;
+			if (isOpen) this.parent.incrementNested();
+			else this.parent.decrementNested();
+		}, { lazy: true });
+	}
+	handleOpen() {
+		if (this.opts.open.current) return;
+		this.opts.open.current = true;
+	}
+	handleClose() {
+		if (!this.opts.open.current) return;
+		this.opts.open.current = false;
+	}
+	getBitsAttr = (part) => {
+		return dialogAttrs.getAttr(part, this.opts.variant.current);
+	};
+	incrementNested() {
+		this.nestedOpenCount++;
+		this.parent?.incrementNested();
+	}
+	decrementNested() {
+		if (this.nestedOpenCount === 0) return;
+		this.nestedOpenCount--;
+		this.parent?.decrementNested();
+	}
+	#sharedProps = derived(() => ({ "data-state": getDataOpenClosed(this.opts.open.current) }));
+	get sharedProps() {
+		return this.#sharedProps();
+	}
+	set sharedProps($$value) {
+		return this.#sharedProps($$value);
+	}
+};
+var DialogCloseState = class DialogCloseState {
+	static create(opts) {
+		return new DialogCloseState(opts, DialogRootContext.get());
+	}
+	opts;
+	root;
+	attachment;
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.attachment = attachRef(this.opts.ref);
+		this.onclick = this.onclick.bind(this);
+		this.onkeydown = this.onkeydown.bind(this);
+	}
+	onclick(e) {
+		if (this.opts.disabled.current) return;
+		if (e.button > 0) return;
+		this.root.handleClose();
+	}
+	onkeydown(e) {
+		if (this.opts.disabled.current) return;
+		if (e.key === SPACE || e.key === ENTER) {
+			e.preventDefault();
+			this.root.handleClose();
+		}
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		[this.root.getBitsAttr(this.opts.variant.current)]: "",
+		onclick: this.onclick,
+		onkeydown: this.onkeydown,
+		disabled: this.opts.disabled.current ? true : void 0,
+		tabindex: 0,
+		...this.root.sharedProps,
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+var DialogActionState = class DialogActionState {
+	static create(opts) {
+		return new DialogActionState(opts, DialogRootContext.get());
+	}
+	opts;
+	root;
+	attachment;
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.attachment = attachRef(this.opts.ref);
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		[this.root.getBitsAttr("action")]: "",
+		...this.root.sharedProps,
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+var DialogTitleState = class DialogTitleState {
+	static create(opts) {
+		return new DialogTitleState(opts, DialogRootContext.get());
+	}
+	opts;
+	root;
+	attachment;
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.root.titleId = this.opts.id.current;
+		this.attachment = attachRef(this.opts.ref);
+		watch.pre(() => this.opts.id.current, (id) => {
+			this.root.titleId = id;
+		});
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		role: "heading",
+		"aria-level": this.opts.level.current,
+		[this.root.getBitsAttr("title")]: "",
+		...this.root.sharedProps,
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+var DialogDescriptionState = class DialogDescriptionState {
+	static create(opts) {
+		return new DialogDescriptionState(opts, DialogRootContext.get());
+	}
+	opts;
+	root;
+	attachment;
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.root.descriptionId = this.opts.id.current;
+		this.attachment = attachRef(this.opts.ref, (v) => {
+			this.root.descriptionNode = v;
+		});
+		watch.pre(() => this.opts.id.current, (id) => {
+			this.root.descriptionId = id;
+		});
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		[this.root.getBitsAttr("description")]: "",
+		...this.root.sharedProps,
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+var DialogContentState = class DialogContentState {
+	static create(opts) {
+		return new DialogContentState(opts, DialogRootContext.get());
+	}
+	opts;
+	root;
+	attachment;
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.attachment = attachRef(this.opts.ref, (v) => {
+			this.root.contentNode = v;
+			this.root.contentId = v?.id;
+		});
+	}
+	#snippetProps = derived(() => ({ open: this.root.opts.open.current }));
+	get snippetProps() {
+		return this.#snippetProps();
+	}
+	set snippetProps($$value) {
+		return this.#snippetProps($$value);
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		role: this.root.opts.variant.current === "alert-dialog" ? "alertdialog" : "dialog",
+		"aria-modal": "true",
+		"aria-describedby": this.root.descriptionId,
+		"aria-labelledby": this.root.titleId,
+		[this.root.getBitsAttr("content")]: "",
+		style: {
+			pointerEvents: "auto",
+			outline: this.root.opts.variant.current === "alert-dialog" ? "none" : void 0,
+			"--bits-dialog-depth": this.root.depth,
+			"--bits-dialog-nested-count": this.root.nestedOpenCount
+		},
+		tabindex: this.root.opts.variant.current === "alert-dialog" ? -1 : void 0,
+		"data-nested-open": boolToEmptyStrOrUndef(this.root.nestedOpenCount > 0),
+		"data-nested": boolToEmptyStrOrUndef(this.root.parent !== null),
+		...this.root.sharedProps,
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+	get shouldRender() {
+		return this.root.contentPresence.shouldRender;
+	}
+};
+var DialogOverlayState = class DialogOverlayState {
+	static create(opts) {
+		return new DialogOverlayState(opts, DialogRootContext.get());
+	}
+	opts;
+	root;
+	attachment;
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.attachment = attachRef(this.opts.ref, (v) => this.root.overlayNode = v);
+	}
+	#snippetProps = derived(() => ({ open: this.root.opts.open.current }));
+	get snippetProps() {
+		return this.#snippetProps();
+	}
+	set snippetProps($$value) {
+		return this.#snippetProps($$value);
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		[this.root.getBitsAttr("overlay")]: "",
+		style: {
+			pointerEvents: "auto",
+			"--bits-dialog-depth": this.root.depth,
+			"--bits-dialog-nested-count": this.root.nestedOpenCount
+		},
+		"data-nested-open": boolToEmptyStrOrUndef(this.root.nestedOpenCount > 0),
+		"data-nested": boolToEmptyStrOrUndef(this.root.parent !== null),
+		...this.root.sharedProps,
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+	get shouldRender() {
+		return this.root.overlayPresence.shouldRender;
+	}
+};
+var AlertDialogCancelState = class AlertDialogCancelState {
+	static create(opts) {
+		return new AlertDialogCancelState(opts, DialogRootContext.get());
+	}
+	opts;
+	root;
+	attachment;
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.attachment = attachRef(this.opts.ref, (v) => this.root.cancelNode = v);
+		this.onclick = this.onclick.bind(this);
+		this.onkeydown = this.onkeydown.bind(this);
+	}
+	onclick(e) {
+		if (this.opts.disabled.current) return;
+		if (e.button > 0) return;
+		this.root.handleClose();
+	}
+	onkeydown(e) {
+		if (this.opts.disabled.current) return;
+		if (e.key === SPACE || e.key === ENTER) {
+			e.preventDefault();
+			this.root.handleClose();
+		}
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		[this.root.getBitsAttr("cancel")]: "",
+		onclick: this.onclick,
+		onkeydown: this.onkeydown,
+		tabindex: 0,
+		...this.root.sharedProps,
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+function Alert_dialog$1($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		let { open = false, onOpenChange = noop, onOpenChangeComplete = noop, children } = $$props;
+		DialogRootState.create({
+			variant: boxWith(() => "alert-dialog"),
+			open: boxWith(() => open, (v) => {
+				open = v;
+				onOpenChange(v);
+			}),
+			onOpenChangeComplete: boxWith(() => onOpenChangeComplete)
+		});
+		children?.($$renderer2);
+		$$renderer2.push(`<!---->`);
+		bind_props($$props, { open });
+	});
+}
+function Dialog_title($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		const uid = props_id($$renderer2);
+		let { id = createId(uid), ref = null, child, children, level = 2, $$slots, $$events, ...restProps } = $$props;
+		const mergedProps = mergeProps(restProps, DialogTitleState.create({
+			id: boxWith(() => id),
+			level: boxWith(() => level),
+			ref: boxWith(() => ref, (v) => ref = v)
+		}).props);
+		if (child) {
+			$$renderer2.push("<!--[-->");
+			child($$renderer2, { props: mergedProps });
+			$$renderer2.push(`<!---->`);
+		} else {
+			$$renderer2.push("<!--[!-->");
+			$$renderer2.push(`<div${attributes({ ...mergedProps })}>`);
+			children?.($$renderer2);
+			$$renderer2.push(`<!----></div>`);
+		}
+		$$renderer2.push(`<!--]-->`);
+		bind_props($$props, { ref });
+	});
+}
+function Alert_dialog_action$1($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		const uid = props_id($$renderer2);
+		let { children, child, id = createId(uid), ref = null, $$slots, $$events, ...restProps } = $$props;
+		const mergedProps = mergeProps(restProps, DialogActionState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v)
+		}).props);
+		if (child) {
+			$$renderer2.push("<!--[-->");
+			child($$renderer2, { props: mergedProps });
+			$$renderer2.push(`<!---->`);
+		} else {
+			$$renderer2.push("<!--[!-->");
+			$$renderer2.push(`<button${attributes({ ...mergedProps })}>`);
+			children?.($$renderer2);
+			$$renderer2.push(`<!----></button>`);
+		}
+		$$renderer2.push(`<!--]-->`);
+		bind_props($$props, { ref });
+	});
+}
+function Alert_dialog_cancel$1($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		const uid = props_id($$renderer2);
+		let { id = createId(uid), ref = null, children, child, disabled = false, $$slots, $$events, ...restProps } = $$props;
+		const mergedProps = mergeProps(restProps, AlertDialogCancelState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v),
+			disabled: boxWith(() => Boolean(disabled))
+		}).props);
+		if (child) {
+			$$renderer2.push("<!--[-->");
+			child($$renderer2, { props: mergedProps });
+			$$renderer2.push(`<!---->`);
+		} else {
+			$$renderer2.push("<!--[!-->");
+			$$renderer2.push(`<button${attributes({ ...mergedProps })}>`);
+			children?.($$renderer2);
+			$$renderer2.push(`<!----></button>`);
+		}
+		$$renderer2.push(`<!--]-->`);
+		bind_props($$props, { ref });
+	});
+}
+const BitsConfigContext = new Context("BitsConfig");
+function getBitsConfig() {
+	const fallback = new BitsConfigState(null, {});
+	return BitsConfigContext.getOr(fallback).opts;
+}
+var BitsConfigState = class {
+	opts;
+	constructor(parent, opts) {
+		const resolveConfigOption = createConfigResolver(parent, opts);
+		this.opts = {
+			defaultPortalTo: resolveConfigOption((config) => config.defaultPortalTo),
+			defaultLocale: resolveConfigOption((config) => config.defaultLocale)
+		};
+	}
+};
+function createConfigResolver(parent, currentOpts) {
+	return (getter) => {
+		return boxWith(() => {
+			const value = getter(currentOpts)?.current;
+			if (value !== void 0) return value;
+			if (parent === null) return void 0;
+			return getter(parent.opts)?.current;
+		});
+	};
+}
+function createPropResolver(configOption, fallback) {
+	return (getProp) => {
+		const config = getBitsConfig();
+		return boxWith(() => {
+			const propValue = getProp();
+			if (propValue !== void 0) return propValue;
+			const option = configOption(config).current;
+			if (option !== void 0) return option;
+			return fallback;
+		});
+	};
+}
+const resolvePortalToProp = createPropResolver((config) => config.defaultPortalTo, "body");
+function Portal($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		let { to: toProp, children, disabled } = $$props;
+		const to = resolvePortalToProp(() => toProp);
+		getAllContexts();
+		let target = getTarget();
+		function getTarget() {
+			if (!isBrowser || disabled) return null;
+			let localTarget = null;
+			if (typeof to.current === "string") localTarget = document.querySelector(to.current);
+			else localTarget = to.current;
+			return localTarget;
+		}
+		let instance;
+		function unmountInstance() {
+			if (instance) {
+				unmount();
+				instance = null;
+			}
+		}
+		watch([() => target, () => disabled], ([target2, disabled2]) => {
+			if (!target2 || disabled2) {
+				unmountInstance();
+				return;
+			}
+			instance = mount();
+			return () => {
+				unmountInstance();
+			};
+		});
+		if (disabled) {
+			$$renderer2.push("<!--[-->");
+			children?.($$renderer2);
+			$$renderer2.push(`<!---->`);
+		} else $$renderer2.push("<!--[!-->");
+		$$renderer2.push(`<!--]-->`);
+	});
+}
+function debounce(fn, wait = 500) {
+	let timeout = null;
+	const debounced = (...args) => {
+		if (timeout !== null) clearTimeout(timeout);
+		timeout = setTimeout(() => {
+			fn(...args);
+		}, wait);
+	};
+	debounced.destroy = () => {
+		if (timeout !== null) {
+			clearTimeout(timeout);
+			timeout = null;
+		}
+	};
+	return debounced;
+}
+function isOrContainsTarget(node, target) {
+	return node === target || node.contains(target);
+}
+function getOwnerDocument(el) {
+	return el?.ownerDocument ?? document;
+}
+function isClickTrulyOutside(event, contentNode) {
+	const { clientX, clientY } = event;
+	const rect = contentNode.getBoundingClientRect();
+	return clientX < rect.left || clientX > rect.right || clientY < rect.top || clientY > rect.bottom;
+}
+const CONTEXT_MENU_TRIGGER_ATTR = "data-context-menu-trigger";
+const CONTEXT_MENU_CONTENT_ATTR = "data-context-menu-content";
+createBitsAttrs({
+	component: "menu",
+	parts: [
+		"trigger",
+		"content",
+		"sub-trigger",
+		"item",
+		"group",
+		"group-heading",
+		"checkbox-group",
+		"checkbox-item",
+		"radio-group",
+		"radio-item",
+		"separator",
+		"sub-content",
+		"arrow"
+	]
+});
+globalThis.bitsDismissableLayers ??= /* @__PURE__ */ new Map();
+var DismissibleLayerState = class DismissibleLayerState {
+	static create(opts) {
+		return new DismissibleLayerState(opts);
+	}
+	opts;
+	#interactOutsideProp;
+	#behaviorType;
+	#interceptedEvents = { pointerdown: false };
+	#isResponsibleLayer = false;
+	#isFocusInsideDOMTree = false;
+	#documentObj = void 0;
+	#onFocusOutside;
+	#unsubClickListener = noop;
+	constructor(opts) {
+		this.opts = opts;
+		this.#behaviorType = opts.interactOutsideBehavior;
+		this.#interactOutsideProp = opts.onInteractOutside;
+		this.#onFocusOutside = opts.onFocusOutside;
+		let unsubEvents = noop;
+		const cleanup = () => {
+			this.#resetState();
+			globalThis.bitsDismissableLayers.delete(this);
+			this.#handleInteractOutside.destroy();
+			unsubEvents();
+		};
+		watch([() => this.opts.enabled.current, () => this.opts.ref.current], () => {
+			if (!this.opts.enabled.current || !this.opts.ref.current) return;
+			afterSleep(1, () => {
+				if (!this.opts.ref.current) return;
+				globalThis.bitsDismissableLayers.set(this, this.#behaviorType);
+				unsubEvents();
+				unsubEvents = this.#addEventListeners();
+			});
+			return cleanup;
+		});
+	}
+	#handleFocus = (event) => {
+		if (event.defaultPrevented) return;
+		if (!this.opts.ref.current) return;
+		afterTick(() => {
+			if (!this.opts.ref.current || this.#isTargetWithinLayer(event.target)) return;
+			if (event.target && !this.#isFocusInsideDOMTree) this.#onFocusOutside.current?.(event);
+		});
+	};
+	#addEventListeners() {
+		return executeCallbacks(
+			/**
+			* CAPTURE INTERACTION START
+			* mark interaction-start event as intercepted.
+			* mark responsible layer during interaction start
+			* to avoid checking if is responsible layer during interaction end
+			* when a new floating element may have been opened.
+			*/
+			on(this.#documentObj, "pointerdown", executeCallbacks(this.#markInterceptedEvent, this.#markResponsibleLayer), { capture: true }),
+			/**
+			* BUBBLE INTERACTION START
+			* Mark interaction-start event as non-intercepted. Debounce `onInteractOutsideStart`
+			* to avoid prematurely checking if other events were intercepted.
+			*/
+			on(this.#documentObj, "pointerdown", executeCallbacks(this.#markNonInterceptedEvent, this.#handleInteractOutside)),
+			/**
+			* HANDLE FOCUS OUTSIDE
+			*/
+			on(this.#documentObj, "focusin", this.#handleFocus)
+		);
+	}
+	#handleDismiss = (e) => {
+		let event = e;
+		if (event.defaultPrevented) event = createWrappedEvent(e);
+		this.#interactOutsideProp.current(e);
+	};
+	#handleInteractOutside = debounce((e) => {
+		if (!this.opts.ref.current) {
+			this.#unsubClickListener();
+			return;
+		}
+		const isEventValid = this.opts.isValidEvent.current(e, this.opts.ref.current) || isValidEvent(e, this.opts.ref.current);
+		if (!this.#isResponsibleLayer || this.#isAnyEventIntercepted() || !isEventValid) {
+			this.#unsubClickListener();
+			return;
+		}
+		let event = e;
+		if (event.defaultPrevented) event = createWrappedEvent(event);
+		if (this.#behaviorType.current !== "close" && this.#behaviorType.current !== "defer-otherwise-close") {
+			this.#unsubClickListener();
+			return;
+		}
+		if (e.pointerType === "touch") {
+			this.#unsubClickListener();
+			this.#unsubClickListener = on(this.#documentObj, "click", this.#handleDismiss, { once: true });
+		} else this.#interactOutsideProp.current(event);
+	}, 10);
+	#markInterceptedEvent = (e) => {
+		this.#interceptedEvents[e.type] = true;
+	};
+	#markNonInterceptedEvent = (e) => {
+		this.#interceptedEvents[e.type] = false;
+	};
+	#markResponsibleLayer = () => {
+		if (!this.opts.ref.current) return;
+		this.#isResponsibleLayer = isResponsibleLayer(this.opts.ref.current);
+	};
+	#isTargetWithinLayer = (target) => {
+		if (!this.opts.ref.current) return false;
+		return isOrContainsTarget(this.opts.ref.current, target);
+	};
+	#resetState = debounce(() => {
+		for (const eventType in this.#interceptedEvents) this.#interceptedEvents[eventType] = false;
+		this.#isResponsibleLayer = false;
+	}, 20);
+	#isAnyEventIntercepted() {
+		return Object.values(this.#interceptedEvents).some(Boolean);
+	}
+	#onfocuscapture = () => {
+		this.#isFocusInsideDOMTree = true;
+	};
+	#onblurcapture = () => {
+		this.#isFocusInsideDOMTree = false;
+	};
+	props = {
+		onfocuscapture: this.#onfocuscapture,
+		onblurcapture: this.#onblurcapture
+	};
+};
+function getTopMostDismissableLayer(layersArr = [...globalThis.bitsDismissableLayers]) {
+	return layersArr.findLast(([_, { current: behaviorType }]) => behaviorType === "close" || behaviorType === "ignore");
+}
+function isResponsibleLayer(node) {
+	const layersArr = [...globalThis.bitsDismissableLayers];
+	const topMostLayer = getTopMostDismissableLayer(layersArr);
+	if (topMostLayer) return topMostLayer[0].opts.ref.current === node;
+	const [firstLayerNode] = layersArr[0];
+	return firstLayerNode.opts.ref.current === node;
+}
+function isValidEvent(e, node) {
+	const target = e.target;
+	if (!isElementOrSVGElement(target)) return false;
+	const targetIsContextMenuTrigger = Boolean(target.closest(`[${CONTEXT_MENU_TRIGGER_ATTR}]`));
+	if ("button" in e && e.button > 0 && !targetIsContextMenuTrigger) return false;
+	if ("button" in e && e.button === 0 && targetIsContextMenuTrigger) return true;
+	const nodeIsContextMenu = Boolean(node.closest(`[${CONTEXT_MENU_CONTENT_ATTR}]`));
+	if (targetIsContextMenuTrigger && nodeIsContextMenu) return false;
+	return getOwnerDocument(target).documentElement.contains(target) && !isOrContainsTarget(node, target) && isClickTrulyOutside(e, node);
+}
+function createWrappedEvent(e) {
+	const capturedCurrentTarget = e.currentTarget;
+	const capturedTarget = e.target;
+	let newEvent;
+	if (e instanceof PointerEvent) newEvent = new PointerEvent(e.type, e);
+	else newEvent = new PointerEvent("pointerdown", e);
+	let isPrevented = false;
+	return new Proxy(newEvent, { get: (target, prop) => {
+		if (prop === "currentTarget") return capturedCurrentTarget;
+		if (prop === "target") return capturedTarget;
+		if (prop === "preventDefault") return () => {
+			isPrevented = true;
+			if (typeof target.preventDefault === "function") target.preventDefault();
+		};
+		if (prop === "defaultPrevented") return isPrevented;
+		if (prop in target) return target[prop];
+		return e[prop];
+	} });
+}
+function Dismissible_layer($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		let { interactOutsideBehavior = "close", onInteractOutside = noop, onFocusOutside = noop, id, children, enabled, isValidEvent: isValidEvent2 = () => false, ref } = $$props;
+		const dismissibleLayerState = DismissibleLayerState.create({
+			id: boxWith(() => id),
+			interactOutsideBehavior: boxWith(() => interactOutsideBehavior),
+			onInteractOutside: boxWith(() => onInteractOutside),
+			enabled: boxWith(() => enabled),
+			onFocusOutside: boxWith(() => onFocusOutside),
+			isValidEvent: boxWith(() => isValidEvent2),
+			ref
+		});
+		children?.($$renderer2, { props: dismissibleLayerState.props });
+		$$renderer2.push(`<!---->`);
+	});
+}
+globalThis.bitsEscapeLayers ??= /* @__PURE__ */ new Map();
+var EscapeLayerState = class EscapeLayerState {
+	static create(opts) {
+		return new EscapeLayerState(opts);
+	}
+	opts;
+	domContext;
+	constructor(opts) {
+		this.opts = opts;
+		this.domContext = new DOMContext(this.opts.ref);
+		let unsubEvents = noop;
+		watch(() => opts.enabled.current, (enabled) => {
+			if (enabled) {
+				globalThis.bitsEscapeLayers.set(this, opts.escapeKeydownBehavior);
+				unsubEvents = this.#addEventListener();
+			}
+			return () => {
+				unsubEvents();
+				globalThis.bitsEscapeLayers.delete(this);
+			};
+		});
+	}
+	#addEventListener = () => {
+		return on(this.domContext.getDocument(), "keydown", this.#onkeydown, { passive: false });
+	};
+	#onkeydown = (e) => {
+		if (e.key !== ESCAPE || !isResponsibleEscapeLayer(this)) return;
+		const clonedEvent = new KeyboardEvent(e.type, e);
+		e.preventDefault();
+		const behaviorType = this.opts.escapeKeydownBehavior.current;
+		if (behaviorType !== "close" && behaviorType !== "defer-otherwise-close") return;
+		this.opts.onEscapeKeydown.current(clonedEvent);
+	};
+};
+function isResponsibleEscapeLayer(instance) {
+	const layersArr = [...globalThis.bitsEscapeLayers];
+	const topMostLayer = layersArr.findLast(([_, { current: behaviorType }]) => behaviorType === "close" || behaviorType === "ignore");
+	if (topMostLayer) return topMostLayer[0] === instance;
+	const [firstLayerNode] = layersArr[0];
+	return firstLayerNode === instance;
+}
+function Escape_layer($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		let { escapeKeydownBehavior = "close", onEscapeKeydown = noop, children, enabled, ref } = $$props;
+		EscapeLayerState.create({
+			escapeKeydownBehavior: boxWith(() => escapeKeydownBehavior),
+			onEscapeKeydown: boxWith(() => onEscapeKeydown),
+			enabled: boxWith(() => enabled),
+			ref
+		});
+		children?.($$renderer2);
+		$$renderer2.push(`<!---->`);
+	});
+}
+var FocusScopeManager = class FocusScopeManager {
+	static instance;
+	#scopeStack = simpleBox([]);
+	#focusHistory = /* @__PURE__ */ new WeakMap();
+	#preFocusHistory = /* @__PURE__ */ new WeakMap();
+	static getInstance() {
+		if (!this.instance) this.instance = new FocusScopeManager();
+		return this.instance;
+	}
+	register(scope) {
+		const current = this.getActive();
+		if (current && current !== scope) current.pause();
+		const activeElement = document.activeElement;
+		if (activeElement && activeElement !== document.body) this.#preFocusHistory.set(scope, activeElement);
+		this.#scopeStack.current = this.#scopeStack.current.filter((s) => s !== scope);
+		this.#scopeStack.current.unshift(scope);
+	}
+	unregister(scope) {
+		this.#scopeStack.current = this.#scopeStack.current.filter((s) => s !== scope);
+		const next = this.getActive();
+		if (next) next.resume();
+	}
+	getActive() {
+		return this.#scopeStack.current[0];
+	}
+	setFocusMemory(scope, element) {
+		this.#focusHistory.set(scope, element);
+	}
+	getFocusMemory(scope) {
+		return this.#focusHistory.get(scope);
+	}
+	isActiveScope(scope) {
+		return this.getActive() === scope;
+	}
+	setPreFocusMemory(scope, element) {
+		this.#preFocusHistory.set(scope, element);
+	}
+	getPreFocusMemory(scope) {
+		return this.#preFocusHistory.get(scope);
+	}
+	clearPreFocusMemory(scope) {
+		this.#preFocusHistory.delete(scope);
+	}
+};
+var FocusScope = class FocusScope {
+	#paused = false;
+	#container = null;
+	#manager = FocusScopeManager.getInstance();
+	#cleanupFns = [];
+	#opts;
+	constructor(opts) {
+		this.#opts = opts;
+	}
+	get paused() {
+		return this.#paused;
+	}
+	pause() {
+		this.#paused = true;
+	}
+	resume() {
+		this.#paused = false;
+	}
+	#cleanup() {
+		for (const fn of this.#cleanupFns) fn();
+		this.#cleanupFns = [];
+	}
+	mount(container) {
+		if (this.#container) this.unmount();
+		this.#container = container;
+		this.#manager.register(this);
+		this.#setupEventListeners();
+		this.#handleOpenAutoFocus();
+	}
+	unmount() {
+		if (!this.#container) return;
+		this.#cleanup();
+		this.#handleCloseAutoFocus();
+		this.#manager.unregister(this);
+		this.#manager.clearPreFocusMemory(this);
+		this.#container = null;
+	}
+	#handleOpenAutoFocus() {
+		if (!this.#container) return;
+		const event = new CustomEvent("focusScope.onOpenAutoFocus", {
+			bubbles: false,
+			cancelable: true
+		});
+		this.#opts.onOpenAutoFocus.current(event);
+		if (!event.defaultPrevented) requestAnimationFrame(() => {
+			if (!this.#container) return;
+			const firstTabbable = this.#getFirstTabbable();
+			if (firstTabbable) {
+				firstTabbable.focus();
+				this.#manager.setFocusMemory(this, firstTabbable);
+			} else this.#container.focus();
+		});
+	}
+	#handleCloseAutoFocus() {
+		const event = new CustomEvent("focusScope.onCloseAutoFocus", {
+			bubbles: false,
+			cancelable: true
+		});
+		this.#opts.onCloseAutoFocus.current?.(event);
+		if (!event.defaultPrevented) {
+			const preFocusedElement = this.#manager.getPreFocusMemory(this);
+			if (preFocusedElement && document.contains(preFocusedElement)) try {
+				preFocusedElement.focus();
+			} catch {
+				document.body.focus();
+			}
+		}
+	}
+	#setupEventListeners() {
+		if (!this.#container || !this.#opts.trap.current) return;
+		const container = this.#container;
+		const doc = container.ownerDocument;
+		const handleFocus = (e) => {
+			if (this.#paused || !this.#manager.isActiveScope(this)) return;
+			const target = e.target;
+			if (!target) return;
+			if (container.contains(target)) this.#manager.setFocusMemory(this, target);
+			else {
+				const lastFocused = this.#manager.getFocusMemory(this);
+				if (lastFocused && container.contains(lastFocused) && isFocusable(lastFocused)) {
+					e.preventDefault();
+					lastFocused.focus();
+				} else {
+					const firstTabbable = this.#getFirstTabbable();
+					const firstFocusable = this.#getAllFocusables()[0];
+					(firstTabbable || firstFocusable || container).focus();
+				}
+			}
+		};
+		const handleKeydown = (e) => {
+			if (!this.#opts.loop || this.#paused || e.key !== "Tab") return;
+			if (!this.#manager.isActiveScope(this)) return;
+			const tabbables = this.#getTabbables();
+			if (tabbables.length < 2) return;
+			const first = tabbables[0];
+			const last = tabbables[tabbables.length - 1];
+			if (!e.shiftKey && doc.activeElement === last) {
+				e.preventDefault();
+				first.focus();
+			} else if (e.shiftKey && doc.activeElement === first) {
+				e.preventDefault();
+				last.focus();
+			}
+		};
+		this.#cleanupFns.push(on(doc, "focusin", handleFocus, { capture: true }), on(container, "keydown", handleKeydown));
+		const observer = new MutationObserver(() => {
+			const lastFocused = this.#manager.getFocusMemory(this);
+			if (lastFocused && !container.contains(lastFocused)) {
+				const firstTabbable = this.#getFirstTabbable();
+				const firstFocusable = this.#getAllFocusables()[0];
+				const elementToFocus = firstTabbable || firstFocusable;
+				if (elementToFocus) {
+					elementToFocus.focus();
+					this.#manager.setFocusMemory(this, elementToFocus);
+				} else container.focus();
+			}
+		});
+		observer.observe(container, {
+			childList: true,
+			subtree: true
+		});
+		this.#cleanupFns.push(() => observer.disconnect());
+	}
+	#getTabbables() {
+		if (!this.#container) return [];
+		return tabbable(this.#container, {
+			includeContainer: false,
+			getShadowRoot: true
+		});
+	}
+	#getFirstTabbable() {
+		return this.#getTabbables()[0] || null;
+	}
+	#getAllFocusables() {
+		if (!this.#container) return [];
+		return focusable(this.#container, {
+			includeContainer: false,
+			getShadowRoot: true
+		});
+	}
+	static use(opts) {
+		let scope = null;
+		watch([() => opts.ref.current, () => opts.enabled.current], ([ref, enabled]) => {
+			if (ref && enabled) {
+				if (!scope) scope = new FocusScope(opts);
+				scope.mount(ref);
+			} else if (scope) {
+				scope.unmount();
+				scope = null;
+			}
+		});
+		return { get props() {
+			return { tabindex: -1 };
+		} };
+	}
+};
+function Focus_scope($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		let { enabled = false, trapFocus = false, loop = false, onCloseAutoFocus = noop, onOpenAutoFocus = noop, focusScope, ref } = $$props;
+		const focusScopeState = FocusScope.use({
+			enabled: boxWith(() => enabled),
+			trap: boxWith(() => trapFocus),
+			loop,
+			onCloseAutoFocus: boxWith(() => onCloseAutoFocus),
+			onOpenAutoFocus: boxWith(() => onOpenAutoFocus),
+			ref
+		});
+		focusScope?.($$renderer2, { props: focusScopeState.props });
+		$$renderer2.push(`<!---->`);
+	});
+}
+globalThis.bitsTextSelectionLayers ??= /* @__PURE__ */ new Map();
+var TextSelectionLayerState = class TextSelectionLayerState {
+	static create(opts) {
+		return new TextSelectionLayerState(opts);
+	}
+	opts;
+	domContext;
+	#unsubSelectionLock = noop;
+	constructor(opts) {
+		this.opts = opts;
+		this.domContext = new DOMContext(opts.ref);
+		let unsubEvents = noop;
+		watch(() => this.opts.enabled.current, (isEnabled) => {
+			if (isEnabled) {
+				globalThis.bitsTextSelectionLayers.set(this, this.opts.enabled);
+				unsubEvents();
+				unsubEvents = this.#addEventListeners();
+			}
+			return () => {
+				unsubEvents();
+				this.#resetSelectionLock();
+				globalThis.bitsTextSelectionLayers.delete(this);
+			};
+		});
+	}
+	#addEventListeners() {
+		return executeCallbacks(on(this.domContext.getDocument(), "pointerdown", this.#pointerdown), on(this.domContext.getDocument(), "pointerup", composeHandlers(this.#resetSelectionLock, this.opts.onPointerUp.current)));
+	}
+	#pointerdown = (e) => {
+		const node = this.opts.ref.current;
+		const target = e.target;
+		if (!isHTMLElement(node) || !isHTMLElement(target) || !this.opts.enabled.current) return;
+		if (!isHighestLayer(this) || !contains(node, target)) return;
+		this.opts.onPointerDown.current(e);
+		if (e.defaultPrevented) return;
+		this.#unsubSelectionLock = preventTextSelectionOverflow(node, this.domContext.getDocument().body);
+	};
+	#resetSelectionLock = () => {
+		this.#unsubSelectionLock();
+		this.#unsubSelectionLock = noop;
+	};
+};
+const getUserSelect = (node) => node.style.userSelect || node.style.webkitUserSelect;
+function preventTextSelectionOverflow(node, body) {
+	const originalBodyUserSelect = getUserSelect(body);
+	const originalNodeUserSelect = getUserSelect(node);
+	setUserSelect(body, "none");
+	setUserSelect(node, "text");
+	return () => {
+		setUserSelect(body, originalBodyUserSelect);
+		setUserSelect(node, originalNodeUserSelect);
+	};
+}
+function setUserSelect(node, value) {
+	node.style.userSelect = value;
+	node.style.webkitUserSelect = value;
+}
+function isHighestLayer(instance) {
+	const layersArr = [...globalThis.bitsTextSelectionLayers];
+	if (!layersArr.length) return false;
+	const highestLayer = layersArr.at(-1);
+	if (!highestLayer) return false;
+	return highestLayer[0] === instance;
+}
+function Text_selection_layer($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		let { preventOverflowTextSelection = true, onPointerDown = noop, onPointerUp = noop, id, children, enabled, ref } = $$props;
+		TextSelectionLayerState.create({
+			id: boxWith(() => id),
+			onPointerDown: boxWith(() => onPointerDown),
+			onPointerUp: boxWith(() => onPointerUp),
+			enabled: boxWith(() => enabled && preventOverflowTextSelection),
+			ref
+		});
+		children?.($$renderer2);
+		$$renderer2.push(`<!---->`);
+	});
+}
+globalThis.bitsIdCounter ??= { current: 0 };
+function useId(prefix = "bits") {
+	globalThis.bitsIdCounter.current++;
+	return `${prefix}-${globalThis.bitsIdCounter.current}`;
+}
+var SharedState = class {
+	#factory;
+	#subscribers = 0;
+	#state;
+	#scope;
+	constructor(factory) {
+		this.#factory = factory;
+	}
+	#dispose() {
+		this.#subscribers -= 1;
+		if (this.#scope && this.#subscribers <= 0) {
+			this.#scope();
+			this.#state = void 0;
+			this.#scope = void 0;
+		}
+	}
+	get(...args) {
+		this.#subscribers += 1;
+		if (this.#state === void 0) this.#scope = () => {};
+		return this.#state;
+	}
+};
+const lockMap = new SvelteMap();
+let initialBodyStyle = null;
+let cleanupTimeoutId = null;
+let isInCleanupTransition = false;
+const anyLocked = boxWith(() => {
+	for (const value of lockMap.values()) if (value) return true;
+	return false;
+});
+let cleanupScheduledAt = null;
+const bodyLockStackCount = new SharedState(() => {
+	function resetBodyStyle() {}
+	function cancelPendingCleanup() {
+		if (cleanupTimeoutId === null) return;
+		window.clearTimeout(cleanupTimeoutId);
+		cleanupTimeoutId = null;
+	}
+	function scheduleCleanupIfNoNewLocks(delay, callback) {
+		cancelPendingCleanup();
+		isInCleanupTransition = true;
+		cleanupScheduledAt = Date.now();
+		const currentCleanupId = cleanupScheduledAt;
+		const cleanupFn = () => {
+			cleanupTimeoutId = null;
+			if (cleanupScheduledAt !== currentCleanupId) return;
+			if (!isAnyLocked(lockMap)) {
+				isInCleanupTransition = false;
+				callback();
+			} else isInCleanupTransition = false;
+		};
+		const actualDelay = delay === null ? 24 : delay;
+		cleanupTimeoutId = window.setTimeout(cleanupFn, actualDelay);
+	}
+	function ensureInitialStyleCaptured() {
+		if (initialBodyStyle === null && lockMap.size === 0 && !isInCleanupTransition) initialBodyStyle = document.body.getAttribute("style");
+	}
+	watch(() => anyLocked.current, () => {
+		if (!anyLocked.current) return;
+		ensureInitialStyleCaptured();
+		isInCleanupTransition = false;
+		const htmlStyle = getComputedStyle(document.documentElement);
+		const bodyStyle = getComputedStyle(document.body);
+		const hasStableGutter = htmlStyle.scrollbarGutter?.includes("stable") || bodyStyle.scrollbarGutter?.includes("stable");
+		const verticalScrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+		const config = {
+			padding: Number.parseInt(bodyStyle.paddingRight ?? "0", 10) + verticalScrollbarWidth,
+			margin: Number.parseInt(bodyStyle.marginRight ?? "0", 10)
+		};
+		if (verticalScrollbarWidth > 0 && !hasStableGutter) {
+			document.body.style.paddingRight = `${config.padding}px`;
+			document.body.style.marginRight = `${config.margin}px`;
+			document.body.style.setProperty("--scrollbar-width", `${verticalScrollbarWidth}px`);
+		}
+		document.body.style.overflow = "hidden";
+		if (isIOS) on(document, "touchmove", (e) => {
+			if (e.target !== document.documentElement) return;
+			if (e.touches.length > 1) return;
+			e.preventDefault();
+		}, { passive: false });
+		afterTick(() => {
+			document.body.style.pointerEvents = "none";
+			document.body.style.overflow = "hidden";
+		});
+	});
+	return {
+		get lockMap() {
+			return lockMap;
+		},
+		resetBodyStyle,
+		scheduleCleanupIfNoNewLocks,
+		cancelPendingCleanup,
+		ensureInitialStyleCaptured
+	};
+});
+var BodyScrollLock = class {
+	#id = useId();
+	#initialState;
+	#restoreScrollDelay = () => null;
+	#countState;
+	locked;
+	constructor(initialState, restoreScrollDelay = () => null) {
+		this.#initialState = initialState;
+		this.#restoreScrollDelay = restoreScrollDelay;
+		this.#countState = bodyLockStackCount.get();
+		if (!this.#countState) return;
+		this.#countState.cancelPendingCleanup();
+		this.#countState.ensureInitialStyleCaptured();
+		this.#countState.lockMap.set(this.#id, this.#initialState ?? false);
+		this.locked = boxWith(() => this.#countState.lockMap.get(this.#id) ?? false, (v) => this.#countState.lockMap.set(this.#id, v));
+	}
+};
+function isAnyLocked(map) {
+	for (const [_, value] of map) if (value) return true;
+	return false;
+}
+function Scroll_lock($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		let { preventScroll = true, restoreScrollDelay = null } = $$props;
+		if (preventScroll) new BodyScrollLock(preventScroll, () => restoreScrollDelay);
+	});
+}
+function Alert_dialog_content$1($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		const uid = props_id($$renderer2);
+		let { id = createId(uid), children, child, ref = null, forceMount = false, interactOutsideBehavior = "ignore", onCloseAutoFocus = noop, onEscapeKeydown = noop, onOpenAutoFocus = noop, onInteractOutside = noop, preventScroll = true, trapFocus = true, restoreScrollDelay = null, $$slots, $$events, ...restProps } = $$props;
+		const contentState = DialogContentState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v)
+		});
+		const mergedProps = mergeProps(restProps, contentState.props);
+		if (contentState.shouldRender || forceMount) {
+			$$renderer2.push("<!--[-->");
+			{
+				let focusScope = function($$renderer3, { props: focusScopeProps }) {
+					Escape_layer($$renderer3, spread_props([mergedProps, {
+						enabled: contentState.root.opts.open.current,
+						ref: contentState.opts.ref,
+						onEscapeKeydown: (e) => {
+							onEscapeKeydown(e);
+							if (e.defaultPrevented) return;
+							contentState.root.handleClose();
+						},
+						children: ($$renderer4) => {
+							Dismissible_layer($$renderer4, spread_props([mergedProps, {
+								ref: contentState.opts.ref,
+								enabled: contentState.root.opts.open.current,
+								interactOutsideBehavior,
+								onInteractOutside: (e) => {
+									onInteractOutside(e);
+									if (e.defaultPrevented) return;
+									contentState.root.handleClose();
+								},
+								children: ($$renderer5) => {
+									Text_selection_layer($$renderer5, spread_props([mergedProps, {
+										ref: contentState.opts.ref,
+										enabled: contentState.root.opts.open.current,
+										children: ($$renderer6) => {
+											if (child) {
+												$$renderer6.push("<!--[-->");
+												if (contentState.root.opts.open.current) {
+													$$renderer6.push("<!--[-->");
+													Scroll_lock($$renderer6, {
+														preventScroll,
+														restoreScrollDelay
+													});
+												} else $$renderer6.push("<!--[!-->");
+												$$renderer6.push(`<!--]--> `);
+												child($$renderer6, {
+													props: mergeProps(mergedProps, focusScopeProps),
+													...contentState.snippetProps
+												});
+												$$renderer6.push(`<!---->`);
+											} else {
+												$$renderer6.push("<!--[!-->");
+												Scroll_lock($$renderer6, { preventScroll });
+												$$renderer6.push(`<!----> <div${attributes({ ...mergeProps(mergedProps, focusScopeProps) })}>`);
+												children?.($$renderer6);
+												$$renderer6.push(`<!----></div>`);
+											}
+											$$renderer6.push(`<!--]-->`);
+										},
+										$$slots: { default: true }
+									}]));
+								},
+								$$slots: { default: true }
+							}]));
+						},
+						$$slots: { default: true }
+					}]));
+				};
+				Focus_scope($$renderer2, {
+					ref: contentState.opts.ref,
+					loop: true,
+					trapFocus,
+					enabled: contentState.root.opts.open.current,
+					onCloseAutoFocus,
+					onOpenAutoFocus: (e) => {
+						onOpenAutoFocus(e);
+						if (e.defaultPrevented) return;
+						e.preventDefault();
+						afterSleep(0, () => contentState.opts.ref.current?.focus());
+					},
+					focusScope
+				});
+			}
+		} else $$renderer2.push("<!--[!-->");
+		$$renderer2.push(`<!--]-->`);
+		bind_props($$props, { ref });
+	});
+}
+function Dialog_overlay($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		const uid = props_id($$renderer2);
+		let { id = createId(uid), forceMount = false, child, children, ref = null, $$slots, $$events, ...restProps } = $$props;
+		const overlayState = DialogOverlayState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v)
+		});
+		const mergedProps = mergeProps(restProps, overlayState.props);
+		if (overlayState.shouldRender || forceMount) {
+			$$renderer2.push("<!--[-->");
+			if (child) {
+				$$renderer2.push("<!--[-->");
+				child($$renderer2, {
+					props: mergeProps(mergedProps),
+					...overlayState.snippetProps
+				});
+				$$renderer2.push(`<!---->`);
+			} else {
+				$$renderer2.push("<!--[!-->");
+				$$renderer2.push(`<div${attributes({ ...mergeProps(mergedProps) })}>`);
+				children?.($$renderer2, overlayState.snippetProps);
+				$$renderer2.push(`<!----></div>`);
+			}
+			$$renderer2.push(`<!--]-->`);
+		} else $$renderer2.push("<!--[!-->");
+		$$renderer2.push(`<!--]-->`);
+		bind_props($$props, { ref });
+	});
+}
+function Dialog_description($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		const uid = props_id($$renderer2);
+		let { id = createId(uid), children, child, ref = null, $$slots, $$events, ...restProps } = $$props;
+		const mergedProps = mergeProps(restProps, DialogDescriptionState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v)
+		}).props);
+		if (child) {
+			$$renderer2.push("<!--[-->");
+			child($$renderer2, { props: mergedProps });
+			$$renderer2.push(`<!---->`);
+		} else {
+			$$renderer2.push("<!--[!-->");
+			$$renderer2.push(`<div${attributes({ ...mergedProps })}>`);
+			children?.($$renderer2);
+			$$renderer2.push(`<!----></div>`);
+		}
+		$$renderer2.push(`<!--]-->`);
+		bind_props($$props, { ref });
+	});
+}
+function Alert_dialog($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		let { open = false, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer3) {
+			$$renderer3.push(`<!---->`);
+			Alert_dialog$1?.($$renderer3, spread_props([restProps, {
+				get open() {
+					return open;
+				},
+				set open($$value) {
+					open = $$value;
+					$$settled = false;
+				}
+			}]));
+			$$renderer3.push(`<!---->`);
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer2.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer2.subsume($$inner_renderer);
+		bind_props($$props, { open });
+	});
+}
+function Alert_dialog_portal($$renderer, $$props) {
+	let { $$slots, $$events, ...restProps } = $$props;
+	$$renderer.push(`<!---->`);
+	Portal?.($$renderer, spread_props([restProps]));
+	$$renderer.push(`<!---->`);
+}
+function Alert_dialog_title($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		let { ref = null, class: className, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer3) {
+			$$renderer3.push(`<!---->`);
+			Dialog_title?.($$renderer3, spread_props([
+				{
+					"data-slot": "alert-dialog-title",
+					class: cn("text-lg font-semibold", className)
+				},
+				restProps,
+				{
+					get ref() {
+						return ref;
+					},
+					set ref($$value) {
+						ref = $$value;
+						$$settled = false;
+					}
+				}
+			]));
+			$$renderer3.push(`<!---->`);
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer2.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer2.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+function Alert_dialog_action($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		let { ref = null, class: className, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer3) {
+			$$renderer3.push(`<!---->`);
+			Alert_dialog_action$1?.($$renderer3, spread_props([
+				{
+					"data-slot": "alert-dialog-action",
+					class: cn(buttonVariants(), className)
+				},
+				restProps,
+				{
+					get ref() {
+						return ref;
+					},
+					set ref($$value) {
+						ref = $$value;
+						$$settled = false;
+					}
+				}
+			]));
+			$$renderer3.push(`<!---->`);
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer2.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer2.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+function Alert_dialog_cancel($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		let { ref = null, class: className, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer3) {
+			$$renderer3.push(`<!---->`);
+			Alert_dialog_cancel$1?.($$renderer3, spread_props([
+				{
+					"data-slot": "alert-dialog-cancel",
+					class: cn(buttonVariants({ variant: "outline" }), className)
+				},
+				restProps,
+				{
+					get ref() {
+						return ref;
+					},
+					set ref($$value) {
+						ref = $$value;
+						$$settled = false;
+					}
+				}
+			]));
+			$$renderer3.push(`<!---->`);
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer2.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer2.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+function Alert_dialog_footer($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		let { ref = null, class: className, children, $$slots, $$events, ...restProps } = $$props;
+		$$renderer2.push(`<div${attributes({
+			"data-slot": "alert-dialog-footer",
+			class: clsx(cn("flex flex-col-reverse gap-2 sm:flex-row sm:justify-end", className)),
+			...restProps
+		})}>`);
+		children?.($$renderer2);
+		$$renderer2.push(`<!----></div>`);
+		bind_props($$props, { ref });
+	});
+}
+function Alert_dialog_header($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		let { ref = null, class: className, children, $$slots, $$events, ...restProps } = $$props;
+		$$renderer2.push(`<div${attributes({
+			"data-slot": "alert-dialog-header",
+			class: clsx(cn("flex flex-col gap-2 text-center sm:text-start", className)),
+			...restProps
+		})}>`);
+		children?.($$renderer2);
+		$$renderer2.push(`<!----></div>`);
+		bind_props($$props, { ref });
+	});
+}
+function Alert_dialog_overlay($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		let { ref = null, class: className, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer3) {
+			$$renderer3.push(`<!---->`);
+			Dialog_overlay?.($$renderer3, spread_props([
+				{
+					"data-slot": "alert-dialog-overlay",
+					class: cn("data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50", className)
+				},
+				restProps,
+				{
+					get ref() {
+						return ref;
+					},
+					set ref($$value) {
+						ref = $$value;
+						$$settled = false;
+					}
+				}
+			]));
+			$$renderer3.push(`<!---->`);
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer2.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer2.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+function Alert_dialog_content($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		let { ref = null, class: className, portalProps, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer3) {
+			Alert_dialog_portal($$renderer3, spread_props([portalProps, {
+				children: ($$renderer4) => {
+					Alert_dialog_overlay($$renderer4, {});
+					$$renderer4.push(`<!----> <!---->`);
+					Alert_dialog_content$1?.($$renderer4, spread_props([
+						{
+							"data-slot": "alert-dialog-content",
+							class: cn("bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-50 grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border p-6 shadow-lg duration-200 sm:max-w-lg", className)
+						},
+						restProps,
+						{
+							get ref() {
+								return ref;
+							},
+							set ref($$value) {
+								ref = $$value;
+								$$settled = false;
+							}
+						}
+					]));
+					$$renderer4.push(`<!---->`);
+				},
+				$$slots: { default: true }
+			}]));
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer2.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer2.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+function Alert_dialog_description($$renderer, $$props) {
+	$$renderer.component(($$renderer2) => {
+		let { ref = null, class: className, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer3) {
+			$$renderer3.push(`<!---->`);
+			Dialog_description?.($$renderer3, spread_props([
+				{
+					"data-slot": "alert-dialog-description",
+					class: cn("text-muted-foreground text-sm", className)
+				},
+				restProps,
+				{
+					get ref() {
+						return ref;
+					},
+					set ref($$value) {
+						ref = $$value;
+						$$settled = false;
+					}
+				}
+			]));
+			$$renderer3.push(`<!---->`);
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer2.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer2.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+
+//#endregion
+export { executeCallbacks as A, Text_selection_layer as C, boxWith as D, boolToStr as E, simpleBox as F, styleToString as I, useId as L, isHTMLElement as M, mergeProps as N, createBitsAttrs as O, noop as P, watch as R, Scroll_lock as S, boolToEmptyStrOrUndef as T, ENTER as _, Alert_dialog_description as a, Portal as b, Alert_dialog_title as c, DialogCloseState as d, DialogContentState as f, Dismissible_layer as g, Dialog_title as h, Alert_dialog_content as i, getAriaChecked as j, createId as k, Context as l, Dialog_overlay as m, Alert_dialog_action as n, Alert_dialog_footer as o, DialogRootState as p, Alert_dialog_cancel as r, Alert_dialog_header as s, Alert_dialog as t, DOMContext as u, Escape_layer as v, attachRef as w, SPACE as x, Focus_scope as y };
+//# sourceMappingURL=alert-dialog-description-DDA6u-nS.js.map