lakutata 2.0.95 → 2.0.96

package/vendor/Package.internal.16.cjs

@@ -1,272 +1,990 @@
-/* Build Date: Mon Nov 24 2025 17:58:53 GMT+0800 (China Standard Time) */
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
 "use strict";
 
-const e = require("./Package.internal.95.cjs");
+const t = require("events");
 
-var n = {
-    exports: {}
+const e = require("fs");
+
+const r = require("./Package.internal.17.cjs");
+
+const s = require("path");
+
+const i = require("./Package.internal.18.cjs");
+
+const n = require("stream");
+
+const o = t => t && t.__esModule ? t : {
+    default: t
 };
 
-n.exports;
+const a = o(t);
 
-var r = e.reusify_1;
+const u = o(e);
 
-function t(e, n, t) {
-    if (typeof e === "function") {
-        t = n;
-        n = e;
-        e = null;
-    }
-    if (!(t >= 1)) {
-        throw new Error("fastqueue concurrency must be equal to or greater than 1");
-    }
-    var l = r(a);
-    var i = null;
-    var o = null;
-    var c = 0;
-    var f = null;
-    var s = {
-        push: w,
-        drain: u,
-        saturated: u,
-        pause: d,
-        paused: false,
-        get concurrency() {
-            return t;
-        },
-        set concurrency(e) {
-            if (!(e >= 1)) {
-                throw new Error("fastqueue concurrency must be equal to or greater than 1");
+const c = o(s);
+
+const l = o(n);
+
+exports.out$1 = {};
+
+var d = {};
+
+var h = {};
+
+var _ = {};
+
+var f = {};
+
+exports.out = {};
+
+var S = {};
+
+Object.defineProperty(S, "__esModule", {
+    value: true
+});
+
+S.read = void 0;
+
+function p(t, e, r) {
+    e.fs.lstat(t, (s, i) => {
+        if (s !== null) {
+            y(r, s);
+            return;
+        }
+        if (!i.isSymbolicLink() || !e.followSymbolicLink) {
+            m(r, i);
+            return;
+        }
+        e.fs.stat(t, (t, s) => {
+            if (t !== null) {
+                if (e.throwErrorOnBrokenSymbolicLink) {
+                    y(r, t);
+                    return;
+                }
+                m(r, i);
+                return;
             }
-            t = e;
-            if (s.paused) return;
-            for (;i && c < t; ) {
-                c++;
-                y();
+            if (e.markSymbolicLink) {
+                s.isSymbolicLink = () => true;
             }
-        },
-        running: v,
-        resume: x,
-        idle: k,
-        length: h,
-        getQueue: p,
-        unshift: g,
-        empty: u,
-        kill: m,
-        killAndDrain: b,
-        error: q
-    };
-    return s;
-    function v() {
-        return c;
-    }
-    function d() {
-        s.paused = true;
-    }
-    function h() {
-        var e = i;
-        var n = 0;
-        while (e) {
-            e = e.next;
-            n++;
+            m(r, s);
+        });
+    });
+}
+
+S.read = p;
+
+function y(t, e) {
+    t(e);
+}
+
+function m(t, e) {
+    t(null, e);
+}
+
+var g = {};
+
+Object.defineProperty(g, "__esModule", {
+    value: true
+});
+
+g.read = void 0;
+
+function b(t, e) {
+    const r = e.fs.lstatSync(t);
+    if (!r.isSymbolicLink() || !e.followSymbolicLink) {
+        return r;
+    }
+    try {
+        const r = e.fs.statSync(t);
+        if (e.markSymbolicLink) {
+            r.isSymbolicLink = () => true;
         }
-        return n;
+        return r;
+    } catch (t) {
+        if (!e.throwErrorOnBrokenSymbolicLink) {
+            return r;
+        }
+        throw t;
     }
-    function p() {
-        var e = i;
-        var n = [];
-        while (e) {
-            n.push(e.value);
-            e = e.next;
+}
+
+g.read = b;
+
+var E = {};
+
+var v = {};
+
+(function(t) {
+    Object.defineProperty(t, "__esModule", {
+        value: true
+    });
+    t.createFileSystemAdapter = t.FILE_SYSTEM_ADAPTER = void 0;
+    const e = u.default;
+    t.FILE_SYSTEM_ADAPTER = {
+        lstat: e.lstat,
+        stat: e.stat,
+        lstatSync: e.lstatSync,
+        statSync: e.statSync
+    };
+    function r(e) {
+        if (e === undefined) {
+            return t.FILE_SYSTEM_ADAPTER;
         }
-        return n;
+        return Object.assign(Object.assign({}, t.FILE_SYSTEM_ADAPTER), e);
+    }
+    t.createFileSystemAdapter = r;
+})(v);
+
+Object.defineProperty(E, "__esModule", {
+    value: true
+});
+
+const P = v;
+
+let k = class Settings {
+    constructor(t = {}) {
+        this._options = t;
+        this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
+        this.fs = P.createFileSystemAdapter(this._options.fs);
+        this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
+        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
+    }
+    _getValue(t, e) {
+        return t !== null && t !== void 0 ? t : e;
+    }
+};
+
+E.default = k;
+
+Object.defineProperty(exports.out, "__esModule", {
+    value: true
+});
+
+exports.out.statSync = exports.out.stat = exports.out.Settings = void 0;
+
+const F = S;
+
+const w = g;
+
+const L = E;
+
+exports.out.Settings = L.default;
+
+function O(t, e, r) {
+    if (typeof e === "function") {
+        F.read(t, D(), e);
+        return;
     }
-    function x() {
-        if (!s.paused) return;
-        s.paused = false;
-        if (i === null) {
-            c++;
-            y();
+    F.read(t, D(e), r);
+}
+
+exports.out.stat = O;
+
+function T(t, e) {
+    const r = D(e);
+    return w.read(t, r);
+}
+
+exports.out.statSync = T;
+
+function D(t = {}) {
+    if (t instanceof L.default) {
+        return t;
+    }
+    return new L.default(t);
+}
+
+var j = {};
+
+Object.defineProperty(j, "__esModule", {
+    value: true
+});
+
+j.IS_SUPPORT_READDIR_WITH_FILE_TYPES = void 0;
+
+const A = process.versions.node.split(".");
+
+if (A[0] === undefined || A[1] === undefined) {
+    throw new Error(`Unexpected behavior. The 'process.versions.node' variable has invalid value: ${process.versions.node}`);
+}
+
+const I = Number.parseInt(A[0], 10);
+
+const M = Number.parseInt(A[1], 10);
+
+const R = 10;
+
+const x = 10;
+
+const V = I > R;
+
+const q = I === R && M >= x;
+
+j.IS_SUPPORT_READDIR_WITH_FILE_TYPES = V || q;
+
+var B = {};
+
+var Y = {};
+
+Object.defineProperty(Y, "__esModule", {
+    value: true
+});
+
+Y.createDirentFromStats = void 0;
+
+class DirentFromStats {
+    constructor(t, e) {
+        this.name = t;
+        this.isBlockDevice = e.isBlockDevice.bind(e);
+        this.isCharacterDevice = e.isCharacterDevice.bind(e);
+        this.isDirectory = e.isDirectory.bind(e);
+        this.isFIFO = e.isFIFO.bind(e);
+        this.isFile = e.isFile.bind(e);
+        this.isSocket = e.isSocket.bind(e);
+        this.isSymbolicLink = e.isSymbolicLink.bind(e);
+    }
+}
+
+function $(t, e) {
+    return new DirentFromStats(t, e);
+}
+
+Y.createDirentFromStats = $;
+
+Object.defineProperty(B, "__esModule", {
+    value: true
+});
+
+B.fs = void 0;
+
+const W = Y;
+
+B.fs = W;
+
+var Q = {};
+
+Object.defineProperty(Q, "__esModule", {
+    value: true
+});
+
+Q.joinPathSegments = void 0;
+
+function N(t, e, r) {
+    if (t.endsWith(r)) {
+        return t + e;
+    }
+    return t + r + e;
+}
+
+Q.joinPathSegments = N;
+
+Object.defineProperty(f, "__esModule", {
+    value: true
+});
+
+f.readdir = f.readdirWithFileTypes = f.read = void 0;
+
+const U = exports.out;
+
+const H = r.runParallel_1;
+
+const C = j;
+
+const z = B;
+
+const G = Q;
+
+function J(t, e, r) {
+    if (!e.stats && C.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+        K(t, e, r);
+        return;
+    }
+    Z(t, e, r);
+}
+
+f.read = J;
+
+function K(t, e, r) {
+    e.fs.readdir(t, {
+        withFileTypes: true
+    }, (s, i) => {
+        if (s !== null) {
+            tt(r, s);
             return;
         }
-        for (;i && c < t; ) {
-            c++;
-            y();
+        const n = i.map(r => ({
+            dirent: r,
+            name: r.name,
+            path: G.joinPathSegments(t, r.name, e.pathSegmentSeparator)
+        }));
+        if (!e.followSymbolicLinks) {
+            et(r, n);
+            return;
         }
-    }
-    function k() {
-        return c === 0 && s.length() === 0;
-    }
-    function w(r, a) {
-        var v = l.get();
-        v.context = e;
-        v.release = y;
-        v.value = r;
-        v.callback = a || u;
-        v.errorHandler = f;
-        if (c >= t || s.paused) {
-            if (o) {
-                o.next = v;
-                o = v;
-            } else {
-                i = v;
-                o = v;
-                s.saturated();
+        const o = n.map(t => X(t, e));
+        H(o, (t, e) => {
+            if (t !== null) {
+                tt(r, t);
+                return;
             }
-        } else {
-            c++;
-            n.call(e, v.value, v.worked);
+            et(r, e);
+        });
+    });
+}
+
+f.readdirWithFileTypes = K;
+
+function X(t, e) {
+    return r => {
+        if (!t.dirent.isSymbolicLink()) {
+            r(null, t);
+            return;
         }
+        e.fs.stat(t.path, (s, i) => {
+            if (s !== null) {
+                if (e.throwErrorOnBrokenSymbolicLink) {
+                    r(s);
+                    return;
+                }
+                r(null, t);
+                return;
+            }
+            t.dirent = z.fs.createDirentFromStats(t.name, i);
+            r(null, t);
+        });
+    };
+}
+
+function Z(t, e, r) {
+    e.fs.readdir(t, (s, i) => {
+        if (s !== null) {
+            tt(r, s);
+            return;
+        }
+        const n = i.map(r => {
+            const s = G.joinPathSegments(t, r, e.pathSegmentSeparator);
+            return t => {
+                U.stat(s, e.fsStatSettings, (i, n) => {
+                    if (i !== null) {
+                        t(i);
+                        return;
+                    }
+                    const o = {
+                        name: r,
+                        path: s,
+                        dirent: z.fs.createDirentFromStats(r, n)
+                    };
+                    if (e.stats) {
+                        o.stats = n;
+                    }
+                    t(null, o);
+                });
+            };
+        });
+        H(n, (t, e) => {
+            if (t !== null) {
+                tt(r, t);
+                return;
+            }
+            et(r, e);
+        });
+    });
+}
+
+f.readdir = Z;
+
+function tt(t, e) {
+    t(e);
+}
+
+function et(t, e) {
+    t(null, e);
+}
+
+var rt = {};
+
+Object.defineProperty(rt, "__esModule", {
+    value: true
+});
+
+rt.readdir = rt.readdirWithFileTypes = rt.read = void 0;
+
+const st = exports.out;
+
+const it = j;
+
+const nt = B;
+
+const ot = Q;
+
+function at(t, e) {
+    if (!e.stats && it.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+        return ut(t, e);
     }
-    function g(r, a) {
-        var v = l.get();
-        v.context = e;
-        v.release = y;
-        v.value = r;
-        v.callback = a || u;
-        v.errorHandler = f;
-        if (c >= t || s.paused) {
-            if (i) {
-                v.next = i;
-                i = v;
-            } else {
-                i = v;
-                o = v;
-                s.saturated();
+    return ct(t, e);
+}
+
+rt.read = at;
+
+function ut(t, e) {
+    const r = e.fs.readdirSync(t, {
+        withFileTypes: true
+    });
+    return r.map(r => {
+        const s = {
+            dirent: r,
+            name: r.name,
+            path: ot.joinPathSegments(t, r.name, e.pathSegmentSeparator)
+        };
+        if (s.dirent.isSymbolicLink() && e.followSymbolicLinks) {
+            try {
+                const t = e.fs.statSync(s.path);
+                s.dirent = nt.fs.createDirentFromStats(s.name, t);
+            } catch (t) {
+                if (e.throwErrorOnBrokenSymbolicLink) {
+                    throw t;
+                }
             }
-        } else {
-            c++;
-            n.call(e, v.value, v.worked);
         }
+        return s;
+    });
+}
+
+rt.readdirWithFileTypes = ut;
+
+function ct(t, e) {
+    const r = e.fs.readdirSync(t);
+    return r.map(r => {
+        const s = ot.joinPathSegments(t, r, e.pathSegmentSeparator);
+        const i = st.statSync(s, e.fsStatSettings);
+        const n = {
+            name: r,
+            path: s,
+            dirent: nt.fs.createDirentFromStats(r, i)
+        };
+        if (e.stats) {
+            n.stats = i;
+        }
+        return n;
+    });
+}
+
+rt.readdir = ct;
+
+var lt = {};
+
+var dt = {};
+
+(function(t) {
+    Object.defineProperty(t, "__esModule", {
+        value: true
+    });
+    t.createFileSystemAdapter = t.FILE_SYSTEM_ADAPTER = void 0;
+    const e = u.default;
+    t.FILE_SYSTEM_ADAPTER = {
+        lstat: e.lstat,
+        stat: e.stat,
+        lstatSync: e.lstatSync,
+        statSync: e.statSync,
+        readdir: e.readdir,
+        readdirSync: e.readdirSync
+    };
+    function r(e) {
+        if (e === undefined) {
+            return t.FILE_SYSTEM_ADAPTER;
+        }
+        return Object.assign(Object.assign({}, t.FILE_SYSTEM_ADAPTER), e);
     }
-    function y(r) {
-        if (r) {
-            l.release(r);
+    t.createFileSystemAdapter = r;
+})(dt);
+
+Object.defineProperty(lt, "__esModule", {
+    value: true
+});
+
+const ht = c.default;
+
+const _t = exports.out;
+
+const ft = dt;
+
+let St = class Settings {
+    constructor(t = {}) {
+        this._options = t;
+        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
+        this.fs = ft.createFileSystemAdapter(this._options.fs);
+        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, ht.sep);
+        this.stats = this._getValue(this._options.stats, false);
+        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
+        this.fsStatSettings = new _t.Settings({
+            followSymbolicLink: this.followSymbolicLinks,
+            fs: this.fs,
+            throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
+        });
+    }
+    _getValue(t, e) {
+        return t !== null && t !== void 0 ? t : e;
+    }
+};
+
+lt.default = St;
+
+Object.defineProperty(_, "__esModule", {
+    value: true
+});
+
+_.Settings = _.scandirSync = _.scandir = void 0;
+
+const pt = f;
+
+const yt = rt;
+
+const mt = lt;
+
+_.Settings = mt.default;
+
+function gt(t, e, r) {
+    if (typeof e === "function") {
+        pt.read(t, Et(), e);
+        return;
+    }
+    pt.read(t, Et(e), r);
+}
+
+_.scandir = gt;
+
+function bt(t, e) {
+    const r = Et(e);
+    return yt.read(t, r);
+}
+
+_.scandirSync = bt;
+
+function Et(t = {}) {
+    if (t instanceof mt.default) {
+        return t;
+    }
+    return new mt.default(t);
+}
+
+var vt = {};
+
+Object.defineProperty(vt, "__esModule", {
+    value: true
+});
+
+vt.joinPathSegments = vt.replacePathSegmentSeparator = vt.isAppliedFilter = vt.isFatalError = void 0;
+
+function Pt(t, e) {
+    if (t.errorFilter === null) {
+        return true;
+    }
+    return !t.errorFilter(e);
+}
+
+vt.isFatalError = Pt;
+
+function kt(t, e) {
+    return t === null || t(e);
+}
+
+vt.isAppliedFilter = kt;
+
+function Ft(t, e) {
+    return t.split(/[/\\]/).join(e);
+}
+
+vt.replacePathSegmentSeparator = Ft;
+
+function wt(t, e, r) {
+    if (t === "") {
+        return e;
+    }
+    if (t.endsWith(r)) {
+        return t + e;
+    }
+    return t + r + e;
+}
+
+vt.joinPathSegments = wt;
+
+var Lt = {};
+
+Object.defineProperty(Lt, "__esModule", {
+    value: true
+});
+
+const Ot = vt;
+
+class Reader {
+    constructor(t, e) {
+        this._root = t;
+        this._settings = e;
+        this._root = Ot.replacePathSegmentSeparator(t, e.pathSegmentSeparator);
+    }
+}
+
+Lt.default = Reader;
+
+Object.defineProperty(h, "__esModule", {
+    value: true
+});
+
+const Tt = a.default;
+
+const Dt = _;
+
+const jt = i.queueExports;
+
+const At = vt;
+
+const It = Lt;
+
+class AsyncReader extends It.default {
+    constructor(t, e) {
+        super(t, e);
+        this._settings = e;
+        this._scandir = Dt.scandir;
+        this._emitter = new Tt.EventEmitter;
+        this._queue = jt(this._worker.bind(this), this._settings.concurrency);
+        this._isFatalError = false;
+        this._isDestroyed = false;
+        this._queue.drain = () => {
+            if (!this._isFatalError) {
+                this._emitter.emit("end");
+            }
+        };
+    }
+    read() {
+        this._isFatalError = false;
+        this._isDestroyed = false;
+        setImmediate(() => {
+            this._pushToQueue(this._root, this._settings.basePath);
+        });
+        return this._emitter;
+    }
+    get isDestroyed() {
+        return this._isDestroyed;
+    }
+    destroy() {
+        if (this._isDestroyed) {
+            throw new Error("The reader is already destroyed");
         }
-        var u = i;
-        if (u && c <= t) {
-            if (!s.paused) {
-                if (o === i) {
-                    o = null;
-                }
-                i = u.next;
-                u.next = null;
-                n.call(e, u.value, u.worked);
-                if (o === null) {
-                    s.empty();
-                }
-            } else {
-                c--;
+        this._isDestroyed = true;
+        this._queue.killAndDrain();
+    }
+    onEntry(t) {
+        this._emitter.on("entry", t);
+    }
+    onError(t) {
+        this._emitter.once("error", t);
+    }
+    onEnd(t) {
+        this._emitter.once("end", t);
+    }
+    _pushToQueue(t, e) {
+        const r = {
+            directory: t,
+            base: e
+        };
+        this._queue.push(r, t => {
+            if (t !== null) {
+                this._handleError(t);
+            }
+        });
+    }
+    _worker(t, e) {
+        this._scandir(t.directory, this._settings.fsScandirSettings, (r, s) => {
+            if (r !== null) {
+                e(r, undefined);
+                return;
+            }
+            for (const e of s) {
+                this._handleEntry(e, t.base);
             }
-        } else if (--c === 0) {
-            s.drain();
+            e(null, undefined);
+        });
+    }
+    _handleError(t) {
+        if (this._isDestroyed || !At.isFatalError(this._settings, t)) {
+            return;
         }
+        this._isFatalError = true;
+        this._isDestroyed = true;
+        this._emitter.emit("error", t);
     }
-    function m() {
-        i = null;
-        o = null;
-        s.drain = u;
-    }
-    function b() {
-        i = null;
-        o = null;
-        s.drain();
-        s.drain = u;
-    }
-    function q(e) {
-        f = e;
-    }
-}
-
-function u() {}
-
-function a() {
-    this.value = null;
-    this.callback = u;
-    this.next = null;
-    this.release = u;
-    this.context = null;
-    this.errorHandler = null;
-    var e = this;
-    this.worked = function n(r, t) {
-        var a = e.callback;
-        var l = e.errorHandler;
-        var i = e.value;
-        e.value = null;
-        e.callback = u;
-        if (e.errorHandler) {
-            l(r, i);
+    _handleEntry(t, e) {
+        if (this._isDestroyed || this._isFatalError) {
+            return;
         }
-        a.call(e.context, r, t);
-        e.release(e);
-    };
+        const r = t.path;
+        if (e !== undefined) {
+            t.path = At.joinPathSegments(e, t.name, this._settings.pathSegmentSeparator);
+        }
+        if (At.isAppliedFilter(this._settings.entryFilter, t)) {
+            this._emitEntry(t);
+        }
+        if (t.dirent.isDirectory() && At.isAppliedFilter(this._settings.deepFilter, t)) {
+            this._pushToQueue(r, e === undefined ? undefined : t.path);
+        }
+    }
+    _emitEntry(t) {
+        this._emitter.emit("entry", t);
+    }
 }
 
-function l(e, n, r) {
-    if (typeof e === "function") {
-        r = n;
-        n = e;
-        e = null;
-    }
-    function a(e, r) {
-        n.call(this, e).then(function(e) {
-            r(null, e);
-        }, r);
-    }
-    var l = t(e, a, r);
-    var i = l.push;
-    var o = l.unshift;
-    l.push = c;
-    l.unshift = f;
-    l.drained = s;
-    return l;
-    function c(e) {
-        var n = new Promise(function(n, r) {
-            i(e, function(e, t) {
-                if (e) {
-                    r(e);
-                    return;
-                }
-                n(t);
-            });
+h.default = AsyncReader;
+
+Object.defineProperty(d, "__esModule", {
+    value: true
+});
+
+const Mt = h;
+
+class AsyncProvider {
+    constructor(t, e) {
+        this._root = t;
+        this._settings = e;
+        this._reader = new Mt.default(this._root, this._settings);
+        this._storage = [];
+    }
+    read(t) {
+        this._reader.onError(e => {
+            Rt(t, e);
         });
-        n.catch(u);
-        return n;
+        this._reader.onEntry(t => {
+            this._storage.push(t);
+        });
+        this._reader.onEnd(() => {
+            xt(t, this._storage);
+        });
+        this._reader.read();
     }
-    function f(e) {
-        var n = new Promise(function(n, r) {
-            o(e, function(e, t) {
-                if (e) {
-                    r(e);
-                    return;
+}
+
+d.default = AsyncProvider;
+
+function Rt(t, e) {
+    t(e);
+}
+
+function xt(t, e) {
+    t(null, e);
+}
+
+var Vt = {};
+
+Object.defineProperty(Vt, "__esModule", {
+    value: true
+});
+
+const qt = l.default;
+
+const Bt = h;
+
+class StreamProvider {
+    constructor(t, e) {
+        this._root = t;
+        this._settings = e;
+        this._reader = new Bt.default(this._root, this._settings);
+        this._stream = new qt.Readable({
+            objectMode: true,
+            read: () => {},
+            destroy: () => {
+                if (!this._reader.isDestroyed) {
+                    this._reader.destroy();
                 }
-                n(t);
-            });
+            }
         });
-        n.catch(u);
-        return n;
     }
-    function s() {
-        var e = new Promise(function(e) {
-            process.nextTick(function() {
-                if (l.idle()) {
-                    e();
-                } else {
-                    var n = l.drain;
-                    l.drain = function() {
-                        if (typeof n === "function") n();
-                        e();
-                        l.drain = n;
-                    };
-                }
-            });
+    read() {
+        this._reader.onError(t => {
+            this._stream.emit("error", t);
         });
-        return e;
+        this._reader.onEntry(t => {
+            this._stream.push(t);
+        });
+        this._reader.onEnd(() => {
+            this._stream.push(null);
+        });
+        this._reader.read();
+        return this._stream;
     }
 }
 
-n.exports = t;
+Vt.default = StreamProvider;
+
+var Yt = {};
+
+var $t = {};
+
+Object.defineProperty($t, "__esModule", {
+    value: true
+});
+
+const Wt = _;
+
+const Qt = vt;
 
-n.exports.promise = l;
+const Nt = Lt;
 
-exports.queueExports = n.exports;
+class SyncReader extends Nt.default {
+    constructor() {
+        super(...arguments);
+        this._scandir = Wt.scandirSync;
+        this._storage = [];
+        this._queue = new Set;
+    }
+    read() {
+        this._pushToQueue(this._root, this._settings.basePath);
+        this._handleQueue();
+        return this._storage;
+    }
+    _pushToQueue(t, e) {
+        this._queue.add({
+            directory: t,
+            base: e
+        });
+    }
+    _handleQueue() {
+        for (const t of this._queue.values()) {
+            this._handleDirectory(t.directory, t.base);
+        }
+    }
+    _handleDirectory(t, e) {
+        try {
+            const r = this._scandir(t, this._settings.fsScandirSettings);
+            for (const t of r) {
+                this._handleEntry(t, e);
+            }
+        } catch (t) {
+            this._handleError(t);
+        }
+    }
+    _handleError(t) {
+        if (!Qt.isFatalError(this._settings, t)) {
+            return;
+        }
+        throw t;
+    }
+    _handleEntry(t, e) {
+        const r = t.path;
+        if (e !== undefined) {
+            t.path = Qt.joinPathSegments(e, t.name, this._settings.pathSegmentSeparator);
+        }
+        if (Qt.isAppliedFilter(this._settings.entryFilter, t)) {
+            this._pushToStorage(t);
+        }
+        if (t.dirent.isDirectory() && Qt.isAppliedFilter(this._settings.deepFilter, t)) {
+            this._pushToQueue(r, e === undefined ? undefined : t.path);
+        }
+    }
+    _pushToStorage(t) {
+        this._storage.push(t);
+    }
+}
+
+$t.default = SyncReader;
+
+Object.defineProperty(Yt, "__esModule", {
+    value: true
+});
+
+const Ut = $t;
+
+class SyncProvider {
+    constructor(t, e) {
+        this._root = t;
+        this._settings = e;
+        this._reader = new Ut.default(this._root, this._settings);
+    }
+    read() {
+        return this._reader.read();
+    }
+}
+
+Yt.default = SyncProvider;
+
+var Ht = {};
+
+Object.defineProperty(Ht, "__esModule", {
+    value: true
+});
+
+const Ct = c.default;
+
+const zt = _;
+
+class Settings {
+    constructor(t = {}) {
+        this._options = t;
+        this.basePath = this._getValue(this._options.basePath, undefined);
+        this.concurrency = this._getValue(this._options.concurrency, Number.POSITIVE_INFINITY);
+        this.deepFilter = this._getValue(this._options.deepFilter, null);
+        this.entryFilter = this._getValue(this._options.entryFilter, null);
+        this.errorFilter = this._getValue(this._options.errorFilter, null);
+        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, Ct.sep);
+        this.fsScandirSettings = new zt.Settings({
+            followSymbolicLinks: this._options.followSymbolicLinks,
+            fs: this._options.fs,
+            pathSegmentSeparator: this._options.pathSegmentSeparator,
+            stats: this._options.stats,
+            throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
+        });
+    }
+    _getValue(t, e) {
+        return t !== null && t !== void 0 ? t : e;
+    }
+}
+
+Ht.default = Settings;
+
+Object.defineProperty(exports.out$1, "__esModule", {
+    value: true
+});
+
+exports.out$1.Settings = exports.out$1.walkStream = exports.out$1.walkSync = exports.out$1.walk = void 0;
+
+const Gt = d;
+
+const Jt = Vt;
+
+const Kt = Yt;
+
+const Xt = Ht;
+
+exports.out$1.Settings = Xt.default;
+
+function Zt(t, e, r) {
+    if (typeof e === "function") {
+        new Gt.default(t, re()).read(e);
+        return;
+    }
+    new Gt.default(t, re(e)).read(r);
+}
+
+exports.out$1.walk = Zt;
+
+function te(t, e) {
+    const r = re(e);
+    const s = new Kt.default(t, r);
+    return s.read();
+}
+
+exports.out$1.walkSync = te;
+
+function ee(t, e) {
+    const r = re(e);
+    const s = new Jt.default(t, r);
+    return s.read();
+}
+
+exports.out$1.walkStream = ee;
+
+function re(t = {}) {
+    if (t instanceof Xt.default) {
+        return t;
+    }
+    return new Xt.default(t);
+}