@fluixi/core 1.0.0-alpha.53

package/dist/src/lib/utils/index.js

@@ -0,0 +1,527 @@
+/**
+ * @fileoverview General utilities for Fluixi
+ * @module @fluixi/core/utils
+ *
+ * This module provides general utility functions for common operations.
+ */
+/**
+ * Debounces a function call
+ *
+ * @template T - Function type
+ * @param {T} fn - Function to debounce
+ * @param {number} delay - Delay in milliseconds
+ * @returns {(...args: Parameters<T>) => void} Debounced function
+ *
+ * @example
+ * ```typescript
+ * import { debounce } from '@fluixi/core/utils';
+ *
+ * const handleInput = debounce((value: string) => {
+ *   console.log('Input:', value);
+ * }, 300);
+ * ```
+ */
+export function debounce(fn, delay) {
+    let timeoutId;
+    return (...args) => {
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => fn(...args), delay);
+    };
+}
+/**
+ * Throttles a function call
+ *
+ * @template T - Function type
+ * @param {T} fn - Function to throttle
+ * @param {number} limit - Time limit in milliseconds
+ * @returns {(...args: Parameters<T>) => void} Throttled function
+ *
+ * @example
+ * ```typescript
+ * import { throttle } from '@fluixi/core/utils';
+ *
+ * const handleScroll = throttle(() => {
+ *   console.log('Scrolled');
+ * }, 100);
+ * ```
+ */
+export function throttle(fn, limit) {
+    let inThrottle;
+    return (...args) => {
+        if (!inThrottle) {
+            fn(...args);
+            inThrottle = true;
+            setTimeout(() => (inThrottle = false), limit);
+        }
+    };
+}
+/**
+ * Creates a memoized version of a function
+ *
+ * @template T - Function type
+ * @param {T} fn - Function to memoize
+ * @returns {T} Memoized function
+ *
+ * @example
+ * ```typescript
+ * import { memoize } from '@fluixi/core/utils';
+ *
+ * const expensiveCalc = memoize((n: number) => {
+ *   return n * n;
+ * });
+ * ```
+ */
+export function memoize(fn) {
+    const cache = new Map();
+    return ((...args) => {
+        const key = JSON.stringify(args);
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const result = fn(...args);
+        cache.set(key, result);
+        return result;
+    });
+}
+/**
+ * Deep clones an object
+ *
+ * @template T - Object type
+ * @param {T} obj - Object to clone
+ * @returns {T} Cloned object
+ *
+ * @example
+ * ```typescript
+ * import { deepClone } from '@fluixi/core/utils';
+ *
+ * const original = { a: 1, b: { c: 2 } };
+ * const copy = deepClone(original);
+ * ```
+ */
+export function deepClone(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (obj instanceof Date) {
+        return new Date(obj.getTime());
+    }
+    if (obj instanceof Array) {
+        return Array.from(obj).map((item) => deepClone(item));
+    }
+    if (obj instanceof Set) {
+        return new Set(Array.from(obj).map((item) => deepClone(item)));
+    }
+    if (obj instanceof Map) {
+        return new Map(Array.from(obj.entries()).map(([key, value]) => [
+            deepClone(key),
+            deepClone(value),
+        ]));
+    }
+    const clonedObj = {};
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            clonedObj[key] = deepClone(obj[key]);
+        }
+    }
+    return clonedObj;
+}
+/**
+ * Deep merges multiple objects
+ *
+ * @template T - Object type
+ * @param {...Partial<T>[]} objects - Objects to merge
+ * @returns {T} Merged object
+ *
+ * @example
+ * ```typescript
+ * import { deepMerge } from '@fluixi/core/utils';
+ *
+ * const result = deepMerge(
+ *   { a: 1, b: { c: 2 } },
+ *   { b: { d: 3 } }
+ * );
+ * // { a: 1, b: { c: 2, d: 3 } }
+ * ```
+ */
+export function deepMerge(...objects) {
+    const result = {};
+    for (const obj of objects) {
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                const value = obj[key];
+                if (value !== null &&
+                    typeof value === 'object' &&
+                    !Array.isArray(value)) {
+                    result[key] = deepMerge(result[key] || {}, value);
+                }
+                else {
+                    result[key] = value;
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Generates a unique ID
+ *
+ * @param {string} prefix - Optional prefix
+ * @returns {string} Unique ID
+ *
+ * @example
+ * ```typescript
+ * import { uniqueId } from '@fluixi/core/utils';
+ *
+ * const id = uniqueId('component-');
+ * // 'component-abc123def456'
+ * ```
+ */
+export function uniqueId(prefix = '') {
+    return prefix + Math.random().toString(36).substr(2, 9);
+}
+/**
+ * Formats a number with commas
+ *
+ * @param {number} num - Number to format
+ * @returns {string} Formatted number
+ *
+ * @example
+ * ```typescript
+ * import { formatNumber } from '@fluixi/core/utils';
+ *
+ * formatNumber(1234567); // '1,234,567'
+ * ```
+ */
+export function formatNumber(num) {
+    return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+/**
+ * Formats bytes to human readable string
+ *
+ * @param {number} bytes - Number of bytes
+ * @param {number} decimals - Decimal places (default: 2)
+ * @returns {string} Formatted string
+ *
+ * @example
+ * ```typescript
+ * import { formatBytes } from '@fluixi/core/utils';
+ *
+ * formatBytes(1024); // '1 KB'
+ * formatBytes(1048576); // '1 MB'
+ * ```
+ */
+export function formatBytes(bytes, decimals = 2) {
+    if (bytes === 0)
+        return '0 Bytes';
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+}
+/**
+ * Capitalizes first letter of a string
+ *
+ * @param {string} str - String to capitalize
+ * @returns {string} Capitalized string
+ *
+ * @example
+ * ```typescript
+ * import { capitalize } from '@fluixi/core/utils';
+ *
+ * capitalize('hello'); // 'Hello'
+ * ```
+ */
+export function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Converts string to kebab-case
+ *
+ * @param {string} str - String to convert
+ * @returns {string} Kebab-case string
+ *
+ * @example
+ * ```typescript
+ * import { kebabCase } from '@fluixi/core/utils';
+ *
+ * kebabCase('HelloWorld'); // 'hello-world'
+ * ```
+ */
+export function kebabCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+/**
+ * Converts string to camelCase
+ *
+ * @param {string} str - String to convert
+ * @returns {string} CamelCase string
+ *
+ * @example
+ * ```typescript
+ * import { camelCase } from '@fluixi/core/utils';
+ *
+ * camelCase('hello-world'); // 'helloWorld'
+ * ```
+ */
+export function camelCase(str) {
+    return str.replace(/[-_\s](.)/g, (_, char) => char.toUpperCase());
+}
+/**
+ * Clamps a number between min and max
+ *
+ * @param {number} value - Value to clamp
+ * @param {number} min - Minimum value
+ * @param {number} max - Maximum value
+ * @returns {number} Clamped value
+ *
+ * @example
+ * ```typescript
+ * import { clamp } from '@fluixi/core/utils';
+ *
+ * clamp(5, 0, 10); // 5
+ * clamp(-5, 0, 10); // 0
+ * clamp(15, 0, 10); // 10
+ * ```
+ */
+export function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+/**
+ * Generates a random number between min and max
+ *
+ * @param {number} min - Minimum value
+ * @param {number} max - Maximum value
+ * @returns {number} Random number
+ *
+ * @example
+ * ```typescript
+ * import { random } from '@fluixi/core/utils';
+ *
+ * const num = random(1, 100);
+ * ```
+ */
+export function random(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+/**
+ * Checks if a value is empty
+ *
+ * @param {any} value - Value to check
+ * @returns {boolean} True if empty
+ *
+ * @example
+ * ```typescript
+ * import { isEmpty } from '@fluixi/core/utils';
+ *
+ * isEmpty(''); // true
+ * isEmpty([]); // true
+ * isEmpty({}); // true
+ * isEmpty(null); // true
+ * isEmpty('text'); // false
+ * ```
+ */
+export function isEmpty(value) {
+    if (value === null || value === undefined)
+        return true;
+    if (typeof value === 'string')
+        return value.trim().length === 0;
+    if (Array.isArray(value))
+        return value.length === 0;
+    if (typeof value === 'object')
+        return Object.keys(value).length === 0;
+    return false;
+}
+/**
+ * Picks specific keys from an object
+ *
+ * @template T - Object type
+ * @template K - Keys to pick
+ * @param {T} obj - Source object
+ * @param {...K[]} keys - Keys to pick
+ * @returns {Pick<T, K>} Object with picked keys
+ *
+ * @example
+ * ```typescript
+ * import { pick } from '@fluixi/core/utils';
+ *
+ * const obj = { a: 1, b: 2, c: 3 };
+ * pick(obj, 'a', 'c'); // { a: 1, c: 3 }
+ * ```
+ */
+export function pick(obj, ...keys) {
+    const result = {};
+    keys.forEach((key) => {
+        if (key in obj) {
+            result[key] = obj[key];
+        }
+    });
+    return result;
+}
+/**
+ * Omits specific keys from an object
+ *
+ * @template T - Object type
+ * @template K - Keys to omit
+ * @param {T} obj - Source object
+ * @param {...K[]} keys - Keys to omit
+ * @returns {Omit<T, K>} Object without omitted keys
+ *
+ * @example
+ * ```typescript
+ * import { omit } from '@fluixi/core/utils';
+ *
+ * const obj = { a: 1, b: 2, c: 3 };
+ * omit(obj, 'b'); // { a: 1, c: 3 }
+ * ```
+ */
+export function omit(obj, ...keys) {
+    const result = { ...obj };
+    keys.forEach((key) => {
+        delete result[key];
+    });
+    return result;
+}
+/**
+ * Groups array items by a key
+ *
+ * @template T - Array item type
+ * @template K - Key type
+ * @param {T[]} array - Array to group
+ * @param {(item: T) => K} fn - Key extraction function
+ * @returns {Map<K, T[]>} Grouped items
+ *
+ * @example
+ * ```typescript
+ * import { groupBy } from '@fluixi/core/utils';
+ *
+ * const users = [
+ *   { name: 'Alice', role: 'admin' },
+ *   { name: 'Bob', role: 'user' },
+ *   { name: 'Charlie', role: 'admin' }
+ * ];
+ * const grouped = groupBy(users, u => u.role);
+ * // Map { 'admin' => [...], 'user' => [...] }
+ * ```
+ */
+export function groupBy(array, fn) {
+    return array.reduce((acc, item) => {
+        const key = fn(item);
+        const group = acc.get(key) || [];
+        group.push(item);
+        acc.set(key, group);
+        return acc;
+    }, new Map());
+}
+/**
+ * Creates an array of numbers from start to end
+ *
+ * @param {number} start - Start number
+ * @param {number} end - End number
+ * @param {number} step - Step size (default: 1)
+ * @returns {number[]} Array of numbers
+ *
+ * @example
+ * ```typescript
+ * import { range } from '@fluixi/core/utils';
+ *
+ * range(0, 5); // [0, 1, 2, 3, 4, 5]
+ * range(0, 10, 2); // [0, 2, 4, 6, 8, 10]
+ * ```
+ */
+export function range(start, end, step = 1) {
+    const result = [];
+    for (let i = start; i <= end; i += step) {
+        result.push(i);
+    }
+    return result;
+}
+/**
+ * Retries an async function
+ *
+ * @template T - Return type
+ * @param {() => Promise<T>} fn - Async function to retry
+ * @param {number} retries - Number of retries (default: 3)
+ * @param {number} delay - Delay between retries in ms (default: 1000)
+ * @returns {Promise<T>} Promise that resolves with the result
+ *
+ * @example
+ * ```typescript
+ * import { retry } from '@fluixi/core/utils';
+ *
+ * const data = await retry(
+ *   () => fetch('/api/data').then(r => r.json()),
+ *   3,
+ *   1000
+ * );
+ * ```
+ */
+export async function retry(fn, retries = 3, delay = 1000) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        if (retries <= 0)
+            throw error;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        return retry(fn, retries - 1, delay);
+    }
+}
+/**
+ * Sleep for specified milliseconds
+ *
+ * @param {number} ms - Milliseconds to sleep
+ * @returns {Promise<void>} Promise that resolves after delay
+ *
+ * @example
+ * ```typescript
+ * import { sleep } from '@fluixi/core/utils';
+ *
+ * await sleep(1000); // Wait 1 second
+ * ```
+ */
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Type guard to check if value is defined
+ *
+ * @template T - Value type
+ * @param {T | null | undefined} value - Value to check
+ * @returns {value is T} True if value is defined
+ *
+ * @example
+ * ```typescript
+ * import { isDefined } from '@fluixi/core/utils';
+ *
+ * const values = [1, null, 2, undefined, 3];
+ * const defined = values.filter(isDefined); // [1, 2, 3]
+ * ```
+ */
+export function isDefined(value) {
+    return value !== null && value !== undefined;
+}
+/**
+ * Creates a chainable pipe function
+ *
+ * @param {...Function[]} fns - Functions to chain
+ * @returns {Function} Piped function
+ *
+ * @example
+ * ```typescript
+ * import { pipe } from '@fluixi/core/utils';
+ *
+ * const transform = pipe(
+ *   (x: number) => x * 2,
+ *   (x: number) => x + 1,
+ *   (x: number) => x.toString()
+ * );
+ * transform(5); // '11'
+ * ```
+ */
+export function pipe(...fns) {
+    return (arg) => fns.reduce((acc, fn) => fn(acc), arg);
+}

package/dist/src/lib/utils/index.mjs

@@ -0,0 +1 @@
+function c(e,t){let r;return(...n)=>{clearTimeout(r),r=setTimeout(()=>e(...n),t)}}function f(e,t){let r;return(...n)=>{r||(e(...n),r=!0,setTimeout(()=>r=!1,t))}}function T(e){let t=new Map;return((...r)=>{let n=JSON.stringify(r);if(t.has(n))return t.get(n);let o=e(...r);return t.set(n,o),o})}function a(e){if(e===null||typeof e!="object")return e;if(e instanceof Date)return new Date(e.getTime());if(e instanceof Array)return Array.from(e).map(r=>a(r));if(e instanceof Set)return new Set(Array.from(e).map(r=>a(r)));if(e instanceof Map)return new Map(Array.from(e.entries()).map(([r,n])=>[a(r),a(n)]));let t={};for(let r in e)e.hasOwnProperty(r)&&(t[r]=a(e[r]));return t}function i(...e){let t={};for(let r of e)for(let n in r)if(r.hasOwnProperty(n)){let o=r[n];o!==null&&typeof o=="object"&&!Array.isArray(o)?t[n]=i(t[n]||{},o):t[n]=o}return t}function p(e=""){return e+Math.random().toString(36).substr(2,9)}function m(e){return e.toString().replace(/\B(?=(\d{3})+(?!\d))/g,",")}function y(e,t=2){if(e===0)return"0 Bytes";let r=1024,n=t<0?0:t,o=["Bytes","KB","MB","GB","TB","PB"],s=Math.floor(Math.log(e)/Math.log(r));return parseFloat((e/Math.pow(r,s)).toFixed(n))+" "+o[s]}function g(e){return e.charAt(0).toUpperCase()+e.slice(1)}function l(e){return e.replace(/([a-z])([A-Z])/g,"$1-$2").replace(/[\s_]+/g,"-").toLowerCase()}function x(e){return e.replace(/[-_\s](.)/g,(t,r)=>r.toUpperCase())}function d(e,t,r){return Math.min(Math.max(e,t),r)}function h(e,t){return Math.floor(Math.random()*(t-e+1))+e}function b(e){return e==null?!0:typeof e=="string"?e.trim().length===0:Array.isArray(e)?e.length===0:typeof e=="object"?Object.keys(e).length===0:!1}function M(e,...t){let r={};return t.forEach(n=>{n in e&&(r[n]=e[n])}),r}function P(e,...t){let r={...e};return t.forEach(n=>{delete r[n]}),r}function w(e,t){return e.reduce((r,n)=>{let o=t(n),s=r.get(o)||[];return s.push(n),r.set(o,s),r},new Map)}function K(e,t,r=1){let n=[];for(let o=e;o<=t;o+=r)n.push(o);return n}async function u(e,t=3,r=1e3){try{return await e()}catch(n){if(t<=0)throw n;return await new Promise(o=>setTimeout(o,r)),u(e,t-1,r)}}function k(e){return new Promise(t=>setTimeout(t,e))}function A(e){return e!=null}function B(...e){return t=>e.reduce((r,n)=>n(r),t)}export{x as camelCase,g as capitalize,d as clamp,c as debounce,a as deepClone,i as deepMerge,y as formatBytes,m as formatNumber,w as groupBy,A as isDefined,b as isEmpty,l as kebabCase,T as memoize,P as omit,M as pick,B as pipe,h as random,K as range,u as retry,k as sleep,f as throttle,p as uniqueId};

package/dist/src/rx.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/src/rx.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rx.d.ts.map

package/dist/src/rx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rx.d.ts","sourceRoot":"","sources":["../../src/rx.ts"],"names":[],"mappings":""}

package/dist/src/rx.js

@@ -0,0 +1,101 @@
+// /**
+//  * @fileoverview Reactive Primitives Export for Fluixi
+//  * @module @fluixi/core/rx
+//  *
+//  * This module provides a convenient alias for importing reactive primitives.
+//  * It re-exports all reactive functions from @fluixi/reactive/signal.
+//  *
+//  * Usage:
+//  * ```typescript
+//  * import { createSignal, createEffect, createMemo } from '@fluixi/core/rx';
+//  * ```
+//  *
+//  * This is equivalent to:
+//  * ```typescript
+//  * import { createSignal, createEffect, createMemo } from '@fluixi/reactive/signal';
+//  * ```
+//  *
+//  * Note: The Babel plugin automatically transforms '@fluixi/core/rx' imports
+//  * to '@fluixi/reactive/signal' for optimal bundling.
+//  */
+export {};
+// // Re-export all reactive primitives from @fluixi/reactive/signal
+// export {
+//   // Core signals
+//   createSignal,
+//   createEffect,
+//   createMemo,
+//   createRoot,
+//   // Batching and tracking
+//   batch,
+//   untrack,
+//   // Ownership
+//   getOwner,
+//   runWithOwner,
+//   // Cleanup
+//   onCleanup,
+//   // Context
+//   createContext,
+//   useContext,
+//   // Additional reactive primitives
+//   createComputed,
+//   createRenderEffect,
+//   createDeferred,
+//   createSelector,
+//   // Utilities
+//   from,
+//   observable,
+//   mapArray,
+//   indexArray,
+// } from '@fluixi/reactive/signal';
+// // Re-export types
+// export type {
+//   Signal,
+//   Accessor,
+//   Setter,
+//   SignalOptions,
+//   Owner,
+//   Context,
+//   Effect,
+//   EffectOptions,
+//   Memo,
+//   MemoOptions,
+// } from '@fluixi/reactive/signal';
+// /**
+//  * Default export for convenience
+//  */
+// export default {
+//   createSignal,
+//   createEffect,
+//   createMemo,
+//   createRoot,
+//   batch,
+//   untrack,
+//   getOwner,
+//   runWithOwner,
+//   onCleanup,
+//   createContext,
+//   useContext,
+// };
+// // Note: Import from '@fluixi/reactive/signal' directly
+// import {
+//   createSignal,
+//   createEffect,
+//   createMemo,
+//   createRoot,
+//   batch,
+//   untrack,
+//   getOwner,
+//   runWithOwner,
+//   onCleanup,
+//   createContext,
+//   useContext,
+//   createComputed,
+//   createRenderEffect,
+//   createDeferred,
+//   createSelector,
+//   from,
+//   observable,
+//   mapArray,
+//   indexArray,
+// } from '@fluixi/reactive/signal';

package/dist/src/server.cjs

@@ -0,0 +1,16 @@
+"use strict";var T=Object.defineProperty;var st=Object.getOwnPropertyDescriptor;var ct=Object.getOwnPropertyNames;var ut=Object.prototype.hasOwnProperty;var dt=(t,e)=>{for(var n in e)T(t,n,{get:e[n],enumerable:!0})},lt=(t,e,n,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of ct(e))!ut.call(t,o)&&o!==n&&T(t,o,{get:()=>e[o],enumerable:!(r=st(e,o))||r.enumerable});return t};var pt=t=>lt(T({},"__esModule",{value:!0}),t);var St={};dt(St,{batch:()=>I,cleanupHydration:()=>m,clearHydrationData:()=>g,clearHydrationDataKey:()=>H,createComputed:()=>P,createContext:()=>U,createDeferred:()=>X,createEffect:()=>f,createHtmlDocument:()=>tt,createHydratableResource:()=>k,createMemo:()=>S,createRenderEffect:()=>V,createResource:()=>J,createRoot:()=>F,createSelector:()=>B,createSignal:()=>K,deserializeHydrationData:()=>b,getHydrationData:()=>d,getOwner:()=>W,getSSRContext:()=>ft,hasHydrationData:()=>R,hydrationMarker:()=>O,hydrationMarkerEnd:()=>A,hydrationMarkerStart:()=>E,isClient:()=>nt,isClientEnvironment:()=>M,isClientReactive:()=>Q,isHydrating:()=>x,isServer:()=>et,isServerEnvironment:()=>j,isServerReactive:()=>G,onCleanup:()=>z,onClient:()=>gt,onServer:()=>xt,renderToPage:()=>Z,renderToStream:()=>rt,renderToString:()=>h,runWithOwner:()=>L,serializeHydrationData:()=>l,setHydrating:()=>D,setHydrationData:()=>u,setSSRContext:()=>yt,startServer:()=>mt,startTransition:()=>q,untrack:()=>N,useContext:()=>Y,useHydrationData:()=>_,withSSRContext:()=>Tt});module.exports=pt(St);var C=!1,a=new Map;function x(){return C}function D(t){C=t}function u(t,e){a.set(t,e)}function d(t){return a.get(t)}function R(t){return a.has(t)}function g(){a.clear()}function H(t){a.delete(t)}function l(){if(a.size===0)return"";let t=Object.fromEntries(a);return`<script type="application/json" id="__FLUIXI_HYDRATION__">${JSON.stringify(t)}<\/script>`}function b(){if(typeof window>"u")return!1;let t=document.getElementById("__FLUIXI_HYDRATION__");if(!t||t.getAttribute("type")!=="application/json")return!1;try{let e=t.textContent||"{}",n=JSON.parse(e);for(let[r,o]of Object.entries(n))a.set(r,o);return!0}catch(e){return console.error("Failed to deserialize hydration data:",e),!1}}function O(t){return`<!--#${t}-->`}function E(t){return`<!--#${t}-->`}function A(t){return`<!--/${t}-->`}function k(t,e){return async()=>{if(x()||typeof window<"u"){let r=d(t);if(r!==void 0)return r}let n=await e();return typeof window>"u"&&u(t,n),n}}function _(t,e){let n=d(t);if(n!==void 0)return n;let r=typeof e=="function"?e():e;return typeof window>"u"&&u(t,r),r}function m(){if(typeof window>"u")return;let t=document.getElementById("__FLUIXI_HYDRATION__");t&&t.remove();let e=document.createTreeWalker(document.body,NodeFilter.SHOW_COMMENT,null),n=[],r;for(;r=e.nextNode();){let o=r,i=o.nodeValue||"";(i.startsWith("#")||i.startsWith("/"))&&n.push(o)}n.forEach(o=>o.remove()),g()}typeof window<"u"&&window.addEventListener("load",()=>{setTimeout(m,100)});function j(){return typeof window>"u"}function M(){return typeof window<"u"}var v=require("@fluixi/server");function K(t,e){let n=t;return[(()=>n),i=>(typeof i=="function"?n=i(n):n=i,n)]}function f(t,e,n){try{t(e)}catch(r){console.error("[Fluixi Server] Effect error:",r)}return{dispose:()=>{}}}function S(t,e,n){let r=t(e);return(()=>r)}function F(t){let e=[],n=()=>{e.forEach(r=>{try{r()}catch(o){console.error("[Fluixi Server] Cleanup error:",o)}}),e.length=0};try{return t(n)}catch(r){throw n(),r}}function I(t){return t()}function N(t){return t()}var $=null;function z(t){$&&$.push(t)}var p=null;function W(){return p}function L(t,e){let n=p;p=t;try{return e()}finally{p=n}}var s=new Map;function U(t){let e=Symbol("context");return{id:e,Provider:r=>{let o=s.get(e);s.set(e,r.value);try{return r.children}finally{o!==void 0?s.set(e,o):s.delete(e)}},defaultValue:t}}function Y(t){let e=s.get(t.id);return e!==void 0?e:t.defaultValue}function P(t){return f(t)}function V(t){return f(t)}function X(t){return S(t)}function B(t){let e=t();return n=>n===e}function J(t,e,n){return[()=>{},{mutate:r=>r,refetch:()=>{}}]}function q(t){t()}var G=!0,Q=!1;var c=null;function ft(){return c}function yt(t){c=t}function Tt(t,e){let n=c;c=t;try{return e()}finally{c=n}}async function Z(t,e={}){let n=await h(t);return tt(n,e)}function tt(t,e={}){let{title:n="Fluixi App",lang:r="en",stylesheets:o=[],scripts:i=[],head:ot="",bodyAttributes:w=""}=e,it=o.map(y=>`<link rel="stylesheet" href="${y}">`).join(`
+    `),at=i.map(y=>`<script type="module" src="${y}"><\/script>`).join(`
+    `);return`<!DOCTYPE html>
+<html lang="${r}">
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${n}</title>
+    ${it}
+    ${ot}
+  </head>
+  <body${w?" "+w:""}>
+    ${t}
+    ${at}
+  </body>
+</html>`}function et(){return typeof window>"u"}function nt(){return typeof window<"u"}function xt(t,e){return et()?t():e}function gt(t,e){return nt()?t():e}async function h(t){let e=await(0,v.renderToString)(t),n=l();return e+n}async function rt(t){let e=await(0,v.renderToString)(t),n=l();return e+n}function mt(t){return{render:e=>h(()=>t({url:e})),stream:e=>rt(()=>t({url:e})),page:(e,n)=>Z(()=>t({url:e}),n)}}