lakutata 2.0.95 → 2.0.96

package/vendor/Package.internal.92.mjs

@@ -1,208 +1,1433 @@
-/* Build Date: Mon Nov 24 2025 17:58:53 GMT+0800 (China Standard Time) */
-var e = u;
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
+import t from "os";
 
-u.default = u;
+import e from "path";
 
-u.stable = s;
+import { i as r } from "./Package.internal.93.mjs";
 
-u.stableStringify = s;
+import { m as s } from "./Package.internal.94.mjs";
 
-var r = "[...]";
+import { m as n } from "./Package.internal.95.mjs";
 
-var t = "[Circular]";
+import { o as i, a as o } from "./Package.internal.16.mjs";
 
-var i = [];
+import a from "stream";
 
-var n = [];
+import c from "fs";
 
-function f() {
+var u = {};
+
+var l = {};
+
+var h = {};
+
+Object.defineProperty(h, "__esModule", {
+    value: true
+});
+
+h.splitWhen = h.flatten = void 0;
+
+function f(t) {
+    return t.reduce((t, e) => [].concat(t, e), []);
+}
+
+h.flatten = f;
+
+function p(t, e) {
+    const r = [ [] ];
+    let s = 0;
+    for (const n of t) {
+        if (e(n)) {
+            s++;
+            r[s] = [];
+        } else {
+            r[s].push(n);
+        }
+    }
+    return r;
+}
+
+h.splitWhen = p;
+
+var d = {};
+
+Object.defineProperty(d, "__esModule", {
+    value: true
+});
+
+d.isEnoentCodeError = void 0;
+
+function _(t) {
+    return t.code === "ENOENT";
+}
+
+d.isEnoentCodeError = _;
+
+var g = {};
+
+Object.defineProperty(g, "__esModule", {
+    value: true
+});
+
+g.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 m(t, e) {
+    return new DirentFromStats(t, e);
+}
+
+g.createDirentFromStats = m;
+
+var y = {};
+
+Object.defineProperty(y, "__esModule", {
+    value: true
+});
+
+y.convertPosixPathToPattern = y.convertWindowsPathToPattern = y.convertPathToPattern = y.escapePosixPath = y.escapeWindowsPath = y.escape = y.removeLeadingDotSegment = y.makeAbsolute = y.unixify = void 0;
+
+const P = t;
+
+const v = e;
+
+const b = P.platform() === "win32";
+
+const S = 2;
+
+const k = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
+
+const E = /(\\?)([()[\]{}]|^!|[!+@](?=\())/g;
+
+const O = /^\\\\([.?])/;
+
+const w = /\\(?![!()+@[\]{}])/g;
+
+function D(t) {
+    return t.replace(/\\/g, "/");
+}
+
+y.unixify = D;
+
+function T(t, e) {
+    return v.resolve(t, e);
+}
+
+y.makeAbsolute = T;
+
+function M(t) {
+    if (t.charAt(0) === ".") {
+        const e = t.charAt(1);
+        if (e === "/" || e === "\\") {
+            return t.slice(S);
+        }
+    }
+    return t;
+}
+
+y.removeLeadingDotSegment = M;
+
+y.escape = b ? F : x;
+
+function F(t) {
+    return t.replace(E, "\\$2");
+}
+
+y.escapeWindowsPath = F;
+
+function x(t) {
+    return t.replace(k, "\\$2");
+}
+
+y.escapePosixPath = x;
+
+y.convertPathToPattern = b ? j : R;
+
+function j(t) {
+    return F(t).replace(O, "//$1").replace(w, "/");
+}
+
+y.convertWindowsPathToPattern = j;
+
+function R(t) {
+    return x(t);
+}
+
+y.convertPosixPathToPattern = R;
+
+var A = {};
+
+var L = r;
+
+var B = e.posix.dirname;
+
+var N = t.platform() === "win32";
+
+var V = "/";
+
+var W = /\\/g;
+
+var I = /[\{\[].*[\}\]]$/;
+
+var C = /(^|[^\\])([\{\[]|\([^\)]+$)/;
+
+var G = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
+
+var $ = function t(e, r) {
+    var s = Object.assign({
+        flipBackslashes: true
+    }, r);
+    if (s.flipBackslashes && N && e.indexOf(V) < 0) {
+        e = e.replace(W, V);
+    }
+    if (I.test(e)) {
+        e += V;
+    }
+    e += "a";
+    do {
+        e = B(e);
+    } while (L(e) || C.test(e));
+    return e.replace(G, "$1");
+};
+
+Object.defineProperty(A, "__esModule", {
+    value: true
+});
+
+A.isAbsolute = A.partitionAbsoluteAndRelative = A.removeDuplicateSlashes = A.matchAny = A.convertPatternsToRe = A.makeRe = A.getPatternParts = A.expandBraceExpansion = A.expandPatternsWithBraceExpansion = A.isAffectDepthOfReadingPattern = A.endsWithSlashGlobStar = A.hasGlobStar = A.getBaseDirectory = A.isPatternRelatedToParentDirectory = A.getPatternsOutsideCurrentDirectory = A.getPatternsInsideCurrentDirectory = A.getPositivePatterns = A.getNegativePatterns = A.isPositivePattern = A.isNegativePattern = A.convertToNegativePattern = A.convertToPositivePattern = A.isDynamicPattern = A.isStaticPattern = void 0;
+
+const q = e;
+
+const U = $;
+
+const Y = s;
+
+const z = "**";
+
+const H = "\\";
+
+const J = /[*?]|^!/;
+
+const K = /\[[^[]*]/;
+
+const Q = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
+
+const X = /[!*+?@]\([^(]*\)/;
+
+const Z = /,|\.\./;
+
+const tt = /(?!^)\/{2,}/g;
+
+function et(t, e = {}) {
+    return !rt(t, e);
+}
+
+A.isStaticPattern = et;
+
+function rt(t, e = {}) {
+    if (t === "") {
+        return false;
+    }
+    if (e.caseSensitiveMatch === false || t.includes(H)) {
+        return true;
+    }
+    if (J.test(t) || K.test(t) || Q.test(t)) {
+        return true;
+    }
+    if (e.extglob !== false && X.test(t)) {
+        return true;
+    }
+    if (e.braceExpansion !== false && st(t)) {
+        return true;
+    }
+    return false;
+}
+
+A.isDynamicPattern = rt;
+
+function st(t) {
+    const e = t.indexOf("{");
+    if (e === -1) {
+        return false;
+    }
+    const r = t.indexOf("}", e + 1);
+    if (r === -1) {
+        return false;
+    }
+    const s = t.slice(e, r);
+    return Z.test(s);
+}
+
+function nt(t) {
+    return ot(t) ? t.slice(1) : t;
+}
+
+A.convertToPositivePattern = nt;
+
+function it(t) {
+    return "!" + t;
+}
+
+A.convertToNegativePattern = it;
+
+function ot(t) {
+    return t.startsWith("!") && t[1] !== "(";
+}
+
+A.isNegativePattern = ot;
+
+function at(t) {
+    return !ot(t);
+}
+
+A.isPositivePattern = at;
+
+function ct(t) {
+    return t.filter(ot);
+}
+
+A.getNegativePatterns = ct;
+
+function ut(t) {
+    return t.filter(at);
+}
+
+A.getPositivePatterns = ut;
+
+function lt(t) {
+    return t.filter(t => !ft(t));
+}
+
+A.getPatternsInsideCurrentDirectory = lt;
+
+function ht(t) {
+    return t.filter(ft);
+}
+
+A.getPatternsOutsideCurrentDirectory = ht;
+
+function ft(t) {
+    return t.startsWith("..") || t.startsWith("./..");
+}
+
+A.isPatternRelatedToParentDirectory = ft;
+
+function pt(t) {
+    return U(t, {
+        flipBackslashes: false
+    });
+}
+
+A.getBaseDirectory = pt;
+
+function dt(t) {
+    return t.includes(z);
+}
+
+A.hasGlobStar = dt;
+
+function _t(t) {
+    return t.endsWith("/" + z);
+}
+
+A.endsWithSlashGlobStar = _t;
+
+function gt(t) {
+    const e = q.basename(t);
+    return _t(t) || et(e);
+}
+
+A.isAffectDepthOfReadingPattern = gt;
+
+function mt(t) {
+    return t.reduce((t, e) => t.concat(yt(e)), []);
+}
+
+A.expandPatternsWithBraceExpansion = mt;
+
+function yt(t) {
+    const e = Y.braces(t, {
+        expand: true,
+        nodupes: true,
+        keepEscaping: true
+    });
+    e.sort((t, e) => t.length - e.length);
+    return e.filter(t => t !== "");
+}
+
+A.expandBraceExpansion = yt;
+
+function Pt(t, e) {
+    let {parts: r} = Y.scan(t, Object.assign(Object.assign({}, e), {
+        parts: true
+    }));
+    if (r.length === 0) {
+        r = [ t ];
+    }
+    if (r[0].startsWith("/")) {
+        r[0] = r[0].slice(1);
+        r.unshift("");
+    }
+    return r;
+}
+
+A.getPatternParts = Pt;
+
+function vt(t, e) {
+    return Y.makeRe(t, e);
+}
+
+A.makeRe = vt;
+
+function bt(t, e) {
+    return t.map(t => vt(t, e));
+}
+
+A.convertPatternsToRe = bt;
+
+function St(t, e) {
+    return e.some(e => e.test(t));
+}
+
+A.matchAny = St;
+
+function kt(t) {
+    return t.replace(tt, "/");
+}
+
+A.removeDuplicateSlashes = kt;
+
+function Et(t) {
+    const e = [];
+    const r = [];
+    for (const s of t) {
+        if (Ot(s)) {
+            e.push(s);
+        } else {
+            r.push(s);
+        }
+    }
+    return [ e, r ];
+}
+
+A.partitionAbsoluteAndRelative = Et;
+
+function Ot(t) {
+    return q.isAbsolute(t);
+}
+
+A.isAbsolute = Ot;
+
+var wt = {};
+
+Object.defineProperty(wt, "__esModule", {
+    value: true
+});
+
+wt.merge = void 0;
+
+const Dt = n;
+
+function Tt(t) {
+    const e = Dt(t);
+    t.forEach(t => {
+        t.once("error", t => e.emit("error", t));
+    });
+    e.once("close", () => Mt(t));
+    e.once("end", () => Mt(t));
+    return e;
+}
+
+wt.merge = Tt;
+
+function Mt(t) {
+    t.forEach(t => t.emit("close"));
+}
+
+var Ft = {};
+
+Object.defineProperty(Ft, "__esModule", {
+    value: true
+});
+
+Ft.isEmpty = Ft.isString = void 0;
+
+function xt(t) {
+    return typeof t === "string";
+}
+
+Ft.isString = xt;
+
+function jt(t) {
+    return t === "";
+}
+
+Ft.isEmpty = jt;
+
+Object.defineProperty(l, "__esModule", {
+    value: true
+});
+
+l.string = l.stream = l.pattern = l.path = l.fs = l.errno = l.array = void 0;
+
+const Rt = h;
+
+l.array = Rt;
+
+const At = d;
+
+l.errno = At;
+
+const Lt = g;
+
+l.fs = Lt;
+
+const Bt = y;
+
+l.path = Bt;
+
+const Nt = A;
+
+l.pattern = Nt;
+
+const Vt = wt;
+
+l.stream = Vt;
+
+const Wt = Ft;
+
+l.string = Wt;
+
+Object.defineProperty(u, "__esModule", {
+    value: true
+});
+
+u.convertPatternGroupToTask = u.convertPatternGroupsToTasks = u.groupPatternsByBaseDirectory = u.getNegativePatternsAsPositive = u.getPositivePatterns = u.convertPatternsToTasks = u.generate = void 0;
+
+const It = l;
+
+function Ct(t, e) {
+    const r = Gt(t, e);
+    const s = Gt(e.ignore, e);
+    const n = qt(r);
+    const i = Ut(r, s);
+    const o = n.filter(t => It.pattern.isStaticPattern(t, e));
+    const a = n.filter(t => It.pattern.isDynamicPattern(t, e));
+    const c = $t(o, i, false);
+    const u = $t(a, i, true);
+    return c.concat(u);
+}
+
+u.generate = Ct;
+
+function Gt(t, e) {
+    let r = t;
+    if (e.braceExpansion) {
+        r = It.pattern.expandPatternsWithBraceExpansion(r);
+    }
+    if (e.baseNameMatch) {
+        r = r.map(t => t.includes("/") ? t : `**/${t}`);
+    }
+    return r.map(t => It.pattern.removeDuplicateSlashes(t));
+}
+
+function $t(t, e, r) {
+    const s = [];
+    const n = It.pattern.getPatternsOutsideCurrentDirectory(t);
+    const i = It.pattern.getPatternsInsideCurrentDirectory(t);
+    const o = Yt(n);
+    const a = Yt(i);
+    s.push(...zt(o, e, r));
+    if ("." in a) {
+        s.push(Ht(".", i, e, r));
+    } else {
+        s.push(...zt(a, e, r));
+    }
+    return s;
+}
+
+u.convertPatternsToTasks = $t;
+
+function qt(t) {
+    return It.pattern.getPositivePatterns(t);
+}
+
+u.getPositivePatterns = qt;
+
+function Ut(t, e) {
+    const r = It.pattern.getNegativePatterns(t).concat(e);
+    const s = r.map(It.pattern.convertToPositivePattern);
+    return s;
+}
+
+u.getNegativePatternsAsPositive = Ut;
+
+function Yt(t) {
+    const e = {};
+    return t.reduce((t, e) => {
+        const r = It.pattern.getBaseDirectory(e);
+        if (r in t) {
+            t[r].push(e);
+        } else {
+            t[r] = [ e ];
+        }
+        return t;
+    }, e);
+}
+
+u.groupPatternsByBaseDirectory = Yt;
+
+function zt(t, e, r) {
+    return Object.keys(t).map(s => Ht(s, t[s], e, r));
+}
+
+u.convertPatternGroupsToTasks = zt;
+
+function Ht(t, e, r, s) {
     return {
-        depthLimit: Number.MAX_SAFE_INTEGER,
-        edgesLimit: Number.MAX_SAFE_INTEGER
+        dynamic: s,
+        positive: e,
+        negative: r,
+        base: t,
+        patterns: [].concat(e, r.map(It.pattern.convertToNegativePattern))
     };
 }
 
-function u(e, r, t, u) {
-    if (typeof u === "undefined") {
-        u = f();
+u.convertPatternGroupToTask = Ht;
+
+var Jt = {};
+
+var Kt = {};
+
+var Qt = {};
+
+Object.defineProperty(Qt, "__esModule", {
+    value: true
+});
+
+const Xt = e;
+
+const Zt = i;
+
+const te = l;
+
+class Reader {
+    constructor(t) {
+        this._settings = t;
+        this._fsStatSettings = new Zt.Settings({
+            followSymbolicLink: this._settings.followSymbolicLinks,
+            fs: this._settings.fs,
+            throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
+        });
     }
-    l(e, "", 0, [], undefined, 0, u);
-    var o;
-    try {
-        if (n.length === 0) {
-            o = JSON.stringify(e, r, t);
-        } else {
-            o = JSON.stringify(e, c(r), t);
-        }
-    } catch (e) {
-        return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
-    } finally {
-        while (i.length !== 0) {
-            var a = i.pop();
-            if (a.length === 4) {
-                Object.defineProperty(a[0], a[1], a[3]);
-            } else {
-                a[0][a[1]] = a[2];
+    _getFullEntryPath(t) {
+        return Xt.resolve(this._settings.cwd, t);
+    }
+    _makeEntry(t, e) {
+        const r = {
+            name: e,
+            path: e,
+            dirent: te.fs.createDirentFromStats(e, t)
+        };
+        if (this._settings.stats) {
+            r.stats = t;
+        }
+        return r;
+    }
+    _isFatalError(t) {
+        return !te.errno.isEnoentCodeError(t) && !this._settings.suppressErrors;
+    }
+}
+
+Qt.default = Reader;
+
+var ee = {};
+
+Object.defineProperty(ee, "__esModule", {
+    value: true
+});
+
+const re = a;
+
+const se = i;
+
+const ne = o;
+
+const ie = Qt;
+
+class ReaderStream extends ie.default {
+    constructor() {
+        super(...arguments);
+        this._walkStream = ne.walkStream;
+        this._stat = se.stat;
+    }
+    dynamic(t, e) {
+        return this._walkStream(t, e);
+    }
+    static(t, e) {
+        const r = t.map(this._getFullEntryPath, this);
+        const s = new re.PassThrough({
+            objectMode: true
+        });
+        s._write = (n, i, o) => this._getEntry(r[n], t[n], e).then(t => {
+            if (t !== null && e.entryFilter(t)) {
+                s.push(t);
             }
+            if (n === r.length - 1) {
+                s.end();
+            }
+            o();
+        }).catch(o);
+        for (let t = 0; t < r.length; t++) {
+            s.write(t);
         }
+        return s;
+    }
+    _getEntry(t, e, r) {
+        return this._getStat(t).then(t => this._makeEntry(t, e)).catch(t => {
+            if (r.errorFilter(t)) {
+                return null;
+            }
+            throw t;
+        });
+    }
+    _getStat(t) {
+        return new Promise((e, r) => {
+            this._stat(t, this._fsStatSettings, (t, s) => t === null ? e(s) : r(t));
+        });
     }
-    return o;
 }
 
-function o(e, r, t, f) {
-    var u = Object.getOwnPropertyDescriptor(f, t);
-    if (u.get !== undefined) {
-        if (u.configurable) {
-            Object.defineProperty(f, t, {
-                value: e
+ee.default = ReaderStream;
+
+Object.defineProperty(Kt, "__esModule", {
+    value: true
+});
+
+const oe = o;
+
+const ae = Qt;
+
+const ce = ee;
+
+class ReaderAsync extends ae.default {
+    constructor() {
+        super(...arguments);
+        this._walkAsync = oe.walk;
+        this._readerStream = new ce.default(this._settings);
+    }
+    dynamic(t, e) {
+        return new Promise((r, s) => {
+            this._walkAsync(t, e, (t, e) => {
+                if (t === null) {
+                    r(e);
+                } else {
+                    s(t);
+                }
+            });
+        });
+    }
+    async static(t, e) {
+        const r = [];
+        const s = this._readerStream.static(t, e);
+        return new Promise((t, e) => {
+            s.once("error", e);
+            s.on("data", t => r.push(t));
+            s.once("end", () => t(r));
+        });
+    }
+}
+
+Kt.default = ReaderAsync;
+
+var ue = {};
+
+var le = {};
+
+var he = {};
+
+var fe = {};
+
+Object.defineProperty(fe, "__esModule", {
+    value: true
+});
+
+const pe = l;
+
+class Matcher {
+    constructor(t, e, r) {
+        this._patterns = t;
+        this._settings = e;
+        this._micromatchOptions = r;
+        this._storage = [];
+        this._fillStorage();
+    }
+    _fillStorage() {
+        for (const t of this._patterns) {
+            const e = this._getPatternSegments(t);
+            const r = this._splitSegmentsIntoSections(e);
+            this._storage.push({
+                complete: r.length <= 1,
+                pattern: t,
+                segments: e,
+                sections: r
             });
-            i.push([ f, t, r, u ]);
-        } else {
-            n.push([ r, t, e ]);
         }
-    } else {
-        f[t] = e;
-        i.push([ f, t, r ]);
+    }
+    _getPatternSegments(t) {
+        const e = pe.pattern.getPatternParts(t, this._micromatchOptions);
+        return e.map(t => {
+            const e = pe.pattern.isDynamicPattern(t, this._settings);
+            if (!e) {
+                return {
+                    dynamic: false,
+                    pattern: t
+                };
+            }
+            return {
+                dynamic: true,
+                pattern: t,
+                patternRe: pe.pattern.makeRe(t, this._micromatchOptions)
+            };
+        });
+    }
+    _splitSegmentsIntoSections(t) {
+        return pe.array.splitWhen(t, t => t.dynamic && pe.pattern.hasGlobStar(t.pattern));
     }
 }
 
-function l(e, i, n, f, u, a, s) {
-    a += 1;
-    var p;
-    if (typeof e === "object" && e !== null) {
-        for (p = 0; p < f.length; p++) {
-            if (f[p] === e) {
-                o(t, e, i, u);
-                return;
+fe.default = Matcher;
+
+Object.defineProperty(he, "__esModule", {
+    value: true
+});
+
+const de = fe;
+
+class PartialMatcher extends de.default {
+    match(t) {
+        const e = t.split("/");
+        const r = e.length;
+        const s = this._storage.filter(t => !t.complete || t.segments.length > r);
+        for (const t of s) {
+            const s = t.sections[0];
+            if (!t.complete && r > s.length) {
+                return true;
+            }
+            const n = e.every((e, r) => {
+                const s = t.segments[r];
+                if (s.dynamic && s.patternRe.test(e)) {
+                    return true;
+                }
+                if (!s.dynamic && s.pattern === e) {
+                    return true;
+                }
+                return false;
+            });
+            if (n) {
+                return true;
             }
         }
-        if (typeof s.depthLimit !== "undefined" && a > s.depthLimit) {
-            o(r, e, i, u);
-            return;
+        return false;
+    }
+}
+
+he.default = PartialMatcher;
+
+Object.defineProperty(le, "__esModule", {
+    value: true
+});
+
+const _e = l;
+
+const ge = he;
+
+class DeepFilter {
+    constructor(t, e) {
+        this._settings = t;
+        this._micromatchOptions = e;
+    }
+    getFilter(t, e, r) {
+        const s = this._getMatcher(e);
+        const n = this._getNegativePatternsRe(r);
+        return e => this._filter(t, e, s, n);
+    }
+    _getMatcher(t) {
+        return new ge.default(t, this._settings, this._micromatchOptions);
+    }
+    _getNegativePatternsRe(t) {
+        const e = t.filter(_e.pattern.isAffectDepthOfReadingPattern);
+        return _e.pattern.convertPatternsToRe(e, this._micromatchOptions);
+    }
+    _filter(t, e, r, s) {
+        if (this._isSkippedByDeep(t, e.path)) {
+            return false;
+        }
+        if (this._isSkippedSymbolicLink(e)) {
+            return false;
         }
-        if (typeof s.edgesLimit !== "undefined" && n + 1 > s.edgesLimit) {
-            o(r, e, i, u);
-            return;
+        const n = _e.path.removeLeadingDotSegment(e.path);
+        if (this._isSkippedByPositivePatterns(n, r)) {
+            return false;
         }
-        f.push(e);
-        if (Array.isArray(e)) {
-            for (p = 0; p < e.length; p++) {
-                l(e[p], p, p, f, e, a, s);
-            }
-        } else {
-            var c = Object.keys(e);
-            for (p = 0; p < c.length; p++) {
-                var d = c[p];
-                l(e[d], d, p, f, e, a, s);
+        return this._isSkippedByNegativePatterns(n, s);
+    }
+    _isSkippedByDeep(t, e) {
+        if (this._settings.deep === Infinity) {
+            return false;
+        }
+        return this._getEntryLevel(t, e) >= this._settings.deep;
+    }
+    _getEntryLevel(t, e) {
+        const r = e.split("/").length;
+        if (t === "") {
+            return r;
+        }
+        const s = t.split("/").length;
+        return r - s;
+    }
+    _isSkippedSymbolicLink(t) {
+        return !this._settings.followSymbolicLinks && t.dirent.isSymbolicLink();
+    }
+    _isSkippedByPositivePatterns(t, e) {
+        return !this._settings.baseNameMatch && !e.match(t);
+    }
+    _isSkippedByNegativePatterns(t, e) {
+        return !_e.pattern.matchAny(t, e);
+    }
+}
+
+le.default = DeepFilter;
+
+var me = {};
+
+Object.defineProperty(me, "__esModule", {
+    value: true
+});
+
+const ye = l;
+
+class EntryFilter {
+    constructor(t, e) {
+        this._settings = t;
+        this._micromatchOptions = e;
+        this.index = new Map;
+    }
+    getFilter(t, e) {
+        const [r, s] = ye.pattern.partitionAbsoluteAndRelative(e);
+        const n = {
+            positive: {
+                all: ye.pattern.convertPatternsToRe(t, this._micromatchOptions)
+            },
+            negative: {
+                absolute: ye.pattern.convertPatternsToRe(r, Object.assign(Object.assign({}, this._micromatchOptions), {
+                    dot: true
+                })),
+                relative: ye.pattern.convertPatternsToRe(s, Object.assign(Object.assign({}, this._micromatchOptions), {
+                    dot: true
+                }))
             }
+        };
+        return t => this._filter(t, n);
+    }
+    _filter(t, e) {
+        const r = ye.path.removeLeadingDotSegment(t.path);
+        if (this._settings.unique && this._isDuplicateEntry(r)) {
+            return false;
+        }
+        if (this._onlyFileFilter(t) || this._onlyDirectoryFilter(t)) {
+            return false;
+        }
+        const s = this._isMatchToPatternsSet(r, e, t.dirent.isDirectory());
+        if (this._settings.unique && s) {
+            this._createIndexRecord(r);
+        }
+        return s;
+    }
+    _isDuplicateEntry(t) {
+        return this.index.has(t);
+    }
+    _createIndexRecord(t) {
+        this.index.set(t, undefined);
+    }
+    _onlyFileFilter(t) {
+        return this._settings.onlyFiles && !t.dirent.isFile();
+    }
+    _onlyDirectoryFilter(t) {
+        return this._settings.onlyDirectories && !t.dirent.isDirectory();
+    }
+    _isMatchToPatternsSet(t, e, r) {
+        const s = this._isMatchToPatterns(t, e.positive.all, r);
+        if (!s) {
+            return false;
+        }
+        const n = this._isMatchToPatterns(t, e.negative.relative, r);
+        if (n) {
+            return false;
         }
-        f.pop();
+        const i = this._isMatchToAbsoluteNegative(t, e.negative.absolute, r);
+        if (i) {
+            return false;
+        }
+        return true;
+    }
+    _isMatchToAbsoluteNegative(t, e, r) {
+        if (e.length === 0) {
+            return false;
+        }
+        const s = ye.path.makeAbsolute(this._settings.cwd, t);
+        return this._isMatchToPatterns(s, e, r);
+    }
+    _isMatchToPatterns(t, e, r) {
+        if (e.length === 0) {
+            return false;
+        }
+        const s = ye.pattern.matchAny(t, e);
+        if (!s && r) {
+            return ye.pattern.matchAny(t + "/", e);
+        }
+        return s;
     }
 }
 
-function a(e, r) {
-    if (e < r) {
-        return -1;
+me.default = EntryFilter;
+
+var Pe = {};
+
+Object.defineProperty(Pe, "__esModule", {
+    value: true
+});
+
+const ve = l;
+
+class ErrorFilter {
+    constructor(t) {
+        this._settings = t;
     }
-    if (e > r) {
-        return 1;
+    getFilter() {
+        return t => this._isNonFatalError(t);
+    }
+    _isNonFatalError(t) {
+        return ve.errno.isEnoentCodeError(t) || this._settings.suppressErrors;
     }
-    return 0;
 }
 
-function s(e, r, t, u) {
-    if (typeof u === "undefined") {
-        u = f();
+Pe.default = ErrorFilter;
+
+var be = {};
+
+Object.defineProperty(be, "__esModule", {
+    value: true
+});
+
+const Se = l;
+
+class EntryTransformer {
+    constructor(t) {
+        this._settings = t;
     }
-    var o = p(e, "", 0, [], undefined, 0, u) || e;
-    var l;
-    try {
-        if (n.length === 0) {
-            l = JSON.stringify(o, r, t);
-        } else {
-            l = JSON.stringify(o, c(r), t);
-        }
-    } catch (e) {
-        return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
-    } finally {
-        while (i.length !== 0) {
-            var a = i.pop();
-            if (a.length === 4) {
-                Object.defineProperty(a[0], a[1], a[3]);
-            } else {
-                a[0][a[1]] = a[2];
-            }
+    getTransformer() {
+        return t => this._transform(t);
+    }
+    _transform(t) {
+        let e = t.path;
+        if (this._settings.absolute) {
+            e = Se.path.makeAbsolute(this._settings.cwd, e);
+            e = Se.path.unixify(e);
+        }
+        if (this._settings.markDirectories && t.dirent.isDirectory()) {
+            e += "/";
         }
+        if (!this._settings.objectMode) {
+            return e;
+        }
+        return Object.assign(Object.assign({}, t), {
+            path: e
+        });
     }
-    return l;
 }
 
-function p(e, n, f, u, l, s, c) {
-    s += 1;
-    var d;
-    if (typeof e === "object" && e !== null) {
-        for (d = 0; d < u.length; d++) {
-            if (u[d] === e) {
-                o(t, e, n, l);
-                return;
+be.default = EntryTransformer;
+
+Object.defineProperty(ue, "__esModule", {
+    value: true
+});
+
+const ke = e;
+
+const Ee = le;
+
+const Oe = me;
+
+const we = Pe;
+
+const De = be;
+
+class Provider {
+    constructor(t) {
+        this._settings = t;
+        this.errorFilter = new we.default(this._settings);
+        this.entryFilter = new Oe.default(this._settings, this._getMicromatchOptions());
+        this.deepFilter = new Ee.default(this._settings, this._getMicromatchOptions());
+        this.entryTransformer = new De.default(this._settings);
+    }
+    _getRootDirectory(t) {
+        return ke.resolve(this._settings.cwd, t.base);
+    }
+    _getReaderOptions(t) {
+        const e = t.base === "." ? "" : t.base;
+        return {
+            basePath: e,
+            pathSegmentSeparator: "/",
+            concurrency: this._settings.concurrency,
+            deepFilter: this.deepFilter.getFilter(e, t.positive, t.negative),
+            entryFilter: this.entryFilter.getFilter(t.positive, t.negative),
+            errorFilter: this.errorFilter.getFilter(),
+            followSymbolicLinks: this._settings.followSymbolicLinks,
+            fs: this._settings.fs,
+            stats: this._settings.stats,
+            throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
+            transform: this.entryTransformer.getTransformer()
+        };
+    }
+    _getMicromatchOptions() {
+        return {
+            dot: this._settings.dot,
+            matchBase: this._settings.baseNameMatch,
+            nobrace: !this._settings.braceExpansion,
+            nocase: !this._settings.caseSensitiveMatch,
+            noext: !this._settings.extglob,
+            noglobstar: !this._settings.globstar,
+            posix: true,
+            strictSlashes: false
+        };
+    }
+}
+
+ue.default = Provider;
+
+Object.defineProperty(Jt, "__esModule", {
+    value: true
+});
+
+const Te = Kt;
+
+const Me = ue;
+
+class ProviderAsync extends Me.default {
+    constructor() {
+        super(...arguments);
+        this._reader = new Te.default(this._settings);
+    }
+    async read(t) {
+        const e = this._getRootDirectory(t);
+        const r = this._getReaderOptions(t);
+        const s = await this.api(e, t, r);
+        return s.map(t => r.transform(t));
+    }
+    api(t, e, r) {
+        if (e.dynamic) {
+            return this._reader.dynamic(t, r);
+        }
+        return this._reader.static(e.patterns, r);
+    }
+}
+
+Jt.default = ProviderAsync;
+
+var Fe = {};
+
+Object.defineProperty(Fe, "__esModule", {
+    value: true
+});
+
+const xe = a;
+
+const je = ee;
+
+const Re = ue;
+
+class ProviderStream extends Re.default {
+    constructor() {
+        super(...arguments);
+        this._reader = new je.default(this._settings);
+    }
+    read(t) {
+        const e = this._getRootDirectory(t);
+        const r = this._getReaderOptions(t);
+        const s = this.api(e, t, r);
+        const n = new xe.Readable({
+            objectMode: true,
+            read: () => {}
+        });
+        s.once("error", t => n.emit("error", t)).on("data", t => n.emit("data", r.transform(t))).once("end", () => n.emit("end"));
+        n.once("close", () => s.destroy());
+        return n;
+    }
+    api(t, e, r) {
+        if (e.dynamic) {
+            return this._reader.dynamic(t, r);
+        }
+        return this._reader.static(e.patterns, r);
+    }
+}
+
+Fe.default = ProviderStream;
+
+var Ae = {};
+
+var Le = {};
+
+Object.defineProperty(Le, "__esModule", {
+    value: true
+});
+
+const Be = i;
+
+const Ne = o;
+
+const Ve = Qt;
+
+class ReaderSync extends Ve.default {
+    constructor() {
+        super(...arguments);
+        this._walkSync = Ne.walkSync;
+        this._statSync = Be.statSync;
+    }
+    dynamic(t, e) {
+        return this._walkSync(t, e);
+    }
+    static(t, e) {
+        const r = [];
+        for (const s of t) {
+            const t = this._getFullEntryPath(s);
+            const n = this._getEntry(t, s, e);
+            if (n === null || !e.entryFilter(n)) {
+                continue;
             }
+            r.push(n);
         }
+        return r;
+    }
+    _getEntry(t, e, r) {
         try {
-            if (typeof e.toJSON === "function") {
-                return;
+            const r = this._getStat(t);
+            return this._makeEntry(r, e);
+        } catch (t) {
+            if (r.errorFilter(t)) {
+                return null;
             }
-        } catch (e) {
-            return;
+            throw t;
         }
-        if (typeof c.depthLimit !== "undefined" && s > c.depthLimit) {
-            o(r, e, n, l);
-            return;
-        }
-        if (typeof c.edgesLimit !== "undefined" && f + 1 > c.edgesLimit) {
-            o(r, e, n, l);
-            return;
+    }
+    _getStat(t) {
+        return this._statSync(t, this._fsStatSettings);
+    }
+}
+
+Le.default = ReaderSync;
+
+Object.defineProperty(Ae, "__esModule", {
+    value: true
+});
+
+const We = Le;
+
+const Ie = ue;
+
+class ProviderSync extends Ie.default {
+    constructor() {
+        super(...arguments);
+        this._reader = new We.default(this._settings);
+    }
+    read(t) {
+        const e = this._getRootDirectory(t);
+        const r = this._getReaderOptions(t);
+        const s = this.api(e, t, r);
+        return s.map(r.transform);
+    }
+    api(t, e, r) {
+        if (e.dynamic) {
+            return this._reader.dynamic(t, r);
         }
-        u.push(e);
-        if (Array.isArray(e)) {
-            for (d = 0; d < e.length; d++) {
-                p(e[d], d, d, u, e, s, c);
-            }
-        } else {
-            var y = {};
-            var h = Object.keys(e).sort(a);
-            for (d = 0; d < h.length; d++) {
-                var g = h[d];
-                p(e[g], g, d, u, e, s, c);
-                y[g] = e[g];
+        return this._reader.static(e.patterns, r);
+    }
+}
+
+Ae.default = ProviderSync;
+
+var Ce = {};
+
+(function(e) {
+    Object.defineProperty(e, "__esModule", {
+        value: true
+    });
+    e.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
+    const r = c;
+    const s = t;
+    const n = Math.max(s.cpus().length, 1);
+    e.DEFAULT_FILE_SYSTEM_ADAPTER = {
+        lstat: r.lstat,
+        lstatSync: r.lstatSync,
+        stat: r.stat,
+        statSync: r.statSync,
+        readdir: r.readdir,
+        readdirSync: r.readdirSync
+    };
+    class Settings {
+        constructor(t = {}) {
+            this._options = t;
+            this.absolute = this._getValue(this._options.absolute, false);
+            this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);
+            this.braceExpansion = this._getValue(this._options.braceExpansion, true);
+            this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true);
+            this.concurrency = this._getValue(this._options.concurrency, n);
+            this.cwd = this._getValue(this._options.cwd, process.cwd());
+            this.deep = this._getValue(this._options.deep, Infinity);
+            this.dot = this._getValue(this._options.dot, false);
+            this.extglob = this._getValue(this._options.extglob, true);
+            this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true);
+            this.fs = this._getFileSystemMethods(this._options.fs);
+            this.globstar = this._getValue(this._options.globstar, true);
+            this.ignore = this._getValue(this._options.ignore, []);
+            this.markDirectories = this._getValue(this._options.markDirectories, false);
+            this.objectMode = this._getValue(this._options.objectMode, false);
+            this.onlyDirectories = this._getValue(this._options.onlyDirectories, false);
+            this.onlyFiles = this._getValue(this._options.onlyFiles, true);
+            this.stats = this._getValue(this._options.stats, false);
+            this.suppressErrors = this._getValue(this._options.suppressErrors, false);
+            this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false);
+            this.unique = this._getValue(this._options.unique, true);
+            if (this.onlyDirectories) {
+                this.onlyFiles = false;
             }
-            if (typeof l !== "undefined") {
-                i.push([ l, n, e ]);
-                l[n] = y;
-            } else {
-                return y;
+            if (this.stats) {
+                this.objectMode = true;
             }
+            this.ignore = [].concat(this.ignore);
+        }
+        _getValue(t, e) {
+            return t === undefined ? e : t;
+        }
+        _getFileSystemMethods(t = {}) {
+            return Object.assign(Object.assign({}, e.DEFAULT_FILE_SYSTEM_ADAPTER), t);
         }
-        u.pop();
     }
+    e.default = Settings;
+})(Ce);
+
+const Ge = u;
+
+const $e = Jt;
+
+const qe = Fe;
+
+const Ue = Ae;
+
+const Ye = Ce;
+
+const ze = l;
+
+async function He(t, e) {
+    Ke(t);
+    const r = Je(t, $e.default, e);
+    const s = await Promise.all(r);
+    return ze.array.flatten(s);
 }
 
-function c(e) {
-    e = typeof e !== "undefined" ? e : function(e, r) {
-        return r;
-    };
-    return function(r, t) {
-        if (n.length > 0) {
-            for (var i = 0; i < n.length; i++) {
-                var f = n[i];
-                if (f[1] === r && f[0] === t) {
-                    t = f[2];
-                    n.splice(i, 1);
-                    break;
-                }
-            }
+(function(t) {
+    t.glob = t;
+    t.globSync = e;
+    t.globStream = r;
+    t.async = t;
+    function e(t, e) {
+        Ke(t);
+        const r = Je(t, Ue.default, e);
+        return ze.array.flatten(r);
+    }
+    t.sync = e;
+    function r(t, e) {
+        Ke(t);
+        const r = Je(t, qe.default, e);
+        return ze.stream.merge(r);
+    }
+    t.stream = r;
+    function s(t, e) {
+        Ke(t);
+        const r = [].concat(t);
+        const s = new Ye.default(e);
+        return Ge.generate(r, s);
+    }
+    t.generateTasks = s;
+    function n(t, e) {
+        Ke(t);
+        const r = new Ye.default(e);
+        return ze.pattern.isDynamicPattern(t, r);
+    }
+    t.isDynamicPattern = n;
+    function i(t) {
+        Ke(t);
+        return ze.path.escape(t);
+    }
+    t.escapePath = i;
+    function o(t) {
+        Ke(t);
+        return ze.path.convertPathToPattern(t);
+    }
+    t.convertPathToPattern = o;
+    (function(t) {
+        function e(t) {
+            Ke(t);
+            return ze.path.escapePosixPath(t);
         }
-        return e.call(this, r, t);
-    };
+        t.escapePath = e;
+        function r(t) {
+            Ke(t);
+            return ze.path.convertPosixPathToPattern(t);
+        }
+        t.convertPathToPattern = r;
+    })(t.posix || (t.posix = {}));
+    (function(t) {
+        function e(t) {
+            Ke(t);
+            return ze.path.escapeWindowsPath(t);
+        }
+        t.escapePath = e;
+        function r(t) {
+            Ke(t);
+            return ze.path.convertWindowsPathToPattern(t);
+        }
+        t.convertPathToPattern = r;
+    })(t.win32 || (t.win32 = {}));
+})(He || (He = {}));
+
+function Je(t, e, r) {
+    const s = [].concat(t);
+    const n = new Ye.default(r);
+    const i = Ge.generate(s, n);
+    const o = new e(n);
+    return i.map(o.read, o);
 }
 
-export { e as f };
+function Ke(t) {
+    const e = [].concat(t);
+    const r = e.every(t => ze.string.isString(t) && !ze.string.isEmpty(t));
+    if (!r) {
+        throw new TypeError("Patterns must be a string (non empty) or an array of strings");
+    }
+}
+
+var Qe = He;
+
+export { Qe as o };