elit 3.6.6 → 3.6.7

package/dist/chokidar.cjs

@@ -17,18 +17,17 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/chokidar.ts
+// src/server/chokidar/index.ts
 var chokidar_exports = {};
 __export(chokidar_exports, {
   FSWatcher: () => FSWatcher,
   default: () => chokidar_default,
-  getRuntime: () => getRuntime,
+  getRuntime: () => getRuntime2,
   watch: () => watch
 });
 module.exports = __toCommonJS(chokidar_exports);
-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";
@@ -38,30 +37,15 @@ var isNode = runtime === "node";
 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,
@@ -92,37 +76,52 @@ function createStatsFromDenoFileInfo(info) {
   };
 }
 
-// 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] === "/";
 }
@@ -143,28 +142,18 @@ function isAbsoluteWin(path) {
   }
   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 === "..") {
@@ -179,21 +168,21 @@ function normalizePath(path, isWin) {
       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;
@@ -208,43 +197,43 @@ function joinPaths(paths, isWin) {
 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) || ".";
 }
@@ -252,15 +241,15 @@ function getDirname(path, isWin) {
   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);
   }
@@ -268,8 +257,8 @@ function getBasename(path, ext, isWin) {
 }
 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);
@@ -285,10 +274,8 @@ function parsePath(path, isWin) {
     } 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);
@@ -304,11 +291,31 @@ function formatPath(pathObject, isWin) {
   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, "/");
 }
@@ -316,9 +323,45 @@ function emitEvent(watcher, eventType, path) {
   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);
@@ -340,12 +383,15 @@ function setupFsWatch(watcher, baseDir, patterns, fs2) {
       }
     });
     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();
@@ -361,12 +407,11 @@ var FSWatcher = class extends import_events.EventEmitter {
       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;
   }
@@ -378,12 +423,11 @@ var FSWatcher = class extends import_events.EventEmitter {
       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;
   }
@@ -395,10 +439,8 @@ var FSWatcher = class extends import_events.EventEmitter {
       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();
   }
@@ -406,7 +448,7 @@ var FSWatcher = class extends import_events.EventEmitter {
    * Get watched paths
    */
   getWatched() {
-    if (runtime === "node" && this._watcher) {
+    if (this._watcher && typeof this._watcher.getWatched === "function") {
       return this._watcher.getWatched();
     }
     const result = {};
@@ -427,100 +469,95 @@ var FSWatcher = class extends import_events.EventEmitter {
   _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
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/chokidar.d.ts

@@ -1,14 +1,5 @@
 import { EventEmitter } from 'events';
 
-/**
- * File watcher module with unified API across runtimes
- * Pure implementation without external dependencies
- * Compatible with 'chokidar' package API
- * - Node.js: uses native fs.watch
- * - Bun: uses native fs.watch with enhancements
- * - Deno: uses Deno.watchFs
- */
-
 /**
  * Watch options
  */
@@ -81,6 +72,7 @@ interface WatchOptions {
      */
     atomic?: boolean | number;
 }
+
 /**
  * FSWatcher class - Compatible with chokidar
  */
@@ -113,7 +105,23 @@ declare class FSWatcher extends EventEmitter {
      * @internal
      */
     _setWatcher(watcher: any): void;
+    /**
+     * Internal method to track watched paths
+     * @internal
+     */
+    _trackWatchedPath(path: string): void;
+    /**
+     * Internal method to untrack watched paths
+     * @internal
+     */
+    _untrackWatchedPath(path: string): void;
+    /**
+     * Internal method to read closed state
+     * @internal
+     */
+    _isClosed(): boolean;
 }
+
 /**
  * Watch files and directories
  */
@@ -122,9 +130,16 @@ declare function watch(paths: string | string[], options?: WatchOptions): FSWatc
  * Get current runtime
  */
 declare function getRuntime(): 'node' | 'bun' | 'deno';
+
 /**
- * Default export
+ * File watcher module with unified API across runtimes
+ * Pure implementation without external dependencies
+ * Compatible with 'chokidar' package API
+ * - Node.js: uses native fs.watch
+ * - Bun: uses native fs.watch with enhancements
+ * - Deno: uses Deno.watchFs
  */
+
 declare const _default: {
     watch: typeof watch;
     FSWatcher: typeof FSWatcher;