@selvajs/selva 4.20.0-beta.5 → 4.20.0-beta.7

package/build/server/chunks/chunks/create-id.js-DByR97E7.js

@@ -0,0 +1,809 @@
+import { ae as derived, r as run, au as ATTACHMENT_KEY } from './server.js-eNE8c09e.js';
+import { clsx } from 'clsx';
+
+//#region ../../node_modules/.pnpm/inline-style-parser@0.2.7/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/.pnpm/style-to-object@1.0.14/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 ../../node_modules/.pnpm/svelte-toolbelt@0.10.6_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plu_085b9b59d7b885361e92fe917f00c285/node_modules/svelte-toolbelt/dist/utils/is.js
+function isFunction(value) {
+	return typeof value === "function";
+}
+function isObject(value) {
+	return value !== null && typeof value === "object";
+}
+var 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;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/svelte-toolbelt@0.10.6_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plu_085b9b59d7b885361e92fe917f00c285/node_modules/svelte-toolbelt/dist/box/box-extras.svelte.js
+var BoxSymbol = Symbol("box");
+var isWritableSymbol = Symbol("is-writable");
+function boxWith(getter, setter) {
+	const derived$1 = derived(getter);
+	if (setter) return {
+		[BoxSymbol]: true,
+		[isWritableSymbol]: true,
+		get current() {
+			return derived$1();
+		},
+		set current(v) {
+			setter(v);
+		}
+	};
+	return {
+		[BoxSymbol]: true,
+		get current() {
+			return getter();
+		}
+	};
+}
+/**
+* @returns Whether the value is a Box
+*
+* @see {@link https://runed.dev/docs/functions/box}
+*/
+function isBox(value) {
+	return isObject(value) && BoxSymbol in value;
+}
+/**
+* @returns Whether the value is a WritableBox
+*
+* @see {@link https://runed.dev/docs/functions/box}
+*/
+function isWritableBox(value) {
+	return isBox(value) && isWritableSymbol in value;
+}
+function boxFrom(value) {
+	if (isBox(value)) return value;
+	if (isFunction(value)) return boxWith(value);
+	return simpleBox(value);
+}
+/**
+* Function that gets an object of boxes, and returns an object of reactive values
+*
+* @example
+* const count = box(0)
+* const flat = box.flatten({ count, double: box.with(() => count.current) })
+* // type of flat is { count: number, readonly double: number }
+*
+* @see {@link https://runed.dev/docs/functions/box}
+*/
+function boxFlatten(boxes) {
+	return Object.entries(boxes).reduce((acc, [key, b]) => {
+		if (!isBox(b)) return Object.assign(acc, { [key]: b });
+		if (isWritableBox(b)) Object.defineProperty(acc, key, {
+			get() {
+				return b.current;
+			},
+			set(v) {
+				b.current = v;
+			}
+		});
+		else Object.defineProperty(acc, key, { get() {
+			return b.current;
+		} });
+		return acc;
+	}, {});
+}
+/**
+* Function that converts a box to a readonly box.
+*
+* @example
+* const count = box(0) // WritableBox<number>
+* const countReadonly = box.readonly(count) // ReadableBox<number>
+*
+* @see {@link https://runed.dev/docs/functions/box}
+*/
+function toReadonlyBox(b) {
+	if (!isWritableBox(b)) return b;
+	return {
+		[BoxSymbol]: true,
+		get current() {
+			return b.current;
+		}
+	};
+}
+function simpleBox(initialValue) {
+	let current = initialValue;
+	return {
+		[BoxSymbol]: true,
+		[isWritableSymbol]: true,
+		get current() {
+			return current;
+		},
+		set current(v) {
+			current = v;
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/svelte-toolbelt@0.10.6_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plu_085b9b59d7b885361e92fe917f00c285/node_modules/svelte-toolbelt/dist/utils/compose-handlers.js
+/**
+* Composes event handlers into a single function that can be called with an event.
+* If the previous handler cancels the event using `event.preventDefault()`, the handlers
+* that follow will not be called.
+*/
+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);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/svelte-toolbelt@0.10.6_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plu_085b9b59d7b885361e92fe917f00c285/node_modules/svelte-toolbelt/dist/utils/strings.js
+var NUMBER_CHAR_RE = /\d/;
+var 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) : "";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/svelte-toolbelt@0.10.6_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plu_085b9b59d7b885361e92fe917f00c285/node_modules/svelte-toolbelt/dist/utils/css-to-style-obj.js
+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;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/svelte-toolbelt@0.10.6_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plu_085b9b59d7b885361e92fe917f00c285/node_modules/svelte-toolbelt/dist/utils/execute-callbacks.js
+/**
+* Executes an array of callback functions with the same arguments.
+* @template T The types of the arguments that the callback functions take.
+* @param callbacks array of callback functions to execute.
+* @returns A new function that executes all of the original callback functions with the same arguments.
+*/
+function executeCallbacks(...callbacks) {
+	return (...args) => {
+		for (const callback of callbacks) if (typeof callback === "function") callback(...args);
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/svelte-toolbelt@0.10.6_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plu_085b9b59d7b885361e92fe917f00c285/node_modules/svelte-toolbelt/dist/utils/style-to-css.js
+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);
+	};
+}
+var 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");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/svelte-toolbelt@0.10.6_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plu_085b9b59d7b885361e92fe917f00c285/node_modules/svelte-toolbelt/dist/utils/style.js
+function styleToString(style = {}) {
+	return styleToCSS(style).replace("\n", " ");
+}
+var EVENT_LIST_SET = /* @__PURE__ */ 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"
+]);
+//#endregion
+//#region ../../node_modules/.pnpm/svelte-toolbelt@0.10.6_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plu_085b9b59d7b885361e92fe917f00c285/node_modules/svelte-toolbelt/dist/utils/merge-props.js
+/**
+* Modified from https://github.com/adobe/react-spectrum/blob/main/packages/%40react-aria/utils/src/mergeProps.ts (see NOTICE.txt for source)
+*/
+function isEventHandler(key) {
+	return EVENT_LIST_SET.has(key);
+}
+/**
+* Given a list of prop objects, merges them into a single object.
+* - Automatically composes event handlers (e.g. `onclick`, `oninput`, etc.)
+* - Chains regular functions with the same name so they are called in order
+* - Merges class strings with `clsx`
+* - Merges style objects and converts them to strings
+* - Handles a bug with Svelte where setting the `hidden` attribute to `false` doesn't remove it
+* - Overrides other values with the last one
+*/
+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(a, b);
+				else if (aIsClassValue) result[key] = clsx(a);
+				else if (bIsClassValue) result[key] = clsx(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;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/svelte@5.57.1_@typescript-eslint+types@8.70.1/node_modules/svelte/src/attachments/index.js
+/**
+* Creates an object key that will be recognised as an attachment when the object is spread onto an element,
+* as a programmatic alternative to using `{@attach ...}`. This can be useful for library authors, though
+* is generally not needed when building an app.
+*
+* ```svelte
+* <script>
+* 	import { createAttachmentKey } from 'svelte/attachments';
+*
+* 	const props = {
+* 		class: 'cool',
+* 		onclick: () => alert('clicked'),
+* 		[createAttachmentKey()]: (node) => {
+* 			node.textContent = 'attached!';
+* 		}
+* 	};
+* <\/script>
+*
+* <button {...props}>click me</button>
+* ```
+* @since 5.29
+*/
+function createAttachmentKey() {
+	return Symbol(ATTACHMENT_KEY);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/svelte-toolbelt@0.10.6_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plu_085b9b59d7b885361e92fe917f00c285/node_modules/svelte-toolbelt/dist/utils/attach-ref.js
+/**
+* Creates a Svelte Attachment that attaches a DOM element to a ref.
+* The ref can be either a WritableBox or a callback function.
+*
+* @param ref - Either a WritableBox to store the element in, or a callback function that receives the element
+* @param onChange - Optional callback that fires when the ref changes
+* @returns An object with a spreadable attachment key that should be spread onto the element
+*
+* @example
+* // Using with WritableBox
+* const ref = box<HTMLDivElement | null>(null);
+* <div {...attachRef(ref)}>Content</div>
+*
+* @example
+* // Using with callback
+* <div {...attachRef((node) => myNode = node)}>Content</div>
+*
+* @example
+* // Using with onChange
+* <div {...attachRef(ref, (node) => console.log(node))}>Content</div>
+*/
+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);
+		};
+	} };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/internal/attrs.js
+function boolToStr(condition) {
+	return condition ? "true" : "false";
+}
+function boolToStrTrueOrUndef(condition) {
+	return condition ? "true" : void 0;
+}
+function boolToEmptyStrOrUndef(condition) {
+	return condition ? "" : void 0;
+}
+function boolToTrueOrUndef(condition) {
+	return condition ? true : void 0;
+}
+function getDataOpenClosed(condition) {
+	return condition ? "open" : "closed";
+}
+function getDataTransitionAttrs(state) {
+	if (state === "starting") return { "data-starting-style": "" };
+	if (state === "ending") return { "data-ending-style": "" };
+	return {};
+}
+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
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/internal/create-id.js
+function createId(prefixOrUid, uid) {
+	return `bits-${prefixOrUid}`;
+}
+
+export { BoxSymbol as B, StyleToObject as S, attachRef as a, boxWith as b, createBitsAttrs as c, getDataTransitionAttrs as d, executeCallbacks as e, boolToEmptyStrOrUndef as f, getDataOpenClosed as g, createId as h, isObject as i, boolToStr as j, styleToString as k, boxFrom as l, mergeProps as m, cssToStyleObj as n, boolToTrueOrUndef as o, boolToStrTrueOrUndef as p, isWritableSymbol as q, boxFlatten as r, simpleBox as s, toReadonlyBox as t, isBox as u, isWritableBox as v, getAriaChecked as w, createAttachmentKey as x };
+//# sourceMappingURL=create-id.js-DByR97E7.js.map