@bleedingdev/modern-js-utils 3.9.0-ultramodern.9 → 3.9.3-ultramodern.2

package/dist/compiled/chokidar/index.mjs

@@ -0,0 +1,1492 @@
+/*! LICENSE: index.mjs.LICENSE.txt */
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+var t = {};
+(()=>{
+    t.d = (e, s)=>{
+        for(var i in s)if (t.o(s, i) && !t.o(e, i)) Object.defineProperty(e, i, {
+            enumerable: true,
+            get: s[i]
+        });
+    };
+})();
+(()=>{
+    t.o = (t, e)=>Object.prototype.hasOwnProperty.call(t, e);
+})();
+var e = {};
+t.d(e, {
+    EQ: ()=>FSWatcher,
+    oF: ()=>WatchHelper,
+    Ay: ()=>B,
+    wB: ()=>watch
+});
+const s = require("node:events");
+const i = require("node:fs");
+const r = require("node:fs/promises");
+const n = require("node:path");
+const a = require("node:stream");
+const o = {
+    FILE_TYPE: "files",
+    DIR_TYPE: "directories",
+    FILE_DIR_TYPE: "files_directories",
+    EVERYTHING_TYPE: "all"
+};
+const h = {
+    root: ".",
+    fileFilter: (t)=>true,
+    directoryFilter: (t)=>true,
+    type: o.FILE_TYPE,
+    lstat: false,
+    depth: 2147483648,
+    alwaysStat: false,
+    highWaterMark: 4096
+};
+Object.freeze(h);
+const c = "READDIRP_RECURSIVE_ERROR";
+const l = new Set([
+    "ENOENT",
+    "EPERM",
+    "EACCES",
+    "ELOOP",
+    c
+]);
+const d = [
+    o.DIR_TYPE,
+    o.EVERYTHING_TYPE,
+    o.FILE_DIR_TYPE,
+    o.FILE_TYPE
+];
+const f = new Set([
+    o.DIR_TYPE,
+    o.EVERYTHING_TYPE,
+    o.FILE_DIR_TYPE
+]);
+const u = new Set([
+    o.EVERYTHING_TYPE,
+    o.FILE_DIR_TYPE,
+    o.FILE_TYPE
+]);
+const isNormalFlowError = (t)=>l.has(t.code);
+const p = "win32" === process.platform;
+const emptyFn = (t)=>true;
+const normalizeFilter = (t)=>{
+    if (void 0 === t) return emptyFn;
+    if ("function" == typeof t) return t;
+    if ("string" == typeof t) {
+        const e = t.trim();
+        return (t)=>t.basename === e;
+    }
+    if (Array.isArray(t)) {
+        const e = t.map((t)=>t.trim());
+        return (t)=>e.some((e)=>t.basename === e);
+    }
+    return emptyFn;
+};
+class ReaddirpStream extends a.Readable {
+    parents;
+    reading;
+    parent;
+    _stat;
+    _maxDepth;
+    _wantsDir;
+    _wantsFile;
+    _wantsEverything;
+    _root;
+    _isDirent;
+    _statsProp;
+    _rdOptions;
+    _fileFilter;
+    _directoryFilter;
+    constructor(t = {}){
+        super({
+            objectMode: true,
+            autoDestroy: true,
+            highWaterMark: t.highWaterMark
+        });
+        const e = {
+            ...h,
+            ...t
+        };
+        const { root: s, type: i } = e;
+        this._fileFilter = normalizeFilter(e.fileFilter);
+        this._directoryFilter = normalizeFilter(e.directoryFilter);
+        const a = e.lstat ? r.lstat : r.stat;
+        if (p) this._stat = (t)=>a(t, {
+                bigint: true
+            });
+        else this._stat = a;
+        this._maxDepth = null != e.depth && Number.isSafeInteger(e.depth) ? e.depth : h.depth;
+        this._wantsDir = i ? f.has(i) : false;
+        this._wantsFile = i ? u.has(i) : false;
+        this._wantsEverything = i === o.EVERYTHING_TYPE;
+        this._root = (0, n.resolve)(s);
+        this._isDirent = !e.alwaysStat;
+        this._statsProp = this._isDirent ? "dirent" : "stats";
+        this._rdOptions = {
+            encoding: "utf8",
+            withFileTypes: this._isDirent
+        };
+        this.parents = [
+            this._exploreDir(s, 1)
+        ];
+        this.reading = false;
+        this.parent = void 0;
+    }
+    async _read(t) {
+        if (this.reading) return;
+        this.reading = true;
+        try {
+            while(!this.destroyed && t > 0){
+                const e = this.parent;
+                const s = e && e.files;
+                if (s && s.length > 0) {
+                    const { path: i, depth: r } = e;
+                    const n = s.splice(0, t).map((t)=>this._formatEntry(t, i));
+                    const a = await Promise.all(n);
+                    for (const e of a){
+                        if (!e) continue;
+                        if (this.destroyed) return;
+                        const s = await this._getEntryType(e);
+                        if ("directory" === s && this._directoryFilter(e)) {
+                            if (r <= this._maxDepth) this.parents.push(this._exploreDir(e.fullPath, r + 1));
+                            if (this._wantsDir) {
+                                this.push(e);
+                                t--;
+                            }
+                        } else if (("file" === s || this._includeAsFile(e)) && this._fileFilter(e)) {
+                            if (this._wantsFile) {
+                                this.push(e);
+                                t--;
+                            }
+                        }
+                    }
+                } else {
+                    const t = this.parents.pop();
+                    if (!t) {
+                        this.push(null);
+                        break;
+                    }
+                    this.parent = await t;
+                    if (this.destroyed) return;
+                }
+            }
+        } catch (t) {
+            this.destroy(t);
+        } finally{
+            this.reading = false;
+        }
+    }
+    async _exploreDir(t, e) {
+        let s;
+        try {
+            s = await (0, r.readdir)(t, this._rdOptions);
+        } catch (t) {
+            this._onError(t);
+        }
+        return {
+            files: s,
+            depth: e,
+            path: t
+        };
+    }
+    async _formatEntry(t, e) {
+        let s;
+        const i = this._isDirent ? t.name : t;
+        try {
+            const r = (0, n.resolve)((0, n.join)(e, i));
+            s = {
+                path: (0, n.relative)(this._root, r),
+                fullPath: r,
+                basename: i
+            };
+            s[this._statsProp] = this._isDirent ? t : await this._stat(r);
+        } catch (t) {
+            this._onError(t);
+            return;
+        }
+        return s;
+    }
+    _onError(t) {
+        if (isNormalFlowError(t) && !this.destroyed) this.emit("warn", t);
+        else this.destroy(t);
+    }
+    async _getEntryType(t) {
+        if (!t && this._statsProp in t) return "";
+        const e = t[this._statsProp];
+        if (e.isFile()) return "file";
+        if (e.isDirectory()) return "directory";
+        if (e && e.isSymbolicLink()) {
+            const e = t.fullPath;
+            try {
+                const t = await (0, r.realpath)(e);
+                const s = await (0, r.lstat)(t);
+                if (s.isFile()) return "file";
+                if (s.isDirectory()) {
+                    const s = t.length;
+                    if (e.startsWith(t) && e.substr(s, 1) === n.sep) {
+                        const s = new Error(`Circular symlink detected: "${e}" points to "${t}"`);
+                        s.code = c;
+                        return this._onError(s);
+                    }
+                    return "directory";
+                }
+            } catch (t) {
+                this._onError(t);
+                return "";
+            }
+        }
+    }
+    _includeAsFile(t) {
+        const e = t && t[this._statsProp];
+        return e && this._wantsEverything && !e.isDirectory();
+    }
+}
+function readdirp(t, e = {}) {
+    let s = e.entryType || e.type;
+    if ("both" === s) s = o.FILE_DIR_TYPE;
+    if (s) e.type = s;
+    if (t) {
+        if ("string" != typeof t) throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+        else if (s && !d.includes(s)) throw new Error(`readdirp: Invalid type passed. Use one of ${d.join(", ")}`);
+    } else throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+    e.root = t;
+    return new ReaddirpStream(e);
+}
+const m = require("node:os");
+const w = "data";
+const g = "end";
+const y = "close";
+const EMPTY_FN = ()=>{};
+const E = process.platform;
+const P = "win32" === E;
+const v = "darwin" === E;
+const b = "linux" === E;
+const D = "freebsd" === E;
+const R = "OS400" === (0, m.type)();
+const I = {
+    ALL: "all",
+    READY: "ready",
+    ADD: "add",
+    CHANGE: "change",
+    ADD_DIR: "addDir",
+    UNLINK: "unlink",
+    UNLINK_DIR: "unlinkDir",
+    RAW: "raw",
+    ERROR: "error"
+};
+const F = I;
+const W = "watch";
+const x = {
+    lstat: r.lstat,
+    stat: r.stat
+};
+const A = "listeners";
+const k = "errHandlers";
+const N = "rawEmitters";
+const S = [
+    A,
+    k,
+    N
+];
+const T = 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 = (t)=>T.has(n.extname(t).slice(1).toLowerCase());
+const foreach = (t, e)=>{
+    if (t instanceof Set) t.forEach(e);
+    else e(t);
+};
+const addAndConvert = (t, e, s)=>{
+    let i = t[e];
+    if (!(i instanceof Set)) t[e] = i = new Set([
+        i
+    ]);
+    i.add(s);
+};
+const clearItem = (t)=>(e)=>{
+        const s = t[e];
+        if (s instanceof Set) s.clear();
+        else delete t[e];
+    };
+const delFromSet = (t, e, s)=>{
+    const i = t[e];
+    if (i instanceof Set) i.delete(s);
+    else if (i === s) delete t[e];
+};
+const isEmptySet = (t)=>t instanceof Set ? 0 === t.size : !t;
+const C = new Map;
+function createFsWatchInstance(t, e, s, r, a) {
+    const handleEvent = (e, i)=>{
+        s(t);
+        a(e, i, {
+            watchedPath: t
+        });
+        if (i && t !== i) fsWatchBroadcast(n.resolve(t, i), A, n.join(t, i));
+    };
+    try {
+        return (0, i.watch)(t, {
+            persistent: e.persistent
+        }, handleEvent);
+    } catch (t) {
+        r(t);
+        return;
+    }
+}
+const fsWatchBroadcast = (t, e, s, i, r)=>{
+    const n = C.get(t);
+    if (!n) return;
+    foreach(n[e], (t)=>{
+        t(s, i, r);
+    });
+};
+const setFsWatchListener = (t, e, s, i)=>{
+    const { listener: n, errHandler: a, rawEmitter: o } = i;
+    let h = C.get(e);
+    let c;
+    if (!s.persistent) {
+        c = createFsWatchInstance(t, s, n, a, o);
+        if (!c) return;
+        return c.close.bind(c);
+    }
+    if (h) {
+        addAndConvert(h, A, n);
+        addAndConvert(h, k, a);
+        addAndConvert(h, N, o);
+    } else {
+        c = createFsWatchInstance(t, s, fsWatchBroadcast.bind(null, e, A), a, fsWatchBroadcast.bind(null, e, N));
+        if (!c) return;
+        c.on(F.ERROR, async (s)=>{
+            const i = fsWatchBroadcast.bind(null, e, k);
+            if (h) h.watcherUnusable = true;
+            if (P && "EPERM" === s.code) try {
+                const e = await (0, r.open)(t, "r");
+                await e.close();
+                i(s);
+            } catch (t) {}
+            else i(s);
+        });
+        h = {
+            listeners: n,
+            errHandlers: a,
+            rawEmitters: o,
+            watcher: c
+        };
+        C.set(e, h);
+    }
+    return ()=>{
+        delFromSet(h, A, n);
+        delFromSet(h, k, a);
+        delFromSet(h, N, o);
+        if (isEmptySet(h.listeners)) {
+            h.watcher.close();
+            C.delete(e);
+            S.forEach(clearItem(h));
+            h.watcher = void 0;
+            Object.freeze(h);
+        }
+    };
+};
+const z = new Map;
+const setFsWatchFileListener = (t, e, s, r)=>{
+    const { listener: n, rawEmitter: a } = r;
+    let o = z.get(e);
+    const h = o && o.options;
+    if (h && (h.persistent < s.persistent || h.interval > s.interval)) {
+        (0, i.unwatchFile)(e);
+        o = void 0;
+    }
+    if (o) {
+        addAndConvert(o, A, n);
+        addAndConvert(o, N, a);
+    } else {
+        o = {
+            listeners: n,
+            rawEmitters: a,
+            options: s,
+            watcher: (0, i.watchFile)(e, s, (s, i)=>{
+                foreach(o.rawEmitters, (t)=>{
+                    t(F.CHANGE, e, {
+                        curr: s,
+                        prev: i
+                    });
+                });
+                const r = s.mtimeMs;
+                if (s.size !== i.size || r > i.mtimeMs || 0 === r) foreach(o.listeners, (e)=>e(t, s));
+            })
+        };
+        z.set(e, o);
+    }
+    return ()=>{
+        delFromSet(o, A, n);
+        delFromSet(o, N, a);
+        if (isEmptySet(o.listeners)) {
+            z.delete(e);
+            (0, i.unwatchFile)(e);
+            o.options = o.watcher = void 0;
+            Object.freeze(o);
+        }
+    };
+};
+class NodeFsHandler {
+    fsw;
+    _boundHandleError;
+    constructor(t){
+        this.fsw = t;
+        this._boundHandleError = (e)=>t._handleError(e);
+    }
+    _watchWithNodeFs(t, e) {
+        const s = this.fsw.options;
+        const i = n.dirname(t);
+        const r = n.basename(t);
+        const a = this.fsw._getWatchedDir(i);
+        a.add(r);
+        const o = n.resolve(t);
+        const h = {
+            persistent: s.persistent
+        };
+        if (!e) e = EMPTY_FN;
+        let c;
+        if (s.usePolling) {
+            const i = s.interval !== s.binaryInterval;
+            h.interval = i && isBinaryPath(r) ? s.binaryInterval : s.interval;
+            c = setFsWatchFileListener(t, o, h, {
+                listener: e,
+                rawEmitter: this.fsw._emitRaw
+            });
+        } else c = setFsWatchListener(t, o, h, {
+            listener: e,
+            errHandler: this._boundHandleError,
+            rawEmitter: this.fsw._emitRaw
+        });
+        return c;
+    }
+    _handleFile(t, e, s) {
+        if (this.fsw.closed) return;
+        const i = n.dirname(t);
+        const a = n.basename(t);
+        const o = this.fsw._getWatchedDir(i);
+        let h = e;
+        if (o.has(a)) return;
+        const listener = async (e, s)=>{
+            if (!this.fsw._throttle(W, t, 5)) return;
+            if (s && 0 !== s.mtimeMs) {
+                if (o.has(a)) {
+                    const e = s.atimeMs;
+                    const i = s.mtimeMs;
+                    if (!e || e <= i || i !== h.mtimeMs) this.fsw._emit(F.CHANGE, t, s);
+                    h = s;
+                }
+            } else try {
+                const s = await (0, r.stat)(t);
+                if (this.fsw.closed) return;
+                const i = s.atimeMs;
+                const n = s.mtimeMs;
+                if (!i || i <= n || n !== h.mtimeMs) this.fsw._emit(F.CHANGE, t, s);
+                if ((v || b || D) && h.ino !== s.ino) {
+                    this.fsw._closeFile(e);
+                    h = s;
+                    const i = this._watchWithNodeFs(t, listener);
+                    if (i) this.fsw._addPathCloser(e, i);
+                } else h = s;
+            } catch (t) {
+                this.fsw._remove(i, a);
+            }
+        };
+        const c = this._watchWithNodeFs(t, listener);
+        if (!(s && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(t)) {
+            if (!this.fsw._throttle(F.ADD, t, 0)) return;
+            this.fsw._emit(F.ADD, t, e);
+        }
+        return c;
+    }
+    async _handleSymlink(t, e, s, i) {
+        if (this.fsw.closed) return;
+        const n = t.fullPath;
+        const a = this.fsw._getWatchedDir(e);
+        if (!this.fsw.options.followSymlinks) {
+            this.fsw._incrReadyCount();
+            let e;
+            try {
+                e = await (0, r.realpath)(s);
+            } catch (t) {
+                this.fsw._emitReady();
+                return true;
+            }
+            if (this.fsw.closed) return;
+            if (a.has(i)) {
+                if (this.fsw._symlinkPaths.get(n) !== e) {
+                    this.fsw._symlinkPaths.set(n, e);
+                    this.fsw._emit(F.CHANGE, s, t.stats);
+                }
+            } else {
+                a.add(i);
+                this.fsw._symlinkPaths.set(n, e);
+                this.fsw._emit(F.ADD, s, t.stats);
+            }
+            this.fsw._emitReady();
+            return true;
+        }
+        if (this.fsw._symlinkPaths.has(n)) return true;
+        this.fsw._symlinkPaths.set(n, true);
+    }
+    _handleRead(t, e, s, i, r, a, o) {
+        t = n.join(t, "");
+        const h = i ? `${t}:${i}` : t;
+        o = this.fsw._throttle("readdir", h, 1e3);
+        if (!o) return;
+        const c = this.fsw._getWatchedDir(s.path);
+        const l = new Set;
+        let d = this.fsw._readdirp(t, {
+            fileFilter: (t)=>s.filterPath(t),
+            directoryFilter: (t)=>s.filterDir(t)
+        });
+        if (!d) return;
+        d.on(w, async (o)=>{
+            if (this.fsw.closed) {
+                d = void 0;
+                return;
+            }
+            const h = o.path;
+            let f = n.join(t, h);
+            l.add(h);
+            if (o.stats.isSymbolicLink() && await this._handleSymlink(o, t, f, h)) return;
+            if (this.fsw.closed) {
+                d = void 0;
+                return;
+            }
+            if (h === i || !i && !c.has(h)) {
+                this.fsw._incrReadyCount();
+                f = n.join(r, n.relative(r, f));
+                this._addToNodeFs(f, e, s, a + 1);
+            }
+        }).on(F.ERROR, this._boundHandleError);
+        return new Promise((e, n)=>{
+            if (!d) return n();
+            d.once(g, ()=>{
+                if (this.fsw.closed) {
+                    d = void 0;
+                    return;
+                }
+                const n = o ? o.clear() : false;
+                e(void 0);
+                c.getChildren().filter((e)=>e !== t && !l.has(e)).forEach((e)=>{
+                    this.fsw._remove(t, e);
+                });
+                d = void 0;
+                if (n) this._handleRead(t, false, s, i, r, a, o);
+            });
+        });
+    }
+    async _handleDir(t, e, s, i, r, a, o) {
+        const h = this.fsw._getWatchedDir(n.dirname(t));
+        const c = h.has(n.basename(t));
+        if (!(s && this.fsw.options.ignoreInitial) && !r && !c) this.fsw._emit(F.ADD_DIR, t, e);
+        h.add(n.basename(t));
+        this.fsw._getWatchedDir(t);
+        let l;
+        let d;
+        const f = this.fsw.options.depth;
+        if ((null == f || i <= f) && !this.fsw._symlinkPaths.has(o)) {
+            if (!r) {
+                await this._handleRead(t, s, a, r, t, i, l);
+                if (this.fsw.closed) return;
+            }
+            d = this._watchWithNodeFs(t, (e, s)=>{
+                if (s && 0 === s.mtimeMs) return;
+                this._handleRead(e, false, a, r, t, i, l);
+            });
+        }
+        return d;
+    }
+    async _addToNodeFs(t, e, s, i, a) {
+        const o = this.fsw._emitReady;
+        if (this.fsw._isIgnored(t) || this.fsw.closed) {
+            o();
+            return false;
+        }
+        const h = this.fsw._getWatchHelpers(t);
+        if (s) {
+            h.filterPath = (t)=>s.filterPath(t);
+            h.filterDir = (t)=>s.filterDir(t);
+        }
+        try {
+            const s = await x[h.statMethod](h.watchPath);
+            if (this.fsw.closed) return;
+            if (this.fsw._isIgnored(h.watchPath, s)) {
+                o();
+                return false;
+            }
+            const c = this.fsw.options.followSymlinks;
+            let l;
+            if (s.isDirectory()) {
+                const o = n.resolve(t);
+                const d = c ? await (0, r.realpath)(t) : t;
+                if (this.fsw.closed) return;
+                l = await this._handleDir(h.watchPath, s, e, i, a, h, d);
+                if (this.fsw.closed) return;
+                if (o !== d && void 0 !== d) this.fsw._symlinkPaths.set(o, d);
+            } else if (s.isSymbolicLink()) {
+                const a = c ? await (0, r.realpath)(t) : t;
+                if (this.fsw.closed) return;
+                const o = n.dirname(h.watchPath);
+                this.fsw._getWatchedDir(o).add(h.watchPath);
+                this.fsw._emit(F.ADD, h.watchPath, s);
+                l = await this._handleDir(o, s, e, i, t, h, a);
+                if (this.fsw.closed) return;
+                if (void 0 !== a) this.fsw._symlinkPaths.set(n.resolve(t), a);
+            } else l = this._handleFile(h.watchPath, s, e);
+            o();
+            if (l) this.fsw._addPathCloser(t, l);
+            return false;
+        } catch (e) {
+            if (this.fsw._handleError(e)) {
+                o();
+                return t;
+            }
+        }
+    }
+}
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */ const j = "/";
+const H = "//";
+const L = ".";
+const O = "..";
+const M = "string";
+const Y = /\\/g;
+const U = /\/\//g;
+const G = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+const q = /^\.[/\\]/;
+function arrify(t) {
+    return Array.isArray(t) ? t : [
+        t
+    ];
+}
+const isMatcherObject = (t)=>"object" == typeof t && null !== t && !(t instanceof RegExp);
+function createPattern(t) {
+    if ("function" == typeof t) return t;
+    if ("string" == typeof t) return (e)=>t === e;
+    if (t instanceof RegExp) return (e)=>t.test(e);
+    if ("object" == typeof t && null !== t) return (e)=>{
+        if (t.path === e) return true;
+        if (t.recursive) {
+            const s = n.relative(t.path, e);
+            if (!s) return false;
+            return !s.startsWith("..") && !n.isAbsolute(s);
+        }
+        return false;
+    };
+    return ()=>false;
+}
+function normalizePath(t) {
+    if ("string" != typeof t) throw new Error("string expected");
+    t = n.normalize(t);
+    t = t.replace(/\\/g, "/");
+    let e = false;
+    if (t.startsWith("//")) e = true;
+    t = t.replace(U, "/");
+    if (e) t = "/" + t;
+    return t;
+}
+function matchPatterns(t, e, s) {
+    const i = normalizePath(e);
+    for(let e = 0; e < t.length; e++){
+        const r = t[e];
+        if (r(i, s)) return true;
+    }
+    return false;
+}
+function anymatch(t, e) {
+    if (null == t) throw new TypeError("anymatch: specify first argument");
+    const s = arrify(t);
+    const i = s.map((t)=>createPattern(t));
+    if (null == e) return (t, e)=>matchPatterns(i, t, e);
+    return matchPatterns(i, e);
+}
+const unifyPaths = (t)=>{
+    const e = arrify(t).flat();
+    if (!e.every((t)=>typeof t === M)) throw new TypeError(`Non-string provided as watch path: ${e}`);
+    return e.map(normalizePathToUnix);
+};
+const toUnix = (t)=>{
+    let e = t.replace(Y, j);
+    let s = false;
+    if (e.startsWith(H)) s = true;
+    e = e.replace(U, j);
+    if (s) e = j + e;
+    return e;
+};
+const normalizePathToUnix = (t)=>toUnix(n.normalize(toUnix(t)));
+const normalizeIgnored = (t = "")=>(e)=>{
+        if ("string" == typeof e) return normalizePathToUnix(n.isAbsolute(e) ? e : n.join(t, e));
+        else return e;
+    };
+const getAbsolutePath = (t, e)=>{
+    if (n.isAbsolute(t)) return t;
+    return n.join(e, t);
+};
+const $ = Object.freeze(new Set);
+class DirEntry {
+    path;
+    _removeWatcher;
+    items;
+    constructor(t, e){
+        this.path = t;
+        this._removeWatcher = e;
+        this.items = new Set;
+    }
+    add(t) {
+        const { items: e } = this;
+        if (!e) return;
+        if (t !== L && t !== O) e.add(t);
+    }
+    async remove(t) {
+        const { items: e } = this;
+        if (!e) return;
+        e.delete(t);
+        if (e.size > 0) return;
+        const s = this.path;
+        try {
+            await (0, r.readdir)(s);
+        } catch (t) {
+            if (this._removeWatcher) this._removeWatcher(n.dirname(s), n.basename(s));
+        }
+    }
+    has(t) {
+        const { items: e } = this;
+        if (!e) return;
+        return e.has(t);
+    }
+    getChildren() {
+        const { items: t } = this;
+        if (!t) return [];
+        return [
+            ...t.values()
+        ];
+    }
+    dispose() {
+        this.items.clear();
+        this.path = "";
+        this._removeWatcher = EMPTY_FN;
+        this.items = $;
+        Object.freeze(this);
+    }
+}
+const K = "stat";
+const V = "lstat";
+class WatchHelper {
+    fsw;
+    path;
+    watchPath;
+    fullWatchPath;
+    dirParts;
+    followSymlinks;
+    statMethod;
+    constructor(t, e, s){
+        this.fsw = s;
+        const i = t;
+        this.path = t = t.replace(q, "");
+        this.watchPath = i;
+        this.fullWatchPath = n.resolve(i);
+        this.dirParts = [];
+        this.dirParts.forEach((t)=>{
+            if (t.length > 1) t.pop();
+        });
+        this.followSymlinks = e;
+        this.statMethod = e ? K : V;
+    }
+    entryPath(t) {
+        return n.join(this.watchPath, n.relative(this.watchPath, t.fullPath));
+    }
+    filterPath(t) {
+        const { stats: e } = t;
+        if (e && e.isSymbolicLink()) return this.filterDir(t);
+        const s = this.entryPath(t);
+        return this.fsw._isntIgnored(s, e) && this.fsw._hasReadPermissions(e);
+    }
+    filterDir(t) {
+        return this.fsw._isntIgnored(this.entryPath(t), t.stats);
+    }
+}
+class FSWatcher extends s.EventEmitter {
+    closed;
+    options;
+    _closers;
+    _ignoredPaths;
+    _throttled;
+    _streams;
+    _symlinkPaths;
+    _watched;
+    _pendingWrites;
+    _pendingUnlinks;
+    _readyCount;
+    _emitReady;
+    _closePromise;
+    _userIgnored;
+    _readyEmitted;
+    _emitRaw;
+    _boundRemove;
+    _nodeFsHandler;
+    constructor(t = {}){
+        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 e = t.awaitWriteFinish;
+        const s = {
+            stabilityThreshold: 2e3,
+            pollInterval: 100
+        };
+        const i = {
+            persistent: true,
+            ignoreInitial: false,
+            ignorePermissionErrors: false,
+            interval: 100,
+            binaryInterval: 300,
+            followSymlinks: true,
+            usePolling: false,
+            atomic: true,
+            ...t,
+            ignored: t.ignored ? arrify(t.ignored) : arrify([]),
+            awaitWriteFinish: true === e ? s : "object" == typeof e ? {
+                ...s,
+                ...e
+            } : false
+        };
+        if (R) i.usePolling = true;
+        if (void 0 === i.atomic) i.atomic = !i.usePolling;
+        const r = process.env.CHOKIDAR_USEPOLLING;
+        if (void 0 !== r) {
+            const t = r.toLowerCase();
+            if ("false" === t || "0" === t) i.usePolling = false;
+            else if ("true" === t || "1" === t) i.usePolling = true;
+            else i.usePolling = !!t;
+        }
+        const n = process.env.CHOKIDAR_INTERVAL;
+        if (n) i.interval = Number.parseInt(n, 10);
+        let a = 0;
+        this._emitReady = ()=>{
+            a++;
+            if (a >= this._readyCount) {
+                this._emitReady = EMPTY_FN;
+                this._readyEmitted = true;
+                process.nextTick(()=>this.emit(I.READY));
+            }
+        };
+        this._emitRaw = (...t)=>this.emit(I.RAW, ...t);
+        this._boundRemove = this._remove.bind(this);
+        this.options = i;
+        this._nodeFsHandler = new NodeFsHandler(this);
+        Object.freeze(i);
+    }
+    _addIgnoredPath(t) {
+        if (isMatcherObject(t)) {
+            for (const e of this._ignoredPaths)if (isMatcherObject(e) && e.path === t.path && e.recursive === t.recursive) return;
+        }
+        this._ignoredPaths.add(t);
+    }
+    _removeIgnoredPath(t) {
+        this._ignoredPaths.delete(t);
+        if ("string" == typeof t) {
+            for (const e of this._ignoredPaths)if (isMatcherObject(e) && e.path === t) this._ignoredPaths.delete(e);
+        }
+    }
+    add(t, e, s) {
+        const { cwd: i } = this.options;
+        this.closed = false;
+        this._closePromise = void 0;
+        let r = unifyPaths(t);
+        if (i) r = r.map((t)=>{
+            const e = getAbsolutePath(t, i);
+            return e;
+        });
+        r.forEach((t)=>{
+            this._removeIgnoredPath(t);
+        });
+        this._userIgnored = void 0;
+        if (!this._readyCount) this._readyCount = 0;
+        this._readyCount += r.length;
+        Promise.all(r.map(async (t)=>{
+            const i = await this._nodeFsHandler._addToNodeFs(t, !s, void 0, 0, e);
+            if (i) this._emitReady();
+            return i;
+        })).then((t)=>{
+            if (this.closed) return;
+            t.forEach((t)=>{
+                if (t) this.add(n.dirname(t), n.basename(e || t));
+            });
+        });
+        return this;
+    }
+    unwatch(t) {
+        if (this.closed) return this;
+        const e = unifyPaths(t);
+        const { cwd: s } = this.options;
+        e.forEach((t)=>{
+            if (!n.isAbsolute(t) && !this._closers.has(t)) {
+                if (s) t = n.join(s, t);
+                t = n.resolve(t);
+            }
+            this._closePath(t);
+            this._addIgnoredPath(t);
+            if (this._watched.has(t)) this._addIgnoredPath({
+                path: t,
+                recursive: true
+            });
+            this._userIgnored = void 0;
+        });
+        return this;
+    }
+    close() {
+        if (this._closePromise) return this._closePromise;
+        this.closed = true;
+        this.removeAllListeners();
+        const t = [];
+        this._closers.forEach((e)=>e.forEach((e)=>{
+                const s = e();
+                if (s instanceof Promise) t.push(s);
+            }));
+        this._streams.forEach((t)=>t.destroy());
+        this._userIgnored = void 0;
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        this._watched.forEach((t)=>t.dispose());
+        this._closers.clear();
+        this._watched.clear();
+        this._streams.clear();
+        this._symlinkPaths.clear();
+        this._throttled.clear();
+        this._closePromise = t.length ? Promise.all(t).then(()=>void 0) : Promise.resolve();
+        return this._closePromise;
+    }
+    getWatched() {
+        const t = {};
+        this._watched.forEach((e, s)=>{
+            const i = this.options.cwd ? n.relative(this.options.cwd, s) : s;
+            const r = i || L;
+            t[r] = e.getChildren().sort();
+        });
+        return t;
+    }
+    emitWithAll(t, e) {
+        this.emit(t, ...e);
+        if (t !== I.ERROR) this.emit(I.ALL, t, ...e);
+    }
+    async _emit(t, e, s) {
+        if (this.closed) return;
+        const i = this.options;
+        if (P) e = n.normalize(e);
+        if (i.cwd) e = n.relative(i.cwd, e);
+        const a = [
+            e
+        ];
+        if (null != s) a.push(s);
+        const o = i.awaitWriteFinish;
+        let h;
+        if (o && (h = this._pendingWrites.get(e))) {
+            h.lastChange = new Date;
+            return this;
+        }
+        if (i.atomic) {
+            if (t === I.UNLINK) {
+                this._pendingUnlinks.set(e, [
+                    t,
+                    ...a
+                ]);
+                setTimeout(()=>{
+                    this._pendingUnlinks.forEach((t, e)=>{
+                        this.emit(...t);
+                        this.emit(I.ALL, ...t);
+                        this._pendingUnlinks.delete(e);
+                    });
+                }, "number" == typeof i.atomic ? i.atomic : 100);
+                return this;
+            }
+            if (t === I.ADD && this._pendingUnlinks.has(e)) {
+                t = I.CHANGE;
+                this._pendingUnlinks.delete(e);
+            }
+        }
+        if (o && (t === I.ADD || t === I.CHANGE) && this._readyEmitted) {
+            const awfEmit = (e, s)=>{
+                if (e) {
+                    t = I.ERROR;
+                    a[0] = e;
+                    this.emitWithAll(t, a);
+                } else if (s) {
+                    if (a.length > 1) a[1] = s;
+                    else a.push(s);
+                    this.emitWithAll(t, a);
+                }
+            };
+            this._awaitWriteFinish(e, o.stabilityThreshold, t, awfEmit);
+            return this;
+        }
+        if (t === I.CHANGE) {
+            const t = !this._throttle(I.CHANGE, e, 50);
+            if (t) return this;
+        }
+        if (i.alwaysStat && void 0 === s && (t === I.ADD || t === I.ADD_DIR || t === I.CHANGE)) {
+            const t = i.cwd ? n.join(i.cwd, e) : e;
+            let s;
+            try {
+                s = await (0, r.stat)(t);
+            } catch (t) {}
+            if (!s || this.closed) return;
+            a.push(s);
+        }
+        this.emitWithAll(t, a);
+        return this;
+    }
+    _handleError(t) {
+        const e = t && t.code;
+        if (t && "ENOENT" !== e && "ENOTDIR" !== e && (!this.options.ignorePermissionErrors || "EPERM" !== e && "EACCES" !== e)) this.emit(I.ERROR, t);
+        return t || this.closed;
+    }
+    _throttle(t, e, s) {
+        if (!this._throttled.has(t)) this._throttled.set(t, new Map);
+        const i = this._throttled.get(t);
+        if (!i) throw new Error("invalid throttle");
+        const r = i.get(e);
+        if (r) {
+            r.count++;
+            return false;
+        }
+        let n;
+        const clear = ()=>{
+            const t = i.get(e);
+            const s = t ? t.count : 0;
+            i.delete(e);
+            clearTimeout(n);
+            if (t) clearTimeout(t.timeoutObject);
+            return s;
+        };
+        n = setTimeout(clear, s);
+        const a = {
+            timeoutObject: n,
+            clear: clear,
+            count: 0
+        };
+        i.set(e, a);
+        return a;
+    }
+    _incrReadyCount() {
+        return this._readyCount++;
+    }
+    _awaitWriteFinish(t, e, s, r) {
+        const a = this.options.awaitWriteFinish;
+        if ("object" != typeof a) return;
+        const o = a.pollInterval;
+        let h;
+        let c = t;
+        if (this.options.cwd && !n.isAbsolute(t)) c = n.join(this.options.cwd, t);
+        const l = new Date;
+        const d = this._pendingWrites;
+        function awaitWriteFinishFn(s) {
+            (0, i.stat)(c, (i, n)=>{
+                if (i || !d.has(t)) {
+                    if (i && "ENOENT" !== i.code) r(i);
+                    return;
+                }
+                const a = Number(new Date);
+                if (s && n.size !== s.size) d.get(t).lastChange = a;
+                const c = d.get(t);
+                const l = a - c.lastChange;
+                if (l >= e) {
+                    d.delete(t);
+                    r(void 0, n);
+                } else h = setTimeout(awaitWriteFinishFn, o, n);
+            });
+        }
+        if (!d.has(t)) {
+            d.set(t, {
+                lastChange: l,
+                cancelWait: ()=>{
+                    d.delete(t);
+                    clearTimeout(h);
+                    return s;
+                }
+            });
+            h = setTimeout(awaitWriteFinishFn, o);
+        }
+    }
+    _isIgnored(t, e) {
+        if (this.options.atomic && G.test(t)) return true;
+        if (!this._userIgnored) {
+            const { cwd: t } = this.options;
+            const e = this.options.ignored;
+            const s = (e || []).map(normalizeIgnored(t));
+            const i = [
+                ...this._ignoredPaths
+            ];
+            const r = [
+                ...i.map(normalizeIgnored(t)),
+                ...s
+            ];
+            this._userIgnored = anymatch(r, void 0);
+        }
+        return this._userIgnored(t, e);
+    }
+    _isntIgnored(t, e) {
+        return !this._isIgnored(t, e);
+    }
+    _getWatchHelpers(t) {
+        return new WatchHelper(t, this.options.followSymlinks, this);
+    }
+    _getWatchedDir(t) {
+        const e = n.resolve(t);
+        if (!this._watched.has(e)) this._watched.set(e, new DirEntry(e, this._boundRemove));
+        return this._watched.get(e);
+    }
+    _hasReadPermissions(t) {
+        if (this.options.ignorePermissionErrors) return true;
+        return Boolean(256 & Number(t.mode));
+    }
+    _remove(t, e, s) {
+        const i = n.join(t, e);
+        const r = n.resolve(i);
+        s = null != s ? s : this._watched.has(i) || this._watched.has(r);
+        if (!this._throttle("remove", i, 100)) return;
+        if (!s && 1 === this._watched.size) this.add(t, e, true);
+        const a = this._getWatchedDir(i);
+        const o = a.getChildren();
+        o.forEach((t)=>this._remove(i, t));
+        const h = this._getWatchedDir(t);
+        const c = h.has(e);
+        h.remove(e);
+        if (this._symlinkPaths.has(r)) this._symlinkPaths.delete(r);
+        let l = i;
+        if (this.options.cwd) l = n.relative(this.options.cwd, i);
+        if (this.options.awaitWriteFinish && this._pendingWrites.has(l)) {
+            const t = this._pendingWrites.get(l).cancelWait();
+            if (t === I.ADD) return;
+        }
+        this._watched.delete(i);
+        this._watched.delete(r);
+        const d = s ? I.UNLINK_DIR : I.UNLINK;
+        if (c && !this._isIgnored(i)) this._emit(d, i);
+        this._closePath(i);
+    }
+    _closePath(t) {
+        this._closeFile(t);
+        const e = n.dirname(t);
+        this._getWatchedDir(e).remove(n.basename(t));
+    }
+    _closeFile(t) {
+        const e = this._closers.get(t);
+        if (!e) return;
+        e.forEach((t)=>t());
+        this._closers.delete(t);
+    }
+    _addPathCloser(t, e) {
+        if (!e) return;
+        let s = this._closers.get(t);
+        if (!s) {
+            s = [];
+            this._closers.set(t, s);
+        }
+        s.push(e);
+    }
+    _readdirp(t, e) {
+        if (this.closed) return;
+        const s = {
+            type: I.ALL,
+            alwaysStat: true,
+            lstat: true,
+            ...e,
+            depth: 0
+        };
+        let i = readdirp(t, s);
+        this._streams.add(i);
+        i.once(y, ()=>{
+            i = void 0;
+        });
+        i.once(g, ()=>{
+            if (i) {
+                this._streams.delete(i);
+                i = void 0;
+            }
+        });
+        return i;
+    }
+}
+function watch(t, e = {}) {
+    const s = new FSWatcher(e);
+    s.add(t);
+    return s;
+}
+const B = {
+    watch: watch,
+    FSWatcher: FSWatcher
+};
+var Q = e.EQ;
+var J = e.oF;
+var X = e.Ay;
+var Z = e.wB;
+export { Q as FSWatcher, J as WatchHelper, X as default, Z as watch };