baraqex 1.0.76 → 2.0.1

package/dist/browser.js

@@ -1,206 +1,360 @@
-// node_modules/frontend-hamroun/dist/index.mjs
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/core/batch.ts
 var isBatching = false;
-var queue = [];
-function batchUpdates(fn) {
+var syncQueue = [];
+var asyncQueue = [];
+async function batchUpdates(fn) {
   if (isBatching) {
-    queue.push(fn);
+    if (fn.constructor.name === "AsyncFunction") {
+      asyncQueue.push(fn);
+    } else {
+      syncQueue.push(fn);
+    }
     return;
   }
   isBatching = true;
   try {
-    fn();
-    while (queue.length > 0) {
-      const nextFn = queue.shift();
-      nextFn == null ? void 0 : nextFn();
+    const result = fn();
+    if (result instanceof Promise) {
+      await result;
+    }
+    while (syncQueue.length > 0) {
+      const nextFn = syncQueue.shift();
+      nextFn();
+    }
+    while (asyncQueue.length > 0) {
+      const nextFn = asyncQueue.shift();
+      await nextFn();
     }
   } finally {
     isBatching = false;
   }
 }
-var currentRender = 0;
-var states = /* @__PURE__ */ new Map();
-var stateIndices = /* @__PURE__ */ new Map();
-var effects = /* @__PURE__ */ new Map();
-var memos = /* @__PURE__ */ new Map();
-var refs = /* @__PURE__ */ new Map();
-var globalRenderCallback = null;
-var globalContainer = null;
-var currentElement = null;
-var isServer = typeof window === "undefined";
-var serverStates = /* @__PURE__ */ new Map();
-function setRenderCallback(callback, element, container) {
-  globalRenderCallback = callback;
-  globalContainer = container;
-  currentElement = element;
+function getIsBatching() {
+  return isBatching;
+}
+
+// src/core/context.ts
+var contextStacks = /* @__PURE__ */ new Map();
+function createContext(defaultValue) {
+  const id = Symbol("context");
+  contextStacks.set(id, []);
+  const context = {
+    Provider: ({ value, children }) => {
+      const stack = contextStacks.get(id);
+      stack.push(value);
+      const result = children;
+      stack.pop();
+      return result;
+    },
+    Consumer: ({ children }) => {
+      const stack = contextStacks.get(id);
+      const value = stack && stack.length > 0 ? stack[stack.length - 1] : defaultValue;
+      return children(value);
+    },
+    _id: id,
+    _defaultValue: defaultValue,
+    useSelector: (selector) => {
+      const stack = contextStacks.get(id);
+      const value = stack && stack.length > 0 ? stack[stack.length - 1] : defaultValue;
+      return selector(value);
+    }
+  };
+  return context;
+}
+function useContext(context) {
+  const stack = contextStacks.get(context._id);
+  if (stack && stack.length > 0) {
+    return stack[stack.length - 1];
+  }
+  return context._defaultValue;
+}
+function getContextValue(context) {
+  return useContext(context);
 }
-function prepareRender() {
-  currentRender++;
-  stateIndices.set(currentRender, 0);
-  return currentRender;
+
+// src/core/hooks.ts
+var rootIdCounter = 0;
+function createRootState() {
+  return {
+    id: ++rootIdCounter,
+    components: /* @__PURE__ */ new Map(),
+    nextComponentId: 0,
+    renderCallback: null,
+    container: null,
+    currentElement: null
+  };
+}
+var currentRoot = null;
+var currentComponentId = null;
+var hookIndex = 0;
+var isServer = typeof window === "undefined";
+function prepareRender(root, componentId) {
+  if (root) {
+    currentRoot = root;
+  }
+  if (componentId !== void 0) {
+    currentComponentId = componentId;
+  } else if (currentRoot) {
+    currentComponentId = ++currentRoot.nextComponentId;
+  }
+  hookIndex = 0;
+  return currentComponentId || 0;
 }
 function finishRender() {
-  if (isServer) {
-    serverStates.delete(currentRender);
+  currentComponentId = null;
+}
+function getCurrentRoot() {
+  return currentRoot;
+}
+function setCurrentRoot(root) {
+  currentRoot = root;
+}
+function getComponentState(root, compId) {
+  let state = root.components.get(compId);
+  if (!state) {
+    state = { states: [], effects: [], memos: [], refs: [] };
+    root.components.set(compId, state);
   }
-  currentRender = 0;
+  return state;
+}
+function setRenderCallback(callback, element, container) {
+  if (!currentRoot)
+    return;
+  currentRoot.renderCallback = callback;
+  currentRoot.currentElement = element;
+  currentRoot.container = container;
 }
 function useState(initial) {
-  if (!currentRender) {
-    throw new Error("useState must be called within a render");
-  }
-  if (isServer) {
-    if (!serverStates.has(currentRender)) {
-      serverStates.set(currentRender, /* @__PURE__ */ new Map());
+  const root = currentRoot;
+  const compId = currentComponentId;
+  if (!root || compId === null) {
+    if (isServer) {
+      return [initial, () => {
+      }];
     }
-    const componentState = serverStates.get(currentRender);
-    const index2 = stateIndices.get(currentRender) || 0;
-    if (!componentState.has(index2)) {
-      componentState.set(index2, initial);
-    }
-    const state2 = componentState.get(index2);
-    const setState2 = (newValue) => {
-    };
-    stateIndices.set(currentRender, index2 + 1);
-    return [state2, setState2];
+    console.warn("useState called outside of render context");
+    return [initial, () => {
+    }];
   }
-  if (!states.has(currentRender)) {
-    states.set(currentRender, []);
+  const compState = getComponentState(root, compId);
+  const currentIndex = hookIndex;
+  hookIndex++;
+  if (currentIndex >= compState.states.length) {
+    compState.states.push(initial);
   }
-  const componentStates = states.get(currentRender);
-  const index = stateIndices.get(currentRender);
-  if (index >= componentStates.length) {
-    componentStates.push(initial);
-  }
-  const state = componentStates[index];
+  const state = compState.states[currentIndex];
   const setState = (newValue) => {
-    const nextValue = typeof newValue === "function" ? newValue(componentStates[index]) : newValue;
-    if (componentStates[index] === nextValue)
+    const currentState = compState.states[currentIndex];
+    const value = typeof newValue === "function" ? newValue(currentState) : newValue;
+    if (Object.is(currentState, value))
       return;
-    componentStates[index] = nextValue;
-    if (isBatching) {
-      batchUpdates(() => rerender(currentRender));
-    } else {
-      rerender(currentRender);
+    compState.states[currentIndex] = value;
+    if (root.renderCallback && root.container && root.currentElement) {
+      root.renderCallback(root.currentElement, root.container);
     }
   };
-  stateIndices.set(currentRender, index + 1);
   return [state, setState];
 }
 function useEffect(callback, deps) {
-  if (!currentRender)
-    throw new Error("useEffect must be called within a render");
-  const effectIndex = stateIndices.get(currentRender);
-  if (!effects.has(currentRender)) {
-    effects.set(currentRender, []);
-  }
-  const componentEffects = effects.get(currentRender);
-  const prevEffect = componentEffects[effectIndex];
-  if (!prevEffect || !deps || !prevEffect.deps || deps.some((dep, i) => dep !== prevEffect.deps[i])) {
-    if (prevEffect == null ? void 0 : prevEffect.cleanup) {
+  const root = currentRoot;
+  const compId = currentComponentId;
+  if (!root || compId === null || isServer)
+    return;
+  const compState = getComponentState(root, compId);
+  const currentIndex = hookIndex;
+  hookIndex++;
+  const prevEffect = compState.effects[currentIndex];
+  const shouldRun = !prevEffect || !deps || !prevEffect.deps || deps.some((dep, i) => !Object.is(dep, prevEffect.deps?.[i]));
+  if (shouldRun) {
+    if (prevEffect?.cleanup) {
       prevEffect.cleanup();
     }
     queueMicrotask(() => {
-      const cleanup = callback() || void 0;
-      componentEffects[effectIndex] = { cleanup, deps };
+      const cleanup = callback();
+      compState.effects[currentIndex] = {
+        callback,
+        deps,
+        cleanup: typeof cleanup === "function" ? cleanup : void 0
+      };
     });
   }
-  stateIndices.set(currentRender, effectIndex + 1);
+  if (!prevEffect) {
+    compState.effects.push({ callback, deps });
+  }
+}
+function useLayoutEffect(callback, deps) {
+  if (isServer)
+    return;
+  const root = currentRoot;
+  const compId = currentComponentId;
+  if (!root || compId === null)
+    return;
+  const compState = getComponentState(root, compId);
+  const currentIndex = hookIndex;
+  hookIndex++;
+  const prevEffect = compState.effects[currentIndex];
+  const shouldRun = !prevEffect || !deps || !prevEffect.deps || deps.some((dep, i) => !Object.is(dep, prevEffect.deps?.[i]));
+  if (shouldRun) {
+    if (prevEffect?.cleanup) {
+      prevEffect.cleanup();
+    }
+    const cleanup = callback();
+    compState.effects[currentIndex] = {
+      callback,
+      deps,
+      cleanup: typeof cleanup === "function" ? cleanup : void 0
+    };
+  }
+  if (!prevEffect) {
+    compState.effects.push({ callback, deps });
+  }
 }
 function useMemo(factory, deps) {
-  if (!currentRender)
-    throw new Error("useMemo must be called within a render");
-  const memoIndex = stateIndices.get(currentRender);
-  if (!memos.has(currentRender)) {
-    memos.set(currentRender, []);
-  }
-  const componentMemos = memos.get(currentRender);
-  const prevMemo = componentMemos[memoIndex];
-  if (!prevMemo || deps && deps.some((dep, i) => !Object.is(dep, prevMemo.deps[i]))) {
+  const root = currentRoot;
+  const compId = currentComponentId;
+  if (!root || compId === null) {
+    return factory();
+  }
+  const compState = getComponentState(root, compId);
+  const currentIndex = hookIndex;
+  hookIndex++;
+  const prevMemo = compState.memos[currentIndex];
+  const shouldRecalculate = !prevMemo || !deps || !prevMemo.deps || deps.some((dep, i) => !Object.is(dep, prevMemo.deps?.[i]));
+  if (shouldRecalculate) {
     const value = factory();
-    componentMemos[memoIndex] = { value, deps };
-    stateIndices.set(currentRender, memoIndex + 1);
+    compState.memos[currentIndex] = { value, deps };
     return value;
   }
-  stateIndices.set(currentRender, memoIndex + 1);
   return prevMemo.value;
 }
+function useCallback(callback, deps) {
+  return useMemo(() => callback, deps);
+}
 function useRef(initial) {
-  if (!currentRender)
-    throw new Error("useRef must be called within a render");
-  const refIndex = stateIndices.get(currentRender);
-  if (!refs.has(currentRender)) {
-    refs.set(currentRender, []);
-  }
-  const componentRefs = refs.get(currentRender);
-  if (refIndex >= componentRefs.length) {
-    const ref2 = { current: initial };
-    componentRefs.push(ref2);
-    stateIndices.set(currentRender, refIndex + 1);
-    return ref2;
-  }
-  const ref = componentRefs[refIndex];
-  stateIndices.set(currentRender, refIndex + 1);
-  return ref;
-}
-async function rerender(rendererId) {
-  try {
-    const componentEffects = effects.get(rendererId);
-    if (componentEffects) {
-      componentEffects.forEach((effect) => {
-        if (effect.cleanup)
-          effect.cleanup();
-      });
-      effects.set(rendererId, []);
-    }
-    if (globalRenderCallback && globalContainer && currentElement) {
-      await globalRenderCallback(currentElement, globalContainer);
-    }
-  } catch (error) {
-    console.error("Error during rerender:", error);
+  const root = currentRoot;
+  const compId = currentComponentId;
+  if (!root || compId === null) {
+    return { current: initial };
+  }
+  const compState = getComponentState(root, compId);
+  const currentIndex = hookIndex;
+  hookIndex++;
+  if (compState.refs[currentIndex] === void 0) {
+    compState.refs[currentIndex] = { current: initial };
   }
+  return compState.refs[currentIndex];
+}
+function useReducer(reducer, initialState) {
+  const [state, setState] = useState(initialState);
+  const dispatch = (action) => {
+    setState((prevState) => reducer(prevState, action));
+  };
+  return [state, dispatch];
 }
 function useErrorBoundary() {
   const [error, setError] = useState(null);
-  return [error, () => setError(null)];
+  const resetError = () => setError(null);
+  return [error, resetError];
 }
-function createContext(defaultValue) {
-  const context = {
-    Provider: ({ value, children }) => {
-      return children;
-    },
-    Consumer: ({ children }) => {
-      return children(defaultValue);
-    },
-    _id: Symbol(),
-    useSelector: (selector) => {
-      return selector(defaultValue);
-    }
-  };
-  return context;
+var idCounter = 0;
+function useId() {
+  const ref = useRef(null);
+  if (ref.current === null) {
+    ref.current = `baraqex-id-${++idCounter}`;
+  }
+  return ref.current;
 }
-function useContext(context) {
-  return context;
+function cleanupHooks(root, compId) {
+  const compState = root.components.get(compId);
+  if (compState) {
+    compState.effects.forEach((effect) => {
+      if (effect.cleanup)
+        effect.cleanup();
+    });
+    root.components.delete(compId);
+  }
+}
+function cleanupRoot(root) {
+  root.components.forEach((compState) => {
+    compState.effects.forEach((effect) => {
+      if (effect.cleanup)
+        effect.cleanup();
+    });
+  });
+  root.components.clear();
 }
-function jsx(type, props) {
-  console.log("JSX Transform:", { type, props });
+
+// src/core/jsx-runtime.ts
+var isBrowser = typeof document !== "undefined";
+function jsx(type, props, key) {
   const processedProps = { ...props };
-  if (arguments.length > 2) {
-    processedProps.children = Array.prototype.slice.call(arguments, 2);
+  if (key !== void 0) {
+    processedProps.key = key;
+  }
+  if (arguments.length > 3) {
+    processedProps.children = Array.prototype.slice.call(arguments, 3);
   }
-  return { type, props: processedProps };
+  return { type, props: processedProps, key: processedProps.key };
+}
+var jsxs = jsx;
+function jsxDEV(type, props, key, _isStaticChildren, _source, _self) {
+  return jsx(type, props, key);
 }
 var Fragment = ({ children }) => children;
-async function createElement(vnode) {
-  var _a;
-  console.log("Creating element from:", vnode);
-  if (vnode == null) {
-    return document.createTextNode("");
+function assertBrowser(method) {
+  if (!isBrowser) {
+    throw new Error(
+      `[baraqex] ${method}() can only be called in a browser environment. Use renderToString() for server-side rendering.`
+    );
+  }
+}
+function createTextNode(text) {
+  return document.createTextNode(text);
+}
+function applyProps(element, props) {
+  for (const [key, value] of Object.entries(props)) {
+    if (key === "children")
+      continue;
+    if (key === "className") {
+      element.setAttribute("class", String(value));
+    } else if (key === "htmlFor") {
+      element.setAttribute("for", String(value));
+    } else if (key.startsWith("on") && typeof value === "function") {
+      const eventName = key.slice(2).toLowerCase();
+      element.addEventListener(eventName, value);
+    } else if (key === "style" && typeof value === "object") {
+      Object.assign(element.style, value);
+    } else if (key === "dangerouslySetInnerHTML" && value && value.__html) {
+      element.innerHTML = value.__html;
+    } else if (key === "ref") {
+      if (typeof value === "function") {
+        value(element);
+      } else if (value && typeof value === "object" && "current" in value) {
+        value.current = element;
+      }
+    } else if (value !== false && value != null) {
+      if (value === true) {
+        element.setAttribute(key, "");
+      } else {
+        element.setAttribute(key, String(value));
+      }
+    }
   }
-  if (typeof vnode === "boolean") {
-    return document.createTextNode("");
+}
+async function createElement(vnode) {
+  assertBrowser("createElement");
+  if (vnode == null || typeof vnode === "boolean") {
+    return createTextNode("");
   }
   if (typeof vnode === "number" || typeof vnode === "string") {
-    return document.createTextNode(String(vnode));
+    return createTextNode(String(vnode));
   }
   if (Array.isArray(vnode)) {
     const fragment = document.createDocumentFragment();
@@ -210,47 +364,29 @@ async function createElement(vnode) {
     }
     return fragment;
   }
-  if ("type" in vnode && vnode.props !== void 0) {
+  if (typeof vnode === "object" && "type" in vnode && vnode.props !== void 0) {
     const { type, props } = vnode;
     if (typeof type === "function") {
+      if (type === Fragment) {
+        const children2 = props?.children;
+        if (children2 == null)
+          return createTextNode("");
+        return createElement(children2);
+      }
+      const root = getCurrentRoot() ?? void 0;
+      const renderId = prepareRender(root);
       try {
-        const result = await type(props || {});
-        const node = await createElement(result);
-        if (node instanceof Element) {
-          node.setAttribute("data-component-id", type.name || type.toString());
-        }
-        return node;
-      } catch (error) {
-        console.error("Error rendering component:", error);
-        return document.createTextNode("");
+        const result = type(props || {});
+        return await createElement(result);
+      } finally {
+        finishRender();
       }
     }
     const element = document.createElement(type);
-    for (const [key, value] of Object.entries(props || {})) {
-      if (key === "children")
-        continue;
-      if (key.startsWith("on") && typeof value === "function") {
-        const eventName = key.toLowerCase().slice(2);
-        const existingHandler = (_a = element.__events) == null ? void 0 : _a[eventName];
-        if (existingHandler) {
-          element.removeEventListener(eventName, existingHandler);
-        }
-        element.addEventListener(eventName, value);
-        if (!element.__events) {
-          element.__events = {};
-        }
-        element.__events[eventName] = value;
-      } else if (key === "style" && typeof value === "object") {
-        Object.assign(element.style, value);
-      } else if (key === "className") {
-        element.setAttribute("class", String(value));
-      } else if (key !== "key" && key !== "ref") {
-        element.setAttribute(key, String(value));
-      }
-    }
-    const children = props == null ? void 0 : props.children;
+    applyProps(element, props || {});
+    const children = props?.children;
     if (children != null) {
-      const childArray = Array.isArray(children) ? children.flat() : [children];
+      const childArray = Array.isArray(children) ? children : [children];
       for (const child of childArray) {
         const childNode = await createElement(child);
         element.appendChild(childNode);
@@ -258,39 +394,1893 @@ async function createElement(vnode) {
     }
     return element;
   }
-  return document.createTextNode(String(vnode));
+  return createTextNode(String(vnode));
 }
-var isHydrating = false;
-async function hydrate(element, container) {
-  isHydrating = true;
-  try {
-    await render(element, container);
-  } finally {
-    isHydrating = false;
+function createElementSync(vnode) {
+  assertBrowser("createElementSync");
+  if (vnode == null || typeof vnode === "boolean") {
+    return createTextNode("");
+  }
+  if (typeof vnode === "number" || typeof vnode === "string") {
+    return createTextNode(String(vnode));
+  }
+  if (Array.isArray(vnode)) {
+    const fragment = document.createDocumentFragment();
+    for (const child of vnode) {
+      fragment.appendChild(createElementSync(child));
+    }
+    return fragment;
+  }
+  if (typeof vnode === "object" && "type" in vnode) {
+    const { type, props } = vnode;
+    if (typeof type === "function") {
+      if (type === Fragment) {
+        return createElementSync(props?.children);
+      }
+      const result = type(props || {});
+      return createElementSync(result);
+    }
+    const element = document.createElement(type);
+    applyProps(element, props || {});
+    const children = props?.children;
+    if (children != null) {
+      const childArray = Array.isArray(children) ? children : [children];
+      for (const child of childArray) {
+        element.appendChild(createElementSync(child));
+      }
+    }
+    return element;
   }
+  return createTextNode(String(vnode));
 }
+
+// src/core/renderer.ts
+var isBrowser2 = typeof document !== "undefined";
+var rootMap = /* @__PURE__ */ new WeakMap();
 async function render(element, container) {
-  console.log("Rendering to:", container.id);
-  batchUpdates(async () => {
-    const rendererId = prepareRender();
+  if (!isBrowser2) {
+    throw new Error(
+      "[baraqex] render() can only be called in a browser. Use renderToString() for server-side rendering."
+    );
+  }
+  if (!container) {
+    throw new Error("[baraqex] render() requires a container element");
+  }
+  let root = rootMap.get(container);
+  if (!root) {
+    root = createRootState();
+    rootMap.set(container, root);
+  }
+  await batchUpdates(async () => {
+    prepareRender(root);
     try {
       setRenderCallback(render, element, container);
       const domNode = await createElement(element);
-      if (!isHydrating) {
-        container.innerHTML = "";
-      }
+      container.textContent = "";
       container.appendChild(domNode);
     } finally {
       finishRender();
     }
   });
 }
-var server = {
-  async getServer() {
-    throw new Error("Server module can only be used in Node.js environment");
+async function hydrate(element, container) {
+  await render(element, container);
+}
+function createRoot(container) {
+  const root = createRootState();
+  rootMap.set(container, root);
+  return {
+    render: (element) => render(element, container),
+    unmount: () => {
+      cleanupRoot(root);
+      rootMap.delete(container);
+      container.textContent = "";
+    }
+  };
+}
+function hasRoot(container) {
+  return rootMap.has(container);
+}
+
+// src/core/server-renderer.ts
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function renderToString(vnode) {
+  prepareRender();
+  try {
+    return renderNodeToString(vnode);
+  } finally {
+    finishRender();
+  }
+}
+function renderToStringWithData(vnode) {
+  const html = renderToString(vnode);
+  return { html, data: {} };
+}
+async function* renderToStream(vnode) {
+  yield renderToString(vnode);
+}
+function renderNodeToString(vnode) {
+  if (vnode === null || vnode === void 0)
+    return "";
+  if (typeof vnode === "boolean")
+    return "";
+  if (typeof vnode === "number" || typeof vnode === "string")
+    return escapeHtml(String(vnode));
+  if (Array.isArray(vnode)) {
+    return vnode.map((child) => renderNodeToString(child)).join("");
+  }
+  if (typeof vnode !== "object" || vnode.type === void 0) {
+    return escapeHtml(String(vnode));
+  }
+  const { type, props } = vnode;
+  if (typeof type === "function") {
+    if (type.name === "Fragment" || type === Symbol.for("react.fragment")) {
+      const children = props?.children;
+      if (children == null)
+        return "";
+      return Array.isArray(children) ? children.map((child) => renderNodeToString(child)).join("") : renderNodeToString(children);
+    }
+    const Component2 = type;
+    try {
+      const renderedNode = Component2(props || {});
+      return renderNodeToString(renderedNode);
+    } catch (error) {
+      console.error("Error rendering component:", error);
+      return `<!-- Error rendering component: ${escapeHtml(String(error))} -->`;
+    }
+  }
+  if (typeof type === "string") {
+    const tag = type;
+    let attrs = "";
+    if (props) {
+      for (const [key, value] of Object.entries(props)) {
+        if (key === "children")
+          continue;
+        if (key === "dangerouslySetInnerHTML")
+          continue;
+        if (key === "ref")
+          continue;
+        if (value === void 0 || value === null || value === false)
+          continue;
+        let attrName = key;
+        let attrValue = value;
+        if (key === "className")
+          attrName = "class";
+        else if (key === "htmlFor")
+          attrName = "for";
+        else if (key === "tabIndex")
+          attrName = "tabindex";
+        if (attrName.startsWith("on") && typeof value === "function")
+          continue;
+        if (attrName === "style" && typeof value === "object") {
+          attrValue = Object.entries(value).map(([prop, val]) => {
+            const cssProperty = prop.replace(/([A-Z])/g, "-$1").toLowerCase();
+            return `${cssProperty}: ${val}`;
+          }).join("; ");
+        }
+        if (value === true) {
+          attrs += ` ${attrName}`;
+        } else {
+          attrs += ` ${attrName}="${escapeHtml(String(attrValue))}"`;
+        }
+      }
+    }
+    if (VOID_ELEMENTS.has(tag)) {
+      return `<${tag}${attrs} />`;
+    }
+    if (props?.dangerouslySetInnerHTML?.__html) {
+      return `<${tag}${attrs}>${props.dangerouslySetInnerHTML.__html}</${tag}>`;
+    }
+    let children = "";
+    const childrenArray = props?.children ? Array.isArray(props.children) ? props.children : [props.children] : [];
+    for (const child of childrenArray) {
+      children += renderNodeToString(child);
+    }
+    return `<${tag}${attrs}>${children}</${tag}>`;
+  }
+  if (type === Symbol.for("react.fragment")) {
+    const children = props?.children;
+    if (children == null)
+      return "";
+    return Array.isArray(children) ? children.map((child) => renderNodeToString(child)).join("") : renderNodeToString(children);
+  }
+  console.warn("Unknown vnode type:", type);
+  return "";
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+
+// src/core/vdom.ts
+var isBrowser3 = typeof document !== "undefined";
+function arePropsEqual(oldProps, newProps) {
+  const oldKeys = Object.keys(oldProps || {}).filter((k) => k !== "children");
+  const newKeys = Object.keys(newProps || {}).filter((k) => k !== "children");
+  if (oldKeys.length !== newKeys.length)
+    return false;
+  return oldKeys.every((key) => Object.is(oldProps[key], newProps[key]));
+}
+function diff(oldNode, newNode) {
+  if (oldNode == null || newNode == null) {
+    return oldNode !== newNode;
+  }
+  if (typeof oldNode !== typeof newNode)
+    return true;
+  if (typeof newNode === "string" || typeof newNode === "number") {
+    return oldNode !== newNode;
+  }
+  if (Array.isArray(oldNode) && Array.isArray(newNode)) {
+    if (oldNode.length !== newNode.length)
+      return true;
+    return oldNode.some((child, i) => diff(child, newNode[i]));
+  }
+  if (typeof oldNode === "object" && typeof newNode === "object") {
+    if (newNode.type !== oldNode.type)
+      return true;
+    if (newNode.key !== oldNode.key)
+      return true;
+    return !arePropsEqual(oldNode.props, newNode.props);
+  }
+  return oldNode !== newNode;
+}
+function shouldComponentUpdate(oldProps, newProps) {
+  return !arePropsEqual(oldProps, newProps);
+}
+function calculatePatches(oldNode, newNode) {
+  if (oldNode == null && newNode != null) {
+    return { type: "CREATE", node: newNode };
+  }
+  if (oldNode != null && newNode == null) {
+    return { type: "REMOVE" };
+  }
+  if (oldNode == null && newNode == null) {
+    return null;
+  }
+  if (typeof oldNode !== typeof newNode) {
+    return { type: "REPLACE", node: newNode };
+  }
+  if (typeof newNode === "string" || typeof newNode === "number") {
+    if (oldNode !== newNode) {
+      return { type: "REPLACE", node: newNode };
+    }
+    return null;
+  }
+  if (typeof oldNode === "object" && typeof newNode === "object" && "type" in newNode) {
+    if (oldNode.type !== newNode.type) {
+      return { type: "REPLACE", node: newNode };
+    }
+    const propPatches = {};
+    let hasChanges = false;
+    const newProps = newNode.props || {};
+    const oldProps = oldNode.props || {};
+    for (const key of Object.keys(newProps)) {
+      if (key === "children")
+        continue;
+      if (!Object.is(newProps[key], oldProps[key])) {
+        propPatches[key] = newProps[key];
+        hasChanges = true;
+      }
+    }
+    for (const key of Object.keys(oldProps)) {
+      if (key === "children")
+        continue;
+      if (!(key in newProps)) {
+        propPatches[key] = void 0;
+        hasChanges = true;
+      }
+    }
+    const oldChildren = normalizeChildren(oldProps.children);
+    const newChildren = normalizeChildren(newProps.children);
+    const childPatches = diffChildren(oldChildren, newChildren);
+    if (childPatches.length > 0) {
+      hasChanges = true;
+    }
+    if (hasChanges) {
+      return {
+        type: "UPDATE",
+        props: propPatches,
+        children: childPatches.length > 0 ? childPatches : void 0
+      };
+    }
+    return null;
+  }
+  return null;
+}
+function normalizeChildren(children) {
+  if (children == null)
+    return [];
+  return Array.isArray(children) ? children : [children];
+}
+function diffChildren(oldChildren, newChildren) {
+  const patches = [];
+  const oldKeyMap = /* @__PURE__ */ new Map();
+  oldChildren.forEach((child, i) => {
+    if (child && typeof child === "object" && child.key != null) {
+      oldKeyMap.set(child.key, i);
+    }
+  });
+  const newKeyMap = /* @__PURE__ */ new Map();
+  newChildren.forEach((child, i) => {
+    if (child && typeof child === "object" && child.key != null) {
+      newKeyMap.set(child.key, i);
+    }
+  });
+  const maxLen = Math.max(oldChildren.length, newChildren.length);
+  for (let i = 0; i < maxLen; i++) {
+    const oldChild = i < oldChildren.length ? oldChildren[i] : null;
+    const newChild = i < newChildren.length ? newChildren[i] : null;
+    const patch = calculatePatches(oldChild, newChild);
+    if (patch) {
+      patches.push(patch);
+    }
+  }
+  return patches;
+}
+function applyPatches(element, patch) {
+  if (!isBrowser3)
+    return element;
+  switch (patch.type) {
+    case "REMOVE":
+      element.parentNode?.removeChild(element);
+      return null;
+    case "REPLACE": {
+      if (!patch.node)
+        return element;
+      const newNode = patch.node;
+      if (typeof newNode === "string" || typeof newNode === "number") {
+        const textNode = document.createTextNode(String(newNode));
+        element.parentNode?.replaceChild(textNode, element);
+        return null;
+      }
+      element.textContent = "";
+      return element;
+    }
+    case "UPDATE": {
+      if (patch.props) {
+        for (const [key, value] of Object.entries(patch.props)) {
+          if (value === void 0) {
+            const attrName = key === "className" ? "class" : key;
+            element.removeAttribute(attrName);
+          } else if (key === "className") {
+            element.setAttribute("class", String(value));
+          } else if (key === "style" && typeof value === "object") {
+            const htmlEl = element;
+            for (const [prop, val] of Object.entries(value)) {
+              htmlEl.style[prop] = val;
+            }
+          } else if (key.startsWith("on") && typeof value === "function") {
+            const eventName = key.slice(2).toLowerCase();
+            const attrName = `data-baraqex-listener-${eventName}`;
+            const oldHandler = element.__baraqexHandlers?.[eventName];
+            if (oldHandler) {
+              element.removeEventListener(eventName, oldHandler);
+            }
+            element.addEventListener(eventName, value);
+            if (!element.__baraqexHandlers) {
+              element.__baraqexHandlers = {};
+            }
+            element.__baraqexHandlers[eventName] = value;
+          } else if (key === "ref") {
+            if (typeof value === "function") {
+              value(element);
+            } else if (value && typeof value === "object" && "current" in value) {
+              value.current = element;
+            }
+          } else {
+            if (value === true) {
+              element.setAttribute(key, "");
+            } else {
+              element.setAttribute(key, String(value));
+            }
+          }
+        }
+      }
+      return element;
+    }
+    default:
+      return element;
+  }
+}
+
+// src/core/component.ts
+var Component = class {
+  constructor(props) {
+    __publicField(this, "props");
+    __publicField(this, "state");
+    __publicField(this, "element", null);
+    __publicField(this, "_mounted", false);
+    __publicField(this, "_pendingState", null);
+    this.props = props;
+    this.state = {};
+  }
+  /**
+   * Called after the component is mounted to the DOM
+   */
+  componentDidMount() {
+  }
+  /**
+   * Called before the component is unmounted from the DOM
+   */
+  componentWillUnmount() {
+  }
+  /**
+   * Called when the component receives new props
+   */
+  componentDidUpdate(_prevProps, _prevState) {
+  }
+  /**
+   * Determine if the component should re-render
+   */
+  shouldComponentUpdate(_nextProps, _nextState) {
+    return true;
+  }
+  /**
+   * Update component state and trigger re-render
+   */
+  setState(newState) {
+    const prevState = { ...this.state };
+    const stateUpdate = typeof newState === "function" ? newState(this.state, this.props) : newState;
+    this.state = { ...this.state, ...stateUpdate };
+    if (this._mounted) {
+      if (this.shouldComponentUpdate(this.props, this.state)) {
+        this._update();
+        this.componentDidUpdate(this.props, prevState);
+      }
+    }
+  }
+  /**
+   * Force a re-render without checking shouldComponentUpdate
+   */
+  forceUpdate() {
+    this._update();
+  }
+  /**
+   * Internal update method
+   */
+  async _update() {
+    const vdom = this.render();
+    if (!vdom || !this.element?.parentNode)
+      return;
+    const newElement = await createElement(vdom);
+    if (newElement instanceof HTMLElement) {
+      this.element.parentNode.replaceChild(newElement, this.element);
+      this.element = newElement;
+    }
+  }
+  /**
+   * Mount the component to a container
+   */
+  async mount(container) {
+    const vdom = this.render();
+    if (!vdom)
+      return;
+    const element = await createElement(vdom);
+    if (element instanceof HTMLElement) {
+      this.element = element;
+      container.appendChild(element);
+      this._mounted = true;
+      this.componentDidMount();
+    }
+  }
+  /**
+   * Unmount the component
+   */
+  unmount() {
+    if (this.element?.parentNode) {
+      this.componentWillUnmount();
+      this.element.parentNode.removeChild(this.element);
+      this._mounted = false;
+      this.element = null;
+    }
+  }
+};
+function createClassComponent(ComponentClass) {
+  return (props) => {
+    const instance = new ComponentClass(props);
+    return instance.render();
+  };
+}
+var PureComponent = class extends Component {
+  shouldComponentUpdate(nextProps, nextState) {
+    const propsKeys = Object.keys(this.props);
+    const nextPropsKeys = Object.keys(nextProps);
+    if (propsKeys.length !== nextPropsKeys.length)
+      return true;
+    for (const key of propsKeys) {
+      if (!Object.is(this.props[key], nextProps[key]))
+        return true;
+    }
+    const stateKeys = Object.keys(this.state);
+    const nextStateKeys = Object.keys(nextState);
+    if (stateKeys.length !== nextStateKeys.length)
+      return true;
+    for (const key of stateKeys) {
+      if (!Object.is(this.state[key], nextState[key]))
+        return true;
+    }
+    return false;
   }
 };
 
+// src/core/event-bus.ts
+function createEventBus() {
+  const events = /* @__PURE__ */ new Map();
+  const onceHandlers = /* @__PURE__ */ new WeakMap();
+  const on = (event, handler) => {
+    if (!events.has(event)) {
+      events.set(event, /* @__PURE__ */ new Set());
+    }
+    events.get(event).add(handler);
+    return () => off(event, handler);
+  };
+  const once = (event, handler) => {
+    const onceWrapper = (...args) => {
+      handler(...args);
+      off(event, onceWrapper);
+    };
+    onceHandlers.set(handler, onceWrapper);
+    return on(event, onceWrapper);
+  };
+  const off = (event, handler) => {
+    if (!handler) {
+      events.delete(event);
+      return;
+    }
+    const handlers = events.get(event);
+    if (!handlers)
+      return;
+    handlers.delete(handler);
+    const onceWrapper = onceHandlers.get(handler);
+    if (onceWrapper) {
+      handlers.delete(onceWrapper);
+      onceHandlers.delete(handler);
+    }
+    if (handlers.size === 0) {
+      events.delete(event);
+    }
+  };
+  const emit = (event, ...args) => {
+    const handlers = events.get(event);
+    if (!handlers)
+      return;
+    const handlersCopy = Array.from(handlers);
+    for (const handler of handlersCopy) {
+      try {
+        handler(...args);
+      } catch (error) {
+        console.error(`Error in event handler for "${event}":`, error);
+      }
+    }
+  };
+  const clear = (event) => {
+    if (event) {
+      events.delete(event);
+    } else {
+      events.clear();
+    }
+  };
+  return { on, once, off, emit, clear };
+}
+var eventBus = createEventBus();
+function useEvent(event, handler, options = {}) {
+  return options.once ? eventBus.once(event, handler) : eventBus.on(event, handler);
+}
+
+// src/core/router.ts
+var RouterContext = createContext({
+  pathname: "/",
+  search: "",
+  hash: "",
+  params: {},
+  query: {},
+  navigate: () => {
+  },
+  back: () => {
+  },
+  forward: () => {
+  },
+  match: () => false
+});
+function parseQuery(search) {
+  const query = {};
+  const params = new URLSearchParams(search);
+  params.forEach((value, key) => {
+    query[key] = value;
+  });
+  return query;
+}
+function matchPath(pathname, pattern, exact = false) {
+  const params = {};
+  const patternParts = pattern.split("/").filter(Boolean);
+  const pathParts = pathname.split("/").filter(Boolean);
+  if (exact && patternParts.length !== pathParts.length) {
+    return { match: false, params };
+  }
+  if (patternParts.length > pathParts.length) {
+    return { match: false, params };
+  }
+  for (let i = 0; i < patternParts.length; i++) {
+    const patternPart = patternParts[i];
+    const pathPart = pathParts[i];
+    if (patternPart.startsWith(":")) {
+      const paramName = patternPart.slice(1);
+      params[paramName] = decodeURIComponent(pathPart);
+    } else if (patternPart === "*") {
+      params["*"] = pathParts.slice(i).join("/");
+      return { match: true, params };
+    } else if (patternPart !== pathPart) {
+      return { match: false, params };
+    }
+  }
+  return { match: true, params };
+}
+function RouterProvider({
+  children
+}) {
+  const [location, setLocation] = useState((() => {
+    if (typeof window === "undefined") {
+      return { pathname: "/", search: "", hash: "", params: {}, query: {} };
+    }
+    return {
+      pathname: window.location.pathname,
+      search: window.location.search,
+      hash: window.location.hash,
+      params: {},
+      query: parseQuery(window.location.search)
+    };
+  })());
+  useEffect(() => {
+    if (typeof window === "undefined")
+      return;
+    const handlePopState = () => {
+      setLocation({
+        pathname: window.location.pathname,
+        search: window.location.search,
+        hash: window.location.hash,
+        params: {},
+        query: parseQuery(window.location.search)
+      });
+    };
+    window.addEventListener("popstate", handlePopState);
+    return () => window.removeEventListener("popstate", handlePopState);
+  }, []);
+  const navigate = (to, options = {}) => {
+    if (typeof window === "undefined")
+      return;
+    const url = new URL(to, window.location.origin);
+    if (options.replace) {
+      window.history.replaceState(options.state || null, "", url.href);
+    } else {
+      window.history.pushState(options.state || null, "", url.href);
+    }
+    setLocation({
+      pathname: url.pathname,
+      search: url.search,
+      hash: url.hash,
+      params: {},
+      query: parseQuery(url.search)
+    });
+  };
+  const back = () => {
+    if (typeof window !== "undefined") {
+      window.history.back();
+    }
+  };
+  const forward = () => {
+    if (typeof window !== "undefined") {
+      window.history.forward();
+    }
+  };
+  const match = (pattern) => {
+    return matchPath(location.pathname, pattern).match;
+  };
+  const contextValue = {
+    ...location,
+    navigate,
+    back,
+    forward,
+    match
+  };
+  return jsx(RouterContext.Provider, { value: contextValue, children });
+}
+function Router({ routes }) {
+  const { pathname, params: existingParams } = useContext(RouterContext);
+  for (const route of routes) {
+    const { match, params } = matchPath(pathname, route.path, route.exact);
+    if (match) {
+      const Component2 = route.component;
+      return jsx(Component2, { ...params, ...existingParams });
+    }
+  }
+  return null;
+}
+function Route({
+  path,
+  component: Component2,
+  exact = false
+}) {
+  const { pathname } = useContext(RouterContext);
+  const { match, params } = matchPath(pathname, path, exact);
+  if (match) {
+    return jsx(Component2, params);
+  }
+  return null;
+}
+function Switch({ children }) {
+  const { pathname } = useContext(RouterContext);
+  const routes = Array.isArray(children) ? children : [children];
+  for (const child of routes) {
+    if (child?.props?.path) {
+      const exact = child.props.exact ?? false;
+      const { match } = matchPath(pathname, child.props.path, exact);
+      if (match) {
+        return child;
+      }
+    }
+  }
+  return null;
+}
+function Link({
+  to,
+  children,
+  replace = false,
+  className = "",
+  activeClassName = "",
+  ...rest
+}) {
+  const { pathname, navigate } = useContext(RouterContext);
+  const isActive = pathname === to || pathname.startsWith(to + "/");
+  const handleClick = (e) => {
+    e.preventDefault();
+    navigate(to, { replace });
+  };
+  const combinedClassName = isActive && activeClassName ? `${className} ${activeClassName}`.trim() : className;
+  return jsx("a", {
+    href: to,
+    onClick: handleClick,
+    className: combinedClassName || void 0,
+    ...rest,
+    children
+  });
+}
+function Redirect({
+  to,
+  replace = true
+}) {
+  const { navigate } = useContext(RouterContext);
+  useEffect(() => {
+    navigate(to, { replace });
+  }, [to, replace]);
+  return null;
+}
+function NavLink({
+  to,
+  children,
+  activeClassName = "active",
+  className = "",
+  exact = false,
+  ...rest
+}) {
+  const { pathname, navigate } = useContext(RouterContext);
+  const { match } = matchPath(pathname, to, exact);
+  const isActive = match;
+  const combinedClassName = isActive ? `${className} ${activeClassName}`.trim() : className;
+  const handleClick = (e) => {
+    e.preventDefault();
+    navigate(to);
+  };
+  return jsx("a", {
+    href: to,
+    onClick: handleClick,
+    className: combinedClassName || void 0,
+    "aria-current": isActive ? "page" : void 0,
+    ...rest,
+    children
+  });
+}
+function useRouter() {
+  return useContext(RouterContext);
+}
+function useLocation() {
+  const { pathname, search, hash, params, query } = useContext(RouterContext);
+  return { pathname, search, hash, params, query };
+}
+function useParams() {
+  const { params } = useContext(RouterContext);
+  return params;
+}
+function useNavigate() {
+  const { navigate } = useContext(RouterContext);
+  return navigate;
+}
+function useSearchParams() {
+  const { search, navigate, pathname } = useContext(RouterContext);
+  const searchParams = new URLSearchParams(search);
+  const setSearchParams = (newParams) => {
+    navigate(`${pathname}?${newParams.toString()}`);
+  };
+  return [searchParams, setSearchParams];
+}
+function useMatch(pattern) {
+  const { pathname } = useContext(RouterContext);
+  const { match, params } = matchPath(pathname, pattern);
+  return match ? params : null;
+}
+
+// src/core/forms.ts
+function validateFieldValue(value, rules, allValues) {
+  if (rules.required) {
+    const isEmpty2 = value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
+    if (isEmpty2) {
+      return typeof rules.required === "string" ? rules.required : "This field is required";
+    }
+  }
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (rules.minLength !== void 0) {
+    const minLength = typeof rules.minLength === "object" ? rules.minLength.value : rules.minLength;
+    const message = typeof rules.minLength === "object" ? rules.minLength.message : `Minimum length is ${minLength}`;
+    if (String(value).length < minLength) {
+      return message;
+    }
+  }
+  if (rules.maxLength !== void 0) {
+    const maxLength = typeof rules.maxLength === "object" ? rules.maxLength.value : rules.maxLength;
+    const message = typeof rules.maxLength === "object" ? rules.maxLength.message : `Maximum length is ${maxLength}`;
+    if (String(value).length > maxLength) {
+      return message;
+    }
+  }
+  if (rules.min !== void 0) {
+    const min = typeof rules.min === "object" ? rules.min.value : rules.min;
+    const message = typeof rules.min === "object" ? rules.min.message : `Minimum value is ${min}`;
+    if (Number(value) < min) {
+      return message;
+    }
+  }
+  if (rules.max !== void 0) {
+    const max = typeof rules.max === "object" ? rules.max.value : rules.max;
+    const message = typeof rules.max === "object" ? rules.max.message : `Maximum value is ${max}`;
+    if (Number(value) > max) {
+      return message;
+    }
+  }
+  if (rules.pattern !== void 0) {
+    const pattern = rules.pattern instanceof RegExp ? rules.pattern : rules.pattern.value;
+    const message = rules.pattern instanceof RegExp ? "Invalid format" : rules.pattern.message;
+    if (!pattern.test(String(value))) {
+      return message;
+    }
+  }
+  if (rules.validate) {
+    const result = rules.validate(value, allValues);
+    if (result === false) {
+      return "Invalid value";
+    }
+    if (typeof result === "string") {
+      return result;
+    }
+  }
+  return void 0;
+}
+function useForm(options) {
+  const {
+    initialValues,
+    validate,
+    validationRules,
+    onSubmit,
+    validateOnChange = true,
+    validateOnBlur = true
+  } = options;
+  const [values, setValuesState] = useState(initialValues);
+  const [errors, setErrorsState] = useState({});
+  const [touched, setTouched] = useState({});
+  const [dirty, setDirty] = useState({});
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [submitCount, setSubmitCount] = useState(0);
+  const initialValuesRef = useRef(initialValues);
+  const isValid = Object.keys(errors).length === 0;
+  const isDirty = Object.values(dirty).some(Boolean);
+  const validateField = useCallback((field) => {
+    const value = values[field];
+    if (validationRules && validationRules[field]) {
+      return validateFieldValue(value, validationRules[field], values);
+    }
+    if (validate) {
+      const allErrors = validate(values);
+      return allErrors[field];
+    }
+    return void 0;
+  }, [values, validate, validationRules]);
+  const validateForm = useCallback(() => {
+    const newErrors = {};
+    if (validationRules) {
+      for (const field in validationRules) {
+        const error = validateFieldValue(values[field], validationRules[field], values);
+        if (error) {
+          newErrors[field] = error;
+        }
+      }
+    }
+    if (validate) {
+      const customErrors = validate(values);
+      Object.assign(newErrors, customErrors);
+    }
+    return newErrors;
+  }, [values, validate, validationRules]);
+  useEffect(() => {
+    if (validateOnChange) {
+      const newErrors = validateForm();
+      setErrorsState(newErrors);
+    }
+  }, [values, validateOnChange, validateForm]);
+  const handleChange = useCallback((e) => {
+    const { name, value, type, checked } = e.target;
+    const fieldValue = type === "checkbox" ? checked : value;
+    setValuesState((prev) => ({ ...prev, [name]: fieldValue }));
+    setDirty((prev) => ({ ...prev, [name]: true }));
+  }, []);
+  const handleBlur = useCallback((e) => {
+    const { name } = e.target;
+    setTouched((prev) => ({ ...prev, [name]: true }));
+    if (validateOnBlur) {
+      const error = validateField(name);
+      setErrorsState((prev) => {
+        if (error) {
+          return { ...prev, [name]: error };
+        }
+        const { [name]: _, ...rest } = prev;
+        return rest;
+      });
+    }
+  }, [validateOnBlur, validateField]);
+  const handleSubmit = useCallback(async (e) => {
+    if (e?.preventDefault) {
+      e.preventDefault();
+    }
+    setSubmitCount((prev) => prev + 1);
+    const allTouched = {};
+    for (const key in values) {
+      allTouched[key] = true;
+    }
+    setTouched(allTouched);
+    const formErrors = validateForm();
+    setErrorsState(formErrors);
+    if (Object.keys(formErrors).length > 0) {
+      return;
+    }
+    if (onSubmit) {
+      setIsSubmitting(true);
+      try {
+        await onSubmit(values, formConfig);
+      } finally {
+        setIsSubmitting(false);
+      }
+    }
+  }, [values, validateForm, onSubmit]);
+  const setFieldValue = useCallback((field, value) => {
+    setValuesState((prev) => ({ ...prev, [field]: value }));
+    setDirty((prev) => ({ ...prev, [field]: true }));
+  }, []);
+  const setFieldError = useCallback((field, error) => {
+    setErrorsState((prev) => ({ ...prev, [field]: error }));
+  }, []);
+  const setFieldTouched = useCallback((field, isTouched = true) => {
+    setTouched((prev) => ({ ...prev, [field]: isTouched }));
+  }, []);
+  const setValues = useCallback((newValues) => {
+    setValuesState((prev) => ({ ...prev, ...newValues }));
+  }, []);
+  const setErrors = useCallback((newErrors) => {
+    setErrorsState(newErrors);
+  }, []);
+  const resetForm = useCallback((nextValues) => {
+    setValuesState(nextValues ? { ...initialValuesRef.current, ...nextValues } : initialValuesRef.current);
+    setErrorsState({});
+    setTouched({});
+    setDirty({});
+    setSubmitCount(0);
+  }, []);
+  const getFieldProps = useCallback((field) => ({
+    name: field,
+    value: values[field] ?? "",
+    onChange: handleChange,
+    onBlur: handleBlur
+  }), [values, handleChange, handleBlur]);
+  const formConfig = {
+    values,
+    errors,
+    touched,
+    dirty,
+    isValid,
+    isDirty,
+    isSubmitting,
+    submitCount,
+    handleChange,
+    handleBlur,
+    handleSubmit,
+    setFieldValue,
+    setFieldError,
+    setFieldTouched,
+    setValues,
+    setErrors,
+    resetForm,
+    validateField,
+    validateForm,
+    getFieldProps,
+    register: getFieldProps
+  };
+  return formConfig;
+}
+function useField(name, form) {
+  return {
+    field: form.getFieldProps(name),
+    meta: {
+      touched: form.touched[name] || false,
+      error: form.errors[name],
+      dirty: form.dirty[name] || false
+    },
+    helpers: {
+      setValue: (value) => form.setFieldValue(name, value),
+      setError: (error) => form.setFieldError(name, error),
+      setTouched: (touched) => form.setFieldTouched(name, touched)
+    }
+  };
+}
+var patterns = {
+  email: /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i,
+  phone: /^\+?[1-9]\d{1,14}$/,
+  url: /^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/,
+  alphanumeric: /^[a-zA-Z0-9]+$/,
+  numeric: /^\d+$/,
+  password: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$/
+};
+
+// src/core/store.ts
+function createStore(reducer, initialState, middlewares = []) {
+  let state = initialState;
+  let listeners = /* @__PURE__ */ new Set();
+  let currentReducer = reducer;
+  const getState = () => state;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  };
+  let dispatch = (action) => {
+    state = currentReducer(state, action);
+    listeners.forEach((listener) => listener());
+  };
+  if (middlewares.length > 0) {
+    const store = { getState, dispatch, subscribe, replaceReducer: () => {
+    } };
+    const chain = middlewares.map((middleware) => middleware(store));
+    dispatch = chain.reduceRight(
+      (next, middleware) => middleware(next),
+      dispatch
+    );
+  }
+  const replaceReducer = (nextReducer) => {
+    currentReducer = nextReducer;
+  };
+  dispatch({ type: "@@INIT" });
+  return {
+    getState,
+    dispatch,
+    subscribe,
+    replaceReducer
+  };
+}
+function combineReducers(reducers) {
+  return (state, action) => {
+    const nextState = {};
+    let hasChanged = false;
+    for (const key in reducers) {
+      const reducer = reducers[key];
+      const previousStateForKey = state[key];
+      const nextStateForKey = reducer(previousStateForKey, action);
+      nextState[key] = nextStateForKey;
+      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
+    }
+    return hasChanged ? nextState : state;
+  };
+}
+var StoreContext = createContext({
+  store: {
+    getState: () => ({}),
+    dispatch: () => {
+    },
+    subscribe: () => () => {
+    },
+    replaceReducer: () => {
+    }
+  },
+  state: {}
+});
+function StoreProvider({
+  store,
+  children
+}) {
+  const [state, setState] = useState(store.getState());
+  useEffect(() => {
+    const unsubscribe = store.subscribe(() => {
+      setState(store.getState());
+    });
+    return unsubscribe;
+  }, [store]);
+  return jsx(StoreContext.Provider, {
+    value: { store, state },
+    children
+  });
+}
+function useSelector(selector) {
+  const { state } = useContext(StoreContext);
+  return selector(state);
+}
+function useDispatch() {
+  const { store } = useContext(StoreContext);
+  return store.dispatch;
+}
+function useStore() {
+  const { store } = useContext(StoreContext);
+  return store;
+}
+var logger = (store) => (next) => (action) => {
+  console.group(`Action: ${action.type}`);
+  console.log("Payload:", action.payload);
+  console.log("Previous State:", store.getState());
+  const result = next(action);
+  console.log("Next State:", store.getState());
+  console.groupEnd();
+  return result;
+};
+var thunk = (store) => (next) => (action) => {
+  if (typeof action === "function") {
+    return action(store.dispatch, store.getState);
+  }
+  return next(action);
+};
+var devTools = (store) => (next) => (action) => {
+  if (typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__) {
+    const devToolsExtension = window.__REDUX_DEVTOOLS_EXTENSION__;
+    devToolsExtension.send(action, store.getState());
+  }
+  return next(action);
+};
+function createAction(type) {
+  const actionCreator = (payload) => ({ type, payload });
+  actionCreator.type = type;
+  actionCreator.match = (action) => action.type === type;
+  return actionCreator;
+}
+function createSlice(config) {
+  const { name, initialState, reducers } = config;
+  const actions = {};
+  for (const key in reducers) {
+    const type = `${name}/${key}`;
+    actions[key] = (payload) => ({ type, payload });
+  }
+  const reducer = (state = initialState, action) => {
+    for (const key in reducers) {
+      const type = `${name}/${key}`;
+      if (action.type === type) {
+        return reducers[key](state, action);
+      }
+    }
+    return state;
+  };
+  return {
+    name,
+    reducer,
+    actions
+  };
+}
+
+// src/core/lifecycle-events.ts
+var LifecycleEvents = /* @__PURE__ */ ((LifecycleEvents2) => {
+  LifecycleEvents2["APP_INIT"] = "app:init";
+  LifecycleEvents2["APP_MOUNTED"] = "app:mounted";
+  LifecycleEvents2["APP_UPDATED"] = "app:updated";
+  LifecycleEvents2["APP_ERROR"] = "app:error";
+  LifecycleEvents2["APP_DESTROYED"] = "app:destroyed";
+  LifecycleEvents2["COMPONENT_CREATED"] = "component:created";
+  LifecycleEvents2["COMPONENT_MOUNTED"] = "component:mounted";
+  LifecycleEvents2["COMPONENT_UPDATED"] = "component:updated";
+  LifecycleEvents2["COMPONENT_ERROR"] = "component:error";
+  LifecycleEvents2["COMPONENT_UNMOUNTED"] = "component:unmounted";
+  LifecycleEvents2["ROUTER_BEFORE_CHANGE"] = "router:before-change";
+  LifecycleEvents2["ROUTER_AFTER_CHANGE"] = "router:after-change";
+  LifecycleEvents2["ROUTER_ERROR"] = "router:error";
+  LifecycleEvents2["STORE_INITIALIZED"] = "store:initialized";
+  LifecycleEvents2["STORE_BEFORE_ACTION"] = "store:before-action";
+  LifecycleEvents2["STORE_AFTER_ACTION"] = "store:after-action";
+  LifecycleEvents2["STORE_ERROR"] = "store:error";
+  return LifecycleEvents2;
+})(LifecycleEvents || {});
+function emitAppInit(data) {
+  eventBus.emit("app:init" /* APP_INIT */, data);
+}
+function emitAppMounted(rootElement) {
+  eventBus.emit("app:mounted" /* APP_MOUNTED */, rootElement);
+}
+function emitAppUpdated() {
+  eventBus.emit("app:updated" /* APP_UPDATED */);
+}
+function emitAppError(error) {
+  eventBus.emit("app:error" /* APP_ERROR */, error);
+}
+function emitAppDestroyed() {
+  eventBus.emit("app:destroyed" /* APP_DESTROYED */);
+}
+function emitComponentCreated(info) {
+  eventBus.emit("component:created" /* COMPONENT_CREATED */, info);
+}
+function emitComponentMounted(info, element) {
+  eventBus.emit("component:mounted" /* COMPONENT_MOUNTED */, info, element);
+}
+function emitComponentUpdated(info, prevProps, newProps) {
+  eventBus.emit("component:updated" /* COMPONENT_UPDATED */, info, prevProps, newProps);
+}
+function emitComponentError(info, error) {
+  eventBus.emit("component:error" /* COMPONENT_ERROR */, info, error);
+}
+function emitComponentUnmounted(info) {
+  eventBus.emit("component:unmounted" /* COMPONENT_UNMOUNTED */, info);
+}
+function emitRouterBeforeChange(info) {
+  return new Promise((resolve) => {
+    let prevented = false;
+    const prevent = () => {
+      prevented = true;
+    };
+    eventBus.emit("router:before-change" /* ROUTER_BEFORE_CHANGE */, info, prevent);
+    resolve(!prevented);
+  });
+}
+function emitRouterAfterChange(info) {
+  eventBus.emit("router:after-change" /* ROUTER_AFTER_CHANGE */, info);
+}
+function emitRouterError(error, info) {
+  eventBus.emit("router:error" /* ROUTER_ERROR */, error, info);
+}
+function emitStoreInitialized(state) {
+  eventBus.emit("store:initialized" /* STORE_INITIALIZED */, state);
+}
+function emitStoreBeforeAction(actionType, payload, state) {
+  eventBus.emit("store:before-action" /* STORE_BEFORE_ACTION */, actionType, payload, state);
+}
+function emitStoreAfterAction(info) {
+  eventBus.emit("store:after-action" /* STORE_AFTER_ACTION */, info);
+}
+function emitStoreError(error, actionType, payload) {
+  eventBus.emit("store:error" /* STORE_ERROR */, error, actionType, payload);
+}
+function onAppInit(handler) {
+  return eventBus.on("app:init" /* APP_INIT */, handler);
+}
+function onAppMounted(handler) {
+  return eventBus.on("app:mounted" /* APP_MOUNTED */, handler);
+}
+function onAppUpdated(handler) {
+  return eventBus.on("app:updated" /* APP_UPDATED */, handler);
+}
+function onAppError(handler) {
+  return eventBus.on("app:error" /* APP_ERROR */, handler);
+}
+function onAppDestroyed(handler) {
+  return eventBus.on("app:destroyed" /* APP_DESTROYED */, handler);
+}
+function onComponentCreated(handler) {
+  return eventBus.on("component:created" /* COMPONENT_CREATED */, handler);
+}
+function onComponentMounted(handler) {
+  return eventBus.on("component:mounted" /* COMPONENT_MOUNTED */, handler);
+}
+function onComponentUpdated(handler) {
+  return eventBus.on("component:updated" /* COMPONENT_UPDATED */, handler);
+}
+function onComponentError(handler) {
+  return eventBus.on("component:error" /* COMPONENT_ERROR */, handler);
+}
+function onComponentUnmounted(handler) {
+  return eventBus.on("component:unmounted" /* COMPONENT_UNMOUNTED */, handler);
+}
+function onRouterBeforeChange(handler) {
+  return eventBus.on("router:before-change" /* ROUTER_BEFORE_CHANGE */, handler);
+}
+function onRouterAfterChange(handler) {
+  return eventBus.on("router:after-change" /* ROUTER_AFTER_CHANGE */, handler);
+}
+function onRouterError(handler) {
+  return eventBus.on("router:error" /* ROUTER_ERROR */, handler);
+}
+function onStoreInitialized(handler) {
+  return eventBus.on("store:initialized" /* STORE_INITIALIZED */, handler);
+}
+function onStoreBeforeAction(handler) {
+  return eventBus.on("store:before-action" /* STORE_BEFORE_ACTION */, handler);
+}
+function onStoreAfterAction(handler) {
+  return eventBus.on("store:after-action" /* STORE_AFTER_ACTION */, handler);
+}
+function onStoreError(handler) {
+  return eventBus.on("store:error" /* STORE_ERROR */, handler);
+}
+
+// src/core/utils.ts
+function debounce(func, wait, options = {}) {
+  let timeoutId = null;
+  let lastArgs = null;
+  let lastThis = null;
+  let result;
+  let lastCallTime;
+  let lastInvokeTime = 0;
+  const { leading = false, trailing = true } = options;
+  const invokeFunc = (time) => {
+    const args = lastArgs;
+    const thisArg = lastThis;
+    lastArgs = null;
+    lastThis = null;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  };
+  const shouldInvoke = (time) => {
+    const timeSinceLastCall = lastCallTime === void 0 ? 0 : time - lastCallTime;
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || timeSinceLastInvoke >= wait;
+  };
+  const trailingEdge = (time) => {
+    timeoutId = null;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = null;
+    lastThis = null;
+    return result;
+  };
+  const remainingWait = (time) => {
+    const timeSinceLastCall = lastCallTime === void 0 ? 0 : time - lastCallTime;
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    const timeWaiting = wait - timeSinceLastCall;
+    return timeWaiting;
+  };
+  const timerExpired = () => {
+    const time = Date.now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timeoutId = setTimeout(timerExpired, remainingWait(time));
+    return result;
+  };
+  const debounced = function(...args) {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(time);
+    lastArgs = args;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timeoutId === null) {
+        lastInvokeTime = time;
+        timeoutId = setTimeout(timerExpired, wait);
+        if (leading) {
+          return invokeFunc(time);
+        }
+      }
+    }
+    if (timeoutId === null) {
+      timeoutId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  };
+  debounced.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = null;
+    lastThis = null;
+    lastCallTime = void 0;
+    timeoutId = null;
+  };
+  debounced.flush = () => {
+    if (timeoutId !== null) {
+      return trailingEdge(Date.now());
+    }
+    return result;
+  };
+  return debounced;
+}
+function throttle(func, wait, options = {}) {
+  let timeoutId = null;
+  let lastArgs = null;
+  let lastThis = null;
+  let result;
+  let lastCallTime = 0;
+  const { leading = true, trailing = true } = options;
+  const invokeFunc = () => {
+    const args = lastArgs;
+    const thisArg = lastThis;
+    lastArgs = null;
+    lastThis = null;
+    lastCallTime = Date.now();
+    result = func.apply(thisArg, args);
+    return result;
+  };
+  const throttled = function(...args) {
+    const now = Date.now();
+    const remaining = wait - (now - lastCallTime);
+    lastArgs = args;
+    lastThis = this;
+    if (remaining <= 0 || remaining > wait) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      if (leading || lastCallTime !== 0) {
+        return invokeFunc();
+      }
+    }
+    if (!timeoutId && trailing) {
+      timeoutId = setTimeout(() => {
+        timeoutId = null;
+        if (trailing && lastArgs) {
+          invokeFunc();
+        }
+      }, remaining);
+    }
+    return result;
+  };
+  throttled.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = null;
+    lastArgs = null;
+    lastThis = null;
+    lastCallTime = 0;
+  };
+  return throttled;
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (obj instanceof Map) {
+    const clonedMap = /* @__PURE__ */ new Map();
+    obj.forEach((value, key) => {
+      clonedMap.set(deepClone(key), deepClone(value));
+    });
+    return clonedMap;
+  }
+  if (obj instanceof Set) {
+    const clonedSet = /* @__PURE__ */ new Set();
+    obj.forEach((value) => {
+      clonedSet.add(deepClone(value));
+    });
+    return clonedSet;
+  }
+  const clonedObj = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      clonedObj[key] = deepClone(obj[key]);
+    }
+  }
+  return clonedObj;
+}
+function deepMerge(target, ...sources) {
+  if (!sources.length)
+    return target;
+  const source = sources.shift();
+  if (source === void 0)
+    return target;
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const sourceValue = source[key];
+      const targetValue = target[key];
+      if (sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue !== null && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+        target[key] = deepMerge(targetValue, sourceValue);
+      } else {
+        target[key] = deepClone(sourceValue);
+      }
+    }
+  }
+  return deepMerge(target, ...sources);
+}
+function memoize(fn, options = {}) {
+  const { maxSize = 100, keyGenerator = (...args) => JSON.stringify(args) } = options;
+  const cache = /* @__PURE__ */ new Map();
+  const memoized = function(...args) {
+    const key = keyGenerator(...args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn(...args);
+    if (cache.size >= maxSize) {
+      const firstKey = cache.keys().next().value;
+      if (firstKey !== void 0) {
+        cache.delete(firstKey);
+      }
+    }
+    cache.set(key, result);
+    return result;
+  };
+  memoized.cache = cache;
+  memoized.clear = () => cache.clear();
+  return memoized;
+}
+function uuid() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function formatDate(date, format = "YYYY-MM-DD HH:mm:ss") {
+  const d = date instanceof Date ? date : new Date(date);
+  if (isNaN(d.getTime())) {
+    return "Invalid Date";
+  }
+  const pad = (n, len = 2) => String(n).padStart(len, "0");
+  const tokens = {
+    "YYYY": String(d.getFullYear()),
+    "YY": String(d.getFullYear()).slice(-2),
+    "MM": pad(d.getMonth() + 1),
+    "M": String(d.getMonth() + 1),
+    "DD": pad(d.getDate()),
+    "D": String(d.getDate()),
+    "HH": pad(d.getHours()),
+    "H": String(d.getHours()),
+    "hh": pad(d.getHours() % 12 || 12),
+    "h": String(d.getHours() % 12 || 12),
+    "mm": pad(d.getMinutes()),
+    "m": String(d.getMinutes()),
+    "ss": pad(d.getSeconds()),
+    "s": String(d.getSeconds()),
+    "SSS": pad(d.getMilliseconds(), 3),
+    "A": d.getHours() < 12 ? "AM" : "PM",
+    "a": d.getHours() < 12 ? "am" : "pm"
+  };
+  let result = format;
+  for (const token in tokens) {
+    result = result.replace(new RegExp(token, "g"), tokens[token]);
+  }
+  return result;
+}
+function shallowEqual(a, b) {
+  if (a === b)
+    return true;
+  if (!a || !b)
+    return false;
+  if (typeof a !== "object" || typeof b !== "object")
+    return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length)
+    return false;
+  for (const key of keysA) {
+    if (a[key] !== b[key])
+      return false;
+  }
+  return true;
+}
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null)
+    return false;
+  if (typeof a !== typeof b)
+    return false;
+  if (typeof a !== "object")
+    return false;
+  if (Array.isArray(a) !== Array.isArray(b))
+    return false;
+  if (Array.isArray(a)) {
+    if (a.length !== b.length)
+      return false;
+    return a.every((item, index) => deepEqual(item, b[index]));
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length)
+    return false;
+  return keysA.every((key) => deepEqual(a[key], b[key]));
+}
+function escapeHtml2(str) {
+  const htmlEscapes = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  };
+  return str.replace(/[&<>"']/g, (char) => htmlEscapes[char]);
+}
+function unescapeHtml(str) {
+  const htmlUnescapes = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'"
+  };
+  return str.replace(/&(?:amp|lt|gt|quot|#39);/g, (entity) => htmlUnescapes[entity] || entity);
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function camelCase(str) {
+  return str.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^(.)/, (char) => char.toLowerCase());
+}
+function kebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retry(fn, options = {}) {
+  const { retries = 3, delay = 1e3, backoff = 2, onRetry } = options;
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < retries) {
+        if (onRetry) {
+          onRetry(lastError, attempt + 1);
+        }
+        await sleep(delay * Math.pow(backoff, attempt));
+      }
+    }
+  }
+  throw lastError;
+}
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
+}
+function groupBy(array, key) {
+  return array.reduce((result, item) => {
+    const groupKey = typeof key === "function" ? key(item) : String(item[key]);
+    if (!result[groupKey]) {
+      result[groupKey] = [];
+    }
+    result[groupKey].push(item);
+    return result;
+  }, {});
+}
+function isEmpty(value) {
+  if (value === null || value === void 0)
+    return true;
+  if (typeof value === "string")
+    return value.trim() === "";
+  if (Array.isArray(value))
+    return value.length === 0;
+  if (value instanceof Map || value instanceof Set)
+    return value.size === 0;
+  if (typeof value === "object")
+    return Object.keys(value).length === 0;
+  return false;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function get(obj, path, defaultValue) {
+  const keys = Array.isArray(path) ? path : path.split(".");
+  let result = obj;
+  for (const key of keys) {
+    if (result === null || result === void 0) {
+      return defaultValue;
+    }
+    result = result[key];
+  }
+  return result === void 0 ? defaultValue : result;
+}
+function set(obj, path, value) {
+  const keys = Array.isArray(path) ? path : path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+  return obj;
+}
+
+// src/core/errors.ts
+var BaraqexError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    __publicField(this, "code");
+    __publicField(this, "hint");
+    __publicField(this, "docs");
+    __publicField(this, "originalCause");
+    this.name = "BaraqexError";
+    this.code = options.code;
+    this.hint = options.hint;
+    this.docs = options.docs;
+    this.originalCause = options.cause;
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+  /**
+   * Format error for console output with helpful hints
+   */
+  format() {
+    let output = `
+\u274C ${this.name}: ${this.message}
+`;
+    output += `   Code: ${this.code}
+`;
+    if (this.hint) {
+      output += `   \u{1F4A1} Hint: ${this.hint}
+`;
+    }
+    if (this.docs) {
+      output += `   \u{1F4DA} Docs: ${this.docs}
+`;
+    }
+    return output;
+  }
+};
+var ConfigError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "CONFIG_ERROR",
+      hint: options?.hint || "Check your baraqex.config.js or server configuration",
+      docs: "https://baraqex.tech/docs/configuration",
+      cause: options?.cause
+    });
+    this.name = "ConfigError";
+  }
+};
+var DatabaseError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "DATABASE_ERROR",
+      hint: options?.hint || "Verify your database connection string and credentials",
+      docs: "https://baraqex.tech/docs/database",
+      cause: options?.cause
+    });
+    __publicField(this, "dbType");
+    this.name = "DatabaseError";
+    this.dbType = options?.dbType;
+  }
+};
+var AuthError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "AUTH_ERROR",
+      hint: options?.hint || "Check your JWT secret and token configuration",
+      docs: "https://baraqex.tech/docs/authentication",
+      cause: options?.cause
+    });
+    this.name = "AuthError";
+  }
+};
+var WasmError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "WASM_ERROR",
+      hint: options?.hint || "Ensure your .wasm file is accessible and properly compiled",
+      docs: "https://baraqex.tech/docs/webassembly",
+      cause: options?.cause
+    });
+    this.name = "WasmError";
+  }
+};
+var RouterError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "ROUTER_ERROR",
+      hint: options?.hint || "Check your API route file structure and exports",
+      docs: "https://baraqex.tech/docs/routing",
+      cause: options?.cause
+    });
+    this.name = "RouterError";
+  }
+};
+var ValidationError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "VALIDATION_ERROR",
+      hint: options?.hint,
+      cause: options?.cause
+    });
+    __publicField(this, "field");
+    __publicField(this, "value");
+    this.name = "ValidationError";
+    this.field = options?.field;
+    this.value = options?.value;
+  }
+};
+function formatError(error) {
+  if (error instanceof BaraqexError) {
+    return error.format();
+  }
+  if (error instanceof Error) {
+    return `
+\u274C Error: ${error.message}
+`;
+  }
+  return `
+\u274C Unknown error: ${String(error)}
+`;
+}
+function withErrorHandling(fn, errorHandler2) {
+  return async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (error) {
+      if (errorHandler2) {
+        errorHandler2(error);
+      } else {
+        console.error(formatError(error));
+      }
+      throw error;
+    }
+  };
+}
+
 // src/wasm.ts
 async function loadGoWasm(wasmUrl, options = {}) {
   if (typeof window === "undefined") {
@@ -402,7 +2392,7 @@ var generateToken = (length = 32) => {
 var generateDocument = (content, options = {}) => `<!DOCTYPE html><html><head><title>${options.title || "App"}</title></head><body>${content}</body></html>`;
 var generateErrorPage = (code, message) => `<div>Error ${code}: ${message}</div>`;
 var generateLoadingPage = (message = "Loading...") => `<div>${message}</div>`;
-var renderToString = (component) => {
+var renderToString2 = (component) => {
   try {
     if (typeof component === "function") {
       const result = component();
@@ -445,58 +2435,182 @@ var writeJsonFile = null;
 var readJsonFile = null;
 var baraqexRenderToString = null;
 var renderComponent = null;
-console.log("Baraqex - Browser build loaded");
 export {
   ApiRouter,
+  AuthError,
   AuthService,
+  BaraqexError,
   BaraqexServer,
+  Component,
+  ConfigError,
   Database,
+  DatabaseError,
   Fragment,
+  LifecycleEvents,
+  Link,
+  NavLink,
+  PureComponent,
+  Redirect,
+  Route,
+  Router,
+  RouterContext,
+  RouterError,
+  RouterProvider,
+  StoreContext,
+  StoreProvider,
+  Switch,
+  ValidationError,
+  WasmError,
+  applyPatches,
   baraqexRenderToString,
   batchUpdates,
+  calculatePatches,
   callWasmFunction,
+  camelCase,
+  capitalize,
+  clamp,
+  cleanupHooks,
+  cleanupRoot,
+  combineReducers,
+  createAction,
+  createClassComponent,
   createContext,
   createDevServer,
+  createElement,
+  createElementSync,
+  createEventBus,
   createProductionServer,
+  createRoot,
+  createRootState,
   createServer,
+  createSlice,
+  createStore,
+  debounce,
+  deepClone,
+  deepEqual,
+  deepMerge,
+  deferred,
+  devTools,
+  diff,
+  emitAppDestroyed,
+  emitAppError,
+  emitAppInit,
+  emitAppMounted,
+  emitAppUpdated,
+  emitComponentCreated,
+  emitComponentError,
+  emitComponentMounted,
+  emitComponentUnmounted,
+  emitComponentUpdated,
+  emitRouterAfterChange,
+  emitRouterBeforeChange,
+  emitRouterError,
+  emitStoreAfterAction,
+  emitStoreBeforeAction,
+  emitStoreError,
+  emitStoreInitialized,
   ensureDirectory,
   errorHandler,
+  escapeHtml2 as escapeHtml,
+  eventBus,
+  finishRender,
+  formatDate,
   generateDocument,
   generateErrorPage,
   generateLoadingPage,
   generateToken,
+  get,
+  getContextValue,
+  getCurrentRoot,
   getEnvironmentInfo,
+  getIsBatching,
   getPagination,
   getWasmFunctions,
+  groupBy,
+  hasRoot,
   hashString,
   hydrate,
   initNodeWasm,
   isDirectoryEmpty,
+  isEmpty,
   isWasmReady,
   jsx,
-  jsx as jsxs,
+  jsxDEV,
+  jsxs,
+  kebabCase,
   loadGoWasm,
   loadGoWasmFromFile,
+  logger,
+  memoize,
   notFoundHandler,
+  omit,
+  onAppDestroyed,
+  onAppError,
+  onAppInit,
+  onAppMounted,
+  onAppUpdated,
+  onComponentCreated,
+  onComponentError,
+  onComponentMounted,
+  onComponentUnmounted,
+  onComponentUpdated,
+  onRouterAfterChange,
+  onRouterBeforeChange,
+  onRouterError,
+  onStoreAfterAction,
+  onStoreBeforeAction,
+  onStoreError,
+  onStoreInitialized,
+  patterns,
+  pick,
+  prepareRender,
   rateLimit,
   readJsonFile,
   render,
   renderComponent,
-  renderToString,
+  renderToStream,
+  renderToString2 as renderToString,
+  renderToStringWithData,
   requestLogger,
+  retry,
   safeJsonParse,
   sendError,
   sendSuccess,
-  server,
+  set,
+  setCurrentRoot,
+  shallowEqual,
+  shouldComponentUpdate,
+  sleep,
+  throttle,
+  thunk,
+  unescapeHtml,
+  useCallback,
   useContext,
+  useDispatch,
   useEffect,
   useErrorBoundary,
+  useEvent,
+  useField,
+  useForm,
   useGoWasm,
+  useId,
+  useLayoutEffect,
+  useLocation,
+  useMatch,
   useMemo,
+  useNavigate,
+  useParams,
+  useReducer,
   useRef,
+  useRouter,
+  useSearchParams,
+  useSelector,
   useState,
+  useStore,
+  uuid,
   validateFields,
   validateFileUpload,
+  withErrorHandling,
   writeJsonFile
 };
 //# sourceMappingURL=browser.js.map