elit 3.5.3 → 3.5.5

package/dist/server.mjs

@@ -55085,199 +55085,8 @@ var WebSocketServer = class extends EventEmitter3 {
 };
 
 // src/chokidar.ts
-init_runtime();
-import { EventEmitter as EventEmitter4 } from "events";
-function normalizePath(path) {
-  return path.replace(/\\/g, "/");
-}
-function emitEvent(watcher, eventType, path) {
-  watcher.emit(eventType, path);
-  watcher.emit("all", eventType, path);
-}
-function matchesAnyPattern(path, patterns) {
-  return patterns.some((pattern) => matchesPattern(path, pattern));
-}
-function handleRenameEvent(watcher, fullPath, fs2) {
-  try {
-    fs2.statSync(fullPath);
-    emitEvent(watcher, "add", fullPath);
-  } catch {
-    emitEvent(watcher, "unlink", fullPath);
-  }
-}
-function setupFsWatch(watcher, baseDir, patterns, fs2) {
-  try {
-    const nativeWatcher = fs2.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);
-      } else if (eventType === "change") {
-        emitEvent(watcher, "change", fullPath);
-      }
-    });
-    watcher._setWatcher(nativeWatcher);
-    watcher["_watched"].add(baseDir);
-    queueMicrotask(() => watcher.emit("ready"));
-  } catch (error) {
-    watcher.emit("error", error);
-  }
-}
-var FSWatcher = class extends EventEmitter4 {
-  constructor(options) {
-    super();
-    this._closed = false;
-    this._watched = /* @__PURE__ */ new Set();
-    this.options = options || {};
-  }
-  /**
-   * Add paths to be watched
-   */
-  add(paths) {
-    if (this._closed) {
-      throw new Error("Watcher has been closed");
-    }
-    const pathArray = Array.isArray(paths) ? paths : [paths];
-    if (runtime === "node") {
-      if (this._watcher) {
-        this._watcher.add(pathArray);
-      }
-    } else {
-      pathArray.forEach((path) => this._watched.add(path));
-    }
-    return this;
-  }
-  /**
-   * Stop watching paths
-   */
-  unwatch(paths) {
-    if (this._closed) {
-      return this;
-    }
-    const pathArray = Array.isArray(paths) ? paths : [paths];
-    if (runtime === "node") {
-      if (this._watcher) {
-        this._watcher.unwatch(pathArray);
-      }
-    } else {
-      pathArray.forEach((path) => this._watched.delete(path));
-    }
-    return this;
-  }
-  /**
-   * Close the watcher
-   */
-  async close() {
-    if (this._closed) {
-      return;
-    }
-    this._closed = true;
-    if (runtime === "node") {
-      if (this._watcher) {
-        await this._watcher.close();
-      }
-    }
-    this.removeAllListeners();
-  }
-  /**
-   * Get watched paths
-   */
-  getWatched() {
-    if (runtime === "node" && this._watcher) {
-      return this._watcher.getWatched();
-    }
-    const result2 = {};
-    this._watched.forEach((path) => {
-      const dir = path.substring(0, path.lastIndexOf("/")) || ".";
-      const file = path.substring(path.lastIndexOf("/") + 1);
-      if (!result2[dir]) {
-        result2[dir] = [];
-      }
-      result2[dir].push(file);
-    });
-    return result2;
-  }
-  /**
-   * Internal method to set native watcher
-   * @internal
-   */
-  _setWatcher(watcher) {
-    this._watcher = watcher;
-  }
-};
-function getBaseDirectory(pattern) {
-  const parts = pattern.split(/[\\\/]/);
-  let baseDir = "";
-  for (const part of parts) {
-    if (part.includes("*") || part.includes("?")) {
-      break;
-    }
-    baseDir = baseDir ? `${baseDir}/${part}` : part;
-  }
-  return baseDir || ".";
-}
-function matchesPattern(filePath, pattern) {
-  const regexPattern = normalizePath(pattern).replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, ".");
-  const regex = new RegExp(`^${regexPattern}$`);
-  const normalizedPath = normalizePath(filePath);
-  return regex.test(normalizedPath);
-}
-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);
-    if (!watchMap.has(baseDir)) {
-      watchMap.set(baseDir, []);
-    }
-    watchMap.get(baseDir).push(path);
-  });
-  if (runtime === "node") {
-    const fs2 = __require("fs");
-    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs2));
-  } else if (runtime === "bun") {
-    const fs2 = __require("fs");
-    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs2));
-  } else if (runtime === "deno") {
-    const baseDirs = Array.from(watchMap.keys());
-    const allPatterns = Array.from(watchMap.values()).flat();
-    (async () => {
-      try {
-        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);
-            if (!matchesAnyPattern(normalizedPath, allPatterns)) continue;
-            switch (event.kind) {
-              case "create":
-                emitEvent(watcher, "add", path);
-                break;
-              case "modify":
-                emitEvent(watcher, "change", path);
-                break;
-              case "remove":
-                emitEvent(watcher, "unlink", path);
-                break;
-            }
-          }
-        }
-      } catch (error) {
-        if (!watcher["_closed"]) {
-          watcher.emit("error", error);
-        }
-      }
-    })();
-    pathArray.forEach((path) => watcher.add(path));
-    queueMicrotask(() => watcher.emit("ready"));
-  }
-  return watcher;
-}
-
-// src/server.ts
 init_fs();
+import { EventEmitter as EventEmitter4 } from "events";
 
 // src/path.ts
 init_runtime();
@@ -55299,7 +55108,7 @@ function createPathOps(isWin) {
   return {
     sep: getSeparator(isWin),
     delimiter: isWin ? ";" : ":",
-    normalize: (path) => normalizePath2(path, isWin),
+    normalize: (path) => normalizePath(path, isWin),
     join: (...paths) => joinPaths(paths, isWin),
     resolve: (...paths) => resolvePaths(paths, isWin),
     isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
@@ -55342,7 +55151,7 @@ var isWindows = (() => {
 var sep = isWindows ? "\\" : "/";
 var posix = createPathOps(false);
 var win32 = createPathOps(true);
-function normalizePath2(path, isWin) {
+function normalizePath(path, isWin) {
   if (path.length === 0) return ".";
   const separator = getSeparator(isWin);
   const isAbsolute = isWin ? isAbsoluteWin(path) : isAbsolutePosix(path);
@@ -55392,7 +55201,7 @@ function joinPaths(paths, isWin) {
     }
   }
   if (joined.length === 0) return ".";
-  return normalizePath2(joined, isWin);
+  return normalizePath(joined, isWin);
 }
 function resolvePaths(paths, isWin) {
   const separator = getSeparator(isWin);
@@ -55409,7 +55218,7 @@ function resolvePaths(paths, isWin) {
     const cwd = getCwd();
     resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
   }
-  return normalizePath2(resolved, isWin);
+  return normalizePath(resolved, isWin);
 }
 function relativePath(from, to, isWin) {
   from = resolvePaths([from], isWin);
@@ -55440,7 +55249,7 @@ function relativePath(from, to, isWin) {
 function getDirname(path, isWin) {
   if (path.length === 0) return ".";
   const separator = getSeparator(isWin);
-  const normalized = normalizePath2(path, isWin);
+  const normalized = normalizePath(path, isWin);
   const lastSepIndex = normalized.lastIndexOf(separator);
   if (lastSepIndex === -1) return ".";
   if (lastSepIndex === 0) return separator;
@@ -55494,7 +55303,7 @@ function formatPath(pathObject, isWin) {
   return dir + separator + base;
 }
 function normalize(path) {
-  return normalizePath2(path, isWindows);
+  return normalizePath(path, isWindows);
 }
 function join(...paths) {
   return joinPaths(paths, isWindows);
@@ -55505,10 +55314,224 @@ function resolve(...paths) {
 function relative(from, to) {
   return relativePath(from, to, isWindows);
 }
+function dirname(path) {
+  return getDirname(path, isWindows);
+}
 function extname(path) {
   return getExtname(path);
 }
 
+// src/chokidar.ts
+init_runtime();
+function normalizePath2(path) {
+  return path.replace(/\\/g, "/");
+}
+function emitEvent(watcher, eventType, path) {
+  watcher.emit(eventType, path);
+  watcher.emit("all", eventType, path);
+}
+function matchesAnyPattern(path, patterns) {
+  return patterns.some((pattern) => matchesPattern(path, pattern));
+}
+function handleRenameEvent(watcher, fullPath, fs2) {
+  try {
+    fs2.statSync(fullPath);
+    emitEvent(watcher, "add", fullPath);
+  } catch {
+    emitEvent(watcher, "unlink", fullPath);
+  }
+}
+function setupFsWatch(watcher, baseDir, patterns, fs2) {
+  try {
+    const nativeWatcher = fs2.watch(baseDir, { recursive: true }, (eventType, filename) => {
+      if (!filename) return;
+      const fullPath = normalizePath2(`${baseDir}/${filename}`);
+      if (!matchesAnyPattern(fullPath, patterns)) return;
+      if (eventType === "rename") {
+        handleRenameEvent(watcher, fullPath, fs2);
+      } else if (eventType === "change") {
+        emitEvent(watcher, "change", fullPath);
+      }
+    });
+    watcher._setWatcher(nativeWatcher);
+    watcher["_watched"].add(baseDir);
+    queueMicrotask(() => watcher.emit("ready"));
+  } catch (error) {
+    watcher.emit("error", error);
+  }
+}
+var FSWatcher = class extends EventEmitter4 {
+  constructor(options) {
+    super();
+    this._closed = false;
+    this._watched = /* @__PURE__ */ new Set();
+    this.options = options || {};
+  }
+  /**
+   * Add paths to be watched
+   */
+  add(paths) {
+    if (this._closed) {
+      throw new Error("Watcher has been closed");
+    }
+    const pathArray = Array.isArray(paths) ? paths : [paths];
+    if (runtime === "node") {
+      if (this._watcher) {
+        this._watcher.add(pathArray);
+      }
+    } else {
+      pathArray.forEach((path) => this._watched.add(path));
+    }
+    return this;
+  }
+  /**
+   * Stop watching paths
+   */
+  unwatch(paths) {
+    if (this._closed) {
+      return this;
+    }
+    const pathArray = Array.isArray(paths) ? paths : [paths];
+    if (runtime === "node") {
+      if (this._watcher) {
+        this._watcher.unwatch(pathArray);
+      }
+    } else {
+      pathArray.forEach((path) => this._watched.delete(path));
+    }
+    return this;
+  }
+  /**
+   * Close the watcher
+   */
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    if (runtime === "node") {
+      if (this._watcher) {
+        await this._watcher.close();
+      }
+    }
+    this.removeAllListeners();
+  }
+  /**
+   * Get watched paths
+   */
+  getWatched() {
+    if (runtime === "node" && this._watcher) {
+      return this._watcher.getWatched();
+    }
+    const result2 = {};
+    this._watched.forEach((path) => {
+      const dir = path.substring(0, path.lastIndexOf("/")) || ".";
+      const file = path.substring(path.lastIndexOf("/") + 1);
+      if (!result2[dir]) {
+        result2[dir] = [];
+      }
+      result2[dir].push(file);
+    });
+    return result2;
+  }
+  /**
+   * Internal method to set native watcher
+   * @internal
+   */
+  _setWatcher(watcher) {
+    this._watcher = watcher;
+  }
+};
+function getBaseDirectory(pattern) {
+  const normalizedPattern = normalizePath2(pattern);
+  const parts = normalizedPattern.split(/[\\\/]/);
+  let baseDir = "";
+  let sawGlob = false;
+  for (const part of parts) {
+    if (part.includes("*") || part.includes("?")) {
+      sawGlob = true;
+      break;
+    }
+    baseDir = baseDir ? `${baseDir}/${part}` : part;
+  }
+  if (sawGlob) {
+    return baseDir || ".";
+  }
+  if (normalizedPattern && existsSync(normalizedPattern)) {
+    try {
+      return statSync(normalizedPattern).isDirectory() ? normalizedPattern : normalizePath2(dirname(normalizedPattern)) || ".";
+    } catch {
+      return normalizePath2(dirname(normalizedPattern)) || ".";
+    }
+  }
+  const lastSegment = parts[parts.length - 1] || "";
+  if (lastSegment.includes(".") && !lastSegment.startsWith(".")) {
+    return normalizePath2(dirname(normalizedPattern)) || ".";
+  }
+  return normalizedPattern || ".";
+}
+function matchesPattern(filePath, pattern) {
+  const regexPattern = normalizePath2(pattern).replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, ".");
+  const regex = new RegExp(`^${regexPattern}$`);
+  const normalizedPath = normalizePath2(filePath);
+  return regex.test(normalizedPath);
+}
+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);
+    if (!watchMap.has(baseDir)) {
+      watchMap.set(baseDir, []);
+    }
+    watchMap.get(baseDir).push(path);
+  });
+  if (runtime === "node") {
+    const fs2 = __require("fs");
+    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs2));
+  } else if (runtime === "bun") {
+    const fs2 = __require("fs");
+    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs2));
+  } else if (runtime === "deno") {
+    const baseDirs = Array.from(watchMap.keys());
+    const allPatterns = Array.from(watchMap.values()).flat();
+    (async () => {
+      try {
+        const denoWatcher = Deno.watchFs(baseDirs);
+        for await (const event of denoWatcher) {
+          if (watcher["_closed"]) break;
+          for (const path of event.paths) {
+            const normalizedPath = normalizePath2(path);
+            if (!matchesAnyPattern(normalizedPath, allPatterns)) continue;
+            switch (event.kind) {
+              case "create":
+                emitEvent(watcher, "add", path);
+                break;
+              case "modify":
+                emitEvent(watcher, "change", path);
+                break;
+              case "remove":
+                emitEvent(watcher, "unlink", path);
+                break;
+            }
+          }
+        }
+      } catch (error) {
+        if (!watcher["_closed"]) {
+          watcher.emit("error", error);
+        }
+      }
+    })();
+    pathArray.forEach((path) => watcher.add(path));
+    queueMicrotask(() => watcher.emit("ready"));
+  }
+  return watcher;
+}
+
+// src/server.ts
+init_fs();
+
 // src/mime-types.ts
 init_runtime();
 var MIME_TYPES = {