@nasl/cli 0.1.6 → 0.1.7

package/dist/index.mjs

@@ -1,8 +1,8 @@
-import * as path$1 from 'path';
-import path__default from 'path';
-import require$$0$3 from 'fs';
+import * as sysPath from 'path';
+import sysPath__default from 'path';
+import require$$0$3, { unwatchFile, watchFile, watch as watch$1, stat as stat$3 } from 'fs';
 import stream$4, { Readable } from 'stream';
-import require$$0$1 from 'os';
+import require$$0$1, { type as type$1 } from 'os';
 import require$$0$2 from 'util';
 import require$$0$4, { EventEmitter } from 'events';
 import require$$1 from 'tty';
@@ -10,11 +10,15 @@ import require$$0$5 from 'constants';
 import require$$5 from 'assert';
 import require$$3 from 'http';
 import require$$4 from 'https';
-import require$$0$6 from 'url';
+import require$$0$6, { URL as URL$1 } from 'url';
 import require$$8 from 'crypto';
 import http2 from 'http2';
 import zlib from 'zlib';
-import { spawnSync } from 'child_process';
+import { spawn, spawnSync } from 'child_process';
+import { realpath as realpath$1, stat as stat$2, lstat as lstat$1, open, readdir as readdir$1 } from 'fs/promises';
+import { lstat, stat as stat$1, readdir, realpath } from 'node:fs/promises';
+import { Readable as Readable$1 } from 'node:stream';
+import { resolve, join, relative, sep } from 'node:path';
 
 /**
  * 默认配置
@@ -354,7 +358,7 @@ function requirePath () {
 	Object.defineProperty(path, "__esModule", { value: true });
 	path.convertPosixPathToPattern = path.convertWindowsPathToPattern = path.convertPathToPattern = path.escapePosixPath = path.escapeWindowsPath = path.escape = path.removeLeadingDotSegment = path.makeAbsolute = path.unixify = void 0;
 	const os = require$$0$1;
-	const path$1 = path__default;
+	const path$1 = sysPath__default;
 	const IS_WINDOWS_PLATFORM = os.platform() === 'win32';
 	const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
 	/**
@@ -619,7 +623,7 @@ function requireGlobParent () {
 	hasRequiredGlobParent = 1;
 
 	var isGlob = requireIsGlob();
-	var pathPosixDirname = path__default.posix.dirname;
+	var pathPosixDirname = sysPath__default.posix.dirname;
 	var isWin32 = require$$0$1.platform() === 'win32';
 
 	var slash = '/';
@@ -2191,7 +2195,7 @@ function requireConstants$1 () {
 	if (hasRequiredConstants$1) return constants$1;
 	hasRequiredConstants$1 = 1;
 
-	const path = path__default;
+	const path = sysPath__default;
 	const WIN_SLASH = '\\\\/';
 	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
@@ -2378,7 +2382,7 @@ function requireUtils$4 () {
 	hasRequiredUtils$4 = 1;
 	(function (exports$1) {
 
-		const path = path__default;
+		const path = sysPath__default;
 		const win32 = process.platform === 'win32';
 		const {
 		  REGEX_BACKSLASH,
@@ -3949,7 +3953,7 @@ function requirePicomatch$1 () {
 	if (hasRequiredPicomatch$1) return picomatch_1;
 	hasRequiredPicomatch$1 = 1;
 
-	const path = path__default;
+	const path = sysPath__default;
 	const scan = requireScan();
 	const parse = requireParse();
 	const utils = requireUtils$4();
@@ -4792,7 +4796,7 @@ function requirePattern () {
 	hasRequiredPattern = 1;
 	Object.defineProperty(pattern, "__esModule", { value: true });
 	pattern.isAbsolute = pattern.partitionAbsoluteAndRelative = pattern.removeDuplicateSlashes = pattern.matchAny = pattern.convertPatternsToRe = pattern.makeRe = pattern.getPatternParts = pattern.expandBraceExpansion = pattern.expandPatternsWithBraceExpansion = pattern.isAffectDepthOfReadingPattern = pattern.endsWithSlashGlobStar = pattern.hasGlobStar = pattern.getBaseDirectory = pattern.isPatternRelatedToParentDirectory = pattern.getPatternsOutsideCurrentDirectory = pattern.getPatternsInsideCurrentDirectory = pattern.getPositivePatterns = pattern.getNegativePatterns = pattern.isPositivePattern = pattern.isNegativePattern = pattern.convertToNegativePattern = pattern.convertToPositivePattern = pattern.isDynamicPattern = pattern.isStaticPattern = void 0;
-	const path = path__default;
+	const path = sysPath__default;
 	const globParent = requireGlobParent();
 	const micromatch = requireMicromatch();
 	const GLOBSTAR = '**';
@@ -5746,7 +5750,7 @@ function requireSettings$2 () {
 	if (hasRequiredSettings$2) return settings$2;
 	hasRequiredSettings$2 = 1;
 	Object.defineProperty(settings$2, "__esModule", { value: true });
-	const path = path__default;
+	const path = sysPath__default;
 	const fsStat = requireOut$3();
 	const fs = requireFs$1();
 	class Settings {
@@ -6508,7 +6512,7 @@ function requireSettings$1 () {
 	if (hasRequiredSettings$1) return settings$1;
 	hasRequiredSettings$1 = 1;
 	Object.defineProperty(settings$1, "__esModule", { value: true });
-	const path = path__default;
+	const path = sysPath__default;
 	const fsScandir = requireOut$2();
 	class Settings {
 	    constructor(_options = {}) {
@@ -6584,7 +6588,7 @@ function requireReader () {
 	if (hasRequiredReader) return reader;
 	hasRequiredReader = 1;
 	Object.defineProperty(reader, "__esModule", { value: true });
-	const path = path__default;
+	const path = sysPath__default;
 	const fsStat = requireOut$3();
 	const utils = requireUtils$3();
 	class Reader {
@@ -7057,7 +7061,7 @@ function requireProvider () {
 	if (hasRequiredProvider) return provider;
 	hasRequiredProvider = 1;
 	Object.defineProperty(provider, "__esModule", { value: true });
-	const path = path__default;
+	const path = sysPath__default;
 	const deep_1 = requireDeep();
 	const entry_1 = requireEntry$1();
 	const error_1 = requireError();
@@ -7497,7 +7501,7 @@ var hasRequiredDirGlob;
 function requireDirGlob () {
 	if (hasRequiredDirGlob) return dirGlob.exports;
 	hasRequiredDirGlob = 1;
-	const path = path__default;
+	const path = sysPath__default;
 	const pathType = requirePathType();
 
 	const getExtensions = extensions => extensions.length > 1 ? `{${extensions.join(',')}}` : extensions[0];
@@ -8247,7 +8251,7 @@ function requireGitignore () {
 	hasRequiredGitignore = 1;
 	const {promisify} = require$$0$2;
 	const fs = require$$0$3;
-	const path = path__default;
+	const path = sysPath__default;
 	const fastGlob = requireOut();
 	const gitIgnore = requireIgnore();
 	const slash = requireSlash();
@@ -11758,7 +11762,7 @@ var hasRequiredUtils$1;
 function requireUtils$1 () {
 	if (hasRequiredUtils$1) return utils$3;
 	hasRequiredUtils$1 = 1;
-	const path = path__default;
+	const path = sysPath__default;
 
 	// https://github.com/nodejs/node/issues/8987
 	// https://github.com/libuv/libuv/pull/1088
@@ -11904,7 +11908,7 @@ function requireStat () {
 	hasRequiredStat = 1;
 
 	const fs = /*@__PURE__*/ requireFs();
-	const path = path__default;
+	const path = sysPath__default;
 	const u = requireUniversalify().fromPromise;
 
 	function getStats (src, dest, opts) {
@@ -12108,7 +12112,7 @@ function requireCopy$1 () {
 	hasRequiredCopy$1 = 1;
 
 	const fs = /*@__PURE__*/ requireFs();
-	const path = path__default;
+	const path = sysPath__default;
 	const { mkdirs } = /*@__PURE__*/ requireMkdirs();
 	const { pathExists } = /*@__PURE__*/ requirePathExists();
 	const { utimesMillis } = /*@__PURE__*/ requireUtimes();
@@ -12291,7 +12295,7 @@ function requireCopySync () {
 	hasRequiredCopySync = 1;
 
 	const fs = requireGracefulFs();
-	const path = path__default;
+	const path = sysPath__default;
 	const mkdirsSync = /*@__PURE__*/ requireMkdirs().mkdirsSync;
 	const utimesMillisSync = /*@__PURE__*/ requireUtimes().utimesMillisSync;
 	const stat = /*@__PURE__*/ requireStat();
@@ -12511,7 +12515,7 @@ function requireEmpty () {
 
 	const u = requireUniversalify().fromPromise;
 	const fs = /*@__PURE__*/ requireFs();
-	const path = path__default;
+	const path = sysPath__default;
 	const mkdir = /*@__PURE__*/ requireMkdirs();
 	const remove = /*@__PURE__*/ requireRemove();
 
@@ -12557,7 +12561,7 @@ function requireFile () {
 	hasRequiredFile = 1;
 
 	const u = requireUniversalify().fromPromise;
-	const path = path__default;
+	const path = sysPath__default;
 	const fs = /*@__PURE__*/ requireFs();
 	const mkdir = /*@__PURE__*/ requireMkdirs();
 
@@ -12631,7 +12635,7 @@ function requireLink () {
 	hasRequiredLink = 1;
 
 	const u = requireUniversalify().fromPromise;
-	const path = path__default;
+	const path = sysPath__default;
 	const fs = /*@__PURE__*/ requireFs();
 	const mkdir = /*@__PURE__*/ requireMkdirs();
 	const { pathExists } = /*@__PURE__*/ requirePathExists();
@@ -12702,7 +12706,7 @@ function requireSymlinkPaths () {
 	if (hasRequiredSymlinkPaths) return symlinkPaths_1;
 	hasRequiredSymlinkPaths = 1;
 
-	const path = path__default;
+	const path = sysPath__default;
 	const fs = /*@__PURE__*/ requireFs();
 	const { pathExists } = /*@__PURE__*/ requirePathExists();
 
@@ -12854,7 +12858,7 @@ function requireSymlink () {
 	hasRequiredSymlink = 1;
 
 	const u = requireUniversalify().fromPromise;
-	const path = path__default;
+	const path = sysPath__default;
 	const fs = /*@__PURE__*/ requireFs();
 
 	const { mkdirs, mkdirsSync } = /*@__PURE__*/ requireMkdirs();
@@ -13100,7 +13104,7 @@ function requireOutputFile () {
 
 	const u = requireUniversalify().fromPromise;
 	const fs = /*@__PURE__*/ requireFs();
-	const path = path__default;
+	const path = sysPath__default;
 	const mkdir = /*@__PURE__*/ requireMkdirs();
 	const pathExists = /*@__PURE__*/ requirePathExists().pathExists;
 
@@ -13202,7 +13206,7 @@ function requireMove$1 () {
 	hasRequiredMove$1 = 1;
 
 	const fs = /*@__PURE__*/ requireFs();
-	const path = path__default;
+	const path = sysPath__default;
 	const { copy } = /*@__PURE__*/ requireCopy();
 	const { remove } = /*@__PURE__*/ requireRemove();
 	const { mkdirp } = /*@__PURE__*/ requireMkdirs();
@@ -13269,7 +13273,7 @@ function requireMoveSync () {
 	hasRequiredMoveSync = 1;
 
 	const fs = requireGracefulFs();
-	const path = path__default;
+	const path = sysPath__default;
 	const copySync = /*@__PURE__*/ requireCopy().copySync;
 	const removeSync = /*@__PURE__*/ requireRemove().removeSync;
 	const mkdirpSync = /*@__PURE__*/ requireMkdirs().mkdirpSync;
@@ -13385,15 +13389,15 @@ var dayjs = /*@__PURE__*/getDefaultExportFromCjs(dayjs_minExports);
 
 function fastLogToFile(entry, suffix, content) {
     if (process.env.NASL_CLI_LOG_DIR) {
-        const logDir = path$1.resolve(process.env.NASL_CLI_LOG_DIR);
+        const logDir = sysPath.resolve(process.env.NASL_CLI_LOG_DIR);
         libExports.ensureDirSync(logDir);
         const timeInDir = (process.env.NASL_CLI_LOG_DIR.match(/\d{6,8}_(\d{6})-/)?.[1] || '00');
         const now = dayjs();
         const hourInDir = parseInt(timeInDir.slice(0, 2), 10);
         // 跨天则累加 24 小时
         const hourStr = (now.hour() >= hourInDir ? now.hour() : Math.ceil(hourInDir / 24) * 24 + now.hour()).toString().padStart(2, '0');
-        const entryName = path$1.basename(Array.isArray(entry) ? entry[0] || '*' : entry).replace(/[\[\]\(\)\{\}\*\+\-\?\|\^\$\,\/\#\:\\\s]+/g, '_');
-        const filePath = path$1.resolve(logDir, `${hourStr}${now.format('mmss_SSS')}-${entryName}-${suffix}`);
+        const entryName = sysPath.basename(Array.isArray(entry) ? entry[0] || '*' : entry).replace(/[\[\]\(\)\{\}\*\+\-\?\|\^\$\,\/\#\:\\\s]+/g, '_');
+        const filePath = sysPath.resolve(logDir, `${hourStr}${now.format('mmss_SSS')}-${entryName}-${suffix}`);
         libExports.outputFileSync(filePath, content);
     }
 }
@@ -13424,16 +13428,16 @@ class BaseLogger {
     }
     debugToFile(topic, ...args) {
         if (process.env.DEBUG_TO_FILE) {
-            const baseDir = path$1.join(process.cwd(), '.nasl');
+            const baseDir = sysPath.join(process.cwd(), '.nasl');
             const currentHour = dayjs().format('YYYYMMDD_HH');
             const prevHour = dayjs().subtract(1, 'hour').format('YYYYMMDD_HH');
             let subdir = `${topic}_${currentHour}`;
             const prevSubdir = `${topic}_${prevHour}`;
             // 判断如果有上一个小时的 subdir，则自己汇聚到上一个小时的 subdir 中
-            if (libExports.existsSync(path$1.join(baseDir, prevSubdir)))
+            if (libExports.existsSync(sysPath.join(baseDir, prevSubdir)))
                 subdir = prevSubdir;
             const fileName = `${topic}_${dayjs().format('YYYYMMDD_HHmmss')}.log`;
-            const filePath = path$1.join(baseDir, subdir, fileName);
+            const filePath = sysPath.join(baseDir, subdir, fileName);
             libExports.outputFileSync(filePath, args.join(' '));
         }
     }
@@ -13481,6 +13485,13 @@ class ConsoleLogger extends BaseLogger {
         process.exit(code);
     }
 }
+class ConsoleLoggerWithoutExit extends ConsoleLogger {
+    exit(code) {
+        if (code)
+            throw new Error(`Error with code: ${code}`);
+        return undefined;
+    }
+}
 /**
  * 内存日志工具类
  * 用于在内存中存储日志
@@ -13530,11 +13541,11 @@ function findConfigDir(startDir = process.cwd()) {
     let currentDir = startDir;
     // eslint-disable-next-line no-constant-condition
     while (true) {
-        const configPath = path$1.join(currentDir, CONFIG_FILE_NAME);
+        const configPath = sysPath.join(currentDir, CONFIG_FILE_NAME);
         if (libExports.existsSync(configPath)) {
             return currentDir;
         }
-        const parentDir = path$1.dirname(currentDir);
+        const parentDir = sysPath.dirname(currentDir);
         // 已经到达根目录
         if (parentDir === currentDir) {
             return null;
@@ -13551,7 +13562,7 @@ function loadConfig(configDir) {
         defaultLogger.error(`未找到配置文件 ${CONFIG_FILE_NAME}，请先运行 nasl-init 初始化配置`);
         return defaultLogger.exit(1);
     }
-    const configPath = path$1.join(dir, CONFIG_FILE_NAME);
+    const configPath = sysPath.join(dir, CONFIG_FILE_NAME);
     try {
         const content = libExports.readFileSync(configPath, 'utf-8');
         const config = JSON.parse(content);
@@ -13596,7 +13607,7 @@ function readFileWithLog(filePath, logger) {
  */
 function writeFileWithLog(filePath, content, logger) {
     try {
-        const dir = path$1.dirname(filePath);
+        const dir = sysPath.dirname(filePath);
         libExports.ensureDirSync(dir);
         libExports.writeFileSync(filePath, content, 'utf-8');
     }
@@ -13677,7 +13688,7 @@ function replaceViewAsSignature(content) {
  * @returns 文件信息和新发现的依赖文件列表
  */
 function processFileDeps(pathRelativeToSrc, srcDir, matchedFileSet, processedFileMap, depNotFoundList, logger, verbose) {
-    const absoluteFilePath = path$1.join(srcDir, pathRelativeToSrc);
+    const absoluteFilePath = sysPath.join(srcDir, pathRelativeToSrc);
     const fileInfo = { path: pathRelativeToSrc, content: '' };
     try {
         fileInfo.content = readFileWithLog(absoluteFilePath, logger);
@@ -13741,15 +13752,15 @@ async function collectDeps(patterns, projectRoot, srcDir, logger, verbose) {
         throw new Error('未找到匹配的入口文件');
     }
     logger.info(`找到 ${matchedFiles.length} 个入口文件`);
-    const absoluteSrcDir = path$1.resolve(srcDir);
+    const absoluteSrcDir = sysPath.resolve(srcDir);
     const matchedFileSet = new Set();
     matchedFiles.forEach((pathRelativeToRoot) => {
         // 统一使用相对于 src 的路径
-        const absoluteFilePath = path$1.resolve(projectRoot, pathRelativeToRoot);
+        const absoluteFilePath = sysPath.resolve(projectRoot, pathRelativeToRoot);
         // 判断 file 是否超出 srcDir 目录（支持相对路径和绝对路径）
         if (!absoluteFilePath.startsWith(absoluteSrcDir))
             throw new Error(`入口文件 ${absoluteFilePath} 超出了源代码目录 ${srcDir}`);
-        const pathRelativeToSrc = path$1.relative(srcDir, absoluteFilePath);
+        const pathRelativeToSrc = sysPath.relative(srcDir, absoluteFilePath);
         filesToProcess.push(pathRelativeToSrc);
         matchedFileSet.add(pathRelativeToSrc);
     });
@@ -13798,7 +13809,7 @@ async function resolveNASLFiles(entry, logger, depMode, verbose) {
     const projectRoot = getProjectRoot();
     logger.info(`项目根目录: ${projectRoot}`);
     logger.info(`源代码目录: ${config.srcDir}`);
-    const srcDir = path$1.join(projectRoot, config.srcDir);
+    const srcDir = sysPath.join(projectRoot, config.srcDir);
     // 收集需要处理的文件
     let collectedFiles = [];
     if (Array.isArray(entry) && !entry.length) {
@@ -13832,7 +13843,7 @@ async function resolveNASLFiles(entry, logger, depMode, verbose) {
         filePaths.sort(sorter);
         collectedFiles = filePaths.map((filePath) => ({
             path: filePath,
-            content: readFileWithLog(path$1.join(srcDir, filePath), logger),
+            content: readFileWithLog(sysPath.join(srcDir, filePath), logger),
         }));
         if (collectedFiles.length === 0) {
             logger.warn('未找到 NASL 文件');
@@ -13853,7 +13864,7 @@ async function resolveNASLFiles(entry, logger, depMode, verbose) {
  */
 function init() {
     const cwd = process.cwd();
-    const configPath = path$1.join(cwd, CONFIG_FILE_NAME);
+    const configPath = sysPath.join(cwd, CONFIG_FILE_NAME);
     // 检查配置文件是否已存在
     if (libExports.existsSync(configPath)) {
         defaultLogger.warn(`配置文件已存在: ${configPath}`);
@@ -13867,7 +13878,7 @@ function init() {
         defaultLogger.info('\n配置内容:');
         defaultLogger.info(JSON.stringify(DEFAULT_CONFIG, null, 2));
         // 创建源代码目录
-        const srcDirPath = path$1.join(cwd, DEFAULT_CONFIG.srcDir);
+        const srcDirPath = sysPath.join(cwd, DEFAULT_CONFIG.srcDir);
         libExports.ensureDirSync(srcDirPath);
         defaultLogger.success(`源代码目录已创建: ${srcDirPath}`);
         defaultLogger.info('\n提示：');
@@ -25859,7 +25870,7 @@ function requireMimeTypes () {
 		 */
 
 		var db = requireMimeDb();
-		var extname = path__default.extname;
+		var extname = sysPath__default.extname;
 
 		/**
 		 * Module variables.
@@ -27600,7 +27611,7 @@ function requireForm_data () {
 
 	var CombinedStream = requireCombined_stream();
 	var util = require$$0$2;
-	var path = path__default;
+	var path = sysPath__default;
 	var http = require$$3;
 	var https = require$$4;
 	var parseUrl = require$$0$6.parse;
@@ -34301,10 +34312,22 @@ const {
 } = axios;
 
 function createAxios(baseURL) {
+    // 解析 baseURL 提取 hostname 和 port
+    const url = new URL$1(baseURL);
+    const hostname = url.hostname;
+    const protocol = url.protocol;
+    // 确定端口：如果 URL 中没有指定端口，根据协议使用默认端口
+    let port = url.port;
+    if (!port) {
+        port = protocol === 'https:' ? '443' : '80';
+    }
+    // 构建 Host 头：hostname:port
+    const hostHeader = `${hostname}:${port}`;
     return axios.create({
         baseURL,
         headers: {
             'Content-Type': 'application/json',
+            'Host': hostHeader,
         },
         timeout: 120000,
     });
@@ -34376,7 +34399,7 @@ async function compile(entry, options) {
     // 收集需要编译的文件
     const { collectedFiles, config, projectRoot } = await resolveNASLFiles(entry, logger, false, options?.verbose);
     logger.info(`输出目录: ${config.outDir}`);
-    const outDir = path$1.join(projectRoot, config.outDir);
+    const outDir = sysPath.join(projectRoot, config.outDir);
     // 调用编译 API
     logger.newLine();
     logger.info('正在调用编译服务...');
@@ -34389,7 +34412,7 @@ async function compile(entry, options) {
         logger.success('编译成功！');
         // 写入输出文件
         for (const file of outputFiles) {
-            const outputPath = path$1.join(outDir, file.path);
+            const outputPath = sysPath.join(outDir, file.path);
             writeFileWithLog(outputPath, file.content, logger);
         }
         logger.info(`输出 ${outputFiles.length} 个文件`);
@@ -34402,11 +34425,11 @@ async function compile(entry, options) {
     return { config, outDir };
 }
 async function tryCompile(entry, options) {
-    const logger = options?.logger || defaultLogger;
     try {
         await compile(entry, options);
     }
     catch (error) {
+        const logger = options?.logger || defaultLogger;
         logger.error(`编译过程发生错误：${error.message}`);
         logger.exit(1);
     }
@@ -34457,24 +34480,189 @@ async function dep(entry, options) {
     return resolveNASLFiles(entry, logger, true, true);
 }
 
-function justExecCommandSync(command, cwd) {
-    console.log(command);
-    const result = spawnSync(command, { shell: true, stdio: 'inherit', cwd });
-    if (result.status) {
-        console.error(String(result.stderr || result.stdout));
+/**
+ * 编译命令 - 将 NASL 编译为 Vue 和 JS
+ */
+async function dev(entry, options) {
+    const logger = options?.logger || new ConsoleLoggerWithoutExit();
+    // 获取项目根目录和配置
+    const projectRoot = process.cwd();
+    const configPath = sysPath.join(projectRoot, 'nasl.config.json');
+    if (!libExports.existsSync(configPath)) {
+        logger.error('未找到 nasl.config.json 配置文件，请先初始化项目');
         process.exit(1);
     }
+    const configContent = libExports.readFileSync(configPath, 'utf-8');
+    const config = JSON.parse(configContent);
+    const srcDir = sysPath.join(projectRoot, config.srcDir);
+    const outDir = sysPath.join(projectRoot, config.outDir);
+    // 检查是否存在 src 目录
+    const hasSrcDir = libExports.existsSync(srcDir) && libExports.statSync(srcDir).isDirectory();
+    let lastCompileSuccess = false;
+    if (hasSrcDir) {
+        // 有 src 目录，先进行一次初始编译
+        logger.info('检测到 src 目录，开始初始编译...');
+        try {
+            await compile(entry);
+            lastCompileSuccess = true;
+            logger.success('初始编译成功！');
+        }
+        catch (error) {
+            logger.error(`初始编译失败：${error.message}`);
+            // 即使编译失败，也要尝试启动服务（可能 out 目录已有旧文件）
+            lastCompileSuccess = false;
+        }
+    }
+    else {
+        logger.info('未检测到 src 目录，将监听 src 目录的创建');
+    }
+    // 确保 out 目录存在
+    if (!libExports.existsSync(outDir)) {
+        logger.info('out 目录不存在，创建空的 out 目录');
+        libExports.ensureDirSync(outDir);
+    }
+    // 启动 webpack 开发服务器
+    const webpackProcess = await startWebpackDevServer(outDir, options, logger);
+    const { default: chokidar } = await Promise.resolve().then(function () { return index$1; });
+    // 监听 src 目录下的文件变化（即使目录不存在也可以监听）
+    logger.info(`正在监听 src 目录: ${srcDir}`);
+    const watcher = chokidar.watch(srcDir, {
+        ignored: /(^|[\/\\])\../, // 忽略隐藏文件
+        ignoreInitial: true,
+        persistent: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 100,
+            pollInterval: 10,
+        },
+    });
+    // 只监听 ts/tsx/nasl 文件的变化
+    const shouldHandleFile = (filePath) => {
+        return /\.(ts|tsx|nasl|css)$/.test(filePath);
+    };
+    let isCompiling = false;
+    let pendingCompile = false;
+    const handleFileChange = async (filePath) => {
+        // 过滤非目标文件类型
+        if (!shouldHandleFile(filePath))
+            return;
+        logger.info(`检测到文件变化: ${sysPath.relative(projectRoot, filePath)}`);
+        if (isCompiling) {
+            pendingCompile = true;
+            return;
+        }
+        isCompiling = true;
+        pendingCompile = false;
+        try {
+            logger.newLine();
+            logger.info('开始重新编译...');
+            await compile(entry);
+            logger.success('重新编译成功！');
+            lastCompileSuccess = true;
+        }
+        catch (error) {
+            logger.error(`重新编译失败：${error.message}`);
+            logger.info('继续使用上次成功的编译结果提供服务');
+            // 不重启 webpack，继续使用旧的 out 目录
+        }
+        finally {
+            isCompiling = false;
+            if (pendingCompile) {
+                // 如果在编译期间有新的文件变化，立即处理
+                setTimeout(() => handleFileChange(filePath), 0);
+            }
+        }
+    };
+    watcher.on('change', handleFileChange);
+    watcher.on('add', handleFileChange);
+    watcher.on('unlink', handleFileChange);
+    // 监听 src 目录本身的创建
+    watcher.on('addDir', async (dirPath) => {
+        // 当 src 目录本身被创建时触发编译
+        if (dirPath === srcDir) {
+            logger.info('检测到 src 目录被创建');
+            if (isCompiling) {
+                pendingCompile = true;
+                return;
+            }
+            isCompiling = true;
+            pendingCompile = false;
+            try {
+                logger.newLine();
+                logger.info('开始编译...');
+                await compile(entry);
+                logger.success('编译成功！');
+                lastCompileSuccess = true;
+            }
+            catch (error) {
+                logger.error(`编译失败：${error.message}`);
+            }
+            finally {
+                isCompiling = false;
+                if (pendingCompile) {
+                    setTimeout(() => handleFileChange(''), 0);
+                }
+            }
+        }
+    });
+    // 监听 out 目录的删除，以便在 out 目录被删除时重新编译
+    const outWatcher = chokidar.watch(outDir, {
+        ignoreInitial: true,
+        persistent: true,
+        depth: 0, // 只监听 out 目录本身，不监听子目录
+    });
+    outWatcher.on('unlinkDir', async (deletedPath) => {
+        if (deletedPath === outDir) {
+            logger.warn('检测到 out 目录被删除');
+            // 检查是否存在 src 目录
+            const hasSrc = libExports.existsSync(srcDir) && libExports.statSync(srcDir).isDirectory();
+            if (hasSrc) {
+                logger.info('检测到 src 目录存在，开始重新编译...');
+                if (isCompiling) {
+                    pendingCompile = true;
+                    return;
+                }
+                isCompiling = true;
+                pendingCompile = false;
+                try {
+                    // 确保 out 目录存在
+                    libExports.ensureDirSync(outDir);
+                    await compile(entry);
+                    logger.success('重新编译成功！out 目录已恢复');
+                    lastCompileSuccess = true;
+                }
+                catch (error) {
+                    logger.error(`重新编译失败：${error.message}`);
+                }
+                finally {
+                    isCompiling = false;
+                    if (pendingCompile) {
+                        setTimeout(() => handleFileChange(''), 0);
+                    }
+                }
+            }
+            else {
+                logger.warn('未检测到 src 目录，无法重新编译');
+            }
+        }
+    });
+    // 处理进程退出
+    const cleanup = () => {
+        if (webpackProcess) {
+            webpackProcess.kill();
+        }
+        watcher.close().catch(() => { });
+        outWatcher.close().catch(() => { });
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
 }
-
 /**
- * 编译命令 - 将 NASL 编译为 Vue 和 JS
+ * 启动 webpack 开发服务器
  */
-async function dev(entry, options) {
-    const logger = options?.logger || defaultLogger;
-    const { outDir } = await compile(entry);
-    logger.newLine();
-    logger.info('正在启动开发服务...');
-    const configRelativePath = path$1.relative(outDir, path$1.resolve(__dirname, '../../build/webpack.config.js'));
+async function startWebpackDevServer(outDir, options, logger) {
+    logger?.newLine();
+    logger?.info('正在启动开发服务...');
+    const configRelativePath = sysPath.relative(outDir, sysPath.resolve(__dirname, '../../build/webpack.config.js'));
     // 构建 webpack-cli 参数
     let webpackArgs = `${require.resolve('.bin/webpack-cli')} serve --config ${configRelativePath}`;
     if (options?.port)
@@ -34485,7 +34673,26 @@ async function dev(entry, options) {
         webpackArgs += ' --open';
     if (options?.hot)
         webpackArgs += ' --hot';
-    await justExecCommandSync(webpackArgs, outDir);
+    // 使用 spawn 而不是 spawnSync，以便进程可以常驻
+    const webpackProcess = spawn(webpackArgs, {
+        shell: true,
+        stdio: 'inherit',
+        cwd: outDir,
+    });
+    webpackProcess.on('error', (error) => {
+        logger?.error(`Webpack 开发服务器启动失败: ${error.message}`);
+        process.exit(1);
+    });
+    return webpackProcess;
+}
+
+function justExecCommandSync(command, cwd) {
+    console.log(command);
+    const result = spawnSync(command, { shell: true, stdio: 'inherit', cwd });
+    if (result.status) {
+        console.error(String(result.stderr || result.stdout));
+        process.exit(1);
+    }
 }
 
 /**
@@ -34496,12 +34703,1677 @@ async function build(entry, options) {
     const { outDir } = await compile(entry);
     logger.newLine();
     logger.info('正在构建项目...');
-    const configRelativePath = path$1.relative(outDir, path$1.resolve(__dirname, '../../build/webpack.config.js'));
+    const configRelativePath = sysPath.relative(outDir, sysPath.resolve(__dirname, '../../build/webpack.config.js'));
     const mode = options?.mode || 'production';
     // 构建 webpack-cli 参数
     let webpackArgs = `${require.resolve('.bin/webpack-cli')} build --config ${configRelativePath} --mode ${mode}`;
     await justExecCommandSync(webpackArgs, outDir);
 }
 
-export { BaseLogger, CONFIG_FILE_NAME, ConsoleLogger, DEFAULT_CONFIG, MemoryLogger, build, check, compile, composeToString, createSorter, defaultLogger, dep, dev, fastLogToFile, init, resolveNASLFiles, scanEntryFiles, scanNASLFiles, sorter, tryCompile };
+const EntryTypes = {
+    FILE_TYPE: 'files',
+    DIR_TYPE: 'directories',
+    FILE_DIR_TYPE: 'files_directories',
+    EVERYTHING_TYPE: 'all',
+};
+const defaultOptions = {
+    root: '.',
+    fileFilter: (_entryInfo) => true,
+    directoryFilter: (_entryInfo) => true,
+    type: EntryTypes.FILE_TYPE,
+    lstat: false,
+    depth: 2147483648,
+    alwaysStat: false,
+    highWaterMark: 4096,
+};
+Object.freeze(defaultOptions);
+const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
+const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);
+const ALL_TYPES = [
+    EntryTypes.DIR_TYPE,
+    EntryTypes.EVERYTHING_TYPE,
+    EntryTypes.FILE_DIR_TYPE,
+    EntryTypes.FILE_TYPE,
+];
+const DIR_TYPES = new Set([
+    EntryTypes.DIR_TYPE,
+    EntryTypes.EVERYTHING_TYPE,
+    EntryTypes.FILE_DIR_TYPE,
+]);
+const FILE_TYPES = new Set([
+    EntryTypes.EVERYTHING_TYPE,
+    EntryTypes.FILE_DIR_TYPE,
+    EntryTypes.FILE_TYPE,
+]);
+const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+const wantBigintFsStats = process.platform === 'win32';
+const emptyFn = (_entryInfo) => true;
+const normalizeFilter = (filter) => {
+    if (filter === undefined)
+        return emptyFn;
+    if (typeof filter === 'function')
+        return filter;
+    if (typeof filter === 'string') {
+        const fl = filter.trim();
+        return (entry) => entry.basename === fl;
+    }
+    if (Array.isArray(filter)) {
+        const trItems = filter.map((item) => item.trim());
+        return (entry) => trItems.some((f) => entry.basename === f);
+    }
+    return emptyFn;
+};
+/** Readable readdir stream, emitting new files as they're being listed. */
+class ReaddirpStream extends Readable$1 {
+    constructor(options = {}) {
+        super({
+            objectMode: true,
+            autoDestroy: true,
+            highWaterMark: options.highWaterMark,
+        });
+        const opts = { ...defaultOptions, ...options };
+        const { root, type } = opts;
+        this._fileFilter = normalizeFilter(opts.fileFilter);
+        this._directoryFilter = normalizeFilter(opts.directoryFilter);
+        const statMethod = opts.lstat ? lstat : stat$1;
+        // Use bigint stats if it's windows and stat() supports options (node 10+).
+        if (wantBigintFsStats) {
+            this._stat = (path) => statMethod(path, { bigint: true });
+        }
+        else {
+            this._stat = statMethod;
+        }
+        this._maxDepth = opts.depth ?? defaultOptions.depth;
+        this._wantsDir = type ? DIR_TYPES.has(type) : false;
+        this._wantsFile = type ? FILE_TYPES.has(type) : false;
+        this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+        this._root = resolve(root);
+        this._isDirent = !opts.alwaysStat;
+        this._statsProp = this._isDirent ? 'dirent' : 'stats';
+        this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
+        // Launch stream with one parent, the root dir.
+        this.parents = [this._exploreDir(root, 1)];
+        this.reading = false;
+        this.parent = undefined;
+    }
+    async _read(batch) {
+        if (this.reading)
+            return;
+        this.reading = true;
+        try {
+            while (!this.destroyed && batch > 0) {
+                const par = this.parent;
+                const fil = par && par.files;
+                if (fil && fil.length > 0) {
+                    const { path, depth } = par;
+                    const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
+                    const awaited = await Promise.all(slice);
+                    for (const entry of awaited) {
+                        if (!entry)
+                            continue;
+                        if (this.destroyed)
+                            return;
+                        const entryType = await this._getEntryType(entry);
+                        if (entryType === 'directory' && this._directoryFilter(entry)) {
+                            if (depth <= this._maxDepth) {
+                                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+                            }
+                            if (this._wantsDir) {
+                                this.push(entry);
+                                batch--;
+                            }
+                        }
+                        else if ((entryType === 'file' || this._includeAsFile(entry)) &&
+                            this._fileFilter(entry)) {
+                            if (this._wantsFile) {
+                                this.push(entry);
+                                batch--;
+                            }
+                        }
+                    }
+                }
+                else {
+                    const parent = this.parents.pop();
+                    if (!parent) {
+                        this.push(null);
+                        break;
+                    }
+                    this.parent = await parent;
+                    if (this.destroyed)
+                        return;
+                }
+            }
+        }
+        catch (error) {
+            this.destroy(error);
+        }
+        finally {
+            this.reading = false;
+        }
+    }
+    async _exploreDir(path, depth) {
+        let files;
+        try {
+            files = await readdir(path, this._rdOptions);
+        }
+        catch (error) {
+            this._onError(error);
+        }
+        return { files, depth, path };
+    }
+    async _formatEntry(dirent, path) {
+        let entry;
+        const basename = this._isDirent ? dirent.name : dirent;
+        try {
+            const fullPath = resolve(join(path, basename));
+            entry = { path: relative(this._root, fullPath), fullPath, basename };
+            entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+        }
+        catch (err) {
+            this._onError(err);
+            return;
+        }
+        return entry;
+    }
+    _onError(err) {
+        if (isNormalFlowError(err) && !this.destroyed) {
+            this.emit('warn', err);
+        }
+        else {
+            this.destroy(err);
+        }
+    }
+    async _getEntryType(entry) {
+        // entry may be undefined, because a warning or an error were emitted
+        // and the statsProp is undefined
+        if (!entry && this._statsProp in entry) {
+            return '';
+        }
+        const stats = entry[this._statsProp];
+        if (stats.isFile())
+            return 'file';
+        if (stats.isDirectory())
+            return 'directory';
+        if (stats && stats.isSymbolicLink()) {
+            const full = entry.fullPath;
+            try {
+                const entryRealPath = await realpath(full);
+                const entryRealPathStats = await lstat(entryRealPath);
+                if (entryRealPathStats.isFile()) {
+                    return 'file';
+                }
+                if (entryRealPathStats.isDirectory()) {
+                    const len = entryRealPath.length;
+                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === sep) {
+                        const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+                        // @ts-ignore
+                        recursiveError.code = RECURSIVE_ERROR_CODE;
+                        return this._onError(recursiveError);
+                    }
+                    return 'directory';
+                }
+            }
+            catch (error) {
+                this._onError(error);
+                return '';
+            }
+        }
+    }
+    _includeAsFile(entry) {
+        const stats = entry && entry[this._statsProp];
+        return stats && this._wantsEverything && !stats.isDirectory();
+    }
+}
+/**
+ * Streaming version: Reads all files and directories in given root recursively.
+ * Consumes ~constant small amount of RAM.
+ * @param root Root directory
+ * @param options Options to specify root (start directory), filters and recursion depth
+ */
+function readdirp(root, options = {}) {
+    // @ts-ignore
+    let type = options.entryType || options.type;
+    if (type === 'both')
+        type = EntryTypes.FILE_DIR_TYPE; // backwards-compatibility
+    if (type)
+        options.type = type;
+    if (!root) {
+        throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
+    }
+    else if (typeof root !== 'string') {
+        throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');
+    }
+    else if (type && !ALL_TYPES.includes(type)) {
+        throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
+    }
+    options.root = root;
+    return new ReaddirpStream(options);
+}
+
+const STR_DATA = 'data';
+const STR_END = 'end';
+const STR_CLOSE = 'close';
+const EMPTY_FN = () => { };
+const pl = process.platform;
+const isWindows = pl === 'win32';
+const isMacos = pl === 'darwin';
+const isLinux = pl === 'linux';
+const isFreeBSD = pl === 'freebsd';
+const isIBMi = type$1() === 'OS400';
+const EVENTS = {
+    ALL: 'all',
+    READY: 'ready',
+    ADD: 'add',
+    CHANGE: 'change',
+    ADD_DIR: 'addDir',
+    UNLINK: 'unlink',
+    UNLINK_DIR: 'unlinkDir',
+    RAW: 'raw',
+    ERROR: 'error',
+};
+const EV = EVENTS;
+const THROTTLE_MODE_WATCH = 'watch';
+const statMethods = { lstat: lstat$1, stat: stat$2 };
+const KEY_LISTENERS = 'listeners';
+const KEY_ERR = 'errHandlers';
+const KEY_RAW = 'rawEmitters';
+const HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+// prettier-ignore
+const binaryExtensions = new Set([
+    '3dm', '3ds', '3g2', '3gp', '7z', 'a', 'aac', 'adp', 'afdesign', 'afphoto', 'afpub', 'ai',
+    'aif', 'aiff', 'alz', 'ape', 'apk', 'appimage', 'ar', 'arj', 'asf', 'au', 'avi',
+    'bak', 'baml', 'bh', 'bin', 'bk', 'bmp', 'btif', 'bz2', 'bzip2',
+    'cab', 'caf', 'cgm', 'class', 'cmx', 'cpio', 'cr2', 'cur', 'dat', 'dcm', 'deb', 'dex', 'djvu',
+    'dll', 'dmg', 'dng', 'doc', 'docm', 'docx', 'dot', 'dotm', 'dra', 'DS_Store', 'dsk', 'dts',
+    'dtshd', 'dvb', 'dwg', 'dxf',
+    'ecelp4800', 'ecelp7470', 'ecelp9600', 'egg', 'eol', 'eot', 'epub', 'exe',
+    'f4v', 'fbs', 'fh', 'fla', 'flac', 'flatpak', 'fli', 'flv', 'fpx', 'fst', 'fvt',
+    'g3', 'gh', 'gif', 'graffle', 'gz', 'gzip',
+    'h261', 'h263', 'h264', 'icns', 'ico', 'ief', 'img', 'ipa', 'iso',
+    'jar', 'jpeg', 'jpg', 'jpgv', 'jpm', 'jxr', 'key', 'ktx',
+    'lha', 'lib', 'lvp', 'lz', 'lzh', 'lzma', 'lzo',
+    'm3u', 'm4a', 'm4v', 'mar', 'mdi', 'mht', 'mid', 'midi', 'mj2', 'mka', 'mkv', 'mmr', 'mng',
+    'mobi', 'mov', 'movie', 'mp3',
+    'mp4', 'mp4a', 'mpeg', 'mpg', 'mpga', 'mxu',
+    'nef', 'npx', 'numbers', 'nupkg',
+    'o', 'odp', 'ods', 'odt', 'oga', 'ogg', 'ogv', 'otf', 'ott',
+    'pages', 'pbm', 'pcx', 'pdb', 'pdf', 'pea', 'pgm', 'pic', 'png', 'pnm', 'pot', 'potm',
+    'potx', 'ppa', 'ppam',
+    'ppm', 'pps', 'ppsm', 'ppsx', 'ppt', 'pptm', 'pptx', 'psd', 'pya', 'pyc', 'pyo', 'pyv',
+    'qt',
+    'rar', 'ras', 'raw', 'resources', 'rgb', 'rip', 'rlc', 'rmf', 'rmvb', 'rpm', 'rtf', 'rz',
+    's3m', 's7z', 'scpt', 'sgi', 'shar', 'snap', 'sil', 'sketch', 'slk', 'smv', 'snk', 'so',
+    'stl', 'suo', 'sub', 'swf',
+    'tar', 'tbz', 'tbz2', 'tga', 'tgz', 'thmx', 'tif', 'tiff', 'tlz', 'ttc', 'ttf', 'txz',
+    'udf', 'uvh', 'uvi', 'uvm', 'uvp', 'uvs', 'uvu',
+    'viv', 'vob',
+    'war', 'wav', 'wax', 'wbmp', 'wdp', 'weba', 'webm', 'webp', 'whl', 'wim', 'wm', 'wma',
+    'wmv', 'wmx', 'woff', 'woff2', 'wrm', 'wvx',
+    'xbm', 'xif', 'xla', 'xlam', 'xls', 'xlsb', 'xlsm', 'xlsx', 'xlt', 'xltm', 'xltx', 'xm',
+    'xmind', 'xpi', 'xpm', 'xwd', 'xz',
+    'z', 'zip', 'zipx',
+]);
+const isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+// TODO: emit errors properly. Example: EMFILE on Macos.
+const foreach = (val, fn) => {
+    if (val instanceof Set) {
+        val.forEach(fn);
+    }
+    else {
+        fn(val);
+    }
+};
+const addAndConvert = (main, prop, item) => {
+    let container = main[prop];
+    if (!(container instanceof Set)) {
+        main[prop] = container = new Set([container]);
+    }
+    container.add(item);
+};
+const clearItem = (cont) => (key) => {
+    const set = cont[key];
+    if (set instanceof Set) {
+        set.clear();
+    }
+    else {
+        delete cont[key];
+    }
+};
+const delFromSet = (main, prop, item) => {
+    const container = main[prop];
+    if (container instanceof Set) {
+        container.delete(item);
+    }
+    else if (container === item) {
+        delete main[prop];
+    }
+};
+const isEmptySet = (val) => (val instanceof Set ? val.size === 0 : !val);
+const FsWatchInstances = new Map();
+/**
+ * Instantiates the fs_watch interface
+ * @param path to be watched
+ * @param options to be passed to fs_watch
+ * @param listener main event handler
+ * @param errHandler emits info about errors
+ * @param emitRaw emits raw event data
+ * @returns {NativeFsWatcher}
+ */
+function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+    const handleEvent = (rawEvent, evPath) => {
+        listener(path);
+        emitRaw(rawEvent, evPath, { watchedPath: path });
+        // emit based on events occurring for files from a directory's watcher in
+        // case the file's watcher misses it (and rely on throttling to de-dupe)
+        if (evPath && path !== evPath) {
+            fsWatchBroadcast(sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath));
+        }
+    };
+    try {
+        return watch$1(path, {
+            persistent: options.persistent,
+        }, handleEvent);
+    }
+    catch (error) {
+        errHandler(error);
+        return undefined;
+    }
+}
+/**
+ * Helper for passing fs_watch event data to a collection of listeners
+ * @param fullPath absolute path bound to fs_watch instance
+ */
+const fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+    const cont = FsWatchInstances.get(fullPath);
+    if (!cont)
+        return;
+    foreach(cont[listenerType], (listener) => {
+        listener(val1, val2, val3);
+    });
+};
+/**
+ * Instantiates the fs_watch interface or binds listeners
+ * to an existing one covering the same file system entry
+ * @param path
+ * @param fullPath absolute path
+ * @param options to be passed to fs_watch
+ * @param handlers container for event listener functions
+ */
+const setFsWatchListener = (path, fullPath, options, handlers) => {
+    const { listener, errHandler, rawEmitter } = handlers;
+    let cont = FsWatchInstances.get(fullPath);
+    let watcher;
+    if (!options.persistent) {
+        watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter);
+        if (!watcher)
+            return;
+        return watcher.close.bind(watcher);
+    }
+    if (cont) {
+        addAndConvert(cont, KEY_LISTENERS, listener);
+        addAndConvert(cont, KEY_ERR, errHandler);
+        addAndConvert(cont, KEY_RAW, rawEmitter);
+    }
+    else {
+        watcher = createFsWatchInstance(path, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, // no need to use broadcast here
+        fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+        if (!watcher)
+            return;
+        watcher.on(EV.ERROR, async (error) => {
+            const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+            if (cont)
+                cont.watcherUnusable = true; // documented since Node 10.4.1
+            // Workaround for https://github.com/joyent/node/issues/4337
+            if (isWindows && error.code === 'EPERM') {
+                try {
+                    const fd = await open(path, 'r');
+                    await fd.close();
+                    broadcastErr(error);
+                }
+                catch (err) {
+                    // do nothing
+                }
+            }
+            else {
+                broadcastErr(error);
+            }
+        });
+        cont = {
+            listeners: listener,
+            errHandlers: errHandler,
+            rawEmitters: rawEmitter,
+            watcher,
+        };
+        FsWatchInstances.set(fullPath, cont);
+    }
+    // const index = cont.listeners.indexOf(listener);
+    // removes this instance's listeners and closes the underlying fs_watch
+    // instance if there are no more listeners left
+    return () => {
+        delFromSet(cont, KEY_LISTENERS, listener);
+        delFromSet(cont, KEY_ERR, errHandler);
+        delFromSet(cont, KEY_RAW, rawEmitter);
+        if (isEmptySet(cont.listeners)) {
+            // Check to protect against issue gh-730.
+            // if (cont.watcherUnusable) {
+            cont.watcher.close();
+            // }
+            FsWatchInstances.delete(fullPath);
+            HANDLER_KEYS.forEach(clearItem(cont));
+            // @ts-ignore
+            cont.watcher = undefined;
+            Object.freeze(cont);
+        }
+    };
+};
+// fs_watchFile helpers
+// object to hold per-process fs_watchFile instances
+// (may be shared across chokidar FSWatcher instances)
+const FsWatchFileInstances = new Map();
+/**
+ * Instantiates the fs_watchFile interface or binds listeners
+ * to an existing one covering the same file system entry
+ * @param path to be watched
+ * @param fullPath absolute path
+ * @param options options to be passed to fs_watchFile
+ * @param handlers container for event listener functions
+ * @returns closer
+ */
+const setFsWatchFileListener = (path, fullPath, options, handlers) => {
+    const { listener, rawEmitter } = handlers;
+    let cont = FsWatchFileInstances.get(fullPath);
+    // let listeners = new Set();
+    // let rawEmitters = new Set();
+    const copts = cont && cont.options;
+    if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+        // "Upgrade" the watcher to persistence or a quicker interval.
+        // This creates some unlikely edge case issues if the user mixes
+        // settings in a very weird way, but solving for those cases
+        // doesn't seem worthwhile for the added complexity.
+        // listeners = cont.listeners;
+        // rawEmitters = cont.rawEmitters;
+        unwatchFile(fullPath);
+        cont = undefined;
+    }
+    if (cont) {
+        addAndConvert(cont, KEY_LISTENERS, listener);
+        addAndConvert(cont, KEY_RAW, rawEmitter);
+    }
+    else {
+        // TODO
+        // listeners.add(listener);
+        // rawEmitters.add(rawEmitter);
+        cont = {
+            listeners: listener,
+            rawEmitters: rawEmitter,
+            options,
+            watcher: watchFile(fullPath, options, (curr, prev) => {
+                foreach(cont.rawEmitters, (rawEmitter) => {
+                    rawEmitter(EV.CHANGE, fullPath, { curr, prev });
+                });
+                const currmtime = curr.mtimeMs;
+                if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+                    foreach(cont.listeners, (listener) => listener(path, curr));
+                }
+            }),
+        };
+        FsWatchFileInstances.set(fullPath, cont);
+    }
+    // const index = cont.listeners.indexOf(listener);
+    // Removes this instance's listeners and closes the underlying fs_watchFile
+    // instance if there are no more listeners left.
+    return () => {
+        delFromSet(cont, KEY_LISTENERS, listener);
+        delFromSet(cont, KEY_RAW, rawEmitter);
+        if (isEmptySet(cont.listeners)) {
+            FsWatchFileInstances.delete(fullPath);
+            unwatchFile(fullPath);
+            cont.options = cont.watcher = undefined;
+            Object.freeze(cont);
+        }
+    };
+};
+/**
+ * @mixin
+ */
+class NodeFsHandler {
+    constructor(fsW) {
+        this.fsw = fsW;
+        this._boundHandleError = (error) => fsW._handleError(error);
+    }
+    /**
+     * Watch file for changes with fs_watchFile or fs_watch.
+     * @param path to file or dir
+     * @param listener on fs change
+     * @returns closer for the watcher instance
+     */
+    _watchWithNodeFs(path, listener) {
+        const opts = this.fsw.options;
+        const directory = sysPath.dirname(path);
+        const basename = sysPath.basename(path);
+        const parent = this.fsw._getWatchedDir(directory);
+        parent.add(basename);
+        const absolutePath = sysPath.resolve(path);
+        const options = {
+            persistent: opts.persistent,
+        };
+        if (!listener)
+            listener = EMPTY_FN;
+        let closer;
+        if (opts.usePolling) {
+            const enableBin = opts.interval !== opts.binaryInterval;
+            options.interval = enableBin && isBinaryPath(basename) ? opts.binaryInterval : opts.interval;
+            closer = setFsWatchFileListener(path, absolutePath, options, {
+                listener,
+                rawEmitter: this.fsw._emitRaw,
+            });
+        }
+        else {
+            closer = setFsWatchListener(path, absolutePath, options, {
+                listener,
+                errHandler: this._boundHandleError,
+                rawEmitter: this.fsw._emitRaw,
+            });
+        }
+        return closer;
+    }
+    /**
+     * Watch a file and emit add event if warranted.
+     * @returns closer for the watcher instance
+     */
+    _handleFile(file, stats, initialAdd) {
+        if (this.fsw.closed) {
+            return;
+        }
+        const dirname = sysPath.dirname(file);
+        const basename = sysPath.basename(file);
+        const parent = this.fsw._getWatchedDir(dirname);
+        // stats is always present
+        let prevStats = stats;
+        // if the file is already being watched, do nothing
+        if (parent.has(basename))
+            return;
+        const listener = async (path, newStats) => {
+            if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+                return;
+            if (!newStats || newStats.mtimeMs === 0) {
+                try {
+                    const newStats = await stat$2(file);
+                    if (this.fsw.closed)
+                        return;
+                    // Check that change event was not fired because of changed only accessTime.
+                    const at = newStats.atimeMs;
+                    const mt = newStats.mtimeMs;
+                    if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+                        this.fsw._emit(EV.CHANGE, file, newStats);
+                    }
+                    if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats.ino) {
+                        this.fsw._closeFile(path);
+                        prevStats = newStats;
+                        const closer = this._watchWithNodeFs(file, listener);
+                        if (closer)
+                            this.fsw._addPathCloser(path, closer);
+                    }
+                    else {
+                        prevStats = newStats;
+                    }
+                }
+                catch (error) {
+                    // Fix issues where mtime is null but file is still present
+                    this.fsw._remove(dirname, basename);
+                }
+                // add is about to be emitted if file not already tracked in parent
+            }
+            else if (parent.has(basename)) {
+                // Check that change event was not fired because of changed only accessTime.
+                const at = newStats.atimeMs;
+                const mt = newStats.mtimeMs;
+                if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+                    this.fsw._emit(EV.CHANGE, file, newStats);
+                }
+                prevStats = newStats;
+            }
+        };
+        // kick off the watcher
+        const closer = this._watchWithNodeFs(file, listener);
+        // emit an add event if we're supposed to
+        if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+            if (!this.fsw._throttle(EV.ADD, file, 0))
+                return;
+            this.fsw._emit(EV.ADD, file, stats);
+        }
+        return closer;
+    }
+    /**
+     * Handle symlinks encountered while reading a dir.
+     * @param entry returned by readdirp
+     * @param directory path of dir being read
+     * @param path of this item
+     * @param item basename of this item
+     * @returns true if no more processing is needed for this entry.
+     */
+    async _handleSymlink(entry, directory, path, item) {
+        if (this.fsw.closed) {
+            return;
+        }
+        const full = entry.fullPath;
+        const dir = this.fsw._getWatchedDir(directory);
+        if (!this.fsw.options.followSymlinks) {
+            // watch symlink directly (don't follow) and detect changes
+            this.fsw._incrReadyCount();
+            let linkPath;
+            try {
+                linkPath = await realpath$1(path);
+            }
+            catch (e) {
+                this.fsw._emitReady();
+                return true;
+            }
+            if (this.fsw.closed)
+                return;
+            if (dir.has(item)) {
+                if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+                    this.fsw._symlinkPaths.set(full, linkPath);
+                    this.fsw._emit(EV.CHANGE, path, entry.stats);
+                }
+            }
+            else {
+                dir.add(item);
+                this.fsw._symlinkPaths.set(full, linkPath);
+                this.fsw._emit(EV.ADD, path, entry.stats);
+            }
+            this.fsw._emitReady();
+            return true;
+        }
+        // don't follow the same symlink more than once
+        if (this.fsw._symlinkPaths.has(full)) {
+            return true;
+        }
+        this.fsw._symlinkPaths.set(full, true);
+    }
+    _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+        // Normalize the directory name on Windows
+        directory = sysPath.join(directory, '');
+        throttler = this.fsw._throttle('readdir', directory, 1000);
+        if (!throttler)
+            return;
+        const previous = this.fsw._getWatchedDir(wh.path);
+        const current = new Set();
+        let stream = this.fsw._readdirp(directory, {
+            fileFilter: (entry) => wh.filterPath(entry),
+            directoryFilter: (entry) => wh.filterDir(entry),
+        });
+        if (!stream)
+            return;
+        stream
+            .on(STR_DATA, async (entry) => {
+            if (this.fsw.closed) {
+                stream = undefined;
+                return;
+            }
+            const item = entry.path;
+            let path = sysPath.join(directory, item);
+            current.add(item);
+            if (entry.stats.isSymbolicLink() &&
+                (await this._handleSymlink(entry, directory, path, item))) {
+                return;
+            }
+            if (this.fsw.closed) {
+                stream = undefined;
+                return;
+            }
+            // Files that present in current directory snapshot
+            // but absent in previous are added to watch list and
+            // emit `add` event.
+            if (item === target || (!target && !previous.has(item))) {
+                this.fsw._incrReadyCount();
+                // ensure relativeness of path is preserved in case of watcher reuse
+                path = sysPath.join(dir, sysPath.relative(dir, path));
+                this._addToNodeFs(path, initialAdd, wh, depth + 1);
+            }
+        })
+            .on(EV.ERROR, this._boundHandleError);
+        return new Promise((resolve, reject) => {
+            if (!stream)
+                return reject();
+            stream.once(STR_END, () => {
+                if (this.fsw.closed) {
+                    stream = undefined;
+                    return;
+                }
+                const wasThrottled = throttler ? throttler.clear() : false;
+                resolve(undefined);
+                // Files that absent in current directory snapshot
+                // but present in previous emit `remove` event
+                // and are removed from @watched[directory].
+                previous
+                    .getChildren()
+                    .filter((item) => {
+                    return item !== directory && !current.has(item);
+                })
+                    .forEach((item) => {
+                    this.fsw._remove(directory, item);
+                });
+                stream = undefined;
+                // one more time for any missed in case changes came in extremely quickly
+                if (wasThrottled)
+                    this._handleRead(directory, false, wh, target, dir, depth, throttler);
+            });
+        });
+    }
+    /**
+     * Read directory to add / remove files from `@watched` list and re-read it on change.
+     * @param dir fs path
+     * @param stats
+     * @param initialAdd
+     * @param depth relative to user-supplied path
+     * @param target child path targeted for watch
+     * @param wh Common watch helpers for this path
+     * @param realpath
+     * @returns closer for the watcher instance.
+     */
+    async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
+        const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
+        const tracked = parentDir.has(sysPath.basename(dir));
+        if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+            this.fsw._emit(EV.ADD_DIR, dir, stats);
+        }
+        // ensure dir is tracked (harmless if redundant)
+        parentDir.add(sysPath.basename(dir));
+        this.fsw._getWatchedDir(dir);
+        let throttler;
+        let closer;
+        const oDepth = this.fsw.options.depth;
+        if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
+            if (!target) {
+                await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+                if (this.fsw.closed)
+                    return;
+            }
+            closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
+                // if current directory is removed, do nothing
+                if (stats && stats.mtimeMs === 0)
+                    return;
+                this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+            });
+        }
+        return closer;
+    }
+    /**
+     * Handle added file, directory, or glob pattern.
+     * Delegates call to _handleFile / _handleDir after checks.
+     * @param path to file or ir
+     * @param initialAdd was the file added at watch instantiation?
+     * @param priorWh depth relative to user-supplied path
+     * @param depth Child path actually targeted for watch
+     * @param target Child path actually targeted for watch
+     */
+    async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+        const ready = this.fsw._emitReady;
+        if (this.fsw._isIgnored(path) || this.fsw.closed) {
+            ready();
+            return false;
+        }
+        const wh = this.fsw._getWatchHelpers(path);
+        if (priorWh) {
+            wh.filterPath = (entry) => priorWh.filterPath(entry);
+            wh.filterDir = (entry) => priorWh.filterDir(entry);
+        }
+        // evaluate what is at the path we're being asked to watch
+        try {
+            const stats = await statMethods[wh.statMethod](wh.watchPath);
+            if (this.fsw.closed)
+                return;
+            if (this.fsw._isIgnored(wh.watchPath, stats)) {
+                ready();
+                return false;
+            }
+            const follow = this.fsw.options.followSymlinks;
+            let closer;
+            if (stats.isDirectory()) {
+                const absPath = sysPath.resolve(path);
+                const targetPath = follow ? await realpath$1(path) : path;
+                if (this.fsw.closed)
+                    return;
+                closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+                if (this.fsw.closed)
+                    return;
+                // preserve this symlink's target path
+                if (absPath !== targetPath && targetPath !== undefined) {
+                    this.fsw._symlinkPaths.set(absPath, targetPath);
+                }
+            }
+            else if (stats.isSymbolicLink()) {
+                const targetPath = follow ? await realpath$1(path) : path;
+                if (this.fsw.closed)
+                    return;
+                const parent = sysPath.dirname(wh.watchPath);
+                this.fsw._getWatchedDir(parent).add(wh.watchPath);
+                this.fsw._emit(EV.ADD, wh.watchPath, stats);
+                closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+                if (this.fsw.closed)
+                    return;
+                // preserve this symlink's target path
+                if (targetPath !== undefined) {
+                    this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+                }
+            }
+            else {
+                closer = this._handleFile(wh.watchPath, stats, initialAdd);
+            }
+            ready();
+            if (closer)
+                this.fsw._addPathCloser(path, closer);
+            return false;
+        }
+        catch (error) {
+            if (this.fsw._handleError(error)) {
+                ready();
+                return path;
+            }
+        }
+    }
+}
+
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+const SLASH = '/';
+const SLASH_SLASH = '//';
+const ONE_DOT = '.';
+const TWO_DOTS = '..';
+const STRING_TYPE = 'string';
+const BACK_SLASH_RE = /\\/g;
+const DOUBLE_SLASH_RE = /\/\//;
+const DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+const REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+    return Array.isArray(item) ? item : [item];
+}
+const isMatcherObject = (matcher) => typeof matcher === 'object' && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+    if (typeof matcher === 'function')
+        return matcher;
+    if (typeof matcher === 'string')
+        return (string) => matcher === string;
+    if (matcher instanceof RegExp)
+        return (string) => matcher.test(string);
+    if (typeof matcher === 'object' && matcher !== null) {
+        return (string) => {
+            if (matcher.path === string)
+                return true;
+            if (matcher.recursive) {
+                const relative = sysPath.relative(matcher.path, string);
+                if (!relative) {
+                    return false;
+                }
+                return !relative.startsWith('..') && !sysPath.isAbsolute(relative);
+            }
+            return false;
+        };
+    }
+    return () => false;
+}
+function normalizePath(path) {
+    if (typeof path !== 'string')
+        throw new Error('string expected');
+    path = sysPath.normalize(path);
+    path = path.replace(/\\/g, '/');
+    let prepend = false;
+    if (path.startsWith('//'))
+        prepend = true;
+    const DOUBLE_SLASH_RE = /\/\//;
+    while (path.match(DOUBLE_SLASH_RE))
+        path = path.replace(DOUBLE_SLASH_RE, '/');
+    if (prepend)
+        path = '/' + path;
+    return path;
+}
+function matchPatterns(patterns, testString, stats) {
+    const path = normalizePath(testString);
+    for (let index = 0; index < patterns.length; index++) {
+        const pattern = patterns[index];
+        if (pattern(path, stats)) {
+            return true;
+        }
+    }
+    return false;
+}
+function anymatch(matchers, testString) {
+    if (matchers == null) {
+        throw new TypeError('anymatch: specify first argument');
+    }
+    // Early cache for matchers.
+    const matchersArray = arrify(matchers);
+    const patterns = matchersArray.map((matcher) => createPattern(matcher));
+    {
+        return (testString, stats) => {
+            return matchPatterns(patterns, testString, stats);
+        };
+    }
+}
+const unifyPaths = (paths_) => {
+    const paths = arrify(paths_).flat();
+    if (!paths.every((p) => typeof p === STRING_TYPE)) {
+        throw new TypeError(`Non-string provided as watch path: ${paths}`);
+    }
+    return paths.map(normalizePathToUnix);
+};
+// If SLASH_SLASH occurs at the beginning of path, it is not replaced
+//     because "//StoragePC/DrivePool/Movies" is a valid network path
+const toUnix = (string) => {
+    let str = string.replace(BACK_SLASH_RE, SLASH);
+    let prepend = false;
+    if (str.startsWith(SLASH_SLASH)) {
+        prepend = true;
+    }
+    while (str.match(DOUBLE_SLASH_RE)) {
+        str = str.replace(DOUBLE_SLASH_RE, SLASH);
+    }
+    if (prepend) {
+        str = SLASH + str;
+    }
+    return str;
+};
+// Our version of upath.normalize
+// TODO: this is not equal to path-normalize module - investigate why
+const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
+// TODO: refactor
+const normalizeIgnored = (cwd = '') => (path) => {
+    if (typeof path === 'string') {
+        return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
+    }
+    else {
+        return path;
+    }
+};
+const getAbsolutePath = (path, cwd) => {
+    if (sysPath.isAbsolute(path)) {
+        return path;
+    }
+    return sysPath.join(cwd, path);
+};
+const EMPTY_SET = Object.freeze(new Set());
+/**
+ * Directory entry.
+ */
+class DirEntry {
+    constructor(dir, removeWatcher) {
+        this.path = dir;
+        this._removeWatcher = removeWatcher;
+        this.items = new Set();
+    }
+    add(item) {
+        const { items } = this;
+        if (!items)
+            return;
+        if (item !== ONE_DOT && item !== TWO_DOTS)
+            items.add(item);
+    }
+    async remove(item) {
+        const { items } = this;
+        if (!items)
+            return;
+        items.delete(item);
+        if (items.size > 0)
+            return;
+        const dir = this.path;
+        try {
+            await readdir$1(dir);
+        }
+        catch (err) {
+            if (this._removeWatcher) {
+                this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
+            }
+        }
+    }
+    has(item) {
+        const { items } = this;
+        if (!items)
+            return;
+        return items.has(item);
+    }
+    getChildren() {
+        const { items } = this;
+        if (!items)
+            return [];
+        return [...items.values()];
+    }
+    dispose() {
+        this.items.clear();
+        this.path = '';
+        this._removeWatcher = EMPTY_FN;
+        this.items = EMPTY_SET;
+        Object.freeze(this);
+    }
+}
+const STAT_METHOD_F = 'stat';
+const STAT_METHOD_L = 'lstat';
+class WatchHelper {
+    constructor(path, follow, fsw) {
+        this.fsw = fsw;
+        const watchPath = path;
+        this.path = path = path.replace(REPLACER_RE, '');
+        this.watchPath = watchPath;
+        this.fullWatchPath = sysPath.resolve(watchPath);
+        this.dirParts = [];
+        this.dirParts.forEach((parts) => {
+            if (parts.length > 1)
+                parts.pop();
+        });
+        this.followSymlinks = follow;
+        this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+    }
+    entryPath(entry) {
+        return sysPath.join(this.watchPath, sysPath.relative(this.watchPath, entry.fullPath));
+    }
+    filterPath(entry) {
+        const { stats } = entry;
+        if (stats && stats.isSymbolicLink())
+            return this.filterDir(entry);
+        const resolvedPath = this.entryPath(entry);
+        // TODO: what if stats is undefined? remove !
+        return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+    }
+    filterDir(entry) {
+        return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+    }
+}
+/**
+ * Watches files & directories for changes. Emitted events:
+ * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+ *
+ *     new FSWatcher()
+ *       .add(directories)
+ *       .on('add', path => log('File', path, 'was added'))
+ */
+class FSWatcher extends EventEmitter {
+    // Not indenting methods for history sake; for now.
+    constructor(_opts = {}) {
+        super();
+        this.closed = false;
+        this._closers = new Map();
+        this._ignoredPaths = new Set();
+        this._throttled = new Map();
+        this._streams = new Set();
+        this._symlinkPaths = new Map();
+        this._watched = new Map();
+        this._pendingWrites = new Map();
+        this._pendingUnlinks = new Map();
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        const awf = _opts.awaitWriteFinish;
+        const DEF_AWF = { stabilityThreshold: 2000, pollInterval: 100 };
+        const opts = {
+            // Defaults
+            persistent: true,
+            ignoreInitial: false,
+            ignorePermissionErrors: false,
+            interval: 100,
+            binaryInterval: 300,
+            followSymlinks: true,
+            usePolling: false,
+            // useAsync: false,
+            atomic: true, // NOTE: overwritten later (depends on usePolling)
+            ..._opts,
+            // Change format
+            ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+            awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === 'object' ? { ...DEF_AWF, ...awf } : false,
+        };
+        // Always default to polling on IBM i because fs.watch() is not available on IBM i.
+        if (isIBMi)
+            opts.usePolling = true;
+        // Editor atomic write normalization enabled by default with fs.watch
+        if (opts.atomic === undefined)
+            opts.atomic = !opts.usePolling;
+        // opts.atomic = typeof _opts.atomic === 'number' ? _opts.atomic : 100;
+        // Global override. Useful for developers, who need to force polling for all
+        // instances of chokidar, regardless of usage / dependency depth
+        const envPoll = process.env.CHOKIDAR_USEPOLLING;
+        if (envPoll !== undefined) {
+            const envLower = envPoll.toLowerCase();
+            if (envLower === 'false' || envLower === '0')
+                opts.usePolling = false;
+            else if (envLower === 'true' || envLower === '1')
+                opts.usePolling = true;
+            else
+                opts.usePolling = !!envLower;
+        }
+        const envInterval = process.env.CHOKIDAR_INTERVAL;
+        if (envInterval)
+            opts.interval = Number.parseInt(envInterval, 10);
+        // This is done to emit ready only once, but each 'add' will increase that?
+        let readyCalls = 0;
+        this._emitReady = () => {
+            readyCalls++;
+            if (readyCalls >= this._readyCount) {
+                this._emitReady = EMPTY_FN;
+                this._readyEmitted = true;
+                // use process.nextTick to allow time for listener to be bound
+                process.nextTick(() => this.emit(EVENTS.READY));
+            }
+        };
+        this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+        this._boundRemove = this._remove.bind(this);
+        this.options = opts;
+        this._nodeFsHandler = new NodeFsHandler(this);
+        // You’re frozen when your heart’s not open.
+        Object.freeze(opts);
+    }
+    _addIgnoredPath(matcher) {
+        if (isMatcherObject(matcher)) {
+            // return early if we already have a deeply equal matcher object
+            for (const ignored of this._ignoredPaths) {
+                if (isMatcherObject(ignored) &&
+                    ignored.path === matcher.path &&
+                    ignored.recursive === matcher.recursive) {
+                    return;
+                }
+            }
+        }
+        this._ignoredPaths.add(matcher);
+    }
+    _removeIgnoredPath(matcher) {
+        this._ignoredPaths.delete(matcher);
+        // now find any matcher objects with the matcher as path
+        if (typeof matcher === 'string') {
+            for (const ignored of this._ignoredPaths) {
+                // TODO (43081j): make this more efficient.
+                // probably just make a `this._ignoredDirectories` or some
+                // such thing.
+                if (isMatcherObject(ignored) && ignored.path === matcher) {
+                    this._ignoredPaths.delete(ignored);
+                }
+            }
+        }
+    }
+    // Public methods
+    /**
+     * Adds paths to be watched on an existing FSWatcher instance.
+     * @param paths_ file or file list. Other arguments are unused
+     */
+    add(paths_, _origAdd, _internal) {
+        const { cwd } = this.options;
+        this.closed = false;
+        this._closePromise = undefined;
+        let paths = unifyPaths(paths_);
+        if (cwd) {
+            paths = paths.map((path) => {
+                const absPath = getAbsolutePath(path, cwd);
+                // Check `path` instead of `absPath` because the cwd portion can't be a glob
+                return absPath;
+            });
+        }
+        paths.forEach((path) => {
+            this._removeIgnoredPath(path);
+        });
+        this._userIgnored = undefined;
+        if (!this._readyCount)
+            this._readyCount = 0;
+        this._readyCount += paths.length;
+        Promise.all(paths.map(async (path) => {
+            const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, undefined, 0, _origAdd);
+            if (res)
+                this._emitReady();
+            return res;
+        })).then((results) => {
+            if (this.closed)
+                return;
+            results.forEach((item) => {
+                if (item)
+                    this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
+            });
+        });
+        return this;
+    }
+    /**
+     * Close watchers or start ignoring events from specified paths.
+     */
+    unwatch(paths_) {
+        if (this.closed)
+            return this;
+        const paths = unifyPaths(paths_);
+        const { cwd } = this.options;
+        paths.forEach((path) => {
+            // convert to absolute path unless relative path already matches
+            if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
+                if (cwd)
+                    path = sysPath.join(cwd, path);
+                path = sysPath.resolve(path);
+            }
+            this._closePath(path);
+            this._addIgnoredPath(path);
+            if (this._watched.has(path)) {
+                this._addIgnoredPath({
+                    path,
+                    recursive: true,
+                });
+            }
+            // reset the cached userIgnored anymatch fn
+            // to make ignoredPaths changes effective
+            this._userIgnored = undefined;
+        });
+        return this;
+    }
+    /**
+     * Close watchers and remove all listeners from watched paths.
+     */
+    close() {
+        if (this._closePromise) {
+            return this._closePromise;
+        }
+        this.closed = true;
+        // Memory management.
+        this.removeAllListeners();
+        const closers = [];
+        this._closers.forEach((closerList) => closerList.forEach((closer) => {
+            const promise = closer();
+            if (promise instanceof Promise)
+                closers.push(promise);
+        }));
+        this._streams.forEach((stream) => stream.destroy());
+        this._userIgnored = undefined;
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        this._watched.forEach((dirent) => dirent.dispose());
+        this._closers.clear();
+        this._watched.clear();
+        this._streams.clear();
+        this._symlinkPaths.clear();
+        this._throttled.clear();
+        this._closePromise = closers.length
+            ? Promise.all(closers).then(() => undefined)
+            : Promise.resolve();
+        return this._closePromise;
+    }
+    /**
+     * Expose list of watched paths
+     * @returns for chaining
+     */
+    getWatched() {
+        const watchList = {};
+        this._watched.forEach((entry, dir) => {
+            const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir;
+            const index = key || ONE_DOT;
+            watchList[index] = entry.getChildren().sort();
+        });
+        return watchList;
+    }
+    emitWithAll(event, args) {
+        this.emit(event, ...args);
+        if (event !== EVENTS.ERROR)
+            this.emit(EVENTS.ALL, event, ...args);
+    }
+    // Common helpers
+    // --------------
+    /**
+     * Normalize and emit events.
+     * Calling _emit DOES NOT MEAN emit() would be called!
+     * @param event Type of event
+     * @param path File or directory path
+     * @param stats arguments to be passed with event
+     * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    async _emit(event, path, stats) {
+        if (this.closed)
+            return;
+        const opts = this.options;
+        if (isWindows)
+            path = sysPath.normalize(path);
+        if (opts.cwd)
+            path = sysPath.relative(opts.cwd, path);
+        const args = [path];
+        if (stats != null)
+            args.push(stats);
+        const awf = opts.awaitWriteFinish;
+        let pw;
+        if (awf && (pw = this._pendingWrites.get(path))) {
+            pw.lastChange = new Date();
+            return this;
+        }
+        if (opts.atomic) {
+            if (event === EVENTS.UNLINK) {
+                this._pendingUnlinks.set(path, [event, ...args]);
+                setTimeout(() => {
+                    this._pendingUnlinks.forEach((entry, path) => {
+                        this.emit(...entry);
+                        this.emit(EVENTS.ALL, ...entry);
+                        this._pendingUnlinks.delete(path);
+                    });
+                }, typeof opts.atomic === 'number' ? opts.atomic : 100);
+                return this;
+            }
+            if (event === EVENTS.ADD && this._pendingUnlinks.has(path)) {
+                event = EVENTS.CHANGE;
+                this._pendingUnlinks.delete(path);
+            }
+        }
+        if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+            const awfEmit = (err, stats) => {
+                if (err) {
+                    event = EVENTS.ERROR;
+                    args[0] = err;
+                    this.emitWithAll(event, args);
+                }
+                else if (stats) {
+                    // if stats doesn't exist the file must have been deleted
+                    if (args.length > 1) {
+                        args[1] = stats;
+                    }
+                    else {
+                        args.push(stats);
+                    }
+                    this.emitWithAll(event, args);
+                }
+            };
+            this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+            return this;
+        }
+        if (event === EVENTS.CHANGE) {
+            const isThrottled = !this._throttle(EVENTS.CHANGE, path, 50);
+            if (isThrottled)
+                return this;
+        }
+        if (opts.alwaysStat &&
+            stats === undefined &&
+            (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+            const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
+            let stats;
+            try {
+                stats = await stat$2(fullPath);
+            }
+            catch (err) {
+                // do nothing
+            }
+            // Suppress event when fs_stat fails, to avoid sending undefined 'stat'
+            if (!stats || this.closed)
+                return;
+            args.push(stats);
+        }
+        this.emitWithAll(event, args);
+        return this;
+    }
+    /**
+     * Common handler for errors
+     * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    _handleError(error) {
+        const code = error && error.code;
+        if (error &&
+            code !== 'ENOENT' &&
+            code !== 'ENOTDIR' &&
+            (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))) {
+            this.emit(EVENTS.ERROR, error);
+        }
+        return error || this.closed;
+    }
+    /**
+     * Helper utility for throttling
+     * @param actionType type being throttled
+     * @param path being acted upon
+     * @param timeout duration of time to suppress duplicate actions
+     * @returns tracking object or false if action should be suppressed
+     */
+    _throttle(actionType, path, timeout) {
+        if (!this._throttled.has(actionType)) {
+            this._throttled.set(actionType, new Map());
+        }
+        const action = this._throttled.get(actionType);
+        if (!action)
+            throw new Error('invalid throttle');
+        const actionPath = action.get(path);
+        if (actionPath) {
+            actionPath.count++;
+            return false;
+        }
+        // eslint-disable-next-line prefer-const
+        let timeoutObject;
+        const clear = () => {
+            const item = action.get(path);
+            const count = item ? item.count : 0;
+            action.delete(path);
+            clearTimeout(timeoutObject);
+            if (item)
+                clearTimeout(item.timeoutObject);
+            return count;
+        };
+        timeoutObject = setTimeout(clear, timeout);
+        const thr = { timeoutObject, clear, count: 0 };
+        action.set(path, thr);
+        return thr;
+    }
+    _incrReadyCount() {
+        return this._readyCount++;
+    }
+    /**
+     * Awaits write operation to finish.
+     * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+     * @param path being acted upon
+     * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+     * @param event
+     * @param awfEmit Callback to be called when ready for event to be emitted.
+     */
+    _awaitWriteFinish(path, threshold, event, awfEmit) {
+        const awf = this.options.awaitWriteFinish;
+        if (typeof awf !== 'object')
+            return;
+        const pollInterval = awf.pollInterval;
+        let timeoutHandler;
+        let fullPath = path;
+        if (this.options.cwd && !sysPath.isAbsolute(path)) {
+            fullPath = sysPath.join(this.options.cwd, path);
+        }
+        const now = new Date();
+        const writes = this._pendingWrites;
+        function awaitWriteFinishFn(prevStat) {
+            stat$3(fullPath, (err, curStat) => {
+                if (err || !writes.has(path)) {
+                    if (err && err.code !== 'ENOENT')
+                        awfEmit(err);
+                    return;
+                }
+                const now = Number(new Date());
+                if (prevStat && curStat.size !== prevStat.size) {
+                    writes.get(path).lastChange = now;
+                }
+                const pw = writes.get(path);
+                const df = now - pw.lastChange;
+                if (df >= threshold) {
+                    writes.delete(path);
+                    awfEmit(undefined, curStat);
+                }
+                else {
+                    timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+                }
+            });
+        }
+        if (!writes.has(path)) {
+            writes.set(path, {
+                lastChange: now,
+                cancelWait: () => {
+                    writes.delete(path);
+                    clearTimeout(timeoutHandler);
+                    return event;
+                },
+            });
+            timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+        }
+    }
+    /**
+     * Determines whether user has asked to ignore this path.
+     */
+    _isIgnored(path, stats) {
+        if (this.options.atomic && DOT_RE.test(path))
+            return true;
+        if (!this._userIgnored) {
+            const { cwd } = this.options;
+            const ign = this.options.ignored;
+            const ignored = (ign || []).map(normalizeIgnored(cwd));
+            const ignoredPaths = [...this._ignoredPaths];
+            const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+            this._userIgnored = anymatch(list);
+        }
+        return this._userIgnored(path, stats);
+    }
+    _isntIgnored(path, stat) {
+        return !this._isIgnored(path, stat);
+    }
+    /**
+     * Provides a set of common helpers and properties relating to symlink handling.
+     * @param path file or directory pattern being watched
+     */
+    _getWatchHelpers(path) {
+        return new WatchHelper(path, this.options.followSymlinks, this);
+    }
+    // Directory helpers
+    // -----------------
+    /**
+     * Provides directory tracking objects
+     * @param directory path of the directory
+     */
+    _getWatchedDir(directory) {
+        const dir = sysPath.resolve(directory);
+        if (!this._watched.has(dir))
+            this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+        return this._watched.get(dir);
+    }
+    // File helpers
+    // ------------
+    /**
+     * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+     */
+    _hasReadPermissions(stats) {
+        if (this.options.ignorePermissionErrors)
+            return true;
+        return Boolean(Number(stats.mode) & 0o400);
+    }
+    /**
+     * Handles emitting unlink events for
+     * files and directories, and via recursion, for
+     * files and directories within directories that are unlinked
+     * @param directory within which the following item is located
+     * @param item      base path of item/directory
+     */
+    _remove(directory, item, isDirectory) {
+        // if what is being deleted is a directory, get that directory's paths
+        // for recursive deleting and cleaning of watched object
+        // if it is not a directory, nestedDirectoryChildren will be empty array
+        const path = sysPath.join(directory, item);
+        const fullPath = sysPath.resolve(path);
+        isDirectory =
+            isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
+        // prevent duplicate handling in case of arriving here nearly simultaneously
+        // via multiple paths (such as _handleFile and _handleDir)
+        if (!this._throttle('remove', path, 100))
+            return;
+        // if the only watched file is removed, watch for its return
+        if (!isDirectory && this._watched.size === 1) {
+            this.add(directory, item, true);
+        }
+        // This will create a new entry in the watched object in either case
+        // so we got to do the directory check beforehand
+        const wp = this._getWatchedDir(path);
+        const nestedDirectoryChildren = wp.getChildren();
+        // Recursively remove children directories / files.
+        nestedDirectoryChildren.forEach((nested) => this._remove(path, nested));
+        // Check if item was on the watched list and remove it
+        const parent = this._getWatchedDir(directory);
+        const wasTracked = parent.has(item);
+        parent.remove(item);
+        // Fixes issue #1042 -> Relative paths were detected and added as symlinks
+        // (https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L612),
+        // but never removed from the map in case the path was deleted.
+        // This leads to an incorrect state if the path was recreated:
+        // https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L553
+        if (this._symlinkPaths.has(fullPath)) {
+            this._symlinkPaths.delete(fullPath);
+        }
+        // If we wait for this file to be fully written, cancel the wait.
+        let relPath = path;
+        if (this.options.cwd)
+            relPath = sysPath.relative(this.options.cwd, path);
+        if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+            const event = this._pendingWrites.get(relPath).cancelWait();
+            if (event === EVENTS.ADD)
+                return;
+        }
+        // The Entry will either be a directory that just got removed
+        // or a bogus entry to a file, in either case we have to remove it
+        this._watched.delete(path);
+        this._watched.delete(fullPath);
+        const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+        if (wasTracked && !this._isIgnored(path))
+            this._emit(eventName, path);
+        // Avoid conflicts if we later create another file with the same name
+        this._closePath(path);
+    }
+    /**
+     * Closes all watchers for a path
+     */
+    _closePath(path) {
+        this._closeFile(path);
+        const dir = sysPath.dirname(path);
+        this._getWatchedDir(dir).remove(sysPath.basename(path));
+    }
+    /**
+     * Closes only file-specific watchers
+     */
+    _closeFile(path) {
+        const closers = this._closers.get(path);
+        if (!closers)
+            return;
+        closers.forEach((closer) => closer());
+        this._closers.delete(path);
+    }
+    _addPathCloser(path, closer) {
+        if (!closer)
+            return;
+        let list = this._closers.get(path);
+        if (!list) {
+            list = [];
+            this._closers.set(path, list);
+        }
+        list.push(closer);
+    }
+    _readdirp(root, opts) {
+        if (this.closed)
+            return;
+        const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+        let stream = readdirp(root, options);
+        this._streams.add(stream);
+        stream.once(STR_CLOSE, () => {
+            stream = undefined;
+        });
+        stream.once(STR_END, () => {
+            if (stream) {
+                this._streams.delete(stream);
+                stream = undefined;
+            }
+        });
+        return stream;
+    }
+}
+/**
+ * Instantiates watcher with paths to be tracked.
+ * @param paths file / directory paths
+ * @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others
+ * @returns an instance of FSWatcher for chaining.
+ * @example
+ * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); });
+ * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') })
+ */
+function watch(paths, options = {}) {
+    const watcher = new FSWatcher(options);
+    watcher.add(paths);
+    return watcher;
+}
+var index = { watch, FSWatcher };
+
+var index$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    FSWatcher: FSWatcher,
+    WatchHelper: WatchHelper,
+    default: index,
+    watch: watch
+});
+
+export { BaseLogger, CONFIG_FILE_NAME, ConsoleLogger, ConsoleLoggerWithoutExit, DEFAULT_CONFIG, MemoryLogger, build, check, compile, composeToString, createSorter, defaultLogger, dep, dev, fastLogToFile, init, resolveNASLFiles, scanEntryFiles, scanNASLFiles, sorter, tryCompile };
 //# sourceMappingURL=index.mjs.map