frontend-hamroun 1.2.4 → 1.2.5

package/dist/frontend-hamroun.es.js

@@ -1,547 +1,468 @@
-import express, { Router } from "express";
-import { Router as Router2 } from "express";
-import path from "path";
-import compression from "compression";
-import helmet from "helmet";
-import morgan from "morgan";
-import mongoose from "mongoose";
-import fs from "fs";
-import jwt from "jsonwebtoken";
-import bcrypt from "bcrypt";
-const globalObj = typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
-function jsx(type, props, key) {
+import R, { Router as ae } from "express";
+import { Router as Et } from "express";
+import de from "path";
+import _e from "compression";
+import Ie from "helmet";
+import Re from "morgan";
+import $ from "mongoose";
+import Ne from "fs";
+import z from "jsonwebtoken";
+import * as fe from "bcrypt";
+import Oe from "crypto";
+const he = globalThis || void 0 || self;
+function De(r) {
+  return r && r.__esModule && Object.prototype.hasOwnProperty.call(r, "default") ? r.default : r;
+}
+var ye = { exports: {} }, m = ye.exports = {}, k, v;
+function te() {
+  throw new Error("setTimeout has not been defined");
+}
+function re() {
+  throw new Error("clearTimeout has not been defined");
+}
+(function() {
+  try {
+    typeof setTimeout == "function" ? k = setTimeout : k = te;
+  } catch {
+    k = te;
+  }
+  try {
+    typeof clearTimeout == "function" ? v = clearTimeout : v = re;
+  } catch {
+    v = re;
+  }
+})();
+function ge(r) {
+  if (k === setTimeout)
+    return setTimeout(r, 0);
+  if ((k === te || !k) && setTimeout)
+    return k = setTimeout, setTimeout(r, 0);
+  try {
+    return k(r, 0);
+  } catch {
+    try {
+      return k.call(null, r, 0);
+    } catch {
+      return k.call(this, r, 0);
+    }
+  }
+}
+function Pe(r) {
+  if (v === clearTimeout)
+    return clearTimeout(r);
+  if ((v === re || !v) && clearTimeout)
+    return v = clearTimeout, clearTimeout(r);
+  try {
+    return v(r);
+  } catch {
+    try {
+      return v.call(null, r);
+    } catch {
+      return v.call(this, r);
+    }
+  }
+}
+var A = [], O = !1, _, H = -1;
+function Me() {
+  !O || !_ || (O = !1, _.length ? A = _.concat(A) : H = -1, A.length && we());
+}
+function we() {
+  if (!O) {
+    var r = ge(Me);
+    O = !0;
+    for (var t = A.length; t; ) {
+      for (_ = A, A = []; ++H < t; )
+        _ && _[H].run();
+      H = -1, t = A.length;
+    }
+    _ = null, O = !1, Pe(r);
+  }
+}
+m.nextTick = function(r) {
+  var t = new Array(arguments.length - 1);
+  if (arguments.length > 1)
+    for (var e = 1; e < arguments.length; e++)
+      t[e - 1] = arguments[e];
+  A.push(new Ee(r, t)), A.length === 1 && !O && ge(we);
+};
+function Ee(r, t) {
+  this.fun = r, this.array = t;
+}
+Ee.prototype.run = function() {
+  this.fun.apply(null, this.array);
+};
+m.title = "browser";
+m.browser = !0;
+m.env = {};
+m.argv = [];
+m.version = "";
+m.versions = {};
+function x() {
+}
+m.on = x;
+m.addListener = x;
+m.once = x;
+m.off = x;
+m.removeListener = x;
+m.removeAllListeners = x;
+m.emit = x;
+m.prependListener = x;
+m.prependOnceListener = x;
+m.listeners = function(r) {
+  return [];
+};
+m.binding = function(r) {
+  throw new Error("process.binding is not supported");
+};
+m.cwd = function() {
+  return "/";
+};
+m.chdir = function(r) {
+  throw new Error("process.chdir is not supported");
+};
+m.umask = function() {
+  return 0;
+};
+var Fe = ye.exports;
+const w = /* @__PURE__ */ De(Fe), j = typeof window < "u" ? window : typeof he < "u" ? he : {};
+function ce(r, t, e) {
   return {
-    type,
-    props: props || {},
-    key
+    type: r,
+    props: t || {},
+    key: e
   };
 }
-function jsxs(type, props, key) {
-  return jsx(type, props, key);
+function be(r, t, e) {
+  return ce(r, t, e);
 }
-function createElement$1(vnode) {
-  if (typeof vnode === "string" || typeof vnode === "number") {
-    return document.createTextNode(String(vnode));
-  }
-  if (typeof vnode.type === "function") {
-    const result = vnode.type(vnode.props);
-    return createElement$1(result);
+function se(r) {
+  if (typeof r == "string" || typeof r == "number")
+    return document.createTextNode(String(r));
+  if (typeof r.type == "function") {
+    const e = r.type(r.props);
+    return se(e);
   }
-  const element = document.createElement(vnode.type);
-  Object.entries(vnode.props || {}).forEach(([name, value]) => {
-    if (name === "children") {
-      const children = Array.isArray(value) ? value : [value];
-      children.forEach((child) => {
-        if (child != null) {
-          const childElement = createElement$1(child);
-          if (process.env.NODE_ENV === "test" && typeof window !== "undefined") {
-            if (!globalObj.__renderStats) {
-              globalObj.__renderStats = {
-                elementsCreated: 0,
-                textNodesCreated: 0,
-                eventsAttached: 0,
-                renderTime: 0
-              };
-              if (typeof afterAll === "function") {
-                afterAll(() => {
-                  try {
-                    const fs2 = require("fs");
-                    const path2 = require("path");
-                    const statsPath = path2.resolve(process.cwd(), "jsx-runtime-stats.json");
-                    fs2.writeFileSync(statsPath, JSON.stringify(globalObj.__renderStats, null, 2));
-                    console.log(`JSX runtime stats written to ${statsPath}`);
-                  } catch (error) {
-                    console.error("Failed to write stats file:", error);
-                  }
-                });
-              }
+  const t = document.createElement(r.type);
+  return Object.entries(r.props || {}).forEach(([e, s]) => {
+    if (e === "children")
+      (Array.isArray(s) ? s : [s]).forEach((i) => {
+        if (i != null) {
+          const o = se(i);
+          w.env.NODE_ENV === "test" && typeof window < "u" && (j.__renderStats || (j.__renderStats = {
+            elementsCreated: 0,
+            textNodesCreated: 0,
+            eventsAttached: 0,
+            renderTime: 0
+          }, typeof afterAll == "function" && afterAll(() => {
+            try {
+              const a = require("fs"), d = require("path").resolve(w.cwd(), "jsx-runtime-stats.json");
+              a.writeFileSync(d, JSON.stringify(j.__renderStats, null, 2)), console.log(`JSX runtime stats written to ${d}`);
+            } catch (a) {
+              console.error("Failed to write stats file:", a);
             }
-            if (childElement instanceof Text) {
-              globalObj.__renderStats.textNodesCreated++;
-            } else {
-              globalObj.__renderStats.elementsCreated++;
-            }
-          }
-          element.appendChild(childElement);
+          })), o instanceof Text ? j.__renderStats.textNodesCreated++ : j.__renderStats.elementsCreated++), t.appendChild(o);
         }
       });
-    } else if (name.startsWith("on")) {
-      const eventName = name.toLowerCase().substring(2);
-      element.addEventListener(eventName, value);
-      if (process.env.NODE_ENV === "test" && typeof window !== "undefined" && globalObj.__renderStats) {
-        globalObj.__renderStats.eventsAttached++;
-      }
-    } else if (name === "className") {
-      element.setAttribute("class", value);
-    } else if (name === "style" && typeof value === "object") {
-      Object.entries(value).forEach(([styleProp, styleValue]) => {
-        element.style[styleProp] = String(styleValue);
-      });
-    } else {
-      element.setAttribute(name, value);
-    }
-  });
-  return element;
-}
-const Fragment = Symbol("Fragment");
-if (typeof window !== "undefined") {
-  window.jsx = jsx;
-  window.jsxs = jsxs;
-  window.Fragment = Fragment;
+    else if (e.startsWith("on")) {
+      const n = e.toLowerCase().substring(2);
+      t.addEventListener(n, s), w.env.NODE_ENV === "test" && typeof window < "u" && j.__renderStats && j.__renderStats.eventsAttached++;
+    } else e === "className" ? t.setAttribute("class", s) : e === "style" && typeof s == "object" ? Object.entries(s).forEach(([n, i]) => {
+      t.style[n] = String(i);
+    }) : t.setAttribute(e, s);
+  }), t;
 }
-const isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
-async function createElement(vnode) {
-  var _a;
-  console.log("Creating element from:", vnode);
-  if (!isBrowser) {
-    if (vnode == null) {
+const Te = Symbol("Fragment");
+typeof window < "u" && (window.jsx = ce, window.jsxs = be, window.Fragment = Te);
+const Le = typeof window < "u" && typeof document < "u";
+async function C(r) {
+  var t;
+  if (console.log("Creating element from:", r), !Le) {
+    if (r == null)
       return { nodeType: 3, textContent: "" };
-    }
-    if (typeof vnode === "boolean") {
+    if (typeof r == "boolean")
       return { nodeType: 3, textContent: "" };
-    }
-    if (typeof vnode === "number" || typeof vnode === "string") {
-      return { nodeType: 3, textContent: String(vnode) };
-    }
-    if (Array.isArray(vnode)) {
-      const fragment = { nodeType: 11, childNodes: [] };
-      for (const child of vnode) {
-        const node = await createElement(child);
-        fragment.childNodes.push(node);
+    if (typeof r == "number" || typeof r == "string")
+      return { nodeType: 3, textContent: String(r) };
+    if (Array.isArray(r)) {
+      const e = { nodeType: 11, childNodes: [] };
+      for (const s of r) {
+        const n = await C(s);
+        e.childNodes.push(n);
       }
-      return fragment;
+      return e;
     }
-    if ("type" in vnode && vnode.props !== void 0) {
-      const { type, props } = vnode;
-      if (typeof type === "function") {
+    if ("type" in r && r.props !== void 0) {
+      const { type: e, props: s } = r;
+      if (typeof e == "function")
         try {
-          const result = await type(props || {});
-          const node = await createElement(result);
-          return node;
-        } catch (error) {
-          console.error("Error rendering component:", error);
-          return { nodeType: 3, textContent: "" };
+          const o = await e(s || {});
+          return await C(o);
+        } catch (o) {
+          return console.error("Error rendering component:", o), { nodeType: 3, textContent: "" };
         }
-      }
-      const element = {
+      const n = {
         nodeType: 1,
-        tagName: type,
+        tagName: e,
         attributes: {},
         style: {},
         childNodes: [],
-        setAttribute: function(key, value) {
-          this.attributes[key] = value;
+        setAttribute: function(o, a) {
+          this.attributes[o] = a;
         },
-        appendChild: function(child) {
-          this.childNodes.push(child);
+        appendChild: function(o) {
+          this.childNodes.push(o);
         }
       };
-      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);
-          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));
+      for (const [o, a] of Object.entries(s || {}))
+        if (o !== "children")
+          if (o.startsWith("on") && typeof a == "function") {
+            const c = o.toLowerCase().slice(2);
+            n.__events || (n.__events = {}), n.__events[c] = a;
+          } else o === "style" && typeof a == "object" ? Object.assign(n.style, a) : o === "className" ? n.setAttribute("class", String(a)) : o !== "key" && o !== "ref" && n.setAttribute(o, String(a));
+      const i = s == null ? void 0 : s.children;
+      if (i != null) {
+        const o = Array.isArray(i) ? i.flat() : [i];
+        for (const a of o) {
+          const c = await C(a);
+          n.appendChild(c);
         }
       }
-      const children = props == null ? void 0 : props.children;
-      if (children != null) {
-        const childArray = Array.isArray(children) ? children.flat() : [children];
-        for (const child of childArray) {
-          const childNode = await createElement(child);
-          element.appendChild(childNode);
-        }
-      }
-      return element;
+      return n;
     }
-    return { nodeType: 3, textContent: String(vnode) };
-  }
-  if (vnode == null) {
-    return document.createTextNode("");
+    return { nodeType: 3, textContent: String(r) };
   }
-  if (typeof vnode === "boolean") {
+  if (r == null || typeof r == "boolean")
     return document.createTextNode("");
-  }
-  if (typeof vnode === "number" || typeof vnode === "string") {
-    return document.createTextNode(String(vnode));
-  }
-  if (Array.isArray(vnode)) {
-    const fragment = document.createDocumentFragment();
-    for (const child of vnode) {
-      const node = await createElement(child);
-      fragment.appendChild(node);
+  if (typeof r == "number" || typeof r == "string")
+    return document.createTextNode(String(r));
+  if (Array.isArray(r)) {
+    const e = document.createDocumentFragment();
+    for (const s of r) {
+      const n = await C(s);
+      e.appendChild(n);
     }
-    return fragment;
+    return e;
   }
-  if ("type" in vnode && vnode.props !== void 0) {
-    const { type, props } = vnode;
-    if (typeof type === "function") {
+  if ("type" in r && r.props !== void 0) {
+    const { type: e, props: s } = r;
+    if (typeof e == "function")
       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 o = await e(s || {}), a = await C(o);
+        return a instanceof Element && a.setAttribute("data-component-id", e.name || e.toString()), a;
+      } catch (o) {
+        return console.error("Error rendering component:", o), document.createTextNode("");
       }
-    }
-    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;
-    if (children != null) {
-      const childArray = Array.isArray(children) ? children.flat() : [children];
-      for (const child of childArray) {
-        const childNode = await createElement(child);
-        element.appendChild(childNode);
+    const n = document.createElement(e);
+    for (const [o, a] of Object.entries(s || {}))
+      if (o !== "children")
+        if (o.startsWith("on") && typeof a == "function") {
+          const c = o.toLowerCase().slice(2), d = (t = n.__events) == null ? void 0 : t[c];
+          d && n.removeEventListener(c, d), n.addEventListener(c, a), n.__events || (n.__events = {}), n.__events[c] = a;
+        } else o === "style" && typeof a == "object" ? Object.assign(n.style, a) : o === "className" ? n.setAttribute("class", String(a)) : o !== "key" && o !== "ref" && n.setAttribute(o, String(a));
+    const i = s == null ? void 0 : s.children;
+    if (i != null) {
+      const o = Array.isArray(i) ? i.flat() : [i];
+      for (const a of o) {
+        const c = await C(a);
+        n.appendChild(c);
       }
     }
-    return element;
+    return n;
   }
-  return document.createTextNode(String(vnode));
+  return document.createTextNode(String(r));
 }
-class Component {
-  constructor(props = {}) {
-    this.state = {};
-    this.element = null;
-    this._mounted = false;
-    this.props = props;
+class Be {
+  constructor(t = {}) {
+    this.state = {}, this.element = null, this._mounted = !1, this.props = t;
   }
   componentDidMount() {
   }
-  async setState(newState) {
-    const prevState = { ...this.state };
-    this.state = { ...prevState, ...newState };
-    console.log(`${this.constructor.name} state updated:`, {
-      prev: prevState,
+  async setState(t) {
+    const e = { ...this.state };
+    this.state = { ...e, ...t }, console.log(`${this.constructor.name} state updated:`, {
+      prev: e,
       next: this.state
-    });
-    await Promise.resolve();
-    if (this._mounted) {
-      await this.update();
-    } else {
-      await this.update();
-    }
+    }), await Promise.resolve(), this._mounted ? await this.update() : await this.update();
   }
-  _replayEvents(oldElement, newElement) {
-    const oldEvents = oldElement.__events || {};
-    Object.entries(oldEvents).forEach(([event, handler]) => {
-      newElement.addEventListener(event, handler);
-    });
-    newElement.__events = oldEvents;
+  _replayEvents(t, e) {
+    const s = t.__events || {};
+    Object.entries(s).forEach(([n, i]) => {
+      e.addEventListener(n, i);
+    }), e.__events = s;
   }
-  _deepCloneWithEvents(node) {
-    const clone = node.cloneNode(false);
-    const events = node.__events || {};
-    clone.__events = events;
-    Object.entries(events).forEach(([event, handler]) => {
-      clone.addEventListener(event, handler);
-    });
-    Array.from(node.childNodes).forEach((child) => {
-      if (child instanceof HTMLElement) {
-        clone.appendChild(this._deepCloneWithEvents(child));
-      } else {
-        clone.appendChild(child.cloneNode(true));
-      }
-    });
-    return clone;
+  _deepCloneWithEvents(t) {
+    const e = t.cloneNode(!1), s = t.__events || {};
+    return e.__events = s, Object.entries(s).forEach(([n, i]) => {
+      e.addEventListener(n, i);
+    }), Array.from(t.childNodes).forEach((n) => {
+      n instanceof HTMLElement ? e.appendChild(this._deepCloneWithEvents(n)) : e.appendChild(n.cloneNode(!0));
+    }), e;
   }
   async update() {
-    const vdom = this.render();
-    if (!vdom) return document.createTextNode("");
-    const rendered = await createElement(vdom);
-    if (rendered instanceof HTMLElement) {
-      return this._updateElement(rendered);
-    }
-    const wrapper = document.createElement("div");
-    wrapper.appendChild(rendered);
-    return this._updateElement(wrapper);
+    const t = this.render();
+    if (!t) return document.createTextNode("");
+    const e = await C(t);
+    if (e instanceof HTMLElement)
+      return this._updateElement(e);
+    const s = document.createElement("div");
+    return s.appendChild(e), this._updateElement(s);
   }
-  async _updateElement(rendered) {
-    const newElement = this._deepCloneWithEvents(rendered);
-    newElement.__instance = this;
-    if (!this.element) {
-      this.element = newElement;
-      if (!this._mounted) {
-        this._mounted = true;
-        queueMicrotask(() => this.componentDidMount());
-      }
-    } else if (this.element.parentNode) {
-      this.element.parentNode.replaceChild(newElement, this.element);
-      this.element = newElement;
-    }
-    return this.element;
+  async _updateElement(t) {
+    const e = this._deepCloneWithEvents(t);
+    return e.__instance = this, this.element ? this.element.parentNode && (this.element.parentNode.replaceChild(e, this.element), this.element = e) : (this.element = e, this._mounted || (this._mounted = !0, queueMicrotask(() => this.componentDidMount()))), this.element;
   }
   render() {
     throw new Error("Component must implement render() method");
   }
 }
-let isBatching = false;
-const queue = [];
-function batchUpdates(fn) {
-  if (isBatching) {
-    queue.push(fn);
+let V = !1;
+const X = [];
+function ue(r) {
+  if (V) {
+    X.push(r);
     return;
   }
-  isBatching = true;
+  V = !0;
   try {
-    fn();
-    while (queue.length > 0) {
-      const nextFn = queue.shift();
-      nextFn == null ? void 0 : nextFn();
+    for (r(); X.length > 0; ) {
+      const t = X.shift();
+      t == null || t();
     }
   } finally {
-    isBatching = false;
+    V = !1;
   }
 }
-let currentRender = 0;
-const states = /* @__PURE__ */ new Map();
-const stateIndices = /* @__PURE__ */ new Map();
-const effects = /* @__PURE__ */ new Map();
-const memos = /* @__PURE__ */ new Map();
-const refs = /* @__PURE__ */ new Map();
-let globalRenderCallback = null;
-let globalContainer = null;
-let currentElement = null;
-const isServer = typeof window === "undefined";
-const serverStates = /* @__PURE__ */ new Map();
-function setRenderCallback(callback, element, container) {
-  globalRenderCallback = callback;
-  globalContainer = container;
-  currentElement = element;
+let u = 0;
+const Z = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map(), F = /* @__PURE__ */ new Map(), K = /* @__PURE__ */ new Map(), ee = /* @__PURE__ */ new Map();
+let ne = null, oe = null, ie = null;
+const ke = typeof window > "u", W = /* @__PURE__ */ new Map();
+function ve(r, t, e) {
+  ne = r, oe = e, ie = t;
 }
-function prepareRender() {
-  currentRender++;
-  stateIndices.set(currentRender, 0);
-  return currentRender;
+function U() {
+  return u++, b.set(u, 0), u;
 }
-function finishRender() {
-  if (isServer) {
-    serverStates.delete(currentRender);
-  }
-  currentRender = 0;
+function q() {
+  ke && W.delete(u), u = 0;
 }
-function useState(initial) {
-  if (!currentRender) {
+function Se(r) {
+  if (!u)
     throw new Error("useState must be called within a render");
-  }
-  if (isServer) {
-    if (!serverStates.has(currentRender)) {
-      serverStates.set(currentRender, /* @__PURE__ */ new Map());
-    }
-    const componentState = serverStates.get(currentRender);
-    const index22 = stateIndices.get(currentRender) || 0;
-    if (!componentState.has(index22)) {
-      componentState.set(index22, initial);
-    }
-    const state2 = componentState.get(index22);
-    const setState2 = (newValue) => {
+  if (ke) {
+    W.has(u) || W.set(u, /* @__PURE__ */ new Map());
+    const i = W.get(u), o = b.get(u) || 0;
+    i.has(o) || i.set(o, r);
+    const a = i.get(o), c = (d) => {
     };
-    stateIndices.set(currentRender, index22 + 1);
-    return [state2, setState2];
-  }
-  if (!states.has(currentRender)) {
-    states.set(currentRender, []);
+    return b.set(u, o + 1), [a, c];
   }
-  const componentStates = states.get(currentRender);
-  const index2 = stateIndices.get(currentRender);
-  if (index2 >= componentStates.length) {
-    componentStates.push(initial);
-  }
-  const state = componentStates[index2];
-  const setState = (newValue) => {
-    const nextValue = typeof newValue === "function" ? newValue(componentStates[index2]) : newValue;
-    if (componentStates[index2] === nextValue) return;
-    componentStates[index2] = nextValue;
-    if (isBatching) {
-      batchUpdates(() => rerender(currentRender));
-    } else {
-      rerender(currentRender);
-    }
+  Z.has(u) || Z.set(u, []);
+  const t = Z.get(u), e = b.get(u);
+  e >= t.length && t.push(r);
+  const s = t[e], n = (i) => {
+    const o = typeof i == "function" ? i(t[e]) : i;
+    t[e] !== o && (t[e] = o, V ? ue(() => pe(u)) : pe(u));
   };
-  stateIndices.set(currentRender, index2 + 1);
-  return [state, setState];
+  return b.set(u, e + 1), [s, n];
 }
-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) {
-      prevEffect.cleanup();
-    }
-    queueMicrotask(() => {
-      const cleanup = callback() || void 0;
-      componentEffects[effectIndex] = { cleanup, deps };
-    });
-  }
-  stateIndices.set(currentRender, effectIndex + 1);
+function He(r, t) {
+  if (!u) throw new Error("useEffect must be called within a render");
+  const e = b.get(u);
+  F.has(u) || F.set(u, []);
+  const s = F.get(u), n = s[e];
+  (!n || !t || !n.deps || t.some((i, o) => i !== n.deps[o])) && (n != null && n.cleanup && n.cleanup(), queueMicrotask(() => {
+    const i = r() || void 0;
+    s[e] = { cleanup: i, deps: t };
+  })), b.set(u, e + 1);
 }
-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, []);
+function Ve(r, t) {
+  if (!u) throw new Error("useMemo must be called within a render");
+  const e = b.get(u);
+  K.has(u) || K.set(u, []);
+  const s = K.get(u), n = s[e];
+  if (!n || t && t.some((i, o) => !Object.is(i, n.deps[o]))) {
+    const i = r();
+    return s[e] = { value: i, deps: t }, b.set(u, e + 1), i;
   }
-  const componentMemos = memos.get(currentRender);
-  const prevMemo = componentMemos[memoIndex];
-  if (!prevMemo || deps && deps.some((dep, i) => !Object.is(dep, prevMemo.deps[i]))) {
-    const value = factory();
-    componentMemos[memoIndex] = { value, deps };
-    stateIndices.set(currentRender, memoIndex + 1);
-    return value;
-  }
-  stateIndices.set(currentRender, memoIndex + 1);
-  return prevMemo.value;
+  return b.set(u, e + 1), n.value;
 }
-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;
+function We(r) {
+  if (!u) throw new Error("useRef must be called within a render");
+  const t = b.get(u);
+  ee.has(u) || ee.set(u, []);
+  const e = ee.get(u);
+  if (t >= e.length) {
+    const n = { current: r };
+    return e.push(n), b.set(u, t + 1), n;
   }
-  const ref = componentRefs[refIndex];
-  stateIndices.set(currentRender, refIndex + 1);
-  return ref;
+  const s = e[t];
+  return b.set(u, t + 1), s;
 }
-async function rerender(rendererId) {
+async function pe(r) {
   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 t = F.get(r);
+    t && (t.forEach((e) => {
+      e.cleanup && e.cleanup();
+    }), F.set(r, [])), ne && oe && ie && await ne(ie, oe);
+  } catch (t) {
+    console.error("Error during rerender:", t);
   }
 }
-function useErrorBoundary() {
-  const [error, setError] = useState(null);
-  return [error, () => setError(null)];
+function Ue() {
+  const [r, t] = Se(null);
+  return [r, () => t(null)];
 }
-let isHydrating = false;
-async function hydrate(element, container) {
-  isHydrating = true;
+let G = !1;
+async function qe(r, t) {
+  G = !0;
   try {
-    await render(element, container);
+    await le(r, t);
   } finally {
-    isHydrating = false;
+    G = !1;
   }
 }
-async function render(element, container) {
-  console.log("Rendering to:", container.id || "unnamed-container");
-  batchUpdates(async () => {
-    const rendererId = prepareRender();
+async function le(r, t) {
+  console.log("Rendering to:", t.id || "unnamed-container"), ue(async () => {
+    const e = U();
     try {
-      setRenderCallback(render, element, container);
-      const domNode = await createElement(element);
-      if (!isHydrating) {
-        container.innerHTML = "";
-      }
-      if (isHydrating && container.firstChild) {
-        console.log("Hydrating existing DOM");
-      } else {
-        container.appendChild(domNode);
-      }
+      ve(le, r, t);
+      const s = await C(r);
+      G || (t.innerHTML = ""), G && t.firstChild ? console.log("Hydrating existing DOM") : t.appendChild(s);
     } finally {
-      finishRender();
+      q();
     }
   });
 }
-async function renderToString(element) {
-  prepareRender();
-  setRenderCallback(() => {
-  }, element, null);
+async function N(r) {
+  U(), ve(() => {
+  }, r, null);
   try {
-    if (element == null) return "";
-    if (typeof element === "boolean") return "";
-    if (typeof element === "number" || typeof element === "string") {
-      return escapeHtml(String(element));
-    }
-    if (Array.isArray(element)) {
-      const children = await Promise.all(element.map(renderToString));
-      return children.join("");
-    }
-    if ("type" in element && element.props !== void 0) {
-      const { type, props } = element;
-      if (typeof type === "function") {
+    if (r == null || typeof r == "boolean") return "";
+    if (typeof r == "number" || typeof r == "string")
+      return B(String(r));
+    if (Array.isArray(r))
+      return (await Promise.all(r.map(N))).join("");
+    if ("type" in r && r.props !== void 0) {
+      const { type: t, props: e } = r;
+      if (typeof t == "function")
         try {
-          prepareRender();
-          const result = await type(props || {});
-          const html2 = await renderToString(result);
-          finishRender();
-          return html2;
-        } catch (error) {
-          console.error("Error rendering component:", error);
-          return "";
+          U();
+          const i = await t(e || {}), o = await N(i);
+          return q(), o;
+        } catch (i) {
+          return console.error("Error rendering component:", i), "";
         }
-      }
-      if (type === Symbol.for("react.fragment") || type.name === "Fragment") {
-        if (props.children) {
-          const children = Array.isArray(props.children) ? props.children : [props.children];
-          const renderedChildren = await Promise.all(children.map(renderToString));
-          return renderedChildren.join("");
+      if (t === Symbol.for("react.fragment") || t.name === "Fragment") {
+        if (e.children) {
+          const i = Array.isArray(e.children) ? e.children : [e.children];
+          return (await Promise.all(i.map(N))).join("");
         }
         return "";
       }
-      let html = `<${type}`;
-      for (const [key, value] of Object.entries(props || {})) {
-        if (key === "children" || key === "key") continue;
-        if (key === "className") {
-          html += ` class="${escapeHtml(String(value))}"`;
-        } else if (key === "style" && typeof value === "object") {
-          html += ` style="${stringifyStyle(value || {})}"`;
-        } else if (!key.startsWith("on")) {
-          html += ` ${key}="${escapeHtml(String(value))}"`;
-        }
-      }
-      const voidElements = /* @__PURE__ */ new Set([
+      let s = `<${t}`;
+      for (const [i, o] of Object.entries(e || {}))
+        i === "children" || i === "key" || (i === "className" ? s += ` class="${B(String(o))}"` : i === "style" && typeof o == "object" ? s += ` style="${Ge(o || {})}"` : i.startsWith("on") || (s += ` ${i}="${B(String(o))}"`));
+      if ((/* @__PURE__ */ new Set([
         "area",
         "base",
         "br",
@@ -556,44 +477,38 @@ async function renderToString(element) {
         "source",
         "track",
         "wbr"
-      ]);
-      if (voidElements.has(type)) {
-        return html + "/>";
+      ])).has(t))
+        return s + "/>";
+      if (s += ">", e != null && e.children) {
+        const i = Array.isArray(e.children) ? e.children : [e.children];
+        for (const o of i)
+          s += await N(o);
       }
-      html += ">";
-      if (props == null ? void 0 : props.children) {
-        const children = Array.isArray(props.children) ? props.children : [props.children];
-        for (const child of children) {
-          html += await renderToString(child);
-        }
-      }
-      return html + `</${type}>`;
+      return s + `</${t}>`;
     }
-    return escapeHtml(String(element));
+    return B(String(r));
   } finally {
-    finishRender();
+    q();
   }
 }
-function escapeHtml(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+function B(r) {
+  return r.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
-function stringifyStyle(style) {
-  return Object.entries(style).map(([key, value]) => `${hyphenate(key)}:${value}`).join(";");
+function Ge(r) {
+  return Object.entries(r).map(([t, e]) => `${Je(t)}:${e}`).join(";");
 }
-function hyphenate(str) {
-  return str.replace(/[A-Z]/g, (match) => "-" + match.toLowerCase());
+function Je(r) {
+  return r.replace(/[A-Z]/g, (t) => "-" + t.toLowerCase());
 }
-class DatabaseConnector {
+class Qe {
   // Renamed from isConnected to _connected
-  constructor(options) {
-    this.connection = null;
-    this._connected = false;
-    this.options = {
+  constructor(t) {
+    this.connection = null, this._connected = !1, this.options = {
       retryAttempts: 3,
       retryDelay: 1e3,
       connectionTimeout: 1e4,
-      autoIndex: true,
-      ...options
+      autoIndex: !0,
+      ...t
     };
   }
   /**
@@ -601,56 +516,38 @@ class DatabaseConnector {
    */
   async connect() {
     try {
-      if (this._connected && this.connection) {
+      if (this._connected && this.connection)
         return this.connection;
-      }
-      mongoose.set("strictQuery", true);
-      let attempts = 0;
-      while (attempts < (this.options.retryAttempts || 3)) {
+      $.set("strictQuery", !0);
+      let t = 0;
+      for (; t < (this.options.retryAttempts || 3); )
         try {
-          await mongoose.connect(this.options.uri, {
+          await $.connect(this.options.uri, {
             dbName: this.options.name,
             connectTimeoutMS: this.options.connectionTimeout,
             autoIndex: this.options.autoIndex,
             ...this.options.options
           });
           break;
-        } catch (error) {
-          attempts++;
-          if (attempts >= (this.options.retryAttempts || 3)) {
-            throw error;
-          }
-          console.log(`Connection attempt ${attempts} failed. Retrying in ${this.options.retryDelay}ms...`);
-          await new Promise((resolve) => setTimeout(resolve, this.options.retryDelay));
+        } catch (e) {
+          if (t++, t >= (this.options.retryAttempts || 3))
+            throw e;
+          console.log(`Connection attempt ${t} failed. Retrying in ${this.options.retryDelay}ms...`), await new Promise((s) => setTimeout(s, this.options.retryDelay));
         }
-      }
-      this.connection = mongoose.connection;
-      this._connected = true;
-      console.log(`Connected to MongoDB at ${this.options.uri}/${this.options.name}`);
-      this.connection.on("error", (err) => {
-        console.error("MongoDB connection error:", err);
-        this._connected = false;
-      });
-      this.connection.on("disconnected", () => {
-        console.log("MongoDB disconnected");
-        this._connected = false;
-      });
-      return this.connection;
-    } catch (error) {
-      console.error("Failed to connect to MongoDB:", error);
-      throw error;
+      return this.connection = $.connection, this._connected = !0, console.log(`Connected to MongoDB at ${this.options.uri}/${this.options.name}`), this.connection.on("error", (e) => {
+        console.error("MongoDB connection error:", e), this._connected = !1;
+      }), this.connection.on("disconnected", () => {
+        console.log("MongoDB disconnected"), this._connected = !1;
+      }), this.connection;
+    } catch (t) {
+      throw console.error("Failed to connect to MongoDB:", t), t;
     }
   }
   /**
    * Disconnect from the database
    */
   async disconnect() {
-    if (this.connection) {
-      await mongoose.disconnect();
-      this._connected = false;
-      this.connection = null;
-      console.log("Disconnected from MongoDB");
-    }
+    this.connection && (await $.disconnect(), this._connected = !1, this.connection = null, console.log("Disconnected from MongoDB"));
   }
   /**
    * Check if connected to the database
@@ -665,165 +562,105 @@ class DatabaseConnector {
     return this.connection;
   }
 }
-function createServer(options = {}) {
-  const app = express();
-  const {
-    port = 3e3,
-    staticDir = "public",
-    enableCors = true,
-    apiPrefix = "/api",
-    ssrEnabled = true,
-    middlewares = [],
-    enableCompression = true,
-    enableHelmet = true,
-    logFormat = "dev",
-    trustProxy = false,
-    showErrorDetails = process.env.NODE_ENV !== "production"
-  } = options;
-  if (trustProxy) {
-    app.set("trust proxy", trustProxy);
-  }
-  app.use(express.json());
-  app.use(express.urlencoded({ extended: true }));
-  if (enableCompression) {
-    app.use(compression());
-  }
-  if (enableHelmet) {
-    app.use(helmet({
-      contentSecurityPolicy: options.disableCSP ? false : void 0
-    }));
-  }
-  if (logFormat) {
-    app.use(morgan(logFormat));
+function Ye(r = {}) {
+  const t = R(), {
+    port: e = 3e3,
+    staticDir: s = "public",
+    enableCors: n = !0,
+    apiPrefix: i = "/api",
+    ssrEnabled: o = !0,
+    middlewares: a = [],
+    enableCompression: c = !0,
+    enableHelmet: d = !0,
+    logFormat: h = "dev",
+    trustProxy: E = !1,
+    showErrorDetails: S = w.env.NODE_ENV !== "production"
+  } = r;
+  if (E && t.set("trust proxy", E), t.use(R.json()), t.use(R.urlencoded({ extended: !0 })), c && t.use(_e()), d && t.use(Ie({
+    contentSecurityPolicy: r.disableCSP ? !1 : void 0
+  })), h && t.use(Re(h)), n && t.use((l, p, f) => {
+    if (p.header("Access-Control-Allow-Origin", "*"), p.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS"), p.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, Authorization"), l.method === "OPTIONS")
+      return p.sendStatus(200);
+    f();
+  }), a.forEach((l) => t.use(l)), s) {
+    const l = de.resolve(w.cwd(), s);
+    Ne.existsSync(l) ? (t.use(R.static(l, {
+      maxAge: r.staticCacheAge || "1d",
+      etag: !0
+    })), console.log(`📂 Serving static files from: ${l}`)) : console.warn(`⚠️ Static directory not found: ${l}`);
   }
-  if (enableCors) {
-    app.use((req, res, next) => {
-      res.header("Access-Control-Allow-Origin", "*");
-      res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
-      res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, Authorization");
-      if (req.method === "OPTIONS") {
-        return res.sendStatus(200);
-      }
-      next();
-    });
-  }
-  middlewares.forEach((middleware) => app.use(middleware));
-  if (staticDir) {
-    const staticPath = path.resolve(process.cwd(), staticDir);
-    if (fs.existsSync(staticPath)) {
-      app.use(express.static(staticPath, {
-        maxAge: options.staticCacheAge || "1d",
-        etag: true
-      }));
-      console.log(`📂 Serving static files from: ${staticPath}`);
-    } else {
-      console.warn(`⚠️ Static directory not found: ${staticPath}`);
-    }
-  }
-  let dbConnector = null;
-  app.connectToDatabase = async (dbOptions) => {
+  let y = null;
+  t.connectToDatabase = async (l) => {
     try {
-      if (dbConnector && dbConnector.isConnected()) {
-        console.log("✅ Using existing database connection");
-        return dbConnector;
-      }
-      dbConnector = new DatabaseConnector(dbOptions);
-      await dbConnector.connect();
-      console.log("✅ Database connected successfully");
-      process.on("SIGTERM", async () => {
-        if (dbConnector && dbConnector.isConnected()) {
-          await dbConnector.disconnect();
-          console.log("Database connection closed");
-        }
-      });
-      return dbConnector;
-    } catch (error) {
-      console.error("❌ Failed to connect to database:", error);
-      throw error;
+      return y && y.isConnected() ? (console.log("✅ Using existing database connection"), y) : (y = new Qe(l), await y.connect(), console.log("✅ Database connected successfully"), w.on("SIGTERM", async () => {
+        y && y.isConnected() && (await y.disconnect(), console.log("Database connection closed"));
+      }), y);
+    } catch (p) {
+      throw console.error("❌ Failed to connect to database:", p), p;
     }
   };
-  const routes = {};
-  const ssrRoutes = {};
-  app.registerApi = (routePath, router, routerOptions = {}) => {
+  const I = {}, J = {};
+  return t.registerApi = (l, p, f = {}) => {
     try {
-      const { prefix = apiPrefix } = routerOptions;
-      const fullPath = path.posix.join(prefix, routePath).replace(/\\/g, "/");
-      app.use(fullPath, router);
-      routes[fullPath] = { router, options: routerOptions };
-      console.log(`🔌 API registered: ${fullPath}`);
-    } catch (error) {
-      console.error(`❌ Failed to register API at ${routePath}:`, error);
+      const { prefix: g = i } = f, T = de.posix.join(g, l).replace(/\\/g, "/");
+      t.use(T, p), I[T] = { router: p, options: f }, console.log(`🔌 API registered: ${T}`);
+    } catch (g) {
+      console.error(`❌ Failed to register API at ${l}:`, g);
     }
-    return app;
-  };
-  app.registerSSR = (routePath, component, options2 = {}) => {
-    if (!ssrEnabled) {
-      console.log(`⚠️ SSR disabled: skipping registration of ${routePath}`);
-      return app;
-    }
-    ssrRoutes[routePath] = { component, options: options2 };
-    app.get(routePath, async (req, res, next) => {
-      try {
-        if (req.query.nossr === "true") {
-          return next();
-        }
-        const props = {
-          req,
-          res,
-          params: req.params,
-          query: req.query,
-          user: req.user,
-          ...options2.props
-        };
-        const html = await renderToString(component(props));
-        res.send(`
+    return t;
+  }, t.registerSSR = (l, p, f = {}) => o ? (J[l] = { component: p, options: f }, t.get(l, async (g, T, Q) => {
+    try {
+      if (g.query.nossr === "true")
+        return Q();
+      const Y = {
+        req: g,
+        res: T,
+        params: g.params,
+        query: g.query,
+        user: g.user,
+        ...f.props
+      }, Ce = await N(p(Y));
+      T.send(`
           <!DOCTYPE html>
-          <html lang="${options2.lang || "en"}">
+          <html lang="${f.lang || "en"}">
             <head>
               <meta charset="UTF-8">
               <meta name="viewport" content="width=device-width, initial-scale=1.0">
-              <title>${options2.title || "Frontend Hamroun App"}</title>
-              ${options2.meta ? options2.meta.map((meta) => `<meta ${Object.entries(meta).map(([k, v]) => `${k}="${v}"`).join(" ")}>`).join("\n              ") : ""}
-              ${options2.head || ""}
-              ${options2.styles ? `<style>${options2.styles}</style>` : ""}
-              ${options2.styleSheets ? options2.styleSheets.map((sheet) => `<link rel="stylesheet" href="${sheet}">`).join("\n              ") : ""}
+              <title>${f.title || "Frontend Hamroun App"}</title>
+              ${f.meta ? f.meta.map((D) => `<meta ${Object.entries(D).map(([$e, je]) => `${$e}="${je}"`).join(" ")}>`).join(`
+              `) : ""}
+              ${f.head || ""}
+              ${f.styles ? `<style>${f.styles}</style>` : ""}
+              ${f.styleSheets ? f.styleSheets.map((D) => `<link rel="stylesheet" href="${D}">`).join(`
+              `) : ""}
             </head>
-            <body ${options2.bodyAttributes || ""}>
-              <div id="${options2.rootId || "root"}">${html}</div>
+            <body ${f.bodyAttributes || ""}>
+              <div id="${f.rootId || "root"}">${Ce}</div>
               <script>
-                window.__INITIAL_DATA__ = ${JSON.stringify(options2.initialData || {})};
+                window.__INITIAL_DATA__ = ${JSON.stringify(f.initialData || {})};
               <\/script>
-              ${options2.scripts ? options2.scripts.map((script) => `<script src="${script}"><\/script>`).join("\n              ") : ""}
+              ${f.scripts ? f.scripts.map((D) => `<script src="${D}"><\/script>`).join(`
+              `) : ""}
             </body>
           </html>
         `);
-      } catch (error) {
-        console.error("SSR Error:", error);
-        if (options2.fallback) {
-          return next();
-        }
-        res.status(500).send("Server rendering error");
-      }
-    });
-    console.log(`🖥️  SSR registered: ${routePath}`);
-    return app;
-  };
-  app.use((err, req, res, next) => {
-    console.error("Server error:", err);
-    const statusCode = err.statusCode || err.status || 500;
-    const isApiRequest = req.path.startsWith(apiPrefix);
-    if (isApiRequest) {
-      res.status(statusCode).json({
-        success: false,
-        error: showErrorDetails ? err.message : "Internal Server Error",
-        stack: showErrorDetails ? err.stack : void 0
-      });
-    } else {
-      res.status(statusCode).send(`
+    } catch (Y) {
+      if (console.error("SSR Error:", Y), f.fallback)
+        return Q();
+      T.status(500).send("Server rendering error");
+    }
+  }), console.log(`🖥️  SSR registered: ${l}`), t) : (console.log(`⚠️ SSR disabled: skipping registration of ${l}`), t), t.use((l, p, f, g) => {
+    console.error("Server error:", l);
+    const T = l.statusCode || l.status || 500;
+    p.path.startsWith(i) ? f.status(T).json({
+      success: !1,
+      error: S ? l.message : "Internal Server Error",
+      stack: S ? l.stack : void 0
+    }) : f.status(T).send(`
         <!DOCTYPE html>
         <html>
           <head>
-            <title>Error - ${statusCode}</title>
+            <title>Error - ${T}</title>
             <style>
               body { font-family: system-ui, sans-serif; padding: 2rem; max-width: 800px; margin: 0 auto; }
               .error { background: #f8d7da; border: 1px solid #f5c6cb; padding: 1rem; border-radius: 4px; }
@@ -831,20 +668,14 @@ function createServer(options = {}) {
             </style>
           </head>
           <body>
-            <h1>Error ${statusCode}</h1>
-            <div class="error">${showErrorDetails ? err.message : "Internal Server Error"}</div>
-            ${showErrorDetails && err.stack ? `<pre class="stack">${err.stack}</pre>` : ""}
+            <h1>Error ${T}</h1>
+            <div class="error">${S ? l.message : "Internal Server Error"}</div>
+            ${S && l.stack ? `<pre class="stack">${l.stack}</pre>` : ""}
           </body>
         </html>
       `);
-    }
-  });
-  app.use((req, res) => {
-    const isApiRequest = req.path.startsWith(apiPrefix);
-    if (isApiRequest) {
-      res.status(404).json({ success: false, error: "Not Found" });
-    } else {
-      res.status(404).send(`
+  }), t.use((l, p) => {
+    l.path.startsWith(i) ? p.status(404).json({ success: !1, error: "Not Found" }) : p.status(404).send(`
         <!DOCTYPE html>
         <html>
           <head>
@@ -860,521 +691,423 @@ function createServer(options = {}) {
           </body>
         </html>
       `);
-    }
-  });
-  app.start = (callback) => {
-    const server = app.listen(port, () => {
+  }), t.start = (l) => {
+    const p = t.listen(e, () => {
       console.log(`
-🚀 Frontend Hamroun server running at http://localhost:${port}
-${Object.keys(routes).length > 0 ? `
+🚀 Frontend Hamroun server running at http://localhost:${e}
+${Object.keys(I).length > 0 ? `
 📡 Registered API Routes:
-${Object.keys(routes).map((route) => `  ${route}`).join("\n")}` : ""}
-${Object.keys(ssrRoutes).length > 0 ? `
+${Object.keys(I).map((g) => `  ${g}`).join(`
+`)}` : ""}
+${Object.keys(J).length > 0 ? `
 🖥️  Registered SSR Routes:
-${Object.keys(ssrRoutes).map((route) => `  ${route}`).join("\n")}` : ""}
-      `);
-      if (callback) callback();
-    });
-    const gracefulShutdown = async (signal) => {
-      console.log(`${signal} signal received: closing HTTP server and cleaning up`);
-      server.close(async () => {
-        console.log("HTTP server closed");
-        if (dbConnector && dbConnector.isConnected()) {
-          await dbConnector.disconnect();
-          console.log("Database connection closed");
-        }
-        process.exit(0);
-      });
-      setTimeout(() => {
-        console.error("Could not close connections in time, forcefully shutting down");
-        process.exit(1);
+${Object.keys(J).map((g) => `  ${g}`).join(`
+`)}` : ""}
+      `), l && l();
+    }), f = async (g) => {
+      console.log(`${g} signal received: closing HTTP server and cleaning up`), p.close(async () => {
+        console.log("HTTP server closed"), y && y.isConnected() && (await y.disconnect(), console.log("Database connection closed")), w.exit(0);
+      }), setTimeout(() => {
+        console.error("Could not close connections in time, forcefully shutting down"), w.exit(1);
       }, 1e4);
     };
-    process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
-    process.on("SIGINT", () => gracefulShutdown("SIGINT"));
-    return server;
-  };
-  return app;
+    return w.on("SIGTERM", () => f("SIGTERM")), w.on("SIGINT", () => f("SIGINT")), p;
+  }, t;
 }
-const defaultErrorHandler = (error, { res }) => {
-  console.error("API Error:", error);
-  const status = error.status || error.statusCode || 500;
-  const message = error.message || "Internal server error";
-  res.status(status).json({
-    success: false,
-    error: message,
-    stack: process.env.NODE_ENV !== "production" ? error.stack : void 0
+const Ae = (r, { res: t }) => {
+  console.error("API Error:", r);
+  const e = r.status || r.statusCode || 500, s = r.message || "Internal server error";
+  t.status(e).json({
+    success: !1,
+    error: s,
+    stack: w.env.NODE_ENV !== "production" ? r.stack : void 0
   });
 };
-function createModelRouter(model, options = {}) {
-  const router = express.Router();
-  const { middleware = [], errorHandler = defaultErrorHandler } = options;
-  middleware.forEach((mw) => router.use(mw));
-  const handleRoute = (handler) => async (req, res, next) => {
+function ut(r, t = {}) {
+  const e = R.Router(), { middleware: s = [], errorHandler: n = Ae } = t;
+  s.forEach((o) => e.use(o));
+  const i = (o) => async (a, c, d) => {
     try {
-      const context = { req, res, next, params: req.params, query: req.query, body: req.body };
-      return await handler(context);
-    } catch (error) {
-      const context = { req, res, next, params: req.params, query: req.query, body: req.body };
-      return errorHandler(error, context);
+      const h = { req: a, res: c, next: d, params: a.params, query: a.query, body: a.body };
+      return await o(h);
+    } catch (h) {
+      const E = { req: a, res: c, next: d, params: a.params, query: a.query, body: a.body };
+      return n(h, E);
     }
   };
-  router.get("/", handleRoute(async ({ req, res }) => {
-    const paginationOptions = req.pagination || { page: 1, limit: 10 };
-    const result = await model.getAll(paginationOptions);
-    res.json({
-      success: true,
-      ...result
+  return e.get("/", i(async ({ req: o, res: a }) => {
+    const c = o.pagination || { page: 1, limit: 10 }, d = await r.getAll(c);
+    a.json({
+      success: !0,
+      ...d
     });
-  }));
-  router.get("/:id", handleRoute(async ({ params, res }) => {
-    const item = await model.getById(params.id);
-    if (!item) {
-      res.status(404).json({
-        success: false,
+  })), e.get("/:id", i(async ({ params: o, res: a }) => {
+    const c = await r.getById(o.id);
+    if (!c) {
+      a.status(404).json({
+        success: !1,
         error: "Item not found"
       });
       return;
     }
-    res.json({
-      success: true,
-      data: item
+    a.json({
+      success: !0,
+      data: c
     });
-  }));
-  router.post("/", handleRoute(async ({ body, res }) => {
-    const newItem = await model.create(body);
-    res.status(201).json({
-      success: true,
-      data: newItem,
+  })), e.post("/", i(async ({ body: o, res: a }) => {
+    const c = await r.create(o);
+    a.status(201).json({
+      success: !0,
+      data: c,
       message: "Item created successfully"
     });
-  }));
-  router.put("/:id", handleRoute(async ({ params, body, res }) => {
-    const updatedItem = await model.update(params.id, body);
-    if (!updatedItem) {
-      res.status(404).json({
-        success: false,
+  })), e.put("/:id", i(async ({ params: o, body: a, res: c }) => {
+    const d = await r.update(o.id, a);
+    if (!d) {
+      c.status(404).json({
+        success: !1,
         error: "Item not found"
       });
       return;
     }
-    res.json({
-      success: true,
-      data: updatedItem,
+    c.json({
+      success: !0,
+      data: d,
       message: "Item updated successfully"
     });
-  }));
-  router.delete("/:id", handleRoute(async ({ params, res }) => {
-    const success = await model.delete(params.id);
-    if (!success) {
-      res.status(404).json({
-        success: false,
+  })), e.delete("/:id", i(async ({ params: o, res: a }) => {
+    if (!await r.delete(o.id)) {
+      a.status(404).json({
+        success: !1,
         error: "Item not found"
       });
       return;
     }
-    res.json({
-      success: true,
+    a.json({
+      success: !0,
       message: "Item deleted successfully"
     });
-  }));
-  return router;
+  })), e;
 }
-function createApiRouter$1(routeConfig, options = {}) {
-  const router = express.Router();
-  const { middleware = [], errorHandler = defaultErrorHandler } = options;
-  middleware.forEach((mw) => router.use(mw));
-  const handleRoute = (handler) => async (req, res, next) => {
+function lt(r, t = {}) {
+  const e = R.Router(), { middleware: s = [], errorHandler: n = Ae } = t;
+  s.forEach((o) => e.use(o));
+  const i = (o) => async (a, c, d) => {
     try {
-      const context = { req, res, next, params: req.params, query: req.query, body: req.body };
-      if (res.headersSent) {
+      const h = { req: a, res: c, next: d, params: a.params, query: a.query, body: a.body };
+      return c.headersSent ? void 0 : await o(h);
+    } catch (h) {
+      if (c.headersSent) {
+        console.error("Error occurred after response was sent:", h);
         return;
       }
-      return await handler(context);
-    } catch (error) {
-      if (res.headersSent) {
-        console.error("Error occurred after response was sent:", error);
-        return;
-      }
-      const context = { req, res, next, params: req.params, query: req.query, body: req.body };
-      return errorHandler(error, context);
+      const E = { req: a, res: c, next: d, params: a.params, query: a.query, body: a.body };
+      return n(h, E);
     }
   };
-  Object.entries(routeConfig).forEach(([path2, config]) => {
-    const { method, handler } = config;
-    router[method](path2, handleRoute(handler));
-  });
-  return router;
+  return Object.entries(r).forEach(([o, a]) => {
+    const { method: c, handler: d } = a;
+    e[c](o, i(d));
+  }), e;
 }
-function apiResponse(success, data, message, error, meta) {
-  const response = { success };
-  if (data !== void 0) response.data = data;
-  if (message) response.message = message;
-  if (error) response.error = error;
-  if (meta) response.meta = meta;
-  return response;
+function xe(r, t, e, s, n) {
+  const i = { success: r };
+  return t !== void 0 && (i.data = t), e && (i.message = e), s && (i.error = s), n && (i.meta = n), i;
 }
-function sendSuccess(res, data, message, statusCode = 200, meta) {
-  res.status(statusCode).json(apiResponse(true, data, message, void 0, meta));
+function P(r, t, e, s = 200, n) {
+  r.status(s).json(xe(!0, t, e, void 0, n));
 }
-function sendError(res, error, statusCode = 400, meta) {
-  const errorMessage = error instanceof Error ? error.message : error;
-  res.status(statusCode).json(apiResponse(false, void 0, void 0, errorMessage, meta));
+function L(r, t, e = 400, s) {
+  const n = t instanceof Error ? t.message : t;
+  r.status(e).json(xe(!1, void 0, void 0, n, s));
 }
-function getPaginationParams(req) {
-  const page = parseInt(req.query.page) || 1;
-  const limit = parseInt(req.query.limit) || 10;
-  const sort = req.query.sort || "createdAt";
-  const order = req.query.order === "asc" ? "asc" : "desc";
-  return { page, limit, sort, order };
+function ze(r) {
+  const t = parseInt(r.query.page) || 1, e = parseInt(r.query.limit) || 10, s = r.query.sort || "createdAt", n = r.query.order === "asc" ? "asc" : "desc";
+  return { page: t, limit: e, sort: s, order: n };
 }
-function paginationMiddleware(req, res, next) {
-  req.pagination = getPaginationParams(req);
-  next();
+function Xe(r, t, e) {
+  r.pagination = ze(r), e();
 }
-function validateRequest(schema) {
-  return (req, res, next) => {
+function dt(r) {
+  return (t, e, s) => {
     try {
-      const { error, value } = schema.validate(req.body);
-      if (error) {
-        sendError(res, `Validation error: ${error.message}`, 400);
+      const { error: n, value: i } = r.validate(t.body);
+      if (n) {
+        L(e, `Validation error: ${n.message}`, 400);
         return;
       }
-      req.body = value;
-      next();
-    } catch (err) {
-      sendError(res, "Validation error", 400);
+      t.body = i, s();
+    } catch {
+      L(e, "Validation error", 400);
     }
   };
 }
-function createApiRouter(options = {}, auth) {
-  const router = Router();
-  if (options.requireAuth && auth) {
-    router.use(auth.authenticate);
-    if (options.requiredRole) {
-      router.use(auth.hasRole(options.requiredRole));
-    }
-  }
-  if (options.rateLimit) {
-    console.warn("Rate limiting is disabled: express-rate-limit dependency is not installed");
-  }
-  return router;
+function Ze(r = {}, t) {
+  const e = ae();
+  return r.requireAuth && t && (e.use(t.authenticate), r.requiredRole && e.use(t.hasRole(r.requiredRole))), r.rateLimit && console.warn("Rate limiting is disabled: express-rate-limit dependency is not installed"), e;
 }
-function asyncHandler(fn) {
-  return (req, res, next) => {
-    fn(req, res, next).catch(next);
+function M(r) {
+  return (t, e, s) => {
+    r(t, e, s).catch(s);
   };
 }
-function createRestEndpoints(model) {
-  const router = Router();
-  router.get("/", paginationMiddleware, asyncHandler(async (req, res) => {
-    const result = await model.getAll(req.pagination);
-    sendSuccess(res, result);
-  }));
-  router.get("/:id", asyncHandler(async (req, res) => {
-    const item = await model.getById(req.params.id);
-    if (!item) {
-      return sendError(res, "Item not found", 404);
-    }
-    sendSuccess(res, item);
-  }));
-  router.post("/", asyncHandler(async (req, res) => {
-    const newItem = await model.create(req.body);
-    sendSuccess(res, newItem, "Item created successfully", 201);
-  }));
-  router.put("/:id", asyncHandler(async (req, res) => {
-    const updatedItem = await model.update(req.params.id, req.body);
-    if (!updatedItem) {
-      return sendError(res, "Item not found", 404);
-    }
-    sendSuccess(res, updatedItem, "Item updated successfully");
-  }));
-  router.delete("/:id", asyncHandler(async (req, res) => {
-    const result = await model.delete(req.params.id);
-    if (!result) {
-      return sendError(res, "Item not found", 404);
-    }
-    sendSuccess(res, null, "Item deleted successfully");
-  }));
-  return router;
+function ft(r) {
+  const t = ae();
+  return t.get("/", Xe, M(async (e, s) => {
+    const n = await r.getAll(e.pagination);
+    P(s, n);
+  })), t.get("/:id", M(async (e, s) => {
+    const n = await r.getById(e.params.id);
+    if (!n)
+      return L(s, "Item not found", 404);
+    P(s, n);
+  })), t.post("/", M(async (e, s) => {
+    const n = await r.create(e.body);
+    P(s, n, "Item created successfully", 201);
+  })), t.put("/:id", M(async (e, s) => {
+    const n = await r.update(e.params.id, e.body);
+    if (!n)
+      return L(s, "Item not found", 404);
+    P(s, n, "Item updated successfully");
+  })), t.delete("/:id", M(async (e, s) => {
+    if (!await r.delete(e.params.id))
+      return L(s, "Item not found", 404);
+    P(s, null, "Item deleted successfully");
+  })), t;
 }
-const crypto = {};
-class Auth {
-  constructor(options) {
-    this.loginAttempts = /* @__PURE__ */ new Map();
-    this.login = async (req, res) => {
+const me = fe.default || fe;
+class Ke {
+  constructor(t) {
+    if (this.loginAttempts = /* @__PURE__ */ new Map(), this.login = async (e, s) => {
       try {
-        const { username, password } = req.body;
-        const ip = req.ip || req.connection.remoteAddress || "";
-        if (!this.checkRateLimit(ip)) {
-          res.status(429).json({
-            success: false,
+        const { username: n, password: i } = e.body, o = e.ip || e.connection.remoteAddress || "";
+        if (!this.checkRateLimit(o)) {
+          s.status(429).json({
+            success: !1,
             message: "Too many login attempts. Please try again later."
           });
           return;
         }
-        if (!username || !password) {
-          res.status(400).json({
-            success: false,
+        if (!n || !i) {
+          s.status(400).json({
+            success: !1,
             message: "Username and password are required"
           });
           return;
         }
         if (!this.options.findUser) {
-          res.status(500).json({
-            success: false,
+          s.status(500).json({
+            success: !1,
             message: "User finder function not configured"
           });
           return;
         }
-        const user = await this.options.findUser(username);
-        if (!user) {
-          res.status(401).json({
-            success: false,
+        const a = await this.options.findUser(n);
+        if (!a) {
+          s.status(401).json({
+            success: !1,
             message: "Invalid credentials"
           });
           return;
         }
-        const isPasswordValid = await this.options.verifyPassword(
-          password,
-          user.password
-        );
-        if (!isPasswordValid) {
-          res.status(401).json({
-            success: false,
+        if (!await this.options.verifyPassword(
+          i,
+          a.password
+        )) {
+          s.status(401).json({
+            success: !1,
             message: "Invalid credentials"
           });
           return;
         }
-        const userWithoutPassword = { ...user };
-        delete userWithoutPassword.password;
-        const tokenPair = this.generateTokenPair({
-          id: user.id || user._id,
-          username: user.username,
-          role: user.role || "user"
+        const d = { ...a };
+        delete d.password;
+        const h = this.generateTokenPair({
+          id: a.id || a._id,
+          username: a.username,
+          role: a.role || "user"
         });
         if (this.options.saveRefreshToken) {
-          const refreshExpiry = /* @__PURE__ */ new Date();
-          refreshExpiry.setSeconds(refreshExpiry.getSeconds() + this.getExpirationSeconds(this.options.refreshExpiration || "7d"));
-          await this.options.saveRefreshToken(
-            user.id || user._id,
-            tokenPair.refreshToken,
-            refreshExpiry
+          const E = /* @__PURE__ */ new Date();
+          E.setSeconds(E.getSeconds() + this.getExpirationSeconds(this.options.refreshExpiration || "7d")), await this.options.saveRefreshToken(
+            a.id || a._id,
+            h.refreshToken,
+            E
           );
         }
-        if (req.body.useCookies) {
-          this.setAuthCookies(res, tokenPair);
-        }
-        res.json({
-          success: true,
+        e.body.useCookies && this.setAuthCookies(s, h), s.json({
+          success: !0,
           message: "Authentication successful",
-          tokens: tokenPair,
-          user: userWithoutPassword
+          tokens: h,
+          user: d
         });
-      } catch (error) {
-        console.error("Authentication error:", error);
-        res.status(500).json({
-          success: false,
+      } catch (n) {
+        console.error("Authentication error:", n), s.status(500).json({
+          success: !1,
           message: "Authentication failed",
-          error: process.env.NODE_ENV !== "production" ? error.message : void 0
+          error: w.env.NODE_ENV !== "production" ? n.message : void 0
         });
       }
-    };
-    this.refreshToken = async (req, res) => {
-      var _a, _b;
+    }, this.refreshToken = async (e, s) => {
+      var n, i;
       try {
-        const refreshToken = ((_a = req.cookies) == null ? void 0 : _a.refreshToken) || req.body.refreshToken;
-        if (!refreshToken) {
-          res.status(401).json({
-            success: false,
+        const o = ((n = e.cookies) == null ? void 0 : n.refreshToken) || e.body.refreshToken;
+        if (!o) {
+          s.status(401).json({
+            success: !1,
             message: "Refresh token required"
           });
           return;
         }
-        const decoded = this.verifyToken(refreshToken, "refresh");
-        if (this.options.verifyRefreshToken) {
-          const isValid = await this.options.verifyRefreshToken(decoded.id, refreshToken);
-          if (!isValid) {
-            this.clearAuthCookies(res);
-            res.status(401).json({
-              success: false,
-              message: "Invalid refresh token"
-            });
-            return;
-          }
+        const a = this.verifyToken(o, "refresh");
+        if (this.options.verifyRefreshToken && !await this.options.verifyRefreshToken(a.id, o)) {
+          this.clearAuthCookies(s), s.status(401).json({
+            success: !1,
+            message: "Invalid refresh token"
+          });
+          return;
         }
-        const tokenPair = this.generateTokenPair({
-          id: decoded.id,
+        const c = this.generateTokenPair({
+          id: a.id,
           // We need to fetch the user data again for complete payload
-          ...this.options.findUser ? await this.options.findUser(decoded.id) : {}
+          ...this.options.findUser ? await this.options.findUser(a.id) : {}
         });
         if (this.options.saveRefreshToken) {
-          const refreshExpiry = /* @__PURE__ */ new Date();
-          refreshExpiry.setSeconds(refreshExpiry.getSeconds() + this.getExpirationSeconds(this.options.refreshExpiration || "7d"));
-          await this.options.saveRefreshToken(
-            decoded.id,
-            tokenPair.refreshToken,
-            refreshExpiry
+          const h = /* @__PURE__ */ new Date();
+          h.setSeconds(h.getSeconds() + this.getExpirationSeconds(this.options.refreshExpiration || "7d")), await this.options.saveRefreshToken(
+            a.id,
+            c.refreshToken,
+            h
           );
         }
-        const useCookies = ((_b = req.cookies) == null ? void 0 : _b.accessToken) || req.body.useCookies;
-        if (useCookies) {
-          this.setAuthCookies(res, tokenPair);
-        }
-        res.json({
-          success: true,
+        (((i = e.cookies) == null ? void 0 : i.accessToken) || e.body.useCookies) && this.setAuthCookies(s, c), s.json({
+          success: !0,
           message: "Token refreshed successfully",
-          tokens: tokenPair
+          tokens: c
         });
-      } catch (error) {
-        this.clearAuthCookies(res);
-        res.status(401).json({
-          success: false,
+      } catch (o) {
+        this.clearAuthCookies(s), s.status(401).json({
+          success: !1,
           message: "Invalid or expired refresh token",
-          error: process.env.NODE_ENV !== "production" ? error.message : void 0
+          error: w.env.NODE_ENV !== "production" ? o.message : void 0
         });
       }
-    };
-    this.logout = async (req, res) => {
-      var _a;
+    }, this.logout = async (e, s) => {
+      var n;
       try {
-        this.clearAuthCookies(res);
-        const refreshToken = ((_a = req.cookies) == null ? void 0 : _a.refreshToken) || req.body.refreshToken;
-        if (refreshToken && this.options.saveRefreshToken) {
+        this.clearAuthCookies(s);
+        const i = ((n = e.cookies) == null ? void 0 : n.refreshToken) || e.body.refreshToken;
+        if (i && this.options.saveRefreshToken)
           try {
-            const decoded = this.verifyToken(refreshToken, "refresh");
-            if (typeof this.options.saveRefreshToken === "function") {
-              await this.options.saveRefreshToken(decoded.id, "", /* @__PURE__ */ new Date());
-            }
-          } catch (e) {
+            const o = this.verifyToken(i, "refresh");
+            typeof this.options.saveRefreshToken == "function" && await this.options.saveRefreshToken(o.id, "", /* @__PURE__ */ new Date());
+          } catch {
           }
-        }
-        res.json({ success: true, message: "Logged out successfully" });
-      } catch (error) {
-        console.error("Logout error:", error);
-        res.status(500).json({ success: false, message: "Logout failed", error: error.message });
+        s.json({ success: !0, message: "Logged out successfully" });
+      } catch (i) {
+        console.error("Logout error:", i), s.status(500).json({ success: !1, message: "Logout failed", error: i.message });
       }
-    };
-    this.authenticate = (req, res, next) => {
-      var _a;
+    }, this.authenticate = (e, s, n) => {
+      var i;
       try {
-        let token = (_a = req.cookies) == null ? void 0 : _a.accessToken;
-        if (!token) {
-          const authHeader = req.headers.authorization;
-          if (authHeader && authHeader.startsWith("Bearer ")) {
-            token = authHeader.split(" ")[1];
-          }
+        let o = (i = e.cookies) == null ? void 0 : i.accessToken;
+        if (!o) {
+          const c = e.headers.authorization;
+          c && c.startsWith("Bearer ") && (o = c.split(" ")[1]);
         }
-        if (!token) {
-          res.status(401).json({
-            success: false,
+        if (!o) {
+          s.status(401).json({
+            success: !1,
             message: "Authentication required"
           });
           return;
         }
-        const decoded = this.verifyToken(token, "access");
-        req.user = decoded;
-        next();
-      } catch (error) {
-        res.status(401).json({
-          success: false,
+        const a = this.verifyToken(o, "access");
+        e.user = a, n();
+      } catch (o) {
+        s.status(401).json({
+          success: !1,
           message: "Invalid or expired token",
-          error: process.env.NODE_ENV !== "production" ? error.message : void 0
+          error: w.env.NODE_ENV !== "production" ? o.message : void 0
         });
       }
-    };
-    this.hasRole = (role) => {
-      return (req, res, next) => {
-        const user = req.user;
-        if (!user) {
-          res.status(401).json({
-            success: false,
-            message: "Authentication required"
-          });
-          return;
-        }
-        const roles = Array.isArray(role) ? role : [role];
-        if (roles.includes(user.role)) {
-          next();
-        } else {
-          res.status(403).json({
-            success: false,
-            message: "Insufficient permissions"
-          });
-        }
-      };
-    };
-    this.options = {
+    }, this.hasRole = (e) => (s, n, i) => {
+      const o = s.user;
+      if (!o) {
+        n.status(401).json({
+          success: !1,
+          message: "Authentication required"
+        });
+        return;
+      }
+      (Array.isArray(e) ? e : [e]).includes(o.role) ? i() : n.status(403).json({
+        success: !1,
+        message: "Insufficient permissions"
+      });
+    }, this.options = {
       tokenExpiration: "15m",
       refreshExpiration: "7d",
       saltRounds: 10,
-      secureCookies: process.env.NODE_ENV === "production",
-      httpOnlyCookies: true,
-      rateLimit: true,
-      ...options,
-      refreshSecret: options.refreshSecret || options.jwtSecret
-    };
-    if (!options.jwtSecret) {
+      secureCookies: w.env.NODE_ENV === "production",
+      httpOnlyCookies: !0,
+      rateLimit: !0,
+      ...t,
+      refreshSecret: t.refreshSecret || t.jwtSecret
+    }, !t.jwtSecret)
       throw new Error("JWT secret is required for authentication");
-    }
-    if (!this.options.verifyPassword) {
-      this.options.verifyPassword = this.verifyPasswordWithBcrypt;
-    }
+    this.options.verifyPassword || (this.options.verifyPassword = this.verifyPasswordWithBcrypt);
   }
   /**
    * Hash a password using bcrypt
    */
-  async hashPassword(password) {
-    return await bcrypt.hash(password, this.options.saltRounds || 10);
+  async hashPassword(t) {
+    return await me.hash(t, this.options.saltRounds || 10);
   }
   /**
    * Verify a password against a hash using bcrypt
    */
-  async verifyPasswordWithBcrypt(password, hashedPassword) {
-    return await bcrypt.compare(password, hashedPassword);
+  async verifyPasswordWithBcrypt(t, e) {
+    return await me.compare(t, e);
   }
   /**
    * Generate a cryptographically secure random token
    */
-  generateSecureToken(length = 32) {
-    return crypto.randomBytes(length).toString("hex");
+  generateSecureToken(t = 32) {
+    return Oe.randomBytes(t).toString("hex");
   }
   /**
    * Generate token pair (access token + refresh token)
    */
-  generateTokenPair(payload) {
-    const expiresIn = this.getExpirationSeconds(this.options.tokenExpiration || "15m");
-    const accessToken = jwt.sign(
-      { ...payload, type: "access" },
+  generateTokenPair(t) {
+    const e = this.getExpirationSeconds(this.options.tokenExpiration || "15m"), s = z.sign(
+      { ...t, type: "access" },
       this.options.jwtSecret,
       { expiresIn: this.options.tokenExpiration }
-    );
-    const refreshToken = jwt.sign(
-      { id: payload.id, type: "refresh" },
+    ), n = z.sign(
+      { id: t.id, type: "refresh" },
       this.options.refreshSecret,
       { expiresIn: this.options.refreshExpiration }
     );
     return {
-      accessToken,
-      refreshToken,
-      expiresIn
+      accessToken: s,
+      refreshToken: n,
+      expiresIn: e
     };
   }
   /**
    * Convert JWT expiration time to seconds
    */
-  getExpirationSeconds(expiration) {
-    const unit = expiration.charAt(expiration.length - 1);
-    const value = parseInt(expiration.slice(0, -1));
-    switch (unit) {
+  getExpirationSeconds(t) {
+    const e = t.charAt(t.length - 1), s = parseInt(t.slice(0, -1));
+    switch (e) {
       case "s":
-        return value;
+        return s;
       case "m":
-        return value * 60;
+        return s * 60;
       case "h":
-        return value * 60 * 60;
+        return s * 60 * 60;
       case "d":
-        return value * 60 * 60 * 24;
+        return s * 60 * 60 * 24;
       default:
         return 3600;
     }
@@ -1382,37 +1115,35 @@ class Auth {
   /**
    * Verify a JWT token
    */
-  verifyToken(token, type = "access") {
+  verifyToken(t, e = "access") {
     try {
-      const secret = type === "access" ? this.options.jwtSecret : this.options.refreshSecret;
-      const decoded = jwt.verify(token, secret);
-      if (typeof decoded === "object" && decoded.type !== type) {
+      const s = e === "access" ? this.options.jwtSecret : this.options.refreshSecret, n = z.verify(t, s);
+      if (typeof n == "object" && n.type !== e)
         throw new Error("Invalid token type");
-      }
-      return decoded;
-    } catch (error) {
+      return n;
+    } catch {
       throw new Error("Invalid or expired token");
     }
   }
   /**
    * Set authentication cookies
    */
-  setAuthCookies(res, tokens) {
-    res.cookie("accessToken", tokens.accessToken, {
+  setAuthCookies(t, e) {
+    t.cookie("accessToken", e.accessToken, {
       httpOnly: this.options.httpOnlyCookies,
       secure: this.options.secureCookies,
       domain: this.options.cookieDomain,
       sameSite: "strict",
-      maxAge: tokens.expiresIn * 1e3
+      maxAge: e.expiresIn * 1e3
     });
-    const refreshExpiresIn = this.getExpirationSeconds(this.options.refreshExpiration || "7d");
-    res.cookie("refreshToken", tokens.refreshToken, {
-      httpOnly: true,
+    const s = this.getExpirationSeconds(this.options.refreshExpiration || "7d");
+    t.cookie("refreshToken", e.refreshToken, {
+      httpOnly: !0,
       // Always HTTP only for refresh tokens
       secure: this.options.secureCookies,
       domain: this.options.cookieDomain,
       sameSite: "strict",
-      maxAge: refreshExpiresIn * 1e3,
+      maxAge: s * 1e3,
       path: "/api/auth/refresh"
       // Restrict to refresh endpoint
     });
@@ -1420,169 +1151,123 @@ class Auth {
   /**
    * Clear authentication cookies
    */
-  clearAuthCookies(res) {
-    res.clearCookie("accessToken");
-    res.clearCookie("refreshToken", { path: "/api/auth/refresh" });
+  clearAuthCookies(t) {
+    t.clearCookie("accessToken"), t.clearCookie("refreshToken", { path: "/api/auth/refresh" });
   }
   /**
    * Check and handle rate limiting
    */
-  checkRateLimit(ip) {
-    if (!this.options.rateLimit) {
-      return true;
-    }
-    const now = Date.now();
-    const attempt = this.loginAttempts.get(ip);
-    if (!attempt) {
-      this.loginAttempts.set(ip, { count: 1, resetTime: now + 36e5 });
-      return true;
-    }
-    if (now > attempt.resetTime) {
-      this.loginAttempts.set(ip, { count: 1, resetTime: now + 36e5 });
-      return true;
-    }
-    if (attempt.count >= 5) {
-      return false;
-    }
-    attempt.count++;
-    this.loginAttempts.set(ip, attempt);
-    return true;
+  checkRateLimit(t) {
+    if (!this.options.rateLimit)
+      return !0;
+    const e = Date.now(), s = this.loginAttempts.get(t);
+    return s ? e > s.resetTime ? (this.loginAttempts.set(t, { count: 1, resetTime: e + 36e5 }), !0) : s.count >= 5 ? !1 : (s.count++, this.loginAttempts.set(t, s), !0) : (this.loginAttempts.set(t, { count: 1, resetTime: e + 36e5 }), !0);
   }
 }
-function createAuth(options) {
-  return new Auth(options);
+function ht(r) {
+  return new Ke(r);
 }
-function createModel(name, schema) {
-  const mongooseModel = mongoose.model(name, schema);
+function pt(r, t) {
+  const e = $.model(r, t);
   return {
-    getAll: async (options) => {
+    getAll: async (s) => {
       try {
-        const { page = 1, limit = 10, sort = "_id", order = "desc" } = options || {};
-        const skip = (page - 1) * limit;
-        const sortOrder = order === "asc" ? 1 : -1;
-        const sortOptions = { [sort]: sortOrder };
-        const [results, total] = await Promise.all([
-          mongooseModel.find().sort(sortOptions).skip(skip).limit(limit).exec(),
-          mongooseModel.countDocuments().exec()
-        ]);
-        const totalPages = Math.ceil(total / limit);
+        const { page: n = 1, limit: i = 10, sort: o = "_id", order: a = "desc" } = s || {}, c = (n - 1) * i, d = a === "asc" ? 1 : -1, h = { [o]: d }, [E, S] = await Promise.all([
+          e.find().sort(h).skip(c).limit(i).exec(),
+          e.countDocuments().exec()
+        ]), y = Math.ceil(S / i);
         return {
-          data: results,
+          data: E,
           pagination: {
-            total,
-            totalPages,
-            currentPage: page,
-            limit,
-            hasNextPage: page < totalPages,
-            hasPrevPage: page > 1
+            total: S,
+            totalPages: y,
+            currentPage: n,
+            limit: i,
+            hasNextPage: n < y,
+            hasPrevPage: n > 1
           }
         };
-      } catch (error) {
-        console.error(`Error in ${name}.getAll:`, error);
-        throw new Error(`Failed to retrieve ${name} records: ${error.message}`);
+      } catch (n) {
+        throw console.error(`Error in ${r}.getAll:`, n), new Error(`Failed to retrieve ${r} records: ${n.message}`);
       }
     },
-    getById: async (id) => {
+    getById: async (s) => {
       try {
-        if (!mongoose.isValidObjectId(id)) {
-          return null;
-        }
-        return await mongooseModel.findById(id).exec();
-      } catch (error) {
-        console.error(`Error in ${name}.getById:`, error);
-        throw new Error(`Failed to retrieve ${name} by ID: ${error.message}`);
+        return $.isValidObjectId(s) ? await e.findById(s).exec() : null;
+      } catch (n) {
+        throw console.error(`Error in ${r}.getById:`, n), new Error(`Failed to retrieve ${r} by ID: ${n.message}`);
       }
     },
-    create: async (data) => {
+    create: async (s) => {
       try {
-        const newDocument = new mongooseModel(data);
-        return await newDocument.save();
-      } catch (error) {
-        console.error(`Error in ${name}.create:`, error);
-        throw new Error(`Failed to create ${name}: ${error.message}`);
+        return await new e(s).save();
+      } catch (n) {
+        throw console.error(`Error in ${r}.create:`, n), new Error(`Failed to create ${r}: ${n.message}`);
       }
     },
-    createMany: async (data) => {
+    createMany: async (s) => {
       try {
-        return await mongooseModel.insertMany(data);
-      } catch (error) {
-        console.error(`Error in ${name}.createMany:`, error);
-        throw new Error(`Failed to create multiple ${name} records: ${error.message}`);
+        return await e.insertMany(s);
+      } catch (n) {
+        throw console.error(`Error in ${r}.createMany:`, n), new Error(`Failed to create multiple ${r} records: ${n.message}`);
       }
     },
-    update: async (id, data) => {
+    update: async (s, n) => {
       try {
-        if (!mongoose.isValidObjectId(id)) {
-          return null;
-        }
-        return await mongooseModel.findByIdAndUpdate(
-          id,
-          { $set: data },
-          { new: true, runValidators: true }
-        ).exec();
-      } catch (error) {
-        console.error(`Error in ${name}.update:`, error);
-        throw new Error(`Failed to update ${name}: ${error.message}`);
+        return $.isValidObjectId(s) ? await e.findByIdAndUpdate(
+          s,
+          { $set: n },
+          { new: !0, runValidators: !0 }
+        ).exec() : null;
+      } catch (i) {
+        throw console.error(`Error in ${r}.update:`, i), new Error(`Failed to update ${r}: ${i.message}`);
       }
     },
-    delete: async (id) => {
+    delete: async (s) => {
       try {
-        if (!mongoose.isValidObjectId(id)) {
-          return false;
-        }
-        const result = await mongooseModel.findByIdAndDelete(id).exec();
-        return result !== null;
-      } catch (error) {
-        console.error(`Error in ${name}.delete:`, error);
-        throw new Error(`Failed to delete ${name}: ${error.message}`);
+        return $.isValidObjectId(s) ? await e.findByIdAndDelete(s).exec() !== null : !1;
+      } catch (n) {
+        throw console.error(`Error in ${r}.delete:`, n), new Error(`Failed to delete ${r}: ${n.message}`);
       }
     },
-    find: async (query, options) => {
+    find: async (s, n) => {
       try {
-        const { page = 1, limit = 10, sort = "_id", order = "desc" } = options || {};
-        const skip = (page - 1) * limit;
-        const sortOrder = order === "asc" ? 1 : -1;
-        const sortOptions = { [sort]: sortOrder };
-        const [results, total] = await Promise.all([
-          mongooseModel.find(query).sort(sortOptions).skip(skip).limit(limit).exec(),
-          mongooseModel.countDocuments(query).exec()
-        ]);
-        const totalPages = Math.ceil(total / limit);
+        const { page: i = 1, limit: o = 10, sort: a = "_id", order: c = "desc" } = n || {}, d = (i - 1) * o, h = c === "asc" ? 1 : -1, E = { [a]: h }, [S, y] = await Promise.all([
+          e.find(s).sort(E).skip(d).limit(o).exec(),
+          e.countDocuments(s).exec()
+        ]), I = Math.ceil(y / o);
         return {
-          data: results,
+          data: S,
           pagination: {
-            total,
-            totalPages,
-            currentPage: page,
-            limit,
-            hasNextPage: page < totalPages,
-            hasPrevPage: page > 1
+            total: y,
+            totalPages: I,
+            currentPage: i,
+            limit: o,
+            hasNextPage: i < I,
+            hasPrevPage: i > 1
           }
         };
-      } catch (error) {
-        console.error(`Error in ${name}.find:`, error);
-        throw new Error(`Failed to find ${name} records: ${error.message}`);
+      } catch (i) {
+        throw console.error(`Error in ${r}.find:`, i), new Error(`Failed to find ${r} records: ${i.message}`);
       }
     },
-    count: async (query) => {
+    count: async (s) => {
       try {
-        return await mongooseModel.countDocuments(query || {}).exec();
-      } catch (error) {
-        console.error(`Error in ${name}.count:`, error);
-        throw new Error(`Failed to count ${name} records: ${error.message}`);
+        return await e.countDocuments(s || {}).exec();
+      } catch (n) {
+        throw console.error(`Error in ${r}.count:`, n), new Error(`Failed to count ${r} records: ${n.message}`);
       }
     },
-    findOne: async (query) => {
+    findOne: async (s) => {
       try {
-        return await mongooseModel.findOne(query).exec();
-      } catch (error) {
-        console.error(`Error in ${name}.findOne:`, error);
-        throw new Error(`Failed to find ${name} record: ${error.message}`);
+        return await e.findOne(s).exec();
+      } catch (n) {
+        throw console.error(`Error in ${r}.findOne:`, n), new Error(`Failed to find ${r} record: ${n.message}`);
       }
     }
   };
 }
-const FieldTypes = {
+const mt = {
   String: { type: String },
   Number: { type: Number },
   Boolean: { type: Boolean },
@@ -1590,75 +1275,73 @@ const FieldTypes = {
   ObjectId: { type: String },
   // Fallback to String instead of using Schema.Types.ObjectId
   // Helper functions for common field patterns
-  Required: (fieldType) => ({ ...fieldType, required: true }),
-  Unique: (fieldType) => ({ ...fieldType, unique: true }),
-  Ref: (model) => ({
+  Required: (r) => ({ ...r, required: !0 }),
+  Unique: (r) => ({ ...r, unique: !0 }),
+  Ref: (r) => ({
     type: String,
     // Fallback to String type for tests
-    ref: model
+    ref: r
   }),
-  Enum: (values) => ({ type: String, enum: values }),
-  Default: (fieldType, defaultValue) => ({ ...fieldType, default: defaultValue }),
+  Enum: (r) => ({ type: String, enum: r }),
+  Default: (r, t) => ({ ...r, default: t }),
   // Array field type
-  Array: (fieldType) => ({ type: [fieldType] })
-};
-const index = {
+  Array: (r) => ({ type: [r] })
+}, yt = {
   // Frontend
-  jsx,
-  jsxs,
-  createElement: createElement$1,
-  Fragment,
-  Component,
-  useState,
-  useEffect,
-  useRef,
-  useMemo,
-  useErrorBoundary,
-  render,
-  hydrate,
-  renderToString,
-  prepareRender,
-  finishRender,
-  batchUpdates,
+  jsx: ce,
+  jsxs: be,
+  createElement: se,
+  Fragment: Te,
+  Component: Be,
+  useState: Se,
+  useEffect: He,
+  useRef: We,
+  useMemo: Ve,
+  useErrorBoundary: Ue,
+  render: le,
+  hydrate: qe,
+  renderToString: N,
+  prepareRender: U,
+  finishRender: q,
+  batchUpdates: ue,
   // Backend
-  createServer,
-  Router,
-  createApiRouter
+  createServer: Ye,
+  Router: ae,
+  createApiRouter: Ze
 };
 export {
-  Component,
-  DatabaseConnector,
-  FieldTypes,
-  Fragment,
-  Router2 as Router,
-  apiResponse,
-  asyncHandler,
-  batchUpdates,
-  createApiRouter,
-  createAuth,
-  createApiRouter$1 as createCustomRouter,
-  createElement$1 as createElement,
-  createModel,
-  createModelRouter,
-  createRestEndpoints,
-  createServer,
-  index as default,
-  finishRender,
-  getPaginationParams,
-  hydrate,
-  jsx,
-  jsxs,
-  paginationMiddleware,
-  prepareRender,
-  render,
-  renderToString,
-  sendError,
-  sendSuccess,
-  useEffect,
-  useErrorBoundary,
-  useMemo,
-  useRef,
-  useState,
-  validateRequest
+  Be as Component,
+  Qe as DatabaseConnector,
+  mt as FieldTypes,
+  Te as Fragment,
+  Et as Router,
+  xe as apiResponse,
+  M as asyncHandler,
+  ue as batchUpdates,
+  Ze as createApiRouter,
+  ht as createAuth,
+  lt as createCustomRouter,
+  se as createElement,
+  pt as createModel,
+  ut as createModelRouter,
+  ft as createRestEndpoints,
+  Ye as createServer,
+  yt as default,
+  q as finishRender,
+  ze as getPaginationParams,
+  qe as hydrate,
+  ce as jsx,
+  be as jsxs,
+  Xe as paginationMiddleware,
+  U as prepareRender,
+  le as render,
+  N as renderToString,
+  L as sendError,
+  P as sendSuccess,
+  He as useEffect,
+  Ue as useErrorBoundary,
+  Ve as useMemo,
+  We as useRef,
+  Se as useState,
+  dt as validateRequest
 };
-//# sourceMappingURL=frontend-hamroun.es.js.map