elit 3.0.2 → 3.0.4

package/dist/server.mjs

@@ -634,6 +634,464 @@ var init_http = __esm({
   }
 });
 
+// src/fs.ts
+var fs_exports = {};
+__export(fs_exports, {
+  appendFile: () => appendFile,
+  appendFileSync: () => appendFileSync,
+  copyFile: () => copyFile,
+  copyFileSync: () => copyFileSync,
+  default: () => fs_default,
+  exists: () => exists,
+  existsSync: () => existsSync,
+  getRuntime: () => getRuntime2,
+  mkdir: () => mkdir,
+  mkdirSync: () => mkdirSync,
+  promises: () => promises,
+  readFile: () => readFile,
+  readFileSync: () => readFileSync,
+  readdir: () => readdir,
+  readdirSync: () => readdirSync,
+  realpath: () => realpath,
+  realpathSync: () => realpathSync,
+  rename: () => rename,
+  renameSync: () => renameSync,
+  rmdir: () => rmdir,
+  rmdirSync: () => rmdirSync,
+  stat: () => stat,
+  statSync: () => statSync,
+  unlink: () => unlink,
+  unlinkSync: () => unlinkSync,
+  writeFile: () => writeFile,
+  writeFileSync: () => writeFileSync
+});
+function parseOptions(options, defaultValue) {
+  return typeof options === "string" ? { encoding: options } : options || defaultValue;
+}
+function decodeContent(content, encoding) {
+  if (encoding) {
+    return new TextDecoder(encoding).decode(content);
+  }
+  return Buffer.from(content instanceof ArrayBuffer ? new Uint8Array(content) : content);
+}
+function dataToUint8Array(data) {
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data);
+  }
+  if (data instanceof Buffer) {
+    return new Uint8Array(data);
+  }
+  return data;
+}
+function processDenoEntries(iterator, withFileTypes) {
+  const entries = [];
+  for (const entry of iterator) {
+    if (withFileTypes) {
+      entries.push(createDirentFromDenoEntry(entry));
+    } else {
+      entries.push(entry.name);
+    }
+  }
+  return entries;
+}
+async function processDenoEntriesAsync(iterator, withFileTypes) {
+  const entries = [];
+  for await (const entry of iterator) {
+    if (withFileTypes) {
+      entries.push(createDirentFromDenoEntry(entry));
+    } else {
+      entries.push(entry.name);
+    }
+  }
+  return entries;
+}
+async function readFile(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fsPromises.readFile(path, opts);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const content = await file.arrayBuffer();
+    return decodeContent(content, opts.encoding);
+  } else if (isDeno) {
+    const content = await Deno.readFile(path);
+    return decodeContent(content, opts.encoding);
+  }
+  throw new Error("Unsupported runtime");
+}
+function readFileSync(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fs.readFileSync(path, opts);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const content = file.arrayBuffer();
+    return decodeContent(content, opts.encoding);
+  } else if (isDeno) {
+    const content = Deno.readFileSync(path);
+    return decodeContent(content, opts.encoding);
+  }
+  throw new Error("Unsupported runtime");
+}
+async function writeFile(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fsPromises.writeFile(path, data, opts);
+  } else if (isBun) {
+    await Bun.write(path, data);
+  } else if (isDeno) {
+    await Deno.writeFile(path, dataToUint8Array(data));
+  }
+}
+function writeFileSync(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    fs.writeFileSync(path, data, opts);
+  } else if (isBun) {
+    Bun.write(path, data);
+  } else if (isDeno) {
+    Deno.writeFileSync(path, dataToUint8Array(data));
+  }
+}
+async function appendFile(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fsPromises.appendFile(path, data, opts);
+  } else {
+    if (await exists(path)) {
+      const existing = await readFile(path);
+      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);
+    } else {
+      await writeFile(path, data, opts);
+    }
+  }
+}
+function appendFileSync(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    fs.appendFileSync(path, data, opts);
+  } else {
+    if (existsSync(path)) {
+      const existing = readFileSync(path);
+      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);
+    } else {
+      writeFileSync(path, data, opts);
+    }
+  }
+}
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function existsSync(path) {
+  try {
+    statSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function stat(path) {
+  if (isNode) {
+    return fsPromises.stat(path);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const size = file.size;
+    const exists2 = await file.exists();
+    if (!exists2) {
+      throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
+    }
+    return createStatsObject(path, size, false);
+  } else if (isDeno) {
+    const info = await Deno.stat(path);
+    return createStatsFromDenoFileInfo(info);
+  }
+  throw new Error("Unsupported runtime");
+}
+function statSync(path) {
+  if (isNode) {
+    return fs.statSync(path);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const size = file.size;
+    try {
+      file.arrayBuffer();
+    } catch {
+      throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
+    }
+    return createStatsObject(path, size, false);
+  } else if (isDeno) {
+    const info = Deno.statSync(path);
+    return createStatsFromDenoFileInfo(info);
+  }
+  throw new Error("Unsupported runtime");
+}
+async function mkdir(path, options) {
+  const opts = typeof options === "number" ? { mode: options } : options || {};
+  if (isNode) {
+    await fsPromises.mkdir(path, opts);
+  } else if (isBun) {
+    await Deno.mkdir(path, { recursive: opts.recursive });
+  } else if (isDeno) {
+    await Deno.mkdir(path, { recursive: opts.recursive });
+  }
+}
+function mkdirSync(path, options) {
+  const opts = typeof options === "number" ? { mode: options } : options || {};
+  if (isNode) {
+    fs.mkdirSync(path, opts);
+  } else if (isBun) {
+    Deno.mkdirSync(path, { recursive: opts.recursive });
+  } else if (isDeno) {
+    Deno.mkdirSync(path, { recursive: opts.recursive });
+  }
+}
+async function readdir(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fsPromises.readdir(path, opts);
+  } else if (isBunOrDeno) {
+    return processDenoEntriesAsync(Deno.readDir(path), opts.withFileTypes);
+  }
+  throw new Error("Unsupported runtime");
+}
+function readdirSync(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fs.readdirSync(path, opts);
+  } else if (isBunOrDeno) {
+    return processDenoEntries(Deno.readDirSync(path), opts.withFileTypes);
+  }
+  throw new Error("Unsupported runtime");
+}
+async function unlink(path) {
+  if (isNode) {
+    return fsPromises.unlink(path);
+  } else if (isBun) {
+    await Deno.remove(path);
+  } else if (isDeno) {
+    await Deno.remove(path);
+  }
+}
+function unlinkSync(path) {
+  if (isNode) {
+    fs.unlinkSync(path);
+  } else if (isBun) {
+    Deno.removeSync(path);
+  } else if (isDeno) {
+    Deno.removeSync(path);
+  }
+}
+async function rmdir(path, options) {
+  if (isNode) {
+    return fsPromises.rmdir(path, options);
+  } else if (isBun) {
+    await Deno.remove(path, { recursive: options?.recursive });
+  } else if (isDeno) {
+    await Deno.remove(path, { recursive: options?.recursive });
+  }
+}
+function rmdirSync(path, options) {
+  if (isNode) {
+    fs.rmdirSync(path, options);
+  } else if (isBun) {
+    Deno.removeSync(path, { recursive: options?.recursive });
+  } else if (isDeno) {
+    Deno.removeSync(path, { recursive: options?.recursive });
+  }
+}
+async function rename(oldPath, newPath) {
+  if (isNode) {
+    return fsPromises.rename(oldPath, newPath);
+  } else if (isBun) {
+    await Deno.rename(oldPath, newPath);
+  } else if (isDeno) {
+    await Deno.rename(oldPath, newPath);
+  }
+}
+function renameSync(oldPath, newPath) {
+  if (isNode) {
+    fs.renameSync(oldPath, newPath);
+  } else if (isBun) {
+    Deno.renameSync(oldPath, newPath);
+  } else if (isDeno) {
+    Deno.renameSync(oldPath, newPath);
+  }
+}
+async function copyFile(src, dest, flags) {
+  if (isNode) {
+    return fsPromises.copyFile(src, dest, flags);
+  } else if (isBun) {
+    await Deno.copyFile(src, dest);
+  } else if (isDeno) {
+    await Deno.copyFile(src, dest);
+  }
+}
+function copyFileSync(src, dest, flags) {
+  if (isNode) {
+    fs.copyFileSync(src, dest, flags);
+  } else if (isBun) {
+    Deno.copyFileSync(src, dest);
+  } else if (isDeno) {
+    Deno.copyFileSync(src, dest);
+  }
+}
+async function realpath(path, options) {
+  if (isNode) {
+    return fsPromises.realpath(path, options);
+  } else if (isBun) {
+    const fs2 = __require("fs/promises");
+    return fs2.realpath(path, options);
+  } else if (isDeno) {
+    return await Deno.realPath(path);
+  }
+  return path;
+}
+function realpathSync(path, options) {
+  if (isNode) {
+    return fs.realpathSync(path, options);
+  } else if (isBun) {
+    const fs2 = __require("fs");
+    return fs2.realpathSync(path, options);
+  } else if (isDeno) {
+    return Deno.realPathSync(path);
+  }
+  return path;
+}
+function createStatsObject(_path, size, isDir) {
+  const now = Date.now();
+  return {
+    isFile: () => !isDir,
+    isDirectory: () => isDir,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    dev: 0,
+    ino: 0,
+    mode: isDir ? 16877 : 33188,
+    nlink: 1,
+    uid: 0,
+    gid: 0,
+    rdev: 0,
+    size,
+    blksize: 4096,
+    blocks: Math.ceil(size / 512),
+    atimeMs: now,
+    mtimeMs: now,
+    ctimeMs: now,
+    birthtimeMs: now,
+    atime: new Date(now),
+    mtime: new Date(now),
+    ctime: new Date(now),
+    birthtime: new Date(now)
+  };
+}
+function createStatsFromDenoFileInfo(info) {
+  return {
+    isFile: () => info.isFile,
+    isDirectory: () => info.isDirectory,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => info.isSymlink || false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    dev: info.dev || 0,
+    ino: info.ino || 0,
+    mode: info.mode || 0,
+    nlink: info.nlink || 1,
+    uid: info.uid || 0,
+    gid: info.gid || 0,
+    rdev: 0,
+    size: info.size,
+    blksize: info.blksize || 4096,
+    blocks: info.blocks || Math.ceil(info.size / 512),
+    atimeMs: info.atime?.getTime() || Date.now(),
+    mtimeMs: info.mtime?.getTime() || Date.now(),
+    ctimeMs: info.birthtime?.getTime() || Date.now(),
+    birthtimeMs: info.birthtime?.getTime() || Date.now(),
+    atime: info.atime || /* @__PURE__ */ new Date(),
+    mtime: info.mtime || /* @__PURE__ */ new Date(),
+    ctime: info.birthtime || /* @__PURE__ */ new Date(),
+    birthtime: info.birthtime || /* @__PURE__ */ new Date()
+  };
+}
+function createDirentFromDenoEntry(entry) {
+  return {
+    name: entry.name,
+    isFile: () => entry.isFile,
+    isDirectory: () => entry.isDirectory,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => entry.isSymlink || false,
+    isFIFO: () => false,
+    isSocket: () => false
+  };
+}
+function getRuntime2() {
+  return runtime;
+}
+var isBunOrDeno, fs, fsPromises, promises, fs_default;
+var init_fs = __esm({
+  "src/fs.ts"() {
+    "use strict";
+    init_runtime();
+    isBunOrDeno = isBun || isDeno;
+    if (isNode) {
+      fs = __require("fs");
+      fsPromises = __require("fs/promises");
+    }
+    promises = {
+      readFile,
+      writeFile,
+      appendFile,
+      stat,
+      mkdir,
+      readdir,
+      unlink,
+      rmdir,
+      rename,
+      copyFile,
+      realpath
+    };
+    fs_default = {
+      readFile,
+      readFileSync,
+      writeFile,
+      writeFileSync,
+      appendFile,
+      appendFileSync,
+      exists,
+      existsSync,
+      stat,
+      statSync,
+      mkdir,
+      mkdirSync,
+      readdir,
+      readdirSync,
+      unlink,
+      unlinkSync,
+      rmdir,
+      rmdirSync,
+      rename,
+      renameSync,
+      copyFile,
+      copyFileSync,
+      realpath,
+      realpathSync,
+      promises,
+      getRuntime: getRuntime2
+    };
+  }
+});
+
 // src/server.ts
 init_http();
 
@@ -1208,124 +1666,8 @@ function watch(paths, options) {
   return watcher;
 }
 
-// src/fs.ts
-init_runtime();
-function parseOptions(options, defaultValue) {
-  return typeof options === "string" ? { encoding: options } : options || defaultValue;
-}
-function decodeContent(content, encoding) {
-  if (encoding) {
-    return new TextDecoder(encoding).decode(content);
-  }
-  return Buffer.from(content instanceof ArrayBuffer ? new Uint8Array(content) : content);
-}
-var fs;
-var fsPromises;
-if (isNode) {
-  fs = __require("fs");
-  fsPromises = __require("fs/promises");
-}
-async function readFile(path, options) {
-  const opts = parseOptions(options, {});
-  if (isNode) {
-    return fsPromises.readFile(path, opts);
-  } else if (isBun) {
-    const file = Bun.file(path);
-    const content = await file.arrayBuffer();
-    return decodeContent(content, opts.encoding);
-  } else if (isDeno) {
-    const content = await Deno.readFile(path);
-    return decodeContent(content, opts.encoding);
-  }
-  throw new Error("Unsupported runtime");
-}
-async function stat(path) {
-  if (isNode) {
-    return fsPromises.stat(path);
-  } else if (isBun) {
-    const file = Bun.file(path);
-    const size = file.size;
-    const exists = await file.exists();
-    if (!exists) {
-      throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
-    }
-    return createStatsObject(path, size, false);
-  } else if (isDeno) {
-    const info = await Deno.stat(path);
-    return createStatsFromDenoFileInfo(info);
-  }
-  throw new Error("Unsupported runtime");
-}
-async function realpath(path, options) {
-  if (isNode) {
-    return fsPromises.realpath(path, options);
-  } else if (isBun) {
-    const fs2 = __require("fs/promises");
-    return fs2.realpath(path, options);
-  } else if (isDeno) {
-    return await Deno.realPath(path);
-  }
-  return path;
-}
-function createStatsObject(_path, size, isDir) {
-  const now = Date.now();
-  return {
-    isFile: () => !isDir,
-    isDirectory: () => isDir,
-    isBlockDevice: () => false,
-    isCharacterDevice: () => false,
-    isSymbolicLink: () => false,
-    isFIFO: () => false,
-    isSocket: () => false,
-    dev: 0,
-    ino: 0,
-    mode: isDir ? 16877 : 33188,
-    nlink: 1,
-    uid: 0,
-    gid: 0,
-    rdev: 0,
-    size,
-    blksize: 4096,
-    blocks: Math.ceil(size / 512),
-    atimeMs: now,
-    mtimeMs: now,
-    ctimeMs: now,
-    birthtimeMs: now,
-    atime: new Date(now),
-    mtime: new Date(now),
-    ctime: new Date(now),
-    birthtime: new Date(now)
-  };
-}
-function createStatsFromDenoFileInfo(info) {
-  return {
-    isFile: () => info.isFile,
-    isDirectory: () => info.isDirectory,
-    isBlockDevice: () => false,
-    isCharacterDevice: () => false,
-    isSymbolicLink: () => info.isSymlink || false,
-    isFIFO: () => false,
-    isSocket: () => false,
-    dev: info.dev || 0,
-    ino: info.ino || 0,
-    mode: info.mode || 0,
-    nlink: info.nlink || 1,
-    uid: info.uid || 0,
-    gid: info.gid || 0,
-    rdev: 0,
-    size: info.size,
-    blksize: info.blksize || 4096,
-    blocks: info.blocks || Math.ceil(info.size / 512),
-    atimeMs: info.atime?.getTime() || Date.now(),
-    mtimeMs: info.mtime?.getTime() || Date.now(),
-    ctimeMs: info.birthtime?.getTime() || Date.now(),
-    birthtimeMs: info.birthtime?.getTime() || Date.now(),
-    atime: info.atime || /* @__PURE__ */ new Date(),
-    mtime: info.mtime || /* @__PURE__ */ new Date(),
-    ctime: info.birthtime || /* @__PURE__ */ new Date(),
-    birthtime: info.birthtime || /* @__PURE__ */ new Date()
-  };
-}
+// src/server.ts
+init_fs();
 
 // src/path.ts
 init_runtime();
@@ -2380,22 +2722,23 @@ var sendError = (res, code, msg) => {
 var send404 = (res, msg = "Not Found") => sendError(res, 404, msg);
 var send403 = (res, msg = "Forbidden") => sendError(res, 403, msg);
 var send500 = (res, msg = "Internal Server Error") => sendError(res, 500, msg);
-var createElitImportMap = (basePath = "", mode = "dev") => {
+var createElitImportMap = async (rootDir, basePath = "", mode = "dev") => {
   const srcPath = mode === "dev" ? basePath ? `${basePath}/node_modules/elit/src` : "/node_modules/elit/src" : basePath ? `${basePath}/node_modules/elit/dist` : "/node_modules/elit/dist";
   const fileExt = mode === "dev" ? ".ts" : ".mjs";
-  return `<script type="importmap">{
-  "imports": {
-    "elit": "${srcPath}/index${fileExt}",
-    "elit/": "${srcPath}/",
-    "elit/dom": "${srcPath}/dom${fileExt}",
-    "elit/state": "${srcPath}/state${fileExt}",
-    "elit/style": "${srcPath}/style${fileExt}",
-    "elit/el": "${srcPath}/el${fileExt}",
-    "elit/router": "${srcPath}/router${fileExt}",
-    "elit/hmr": "${srcPath}/hmr${fileExt}",
-    "elit/types": "${srcPath}/types${fileExt}"
-  }
-}</script>`;
+  const elitImports = {
+    "elit": `${srcPath}/index${fileExt}`,
+    "elit/": `${srcPath}/`,
+    "elit/dom": `${srcPath}/dom${fileExt}`,
+    "elit/state": `${srcPath}/state${fileExt}`,
+    "elit/style": `${srcPath}/style${fileExt}`,
+    "elit/el": `${srcPath}/el${fileExt}`,
+    "elit/router": `${srcPath}/router${fileExt}`,
+    "elit/hmr": `${srcPath}/hmr${fileExt}`,
+    "elit/types": `${srcPath}/types${fileExt}`
+  };
+  const externalImports = await generateExternalImportMaps(rootDir, basePath);
+  const allImports = { ...externalImports, ...elitImports };
+  return `<script type="importmap">${JSON.stringify({ imports: allImports }, null, 2)}</script>`;
 };
 var createHMRScript = (port, wsPath) => `<script>(function(){let ws;let retries=0;let maxRetries=5;function connect(){ws=new WebSocket('ws://'+window.location.hostname+':${port}${wsPath}');ws.onopen=()=>{console.log('[Elit HMR] Connected');retries=0};ws.onmessage=(e)=>{const d=JSON.parse(e.data);if(d.type==='update'){console.log('[Elit HMR] File updated:',d.path);window.location.reload()}else if(d.type==='reload'){console.log('[Elit HMR] Reloading...');window.location.reload()}else if(d.type==='error')console.error('[Elit HMR] Error:',d.error)};ws.onclose=()=>{if(retries<maxRetries){retries++;setTimeout(connect,1000*retries)}else if(retries===maxRetries){console.log('[Elit HMR] Connection closed. Start dev server to reconnect.')}};ws.onerror=()=>{ws.close()}}connect()})();</script>`;
 var rewriteRelativePaths = (html2, basePath) => {
@@ -2423,6 +2766,223 @@ async function findSpecialDir(startDir, targetDir) {
   }
   return null;
 }
+var importMapCache = /* @__PURE__ */ new Map();
+function clearImportMapCache() {
+  importMapCache.clear();
+}
+async function generateExternalImportMaps(rootDir, basePath = "") {
+  const cacheKey = `${rootDir}:${basePath}`;
+  if (importMapCache.has(cacheKey)) {
+    return importMapCache.get(cacheKey);
+  }
+  const importMap = {};
+  const nodeModulesPath = await findNodeModules(rootDir);
+  if (!nodeModulesPath) {
+    importMapCache.set(cacheKey, importMap);
+    return importMap;
+  }
+  try {
+    const { readdir: readdir2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+    const packages = await readdir2(nodeModulesPath);
+    for (const pkgEntry of packages) {
+      const pkg = typeof pkgEntry === "string" ? pkgEntry : pkgEntry.name;
+      if (pkg.startsWith(".")) continue;
+      if (pkg.startsWith("@")) {
+        try {
+          const scopedPackages = await readdir2(join(nodeModulesPath, pkg));
+          for (const scopedEntry of scopedPackages) {
+            const scopedPkg = typeof scopedEntry === "string" ? scopedEntry : scopedEntry.name;
+            const fullPkgName = `${pkg}/${scopedPkg}`;
+            await processPackage(nodeModulesPath, fullPkgName, importMap, basePath);
+          }
+        } catch {
+        }
+      } else {
+        await processPackage(nodeModulesPath, pkg, importMap, basePath);
+      }
+    }
+  } catch (error) {
+    console.error("[Import Maps] Error scanning node_modules:", error);
+  }
+  importMapCache.set(cacheKey, importMap);
+  return importMap;
+}
+async function findNodeModules(startDir) {
+  const foundDir = await findSpecialDir(startDir, "node_modules");
+  return foundDir ? join(foundDir, "node_modules") : null;
+}
+function isBrowserCompatible(pkgName, pkgJson) {
+  const buildTools = [
+    "typescript",
+    "esbuild",
+    "@esbuild/",
+    "tsx",
+    "tsup",
+    "rollup",
+    "vite",
+    "webpack",
+    "parcel",
+    "terser",
+    "uglify",
+    "babel",
+    "@babel/",
+    "postcss",
+    "autoprefixer",
+    "cssnano",
+    "sass",
+    "less",
+    "stylus"
+  ];
+  const nodeOnly = [
+    "node-",
+    "@node-",
+    "fsevents",
+    "chokidar",
+    "express",
+    "koa",
+    "fastify",
+    "nest",
+    "commander",
+    "yargs",
+    "inquirer",
+    "chalk",
+    "ora",
+    "nodemon",
+    "pm2",
+    "dotenv"
+  ];
+  const testingTools = [
+    "jest",
+    "vitest",
+    "mocha",
+    "chai",
+    "jasmine",
+    "@jest/",
+    "@testing-library/",
+    "@vitest/",
+    "playwright",
+    "puppeteer",
+    "cypress"
+  ];
+  const linters = [
+    "eslint",
+    "@eslint/",
+    "prettier",
+    "tslint",
+    "stylelint",
+    "commitlint"
+  ];
+  const typeDefinitions = [
+    "@types/",
+    "@typescript-eslint/"
+  ];
+  const utilities = [
+    "get-tsconfig",
+    "resolve-pkg-maps",
+    "pkg-types",
+    "fast-glob",
+    "globby",
+    "micromatch",
+    "execa",
+    "cross-spawn",
+    "shelljs"
+  ];
+  const skipPatterns = [
+    ...buildTools,
+    ...nodeOnly,
+    ...testingTools,
+    ...linters,
+    ...typeDefinitions,
+    ...utilities
+  ];
+  if (skipPatterns.some((pattern) => pkgName.startsWith(pattern))) {
+    return false;
+  }
+  if (pkgName === "lodash") {
+    return false;
+  }
+  if (pkgJson.browser || pkgJson.module) {
+    return true;
+  }
+  if (pkgJson.exports) {
+    const exportsStr = JSON.stringify(pkgJson.exports);
+    if (exportsStr.includes('"import"') || exportsStr.includes('"browser"')) {
+      return true;
+    }
+  }
+  if (pkgJson.type === "commonjs" && !pkgJson.module && !pkgJson.browser) {
+    return false;
+  }
+  return !!(pkgJson.exports || pkgJson.type === "module" || pkgJson.module);
+}
+async function processPackage(nodeModulesPath, pkgName, importMap, basePath) {
+  const pkgPath = join(nodeModulesPath, pkgName);
+  const pkgJsonPath = join(pkgPath, "package.json");
+  try {
+    const pkgJsonContent = await readFile(pkgJsonPath);
+    const pkgJson = JSON.parse(pkgJsonContent.toString());
+    if (!isBrowserCompatible(pkgName, pkgJson)) {
+      return;
+    }
+    const baseUrl = basePath ? `${basePath}/node_modules/${pkgName}` : `/node_modules/${pkgName}`;
+    if (pkgJson.exports) {
+      processExportsField(pkgName, pkgJson.exports, baseUrl, importMap);
+    } else {
+      const entryPoint = pkgJson.browser || pkgJson.module || pkgJson.main || "index.js";
+      importMap[pkgName] = `${baseUrl}/${entryPoint}`;
+      importMap[`${pkgName}/`] = `${baseUrl}/`;
+    }
+  } catch {
+  }
+}
+function processExportsField(pkgName, exports, baseUrl, importMap) {
+  if (typeof exports === "string") {
+    importMap[pkgName] = `${baseUrl}/${exports}`;
+    importMap[`${pkgName}/`] = `${baseUrl}/`;
+    return;
+  }
+  if (typeof exports === "object" && exports !== null) {
+    if ("." in exports) {
+      const dotExport = exports["."];
+      const resolved = resolveExport(dotExport);
+      if (resolved) {
+        importMap[pkgName] = `${baseUrl}/${resolved}`;
+      }
+    } else if ("import" in exports) {
+      const resolved = resolveExport(exports);
+      if (resolved) {
+        importMap[pkgName] = `${baseUrl}/${resolved}`;
+      }
+    }
+    for (const [key, value] of Object.entries(exports)) {
+      if (key === "." || key === "import" || key === "require" || key === "types" || key === "default") {
+        continue;
+      }
+      const resolved = resolveExport(value);
+      if (resolved) {
+        const cleanKey = key.startsWith("./") ? key.slice(2) : key;
+        const importName = cleanKey ? `${pkgName}/${cleanKey}` : pkgName;
+        importMap[importName] = `${baseUrl}/${resolved}`;
+      }
+    }
+    importMap[`${pkgName}/`] = `${baseUrl}/`;
+  }
+}
+function resolveExport(exportValue) {
+  if (typeof exportValue === "string") {
+    return exportValue.startsWith("./") ? exportValue.slice(2) : exportValue;
+  }
+  if (typeof exportValue === "object" && exportValue !== null) {
+    const resolved = exportValue.import || exportValue.browser || exportValue.default || exportValue.require;
+    if (typeof resolved === "object" && resolved !== null) {
+      return resolveExport(resolved);
+    }
+    if (typeof resolved === "string") {
+      return resolved.startsWith("./") ? resolved.slice(2) : resolved;
+    }
+  }
+  return null;
+}
 function cors(options = {}) {
   const { origin = "*", methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"], credentials = true, maxAge = 86400 } = options;
   return async (ctx, next) => {
@@ -2578,8 +3138,9 @@ function createProxyHandler(proxyConfigs) {
       }
       if (changeOrigin) {
         proxyReqHeaders.host = targetUrl.host;
+      } else {
+        delete proxyReqHeaders["host"];
       }
-      delete proxyReqHeaders["host"];
       const proxyReqOptions = {
         method: req.method,
         headers: proxyReqHeaders
@@ -2716,7 +3277,6 @@ var defaultOptions = {
   watch: ["**/*.ts", "**/*.js", "**/*.html", "**/*.css"],
   ignore: ["node_modules/**", "dist/**", ".git/**", "**/*.d.ts"],
   logging: true,
-  middleware: [],
   worker: [],
   mode: "dev"
 };
@@ -2788,7 +3348,7 @@ function createDevServer(options) {
     }
     let filePath;
     if (url === "/" && matchedClient.ssr && !matchedClient.index) {
-      return serveSSR(res, matchedClient);
+      return await serveSSR(res, matchedClient);
     } else {
       filePath = url === "/" ? matchedClient.index || "/index.html" : url;
     }
@@ -2870,7 +3430,7 @@ function createDevServer(options) {
       if (!resolvedPath) {
         if (!res.headersSent) {
           if (filePath === "/index.html" && matchedClient.ssr) {
-            return serveSSR(res, matchedClient);
+            return await serveSSR(res, matchedClient);
           }
           if (config.logging) console.log(`[404] ${filePath}`);
           return send404(res, "404 Not Found");
@@ -2894,7 +3454,7 @@ function createDevServer(options) {
           } catch {
             if (config.logging) console.log(`[DEBUG] No index file found in directory`);
             if (matchedClient.ssr) {
-              return serveSSR(res, matchedClient);
+              return await serveSSR(res, matchedClient);
             }
             return send404(res, "404 Not Found");
           }
@@ -2914,12 +3474,12 @@ function createDevServer(options) {
             return send403(res, "403 Forbidden");
           }
           await stat(indexPath);
-          return serveFile(indexPath, res, matchedClient);
+          return serveFile(indexPath, res, matchedClient, isDistRequest || isNodeModulesRequest);
         } catch {
           return send404(res, "404 Not Found");
         }
       }
-      await serveFile(fullPath, res, matchedClient);
+      await serveFile(fullPath, res, matchedClient, isDistRequest || isNodeModulesRequest);
     } catch (error) {
       if (!res.headersSent) {
         if (config.logging) console.log(`[404] ${filePath}`);
@@ -2927,16 +3487,12 @@ function createDevServer(options) {
       }
     }
   });
-  async function serveFile(filePath, res, client) {
+  async function serveFile(filePath, res, client, isNodeModulesOrDist = false) {
     try {
       const rootDir = await realpath(resolve(client.root));
       const unresolvedPath = resolve(filePath);
-      const isNodeModules = filePath.includes("/node_modules/") || filePath.includes("\\node_modules\\");
-      const isDist = filePath.includes("/dist/") || filePath.includes("\\dist\\");
-      const projectRoot = await realpath(resolve(client.root, ".."));
-      const isInProjectRoot = unresolvedPath.startsWith(projectRoot + sep) || unresolvedPath === projectRoot;
-      if (!unresolvedPath.startsWith(rootDir + sep) && unresolvedPath !== rootDir && !isInProjectRoot) {
-        if (!isNodeModules && !isDist) {
+      if (!isNodeModulesOrDist) {
+        if (!unresolvedPath.startsWith(rootDir + sep) && unresolvedPath !== rootDir) {
           if (config.logging) console.log(`[403] Attempted to serve file outside allowed directories: ${filePath}`);
           return send403(res, "403 Forbidden");
         }
@@ -2944,9 +3500,14 @@ function createDevServer(options) {
       let resolvedPath;
       try {
         resolvedPath = await realpath(unresolvedPath);
+        if (isNodeModulesOrDist && resolvedPath) {
+          if (config.logging && !resolvedPath.startsWith(rootDir + sep)) {
+            console.log(`[DEBUG] Serving symlinked file: ${resolvedPath}`);
+          }
+        }
       } catch {
         if (filePath.endsWith("index.html") && client.ssr) {
-          return serveSSR(res, client);
+          return await serveSSR(res, client);
         }
         return send404(res, "404 Not Found");
       }
@@ -3050,7 +3611,7 @@ ${error}`);
             }
           }
         }
-        const elitImportMap = createElitImportMap(basePath, client.mode);
+        const elitImportMap = await createElitImportMap(client.root, basePath, client.mode);
         const headInjection = ssrStyles ? `${ssrStyles}
 ${elitImportMap}` : elitImportMap;
         html2 = html2.includes("</head>") ? html2.replace("</head>", `${headInjection}</head>`) : html2;
@@ -3080,7 +3641,7 @@ ${elitImportMap}` : elitImportMap;
       send500(res, "500 Internal Server Error");
     }
   }
-  function serveSSR(res, client) {
+  async function serveSSR(res, client) {
     try {
       if (!client.ssr) {
         return send500(res, "SSR function not configured");
@@ -3102,7 +3663,7 @@ ${elitImportMap}` : elitImportMap;
       const basePath = normalizeBasePath(client.basePath);
       html2 = rewriteRelativePaths(html2, basePath);
       const hmrScript = createHMRScript(config.port, basePath);
-      const elitImportMap = createElitImportMap(basePath, client.mode);
+      const elitImportMap = await createElitImportMap(client.root, basePath, client.mode);
       html2 = html2.includes("</head>") ? html2.replace("</head>", `${elitImportMap}</head>`) : html2;
       html2 = html2.includes("</body>") ? html2.replace("</body>", `${hmrScript}</body>`) : html2 + hmrScript;
       res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-cache, no-store, must-revalidate" });
@@ -3238,6 +3799,7 @@ export {
   StateManager,
   bodyLimit,
   cacheControl,
+  clearImportMapCache,
   compress,
   cors,
   createDevServer,