elit 3.6.6 → 3.6.7

package/dist/chokidar.js

@@ -7,10 +7,7 @@
     throw Error('Dynamic require of "' + x + '" is not supported');
   });
 
-  // src/chokidar.ts
-  var import_events = __require("events");
-
-  // src/runtime.ts
+  // src/shares/runtime.ts
   var runtime = (() => {
     if (typeof Deno !== "undefined") return "deno";
     if (typeof Bun !== "undefined") return "bun";
@@ -20,30 +17,15 @@
   var isBun = runtime === "bun";
   var isDeno = runtime === "deno";
 
-  // src/fs.ts
+  // src/server/fs/node-modules.ts
   var fs;
   var fsPromises;
   if (isNode || isBun) {
     fs = __require("fs");
     fsPromises = __require("fs/promises");
   }
-  function existsSync(path) {
-    try {
-      statSync(path);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  function statSync(path) {
-    if (isNode || isBun) {
-      return fs.statSync(path);
-    } else if (isDeno) {
-      const info = Deno.statSync(path);
-      return createStatsFromDenoFileInfo(info);
-    }
-    throw new Error("Unsupported runtime");
-  }
+
+  // src/server/fs/utils.ts
   function createStatsFromDenoFileInfo(info) {
     return {
       isFile: () => info.isFile,
@@ -74,37 +56,52 @@
     };
   }
 
-  // src/path.ts
+  // src/server/fs/file-ops.ts
+  function existsSync(path) {
+    try {
+      statSync(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function statSync(path) {
+    if (isNode || isBun) {
+      return fs.statSync(path);
+    } else if (isDeno) {
+      const info = Deno.statSync(path);
+      return createStatsFromDenoFileInfo(info);
+    }
+    throw new Error("Unsupported runtime");
+  }
+
+  // src/server/path/platform.ts
   function getSeparator(isWin) {
     return isWin ? "\\" : "/";
   }
   function getCwd() {
     if (isNode || isBun) {
       return process.cwd();
-    } else if (isDeno) {
+    }
+    if (isDeno) {
       return Deno.cwd();
     }
     return "/";
   }
+  var isWindows = (() => {
+    if (isNode) {
+      return process.platform === "win32";
+    }
+    if (isDeno) {
+      return Deno.build.os === "windows";
+    }
+    return typeof process !== "undefined" && process.platform === "win32";
+  })();
+
+  // src/server/path/operations.ts
   function findLastSeparator(path) {
     return Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
   }
-  function createPathOps(isWin) {
-    return {
-      sep: getSeparator(isWin),
-      delimiter: isWin ? ";" : ":",
-      normalize: (path) => normalizePath(path, isWin),
-      join: (...paths) => joinPaths(paths, isWin),
-      resolve: (...paths) => resolvePaths(paths, isWin),
-      isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
-      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),
-      format: (pathObject) => formatPath(pathObject, isWin)
-    };
-  }
   function isAbsolutePosix(path) {
     return path.length > 0 && path[0] === "/";
   }
@@ -125,28 +122,18 @@
     }
     return false;
   }
-  var isWindows = (() => {
-    if (isNode) {
-      return process.platform === "win32";
-    } else if (isDeno) {
-      return Deno.build.os === "windows";
-    }
-    return typeof process !== "undefined" && process.platform === "win32";
-  })();
-  var posix = createPathOps(false);
-  var win32 = createPathOps(true);
   function normalizePath(path, isWin) {
     if (path.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 normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
     const parts = normalized.split(separator);
     const result = [];
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i];
+    for (let index = 0; index < parts.length; index++) {
+      const part = parts[index];
       if (part === "" || part === ".") {
-        if (i === 0 && isAbsolute) result.push("");
+        if (index === 0 && isAbsolute) result.push("");
         continue;
       }
       if (part === "..") {
@@ -161,21 +148,21 @@
         result.push(part);
       }
     }
-    let final = result.join(separator);
-    if (final.length === 0) {
+    let finalPath = result.join(separator);
+    if (finalPath.length === 0) {
       return isAbsolute ? separator : ".";
     }
-    if (trailingSeparator && final[final.length - 1] !== separator) {
-      final += separator;
+    if (trailingSeparator && finalPath[finalPath.length - 1] !== separator) {
+      finalPath += separator;
     }
-    return final;
+    return finalPath;
   }
   function joinPaths(paths, isWin) {
     if (paths.length === 0) return ".";
     const separator = getSeparator(isWin);
     let joined = "";
-    for (let i = 0; i < paths.length; i++) {
-      const path = paths[i];
+    for (let index = 0; index < paths.length; index++) {
+      const path = paths[index];
       if (path && path.length > 0) {
         if (joined.length === 0) {
           joined = path;
@@ -190,43 +177,43 @@
   function resolvePaths(paths, isWin) {
     const separator = getSeparator(isWin);
     let resolved = "";
-    let isAbsolute = false;
-    for (let i = paths.length - 1; i >= 0 && !isAbsolute; i--) {
-      const path = paths[i];
+    let absolute = false;
+    for (let index = paths.length - 1; index >= 0 && !absolute; index--) {
+      const path = paths[index];
       if (path && path.length > 0) {
         resolved = path + (resolved.length > 0 ? separator + resolved : "");
-        isAbsolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
+        absolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
       }
     }
-    if (!isAbsolute) {
+    if (!absolute) {
       const cwd = getCwd();
       resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
     }
     return normalizePath(resolved, isWin);
   }
   function relativePath(from, to, isWin) {
-    from = resolvePaths([from], isWin);
-    to = resolvePaths([to], isWin);
-    if (from === to) return "";
+    const resolvedFrom = resolvePaths([from], isWin);
+    const resolvedTo = resolvePaths([to], isWin);
+    if (resolvedFrom === resolvedTo) return "";
     const separator = getSeparator(isWin);
-    const fromParts = from.split(separator).filter((p) => p.length > 0);
-    const toParts = to.split(separator).filter((p) => p.length > 0);
-    let commonLength = 0;
+    const fromParts = resolvedFrom.split(separator).filter((part) => part.length > 0);
+    const toParts = resolvedTo.split(separator).filter((part) => part.length > 0);
     const minLength = Math.min(fromParts.length, toParts.length);
-    for (let i = 0; i < minLength; i++) {
-      if (fromParts[i] === toParts[i]) {
+    let commonLength = 0;
+    for (let index = 0; index < minLength; index++) {
+      if (fromParts[index] === toParts[index]) {
         commonLength++;
       } else {
         break;
       }
     }
-    const upCount = fromParts.length - commonLength;
     const result = [];
-    for (let i = 0; i < upCount; i++) {
+    const upCount = fromParts.length - commonLength;
+    for (let index = 0; index < upCount; index++) {
       result.push("..");
     }
-    for (let i = commonLength; i < toParts.length; i++) {
-      result.push(toParts[i]);
+    for (let index = commonLength; index < toParts.length; index++) {
+      result.push(toParts[index]);
     }
     return result.join(separator) || ".";
   }
@@ -234,15 +221,15 @@
     if (path.length === 0) return ".";
     const separator = getSeparator(isWin);
     const normalized = normalizePath(path, isWin);
-    const lastSepIndex = normalized.lastIndexOf(separator);
-    if (lastSepIndex === -1) return ".";
-    if (lastSepIndex === 0) return separator;
-    return normalized.slice(0, lastSepIndex);
+    const lastSeparatorIndex = normalized.lastIndexOf(separator);
+    if (lastSeparatorIndex === -1) return ".";
+    if (lastSeparatorIndex === 0) return separator;
+    return normalized.slice(0, lastSeparatorIndex);
   }
   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);
+    const lastSeparatorIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
+    let base = lastSeparatorIndex === -1 ? path : path.slice(lastSeparatorIndex + 1);
     if (ext && base.endsWith(ext)) {
       base = base.slice(0, base.length - ext.length);
     }
@@ -250,8 +237,8 @@
   }
   function getExtname(path) {
     const lastDotIndex = path.lastIndexOf(".");
-    const lastSepIndex = findLastSeparator(path);
-    if (lastDotIndex === -1 || lastDotIndex < lastSepIndex || lastDotIndex === path.length - 1) {
+    const lastSeparatorIndex = findLastSeparator(path);
+    if (lastDotIndex === -1 || lastDotIndex < lastSeparatorIndex || lastDotIndex === path.length - 1) {
       return "";
     }
     return path.slice(lastDotIndex);
@@ -267,10 +254,8 @@
       } else if (path[0] === "\\" || path[0] === "/") {
         root = "\\";
       }
-    } else {
-      if (path[0] === "/") {
-        root = "/";
-      }
+    } else if (path[0] === "/") {
+      root = "/";
     }
     const dir = getDirname(path, isWin);
     const base = getBasename(path, void 0, isWin);
@@ -286,11 +271,31 @@
     if (dir === pathObject.root) return dir + base;
     return dir + separator + base;
   }
+  function createPathOps(isWin) {
+    return {
+      sep: getSeparator(isWin),
+      delimiter: isWin ? ";" : ":",
+      normalize: (path) => normalizePath(path, isWin),
+      join: (...paths) => joinPaths(paths, isWin),
+      resolve: (...paths) => resolvePaths(paths, isWin),
+      isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
+      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),
+      format: (pathObject) => formatPath(pathObject, isWin)
+    };
+  }
+
+  // src/server/path/index.ts
+  var posix = createPathOps(false);
+  var win32 = createPathOps(true);
   function dirname(path) {
     return getDirname(path, isWindows);
   }
 
-  // src/chokidar.ts
+  // src/server/chokidar/utils.ts
   function normalizePath2(path) {
     return path.replace(/\\/g, "/");
   }
@@ -298,9 +303,45 @@
     watcher.emit(eventType, path);
     watcher.emit("all", eventType, path);
   }
+  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 matchesAnyPattern(path, patterns) {
     return patterns.some((pattern) => matchesPattern(path, pattern));
   }
+  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 || ".";
+  }
+
+  // src/server/chokidar/native-watch.ts
   function handleRenameEvent(watcher, fullPath, fs2) {
     try {
       fs2.statSync(fullPath);
@@ -322,12 +363,15 @@
         }
       });
       watcher._setWatcher(nativeWatcher);
-      watcher["_watched"].add(baseDir);
+      watcher._trackWatchedPath(baseDir);
       queueMicrotask(() => watcher.emit("ready"));
     } catch (error) {
       watcher.emit("error", error);
     }
   }
+
+  // src/server/chokidar/watcher.ts
+  var import_events = __require("events");
   var FSWatcher = class extends import_events.EventEmitter {
     constructor(options) {
       super();
@@ -343,12 +387,11 @@
         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));
+      if (this._watcher && typeof this._watcher.add === "function") {
+        this._watcher.add(pathArray);
+      }
+      if (runtime !== "node" || !this._watcher || typeof this._watcher.add !== "function") {
+        pathArray.forEach((path) => this._trackWatchedPath(path));
       }
       return this;
     }
@@ -360,12 +403,11 @@
         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));
+      if (this._watcher && typeof this._watcher.unwatch === "function") {
+        this._watcher.unwatch(pathArray);
+      }
+      if (runtime !== "node" || !this._watcher || typeof this._watcher.unwatch !== "function") {
+        pathArray.forEach((path) => this._untrackWatchedPath(path));
       }
       return this;
     }
@@ -377,10 +419,8 @@
         return;
       }
       this._closed = true;
-      if (runtime === "node") {
-        if (this._watcher) {
-          await this._watcher.close();
-        }
+      if (this._watcher && typeof this._watcher.close === "function") {
+        await this._watcher.close();
       }
       this.removeAllListeners();
     }
@@ -388,7 +428,7 @@
      * Get watched paths
      */
     getWatched() {
-      if (runtime === "node" && this._watcher) {
+      if (this._watcher && typeof this._watcher.getWatched === "function") {
         return this._watcher.getWatched();
       }
       const result = {};
@@ -409,99 +449,94 @@
     _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 || ".";
+    /**
+     * Internal method to track watched paths
+     * @internal
+     */
+    _trackWatchedPath(path) {
+      this._watched.add(path);
     }
-    if (normalizedPattern && existsSync(normalizedPattern)) {
-      try {
-        return statSync(normalizedPattern).isDirectory() ? normalizedPattern : normalizePath2(dirname(normalizedPattern)) || ".";
-      } catch {
-        return normalizePath2(dirname(normalizedPattern)) || ".";
-      }
+    /**
+     * Internal method to untrack watched paths
+     * @internal
+     */
+    _untrackWatchedPath(path) {
+      this._watched.delete(path);
     }
-    const lastSegment = parts[parts.length - 1] || "";
-    if (lastSegment.includes(".") && !lastSegment.startsWith(".")) {
-      return normalizePath2(dirname(normalizedPattern)) || ".";
+    /**
+     * Internal method to read closed state
+     * @internal
+     */
+    _isClosed() {
+      return this._closed;
     }
-    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];
+  };
+
+  // src/server/chokidar/watch.ts
+  function createWatchMap(paths) {
     const watchMap = /* @__PURE__ */ new Map();
-    pathArray.forEach((path) => {
+    paths.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;
-              }
+    return watchMap;
+  }
+  function setupDenoWatch(watcher, watchMap, pathArray) {
+    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._isClosed()) 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"));
+      } catch (error) {
+        if (!watcher._isClosed()) {
+          watcher.emit("error", error);
+        }
+      }
+    })();
+    pathArray.forEach((path) => watcher.add(path));
+    queueMicrotask(() => watcher.emit("ready"));
+  }
+  function watch(paths, options) {
+    const watcher = new FSWatcher(options);
+    const pathArray = Array.isArray(paths) ? paths : [paths];
+    const watchMap = createWatchMap(pathArray);
+    if (runtime === "node" || runtime === "bun") {
+      const fs2 = __require("fs");
+      watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs2));
+    } else if (runtime === "deno") {
+      setupDenoWatch(watcher, watchMap, pathArray);
     }
     return watcher;
   }
-  function getRuntime() {
+  function getRuntime2() {
     return runtime;
   }
+
+  // src/server/chokidar/index.ts
   var chokidar_default = {
     watch,
     FSWatcher,
-    getRuntime
+    getRuntime: getRuntime2
   };
 })();