@danielito1996/compose-svelted 0.0.1 → 0.2.0

package/dist/index.js

@@ -0,0 +1,1164 @@
+function toCss(l) {
+	return l === void 0 ? "0px" : typeof l == "number" ? `${l}px` : l;
+}
+var RoundedCornerShapeImpl = class {
+	constructor(l) {
+		this.params = l;
+	}
+	toCssBorderRadius() {
+		if (typeof this.params == "number" || typeof this.params == "string") {
+			let R = toCss(this.params);
+			return `${R} ${R} ${R} ${R}`;
+		}
+		let { topStart: R = 0, topEnd: z = 0, bottomEnd: B = 0, bottomStart: V = 0 } = this.params;
+		return `
+            ${toCss(R)}
+            ${toCss(z)}
+            ${toCss(B)}
+            ${toCss(V)}
+        `.trim();
+	}
+};
+function RoundedCornerShape(l) {
+	return new RoundedCornerShapeImpl(l);
+}
+const ColorScheme = {
+	Primary: "primary",
+	OnPrimary: "onPrimary",
+	Secondary: "secondary",
+	OnSecondary: "onSecondary",
+	Background: "background",
+	OnBackground: "onBackground",
+	Surface: "surface",
+	OnSurface: "onSurface",
+	SurfaceVariant: "surfaceVariant",
+	OnSurfaceVariant: "onSurfaceVariant",
+	Outline: "outline",
+	Error: "error",
+	OnError: "onError"
+}, TextStyle = {
+	DisplayLarge: "displayLarge",
+	DisplayMedium: "displayMedium",
+	DisplaySmall: "displaySmall",
+	HeadlineLarge: "headlineLarge",
+	HeadlineMedium: "headlineMedium",
+	HeadlineSmall: "headlineSmall",
+	TitleLarge: "titleLarge",
+	TitleMedium: "titleMedium",
+	TitleSmall: "titleSmall",
+	BodyLarge: "bodyLarge",
+	BodyMedium: "bodyMedium",
+	BodySmall: "bodySmall",
+	LabelLarge: "labelLarge",
+	LabelMedium: "labelMedium",
+	LabelSmall: "labelSmall"
+}, Density = {
+	Default: "default",
+	Compact: "compact"
+}, resolveColor = (l) => `var(--md-sys-color-${l})`;
+var ModifierImpl = class l {
+	constructor(l = []) {
+		this.entries = l;
+	}
+	then(R) {
+		return new l([...this.entries, ...R.entries]);
+	}
+	paddingHorizontal(R) {
+		return this.then(new l([{ style: `padding-left:${R}px;padding-right:${R}px;` }]));
+	}
+	verticalScroll(R = !0) {
+		return this.then(new l([{ style: R ? "overflow-y:auto;overflow-x:hidden;-webkit-overflow-scrolling:touch;" : "" }]));
+	}
+	horizontalScroll(R = !0) {
+		return this.then(new l([{ style: R ? "overflow-x:auto;overflow-y:hidden;-webkit-overflow-scrolling:touch;white-space:nowrap;" : "" }]));
+	}
+	paddingVertical(R) {
+		return this.then(new l([{ style: `padding-top:${R}px;padding-bottom:${R}px;` }]));
+	}
+	fillMaxWidth() {
+		return this.then(new l([{ style: "width:100%;" }]));
+	}
+	fillMaxHeight() {
+		return this.then(new l([{ style: "height:100%;" }]));
+	}
+	fillMaxSize() {
+		return this.then(new l([{ style: "width:100%;height:100%;" }]));
+	}
+	background(R) {
+		let z;
+		return z = typeof R == "string" && (R.startsWith("#") || R.startsWith("rgb") || R.startsWith("hsl") || R === "transparent" || R === "currentColor") ? R : resolveColor(R), this.then(new l([{ style: `background:${z};` }]));
+	}
+	weight(R, z = !0) {
+		if (R <= 0) return console.warn("Modifier.weight() debe ser > 0"), this;
+		let B = [
+			`flex-grow: ${R};`,
+			`flex-shrink: ${z ? 1 : 0};`,
+			"flex-basis: 0%;"
+		];
+		return this.then(new l([{ style: B.join(" ") }]));
+	}
+	align(R) {
+		let z = R.split(" "), B = z[0], V = z[1] || z[0], H = "position: absolute;";
+		return V === "flex-start" ? H += "top: 0;" : V === "flex-end" ? H += "bottom: 0;" : V === "center" && (H += "top: 50%; transform: translateY(-50%);"), B === "flex-start" ? H += "left: 0;" : B === "flex-end" ? H += "right: 0;" : B === "center" && (H += "left: 50%;", H.includes("translateY") ? H = H.replace("translateY(-50%)", "translate(-50%, -50%)") : H += "transform: translateX(-50%);"), this.then(new l([{ style: H }]));
+	}
+	padding(R = 0, z = "px") {
+		let B = "";
+		if (typeof R == "number") B = `padding:${R}${z};`;
+		else {
+			let { top: l = 0, bottom: V = 0, start: H = 0, end: U = 0 } = R;
+			B = `
+                padding-top:${l}${z};
+                padding-bottom:${V}${z};
+                padding-left:${H}${z};
+                //padding-right:${U}${z};
+    `.trim();
+		}
+		return this.then(new l([{ style: B }]));
+	}
+	width(R, z = "px") {
+		let B = typeof R == "number" ? `${R}${z}` : R;
+		return this.then(new l([{ style: `width:${B};` }]));
+	}
+	height(R, z = "px") {
+		let B = typeof R == "number" ? `${R}${z}` : R;
+		return this.then(new l([{ style: `height:${B};` }]));
+	}
+	marginTop(R, z = "px") {
+		return this.then(new l([{ style: `margin-top:${R}${z};` }]));
+	}
+	clip(R) {
+		return this.then(new l([{ style: `
+                    border-radius:${R.toCssBorderRadius()};
+                    overflow:hidden;
+                ` }]));
+	}
+	size(R, z = "px") {
+		if (R == null) return this;
+		let B;
+		if (typeof R == "number") {
+			if (isNaN(R)) return this;
+			B = `${R}${z}`;
+		} else {
+			if (R.trim() === "") return this;
+			B = R;
+		}
+		return this.then(new l([{ style: `width:${B};height:${B};` }]));
+	}
+	offset(R, z) {
+		return isNaN(R) || isNaN(z) ? this : this.then(new l([{ style: `transform: translate(${R}px, ${z}px);` }]));
+	}
+	clickable(R) {
+		return this.then(new l([{
+			className: "compose-clickable",
+			style: "\n                    cursor: pointer;\n                    user-select: none;\n                "
+		}]));
+	}
+	border(R, z, B) {
+		if (R <= 0) return this;
+		let V = B ? B.toCssBorderRadius() : void 0;
+		return this.then(new l([{ style: `
+                    border:${R}px solid ${z};
+                    ${V ? `border-radius:${V};` : ""}
+                ` }]));
+	}
+	toStyle() {
+		return this.entries.map((l) => l.style ?? "").join("");
+	}
+	toClass() {
+		return this.entries.map((l) => l.className ?? "").join(" ");
+	}
+};
+const Modifier = {
+	empty() {
+		return new ModifierImpl();
+	},
+	padding(l = 0, R = "px") {
+		return new ModifierImpl().padding(l, R);
+	},
+	paddingHorizontal(l) {
+		return new ModifierImpl().paddingHorizontal(l);
+	},
+	border(l, R, z) {
+		return new ModifierImpl().border(l, R, z);
+	},
+	clickable(l) {
+		return new ModifierImpl().clickable(l);
+	},
+	offset(l, R) {
+		return new ModifierImpl().offset(l, R);
+	},
+	verticalScroll(l = !0) {
+		return new ModifierImpl().verticalScroll(l);
+	},
+	horizontalScroll(l = !0) {
+		return new ModifierImpl().horizontalScroll(l);
+	},
+	paddingVertical(l) {
+		return new ModifierImpl().paddingVertical(l);
+	},
+	align(l) {
+		return new ModifierImpl().align(l);
+	},
+	fillMaxWidth() {
+		return new ModifierImpl().fillMaxWidth();
+	},
+	fillMaxHeight() {
+		return new ModifierImpl().fillMaxHeight();
+	},
+	fillMaxSize() {
+		return new ModifierImpl().fillMaxSize();
+	},
+	height(l, R = "px") {
+		return new ModifierImpl().height(l, R);
+	},
+	width(l, R = "px") {
+		return new ModifierImpl().width(l, R);
+	},
+	background(l) {
+		return new ModifierImpl().background(l);
+	},
+	weight(l, R = !0) {
+		return new ModifierImpl().weight(l, R);
+	},
+	weightNoFill(l) {
+		return this.weight(l, !1);
+	},
+	marginTop(l, R = "px") {
+		return new ModifierImpl().marginTop(l, R);
+	},
+	clip(l) {
+		return new ModifierImpl().clip(l);
+	},
+	size(l, R = "px") {
+		return new ModifierImpl().size(l, R);
+	}
+}, Arrangement = {
+	Start: {
+		type: "static",
+		justifyContent: "flex-start"
+	},
+	Center: {
+		type: "static",
+		justifyContent: "center"
+	},
+	End: {
+		type: "static",
+		justifyContent: "flex-end"
+	},
+	Bottom: {
+		type: "static",
+		justifyContent: "flex-end"
+	},
+	Top: {
+		type: "static",
+		justifyContent: "flex-start"
+	},
+	SpaceBetween: {
+		type: "static",
+		justifyContent: "space-between"
+	},
+	SpaceAround: {
+		type: "static",
+		justifyContent: "space-around"
+	},
+	SpaceEvenly: {
+		type: "static",
+		justifyContent: "space-evenly"
+	},
+	spacedBy(l) {
+		return {
+			type: "spaced",
+			gap: l,
+			justifyContent: "flex-start"
+		};
+	}
+}, Alignment = {
+	Start: "flex-start",
+	CenterHorizontally: "center",
+	End: "flex-end",
+	Top: "flex-start",
+	CenterVertically: "center",
+	Bottom: "flex-end",
+	TopStart: "flex-start flex-start",
+	TopCenter: "center flex-start",
+	TopEnd: "flex-end flex-start",
+	CenterStart: "flex-start center",
+	Center: "center center",
+	CenterEnd: "flex-end center",
+	BottomStart: "flex-start flex-end",
+	BottomCenter: "center flex-end",
+	BottomEnd: "flex-end flex-end"
+}, ContentScale = {
+	Crop: "cover",
+	Fit: "contain",
+	FillBounds: "fill",
+	Inside: "contain",
+	FillWidth: "fillWidth",
+	FillHeight: "fillHeight",
+	None: "none"
+}, Res = {
+	raw(l) {
+		return "raw/" + l;
+	},
+	image(l) {
+		return "img/" + l;
+	},
+	values(l) {
+		return "values/" + l;
+	},
+	fonts(l) {
+		return "fonts/" + l;
+	}
+};
+function painterResource(l) {
+	return "/src/assets/" + l;
+}
+var defaultEnter = 280, defaultExit = 220;
+function fadeIn(l = defaultEnter) {
+	return {
+		base: `transition-opacity duration-[${l}ms] ease-out`,
+		from: "opacity-0",
+		to: "opacity-100",
+		duration: l
+	};
+}
+function fadeOut(l = defaultExit) {
+	return {
+		base: `transition-opacity duration-[${l}ms] ease-in`,
+		from: "opacity-100",
+		to: "opacity-0",
+		duration: l
+	};
+}
+function scaleIn(l = defaultEnter) {
+	return {
+		base: `transition-all duration-[${l}ms] ease-out`,
+		from: "opacity-0 scale-95",
+		to: "opacity-100 scale-100",
+		duration: l
+	};
+}
+function scaleOut(l = defaultExit) {
+	return {
+		base: `transition-all duration-[${l}ms] ease-in`,
+		from: "opacity-100 scale-100",
+		to: "opacity-0 scale-95",
+		duration: l
+	};
+}
+function slideIn(l = defaultEnter, R = "right") {
+	return {
+		base: `transition-all duration-[${l}ms] ease-out`,
+		from: `opacity-0 ${{
+			left: "-translate-x-4",
+			right: "translate-x-4",
+			up: "-translate-y-4",
+			down: "translate-y-4"
+		}[R]}`,
+		to: "opacity-100 translate-x-0 translate-y-0",
+		duration: l
+	};
+}
+function slideOut(l = defaultExit, R = "right") {
+	return {
+		base: `transition-all duration-[${l}ms] ease-in`,
+		from: "opacity-100 translate-x-0 translate-y-0",
+		to: `opacity-0 ${{
+			left: "-translate-x-4",
+			right: "translate-x-4",
+			up: "-translate-y-4",
+			down: "translate-y-4"
+		}[R]}`,
+		duration: l
+	};
+}
+function slideHorizontal() {
+	return {
+		enter: "transition-transform duration-200 ease-out translate-x-0",
+		exit: "transition-transform duration-200 ease-in -translate-x-full",
+		duration: 200
+	};
+}
+function scaleFade() {
+	return {
+		enter: "transition-all duration-220 ease-out opacity-100 scale-100",
+		exit: "transition-all duration-180 ease-in opacity-0 scale-95",
+		duration: 220
+	};
+}
+function fade(l = 300) {
+	return {
+		enter: "animate-fade-in",
+		exit: "animate-fade-out",
+		duration: l
+	};
+}
+var is_array = Array.isArray, index_of = Array.prototype.indexOf;
+Array.from, Object.keys, Object.defineProperty;
+var get_descriptor = Object.getOwnPropertyDescriptor, object_prototype = Object.prototype, array_prototype = Array.prototype, get_prototype_of = Object.getPrototypeOf;
+Object.isExtensible;
+const noop = () => {};
+function run_all(l) {
+	for (var R = 0; R < l.length; R++) l[R]();
+}
+function deferred() {
+	var l, R;
+	return {
+		promise: new Promise((z, B) => {
+			l = z, R = B;
+		}),
+		resolve: l,
+		reject: R
+	};
+}
+const CLEAN = 1024, DIRTY = 2048, MAYBE_DIRTY = 4096, INERT = 8192, WAS_MARKED = 32768, REACTION_IS_UPDATING = 1 << 21, ERROR_VALUE = 1 << 23, STATE_SYMBOL = Symbol("$state"), STALE_REACTION = new class extends Error {
+	name = "StaleReactionError";
+	message = "The reaction that called `getAbortSignal()` was re-run or destroyed";
+}();
+function equals(l) {
+	return l === this.v;
+}
+function safe_not_equal(l, R) {
+	return l == l ? l !== R || typeof l == "object" && !!l || typeof l == "function" : R == R;
+}
+function effect_update_depth_exceeded() {
+	throw Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function state_descriptors_fixed() {
+	throw Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function state_prototype_fixed() {
+	throw Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function state_unsafe_mutation() {
+	throw Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+const UNINITIALIZED = Symbol();
+let component_context = null;
+function set_component_context(l) {
+	component_context = l;
+}
+function is_runes() {
+	return !0;
+}
+var micro_tasks = [];
+function run_micro_tasks() {
+	var l = micro_tasks;
+	micro_tasks = [], run_all(l);
+}
+function queue_micro_task(l) {
+	if (micro_tasks.length === 0 && !is_flushing_sync) {
+		var R = micro_tasks;
+		queueMicrotask(() => {
+			R === micro_tasks && run_micro_tasks();
+		});
+	}
+	micro_tasks.push(l);
+}
+function proxy(l) {
+	if (typeof l != "object" || !l || STATE_SYMBOL in l) return l;
+	let R = get_prototype_of(l);
+	if (R !== object_prototype && R !== array_prototype) return l;
+	var z = /* @__PURE__ */ new Map(), B = is_array(l), V = /* @__PURE__ */ state(0), H = null, U = update_version, W = (l) => {
+		if (update_version === U) return l();
+		var R = active_reaction, z = update_version;
+		set_active_reaction(null), set_update_version(U);
+		var B = l();
+		return set_active_reaction(R), set_update_version(z), B;
+	};
+	return B && z.set("length", /* @__PURE__ */ state(l.length, H)), new Proxy(l, {
+		defineProperty(l, R, B) {
+			(!("value" in B) || B.configurable === !1 || B.enumerable === !1 || B.writable === !1) && state_descriptors_fixed();
+			var V = z.get(R);
+			return V === void 0 ? V = W(() => {
+				var l = /* @__PURE__ */ state(B.value, H);
+				return z.set(R, l), l;
+			}) : set(V, B.value, !0), !0;
+		},
+		deleteProperty(l, R) {
+			var B = z.get(R);
+			if (B === void 0) {
+				if (R in l) {
+					let l = W(() => /* @__PURE__ */ state(UNINITIALIZED, H));
+					z.set(R, l), increment(V);
+				}
+			} else set(B, UNINITIALIZED), increment(V);
+			return !0;
+		},
+		get(R, B, V) {
+			if (B === STATE_SYMBOL) return l;
+			var U = z.get(B), G = B in R;
+			if (U === void 0 && (!G || get_descriptor(R, B)?.writable) && (U = W(() => /* @__PURE__ */ state(proxy(G ? R[B] : UNINITIALIZED), H)), z.set(B, U)), U !== void 0) {
+				var K = get$1(U);
+				return K === UNINITIALIZED ? void 0 : K;
+			}
+			return Reflect.get(R, B, V);
+		},
+		getOwnPropertyDescriptor(l, R) {
+			var B = Reflect.getOwnPropertyDescriptor(l, R);
+			if (B && "value" in B) {
+				var V = z.get(R);
+				V && (B.value = get$1(V));
+			} else if (B === void 0) {
+				var H = z.get(R), U = H?.v;
+				if (H !== void 0 && U !== UNINITIALIZED) return {
+					enumerable: !0,
+					configurable: !0,
+					value: U,
+					writable: !0
+				};
+			}
+			return B;
+		},
+		has(l, R) {
+			if (R === STATE_SYMBOL) return !0;
+			var B = z.get(R), V = B !== void 0 && B.v !== UNINITIALIZED || Reflect.has(l, R);
+			return (B !== void 0 || active_effect !== null && (!V || get_descriptor(l, R)?.writable)) && (B === void 0 && (B = W(() => /* @__PURE__ */ state(V ? proxy(l[R]) : UNINITIALIZED, H)), z.set(R, B)), get$1(B) === UNINITIALIZED) ? !1 : V;
+		},
+		set(l, R, U, G) {
+			var K = z.get(R), q = R in l;
+			if (B && R === "length") for (var J = U; J < K.v; J += 1) {
+				var Y = z.get(J + "");
+				Y === void 0 ? J in l && (Y = W(() => /* @__PURE__ */ state(UNINITIALIZED, H)), z.set(J + "", Y)) : set(Y, UNINITIALIZED);
+			}
+			if (K === void 0) (!q || get_descriptor(l, R)?.writable) && (K = W(() => /* @__PURE__ */ state(void 0, H)), set(K, proxy(U)), z.set(R, K));
+			else {
+				q = K.v !== UNINITIALIZED;
+				var X = W(() => proxy(U));
+				set(K, X);
+			}
+			var Z = Reflect.getOwnPropertyDescriptor(l, R);
+			if (Z?.set && Z.set.call(G, U), !q) {
+				if (B && typeof R == "string") {
+					var Q = z.get("length"), $ = Number(R);
+					Number.isInteger($) && $ >= Q.v && set(Q, $ + 1);
+				}
+				increment(V);
+			}
+			return !0;
+		},
+		ownKeys(l) {
+			get$1(V);
+			var R = Reflect.ownKeys(l).filter((l) => {
+				var R = z.get(l);
+				return R === void 0 || R.v !== UNINITIALIZED;
+			});
+			for (var [B, H] of z) H.v !== UNINITIALIZED && !(B in l) && R.push(B);
+			return R;
+		},
+		setPrototypeOf() {
+			state_prototype_fixed();
+		}
+	});
+}
+var next_sibling_getter;
+/* @__NO_SIDE_EFFECTS__ */
+function get_next_sibling(l) {
+	return next_sibling_getter.call(l);
+}
+function handle_error(l) {
+	var R = active_effect;
+	if (R === null) return active_reaction.f |= ERROR_VALUE, l;
+	if (R.f & 32768) invoke_error_boundary(l, R);
+	else {
+		if (!(R.f & 128)) throw l;
+		R.b.error(l);
+	}
+}
+function invoke_error_boundary(l, R) {
+	for (; R !== null;) {
+		if (R.f & 128) try {
+			R.b.error(l);
+			return;
+		} catch (R) {
+			l = R;
+		}
+		R = R.parent;
+	}
+	throw l;
+}
+var batches = /* @__PURE__ */ new Set();
+let current_batch = null, batch_values = null;
+var queued_root_effects = [], last_scheduled_effect = null, is_flushing = !1;
+let is_flushing_sync = !1;
+var Batch = class l {
+	committed = !1;
+	current = /* @__PURE__ */ new Map();
+	previous = /* @__PURE__ */ new Map();
+	#e = /* @__PURE__ */ new Set();
+	#t = /* @__PURE__ */ new Set();
+	#n = 0;
+	#r = 0;
+	#i = null;
+	#a = /* @__PURE__ */ new Set();
+	#o = /* @__PURE__ */ new Set();
+	skipped_effects = /* @__PURE__ */ new Set();
+	is_fork = !1;
+	is_deferred() {
+		return this.is_fork || this.#r > 0;
+	}
+	process(l) {
+		queued_root_effects = [], this.apply();
+		var R = {
+			parent: null,
+			effect: null,
+			effects: [],
+			render_effects: []
+		};
+		for (let z of l) this.#s(z, R);
+		this.is_fork || this.#u(), this.is_deferred() ? (this.#c(R.effects), this.#c(R.render_effects)) : (current_batch = null, flush_queued_effects(R.render_effects), flush_queued_effects(R.effects), this.#i?.resolve()), batch_values = null;
+	}
+	#s(l, R) {
+		l.f ^= CLEAN;
+		for (var z = l.first; z !== null;) {
+			var B = z.f, V = (B & 96) != 0, H = V && (B & 1024) != 0 || (B & 8192) != 0 || this.skipped_effects.has(z);
+			if (z.f & 128 && z.b?.is_pending() && (R = {
+				parent: R,
+				effect: z,
+				effects: [],
+				render_effects: []
+			}), !H && z.fn !== null) {
+				V ? z.f ^= CLEAN : B & 4 ? R.effects.push(z) : is_dirty(z) && (z.f & 16 && this.#a.add(z), update_effect(z));
+				var U = z.first;
+				if (U !== null) {
+					z = U;
+					continue;
+				}
+			}
+			var W = z.parent;
+			for (z = z.next; z === null && W !== null;) W === R.effect && (this.#c(R.effects), this.#c(R.render_effects), R = R.parent), z = W.next, W = W.parent;
+		}
+	}
+	#c(l) {
+		for (let R of l) R.f & 2048 ? this.#a.add(R) : R.f & 4096 && this.#o.add(R), this.#l(R.deps), set_signal_status(R, CLEAN);
+	}
+	#l(l) {
+		if (l !== null) for (let R of l) !(R.f & 2) || !(R.f & 32768) || (R.f ^= WAS_MARKED, this.#l(R.deps));
+	}
+	capture(l, R) {
+		this.previous.has(l) || this.previous.set(l, R), l.f & 8388608 || (this.current.set(l, l.v), batch_values?.set(l, l.v));
+	}
+	activate() {
+		current_batch = this, this.apply();
+	}
+	deactivate() {
+		current_batch === this && (current_batch = null, batch_values = null);
+	}
+	flush() {
+		if (this.activate(), queued_root_effects.length > 0) {
+			if (flush_effects(), current_batch !== null && current_batch !== this) return;
+		} else this.#n === 0 && this.process([]);
+		this.deactivate();
+	}
+	discard() {
+		for (let l of this.#t) l(this);
+		this.#t.clear();
+	}
+	#u() {
+		if (this.#r === 0) {
+			for (let l of this.#e) l();
+			this.#e.clear();
+		}
+		this.#n === 0 && this.#d();
+	}
+	#d() {
+		if (batches.size > 1) {
+			this.previous.clear();
+			var l = batch_values, R = !0, z = {
+				parent: null,
+				effect: null,
+				effects: [],
+				render_effects: []
+			};
+			for (let l of batches) {
+				if (l === this) {
+					R = !1;
+					continue;
+				}
+				let V = [];
+				for (let [z, B] of this.current) {
+					if (l.current.has(z)) if (R && B !== l.current.get(z)) l.current.set(z, B);
+					else continue;
+					V.push(z);
+				}
+				if (V.length === 0) continue;
+				let H = [...l.current.keys()].filter((l) => !this.current.has(l));
+				if (H.length > 0) {
+					var B = queued_root_effects;
+					queued_root_effects = [];
+					let R = /* @__PURE__ */ new Set(), U = /* @__PURE__ */ new Map();
+					for (let l of V) mark_effects(l, H, R, U);
+					if (queued_root_effects.length > 0) {
+						current_batch = l, l.apply();
+						for (let R of queued_root_effects) l.#s(R, z);
+						l.deactivate();
+					}
+					queued_root_effects = B;
+				}
+			}
+			current_batch = null, batch_values = l;
+		}
+		this.committed = !0, batches.delete(this);
+	}
+	increment(l) {
+		this.#n += 1, l && (this.#r += 1);
+	}
+	decrement(l) {
+		--this.#n, l && --this.#r, this.revive();
+	}
+	revive() {
+		for (let l of this.#a) this.#o.delete(l), set_signal_status(l, DIRTY), schedule_effect(l);
+		for (let l of this.#o) set_signal_status(l, MAYBE_DIRTY), schedule_effect(l);
+		this.flush();
+	}
+	oncommit(l) {
+		this.#e.add(l);
+	}
+	ondiscard(l) {
+		this.#t.add(l);
+	}
+	settled() {
+		return (this.#i ??= deferred()).promise;
+	}
+	static ensure() {
+		if (current_batch === null) {
+			let R = current_batch = new l();
+			batches.add(current_batch), l.enqueue(() => {
+				current_batch === R && R.flush();
+			});
+		}
+		return current_batch;
+	}
+	static enqueue(l) {
+		queue_micro_task(l);
+	}
+	apply() {}
+};
+function flush_effects() {
+	var l = is_updating_effect;
+	is_flushing = !0;
+	try {
+		var R = 0;
+		for (set_is_updating_effect(!0); queued_root_effects.length > 0;) {
+			var z = Batch.ensure();
+			R++ > 1e3 && infinite_loop_guard(), z.process(queued_root_effects), old_values.clear();
+		}
+	} finally {
+		is_flushing = !1, set_is_updating_effect(l), last_scheduled_effect = null;
+	}
+}
+function infinite_loop_guard() {
+	try {
+		effect_update_depth_exceeded();
+	} catch (l) {
+		invoke_error_boundary(l, last_scheduled_effect);
+	}
+}
+let eager_block_effects = null;
+function flush_queued_effects(l) {
+	var R = l.length;
+	if (R !== 0) {
+		for (var z = 0; z < R;) {
+			var B = l[z++];
+			if (!(B.f & 24576) && is_dirty(B) && (eager_block_effects = /* @__PURE__ */ new Set(), update_effect(B), B.deps === null && B.first === null && B.nodes === null && (B.teardown === null && B.ac === null ? unlink_effect(B) : B.fn = null), eager_block_effects?.size > 0)) {
+				old_values.clear();
+				for (let l of eager_block_effects) {
+					if (l.f & 24576) continue;
+					let R = [l], z = l.parent;
+					for (; z !== null;) eager_block_effects.has(z) && (eager_block_effects.delete(z), R.push(z)), z = z.parent;
+					for (let l = R.length - 1; l >= 0; l--) {
+						let z = R[l];
+						z.f & 24576 || update_effect(z);
+					}
+				}
+				eager_block_effects.clear();
+			}
+		}
+		eager_block_effects = null;
+	}
+}
+function mark_effects(l, R, z, B) {
+	if (!z.has(l) && (z.add(l), l.reactions !== null)) for (let V of l.reactions) {
+		let l = V.f;
+		l & 2 ? mark_effects(V, R, z, B) : l & 4194320 && !(l & 2048) && depends_on(V, R, B) && (set_signal_status(V, DIRTY), schedule_effect(V));
+	}
+}
+function depends_on(l, R, z) {
+	let B = z.get(l);
+	if (B !== void 0) return B;
+	if (l.deps !== null) for (let B of l.deps) {
+		if (R.includes(B)) return !0;
+		if (B.f & 2 && depends_on(B, R, z)) return z.set(B, !0), !0;
+	}
+	return z.set(l, !1), !1;
+}
+function schedule_effect(l) {
+	for (var R = last_scheduled_effect = l; R.parent !== null;) {
+		R = R.parent;
+		var z = R.f;
+		if (is_flushing && R === active_effect && z & 16 && !(z & 262144)) return;
+		if (z & 96) {
+			if (!(z & 1024)) return;
+			R.f ^= CLEAN;
+		}
+	}
+	queued_root_effects.push(R);
+}
+function destroy_derived_effects(l) {
+	var R = l.effects;
+	if (R !== null) {
+		l.effects = null;
+		for (var z = 0; z < R.length; z += 1) destroy_effect(R[z]);
+	}
+}
+function get_derived_parent_effect(l) {
+	for (var R = l.parent; R !== null;) {
+		if (!(R.f & 2)) return R.f & 16384 ? null : R;
+		R = R.parent;
+	}
+	return null;
+}
+function execute_derived(l) {
+	var R, z = active_effect;
+	set_active_effect(get_derived_parent_effect(l));
+	try {
+		l.f &= ~WAS_MARKED, destroy_derived_effects(l), R = update_reaction(l);
+	} finally {
+		set_active_effect(z);
+	}
+	return R;
+}
+function update_derived(l) {
+	var R = execute_derived(l);
+	l.equals(R) || (current_batch?.is_fork || (l.v = R), l.wv = increment_write_version()), !is_destroying_effect && (batch_values === null ? set_signal_status(l, l.f & 512 ? CLEAN : MAYBE_DIRTY) : (effect_tracking() || current_batch?.is_fork) && batch_values.set(l, R));
+}
+let eager_effects = /* @__PURE__ */ new Set();
+const old_values = /* @__PURE__ */ new Map();
+var eager_effects_deferred = !1;
+function source(l, R) {
+	return {
+		f: 0,
+		v: l,
+		reactions: null,
+		equals,
+		rv: 0,
+		wv: 0
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function state(l, R) {
+	let z = source(l, R);
+	return push_reaction_value(z), z;
+}
+function set(l, R, z = !1) {
+	return active_reaction !== null && (!untracking || active_reaction.f & 131072) && is_runes() && active_reaction.f & 4325394 && !current_sources?.includes(l) && state_unsafe_mutation(), internal_set(l, z ? proxy(R) : R);
+}
+function internal_set(l, R) {
+	if (!l.equals(R)) {
+		var z = l.v;
+		is_destroying_effect ? old_values.set(l, R) : old_values.set(l, z), l.v = R;
+		var B = Batch.ensure();
+		B.capture(l, z), l.f & 2 && (l.f & 2048 && execute_derived(l), set_signal_status(l, l.f & 512 ? CLEAN : MAYBE_DIRTY)), l.wv = increment_write_version(), mark_reactions(l, DIRTY), is_runes() && active_effect !== null && active_effect.f & 1024 && !(active_effect.f & 96) && (untracked_writes === null ? set_untracked_writes([l]) : untracked_writes.push(l)), !B.is_fork && eager_effects.size > 0 && !eager_effects_deferred && flush_eager_effects();
+	}
+	return R;
+}
+function flush_eager_effects() {
+	eager_effects_deferred = !1;
+	var l = is_updating_effect;
+	set_is_updating_effect(!0);
+	let R = Array.from(eager_effects);
+	try {
+		for (let l of R) l.f & 1024 && set_signal_status(l, MAYBE_DIRTY), is_dirty(l) && update_effect(l);
+	} finally {
+		set_is_updating_effect(l);
+	}
+	eager_effects.clear();
+}
+function increment(l) {
+	set(l, l.v + 1);
+}
+function mark_reactions(l, R) {
+	var z = l.reactions;
+	if (z !== null) for (var B = is_runes(), V = z.length, H = 0; H < V; H++) {
+		var U = z[H], W = U.f;
+		if (!(!B && U === active_effect)) {
+			var G = (W & DIRTY) === 0;
+			if (G && set_signal_status(U, R), W & 2) {
+				var K = U;
+				batch_values?.delete(K), W & 32768 || (W & 512 && (U.f |= WAS_MARKED), mark_reactions(K, MAYBE_DIRTY));
+			} else G && (W & 16 && eager_block_effects !== null && eager_block_effects.add(U), schedule_effect(U));
+		}
+	}
+}
+function without_reactive_context(l) {
+	var R = active_reaction, z = active_effect;
+	set_active_reaction(null), set_active_effect(null);
+	try {
+		return l();
+	} finally {
+		set_active_reaction(R), set_active_effect(z);
+	}
+}
+let is_updating_effect = !1;
+function set_is_updating_effect(l) {
+	is_updating_effect = l;
+}
+let is_destroying_effect = !1;
+function set_is_destroying_effect(l) {
+	is_destroying_effect = l;
+}
+let active_reaction = null, untracking = !1;
+function set_active_reaction(l) {
+	active_reaction = l;
+}
+let active_effect = null;
+function set_active_effect(l) {
+	active_effect = l;
+}
+let current_sources = null;
+function push_reaction_value(l) {
+	active_reaction !== null && (current_sources === null ? current_sources = [l] : current_sources.push(l));
+}
+var new_deps = null, skipped_deps = 0;
+let untracked_writes = null;
+function set_untracked_writes(l) {
+	untracked_writes = l;
+}
+let write_version = 1;
+var read_version = 0;
+let update_version = read_version;
+function set_update_version(l) {
+	update_version = l;
+}
+function increment_write_version() {
+	return ++write_version;
+}
+function is_dirty(l) {
+	var R = l.f;
+	if (R & 2048) return !0;
+	if (R & 2 && (l.f &= ~WAS_MARKED), R & 4096) {
+		var z = l.deps;
+		if (z !== null) for (var B = z.length, V = 0; V < B; V++) {
+			var H = z[V];
+			if (is_dirty(H) && update_derived(H), H.wv > l.wv) return !0;
+		}
+		R & 512 && batch_values === null && set_signal_status(l, CLEAN);
+	}
+	return !1;
+}
+function schedule_possible_effect_self_invalidation(l, R, z = !0) {
+	var B = l.reactions;
+	if (B !== null && !current_sources?.includes(l)) for (var V = 0; V < B.length; V++) {
+		var H = B[V];
+		H.f & 2 ? schedule_possible_effect_self_invalidation(H, R, !1) : R === H && (z ? set_signal_status(H, DIRTY) : H.f & 1024 && set_signal_status(H, MAYBE_DIRTY), schedule_effect(H));
+	}
+}
+function update_reaction(l) {
+	var R = new_deps, z = skipped_deps, B = untracked_writes, V = active_reaction, H = current_sources, U = component_context, W = untracking, G = update_version, K = l.f;
+	new_deps = null, skipped_deps = 0, untracked_writes = null, active_reaction = K & 96 ? null : l, current_sources = null, set_component_context(l.ctx), untracking = !1, update_version = ++read_version, l.ac !== null && (without_reactive_context(() => {
+		l.ac.abort(STALE_REACTION);
+	}), l.ac = null);
+	try {
+		l.f |= REACTION_IS_UPDATING;
+		var q = l.fn, J = q(), Y = l.deps;
+		if (new_deps !== null) {
+			var X;
+			if (remove_reactions(l, skipped_deps), Y !== null && skipped_deps > 0) for (Y.length = skipped_deps + new_deps.length, X = 0; X < new_deps.length; X++) Y[skipped_deps + X] = new_deps[X];
+			else l.deps = Y = new_deps;
+			if (effect_tracking() && l.f & 512) for (X = skipped_deps; X < Y.length; X++) (Y[X].reactions ??= []).push(l);
+		} else Y !== null && skipped_deps < Y.length && (remove_reactions(l, skipped_deps), Y.length = skipped_deps);
+		if (is_runes() && untracked_writes !== null && !untracking && Y !== null && !(l.f & 6146)) for (X = 0; X < untracked_writes.length; X++) schedule_possible_effect_self_invalidation(untracked_writes[X], l);
+		return V !== null && V !== l && (read_version++, untracked_writes !== null && (B === null ? B = untracked_writes : B.push(...untracked_writes))), l.f & 8388608 && (l.f ^= ERROR_VALUE), J;
+	} catch (l) {
+		return handle_error(l);
+	} finally {
+		l.f ^= REACTION_IS_UPDATING, new_deps = R, skipped_deps = z, untracked_writes = B, active_reaction = V, current_sources = H, set_component_context(U), untracking = W, update_version = G;
+	}
+}
+function remove_reaction(l, R) {
+	let z = R.reactions;
+	if (z !== null) {
+		var B = index_of.call(z, l);
+		if (B !== -1) {
+			var V = z.length - 1;
+			V === 0 ? z = R.reactions = null : (z[B] = z[V], z.pop());
+		}
+	}
+	z === null && R.f & 2 && (new_deps === null || !new_deps.includes(R)) && (set_signal_status(R, MAYBE_DIRTY), R.f & 512 && (R.f ^= 512, R.f &= ~WAS_MARKED), destroy_derived_effects(R), remove_reactions(R, 0));
+}
+function remove_reactions(l, R) {
+	var z = l.deps;
+	if (z !== null) for (var B = R; B < z.length; B++) remove_reaction(l, z[B]);
+}
+function update_effect(l) {
+	var R = l.f;
+	if (!(R & 16384)) {
+		set_signal_status(l, CLEAN);
+		var z = active_effect, B = is_updating_effect;
+		active_effect = l, is_updating_effect = !0;
+		try {
+			R & 16777232 ? destroy_block_effect_children(l) : destroy_effect_children(l), execute_effect_teardown(l);
+			var V = update_reaction(l);
+			l.teardown = typeof V == "function" ? V : null, l.wv = write_version;
+		} finally {
+			is_updating_effect = B, active_effect = z;
+		}
+	}
+}
+function get$1(l) {
+	var R = (l.f & 2) != 0;
+	if (null?.add(l), active_reaction !== null && !untracking && !(active_effect !== null && active_effect.f & 16384) && !current_sources?.includes(l)) {
+		var z = active_reaction.deps;
+		if (active_reaction.f & 2097152) l.rv < read_version && (l.rv = read_version, new_deps === null && z !== null && z[skipped_deps] === l ? skipped_deps++ : new_deps === null ? new_deps = [l] : new_deps.includes(l) || new_deps.push(l));
+		else {
+			(active_reaction.deps ??= []).push(l);
+			var B = l.reactions;
+			B === null ? l.reactions = [active_reaction] : B.includes(active_reaction) || B.push(active_reaction);
+		}
+	}
+	if (is_destroying_effect) {
+		if (old_values.has(l)) return old_values.get(l);
+		if (R) {
+			var V = l, H = V.v;
+			return (!(V.f & 1024) && V.reactions !== null || depends_on_old_values(V)) && (H = execute_derived(V)), old_values.set(V, H), H;
+		}
+	} else R && (!batch_values?.has(l) || current_batch?.is_fork && !effect_tracking()) && (V = l, is_dirty(V) && update_derived(V), is_updating_effect && effect_tracking() && !(V.f & 512) && reconnect(V));
+	if (batch_values?.has(l)) return batch_values.get(l);
+	if (l.f & 8388608) throw l.v;
+	return l.v;
+}
+function reconnect(l) {
+	if (l.deps !== null) {
+		l.f ^= 512;
+		for (let R of l.deps) (R.reactions ??= []).push(l), R.f & 2 && !(R.f & 512) && reconnect(R);
+	}
+}
+function depends_on_old_values(l) {
+	if (l.v === UNINITIALIZED) return !0;
+	if (l.deps === null) return !1;
+	for (let R of l.deps) if (old_values.has(R) || R.f & 2 && depends_on_old_values(R)) return !0;
+	return !1;
+}
+var STATUS_MASK = ~(MAYBE_DIRTY | 3072);
+function set_signal_status(l, R) {
+	l.f = l.f & STATUS_MASK | R;
+}
+function effect_tracking() {
+	return active_reaction !== null && !untracking;
+}
+function execute_effect_teardown(l) {
+	var R = l.teardown;
+	if (R !== null) {
+		let l = is_destroying_effect, z = active_reaction;
+		set_is_destroying_effect(!0), set_active_reaction(null);
+		try {
+			R.call(null);
+		} finally {
+			set_is_destroying_effect(l), set_active_reaction(z);
+		}
+	}
+}
+function destroy_effect_children(l, R = !1) {
+	var z = l.first;
+	for (l.first = l.last = null; z !== null;) {
+		let l = z.ac;
+		l !== null && without_reactive_context(() => {
+			l.abort(STALE_REACTION);
+		});
+		var B = z.next;
+		z.f & 64 ? z.parent = null : destroy_effect(z, R), z = B;
+	}
+}
+function destroy_block_effect_children(l) {
+	for (var R = l.first; R !== null;) {
+		var z = R.next;
+		R.f & 32 || destroy_effect(R), R = z;
+	}
+}
+function destroy_effect(l, R = !0) {
+	var z = !1;
+	(R || l.f & 262144) && l.nodes !== null && l.nodes.end !== null && (remove_effect_dom(l.nodes.start, l.nodes.end), z = !0), destroy_effect_children(l, R && !z), remove_reactions(l, 0), set_signal_status(l, 16384);
+	var B = l.nodes && l.nodes.t;
+	if (B !== null) for (let l of B) l.stop();
+	execute_effect_teardown(l);
+	var V = l.parent;
+	V !== null && V.first !== null && unlink_effect(l), l.next = l.prev = l.teardown = l.ctx = l.deps = l.fn = l.nodes = l.ac = null;
+}
+function remove_effect_dom(l, R) {
+	for (; l !== null;) {
+		var z = l === R ? null : /* @__PURE__ */ get_next_sibling(l);
+		l.remove(), l = z;
+	}
+}
+function unlink_effect(l) {
+	var R = l.parent, z = l.prev, B = l.next;
+	z !== null && (z.next = B), B !== null && (B.prev = z), R !== null && (R.first === l && (R.first = B), R.last === l && (R.last = z));
+}
+function pause_children(l, R, z) {
+	if (!(l.f & 8192)) {
+		l.f ^= 8192;
+		var B = l.nodes && l.nodes.t;
+		if (B !== null) for (let l of B) (l.is_global || z) && R.push(l);
+		for (var V = l.first; V !== null;) {
+			var H = V.next, U = (V.f & 65536) != 0 || (V.f & 32) != 0 && (l.f & 16) != 0;
+			pause_children(V, R, U ? z : !1), V = H;
+		}
+	}
+}
+[.../* @__PURE__ */ "allowfullscreen.async.autofocus.autoplay.checked.controls.default.disabled.formnovalidate.indeterminate.inert.ismap.loop.multiple.muted.nomodule.novalidate.open.playsinline.readonly.required.reversed.seamless.selected.webkitdirectory.defer.disablepictureinpicture.disableremoteplayback".split(".")];
+var subscriber_queue = [];
+function writable(l, R = noop) {
+	let z = null, B = /* @__PURE__ */ new Set();
+	function V(R) {
+		if (safe_not_equal(l, R) && (l = R, z)) {
+			let R = !subscriber_queue.length;
+			for (let R of B) R[1](), subscriber_queue.push(R, l);
+			if (R) {
+				for (let l = 0; l < subscriber_queue.length; l += 2) subscriber_queue[l][0](subscriber_queue[l + 1]);
+				subscriber_queue.length = 0;
+			}
+		}
+	}
+	function H(R) {
+		V(R(l));
+	}
+	function U(U, W = noop) {
+		let G = [U, W];
+		return B.add(G), B.size === 1 && (z = R(V, H) || noop), U(l), () => {
+			B.delete(G), B.size === 0 && z && (z(), z = null);
+		};
+	}
+	return {
+		set: V,
+		update: H,
+		subscribe: U
+	};
+}
+var NavController = class {
+	constructor(l) {
+		this.stackStore = writable([{ route: l }]);
+	}
+	_getStackStore() {
+		return this.stackStore;
+	}
+	navigate(l, R) {
+		this.stackStore.update((z) => [...z, {
+			route: l,
+			args: R
+		}]);
+	}
+	popBackStack() {
+		this.stackStore.update((l) => l.length > 1 ? l.slice(0, -1) : l);
+	}
+};
+function rememberNavController(l) {
+	return new NavController(l);
+}
+function composable(l, R) {
+	return {
+		route: l,
+		component: R()
+	};
+}
+var ComposeTheme = class extends SvelteComponent {}, AppRoot = class extends SvelteComponent {}, Column = class extends SvelteComponent {}, Row = class extends SvelteComponent {}, Box = class extends SvelteComponent {}, Spacer = class extends SvelteComponent {}, LazyColumn = class extends SvelteComponent {}, LazyRow = class extends SvelteComponent {}, Scaffold = class extends SvelteComponent {}, Surface = class extends SvelteComponent {}, Text$1 = class extends SvelteComponent {}, Button = class extends SvelteComponent {}, TextButton = class extends SvelteComponent {}, TonalButton = class extends SvelteComponent {}, IconButton = class extends SvelteComponent {}, ButtonWithIcon = class extends SvelteComponent {}, OutlinedButton = class extends SvelteComponent {}, OutlinedButtonWithIcon = class extends SvelteComponent {}, CheckButton = class extends SvelteComponent {}, Card = class extends SvelteComponent {}, OutlinedCard = class extends SvelteComponent {}, TextField = class extends SvelteComponent {}, OutlinedTextField = class extends SvelteComponent {}, Image = class extends SvelteComponent {}, Icon = class extends SvelteComponent {}, AnimatedVisibility = class extends SvelteComponent {}, AnimatedContent = class extends SvelteComponent {}, NavHost = class extends SvelteComponent {}, CodeBlock = class extends SvelteComponent {};
+export { Alignment, AnimatedContent, AnimatedVisibility, AppRoot, Arrangement, Box, Button, ButtonWithIcon, Card, CheckButton, CodeBlock, ColorScheme, Column, ComposeTheme, ContentScale, Density, Icon, IconButton, Image, LazyColumn, LazyRow, Modifier, NavController, NavHost, OutlinedButton, OutlinedButtonWithIcon, OutlinedCard, OutlinedTextField, Res, RoundedCornerShape, Row, Scaffold, Spacer, Surface, Text$1 as Text, TextButton, TextField, TextStyle, TonalButton, composable, fade, fadeIn, fadeOut, painterResource, rememberNavController, scaleFade, scaleIn, scaleOut, slideHorizontal, slideIn, slideOut };