@sigx/runtime-core 0.1.7 → 0.1.9

package/dist/renderer-KQIgreMb.js

@@ -0,0 +1,1230 @@
+import { detectAccess, effect, isComputed, signal, untrack } from "@sigx/reactivity";
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var plugins = [];
+function registerComponentPlugin(plugin) {
+	plugins.push(plugin);
+}
+function getComponentPlugins() {
+	return plugins;
+}
+var contextExtensions = [];
+function registerContextExtension(extension) {
+	contextExtensions.push(extension);
+}
+function applyContextExtensions(ctx) {
+	for (const extension of contextExtensions) extension(ctx);
+}
+var require___vite_browser_external = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {};
+}));
+var asyncLocalStorage = null;
+try {
+	if (typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined") {
+		const nodeAsync = globalThis.process?.versions?.node ? require___vite_browser_external() : null;
+		if (nodeAsync?.AsyncLocalStorage) asyncLocalStorage = new nodeAsync.AsyncLocalStorage();
+	}
+} catch {}
+var _fallbackContext = {
+	currentComponentContext: null,
+	currentSuspenseBoundary: null
+};
+function getRequestContext() {
+	if (asyncLocalStorage) {
+		const store = asyncLocalStorage.getStore();
+		if (store) return store;
+	}
+	return _fallbackContext;
+}
+function getCurrentInstanceSafe() {
+	return getRequestContext().currentComponentContext;
+}
+function setCurrentInstanceSafe(ctx) {
+	const reqCtx = getRequestContext();
+	const prev = reqCtx.currentComponentContext;
+	reqCtx.currentComponentContext = ctx;
+	return prev;
+}
+function getCurrentSuspenseBoundarySafe() {
+	return getRequestContext().currentSuspenseBoundary;
+}
+function setCurrentSuspenseBoundarySafe(boundary) {
+	const reqCtx = getRequestContext();
+	const prev = reqCtx.currentSuspenseBoundary;
+	reqCtx.currentSuspenseBoundary = boundary;
+	return prev;
+}
+function runInRequestScope(fn) {
+	if (asyncLocalStorage) return asyncLocalStorage.run({
+		currentComponentContext: null,
+		currentSuspenseBoundary: null
+	}, fn);
+	return fn();
+}
+function hasRequestIsolation() {
+	return asyncLocalStorage !== null;
+}
+var currentComponentContext = null;
+function getCurrentInstance() {
+	return getCurrentInstanceSafe() ?? currentComponentContext;
+}
+function setCurrentInstance(ctx) {
+	const prevSafe = setCurrentInstanceSafe(ctx);
+	const prevModule = currentComponentContext;
+	currentComponentContext = ctx;
+	return prevSafe ?? prevModule;
+}
+function onMounted(fn) {
+	if (currentComponentContext) currentComponentContext.onMounted(fn);
+	else console.warn("onMounted called outside of component setup");
+}
+function onUnmounted(fn) {
+	if (currentComponentContext) currentComponentContext.onUnmounted(fn);
+	else console.warn("onUnmounted called outside of component setup");
+}
+function onCreated(fn) {
+	if (currentComponentContext) currentComponentContext.onCreated(fn);
+	else console.warn("onCreated called outside of component setup");
+}
+function onUpdated(fn) {
+	if (currentComponentContext) currentComponentContext.onUpdated(fn);
+	else console.warn("onUpdated called outside of component setup");
+}
+var componentRegistry = /* @__PURE__ */ new Map();
+function getComponentMeta(factory) {
+	return componentRegistry.get(factory);
+}
+function component(setup, options) {
+	const factory = function(props) {
+		return {
+			type: factory,
+			props: props || {},
+			key: props?.key || null,
+			children: [],
+			dom: null
+		};
+	};
+	factory.__setup = setup;
+	factory.__name = options?.name;
+	factory.__props = null;
+	factory.__events = null;
+	factory.__ref = null;
+	factory.__slots = null;
+	componentRegistry.set(factory, {
+		name: options?.name,
+		setup
+	});
+	getComponentPlugins().forEach((p) => p.onDefine?.(options?.name, factory, setup));
+	return factory;
+}
+var globalInstances = /* @__PURE__ */ new Map();
+var appContextToken = Symbol("sigx:appContext");
+function lookupProvided(token) {
+	const ctx = getCurrentInstance();
+	if (!ctx) return;
+	let current = ctx;
+	while (current) {
+		if (current.provides && current.provides.has(token)) return current.provides.get(token);
+		current = current.parent;
+	}
+}
+function provideAtComponent(token, value) {
+	const ctx = getCurrentInstance();
+	if (!ctx) throw new Error("defineProvide must be called inside a component setup function");
+	if (!ctx.provides) ctx.provides = /* @__PURE__ */ new Map();
+	ctx.provides.set(token, value);
+}
+function defineInjectable(factory) {
+	const token = Symbol();
+	const useFn = (() => {
+		const provided = lookupProvided(token);
+		if (provided !== void 0) return provided;
+		if (!globalInstances.has(token)) globalInstances.set(token, factory());
+		return globalInstances.get(token);
+	});
+	useFn._factory = factory;
+	useFn._token = token;
+	return useFn;
+}
+function defineProvide(useFn, factory) {
+	const actualFactory = factory ?? useFn._factory;
+	const token = useFn._token;
+	if (!actualFactory || !token) throw new Error("defineProvide must be called with a function created by defineInjectable");
+	const instance = actualFactory();
+	provideAtComponent(token, instance);
+	return instance;
+}
+function useAppContext() {
+	return lookupProvided(appContextToken) ?? null;
+}
+function getAppContextToken() {
+	return appContextToken;
+}
+function provideAppContext(ctx, appContext) {
+	if (!ctx.provides) ctx.provides = /* @__PURE__ */ new Map();
+	ctx.provides.set(appContextToken, appContext);
+	if (appContext.provides) for (const [token, value] of appContext.provides) ctx.provides.set(token, value);
+}
+const __DIRECTIVE__ = Symbol.for("sigx.directive");
+function defineDirective(definition) {
+	definition[__DIRECTIVE__] = true;
+	return definition;
+}
+function isDirective(value) {
+	return value != null && typeof value === "object" && value[__DIRECTIVE__] === true;
+}
+var isDev = typeof process !== "undefined" && process.env.NODE_ENV !== "production" || true;
+var defaultMountFn = null;
+function setDefaultMount(mountFn) {
+	defaultMountFn = mountFn;
+}
+function getDefaultMount() {
+	return defaultMountFn;
+}
+function defineApp(rootComponent) {
+	const installedPlugins = /* @__PURE__ */ new Set();
+	const context = {
+		app: null,
+		provides: /* @__PURE__ */ new Map(),
+		config: {},
+		hooks: [],
+		directives: /* @__PURE__ */ new Map()
+	};
+	let isMounted = false;
+	let container = null;
+	let unmountFn = null;
+	const app = {
+		config: context.config,
+		use(plugin, options) {
+			if (installedPlugins.has(plugin)) {
+				if (isDev) console.warn(`Plugin ${plugin.name || "anonymous"} is already installed.`);
+				return app;
+			}
+			installedPlugins.add(plugin);
+			if (typeof plugin === "function") plugin(app, options);
+			else if (plugin && typeof plugin.install === "function") plugin.install(app, options);
+			else if (isDev) console.warn("Invalid plugin: must be a function or have an install() method.");
+			return app;
+		},
+		defineProvide(useFn, factory) {
+			const actualFactory = factory ?? useFn._factory;
+			const token = useFn._token;
+			if (!actualFactory || !token) throw new Error("defineProvide must be called with a function created by defineInjectable");
+			const instance = actualFactory();
+			context.provides.set(token, instance);
+			return instance;
+		},
+		hook(hooks) {
+			context.hooks.push(hooks);
+			return app;
+		},
+		directive(name, definition) {
+			if (definition !== void 0) {
+				if (isDev && !isDirective(definition)) console.warn(`[sigx] app.directive('${name}', ...) received a value that is not a valid directive definition. Use defineDirective() to create directive definitions.`);
+				context.directives.set(name, definition);
+				return app;
+			}
+			return context.directives.get(name);
+		},
+		mount(target, renderFn) {
+			if (isMounted) {
+				if (isDev) console.warn("App is already mounted. Call app.unmount() first.");
+				return app;
+			}
+			const mountFn = renderFn ?? defaultMountFn;
+			if (!mountFn) throw new Error("No mount function provided and no default mount function set. Either pass a mount function to app.mount(), or import a platform package (e.g., @sigx/runtime-dom or @sigx/runtime-terminal) that sets the default.");
+			container = target;
+			isMounted = true;
+			const result = mountFn(rootComponent, target, context);
+			if (typeof result === "function") unmountFn = result;
+			return app;
+		},
+		unmount() {
+			if (!isMounted) {
+				if (isDev) console.warn("App is not mounted.");
+				return;
+			}
+			if (unmountFn) unmountFn();
+			context.provides.clear();
+			isMounted = false;
+			container = null;
+		},
+		get _context() {
+			return context;
+		},
+		get _isMounted() {
+			return isMounted;
+		},
+		get _container() {
+			return container;
+		},
+		get _rootComponent() {
+			return rootComponent;
+		}
+	};
+	context.app = app;
+	const appContextToken = getAppContextToken();
+	context.provides.set(appContextToken, context);
+	return app;
+}
+function notifyComponentCreated(context, instance) {
+	if (!context) return;
+	for (const hooks of context.hooks) try {
+		hooks.onComponentCreated?.(instance);
+	} catch (err) {
+		handleHookError(context, err, instance, "onComponentCreated");
+	}
+}
+function notifyComponentMounted(context, instance) {
+	if (!context) return;
+	for (const hooks of context.hooks) try {
+		hooks.onComponentMounted?.(instance);
+	} catch (err) {
+		handleHookError(context, err, instance, "onComponentMounted");
+	}
+}
+function notifyComponentUnmounted(context, instance) {
+	if (!context) return;
+	for (const hooks of context.hooks) try {
+		hooks.onComponentUnmounted?.(instance);
+	} catch (err) {
+		handleHookError(context, err, instance, "onComponentUnmounted");
+	}
+}
+function notifyComponentUpdated(context, instance) {
+	if (!context) return;
+	for (const hooks of context.hooks) try {
+		hooks.onComponentUpdated?.(instance);
+	} catch (err) {
+		handleHookError(context, err, instance, "onComponentUpdated");
+	}
+}
+function handleComponentError(context, err, instance, info) {
+	if (!context) return false;
+	for (const hooks of context.hooks) try {
+		if (hooks.onComponentError?.(err, instance, info) === true) return true;
+	} catch (hookErr) {
+		console.error("Error in onComponentError hook:", hookErr);
+	}
+	if (context.config.errorHandler) try {
+		if (context.config.errorHandler(err, instance, info) === true) return true;
+	} catch (handlerErr) {
+		console.error("Error in app.config.errorHandler:", handlerErr);
+	}
+	return false;
+}
+function handleHookError(context, err, instance, hookName) {
+	console.error(`Error in ${hookName} hook:`, err);
+	if (context.config.errorHandler) try {
+		context.config.errorHandler(err, instance, `plugin hook: ${hookName}`);
+	} catch {}
+}
+var MODEL_SYMBOL = Symbol.for("sigx.model");
+function createModel(tuple, updateHandler) {
+	const [obj, key] = tuple;
+	return {
+		get value() {
+			return obj[key];
+		},
+		set value(v) {
+			updateHandler(v);
+		},
+		get binding() {
+			return [
+				obj,
+				key,
+				updateHandler
+			];
+		},
+		[MODEL_SYMBOL]: true
+	};
+}
+function createModelFromBinding(binding) {
+	const [obj, key, handler] = binding;
+	return createModel([obj, key], handler);
+}
+function isModel(value) {
+	return value !== null && typeof value === "object" && MODEL_SYMBOL in value && value[MODEL_SYMBOL] === true;
+}
+function getModelSymbol() {
+	return MODEL_SYMBOL;
+}
+var platformModelProcessor = null;
+function setPlatformModelProcessor(fn) {
+	platformModelProcessor = fn;
+}
+function getPlatformModelProcessor() {
+	return platformModelProcessor;
+}
+function isComponent(type) {
+	return typeof type === "function" && "__setup" in type;
+}
+const Fragment = Symbol.for("sigx.Fragment");
+const Text = Symbol.for("sigx.Text");
+function normalizeChildren(children) {
+	if (children == null || children === false || children === true) return [];
+	if (isComputed(children)) return normalizeChildren(children.value);
+	if (Array.isArray(children)) return children.flatMap((c) => normalizeChildren(c));
+	if (typeof children === "string" || typeof children === "number") return [{
+		type: Text,
+		props: {},
+		key: null,
+		children: [],
+		dom: null,
+		text: children
+	}];
+	if (children.type) return [children];
+	return [];
+}
+function jsx(type, props, key) {
+	const processedProps = { ...props };
+	const models = {};
+	const isComponentType = isComponent(type);
+	if (props) {
+		for (const propKey in props) if (propKey === "model") {
+			let modelBinding = props[propKey];
+			let tuple = null;
+			let updateHandler = null;
+			if (isModel(modelBinding)) {
+				const [obj, key, handler] = modelBinding.binding;
+				tuple = [obj, key];
+				updateHandler = handler;
+			} else if (typeof modelBinding === "function") {
+				const detected = detectAccess(modelBinding);
+				if (detected && typeof detected[1] === "string") tuple = detected;
+			} else if (Array.isArray(modelBinding) && modelBinding.length === 2 && typeof modelBinding[1] === "string") tuple = modelBinding;
+			if (tuple) {
+				const [stateObj, stateKey] = tuple;
+				let handled = false;
+				if (!updateHandler) {
+					const existingHandler = processedProps["onUpdate:modelValue"];
+					updateHandler = (v) => {
+						const customHandler = stateObj[`onUpdate:${stateKey}`];
+						if (typeof customHandler === "function") customHandler(v);
+						else stateObj[stateKey] = v;
+						if (existingHandler) existingHandler(v);
+					};
+				}
+				const platformProcessor = getPlatformModelProcessor();
+				if (typeof type === "string" && platformProcessor) handled = platformProcessor(type, processedProps, tuple, props);
+				if (isComponentType) {
+					models.model = createModel(tuple, updateHandler);
+					processedProps["onUpdate:modelValue"] = updateHandler;
+				} else if (!handled) {
+					processedProps.modelValue = stateObj[stateKey];
+					processedProps["onUpdate:modelValue"] = updateHandler;
+				}
+				delete processedProps.model;
+			}
+		} else if (propKey.startsWith("model:")) {
+			let modelBinding = props[propKey];
+			const name = propKey.slice(6);
+			let tuple = null;
+			let updateHandler = null;
+			if (isModel(modelBinding)) {
+				const [obj, key, handler] = modelBinding.binding;
+				tuple = [obj, key];
+				updateHandler = handler;
+			} else if (typeof modelBinding === "function") {
+				const detected = detectAccess(modelBinding);
+				if (detected && typeof detected[1] === "string") tuple = detected;
+			} else if (Array.isArray(modelBinding) && modelBinding.length === 2 && typeof modelBinding[1] === "string") tuple = modelBinding;
+			if (tuple) {
+				const [stateObj, stateKey] = tuple;
+				const eventName = `onUpdate:${name}`;
+				if (!updateHandler) {
+					const existingHandler = processedProps[eventName];
+					updateHandler = (v) => {
+						const customHandler = stateObj[`onUpdate:${stateKey}`];
+						if (typeof customHandler === "function") customHandler(v);
+						else stateObj[stateKey] = v;
+						if (existingHandler) existingHandler(v);
+					};
+				}
+				if (isComponentType) {
+					models[name] = createModel(tuple, updateHandler);
+					processedProps[eventName] = updateHandler;
+				} else {
+					processedProps[name] = stateObj[stateKey];
+					processedProps[eventName] = updateHandler;
+				}
+				delete processedProps[propKey];
+			}
+		}
+	}
+	if (Object.keys(models).length > 0) processedProps.$models = models;
+	if (isComponent(type)) {
+		const { children, ...rest } = processedProps;
+		return {
+			type,
+			props: {
+				...rest,
+				children
+			},
+			key: key || rest.key || null,
+			children: [],
+			dom: null
+		};
+	}
+	if (typeof type === "function" && type !== Fragment) return type(processedProps);
+	const { children, ...rest } = processedProps;
+	return {
+		type,
+		props: rest,
+		key: key || rest.key || null,
+		children: normalizeChildren(children),
+		dom: null
+	};
+}
+function jsxs(type, props, key) {
+	return jsx(type, props, key);
+}
+const jsxDEV = jsx;
+var currentSuspenseBoundary = null;
+function registerPendingPromise(promise) {
+	const boundary = getCurrentSuspenseBoundarySafe() ?? currentSuspenseBoundary;
+	if (boundary) {
+		boundary.pending.add(promise);
+		promise.finally(() => {
+			boundary.pending.delete(promise);
+			if (boundary.pending.size === 0) boundary.onResolve();
+		});
+		return true;
+	}
+	return false;
+}
+function lazy(loader) {
+	let Component = null;
+	let promise = null;
+	let error = null;
+	let state = "pending";
+	const LazyWrapper = component((ctx) => {
+		const loadState = ctx.signal({
+			state,
+			tick: 0
+		});
+		if (!promise) promise = loader().then((mod) => {
+			Component = "default" in mod ? mod.default : mod;
+			state = "resolved";
+			loadState.state = "resolved";
+			loadState.tick++;
+			return Component;
+		}).catch((err) => {
+			error = err instanceof Error ? err : new Error(String(err));
+			state = "rejected";
+			loadState.state = "rejected";
+			loadState.tick++;
+			throw error;
+		});
+		if (state === "resolved" && Component) return () => {
+			return jsx(Component, {});
+		};
+		if (state === "rejected" && error) throw error;
+		if (!registerPendingPromise(promise)) promise.catch(() => {});
+		return () => {
+			const currentState = loadState.state;
+			loadState.tick;
+			if (currentState === "resolved" && Component) return jsx(Component, {});
+			if (currentState === "rejected" && error) throw error;
+			return null;
+		};
+	}, { name: "LazyComponent" });
+	LazyWrapper.__lazy = true;
+	LazyWrapper.preload = () => {
+		if (!promise) promise = loader().then((mod) => {
+			Component = "default" in mod ? mod.default : mod;
+			state = "resolved";
+			return Component;
+		}).catch((err) => {
+			error = err instanceof Error ? err : new Error(String(err));
+			state = "rejected";
+			throw error;
+		});
+		return promise;
+	};
+	LazyWrapper.isLoaded = () => {
+		return state === "resolved";
+	};
+	return LazyWrapper;
+}
+const Suspense = component((ctx) => {
+	const { props, slots } = ctx;
+	const state = ctx.signal({
+		isReady: false,
+		pendingCount: 0
+	});
+	const boundary = {
+		pending: /* @__PURE__ */ new Set(),
+		onResolve: () => {
+			state.pendingCount = boundary.pending.size;
+			if (boundary.pending.size === 0) state.isReady = true;
+		}
+	};
+	ctx.onMounted(() => {
+		if (boundary.pending.size === 0) state.isReady = true;
+	});
+	return () => {
+		state.isReady;
+		state.pendingCount;
+		const prevBoundary = getCurrentSuspenseBoundarySafe() ?? currentSuspenseBoundary;
+		currentSuspenseBoundary = boundary;
+		setCurrentSuspenseBoundarySafe(boundary);
+		try {
+			const children = slots.default();
+			if (boundary.pending.size > 0) {
+				const fallback = props.fallback;
+				if (typeof fallback === "function") return fallback();
+				return fallback ?? null;
+			}
+			if (Array.isArray(children)) {
+				const filtered = children.filter((c) => c != null && c !== false && c !== true);
+				if (filtered.length === 0) return null;
+				if (filtered.length === 1) return filtered[0];
+				return filtered;
+			}
+			return children;
+		} catch (err) {
+			if (err instanceof Promise) {
+				registerPendingPromise(err);
+				const fallback = props.fallback;
+				if (typeof fallback === "function") return fallback();
+				return fallback ?? null;
+			}
+			throw err;
+		} finally {
+			currentSuspenseBoundary = prevBoundary;
+			setCurrentSuspenseBoundarySafe(prevBoundary);
+		}
+	};
+}, { name: "Suspense" });
+function isLazyComponent(component) {
+	return component && component.__lazy === true;
+}
+function createPropsAccessor(reactiveProps) {
+	return new Proxy(reactiveProps, {
+		get(target, key) {
+			if (typeof key === "symbol") return void 0;
+			return target[key];
+		},
+		has(target, key) {
+			if (typeof key === "symbol") return false;
+			return key in target;
+		},
+		ownKeys(target) {
+			return Object.keys(target);
+		},
+		getOwnPropertyDescriptor(target, key) {
+			if (typeof key === "symbol") return void 0;
+			if (key in target) return {
+				enumerable: true,
+				configurable: true,
+				writable: false
+			};
+		}
+	});
+}
+function createSlots(children, slotsFromProps) {
+	const versionSignal = signal({ v: 0 });
+	function extractNamedSlotsFromChildren(c) {
+		const defaultChildren = [];
+		const namedSlots = {};
+		if (c == null) return {
+			defaultChildren,
+			namedSlots
+		};
+		const items = Array.isArray(c) ? c : [c];
+		for (const child of items) if (child && typeof child === "object" && child.props && child.props.slot) {
+			const slotName = child.props.slot;
+			if (!namedSlots[slotName]) namedSlots[slotName] = [];
+			namedSlots[slotName].push(child);
+		} else defaultChildren.push(child);
+		return {
+			defaultChildren,
+			namedSlots
+		};
+	}
+	const slotsObj = {
+		_children: children,
+		_slotsFromProps: slotsFromProps || {},
+		_version: versionSignal,
+		_isPatching: false,
+		default: function() {
+			this._version.v;
+			const c = this._children;
+			const { defaultChildren } = extractNamedSlotsFromChildren(c);
+			return defaultChildren.filter((child) => child != null && child !== false && child !== true);
+		}
+	};
+	return new Proxy(slotsObj, { get(target, prop) {
+		if (prop in target) return target[prop];
+		if (typeof prop === "string") return function(scopedProps) {
+			target._version.v;
+			if (target._slotsFromProps && typeof target._slotsFromProps[prop] === "function") {
+				const result = target._slotsFromProps[prop](scopedProps);
+				if (result == null) return [];
+				return Array.isArray(result) ? result : [result];
+			}
+			const { namedSlots } = extractNamedSlotsFromChildren(target._children);
+			return namedSlots[prop] || [];
+		};
+	} });
+}
+function normalizeSubTree(result) {
+	if (result == null || result === false || result === true) return {
+		type: Text,
+		props: {},
+		key: null,
+		children: [],
+		dom: null,
+		text: ""
+	};
+	if (isComputed(result)) return normalizeSubTree(result.value);
+	if (Array.isArray(result)) return {
+		type: Fragment,
+		props: {},
+		key: null,
+		children: result,
+		dom: null
+	};
+	if (typeof result === "string" || typeof result === "number") return {
+		type: Text,
+		props: {},
+		key: null,
+		children: [],
+		dom: null,
+		text: result
+	};
+	return result;
+}
+const CLIENT_DIRECTIVE_PREFIX = "client:";
+const CLIENT_DIRECTIVES = [
+	"client:load",
+	"client:idle",
+	"client:visible",
+	"client:media",
+	"client:only"
+];
+function filterClientDirectives(props) {
+	const filtered = {};
+	for (const key in props) if (!key.startsWith("client:")) filtered[key] = props[key];
+	return filtered;
+}
+function getHydrationDirective(props) {
+	if (props["client:load"] !== void 0) return { strategy: "load" };
+	if (props["client:idle"] !== void 0) return { strategy: "idle" };
+	if (props["client:visible"] !== void 0) return { strategy: "visible" };
+	if (props["client:only"] !== void 0) return { strategy: "only" };
+	if (props["client:media"] !== void 0) return {
+		strategy: "media",
+		media: props["client:media"]
+	};
+	return null;
+}
+function hasClientDirective(props) {
+	for (const key in props) if (key.startsWith("client:")) return true;
+	return false;
+}
+function serializeProps(props) {
+	const filtered = filterClientDirectives(props);
+	const result = {};
+	let hasProps = false;
+	for (const key in filtered) {
+		const value = filtered[key];
+		if (key === "children" || key === "key" || key === "ref" || key === "slots") continue;
+		if (typeof value === "function") continue;
+		if (typeof value === "symbol") continue;
+		if (value === void 0) continue;
+		if (key.startsWith("on") && key.length > 2 && key[2] === key[2].toUpperCase()) continue;
+		try {
+			JSON.stringify(value);
+			result[key] = value;
+			hasProps = true;
+		} catch {}
+	}
+	return hasProps ? result : void 0;
+}
+function createEmit(reactiveProps) {
+	return (event, ...args) => {
+		const eventName = `on${event[0].toUpperCase() + event.slice(1)}`;
+		const handler = ("value" in reactiveProps ? reactiveProps.value : reactiveProps)?.[eventName];
+		if (handler && typeof handler === "function") handler(...args);
+	};
+}
+function createRenderer(options) {
+	const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: _hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, cloneNode: _hostCloneNode, insertStaticContent: _hostInsertStaticContent, patchDirective: hostPatchDirective, onElementMounted: hostOnElementMounted, onElementUnmounted: hostOnElementUnmounted, getActiveElement: hostGetActiveElement, restoreFocus: hostRestoreFocus } = options;
+	let currentAppContext = null;
+	function render(element, container, appContext) {
+		if (appContext) currentAppContext = appContext;
+		const oldVNode = container._vnode;
+		let vnode = null;
+		if (element != null && element !== false && element !== true) if (typeof element === "string" || typeof element === "number") vnode = {
+			type: Text,
+			props: {},
+			key: null,
+			children: [],
+			dom: null,
+			text: element
+		};
+		else if (isComponent(element)) vnode = {
+			type: element,
+			props: {},
+			key: null,
+			children: [],
+			dom: null
+		};
+		else vnode = element;
+		if (vnode) {
+			if (oldVNode) patch(oldVNode, vnode, container);
+			else mount(vnode, container);
+			container._vnode = vnode;
+		} else if (oldVNode) {
+			unmount(oldVNode, container);
+			container._vnode = null;
+		}
+	}
+	const svgTags = new Set([
+		"svg",
+		"animate",
+		"animateMotion",
+		"animateTransform",
+		"circle",
+		"clipPath",
+		"defs",
+		"desc",
+		"ellipse",
+		"feBlend",
+		"feColorMatrix",
+		"feComponentTransfer",
+		"feComposite",
+		"feConvolveMatrix",
+		"feDiffuseLighting",
+		"feDisplacementMap",
+		"feDistantLight",
+		"feDropShadow",
+		"feFlood",
+		"feFuncA",
+		"feFuncB",
+		"feFuncG",
+		"feFuncR",
+		"feGaussianBlur",
+		"feImage",
+		"feMerge",
+		"feMergeNode",
+		"feMorphology",
+		"feOffset",
+		"fePointLight",
+		"feSpecularLighting",
+		"feSpotLight",
+		"feTile",
+		"feTurbulence",
+		"filter",
+		"foreignObject",
+		"g",
+		"image",
+		"line",
+		"linearGradient",
+		"marker",
+		"mask",
+		"metadata",
+		"mpath",
+		"path",
+		"pattern",
+		"polygon",
+		"polyline",
+		"radialGradient",
+		"rect",
+		"set",
+		"stop",
+		"switch",
+		"symbol",
+		"text",
+		"textPath",
+		"title",
+		"tspan",
+		"use",
+		"view"
+	]);
+	function isSvgTag(tag) {
+		return svgTags.has(tag);
+	}
+	function mount(vnode, container, before = null, parentIsSVG = false) {
+		if (vnode == null || vnode === false || vnode === true) return;
+		if (vnode.type === Text) {
+			const node = hostCreateText(String(vnode.text));
+			vnode.dom = node;
+			node.__vnode = vnode;
+			hostInsert(node, container, before);
+			return;
+		}
+		if (vnode.type === Fragment) {
+			const anchor = hostCreateComment("");
+			vnode.dom = anchor;
+			hostInsert(anchor, container, before);
+			if (vnode.children) vnode.children.forEach((child) => mount(child, container, anchor, parentIsSVG));
+			return;
+		}
+		if (isComponent(vnode.type)) {
+			mountComponent(vnode, container, before, vnode.type.__setup);
+			return;
+		}
+		const tag = vnode.type;
+		const isSVG = tag === "svg" || parentIsSVG && tag !== "foreignObject";
+		const element = hostCreateElement(tag, isSVG);
+		vnode.dom = element;
+		element.__vnode = vnode;
+		if (vnode.props) {
+			for (const key in vnode.props) if (key !== "children" && key !== "key" && key !== "ref") if (key.charCodeAt(0) === 117 && key.startsWith("use:")) {
+				if (hostPatchDirective) hostPatchDirective(element, key.slice(4), null, vnode.props[key], currentAppContext);
+			} else hostPatchProp(element, key, null, vnode.props[key], isSVG);
+			if (vnode.props.ref) untrack(() => {
+				if (typeof vnode.props.ref === "function") vnode.props.ref(element);
+				else if (typeof vnode.props.ref === "object") vnode.props.ref.current = element;
+			});
+		}
+		const childIsSVG = isSVG && tag !== "foreignObject";
+		if (vnode.children) vnode.children.forEach((child) => {
+			child.parent = vnode;
+			mount(child, element, null, childIsSVG);
+		});
+		hostInsert(element, container, before);
+		if (hostOnElementMounted) hostOnElementMounted(element);
+	}
+	function unmount(vnode, container) {
+		const internalVNode = vnode;
+		if (internalVNode._effect) internalVNode._effect.stop();
+		if (vnode.cleanup) vnode.cleanup();
+		if (isComponent(vnode.type)) {
+			const subTree = internalVNode._subTree;
+			if (subTree) unmount(subTree, container);
+			if (vnode.dom) hostRemove(vnode.dom);
+			if (vnode.props?.ref) untrack(() => {
+				if (typeof vnode.props.ref === "function") vnode.props.ref(null);
+				else if (typeof vnode.props.ref === "object") vnode.props.ref.current = null;
+			});
+			return;
+		}
+		if (vnode.type === Fragment) {
+			if (vnode.children) vnode.children.forEach((child) => unmount(child, container));
+			if (vnode.dom) hostRemove(vnode.dom);
+			return;
+		}
+		if (vnode.props?.ref) untrack(() => {
+			if (typeof vnode.props.ref === "function") vnode.props.ref(null);
+			else if (vnode.props.ref && typeof vnode.props.ref === "object") vnode.props.ref.current = null;
+		});
+		if (hostOnElementUnmounted && vnode.dom) hostOnElementUnmounted(vnode.dom);
+		if (vnode.children && vnode.children.length > 0) vnode.children.forEach((child) => unmount(child, vnode.dom));
+		if (vnode.dom) hostRemove(vnode.dom);
+	}
+	function patch(oldVNode, newVNode, container) {
+		if (oldVNode === newVNode) return;
+		if (!isSameVNode(oldVNode, newVNode)) {
+			const parent = hostParentNode(oldVNode.dom) || container;
+			const nextSibling = oldVNode.dom ? hostNextSibling(oldVNode.dom) : null;
+			unmount(oldVNode, parent);
+			mount(newVNode, parent, nextSibling);
+			return;
+		}
+		const oldInternal = oldVNode;
+		const newInternal = newVNode;
+		if (oldInternal._effect) {
+			newVNode.dom = oldVNode.dom;
+			newInternal._effect = oldInternal._effect;
+			newInternal._subTree = oldInternal._subTree;
+			newInternal._slots = oldInternal._slots;
+			const props = oldInternal._componentProps;
+			newInternal._componentProps = props;
+			if (props) {
+				const newProps = newVNode.props || {};
+				const newModels = newVNode.props?.$models || {};
+				untrack(() => {
+					for (const key in newProps) if (key !== "children" && key !== "key" && key !== "ref" && key !== "$models") {
+						if (props[key] !== newProps[key]) props[key] = newProps[key];
+					}
+					for (const modelKey in newModels) {
+						const newModel = newModels[modelKey];
+						const oldModel = props[modelKey];
+						if (isModel(newModel)) {
+							if (isModel(oldModel)) {
+								const [newObj, newKey] = newModel.binding;
+								const [oldObj, oldKey] = oldModel.binding;
+								if (newObj === oldObj && newKey === oldKey) continue;
+							}
+							props[modelKey] = newModel;
+						}
+					}
+					for (const key in props) if (!(key in newProps) && !(key in newModels) && key !== "children" && key !== "key" && key !== "ref" && key !== "$models") delete props[key];
+				});
+			}
+			const slotsRef = oldInternal._slots;
+			const newChildren = newVNode.props?.children;
+			const newSlotsFromProps = newVNode.props?.slots;
+			if (slotsRef) {
+				if (newChildren !== void 0) slotsRef._children = newChildren;
+				if (newSlotsFromProps !== void 0) slotsRef._slotsFromProps = newSlotsFromProps;
+				if (!slotsRef._isPatching) {
+					slotsRef._isPatching = true;
+					try {
+						untrack(() => {
+							slotsRef._version.v++;
+						});
+					} finally {
+						slotsRef._isPatching = false;
+					}
+				}
+			}
+			return;
+		}
+		if (newVNode.type === Text) {
+			newVNode.dom = oldVNode.dom;
+			if (!newVNode.dom) {
+				const textNode = hostCreateText(String(newVNode.text));
+				newVNode.dom = textNode;
+				if (container) hostInsert(textNode, container, oldVNode.dom || null);
+				return;
+			}
+			if (oldVNode.text !== newVNode.text) hostSetText(newVNode.dom, String(newVNode.text));
+			return;
+		}
+		if (newVNode.type === Fragment) {
+			patchChildren(oldVNode, newVNode, container, false);
+			return;
+		}
+		const element = newVNode.dom = oldVNode.dom;
+		if (!element) {
+			mount(newVNode, container);
+			return;
+		}
+		const tag = newVNode.type;
+		const isSVG = tag === "svg" || isSvgTag(tag);
+		const oldProps = oldVNode.props || {};
+		const newProps = newVNode.props || {};
+		for (const key in oldProps) if (!(key in newProps) && key !== "children" && key !== "key" && key !== "ref") if (key.charCodeAt(0) === 117 && key.startsWith("use:")) {
+			if (hostPatchDirective) hostPatchDirective(element, key.slice(4), oldProps[key], null, currentAppContext);
+		} else hostPatchProp(element, key, oldProps[key], null, isSVG);
+		for (const key in newProps) {
+			const oldValue = oldProps[key];
+			const newValue = newProps[key];
+			if (key !== "children" && key !== "key" && key !== "ref" && oldValue !== newValue) if (key.charCodeAt(0) === 117 && key.startsWith("use:")) {
+				if (hostPatchDirective) hostPatchDirective(element, key.slice(4), oldValue, newValue, currentAppContext);
+			} else hostPatchProp(element, key, oldValue, newValue, isSVG);
+		}
+		patchChildren(oldVNode, newVNode, element, isSVG && tag !== "foreignObject");
+	}
+	function patchChildren(oldVNode, newVNode, container, parentIsSVG = false) {
+		const oldChildren = oldVNode.children;
+		const newChildren = newVNode.children;
+		newChildren.forEach((c) => c.parent = newVNode);
+		reconcileChildrenArray(container, oldChildren, newChildren, parentIsSVG);
+	}
+	function checkDuplicateKeys(children) {
+		if (process.env.NODE_ENV === "production") return;
+		const seenKeys = /* @__PURE__ */ new Set();
+		for (const child of children) if (child?.key != null) {
+			const keyStr = String(child.key);
+			if (seenKeys.has(keyStr)) console.warn(`[SignalX] Duplicate key "${child.key}" detected in list. Keys should be unique among siblings to ensure correct reconciliation. This may cause unexpected behavior when items are reordered, added, or removed.`);
+			seenKeys.add(keyStr);
+		}
+	}
+	function reconcileChildrenArray(parent, oldChildren, newChildren, parentIsSVG = false) {
+		if (process.env.NODE_ENV !== "production") checkDuplicateKeys(newChildren);
+		let oldStartIdx = 0;
+		let oldEndIdx = oldChildren.length - 1;
+		let oldStartVNode = oldChildren[0];
+		let oldEndVNode = oldChildren[oldEndIdx];
+		let newStartIdx = 0;
+		let newEndIdx = newChildren.length - 1;
+		let newStartVNode = newChildren[0];
+		let newEndVNode = newChildren[newEndIdx];
+		let oldKeyToIdx;
+		while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) if (oldStartVNode == null) oldStartVNode = oldChildren[++oldStartIdx];
+		else if (oldEndVNode == null) oldEndVNode = oldChildren[--oldEndIdx];
+		else if (isSameVNode(oldStartVNode, newStartVNode)) {
+			patch(oldStartVNode, newStartVNode, parent);
+			oldStartVNode = oldChildren[++oldStartIdx];
+			newStartVNode = newChildren[++newStartIdx];
+		} else if (isSameVNode(oldEndVNode, newEndVNode)) {
+			patch(oldEndVNode, newEndVNode, parent);
+			oldEndVNode = oldChildren[--oldEndIdx];
+			newEndVNode = newChildren[--newEndIdx];
+		} else if (isSameVNode(oldStartVNode, newEndVNode)) {
+			patch(oldStartVNode, newEndVNode, parent);
+			const nodeToMove = oldStartVNode.dom;
+			const anchor = hostNextSibling(oldEndVNode.dom);
+			if (nodeToMove) hostInsert(nodeToMove, parent, anchor);
+			oldStartVNode = oldChildren[++oldStartIdx];
+			newEndVNode = newChildren[--newEndIdx];
+		} else if (isSameVNode(oldEndVNode, newStartVNode)) {
+			patch(oldEndVNode, newStartVNode, parent);
+			const nodeToMove = oldEndVNode.dom;
+			const anchor = oldStartVNode.dom;
+			if (nodeToMove) hostInsert(nodeToMove, parent, anchor);
+			oldEndVNode = oldChildren[--oldEndIdx];
+			newStartVNode = newChildren[++newStartIdx];
+		} else {
+			if (!oldKeyToIdx) oldKeyToIdx = createKeyToKeyIndexMap(oldChildren, oldStartIdx, oldEndIdx);
+			const idxInOld = newStartVNode.key != null ? oldKeyToIdx.get(String(newStartVNode.key)) : findIndexInOld(oldChildren, newStartVNode, oldStartIdx, oldEndIdx);
+			if (idxInOld != null) {
+				const vnodeToMove = oldChildren[idxInOld];
+				patch(vnodeToMove, newStartVNode, parent);
+				oldChildren[idxInOld] = void 0;
+				if (vnodeToMove.dom && oldStartVNode.dom) hostInsert(vnodeToMove.dom, parent, oldStartVNode.dom);
+			} else mount(newStartVNode, parent, oldStartVNode.dom, parentIsSVG);
+			newStartVNode = newChildren[++newStartIdx];
+		}
+		if (oldStartIdx > oldEndIdx) {
+			if (newStartIdx <= newEndIdx) {
+				const anchor = newChildren[newEndIdx + 1] == null ? null : newChildren[newEndIdx + 1].dom;
+				for (let i = newStartIdx; i <= newEndIdx; i++) mount(newChildren[i], parent, anchor, parentIsSVG);
+			}
+		} else if (newStartIdx > newEndIdx) {
+			for (let i = oldStartIdx; i <= oldEndIdx; i++) if (oldChildren[i]) unmount(oldChildren[i], parent);
+		}
+	}
+	function isSameVNode(n1, n2) {
+		const k1 = n1.key == null ? null : n1.key;
+		const k2 = n2.key == null ? null : n2.key;
+		if (n1.type !== n2.type) return false;
+		if (k1 === k2) return true;
+		return String(k1) === String(k2);
+	}
+	function createKeyToKeyIndexMap(children, beginIdx, endIdx) {
+		const map = /* @__PURE__ */ new Map();
+		for (let i = beginIdx; i <= endIdx; i++) {
+			const key = children[i]?.key;
+			if (key != null) {
+				const keyStr = String(key);
+				if (process.env.NODE_ENV !== "production" && map.has(keyStr)) console.warn(`[SignalX] Duplicate key "${key}" detected in list. Keys should be unique among siblings to ensure correct reconciliation. This may cause unexpected behavior when items are reordered, added, or removed.`);
+				map.set(keyStr, i);
+			}
+		}
+		return map;
+	}
+	function findIndexInOld(children, newChild, beginIdx, endIdx) {
+		for (let i = beginIdx; i <= endIdx; i++) if (children[i] && isSameVNode(children[i], newChild)) return i;
+		return null;
+	}
+	function mountComponent(vnode, container, before, setup) {
+		const anchor = hostCreateComment("");
+		vnode.dom = anchor;
+		anchor.__vnode = vnode;
+		hostInsert(anchor, container, before);
+		let exposed = null;
+		let exposeCalled = false;
+		const { children, slots: slotsFromProps, $models: modelsData, ...propsData } = vnode.props || {};
+		const propsWithModels = { ...propsData };
+		if (modelsData) for (const modelKey in modelsData) {
+			const modelValue = modelsData[modelKey];
+			if (isModel(modelValue)) propsWithModels[modelKey] = modelValue;
+		}
+		const reactiveProps = signal(propsWithModels);
+		const internalVNode = vnode;
+		internalVNode._componentProps = reactiveProps;
+		const slots = createSlots(children, slotsFromProps);
+		internalVNode._slots = slots;
+		const createdHooks = [];
+		const mountHooks = [];
+		const updatedHooks = [];
+		const unmountHooks = [];
+		const parentInstance = getCurrentInstance();
+		const componentName = vnode.type.__name;
+		const ctx = {
+			el: container,
+			signal,
+			props: createPropsAccessor(reactiveProps),
+			slots,
+			emit: createEmit(reactiveProps),
+			parent: parentInstance,
+			onMounted: (fn) => {
+				mountHooks.push(fn);
+			},
+			onUnmounted: (fn) => {
+				unmountHooks.push(fn);
+			},
+			onCreated: (fn) => {
+				createdHooks.push(fn);
+			},
+			onUpdated: (fn) => {
+				updatedHooks.push(fn);
+			},
+			expose: (exposedValue) => {
+				exposed = exposedValue;
+				exposeCalled = true;
+			},
+			renderFn: null,
+			update: () => {}
+		};
+		applyContextExtensions(ctx);
+		ctx.__name = componentName;
+		if (!parentInstance && currentAppContext) provideAppContext(ctx, currentAppContext);
+		const componentInstance = {
+			name: componentName,
+			ctx,
+			vnode
+		};
+		const prev = setCurrentInstance(ctx);
+		let renderFn;
+		try {
+			const setupResult = setup(ctx);
+			if (setupResult && typeof setupResult.then === "function") throw new Error(`Async setup in component "${componentName}" is only supported during SSR. On the client, use pre-loaded data from hydration or fetch in onMounted.`);
+			renderFn = setupResult;
+			notifyComponentCreated(currentAppContext, componentInstance);
+			createdHooks.forEach((hook) => hook());
+		} catch (err) {
+			if (!handleComponentError(currentAppContext, err, componentInstance, "setup")) throw err;
+		} finally {
+			setCurrentInstance(prev);
+		}
+		if (vnode.props?.ref) {
+			const refValue = exposeCalled ? exposed : null;
+			untrack(() => {
+				if (typeof vnode.props.ref === "function") vnode.props.ref(refValue);
+				else if (vnode.props.ref && typeof vnode.props.ref === "object") vnode.props.ref.current = refValue;
+			});
+		}
+		if (renderFn) {
+			ctx.renderFn = renderFn;
+			const componentEffect = effect(() => {
+				const prevInstance = setCurrentInstance(ctx);
+				try {
+					const subTreeResult = ctx.renderFn();
+					if (subTreeResult == null) return;
+					const subTree = normalizeSubTree(subTreeResult);
+					const prevSubTree = internalVNode._subTree;
+					if (prevSubTree) {
+						const prevFocus = hostGetActiveElement ? hostGetActiveElement() : null;
+						patch(prevSubTree, subTree, container);
+						if (prevFocus && hostRestoreFocus && hostGetActiveElement() !== prevFocus) hostRestoreFocus(prevFocus);
+						notifyComponentUpdated(currentAppContext, componentInstance);
+						updatedHooks.forEach((hook) => hook());
+					} else mount(subTree, container, anchor);
+					internalVNode._subTree = subTree;
+				} catch (err) {
+					if (!handleComponentError(currentAppContext, err, componentInstance, "render")) throw err;
+				} finally {
+					setCurrentInstance(prevInstance);
+				}
+			});
+			internalVNode._effect = componentEffect;
+			ctx.update = () => {
+				componentEffect();
+			};
+		}
+		const mountCtx = { el: container };
+		mountHooks.forEach((hook) => hook(mountCtx));
+		notifyComponentMounted(currentAppContext, componentInstance);
+		vnode.cleanup = () => {
+			notifyComponentUnmounted(currentAppContext, componentInstance);
+			unmountHooks.forEach((hook) => hook(mountCtx));
+		};
+	}
+	return {
+		render,
+		patch,
+		mount,
+		unmount,
+		mountComponent
+	};
+}
+export { runInRequestScope as $, handleComponentError as A, defineProvide as B, setPlatformModelProcessor as C, isModel as D, getModelSymbol as E, setDefaultMount as F, getComponentMeta as G, provideAppContext as H, __DIRECTIVE__ as I, onMounted as J, getCurrentInstance as K, defineDirective as L, notifyComponentMounted as M, notifyComponentUnmounted as N, defineApp as O, notifyComponentUpdated as P, hasRequestIsolation as Q, isDirective as R, getPlatformModelProcessor as S, createModelFromBinding as T, useAppContext as U, getAppContextToken as V, component as W, onUpdated as X, onUnmounted as Y, setCurrentInstance as Z, Text as _, filterClientDirectives as a, jsxs as b, serializeProps as c, createPropsAccessor as d, applyContextExtensions as et, Suspense as f, Fragment as g, registerPendingPromise as h, createEmit as i, notifyComponentCreated as j, getDefaultMount as k, normalizeSubTree as l, lazy as m, CLIENT_DIRECTIVES as n, registerComponentPlugin as nt, getHydrationDirective as o, isLazyComponent as p, onCreated as q, CLIENT_DIRECTIVE_PREFIX as r, registerContextExtension as rt, hasClientDirective as s, createRenderer as t, getComponentPlugins as tt, createSlots as u, jsx as v, createModel as w, isComponent as x, jsxDEV as y, defineInjectable as z };
+
+//# sourceMappingURL=renderer-KQIgreMb.js.map