elit 3.1.7 → 3.1.8

package/dist/database.mjs

@@ -1,68 +1,19 @@
 import {createRequire as __createRequire} from 'module';const require = __createRequire(import.meta.url);
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-
-// src/runtime.ts
-var runtime, isNode, isBun, isDeno;
-var init_runtime = __esm({
-  "src/runtime.ts"() {
-    "use strict";
-    runtime = (() => {
-      if (typeof Deno !== "undefined") return "deno";
-      if (typeof Bun !== "undefined") return "bun";
-      return "node";
-    })();
-    isNode = runtime === "node";
-    isBun = runtime === "bun";
-    isDeno = runtime === "deno";
-  }
-});
-
-// src/http.ts
-import { EventEmitter } from "events";
-var http, https;
-var init_http = __esm({
-  "src/http.ts"() {
-    "use strict";
-    init_runtime();
-    if (isNode && typeof process !== "undefined") {
-      try {
-        http = __require("http");
-        https = __require("https");
-      } catch (e) {
-        http = __require("http");
-        https = __require("https");
-      }
-    }
-  }
-});
-
-// src/fs.ts
-var fs, fsPromises;
-var init_fs = __esm({
-  "src/fs.ts"() {
-    "use strict";
-    init_runtime();
-    if (isNode) {
-      fs = __require("fs");
-      fsPromises = __require("fs/promises");
-    }
-  }
-});
 
 // src/database.ts
 import vm from "vm";
 
+// src/runtime.ts
+var runtime = (() => {
+  if (typeof Deno !== "undefined") return "deno";
+  if (typeof Bun !== "undefined") return "bun";
+  return "node";
+})();
+var isNode = runtime === "node";
+var isBun = runtime === "bun";
+var isDeno = runtime === "deno";
+
 // src/path.ts
-init_runtime();
 function getSeparator(isWin) {
   return isWin ? "\\" : "/";
 }
@@ -280,766 +231,7 @@ function resolve(...paths) {
 
 // src/database.ts
 import path from "path";
-import fs2 from "fs";
-
-// src/server.ts
-init_http();
-
-// src/https.ts
-init_runtime();
-import { EventEmitter as EventEmitter2 } from "events";
-
-// src/ws.ts
-init_runtime();
-import { EventEmitter as EventEmitter3 } from "events";
-
-// src/chokidar.ts
-init_runtime();
-import { EventEmitter as EventEmitter4 } from "events";
-
-// src/server.ts
-init_fs();
-
-// src/mime-types.ts
-init_runtime();
-var MIME_TYPES = {
-  // Text
-  "txt": "text/plain",
-  "html": "text/html",
-  "htm": "text/html",
-  "css": "text/css",
-  "js": "text/javascript",
-  "mjs": "text/javascript",
-  "json": "application/json",
-  "xml": "application/xml",
-  "csv": "text/csv",
-  "md": "text/markdown",
-  "markdown": "text/x-markdown",
-  // Images
-  "png": "image/png",
-  "jpg": "image/jpeg",
-  "jpeg": "image/jpeg",
-  "gif": "image/gif",
-  "svg": "image/svg+xml",
-  "webp": "image/webp",
-  "ico": "image/x-icon",
-  "bmp": "image/bmp",
-  "tiff": "image/tiff",
-  "tif": "image/tiff",
-  // Audio
-  "mp3": "audio/mpeg",
-  "wav": "audio/wav",
-  "ogg": "audio/ogg",
-  "aac": "audio/aac",
-  "m4a": "audio/mp4",
-  "flac": "audio/flac",
-  // Video
-  "mp4": "video/mp4",
-  "webm": "video/webm",
-  "avi": "video/x-msvideo",
-  "mov": "video/quicktime",
-  "mkv": "video/x-matroska",
-  "flv": "video/x-flv",
-  // Application
-  "pdf": "application/pdf",
-  "zip": "application/zip",
-  "gz": "application/gzip",
-  "tar": "application/x-tar",
-  "rar": "application/x-rar-compressed",
-  "7z": "application/x-7z-compressed",
-  // Documents
-  "doc": "application/msword",
-  "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-  "xls": "application/vnd.ms-excel",
-  "xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-  "ppt": "application/vnd.ms-powerpoint",
-  "pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-  // Fonts
-  "woff": "font/woff",
-  "woff2": "font/woff2",
-  "ttf": "font/ttf",
-  "otf": "font/otf",
-  "eot": "application/vnd.ms-fontobject",
-  // Web
-  "wasm": "application/wasm",
-  "manifest": "application/manifest+json",
-  // Binary
-  "bin": "application/octet-stream",
-  "exe": "application/x-msdownload",
-  "dll": "application/x-msdownload",
-  // TypeScript/Modern JS
-  "ts": "text/typescript",
-  "tsx": "text/tsx",
-  "jsx": "text/jsx"
-};
-var TYPE_TO_EXTENSIONS = {};
-for (const ext in MIME_TYPES) {
-  const type = MIME_TYPES[ext];
-  if (!TYPE_TO_EXTENSIONS[type]) {
-    TYPE_TO_EXTENSIONS[type] = [];
-  }
-  TYPE_TO_EXTENSIONS[type].push(ext);
-}
-
-// src/server.ts
-init_runtime();
-
-// src/dom.ts
-function resolveElement(rootElement) {
-  return typeof rootElement === "string" ? document.getElementById(rootElement.replace("#", "")) : rootElement;
-}
-function ensureElement(el, rootElement) {
-  if (!el) {
-    throw new Error(`Element not found: ${rootElement}`);
-  }
-  return el;
-}
-function shouldSkipChild(child) {
-  return child == null || child === false;
-}
-function isPrimitiveJson(json) {
-  return json == null || typeof json === "boolean" || typeof json === "string" || typeof json === "number";
-}
-var DomNode = class {
-  constructor() {
-    this.elementCache = /* @__PURE__ */ new WeakMap();
-    this.reactiveNodes = /* @__PURE__ */ new Map();
-  }
-  createElement(tagName, props = {}, children = []) {
-    return { tagName, props, children };
-  }
-  renderToDOM(vNode, parent) {
-    if (vNode == null || vNode === false) return;
-    if (typeof vNode !== "object") {
-      parent.appendChild(document.createTextNode(String(vNode)));
-      return;
-    }
-    const { tagName, props, children } = vNode;
-    const isSVG = tagName === "svg" || tagName[0] === "s" && tagName[1] === "v" && tagName[2] === "g" || parent.namespaceURI === "http://www.w3.org/2000/svg";
-    const el = isSVG ? document.createElementNS("http://www.w3.org/2000/svg", tagName.replace("svg", "").toLowerCase() || tagName) : document.createElement(tagName);
-    for (const key in props) {
-      const value = props[key];
-      if (value == null || value === false) continue;
-      const c = key.charCodeAt(0);
-      if (c === 99 && (key.length < 6 || key[5] === "N")) {
-        const classValue = Array.isArray(value) ? value.join(" ") : value;
-        isSVG ? el.setAttribute("class", classValue) : el.className = classValue;
-      } else if (c === 115 && key.length === 5) {
-        if (typeof value === "string") {
-          el.style.cssText = value;
-        } else {
-          const s = el.style;
-          for (const k in value) s[k] = value[k];
-        }
-      } else if (c === 111 && key.charCodeAt(1) === 110) {
-        el[key.toLowerCase()] = value;
-      } else if (c === 100 && key.length > 20) {
-        el.innerHTML = value.__html;
-      } else if (c === 114 && key.length === 3) {
-        setTimeout(() => {
-          typeof value === "function" ? value(el) : value.current = el;
-        }, 0);
-      } else {
-        el.setAttribute(key, value === true ? "" : String(value));
-      }
-    }
-    const len = children.length;
-    if (!len) {
-      parent.appendChild(el);
-      return;
-    }
-    const renderChildren = (target) => {
-      for (let i = 0; i < len; i++) {
-        const child = children[i];
-        if (shouldSkipChild(child)) continue;
-        if (Array.isArray(child)) {
-          for (let j = 0, cLen = child.length; j < cLen; j++) {
-            const c = child[j];
-            !shouldSkipChild(c) && this.renderToDOM(c, target);
-          }
-        } else {
-          this.renderToDOM(child, target);
-        }
-      }
-    };
-    if (len > 30) {
-      const fragment = document.createDocumentFragment();
-      renderChildren(fragment);
-      el.appendChild(fragment);
-    } else {
-      renderChildren(el);
-    }
-    parent.appendChild(el);
-  }
-  render(rootElement, vNode) {
-    const el = ensureElement(resolveElement(rootElement), rootElement);
-    el.innerHTML = "";
-    if (vNode.children && vNode.children.length > 500) {
-      const fragment = document.createDocumentFragment();
-      this.renderToDOM(vNode, fragment);
-      el.appendChild(fragment);
-    } else {
-      this.renderToDOM(vNode, el);
-    }
-    return el;
-  }
-  batchRender(rootElement, vNodes) {
-    const el = ensureElement(resolveElement(rootElement), rootElement);
-    const len = vNodes.length;
-    if (len > 3e3) {
-      const fragment = document.createDocumentFragment();
-      let processed = 0;
-      const chunkSize = 1500;
-      const processChunk = () => {
-        const end = Math.min(processed + chunkSize, len);
-        for (let i = processed; i < end; i++) {
-          this.renderToDOM(vNodes[i], fragment);
-        }
-        processed = end;
-        if (processed >= len) {
-          el.appendChild(fragment);
-        } else {
-          requestAnimationFrame(processChunk);
-        }
-      };
-      processChunk();
-    } else {
-      const fragment = document.createDocumentFragment();
-      for (let i = 0; i < len; i++) {
-        this.renderToDOM(vNodes[i], fragment);
-      }
-      el.appendChild(fragment);
-    }
-    return el;
-  }
-  renderChunked(rootElement, vNodes, chunkSize = 5e3, onProgress) {
-    const el = ensureElement(resolveElement(rootElement), rootElement);
-    const len = vNodes.length;
-    let index = 0;
-    const renderChunk = () => {
-      const end = Math.min(index + chunkSize, len);
-      const fragment = document.createDocumentFragment();
-      for (let i = index; i < end; i++) {
-        this.renderToDOM(vNodes[i], fragment);
-      }
-      el.appendChild(fragment);
-      index = end;
-      if (onProgress) onProgress(index, len);
-      if (index < len) {
-        requestAnimationFrame(renderChunk);
-      }
-    };
-    requestAnimationFrame(renderChunk);
-    return el;
-  }
-  renderToHead(...vNodes) {
-    const head = document.head;
-    if (head) {
-      for (const vNode of vNodes.flat()) {
-        vNode && this.renderToDOM(vNode, head);
-      }
-    }
-    return head;
-  }
-  addStyle(cssText) {
-    const el = document.createElement("style");
-    el.textContent = cssText;
-    return document.head.appendChild(el);
-  }
-  addMeta(attrs) {
-    const el = document.createElement("meta");
-    for (const k in attrs) el.setAttribute(k, attrs[k]);
-    return document.head.appendChild(el);
-  }
-  addLink(attrs) {
-    const el = document.createElement("link");
-    for (const k in attrs) el.setAttribute(k, attrs[k]);
-    return document.head.appendChild(el);
-  }
-  setTitle(text) {
-    return document.title = text;
-  }
-  // Reactive State Management
-  createState(initialValue, options = {}) {
-    let value = initialValue;
-    const listeners = /* @__PURE__ */ new Set();
-    let updateTimer = null;
-    const { throttle = 0, deep = false } = options;
-    const notify = () => listeners.forEach((fn) => fn(value));
-    const scheduleUpdate = () => {
-      if (throttle > 0) {
-        if (!updateTimer) {
-          updateTimer = setTimeout(() => {
-            updateTimer = null;
-            notify();
-          }, throttle);
-        }
-      } else {
-        notify();
-      }
-    };
-    return {
-      get value() {
-        return value;
-      },
-      set value(newValue) {
-        const changed = deep ? JSON.stringify(value) !== JSON.stringify(newValue) : value !== newValue;
-        if (changed) {
-          value = newValue;
-          scheduleUpdate();
-        }
-      },
-      subscribe(fn) {
-        listeners.add(fn);
-        return () => listeners.delete(fn);
-      },
-      destroy() {
-        listeners.clear();
-        updateTimer && clearTimeout(updateTimer);
-      }
-    };
-  }
-  computed(states, computeFn) {
-    const values = states.map((s) => s.value);
-    const result = this.createState(computeFn(...values));
-    states.forEach((state, index) => {
-      state.subscribe((newValue) => {
-        values[index] = newValue;
-        result.value = computeFn(...values);
-      });
-    });
-    return result;
-  }
-  effect(stateFn) {
-    stateFn();
-  }
-  // Virtual scrolling helper for large lists
-  createVirtualList(container, items, renderItem, itemHeight = 50, bufferSize = 5) {
-    const viewportHeight = container.clientHeight;
-    const totalHeight = items.length * itemHeight;
-    let scrollTop = 0;
-    const getVisibleRange = () => {
-      const start = Math.max(0, Math.floor(scrollTop / itemHeight) - bufferSize);
-      const end = Math.min(items.length, Math.ceil((scrollTop + viewportHeight) / itemHeight) + bufferSize);
-      return { start, end };
-    };
-    const render2 = () => {
-      const { start, end } = getVisibleRange();
-      const wrapper = document.createElement("div");
-      wrapper.style.cssText = `height:${totalHeight}px;position:relative`;
-      for (let i = start; i < end; i++) {
-        const itemEl = document.createElement("div");
-        itemEl.style.cssText = `position:absolute;top:${i * itemHeight}px;height:${itemHeight}px;width:100%`;
-        this.renderToDOM(renderItem(items[i], i), itemEl);
-        wrapper.appendChild(itemEl);
-      }
-      container.innerHTML = "";
-      container.appendChild(wrapper);
-    };
-    const scrollHandler = () => {
-      scrollTop = container.scrollTop;
-      requestAnimationFrame(render2);
-    };
-    container.addEventListener("scroll", scrollHandler);
-    render2();
-    return {
-      render: render2,
-      destroy: () => {
-        container.removeEventListener("scroll", scrollHandler);
-        container.innerHTML = "";
-      }
-    };
-  }
-  // Lazy load components
-  lazy(loadFn) {
-    let component = null;
-    let loading = false;
-    return async (...args) => {
-      if (!component && !loading) {
-        loading = true;
-        component = await loadFn();
-        loading = false;
-      }
-      return component ? component(...args) : { tagName: "div", props: { class: "loading" }, children: ["Loading..."] };
-    };
-  }
-  // Memory management - cleanup unused elements
-  cleanupUnusedElements(root) {
-    const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
-    const toRemove = [];
-    while (walker.nextNode()) {
-      const node = walker.currentNode;
-      if (node.id && node.id.startsWith("r") && !this.elementCache.has(node)) {
-        toRemove.push(node);
-      }
-    }
-    toRemove.forEach((el) => el.remove());
-    return toRemove.length;
-  }
-  // Server-Side Rendering - convert VNode to HTML string
-  renderToString(vNode, options = {}) {
-    const { pretty = false, indent = 0 } = options;
-    const indentStr = pretty ? "  ".repeat(indent) : "";
-    const newLine = pretty ? "\n" : "";
-    let resolvedVNode = this.resolveStateValue(vNode);
-    resolvedVNode = this.unwrapReactive(resolvedVNode);
-    if (Array.isArray(resolvedVNode)) {
-      return resolvedVNode.map((child) => this.renderToString(child, options)).join("");
-    }
-    if (typeof resolvedVNode !== "object" || resolvedVNode === null) {
-      if (resolvedVNode === null || resolvedVNode === void 0 || resolvedVNode === false) {
-        return "";
-      }
-      return this.escapeHtml(String(resolvedVNode));
-    }
-    const { tagName, props, children } = resolvedVNode;
-    const isSelfClosing = this.isSelfClosingTag(tagName);
-    let html = `${indentStr}<${tagName}`;
-    const attrs = this.propsToAttributes(props);
-    if (attrs) {
-      html += ` ${attrs}`;
-    }
-    if (isSelfClosing) {
-      html += ` />${newLine}`;
-      return html;
-    }
-    html += ">";
-    if (props.dangerouslySetInnerHTML) {
-      html += props.dangerouslySetInnerHTML.__html;
-      html += `</${tagName}>${newLine}`;
-      return html;
-    }
-    if (children && children.length > 0) {
-      const resolvedChildren = children.map((c) => {
-        const resolved = this.resolveStateValue(c);
-        return this.unwrapReactive(resolved);
-      });
-      const hasComplexChildren = resolvedChildren.some(
-        (c) => typeof c === "object" && c !== null && !Array.isArray(c) && "tagName" in c
-      );
-      if (pretty && hasComplexChildren) {
-        html += newLine;
-        for (const child of resolvedChildren) {
-          if (shouldSkipChild(child)) continue;
-          if (Array.isArray(child)) {
-            for (const c of child) {
-              if (!shouldSkipChild(c)) {
-                html += this.renderToString(c, { pretty, indent: indent + 1 });
-              }
-            }
-          } else {
-            html += this.renderToString(child, { pretty, indent: indent + 1 });
-          }
-        }
-        html += indentStr;
-      } else {
-        for (const child of resolvedChildren) {
-          if (shouldSkipChild(child)) continue;
-          if (Array.isArray(child)) {
-            for (const c of child) {
-              if (!shouldSkipChild(c)) {
-                html += this.renderToString(c, { pretty: false, indent: 0 });
-              }
-            }
-          } else {
-            html += this.renderToString(child, { pretty: false, indent: 0 });
-          }
-        }
-      }
-    }
-    html += `</${tagName}>${newLine}`;
-    return html;
-  }
-  resolveStateValue(value) {
-    if (value && typeof value === "object" && "value" in value && "subscribe" in value) {
-      return value.value;
-    }
-    return value;
-  }
-  isReactiveWrapper(vNode) {
-    if (!vNode || typeof vNode !== "object" || !vNode.tagName) {
-      return false;
-    }
-    return vNode.tagName === "span" && vNode.props?.id && typeof vNode.props.id === "string" && vNode.props.id.match(/^r[a-z0-9]{9}$/);
-  }
-  unwrapReactive(vNode) {
-    if (!this.isReactiveWrapper(vNode)) {
-      return vNode;
-    }
-    const children = vNode.children;
-    if (!children || children.length === 0) {
-      return "";
-    }
-    if (children.length === 1) {
-      const child = children[0];
-      if (child && typeof child === "object" && child.tagName === "span") {
-        const props = child.props;
-        const hasNoProps = !props || Object.keys(props).length === 0;
-        const hasSingleStringChild = child.children && child.children.length === 1 && typeof child.children[0] === "string";
-        if (hasNoProps && hasSingleStringChild) {
-          return child.children[0];
-        }
-      }
-      return this.unwrapReactive(child);
-    }
-    return children.map((c) => this.unwrapReactive(c));
-  }
-  escapeHtml(text) {
-    const htmlEscapes = {
-      "&": "&amp;",
-      "<": "&lt;",
-      ">": "&gt;",
-      '"': "&quot;",
-      "'": "&#x27;"
-    };
-    return text.replace(/[&<>"']/g, (char) => htmlEscapes[char]);
-  }
-  isSelfClosingTag(tagName) {
-    const selfClosingTags = /* @__PURE__ */ new Set([
-      "area",
-      "base",
-      "br",
-      "col",
-      "embed",
-      "hr",
-      "img",
-      "input",
-      "link",
-      "meta",
-      "param",
-      "source",
-      "track",
-      "wbr"
-    ]);
-    return selfClosingTags.has(tagName.toLowerCase());
-  }
-  propsToAttributes(props) {
-    const attrs = [];
-    for (const key in props) {
-      if (key === "children" || key === "dangerouslySetInnerHTML" || key === "ref") {
-        continue;
-      }
-      let value = props[key];
-      value = this.resolveStateValue(value);
-      if (value == null || value === false) continue;
-      if (key.startsWith("on") && typeof value === "function") {
-        continue;
-      }
-      if (key === "className" || key === "class") {
-        const className = Array.isArray(value) ? value.join(" ") : value;
-        if (className) {
-          attrs.push(`class="${this.escapeHtml(String(className))}"`);
-        }
-        continue;
-      }
-      if (key === "style") {
-        const styleStr = this.styleToString(value);
-        if (styleStr) {
-          attrs.push(`style="${this.escapeHtml(styleStr)}"`);
-        }
-        continue;
-      }
-      if (value === true) {
-        attrs.push(key);
-        continue;
-      }
-      attrs.push(`${key}="${this.escapeHtml(String(value))}"`);
-    }
-    return attrs.join(" ");
-  }
-  styleToString(style) {
-    if (typeof style === "string") {
-      return style;
-    }
-    if (typeof style === "object" && style !== null) {
-      const styles = [];
-      for (const key in style) {
-        const cssKey = key.replace(/([A-Z])/g, "-$1").toLowerCase();
-        styles.push(`${cssKey}:${style[key]}`);
-      }
-      return styles.join(";");
-    }
-    return "";
-  }
-  isState(value) {
-    return value && typeof value === "object" && "value" in value && "subscribe" in value && typeof value.subscribe === "function";
-  }
-  createReactiveChild(state, renderFn) {
-    const currentValue = renderFn(state.value);
-    if (typeof window !== "undefined" && typeof document !== "undefined") {
-      const entry = { node: null, renderFn };
-      this.reactiveNodes.set(state, entry);
-      state.subscribe(() => {
-        if (entry.node && entry.node.parentNode) {
-          const newValue = renderFn(state.value);
-          entry.node.textContent = String(newValue ?? "");
-        }
-      });
-    }
-    return currentValue;
-  }
-  jsonToVNode(json) {
-    if (this.isState(json)) {
-      return this.createReactiveChild(json, (v) => v);
-    }
-    if (isPrimitiveJson(json)) {
-      return json;
-    }
-    const { tag, attributes = {}, children } = json;
-    const props = {};
-    for (const key in attributes) {
-      const value = attributes[key];
-      if (key === "class") {
-        props.className = this.isState(value) ? value.value : value;
-      } else {
-        props[key] = this.isState(value) ? value.value : value;
-      }
-    }
-    const childrenArray = [];
-    if (children != null) {
-      if (Array.isArray(children)) {
-        for (const child of children) {
-          if (this.isState(child)) {
-            childrenArray.push(this.createReactiveChild(child, (v) => v));
-          } else {
-            const converted = this.jsonToVNode(child);
-            if (converted != null && converted !== false) {
-              childrenArray.push(converted);
-            }
-          }
-        }
-      } else if (this.isState(children)) {
-        childrenArray.push(this.createReactiveChild(children, (v) => v));
-      } else if (typeof children === "object" && "tag" in children) {
-        const converted = this.jsonToVNode(children);
-        if (converted != null && converted !== false) {
-          childrenArray.push(converted);
-        }
-      } else {
-        childrenArray.push(children);
-      }
-    }
-    return { tagName: tag, props, children: childrenArray };
-  }
-  vNodeJsonToVNode(json) {
-    if (this.isState(json)) {
-      return this.createReactiveChild(json, (v) => v);
-    }
-    if (isPrimitiveJson(json)) {
-      return json;
-    }
-    const { tagName, props = {}, children = [] } = json;
-    const resolvedProps = {};
-    for (const key in props) {
-      const value = props[key];
-      resolvedProps[key] = this.isState(value) ? value.value : value;
-    }
-    const childrenArray = [];
-    for (const child of children) {
-      if (this.isState(child)) {
-        childrenArray.push(this.createReactiveChild(child, (v) => v));
-      } else {
-        const converted = this.vNodeJsonToVNode(child);
-        if (converted != null && converted !== false) {
-          childrenArray.push(converted);
-        }
-      }
-    }
-    return { tagName, props: resolvedProps, children: childrenArray };
-  }
-  renderJson(rootElement, json) {
-    const vNode = this.jsonToVNode(json);
-    if (!vNode || typeof vNode !== "object" || !("tagName" in vNode)) {
-      throw new Error("Invalid JSON structure");
-    }
-    return this.render(rootElement, vNode);
-  }
-  renderVNode(rootElement, json) {
-    const vNode = this.vNodeJsonToVNode(json);
-    if (!vNode || typeof vNode !== "object" || !("tagName" in vNode)) {
-      throw new Error("Invalid VNode JSON structure");
-    }
-    return this.render(rootElement, vNode);
-  }
-  renderJsonToString(json, options = {}) {
-    const vNode = this.jsonToVNode(json);
-    return this.renderToString(vNode, options);
-  }
-  renderVNodeToString(json, options = {}) {
-    const vNode = this.vNodeJsonToVNode(json);
-    return this.renderToString(vNode, options);
-  }
-  // Generate complete HTML document as string (for SSR)
-  renderToHTMLDocument(vNode, options = {}) {
-    const { title = "", meta = [], links = [], scripts = [], styles = [], lang = "en", head = "", bodyAttrs = {}, pretty = false } = options;
-    const nl = pretty ? "\n" : "";
-    const indent = pretty ? "  " : "";
-    const indent2 = pretty ? "    " : "";
-    let html = `<!DOCTYPE html>${nl}<html lang="${lang}">${nl}${indent}<head>${nl}${indent2}<meta charset="UTF-8">${nl}${indent2}<meta name="viewport" content="width=device-width, initial-scale=1.0">${nl}`;
-    if (title) html += `${indent2}<title>${this.escapeHtml(title)}</title>${nl}`;
-    for (const m of meta) {
-      html += `${indent2}<meta`;
-      for (const k in m) html += ` ${k}="${this.escapeHtml(m[k])}"`;
-      html += `>${nl}`;
-    }
-    for (const l of links) {
-      html += `${indent2}<link`;
-      for (const k in l) html += ` ${k}="${this.escapeHtml(l[k])}"`;
-      html += `>${nl}`;
-    }
-    for (const s of styles) {
-      if (s.href) {
-        html += `${indent2}<link rel="stylesheet" href="${this.escapeHtml(s.href)}">${nl}`;
-      } else if (s.content) {
-        html += `${indent2}<style>${s.content}</style>${nl}`;
-      }
-    }
-    if (head) html += head + nl;
-    html += `${indent}</head>${nl}${indent}<body`;
-    for (const k in bodyAttrs) html += ` ${k}="${this.escapeHtml(bodyAttrs[k])}"`;
-    html += `>${nl}`;
-    html += this.renderToString(vNode, { pretty, indent: 2 });
-    for (const script of scripts) {
-      html += `${indent2}<script`;
-      if (script.type) html += ` type="${this.escapeHtml(script.type)}"`;
-      if (script.async) html += ` async`;
-      if (script.defer) html += ` defer`;
-      if (script.src) {
-        html += ` src="${this.escapeHtml(script.src)}"></script>${nl}`;
-      } else if (script.content) {
-        html += `>${script.content}</script>${nl}`;
-      } else {
-        html += `></script>${nl}`;
-      }
-    }
-    html += `${indent}</body>${nl}</html>`;
-    return html;
-  }
-  // Expose elementCache for reactive updates
-  getElementCache() {
-    return this.elementCache;
-  }
-};
-var dom = new DomNode();
-var render = dom.render.bind(dom);
-var renderToString = dom.renderToString.bind(dom);
-
-// src/server.ts
-var ServerDatabase = class {
-  constructor() {
-    this._db = null;
-  }
-  async initialize(config) {
-    this._db = new Database(config);
-  }
-  database() {
-    return this._db;
-  }
-};
-var serverDatabase = new ServerDatabase();
-var database = serverDatabase.database;
-
-// src/database.ts
+import fs from "fs";
 import * as esbuild from "esbuild";
 var Database = class {
   constructor(config) {
@@ -1077,7 +269,7 @@ var Database = class {
     });
   }
   async moduleLinker(specifier, referencingModule) {
-    const dbFiles = fs2.readdirSync(this._config.dir || resolve(process.cwd(), "databases")).filter((f) => f.endsWith(".ts")).map((f) => path.join(this._config.dir || resolve(process.cwd(), "databases"), f));
+    const dbFiles = fs.readdirSync(this._config.dir || resolve(process.cwd(), "databases")).filter((f) => f.endsWith(".ts")).map((f) => path.join(this._config.dir || resolve(process.cwd(), "databases"), f));
     const dbResult = this.resolvePath(dbFiles, specifier);
     if (dbResult) {
       try {
@@ -1111,26 +303,66 @@ var Database = class {
     let stringCode;
     if (typeof code === "function") {
       const funcStr = code.toString();
-      const arrowMatch = funcStr.match(/^[\s]*\(?\s*\)?\s*=>\s*{?/);
-      const functionMatch = funcStr.match(/^[\s]*function\s*\(?[\w\s]*\)?\s*{/);
-      const match = arrowMatch || functionMatch;
-      const start = match ? match[0].length : 0;
-      const end = funcStr.lastIndexOf("}");
-      stringCode = funcStr.substring(start, end);
-      stringCode = stringCode.replace(/^[\s\r\n]+/, "").replace(/[\s\r\n]+$/, "");
-      stringCode = stringCode.replace(
-        /import\s*\(\s*([^)]+?)\s*\)\s*\.from\s*\(\s*(['"])([^'"]+)\2\s*\)/g,
-        (_, importArg, quote, modulePath) => {
-          const trimmed = importArg.trim();
-          if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
-            const inner = trimmed.slice(1, -1).trim();
-            return `import { ${inner} } from ${quote}${modulePath}${quote}`;
-          } else {
-            return `import ${trimmed} from ${quote}${modulePath}${quote}`;
-          }
+      if (funcStr.includes("=>")) {
+        const arrowIndex = funcStr.indexOf("=>");
+        let start = arrowIndex + 2;
+        while (start < funcStr.length && funcStr[start] === " ") start++;
+        if (funcStr[start] === "{") start++;
+        let end = funcStr.lastIndexOf("}");
+        if (start < end) {
+          stringCode = funcStr.substring(start, end);
+        } else {
+          stringCode = funcStr.substring(start);
+        }
+      } else if (funcStr.includes("function")) {
+        const funcIndex = funcStr.indexOf("function");
+        let start = funcIndex + 8;
+        while (start < funcStr.length && funcStr[start] === " ") start++;
+        if (funcStr[start] === "(") start++;
+        if (start < funcStr.length && funcStr[start] !== "(") {
+          while (start < funcStr.length && funcStr[start] !== " " && funcStr[start] !== "(") start++;
+        }
+        if (funcStr[start] === "(") start++;
+        while (start < funcStr.length && funcStr[start] === " ") start++;
+        if (funcStr[start] === "{") start++;
+        const end = funcStr.lastIndexOf("}");
+        if (start < end) {
+          stringCode = funcStr.substring(start, end);
+        } else {
+          stringCode = funcStr.substring(start);
         }
-      );
-      stringCode = stringCode.split("\n").map((line) => line.trim()).join("\n").trim();
+      } else {
+        stringCode = funcStr;
+      }
+      stringCode = stringCode.trim();
+      let importPos = 0;
+      while ((importPos = stringCode.indexOf("import(", importPos)) !== -1) {
+        const fromPos = stringCode.indexOf(".from(", importPos);
+        if (fromPos === -1) break;
+        const quoteStart = stringCode.indexOf("(", fromPos + 7) + 1;
+        if (quoteStart === -1) break;
+        const quoteChar = stringCode[quoteStart];
+        if (quoteChar !== '"' && quoteChar !== "'") break;
+        const quoteEnd = stringCode.indexOf(quoteChar, quoteStart + 1);
+        if (quoteEnd === -1) break;
+        const modulePath = stringCode.substring(quoteStart + 1, quoteEnd);
+        const importArgEnd = fromPos - 1;
+        const importArgStart = importPos + 7;
+        const trimmed = stringCode.substring(importArgStart, importArgEnd).trim();
+        let replacement;
+        if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+          const inner = trimmed.slice(1, -1).trim();
+          replacement = `import { ${inner} } from "${modulePath}"`;
+        } else {
+          replacement = `import ${trimmed} from "${modulePath}"`;
+        }
+        const before = stringCode.substring(0, importPos);
+        const after = stringCode.substring(quoteEnd + 2);
+        stringCode = before + replacement + after;
+      }
+      const lines = stringCode.split("\n");
+      const trimmedLines = lines.map((line) => line.trim());
+      stringCode = trimmedLines.join("\n").trim();
     } else {
       stringCode = code;
     }
@@ -1161,10 +393,14 @@ var Database = class {
     return await this.vmRun(code, options);
   }
 };
-var database2 = serverDatabase.database;
-var database_default = database2;
+function database() {
+  return new Database({
+    dir: resolve(process.cwd(), "databases")
+  });
+}
+var database_default = database;
 export {
   Database,
-  database2 as database,
+  database,
   database_default as default
 };