lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.92.cjs

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