elit 3.1.6 → 3.1.7

package/dist/server.js

@@ -709,205 +709,205 @@ async function processDenoEntriesAsync(iterator, withFileTypes) {
   }
   return entries;
 }
-async function readFile(path, options) {
+async function readFile(path2, options) {
   const opts = parseOptions(options, {});
   if (isNode) {
-    return fsPromises.readFile(path, opts);
+    return fsPromises.readFile(path2, opts);
   } else if (isBun) {
-    const file = Bun.file(path);
+    const file = Bun.file(path2);
     const content = await file.arrayBuffer();
     return decodeContent(content, opts.encoding);
   } else if (isDeno) {
-    const content = await Deno.readFile(path);
+    const content = await Deno.readFile(path2);
     return decodeContent(content, opts.encoding);
   }
   throw new Error("Unsupported runtime");
 }
-function readFileSync(path, options) {
+function readFileSync(path2, options) {
   const opts = parseOptions(options, {});
   if (isNode) {
-    return fs.readFileSync(path, opts);
+    return fs.readFileSync(path2, opts);
   } else if (isBun) {
-    const file = Bun.file(path);
+    const file = Bun.file(path2);
     const content = file.arrayBuffer();
     return decodeContent(content, opts.encoding);
   } else if (isDeno) {
-    const content = Deno.readFileSync(path);
+    const content = Deno.readFileSync(path2);
     return decodeContent(content, opts.encoding);
   }
   throw new Error("Unsupported runtime");
 }
-async function writeFile(path, data, options) {
+async function writeFile(path2, data, options) {
   const opts = parseOptions(options, {});
   if (isNode) {
-    return fsPromises.writeFile(path, data, opts);
+    return fsPromises.writeFile(path2, data, opts);
   } else if (isBun) {
-    await Bun.write(path, data);
+    await Bun.write(path2, data);
   } else if (isDeno) {
-    await Deno.writeFile(path, dataToUint8Array(data));
+    await Deno.writeFile(path2, dataToUint8Array(data));
   }
 }
-function writeFileSync(path, data, options) {
+function writeFileSync(path2, data, options) {
   const opts = parseOptions(options, {});
   if (isNode) {
-    fs.writeFileSync(path, data, opts);
+    fs.writeFileSync(path2, data, opts);
   } else if (isBun) {
-    Bun.write(path, data);
+    Bun.write(path2, data);
   } else if (isDeno) {
-    Deno.writeFileSync(path, dataToUint8Array(data));
+    Deno.writeFileSync(path2, dataToUint8Array(data));
   }
 }
-async function appendFile(path, data, options) {
+async function appendFile(path2, data, options) {
   const opts = parseOptions(options, {});
   if (isNode) {
-    return fsPromises.appendFile(path, data, opts);
+    return fsPromises.appendFile(path2, data, opts);
   } else {
-    if (await exists(path)) {
-      const existing = await readFile(path);
+    if (await exists(path2)) {
+      const existing = await readFile(path2);
       const combined = Buffer.isBuffer(existing) ? Buffer.concat([existing, Buffer.isBuffer(data) ? data : Buffer.from(data)]) : existing + (Buffer.isBuffer(data) ? data.toString() : data);
-      await writeFile(path, combined, opts);
+      await writeFile(path2, combined, opts);
     } else {
-      await writeFile(path, data, opts);
+      await writeFile(path2, data, opts);
     }
   }
 }
-function appendFileSync(path, data, options) {
+function appendFileSync(path2, data, options) {
   const opts = parseOptions(options, {});
   if (isNode) {
-    fs.appendFileSync(path, data, opts);
+    fs.appendFileSync(path2, data, opts);
   } else {
-    if (existsSync(path)) {
-      const existing = readFileSync(path);
+    if (existsSync(path2)) {
+      const existing = readFileSync(path2);
       const combined = Buffer.isBuffer(existing) ? Buffer.concat([existing, Buffer.isBuffer(data) ? data : Buffer.from(data)]) : existing + (Buffer.isBuffer(data) ? data.toString() : data);
-      writeFileSync(path, combined, opts);
+      writeFileSync(path2, combined, opts);
     } else {
-      writeFileSync(path, data, opts);
+      writeFileSync(path2, data, opts);
     }
   }
 }
-async function exists(path) {
+async function exists(path2) {
   try {
-    await stat(path);
+    await stat(path2);
     return true;
   } catch {
     return false;
   }
 }
-function existsSync(path) {
+function existsSync(path2) {
   try {
-    statSync(path);
+    statSync(path2);
     return true;
   } catch {
     return false;
   }
 }
-async function stat(path) {
+async function stat(path2) {
   if (isNode) {
-    return fsPromises.stat(path);
+    return fsPromises.stat(path2);
   } else if (isBun) {
-    const file = Bun.file(path);
+    const file = Bun.file(path2);
     const size = file.size;
     const exists2 = await file.exists();
     if (!exists2) {
-      throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
+      throw new Error(`ENOENT: no such file or directory, stat '${path2}'`);
     }
-    return createStatsObject(path, size, false);
+    return createStatsObject(path2, size, false);
   } else if (isDeno) {
-    const info = await Deno.stat(path);
+    const info = await Deno.stat(path2);
     return createStatsFromDenoFileInfo(info);
   }
   throw new Error("Unsupported runtime");
 }
-function statSync(path) {
+function statSync(path2) {
   if (isNode) {
-    return fs.statSync(path);
+    return fs.statSync(path2);
   } else if (isBun) {
-    const file = Bun.file(path);
+    const file = Bun.file(path2);
     const size = file.size;
     try {
       file.arrayBuffer();
     } catch {
-      throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
+      throw new Error(`ENOENT: no such file or directory, stat '${path2}'`);
     }
-    return createStatsObject(path, size, false);
+    return createStatsObject(path2, size, false);
   } else if (isDeno) {
-    const info = Deno.statSync(path);
+    const info = Deno.statSync(path2);
     return createStatsFromDenoFileInfo(info);
   }
   throw new Error("Unsupported runtime");
 }
-async function mkdir(path, options) {
+async function mkdir(path2, options) {
   const opts = typeof options === "number" ? { mode: options } : options || {};
   if (isNode) {
-    await fsPromises.mkdir(path, opts);
+    await fsPromises.mkdir(path2, opts);
   } else if (isBun) {
-    await Deno.mkdir(path, { recursive: opts.recursive });
+    await Deno.mkdir(path2, { recursive: opts.recursive });
   } else if (isDeno) {
-    await Deno.mkdir(path, { recursive: opts.recursive });
+    await Deno.mkdir(path2, { recursive: opts.recursive });
   }
 }
-function mkdirSync(path, options) {
+function mkdirSync(path2, options) {
   const opts = typeof options === "number" ? { mode: options } : options || {};
   if (isNode) {
-    fs.mkdirSync(path, opts);
+    fs.mkdirSync(path2, opts);
   } else if (isBun) {
-    Deno.mkdirSync(path, { recursive: opts.recursive });
+    Deno.mkdirSync(path2, { recursive: opts.recursive });
   } else if (isDeno) {
-    Deno.mkdirSync(path, { recursive: opts.recursive });
+    Deno.mkdirSync(path2, { recursive: opts.recursive });
   }
 }
-async function readdir(path, options) {
+async function readdir(path2, options) {
   const opts = parseOptions(options, {});
   if (isNode) {
-    return fsPromises.readdir(path, opts);
+    return fsPromises.readdir(path2, opts);
   } else if (isBunOrDeno) {
-    return processDenoEntriesAsync(Deno.readDir(path), opts.withFileTypes);
+    return processDenoEntriesAsync(Deno.readDir(path2), opts.withFileTypes);
   }
   throw new Error("Unsupported runtime");
 }
-function readdirSync(path, options) {
+function readdirSync(path2, options) {
   const opts = parseOptions(options, {});
   if (isNode) {
-    return fs.readdirSync(path, opts);
+    return fs.readdirSync(path2, opts);
   } else if (isBunOrDeno) {
-    return processDenoEntries(Deno.readDirSync(path), opts.withFileTypes);
+    return processDenoEntries(Deno.readDirSync(path2), opts.withFileTypes);
   }
   throw new Error("Unsupported runtime");
 }
-async function unlink(path) {
+async function unlink(path2) {
   if (isNode) {
-    return fsPromises.unlink(path);
+    return fsPromises.unlink(path2);
   } else if (isBun) {
-    await Deno.remove(path);
+    await Deno.remove(path2);
   } else if (isDeno) {
-    await Deno.remove(path);
+    await Deno.remove(path2);
   }
 }
-function unlinkSync(path) {
+function unlinkSync(path2) {
   if (isNode) {
-    fs.unlinkSync(path);
+    fs.unlinkSync(path2);
   } else if (isBun) {
-    Deno.removeSync(path);
+    Deno.removeSync(path2);
   } else if (isDeno) {
-    Deno.removeSync(path);
+    Deno.removeSync(path2);
   }
 }
-async function rmdir(path, options) {
+async function rmdir(path2, options) {
   if (isNode) {
-    return fsPromises.rmdir(path, options);
+    return fsPromises.rmdir(path2, options);
   } else if (isBun) {
-    await Deno.remove(path, { recursive: options?.recursive });
+    await Deno.remove(path2, { recursive: options?.recursive });
   } else if (isDeno) {
-    await Deno.remove(path, { recursive: options?.recursive });
+    await Deno.remove(path2, { recursive: options?.recursive });
   }
 }
-function rmdirSync(path, options) {
+function rmdirSync(path2, options) {
   if (isNode) {
-    fs.rmdirSync(path, options);
+    fs.rmdirSync(path2, options);
   } else if (isBun) {
-    Deno.removeSync(path, { recursive: options?.recursive });
+    Deno.removeSync(path2, { recursive: options?.recursive });
   } else if (isDeno) {
-    Deno.removeSync(path, { recursive: options?.recursive });
+    Deno.removeSync(path2, { recursive: options?.recursive });
   }
 }
 async function rename(oldPath, newPath) {
@@ -946,27 +946,27 @@ function copyFileSync(src, dest, flags) {
     Deno.copyFileSync(src, dest);
   }
 }
-async function realpath(path, options) {
+async function realpath(path2, options) {
   if (isNode) {
-    return fsPromises.realpath(path, options);
+    return fsPromises.realpath(path2, options);
   } else if (isBun) {
-    const fs2 = require("fs/promises");
-    return fs2.realpath(path, options);
+    const fs3 = require("fs/promises");
+    return fs3.realpath(path2, options);
   } else if (isDeno) {
-    return await Deno.realPath(path);
+    return await Deno.realPath(path2);
   }
-  return path;
+  return path2;
 }
-function realpathSync(path, options) {
+function realpathSync(path2, options) {
   if (isNode) {
-    return fs.realpathSync(path, options);
+    return fs.realpathSync(path2, options);
   } else if (isBun) {
-    const fs2 = require("fs");
-    return fs2.realpathSync(path, options);
+    const fs3 = require("fs");
+    return fs3.realpathSync(path2, options);
   } else if (isDeno) {
-    return Deno.realPathSync(path);
+    return Deno.realPathSync(path2);
   }
-  return path;
+  return path2;
 }
 function createStatsObject(_path, size, isDir) {
   const now = Date.now();
@@ -1109,12 +1109,14 @@ __export(server_exports, {
   cors: () => cors,
   createDevServer: () => createDevServer,
   createProxyHandler: () => createProxyHandler,
+  database: () => database2,
   errorHandler: () => errorHandler,
   html: () => html,
   json: () => json,
   logger: () => logger,
   rateLimit: () => rateLimit,
   security: () => security,
+  serverDatabase: () => serverDatabase,
   status: () => status,
   text: () => text
 });
@@ -1503,32 +1505,32 @@ var WebSocketServer = class extends import_events2.EventEmitter {
 // src/chokidar.ts
 var import_events3 = require("events");
 init_runtime();
-function normalizePath(path) {
-  return path.replace(/\\/g, "/");
+function normalizePath(path2) {
+  return path2.replace(/\\/g, "/");
 }
-function emitEvent(watcher, eventType, path) {
-  watcher.emit(eventType, path);
-  watcher.emit("all", eventType, path);
+function emitEvent(watcher, eventType, path2) {
+  watcher.emit(eventType, path2);
+  watcher.emit("all", eventType, path2);
 }
-function matchesAnyPattern(path, patterns) {
-  return patterns.some((pattern) => matchesPattern(path, pattern));
+function matchesAnyPattern(path2, patterns) {
+  return patterns.some((pattern) => matchesPattern(path2, pattern));
 }
-function handleRenameEvent(watcher, fullPath, fs2) {
+function handleRenameEvent(watcher, fullPath, fs3) {
   try {
-    fs2.statSync(fullPath);
+    fs3.statSync(fullPath);
     emitEvent(watcher, "add", fullPath);
   } catch {
     emitEvent(watcher, "unlink", fullPath);
   }
 }
-function setupFsWatch(watcher, baseDir, patterns, fs2) {
+function setupFsWatch(watcher, baseDir, patterns, fs3) {
   try {
-    const nativeWatcher = fs2.watch(baseDir, { recursive: true }, (eventType, filename) => {
+    const nativeWatcher = fs3.watch(baseDir, { recursive: true }, (eventType, filename) => {
       if (!filename) return;
       const fullPath = normalizePath(`${baseDir}/${filename}`);
       if (!matchesAnyPattern(fullPath, patterns)) return;
       if (eventType === "rename") {
-        handleRenameEvent(watcher, fullPath, fs2);
+        handleRenameEvent(watcher, fullPath, fs3);
       } else if (eventType === "change") {
         emitEvent(watcher, "change", fullPath);
       }
@@ -1560,7 +1562,7 @@ var FSWatcher = class extends import_events3.EventEmitter {
         this._watcher.add(pathArray);
       }
     } else {
-      pathArray.forEach((path) => this._watched.add(path));
+      pathArray.forEach((path2) => this._watched.add(path2));
     }
     return this;
   }
@@ -1577,7 +1579,7 @@ var FSWatcher = class extends import_events3.EventEmitter {
         this._watcher.unwatch(pathArray);
       }
     } else {
-      pathArray.forEach((path) => this._watched.delete(path));
+      pathArray.forEach((path2) => this._watched.delete(path2));
     }
     return this;
   }
@@ -1604,9 +1606,9 @@ var FSWatcher = class extends import_events3.EventEmitter {
       return this._watcher.getWatched();
     }
     const result = {};
-    this._watched.forEach((path) => {
-      const dir = path.substring(0, path.lastIndexOf("/")) || ".";
-      const file = path.substring(path.lastIndexOf("/") + 1);
+    this._watched.forEach((path2) => {
+      const dir = path2.substring(0, path2.lastIndexOf("/")) || ".";
+      const file = path2.substring(path2.lastIndexOf("/") + 1);
       if (!result[dir]) {
         result[dir] = [];
       }
@@ -1643,19 +1645,19 @@ function watch(paths, options) {
   const watcher = new FSWatcher(options);
   const pathArray = Array.isArray(paths) ? paths : [paths];
   const watchMap = /* @__PURE__ */ new Map();
-  pathArray.forEach((path) => {
-    const baseDir = getBaseDirectory(path);
+  pathArray.forEach((path2) => {
+    const baseDir = getBaseDirectory(path2);
     if (!watchMap.has(baseDir)) {
       watchMap.set(baseDir, []);
     }
-    watchMap.get(baseDir).push(path);
+    watchMap.get(baseDir).push(path2);
   });
   if (runtime === "node") {
-    const fs2 = require("fs");
-    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs2));
+    const fs3 = require("fs");
+    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs3));
   } else if (runtime === "bun") {
-    const fs2 = require("fs");
-    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs2));
+    const fs3 = require("fs");
+    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs3));
   } else if (runtime === "deno") {
     const baseDirs = Array.from(watchMap.keys());
     const allPatterns = Array.from(watchMap.values()).flat();
@@ -1664,18 +1666,18 @@ function watch(paths, options) {
         const denoWatcher = Deno.watchFs(baseDirs);
         for await (const event of denoWatcher) {
           if (watcher["_closed"]) break;
-          for (const path of event.paths) {
-            const normalizedPath = normalizePath(path);
+          for (const path2 of event.paths) {
+            const normalizedPath = normalizePath(path2);
             if (!matchesAnyPattern(normalizedPath, allPatterns)) continue;
             switch (event.kind) {
               case "create":
-                emitEvent(watcher, "add", path);
+                emitEvent(watcher, "add", path2);
                 break;
               case "modify":
-                emitEvent(watcher, "change", path);
+                emitEvent(watcher, "change", path2);
                 break;
               case "remove":
-                emitEvent(watcher, "unlink", path);
+                emitEvent(watcher, "unlink", path2);
                 break;
             }
           }
@@ -1686,7 +1688,7 @@ function watch(paths, options) {
         }
       }
     })();
-    pathArray.forEach((path) => watcher.add(path));
+    pathArray.forEach((path2) => watcher.add(path2));
     queueMicrotask(() => watcher.emit("ready"));
   }
   return watcher;
@@ -1708,38 +1710,38 @@ function getCwd() {
   }
   return "/";
 }
-function findLastSeparator(path) {
-  return Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+function findLastSeparator(path2) {
+  return Math.max(path2.lastIndexOf("/"), path2.lastIndexOf("\\"));
 }
 function createPathOps(isWin) {
   return {
     sep: getSeparator(isWin),
     delimiter: isWin ? ";" : ":",
-    normalize: (path) => normalizePath2(path, isWin),
+    normalize: (path2) => normalizePath2(path2, isWin),
     join: (...paths) => joinPaths(paths, isWin),
     resolve: (...paths) => resolvePaths(paths, isWin),
-    isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
+    isAbsolute: (path2) => isWin ? isAbsoluteWin(path2) : isAbsolutePosix(path2),
     relative: (from, to) => relativePath(from, to, isWin),
-    dirname: (path) => getDirname(path, isWin),
-    basename: (path, ext) => getBasename(path, ext, isWin),
-    extname: (path) => getExtname(path),
-    parse: (path) => parsePath(path, isWin),
+    dirname: (path2) => getDirname(path2, isWin),
+    basename: (path2, ext) => getBasename(path2, ext, isWin),
+    extname: (path2) => getExtname(path2),
+    parse: (path2) => parsePath(path2, isWin),
     format: (pathObject) => formatPath(pathObject, isWin)
   };
 }
-function isAbsolutePosix(path) {
-  return path.length > 0 && path[0] === "/";
+function isAbsolutePosix(path2) {
+  return path2.length > 0 && path2[0] === "/";
 }
-function isAbsoluteWin(path) {
-  const len = path.length;
+function isAbsoluteWin(path2) {
+  const len = path2.length;
   if (len === 0) return false;
-  const code = path.charCodeAt(0);
+  const code = path2.charCodeAt(0);
   if (code === 47 || code === 92) {
     return true;
   }
   if (code >= 65 && code <= 90 || code >= 97 && code <= 122) {
-    if (len > 2 && path.charCodeAt(1) === 58) {
-      const code2 = path.charCodeAt(2);
+    if (len > 2 && path2.charCodeAt(1) === 58) {
+      const code2 = path2.charCodeAt(2);
       if (code2 === 47 || code2 === 92) {
         return true;
       }
@@ -1758,12 +1760,12 @@ var isWindows = (() => {
 var sep = isWindows ? "\\" : "/";
 var posix = createPathOps(false);
 var win32 = createPathOps(true);
-function normalizePath2(path, isWin) {
-  if (path.length === 0) return ".";
+function normalizePath2(path2, isWin) {
+  if (path2.length === 0) return ".";
   const separator = getSeparator(isWin);
-  const isAbsolute = isWin ? isAbsoluteWin(path) : isAbsolutePosix(path);
-  const trailingSeparator = path[path.length - 1] === separator || isWin && path[path.length - 1] === "/";
-  let normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
+  const isAbsolute = isWin ? isAbsoluteWin(path2) : isAbsolutePosix(path2);
+  const trailingSeparator = path2[path2.length - 1] === separator || isWin && path2[path2.length - 1] === "/";
+  let normalized = path2.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
   const parts = normalized.split(separator);
   const result = [];
   for (let i = 0; i < parts.length; i++) {
@@ -1798,12 +1800,12 @@ function joinPaths(paths, isWin) {
   const separator = getSeparator(isWin);
   let joined = "";
   for (let i = 0; i < paths.length; i++) {
-    const path = paths[i];
-    if (path && path.length > 0) {
+    const path2 = paths[i];
+    if (path2 && path2.length > 0) {
       if (joined.length === 0) {
-        joined = path;
+        joined = path2;
       } else {
-        joined += separator + path;
+        joined += separator + path2;
       }
     }
   }
@@ -1815,9 +1817,9 @@ function resolvePaths(paths, isWin) {
   let resolved = "";
   let isAbsolute = false;
   for (let i = paths.length - 1; i >= 0 && !isAbsolute; i--) {
-    const path = paths[i];
-    if (path && path.length > 0) {
-      resolved = path + (resolved.length > 0 ? separator + resolved : "");
+    const path2 = paths[i];
+    if (path2 && path2.length > 0) {
+      resolved = path2 + (resolved.length > 0 ? separator + resolved : "");
       isAbsolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
     }
   }
@@ -1853,51 +1855,51 @@ function relativePath(from, to, isWin) {
   }
   return result.join(separator) || ".";
 }
-function getDirname(path, isWin) {
-  if (path.length === 0) return ".";
+function getDirname(path2, isWin) {
+  if (path2.length === 0) return ".";
   const separator = getSeparator(isWin);
-  const normalized = normalizePath2(path, isWin);
+  const normalized = normalizePath2(path2, isWin);
   const lastSepIndex = normalized.lastIndexOf(separator);
   if (lastSepIndex === -1) return ".";
   if (lastSepIndex === 0) return separator;
   return normalized.slice(0, lastSepIndex);
 }
-function getBasename(path, ext, isWin) {
-  if (path.length === 0) return "";
-  const lastSepIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
-  let base = lastSepIndex === -1 ? path : path.slice(lastSepIndex + 1);
+function getBasename(path2, ext, isWin) {
+  if (path2.length === 0) return "";
+  const lastSepIndex = isWin ? findLastSeparator(path2) : path2.lastIndexOf("/");
+  let base = lastSepIndex === -1 ? path2 : path2.slice(lastSepIndex + 1);
   if (ext && base.endsWith(ext)) {
     base = base.slice(0, base.length - ext.length);
   }
   return base;
 }
-function getExtname(path) {
-  const lastDotIndex = path.lastIndexOf(".");
-  const lastSepIndex = findLastSeparator(path);
-  if (lastDotIndex === -1 || lastDotIndex < lastSepIndex || lastDotIndex === path.length - 1) {
+function getExtname(path2) {
+  const lastDotIndex = path2.lastIndexOf(".");
+  const lastSepIndex = findLastSeparator(path2);
+  if (lastDotIndex === -1 || lastDotIndex < lastSepIndex || lastDotIndex === path2.length - 1) {
     return "";
   }
-  return path.slice(lastDotIndex);
+  return path2.slice(lastDotIndex);
 }
-function parsePath(path, isWin) {
+function parsePath(path2, isWin) {
   let root = "";
   if (isWin) {
-    if (path.length >= 2 && path[1] === ":") {
-      root = path.slice(0, 2);
-      if (path.length > 2 && (path[2] === "\\" || path[2] === "/")) {
+    if (path2.length >= 2 && path2[1] === ":") {
+      root = path2.slice(0, 2);
+      if (path2.length > 2 && (path2[2] === "\\" || path2[2] === "/")) {
         root += "\\";
       }
-    } else if (path[0] === "\\" || path[0] === "/") {
+    } else if (path2[0] === "\\" || path2[0] === "/") {
       root = "\\";
     }
   } else {
-    if (path[0] === "/") {
+    if (path2[0] === "/") {
       root = "/";
     }
   }
-  const dir = getDirname(path, isWin);
-  const base = getBasename(path, void 0, isWin);
-  const ext = getExtname(path);
+  const dir = getDirname(path2, isWin);
+  const base = getBasename(path2, void 0, isWin);
+  const ext = getExtname(path2);
   const name = ext ? base.slice(0, base.length - ext.length) : base;
   return { root, dir, base, ext, name };
 }
@@ -1909,8 +1911,8 @@ function formatPath(pathObject, isWin) {
   if (dir === pathObject.root) return dir + base;
   return dir + separator + base;
 }
-function normalize(path) {
-  return normalizePath2(path, isWindows);
+function normalize(path2) {
+  return normalizePath2(path2, isWindows);
 }
 function join(...paths) {
   return joinPaths(paths, isWindows);
@@ -1921,8 +1923,8 @@ function resolve(...paths) {
 function relative(from, to) {
   return relativePath(from, to, isWindows);
 }
-function extname(path) {
-  return getExtname(path);
+function extname(path2) {
+  return getExtname(path2);
 }
 
 // src/mime-types.ts
@@ -2005,12 +2007,12 @@ for (const ext in MIME_TYPES) {
   }
   TYPE_TO_EXTENSIONS[type].push(ext);
 }
-function getExtension(path) {
-  const match = /\.([^./\\]+)$/.exec(path);
+function getExtension(path2) {
+  const match = /\.([^./\\]+)$/.exec(path2);
   return match ? match[1].toLowerCase() : "";
 }
-function lookup(path) {
-  const ext = getExtension(path) || path.toLowerCase();
+function lookup(path2) {
+  const ext = getExtension(path2) || path2.toLowerCase();
   return MIME_TYPES[ext] || false;
 }
 
@@ -2657,29 +2659,169 @@ var dom = new DomNode();
 var render = dom.render.bind(dom);
 var renderToString = dom.renderToString.bind(dom);
 
+// src/database.ts
+var import_node_vm = __toESM(require("vm"));
+var import_node_path = __toESM(require("path"));
+var import_node_fs = __toESM(require("fs"));
+var esbuild = __toESM(require("esbuild"));
+var Database = class {
+  constructor(config) {
+    this._config = {
+      dir: resolve(process.cwd(), "databases")
+    };
+    this._config = { ...this._config, ...config };
+    this._registerModules = config.registerModules || {};
+    this._ctx = import_node_vm.default.createContext(this._registerModules);
+  }
+  set config(config) {
+    this._config = { ...this._config, ...config };
+  }
+  register(context) {
+    this._registerModules = { ...this._registerModules, ...context };
+    this._ctx = import_node_vm.default.createContext(this._registerModules);
+  }
+  plugin(moduleName, moduleContent) {
+    this.register({ [moduleName]: moduleContent });
+  }
+  resolvePath(fileList, query) {
+    const aliases = { "@db": this._config.dir || resolve(process.cwd(), "databases") };
+    let resolvedPath = query;
+    for (const [alias, target] of Object.entries(aliases)) {
+      if (resolvedPath.startsWith(alias + "/")) {
+        resolvedPath = resolvedPath.replace(alias, target);
+        break;
+      }
+    }
+    resolvedPath = import_node_path.default.normalize(resolvedPath);
+    return fileList.find((file) => {
+      const normalizedFile = import_node_path.default.normalize(file);
+      const fileWithoutExt = normalizedFile.replace(/\.[^/.]+$/, "");
+      return normalizedFile === resolvedPath || fileWithoutExt === resolvedPath || normalizedFile === resolvedPath + ".ts" || normalizedFile === resolvedPath + ".js";
+    });
+  }
+  async moduleLinker(specifier, referencingModule) {
+    const dbFiles = import_node_fs.default.readdirSync(this._config.dir || resolve(process.cwd(), "databases")).filter((f) => f.endsWith(".ts")).map((f) => import_node_path.default.join(this._config.dir || resolve(process.cwd(), "databases"), f));
+    const dbResult = this.resolvePath(dbFiles, specifier);
+    if (dbResult) {
+      try {
+        const actualModule = await import(dbResult);
+        const exportNames = Object.keys(actualModule);
+        return new import_node_vm.default.SyntheticModule(
+          exportNames,
+          function() {
+            exportNames.forEach((key) => {
+              this.setExport(key, actualModule[key]);
+            });
+          },
+          { identifier: specifier, context: referencingModule.context }
+        );
+      } catch (err) {
+        console.error(`Failed to load database module ${specifier}:`, err);
+        throw err;
+      }
+    }
+    throw new Error(`Module ${specifier} is not allowed or not found.`);
+  }
+  async vmRun(code, _options) {
+    const logs = [];
+    const customConsole = ["log", "error", "warn", "info", "debug", "trace"].reduce((acc, type) => {
+      acc[type] = (...args) => logs.push({ type, args });
+      return acc;
+    }, {});
+    this.register({
+      console: customConsole
+    });
+    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}`;
+          }
+        }
+      );
+      stringCode = stringCode.split("\n").map((line) => line.trim()).join("\n").trim();
+    } else {
+      stringCode = code;
+    }
+    const result = await esbuild.build({
+      stdin: {
+        contents: stringCode,
+        loader: this._config.language || "ts"
+      },
+      format: "esm",
+      target: "es2020",
+      write: false,
+      bundle: false,
+      sourcemap: false
+    });
+    const js = result.outputFiles[0].text;
+    const mod = new import_node_vm.default.SourceTextModule(js, { context: this._ctx, identifier: import_node_path.default.join(this._config.dir || resolve(process.cwd(), "databases"), "virtual-entry.js") });
+    await mod.link(this.moduleLinker.bind(this));
+    await mod.evaluate();
+    return {
+      namespace: mod.namespace,
+      logs
+    };
+  }
+  /**
+   * Execute database code and return results
+   */
+  async execute(code, options) {
+    return await this.vmRun(code, options);
+  }
+};
+var database = serverDatabase.database;
+
 // 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 database2 = serverDatabase.database;
 var ServerRouter = class {
   constructor() {
     this.routes = [];
     this.middlewares = [];
     // Express-like .all() method - matches all HTTP methods
-    this.all = (path, ...handlers) => this.addRoute("ALL", path, handlers);
+    this.all = (path2, ...handlers) => this.addRoute("ALL", path2, handlers);
     // Support per-route middleware: accept middleware(s) before the final handler
-    this.get = (path, ...handlers) => this.addRoute("GET", path, handlers);
-    this.post = (path, ...handlers) => this.addRoute("POST", path, handlers);
-    this.put = (path, ...handlers) => this.addRoute("PUT", path, handlers);
-    this.delete = (path, ...handlers) => this.addRoute("DELETE", path, handlers);
-    this.patch = (path, ...handlers) => this.addRoute("PATCH", path, handlers);
-    this.options = (path, ...handlers) => this.addRoute("OPTIONS", path, handlers);
-    this.head = (path, ...handlers) => this.addRoute("HEAD", path, handlers);
+    this.get = (path2, ...handlers) => this.addRoute("GET", path2, handlers);
+    this.post = (path2, ...handlers) => this.addRoute("POST", path2, handlers);
+    this.put = (path2, ...handlers) => this.addRoute("PUT", path2, handlers);
+    this.delete = (path2, ...handlers) => this.addRoute("DELETE", path2, handlers);
+    this.patch = (path2, ...handlers) => this.addRoute("PATCH", path2, handlers);
+    this.options = (path2, ...handlers) => this.addRoute("OPTIONS", path2, handlers);
+    this.head = (path2, ...handlers) => this.addRoute("HEAD", path2, handlers);
   }
   // Accept both internal Middleware and Express-style `(req, res, next?)` functions
   // Also support path-based middleware like Express: use(path, middleware)
   use(...args) {
     if (typeof args[0] === "string") {
-      const path = args[0];
+      const path2 = args[0];
       const middlewares = args.slice(1);
-      return this.addRoute("ALL", path, middlewares);
+      return this.addRoute("ALL", path2, middlewares);
     }
     const mw = args[0];
     this.middlewares.push(this.toMiddleware(mw));
@@ -2710,8 +2852,8 @@ var ServerRouter = class {
       await next();
     };
   }
-  addRoute(method, path, handlers) {
-    const { pattern, paramNames } = this.pathToRegex(path);
+  addRoute(method, path2, handlers) {
+    const { pattern, paramNames } = this.pathToRegex(path2);
     if (!handlers || handlers.length === 0) throw new Error("Route must include a handler");
     const rawMiddlewares = handlers.slice(0, handlers.length - 1);
     const rawLast = handlers[handlers.length - 1];
@@ -2740,9 +2882,9 @@ var ServerRouter = class {
     this.routes.push({ method, pattern, paramNames, handler: last, middlewares });
     return this;
   }
-  pathToRegex(path) {
+  pathToRegex(path2) {
     const paramNames = [];
-    const pattern = path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\//g, "\\/").replace(/:(\w+)/g, (_, name) => (paramNames.push(name), "([^\\/]+)"));
+    const pattern = path2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\//g, "\\/").replace(/:(\w+)/g, (_, name) => (paramNames.push(name), "([^\\/]+)"));
     return { pattern: new RegExp(`^${pattern}$`), paramNames };
   }
   parseQuery(url) {
@@ -2800,11 +2942,11 @@ var ServerRouter = class {
     });
   }
   async handle(req, res) {
-    const method = req.method, url = req.url || "/", path = url.split("?")[0];
+    const method = req.method, url = req.url || "/", path2 = url.split("?")[0];
     for (const route of this.routes) {
       if (route.method !== "ALL" && route.method !== method) continue;
-      if (!route.pattern.test(path)) continue;
-      const match = path.match(route.pattern);
+      if (!route.pattern.test(path2)) continue;
+      const match = path2.match(route.pattern);
       const params = Object.fromEntries(route.paramNames.map((name, i2) => [name, match[i2 + 1]]));
       let body = {};
       if (["POST", "PUT", "PATCH"].includes(method)) {
@@ -3262,21 +3404,21 @@ function security() {
     await next();
   };
 }
-function rewritePath(path, pathRewrite) {
-  if (!pathRewrite) return path;
+function rewritePath(path2, pathRewrite) {
+  if (!pathRewrite) return path2;
   for (const [from, to] of Object.entries(pathRewrite)) {
     const regex = new RegExp(from);
-    if (regex.test(path)) {
-      return path.replace(regex, to);
+    if (regex.test(path2)) {
+      return path2.replace(regex, to);
     }
   }
-  return path;
+  return path2;
 }
 function createProxyHandler(proxyConfigs) {
   return async (req, res) => {
     const url = req.url || "/";
-    const path = url.split("?")[0];
-    const proxy = proxyConfigs.find((p) => path.startsWith(p.context));
+    const path2 = url.split("?")[0];
+    const proxy = proxyConfigs.find((p) => path2.startsWith(p.context));
     if (!proxy) return false;
     const { target, changeOrigin, pathRewrite, headers } = proxy;
     try {
@@ -3328,7 +3470,7 @@ function createProxyHandler(proxyConfigs) {
       req.on("end", () => proxyReq.end());
       return true;
     } catch (error) {
-      console.error("[Proxy] Invalid proxy configuration for %s:", path, error);
+      console.error("[Proxy] Invalid proxy configuration for %s:", path2, error);
       return false;
     }
   };
@@ -3449,6 +3591,9 @@ function createDevServer(options) {
   if (config.mode === "dev") {
     clearImportMapCache();
   }
+  if (config.database) {
+    serverDatabase.initialize(config.database);
+  }
   const clientsToNormalize = config.clients?.length ? config.clients : config.root ? [{ root: config.root, basePath: config.basePath || "", index: config.index, ssr: config.ssr, api: config.api, proxy: config.proxy, mode: config.mode }] : null;
   if (!clientsToNormalize) throw new Error('DevServerOptions must include either "clients" array or "root" directory');
   const normalizedClients = clientsToNormalize.map((client) => {
@@ -3478,6 +3623,17 @@ function createDevServer(options) {
   const globalProxyHandler = config.proxy ? createProxyHandler(config.proxy) : null;
   const server = createServer(async (req, res) => {
     const originalUrl = req.url || "/";
+    const hostHeader = req.headers.host;
+    const hostName = hostHeader ? (Array.isArray(hostHeader) ? hostHeader[0] : hostHeader).split(":")[0] : "";
+    if (config.domain && hostName === (config.host || "localhost")) {
+      const redirectUrl = `http://${config.domain}${originalUrl}`;
+      if (config.logging) {
+        console.log(`[Domain Map] ${hostName}:${config.port}${originalUrl} -> ${redirectUrl}`);
+      }
+      res.writeHead(302, { Location: redirectUrl });
+      res.end();
+      return;
+    }
     const matchedClient = normalizedClients.find((c) => c.basePath && originalUrl.startsWith(c.basePath)) || normalizedClients.find((c) => !c.basePath);
     if (!matchedClient) return send404(res, "404 Not Found");
     if (matchedClient.proxyHandler) {
@@ -3729,8 +3885,8 @@ export default css;
             });
             transpiled = transpiler.transformSync(content.toString());
           } else {
-            const { build } = await import("esbuild");
-            const result = await build({
+            const { build: build2 } = await import("esbuild");
+            const result = await build2({
               stdin: {
                 contents: content.toString(),
                 loader: ext === ".tsx" ? "tsx" : "ts",
@@ -3747,19 +3903,19 @@ export default css;
           }
           transpiled = transpiled.replace(
             /from\s+["']([^"']+)\.ts(x?)["']/g,
-            (_, path, tsx) => `from "${path}.js${tsx}"`
+            (_, path2, tsx) => `from "${path2}.js${tsx}"`
           );
           transpiled = transpiled.replace(
             /import\s+["']([^"']+)\.ts(x?)["']/g,
-            (_, path, tsx) => `import "${path}.js${tsx}"`
+            (_, path2, tsx) => `import "${path2}.js${tsx}"`
           );
           transpiled = transpiled.replace(
             /import\s+["']([^"']+\.css)["']/g,
-            (_, path) => `import "${path}?inline"`
+            (_, path2) => `import "${path2}?inline"`
           );
           transpiled = transpiled.replace(
             /from\s+["']([^"']+\.css)["']/g,
-            (_, path) => `from "${path}?inline"`
+            (_, path2) => `from "${path2}?inline"`
           );
           content = Buffer.from(transpiled);
           mimeType = "application/javascript";
@@ -3921,17 +4077,17 @@ ${elitImportMap}` : elitImportMap;
     (client) => config.watch.map((pattern) => join(client.root, pattern))
   );
   const watcher = watch(watchPaths, {
-    ignored: (path) => config.ignore.some((pattern) => path.includes(pattern.replace("/**", "").replace("**/", ""))),
+    ignored: (path2) => config.ignore.some((pattern) => path2.includes(pattern.replace("/**", "").replace("**/", ""))),
     ignoreInitial: true,
     persistent: true
   });
-  watcher.on("change", (path) => {
-    if (config.logging) console.log(`[HMR] File changed: ${path}`);
-    const message = JSON.stringify({ type: "update", path, timestamp: Date.now() });
+  watcher.on("change", (path2) => {
+    if (config.logging) console.log(`[HMR] File changed: ${path2}`);
+    const message = JSON.stringify({ type: "update", path: path2, timestamp: Date.now() });
     wsClients.forEach((client) => client.readyState === 1 /* OPEN */ && client.send(message));
   });
-  watcher.on("add", (path) => config.logging && console.log(`[HMR] File added: ${path}`));
-  watcher.on("unlink", (path) => config.logging && console.log(`[HMR] File removed: ${path}`));
+  watcher.on("add", (path2) => config.logging && console.log(`[HMR] File added: ${path2}`));
+  watcher.on("unlink", (path2) => config.logging && console.log(`[HMR] File removed: ${path2}`));
   server.setMaxListeners(20);
   server.listen(config.port, config.host, () => {
     if (config.logging) {
@@ -4004,12 +4160,14 @@ ${elitImportMap}` : elitImportMap;
   cors,
   createDevServer,
   createProxyHandler,
+  database,
   errorHandler,
   html,
   json,
   logger,
   rateLimit,
   security,
+  serverDatabase,
   status,
   text
 });