lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.94.cjs

@@ -1,74 +1,1822 @@
-/* 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";
 
-const e = /^[-+]?0x[a-fA-F0-9]+$/;
+const t = require("util");
 
-const r = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
+const e = require("./Package.internal.45.cjs");
 
-const t = {
-    hex: true,
-    leadingZeros: true,
-    decimalPoint: ".",
-    eNotation: true
+const n = require("path");
+
+const u = t => t && t.__esModule ? t : {
+    default: t
 };
 
-function n(n, u = {}) {
-    u = Object.assign({}, t, u);
-    if (!n || typeof n !== "string") return n;
-    let l = n.trim();
-    if (u.skipLike !== undefined && u.skipLike.test(l)) return n; else if (n === "0") return 0; else if (u.hex && e.test(l)) {
-        return i(l, 16);
-    } else if (l.search(/[eE]/) !== -1) {
-        const e = l.match(/^([-\+])?(0*)([0-9]*(\.[0-9]*)?[eE][-\+]?[0-9]+)$/);
-        if (e) {
-            if (u.leadingZeros) {
-                l = (e[1] || "") + e[3];
-            } else {
-                if (e[2] === "0" && e[3][0] === ".") ; else {
-                    return n;
+const o = u(t);
+
+const s = u(n);
+
+var r = {};
+
+const a = s.default;
+
+const i = "\\\\/";
+
+const c = `[^${i}]`;
+
+const l = "\\.";
+
+const p = "\\+";
+
+const f = "\\?";
+
+const A = "\\/";
+
+const R = "(?=.)";
+
+const h = "[^/]";
+
+const _ = `(?:${A}|$)`;
+
+const E = `(?:^|${A})`;
+
+const g = `${l}{1,2}${_}`;
+
+const b = `(?!${l})`;
+
+const y = `(?!${E}${g})`;
+
+const S = `(?!${l}{0,1}${_})`;
+
+const $ = `(?!${g})`;
+
+const C = `[^.${A}]`;
+
+const x = `${h}*?`;
+
+const d = {
+    DOT_LITERAL: l,
+    PLUS_LITERAL: p,
+    QMARK_LITERAL: f,
+    SLASH_LITERAL: A,
+    ONE_CHAR: R,
+    QMARK: h,
+    END_ANCHOR: _,
+    DOTS_SLASH: g,
+    NO_DOT: b,
+    NO_DOTS: y,
+    NO_DOT_SLASH: S,
+    NO_DOTS_SLASH: $,
+    QMARK_NO_DOT: C,
+    STAR: x,
+    START_ANCHOR: E
+};
+
+const H = {
+    ...d,
+    SLASH_LITERAL: `[${i}]`,
+    QMARK: c,
+    STAR: `${c}*?`,
+    DOTS_SLASH: `${l}{1,2}(?:[${i}]|$)`,
+    NO_DOT: `(?!${l})`,
+    NO_DOTS: `(?!(?:^|[${i}])${l}{1,2}(?:[${i}]|$))`,
+    NO_DOT_SLASH: `(?!${l}{0,1}(?:[${i}]|$))`,
+    NO_DOTS_SLASH: `(?!${l}{1,2}(?:[${i}]|$))`,
+    QMARK_NO_DOT: `[^.${i}]`,
+    START_ANCHOR: `(?:^|[${i}])`,
+    END_ANCHOR: `(?:[${i}]|$)`
+};
+
+const v = {
+    alnum: "a-zA-Z0-9",
+    alpha: "a-zA-Z",
+    ascii: "\\x00-\\x7F",
+    blank: " \\t",
+    cntrl: "\\x00-\\x1F\\x7F",
+    digit: "0-9",
+    graph: "\\x21-\\x7E",
+    lower: "a-z",
+    print: "\\x20-\\x7E ",
+    punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+    space: " \\t\\r\\n\\v\\f",
+    upper: "A-Z",
+    word: "A-Za-z0-9_",
+    xdigit: "A-Fa-f0-9"
+};
+
+var T = {
+    MAX_LENGTH: 1024 * 64,
+    POSIX_REGEX_SOURCE: v,
+    REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+    REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+    REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+    REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+    REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+    REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+    REPLACEMENTS: {
+        "***": "*",
+        "**/**": "**",
+        "**/**/**": "**"
+    },
+    CHAR_0: 48,
+    CHAR_9: 57,
+    CHAR_UPPERCASE_A: 65,
+    CHAR_LOWERCASE_A: 97,
+    CHAR_UPPERCASE_Z: 90,
+    CHAR_LOWERCASE_Z: 122,
+    CHAR_LEFT_PARENTHESES: 40,
+    CHAR_RIGHT_PARENTHESES: 41,
+    CHAR_ASTERISK: 42,
+    CHAR_AMPERSAND: 38,
+    CHAR_AT: 64,
+    CHAR_BACKWARD_SLASH: 92,
+    CHAR_CARRIAGE_RETURN: 13,
+    CHAR_CIRCUMFLEX_ACCENT: 94,
+    CHAR_COLON: 58,
+    CHAR_COMMA: 44,
+    CHAR_DOT: 46,
+    CHAR_DOUBLE_QUOTE: 34,
+    CHAR_EQUAL: 61,
+    CHAR_EXCLAMATION_MARK: 33,
+    CHAR_FORM_FEED: 12,
+    CHAR_FORWARD_SLASH: 47,
+    CHAR_GRAVE_ACCENT: 96,
+    CHAR_HASH: 35,
+    CHAR_HYPHEN_MINUS: 45,
+    CHAR_LEFT_ANGLE_BRACKET: 60,
+    CHAR_LEFT_CURLY_BRACE: 123,
+    CHAR_LEFT_SQUARE_BRACKET: 91,
+    CHAR_LINE_FEED: 10,
+    CHAR_NO_BREAK_SPACE: 160,
+    CHAR_PERCENT: 37,
+    CHAR_PLUS: 43,
+    CHAR_QUESTION_MARK: 63,
+    CHAR_RIGHT_ANGLE_BRACKET: 62,
+    CHAR_RIGHT_CURLY_BRACE: 125,
+    CHAR_RIGHT_SQUARE_BRACKET: 93,
+    CHAR_SEMICOLON: 59,
+    CHAR_SINGLE_QUOTE: 39,
+    CHAR_SPACE: 32,
+    CHAR_TAB: 9,
+    CHAR_UNDERSCORE: 95,
+    CHAR_VERTICAL_LINE: 124,
+    CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+    SEP: a.sep,
+    extglobChars(t) {
+        return {
+            "!": {
+                type: "negate",
+                open: "(?:(?!(?:",
+                close: `))${t.STAR})`
+            },
+            "?": {
+                type: "qmark",
+                open: "(?:",
+                close: ")?"
+            },
+            "+": {
+                type: "plus",
+                open: "(?:",
+                close: ")+"
+            },
+            "*": {
+                type: "star",
+                open: "(?:",
+                close: ")*"
+            },
+            "@": {
+                type: "at",
+                open: "(?:",
+                close: ")"
+            }
+        };
+    },
+    globChars(t) {
+        return t === true ? H : d;
+    }
+};
+
+(function(t) {
+    const e = s.default;
+    const n = process.platform === "win32";
+    const {REGEX_BACKSLASH: u, REGEX_REMOVE_BACKSLASH: o, REGEX_SPECIAL_CHARS: r, REGEX_SPECIAL_CHARS_GLOBAL: a} = T;
+    t.isObject = t => t !== null && typeof t === "object" && !Array.isArray(t);
+    t.hasRegexChars = t => r.test(t);
+    t.isRegexChar = e => e.length === 1 && t.hasRegexChars(e);
+    t.escapeRegex = t => t.replace(a, "\\$1");
+    t.toPosixSlashes = t => t.replace(u, "/");
+    t.removeBackslashes = t => t.replace(o, t => t === "\\" ? "" : t);
+    t.supportsLookbehinds = () => {
+        const t = process.version.slice(1).split(".").map(Number);
+        if (t.length === 3 && t[0] >= 9 || t[0] === 8 && t[1] >= 10) {
+            return true;
+        }
+        return false;
+    };
+    t.isWindows = t => {
+        if (t && typeof t.windows === "boolean") {
+            return t.windows;
+        }
+        return n === true || e.sep === "\\";
+    };
+    t.escapeLast = (e, n, u) => {
+        const o = e.lastIndexOf(n, u);
+        if (o === -1) return e;
+        if (e[o - 1] === "\\") return t.escapeLast(e, n, o - 1);
+        return `${e.slice(0, o)}\\${e.slice(o)}`;
+    };
+    t.removePrefix = (t, e = {}) => {
+        let n = t;
+        if (n.startsWith("./")) {
+            n = n.slice(2);
+            e.prefix = "./";
+        }
+        return n;
+    };
+    t.wrapOutput = (t, e = {}, n = {}) => {
+        const u = n.contains ? "" : "^";
+        const o = n.contains ? "" : "$";
+        let s = `${u}(?:${t})${o}`;
+        if (e.negated === true) {
+            s = `(?:^(?!${s}).*$)`;
+        }
+        return s;
+    };
+})(r);
+
+const L = r;
+
+const {CHAR_ASTERISK: O, CHAR_AT: k, CHAR_BACKWARD_SLASH: m, CHAR_COMMA: w, CHAR_DOT: N, CHAR_EXCLAMATION_MARK: I, CHAR_FORWARD_SLASH: M, CHAR_LEFT_CURLY_BRACE: B, CHAR_LEFT_PARENTHESES: G, CHAR_LEFT_SQUARE_BRACKET: D, CHAR_PLUS: P, CHAR_QUESTION_MARK: K, CHAR_RIGHT_CURLY_BRACE: U, CHAR_RIGHT_PARENTHESES: X, CHAR_RIGHT_SQUARE_BRACKET: F} = T;
+
+const Q = t => t === M || t === m;
+
+const W = t => {
+    if (t.isPrefix !== true) {
+        t.depth = t.isGlobstar ? Infinity : 1;
+    }
+};
+
+const q = (t, e) => {
+    const n = e || {};
+    const u = t.length - 1;
+    const o = n.parts === true || n.scanToEnd === true;
+    const s = [];
+    const r = [];
+    const a = [];
+    let i = t;
+    let c = -1;
+    let l = 0;
+    let p = 0;
+    let f = false;
+    let A = false;
+    let R = false;
+    let h = false;
+    let _ = false;
+    let E = false;
+    let g = false;
+    let b = false;
+    let y = false;
+    let S = false;
+    let $ = 0;
+    let C;
+    let x;
+    let d = {
+        value: "",
+        depth: 0,
+        isGlob: false
+    };
+    const H = () => c >= u;
+    const v = () => i.charCodeAt(c + 1);
+    const T = () => {
+        C = x;
+        return i.charCodeAt(++c);
+    };
+    while (c < u) {
+        x = T();
+        let t;
+        if (x === m) {
+            g = d.backslashes = true;
+            x = T();
+            if (x === B) {
+                E = true;
+            }
+            continue;
+        }
+        if (E === true || x === B) {
+            $++;
+            while (H() !== true && (x = T())) {
+                if (x === m) {
+                    g = d.backslashes = true;
+                    T();
+                    continue;
+                }
+                if (x === B) {
+                    $++;
+                    continue;
+                }
+                if (E !== true && x === N && (x = T()) === N) {
+                    f = d.isBrace = true;
+                    R = d.isGlob = true;
+                    S = true;
+                    if (o === true) {
+                        continue;
+                    }
+                    break;
+                }
+                if (E !== true && x === w) {
+                    f = d.isBrace = true;
+                    R = d.isGlob = true;
+                    S = true;
+                    if (o === true) {
+                        continue;
+                    }
+                    break;
+                }
+                if (x === U) {
+                    $--;
+                    if ($ === 0) {
+                        E = false;
+                        f = d.isBrace = true;
+                        S = true;
+                        break;
+                    }
                 }
             }
-            return u.eNotation ? Number(l) : n;
-        } else {
-            return n;
+            if (o === true) {
+                continue;
+            }
+            break;
+        }
+        if (x === M) {
+            s.push(c);
+            r.push(d);
+            d = {
+                value: "",
+                depth: 0,
+                isGlob: false
+            };
+            if (S === true) continue;
+            if (C === N && c === l + 1) {
+                l += 2;
+                continue;
+            }
+            p = c + 1;
+            continue;
         }
+        if (n.noext !== true) {
+            const t = x === P || x === k || x === O || x === K || x === I;
+            if (t === true && v() === G) {
+                R = d.isGlob = true;
+                h = d.isExtglob = true;
+                S = true;
+                if (x === I && c === l) {
+                    y = true;
+                }
+                if (o === true) {
+                    while (H() !== true && (x = T())) {
+                        if (x === m) {
+                            g = d.backslashes = true;
+                            x = T();
+                            continue;
+                        }
+                        if (x === X) {
+                            R = d.isGlob = true;
+                            S = true;
+                            break;
+                        }
+                    }
+                    continue;
+                }
+                break;
+            }
+        }
+        if (x === O) {
+            if (C === O) _ = d.isGlobstar = true;
+            R = d.isGlob = true;
+            S = true;
+            if (o === true) {
+                continue;
+            }
+            break;
+        }
+        if (x === K) {
+            R = d.isGlob = true;
+            S = true;
+            if (o === true) {
+                continue;
+            }
+            break;
+        }
+        if (x === D) {
+            while (H() !== true && (t = T())) {
+                if (t === m) {
+                    g = d.backslashes = true;
+                    T();
+                    continue;
+                }
+                if (t === F) {
+                    A = d.isBracket = true;
+                    R = d.isGlob = true;
+                    S = true;
+                    break;
+                }
+            }
+            if (o === true) {
+                continue;
+            }
+            break;
+        }
+        if (n.nonegate !== true && x === I && c === l) {
+            b = d.negated = true;
+            l++;
+            continue;
+        }
+        if (n.noparen !== true && x === G) {
+            R = d.isGlob = true;
+            if (o === true) {
+                while (H() !== true && (x = T())) {
+                    if (x === G) {
+                        g = d.backslashes = true;
+                        x = T();
+                        continue;
+                    }
+                    if (x === X) {
+                        S = true;
+                        break;
+                    }
+                }
+                continue;
+            }
+            break;
+        }
+        if (R === true) {
+            S = true;
+            if (o === true) {
+                continue;
+            }
+            break;
+        }
+    }
+    if (n.noext === true) {
+        h = false;
+        R = false;
+    }
+    let q = i;
+    let j = "";
+    let Z = "";
+    if (l > 0) {
+        j = i.slice(0, l);
+        i = i.slice(l);
+        p -= l;
+    }
+    if (q && R === true && p > 0) {
+        q = i.slice(0, p);
+        Z = i.slice(p);
+    } else if (R === true) {
+        q = "";
+        Z = i;
     } else {
-        const e = r.exec(l);
-        if (e) {
-            const r = e[1];
-            const t = e[2];
-            let i = s(e[3]);
-            if (!u.leadingZeros && t.length > 0 && r && l[2] !== ".") return n; else if (!u.leadingZeros && t.length > 0 && !r && l[1] !== ".") return n; else if (u.leadingZeros && t === n) return 0; else {
-                const e = Number(l);
-                const s = "" + e;
-                if (s.search(/[eE]/) !== -1) {
-                    if (u.eNotation) return e; else return n;
-                } else if (l.indexOf(".") !== -1) {
-                    if (s === "0" && i === "") return e; else if (s === i) return e; else if (r && s === "-" + i) return e; else return n;
-                }
-                if (t) {
-                    return i === s || r + i === s ? e : n;
+        q = i;
+    }
+    if (q && q !== "" && q !== "/" && q !== i) {
+        if (Q(q.charCodeAt(q.length - 1))) {
+            q = q.slice(0, -1);
+        }
+    }
+    if (n.unescape === true) {
+        if (Z) Z = L.removeBackslashes(Z);
+        if (q && g === true) {
+            q = L.removeBackslashes(q);
+        }
+    }
+    const Y = {
+        prefix: j,
+        input: t,
+        start: l,
+        base: q,
+        glob: Z,
+        isBrace: f,
+        isBracket: A,
+        isGlob: R,
+        isExtglob: h,
+        isGlobstar: _,
+        negated: b,
+        negatedExtglob: y
+    };
+    if (n.tokens === true) {
+        Y.maxDepth = 0;
+        if (!Q(x)) {
+            r.push(d);
+        }
+        Y.tokens = r;
+    }
+    if (n.parts === true || n.tokens === true) {
+        let e;
+        for (let u = 0; u < s.length; u++) {
+            const o = e ? e + 1 : l;
+            const i = s[u];
+            const c = t.slice(o, i);
+            if (n.tokens) {
+                if (u === 0 && l !== 0) {
+                    r[u].isPrefix = true;
+                    r[u].value = j;
                 } else {
-                    return l === s || l === r + s ? e : n;
+                    r[u].value = c;
+                }
+                W(r[u]);
+                Y.maxDepth += r[u].depth;
+            }
+            if (u !== 0 || c !== "") {
+                a.push(c);
+            }
+            e = i;
+        }
+        if (e && e + 1 < t.length) {
+            const u = t.slice(e + 1);
+            a.push(u);
+            if (n.tokens) {
+                r[r.length - 1].value = u;
+                W(r[r.length - 1]);
+                Y.maxDepth += r[r.length - 1].depth;
+            }
+        }
+        Y.slashes = s;
+        Y.parts = a;
+    }
+    return Y;
+};
+
+var j = q;
+
+const Z = T;
+
+const Y = r;
+
+const {MAX_LENGTH: z, POSIX_REGEX_SOURCE: V, REGEX_NON_SPECIAL_CHARS: J, REGEX_SPECIAL_CHARS_BACKREF: tt, REPLACEMENTS: et} = Z;
+
+const nt = (t, e) => {
+    if (typeof e.expandRange === "function") {
+        return e.expandRange(...t, e);
+    }
+    t.sort();
+    const n = `[${t.join("-")}]`;
+    try {
+        new RegExp(n);
+    } catch (e) {
+        return t.map(t => Y.escapeRegex(t)).join("..");
+    }
+    return n;
+};
+
+const ut = (t, e) => `Missing ${t}: "${e}" - use "\\\\${e}" to match literal characters`;
+
+const ot = (t, e) => {
+    if (typeof t !== "string") {
+        throw new TypeError("Expected a string");
+    }
+    t = et[t] || t;
+    const n = {
+        ...e
+    };
+    const u = typeof n.maxLength === "number" ? Math.min(z, n.maxLength) : z;
+    let o = t.length;
+    if (o > u) {
+        throw new SyntaxError(`Input length: ${o}, exceeds maximum allowed length: ${u}`);
+    }
+    const s = {
+        type: "bos",
+        value: "",
+        output: n.prepend || ""
+    };
+    const r = [ s ];
+    const a = n.capture ? "" : "?:";
+    const i = Y.isWindows(e);
+    const c = Z.globChars(i);
+    const l = Z.extglobChars(c);
+    const {DOT_LITERAL: p, PLUS_LITERAL: f, SLASH_LITERAL: A, ONE_CHAR: R, DOTS_SLASH: h, NO_DOT: _, NO_DOT_SLASH: E, NO_DOTS_SLASH: g, QMARK: b, QMARK_NO_DOT: y, STAR: S, START_ANCHOR: $} = c;
+    const C = t => `(${a}(?:(?!${$}${t.dot ? h : p}).)*?)`;
+    const x = n.dot ? "" : _;
+    const d = n.dot ? b : y;
+    let H = n.bash === true ? C(n) : S;
+    if (n.capture) {
+        H = `(${H})`;
+    }
+    if (typeof n.noext === "boolean") {
+        n.noextglob = n.noext;
+    }
+    const v = {
+        input: t,
+        index: -1,
+        start: 0,
+        dot: n.dot === true,
+        consumed: "",
+        output: "",
+        prefix: "",
+        backtrack: false,
+        negated: false,
+        brackets: 0,
+        braces: 0,
+        parens: 0,
+        quotes: 0,
+        globstar: false,
+        tokens: r
+    };
+    t = Y.removePrefix(t, v);
+    o = t.length;
+    const T = [];
+    const L = [];
+    const O = [];
+    let k = s;
+    let m;
+    const w = () => v.index === o - 1;
+    const N = v.peek = (e = 1) => t[v.index + e];
+    const I = v.advance = () => t[++v.index] || "";
+    const M = () => t.slice(v.index + 1);
+    const B = (t = "", e = 0) => {
+        v.consumed += t;
+        v.index += e;
+    };
+    const G = t => {
+        v.output += t.output != null ? t.output : t.value;
+        B(t.value);
+    };
+    const D = () => {
+        let t = 1;
+        while (N() === "!" && (N(2) !== "(" || N(3) === "?")) {
+            I();
+            v.start++;
+            t++;
+        }
+        if (t % 2 === 0) {
+            return false;
+        }
+        v.negated = true;
+        v.start++;
+        return true;
+    };
+    const P = t => {
+        v[t]++;
+        O.push(t);
+    };
+    const K = t => {
+        v[t]--;
+        O.pop();
+    };
+    const U = t => {
+        if (k.type === "globstar") {
+            const e = v.braces > 0 && (t.type === "comma" || t.type === "brace");
+            const n = t.extglob === true || T.length && (t.type === "pipe" || t.type === "paren");
+            if (t.type !== "slash" && t.type !== "paren" && !e && !n) {
+                v.output = v.output.slice(0, -k.output.length);
+                k.type = "star";
+                k.value = "*";
+                k.output = H;
+                v.output += k.output;
+            }
+        }
+        if (T.length && t.type !== "paren") {
+            T[T.length - 1].inner += t.value;
+        }
+        if (t.value || t.output) G(t);
+        if (k && k.type === "text" && t.type === "text") {
+            k.value += t.value;
+            k.output = (k.output || "") + t.value;
+            return;
+        }
+        t.prev = k;
+        r.push(t);
+        k = t;
+    };
+    const X = (t, e) => {
+        const u = {
+            ...l[e],
+            conditions: 1,
+            inner: ""
+        };
+        u.prev = k;
+        u.parens = v.parens;
+        u.output = v.output;
+        const o = (n.capture ? "(" : "") + u.open;
+        P("parens");
+        U({
+            type: t,
+            value: e,
+            output: v.output ? "" : R
+        });
+        U({
+            type: "paren",
+            extglob: true,
+            value: I(),
+            output: o
+        });
+        T.push(u);
+    };
+    const F = t => {
+        let u = t.close + (n.capture ? ")" : "");
+        let o;
+        if (t.type === "negate") {
+            let s = H;
+            if (t.inner && t.inner.length > 1 && t.inner.includes("/")) {
+                s = C(n);
+            }
+            if (s !== H || w() || /^\)+$/.test(M())) {
+                u = t.close = `)$))${s}`;
+            }
+            if (t.inner.includes("*") && (o = M()) && /^\.[^\\/.]+$/.test(o)) {
+                const n = ot(o, {
+                    ...e,
+                    fastpaths: false
+                }).output;
+                u = t.close = `)${n})${s})`;
+            }
+            if (t.prev.type === "bos") {
+                v.negatedExtglob = true;
+            }
+        }
+        U({
+            type: "paren",
+            extglob: true,
+            value: m,
+            output: u
+        });
+        K("parens");
+    };
+    if (n.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(t)) {
+        let u = false;
+        let o = t.replace(tt, (t, e, n, o, s, r) => {
+            if (o === "\\") {
+                u = true;
+                return t;
+            }
+            if (o === "?") {
+                if (e) {
+                    return e + o + (s ? b.repeat(s.length) : "");
+                }
+                if (r === 0) {
+                    return d + (s ? b.repeat(s.length) : "");
+                }
+                return b.repeat(n.length);
+            }
+            if (o === ".") {
+                return p.repeat(n.length);
+            }
+            if (o === "*") {
+                if (e) {
+                    return e + o + (s ? H : "");
+                }
+                return H;
+            }
+            return e ? t : `\\${t}`;
+        });
+        if (u === true) {
+            if (n.unescape === true) {
+                o = o.replace(/\\/g, "");
+            } else {
+                o = o.replace(/\\+/g, t => t.length % 2 === 0 ? "\\\\" : t ? "\\" : "");
+            }
+        }
+        if (o === t && n.contains === true) {
+            v.output = t;
+            return v;
+        }
+        v.output = Y.wrapOutput(o, v, e);
+        return v;
+    }
+    while (!w()) {
+        m = I();
+        if (m === "\0") {
+            continue;
+        }
+        if (m === "\\") {
+            const t = N();
+            if (t === "/" && n.bash !== true) {
+                continue;
+            }
+            if (t === "." || t === ";") {
+                continue;
+            }
+            if (!t) {
+                m += "\\";
+                U({
+                    type: "text",
+                    value: m
+                });
+                continue;
+            }
+            const e = /^\\+/.exec(M());
+            let u = 0;
+            if (e && e[0].length > 2) {
+                u = e[0].length;
+                v.index += u;
+                if (u % 2 !== 0) {
+                    m += "\\";
+                }
+            }
+            if (n.unescape === true) {
+                m = I();
+            } else {
+                m += I();
+            }
+            if (v.brackets === 0) {
+                U({
+                    type: "text",
+                    value: m
+                });
+                continue;
+            }
+        }
+        if (v.brackets > 0 && (m !== "]" || k.value === "[" || k.value === "[^")) {
+            if (n.posix !== false && m === ":") {
+                const t = k.value.slice(1);
+                if (t.includes("[")) {
+                    k.posix = true;
+                    if (t.includes(":")) {
+                        const t = k.value.lastIndexOf("[");
+                        const e = k.value.slice(0, t);
+                        const n = k.value.slice(t + 2);
+                        const u = V[n];
+                        if (u) {
+                            k.value = e + u;
+                            v.backtrack = true;
+                            I();
+                            if (!s.output && r.indexOf(k) === 1) {
+                                s.output = R;
+                            }
+                            continue;
+                        }
+                    }
+                }
+            }
+            if (m === "[" && N() !== ":" || m === "-" && N() === "]") {
+                m = `\\${m}`;
+            }
+            if (m === "]" && (k.value === "[" || k.value === "[^")) {
+                m = `\\${m}`;
+            }
+            if (n.posix === true && m === "!" && k.value === "[") {
+                m = "^";
+            }
+            k.value += m;
+            G({
+                value: m
+            });
+            continue;
+        }
+        if (v.quotes === 1 && m !== '"') {
+            m = Y.escapeRegex(m);
+            k.value += m;
+            G({
+                value: m
+            });
+            continue;
+        }
+        if (m === '"') {
+            v.quotes = v.quotes === 1 ? 0 : 1;
+            if (n.keepQuotes === true) {
+                U({
+                    type: "text",
+                    value: m
+                });
+            }
+            continue;
+        }
+        if (m === "(") {
+            P("parens");
+            U({
+                type: "paren",
+                value: m
+            });
+            continue;
+        }
+        if (m === ")") {
+            if (v.parens === 0 && n.strictBrackets === true) {
+                throw new SyntaxError(ut("opening", "("));
+            }
+            const t = T[T.length - 1];
+            if (t && v.parens === t.parens + 1) {
+                F(T.pop());
+                continue;
+            }
+            U({
+                type: "paren",
+                value: m,
+                output: v.parens ? ")" : "\\)"
+            });
+            K("parens");
+            continue;
+        }
+        if (m === "[") {
+            if (n.nobracket === true || !M().includes("]")) {
+                if (n.nobracket !== true && n.strictBrackets === true) {
+                    throw new SyntaxError(ut("closing", "]"));
+                }
+                m = `\\${m}`;
+            } else {
+                P("brackets");
+            }
+            U({
+                type: "bracket",
+                value: m
+            });
+            continue;
+        }
+        if (m === "]") {
+            if (n.nobracket === true || k && k.type === "bracket" && k.value.length === 1) {
+                U({
+                    type: "text",
+                    value: m,
+                    output: `\\${m}`
+                });
+                continue;
+            }
+            if (v.brackets === 0) {
+                if (n.strictBrackets === true) {
+                    throw new SyntaxError(ut("opening", "["));
+                }
+                U({
+                    type: "text",
+                    value: m,
+                    output: `\\${m}`
+                });
+                continue;
+            }
+            K("brackets");
+            const t = k.value.slice(1);
+            if (k.posix !== true && t[0] === "^" && !t.includes("/")) {
+                m = `/${m}`;
+            }
+            k.value += m;
+            G({
+                value: m
+            });
+            if (n.literalBrackets === false || Y.hasRegexChars(t)) {
+                continue;
+            }
+            const e = Y.escapeRegex(k.value);
+            v.output = v.output.slice(0, -k.value.length);
+            if (n.literalBrackets === true) {
+                v.output += e;
+                k.value = e;
+                continue;
+            }
+            k.value = `(${a}${e}|${k.value})`;
+            v.output += k.value;
+            continue;
+        }
+        if (m === "{" && n.nobrace !== true) {
+            P("braces");
+            const t = {
+                type: "brace",
+                value: m,
+                output: "(",
+                outputIndex: v.output.length,
+                tokensIndex: v.tokens.length
+            };
+            L.push(t);
+            U(t);
+            continue;
+        }
+        if (m === "}") {
+            const t = L[L.length - 1];
+            if (n.nobrace === true || !t) {
+                U({
+                    type: "text",
+                    value: m,
+                    output: m
+                });
+                continue;
+            }
+            let e = ")";
+            if (t.dots === true) {
+                const t = r.slice();
+                const u = [];
+                for (let e = t.length - 1; e >= 0; e--) {
+                    r.pop();
+                    if (t[e].type === "brace") {
+                        break;
+                    }
+                    if (t[e].type !== "dots") {
+                        u.unshift(t[e].value);
+                    }
+                }
+                e = nt(u, n);
+                v.backtrack = true;
+            }
+            if (t.comma !== true && t.dots !== true) {
+                const n = v.output.slice(0, t.outputIndex);
+                const u = v.tokens.slice(t.tokensIndex);
+                t.value = t.output = "\\{";
+                m = e = "\\}";
+                v.output = n;
+                for (const t of u) {
+                    v.output += t.output || t.value;
+                }
+            }
+            U({
+                type: "brace",
+                value: m,
+                output: e
+            });
+            K("braces");
+            L.pop();
+            continue;
+        }
+        if (m === "|") {
+            if (T.length > 0) {
+                T[T.length - 1].conditions++;
+            }
+            U({
+                type: "text",
+                value: m
+            });
+            continue;
+        }
+        if (m === ",") {
+            let t = m;
+            const e = L[L.length - 1];
+            if (e && O[O.length - 1] === "braces") {
+                e.comma = true;
+                t = "|";
+            }
+            U({
+                type: "comma",
+                value: m,
+                output: t
+            });
+            continue;
+        }
+        if (m === "/") {
+            if (k.type === "dot" && v.index === v.start + 1) {
+                v.start = v.index + 1;
+                v.consumed = "";
+                v.output = "";
+                r.pop();
+                k = s;
+                continue;
+            }
+            U({
+                type: "slash",
+                value: m,
+                output: A
+            });
+            continue;
+        }
+        if (m === ".") {
+            if (v.braces > 0 && k.type === "dot") {
+                if (k.value === ".") k.output = p;
+                const t = L[L.length - 1];
+                k.type = "dots";
+                k.output += m;
+                k.value += m;
+                t.dots = true;
+                continue;
+            }
+            if (v.braces + v.parens === 0 && k.type !== "bos" && k.type !== "slash") {
+                U({
+                    type: "text",
+                    value: m,
+                    output: p
+                });
+                continue;
+            }
+            U({
+                type: "dot",
+                value: m,
+                output: p
+            });
+            continue;
+        }
+        if (m === "?") {
+            const t = k && k.value === "(";
+            if (!t && n.noextglob !== true && N() === "(" && N(2) !== "?") {
+                X("qmark", m);
+                continue;
+            }
+            if (k && k.type === "paren") {
+                const t = N();
+                let e = m;
+                if (t === "<" && !Y.supportsLookbehinds()) {
+                    throw new Error("Node.js v10 or higher is required for regex lookbehinds");
+                }
+                if (k.value === "(" && !/[!=<:]/.test(t) || t === "<" && !/<([!=]|\w+>)/.test(M())) {
+                    e = `\\${m}`;
+                }
+                U({
+                    type: "text",
+                    value: m,
+                    output: e
+                });
+                continue;
+            }
+            if (n.dot !== true && (k.type === "slash" || k.type === "bos")) {
+                U({
+                    type: "qmark",
+                    value: m,
+                    output: y
+                });
+                continue;
+            }
+            U({
+                type: "qmark",
+                value: m,
+                output: b
+            });
+            continue;
+        }
+        if (m === "!") {
+            if (n.noextglob !== true && N() === "(") {
+                if (N(2) !== "?" || !/[!=<:]/.test(N(3))) {
+                    X("negate", m);
+                    continue;
                 }
             }
+            if (n.nonegate !== true && v.index === 0) {
+                D();
+                continue;
+            }
+        }
+        if (m === "+") {
+            if (n.noextglob !== true && N() === "(" && N(2) !== "?") {
+                X("plus", m);
+                continue;
+            }
+            if (k && k.value === "(" || n.regex === false) {
+                U({
+                    type: "plus",
+                    value: m,
+                    output: f
+                });
+                continue;
+            }
+            if (k && (k.type === "bracket" || k.type === "paren" || k.type === "brace") || v.parens > 0) {
+                U({
+                    type: "plus",
+                    value: m
+                });
+                continue;
+            }
+            U({
+                type: "plus",
+                value: f
+            });
+            continue;
+        }
+        if (m === "@") {
+            if (n.noextglob !== true && N() === "(" && N(2) !== "?") {
+                U({
+                    type: "at",
+                    extglob: true,
+                    value: m,
+                    output: ""
+                });
+                continue;
+            }
+            U({
+                type: "text",
+                value: m
+            });
+            continue;
+        }
+        if (m !== "*") {
+            if (m === "$" || m === "^") {
+                m = `\\${m}`;
+            }
+            const t = J.exec(M());
+            if (t) {
+                m += t[0];
+                v.index += t[0].length;
+            }
+            U({
+                type: "text",
+                value: m
+            });
+            continue;
+        }
+        if (k && (k.type === "globstar" || k.star === true)) {
+            k.type = "star";
+            k.star = true;
+            k.value += m;
+            k.output = H;
+            v.backtrack = true;
+            v.globstar = true;
+            B(m);
+            continue;
+        }
+        let e = M();
+        if (n.noextglob !== true && /^\([^?]/.test(e)) {
+            X("star", m);
+            continue;
+        }
+        if (k.type === "star") {
+            if (n.noglobstar === true) {
+                B(m);
+                continue;
+            }
+            const u = k.prev;
+            const o = u.prev;
+            const s = u.type === "slash" || u.type === "bos";
+            const r = o && (o.type === "star" || o.type === "globstar");
+            if (n.bash === true && (!s || e[0] && e[0] !== "/")) {
+                U({
+                    type: "star",
+                    value: m,
+                    output: ""
+                });
+                continue;
+            }
+            const a = v.braces > 0 && (u.type === "comma" || u.type === "brace");
+            const i = T.length && (u.type === "pipe" || u.type === "paren");
+            if (!s && u.type !== "paren" && !a && !i) {
+                U({
+                    type: "star",
+                    value: m,
+                    output: ""
+                });
+                continue;
+            }
+            while (e.slice(0, 3) === "/**") {
+                const n = t[v.index + 4];
+                if (n && n !== "/") {
+                    break;
+                }
+                e = e.slice(3);
+                B("/**", 3);
+            }
+            if (u.type === "bos" && w()) {
+                k.type = "globstar";
+                k.value += m;
+                k.output = C(n);
+                v.output = k.output;
+                v.globstar = true;
+                B(m);
+                continue;
+            }
+            if (u.type === "slash" && u.prev.type !== "bos" && !r && w()) {
+                v.output = v.output.slice(0, -(u.output + k.output).length);
+                u.output = `(?:${u.output}`;
+                k.type = "globstar";
+                k.output = C(n) + (n.strictSlashes ? ")" : "|$)");
+                k.value += m;
+                v.globstar = true;
+                v.output += u.output + k.output;
+                B(m);
+                continue;
+            }
+            if (u.type === "slash" && u.prev.type !== "bos" && e[0] === "/") {
+                const t = e[1] !== void 0 ? "|$" : "";
+                v.output = v.output.slice(0, -(u.output + k.output).length);
+                u.output = `(?:${u.output}`;
+                k.type = "globstar";
+                k.output = `${C(n)}${A}|${A}${t})`;
+                k.value += m;
+                v.output += u.output + k.output;
+                v.globstar = true;
+                B(m + I());
+                U({
+                    type: "slash",
+                    value: "/",
+                    output: ""
+                });
+                continue;
+            }
+            if (u.type === "bos" && e[0] === "/") {
+                k.type = "globstar";
+                k.value += m;
+                k.output = `(?:^|${A}|${C(n)}${A})`;
+                v.output = k.output;
+                v.globstar = true;
+                B(m + I());
+                U({
+                    type: "slash",
+                    value: "/",
+                    output: ""
+                });
+                continue;
+            }
+            v.output = v.output.slice(0, -k.output.length);
+            k.type = "globstar";
+            k.output = C(n);
+            k.value += m;
+            v.output += k.output;
+            v.globstar = true;
+            B(m);
+            continue;
+        }
+        const u = {
+            type: "star",
+            value: m,
+            output: H
+        };
+        if (n.bash === true) {
+            u.output = ".*?";
+            if (k.type === "bos" || k.type === "slash") {
+                u.output = x + u.output;
+            }
+            U(u);
+            continue;
+        }
+        if (k && (k.type === "bracket" || k.type === "paren") && n.regex === true) {
+            u.output = m;
+            U(u);
+            continue;
+        }
+        if (v.index === v.start || k.type === "slash" || k.type === "dot") {
+            if (k.type === "dot") {
+                v.output += E;
+                k.output += E;
+            } else if (n.dot === true) {
+                v.output += g;
+                k.output += g;
+            } else {
+                v.output += x;
+                k.output += x;
+            }
+            if (N() !== "*") {
+                v.output += R;
+                k.output += R;
+            }
+        }
+        U(u);
+    }
+    while (v.brackets > 0) {
+        if (n.strictBrackets === true) throw new SyntaxError(ut("closing", "]"));
+        v.output = Y.escapeLast(v.output, "[");
+        K("brackets");
+    }
+    while (v.parens > 0) {
+        if (n.strictBrackets === true) throw new SyntaxError(ut("closing", ")"));
+        v.output = Y.escapeLast(v.output, "(");
+        K("parens");
+    }
+    while (v.braces > 0) {
+        if (n.strictBrackets === true) throw new SyntaxError(ut("closing", "}"));
+        v.output = Y.escapeLast(v.output, "{");
+        K("braces");
+    }
+    if (n.strictSlashes !== true && (k.type === "star" || k.type === "bracket")) {
+        U({
+            type: "maybe_slash",
+            value: "",
+            output: `${A}?`
+        });
+    }
+    if (v.backtrack === true) {
+        v.output = "";
+        for (const t of v.tokens) {
+            v.output += t.output != null ? t.output : t.value;
+            if (t.suffix) {
+                v.output += t.suffix;
+            }
+        }
+    }
+    return v;
+};
+
+ot.fastpaths = (t, e) => {
+    const n = {
+        ...e
+    };
+    const u = typeof n.maxLength === "number" ? Math.min(z, n.maxLength) : z;
+    const o = t.length;
+    if (o > u) {
+        throw new SyntaxError(`Input length: ${o}, exceeds maximum allowed length: ${u}`);
+    }
+    t = et[t] || t;
+    const s = Y.isWindows(e);
+    const {DOT_LITERAL: r, SLASH_LITERAL: a, ONE_CHAR: i, DOTS_SLASH: c, NO_DOT: l, NO_DOTS: p, NO_DOTS_SLASH: f, STAR: A, START_ANCHOR: R} = Z.globChars(s);
+    const h = n.dot ? p : l;
+    const _ = n.dot ? f : l;
+    const E = n.capture ? "" : "?:";
+    const g = {
+        negated: false,
+        prefix: ""
+    };
+    let b = n.bash === true ? ".*?" : A;
+    if (n.capture) {
+        b = `(${b})`;
+    }
+    const y = t => {
+        if (t.noglobstar === true) return b;
+        return `(${E}(?:(?!${R}${t.dot ? c : r}).)*?)`;
+    };
+    const S = t => {
+        switch (t) {
+          case "*":
+            return `${h}${i}${b}`;
+
+          case ".*":
+            return `${r}${i}${b}`;
+
+          case "*.*":
+            return `${h}${b}${r}${i}${b}`;
+
+          case "*/*":
+            return `${h}${b}${a}${i}${_}${b}`;
+
+          case "**":
+            return h + y(n);
+
+          case "**/*":
+            return `(?:${h}${y(n)}${a})?${_}${i}${b}`;
+
+          case "**/*.*":
+            return `(?:${h}${y(n)}${a})?${_}${b}${r}${i}${b}`;
+
+          case "**/.*":
+            return `(?:${h}${y(n)}${a})?${r}${i}${b}`;
+
+          default:
+            {
+                const e = /^(.*?)\.(\w+)$/.exec(t);
+                if (!e) return;
+                const n = S(e[1]);
+                if (!n) return;
+                return n + r + e[2];
+            }
+        }
+    };
+    const $ = Y.removePrefix(t, g);
+    let C = S($);
+    if (C && n.strictSlashes !== true) {
+        C += `${a}?`;
+    }
+    return C;
+};
+
+var st = ot;
+
+const rt = s.default;
+
+const at = j;
+
+const it = st;
+
+const ct = r;
+
+const lt = T;
+
+const pt = t => t && typeof t === "object" && !Array.isArray(t);
+
+const ft = (t, e, n = false) => {
+    if (Array.isArray(t)) {
+        const u = t.map(t => ft(t, e, n));
+        const o = t => {
+            for (const e of u) {
+                const n = e(t);
+                if (n) return n;
+            }
+            return false;
+        };
+        return o;
+    }
+    const u = pt(t) && t.tokens && t.input;
+    if (t === "" || typeof t !== "string" && !u) {
+        throw new TypeError("Expected pattern to be a non-empty string");
+    }
+    const o = e || {};
+    const s = ct.isWindows(e);
+    const r = u ? ft.compileRe(t, e) : ft.makeRe(t, e, false, true);
+    const a = r.state;
+    delete r.state;
+    let i = () => false;
+    if (o.ignore) {
+        const t = {
+            ...e,
+            ignore: null,
+            onMatch: null,
+            onResult: null
+        };
+        i = ft(o.ignore, t, n);
+    }
+    const c = (n, u = false) => {
+        const {isMatch: c, match: l, output: p} = ft.test(n, r, e, {
+            glob: t,
+            posix: s
+        });
+        const f = {
+            glob: t,
+            state: a,
+            regex: r,
+            posix: s,
+            input: n,
+            output: p,
+            match: l,
+            isMatch: c
+        };
+        if (typeof o.onResult === "function") {
+            o.onResult(f);
+        }
+        if (c === false) {
+            f.isMatch = false;
+            return u ? f : false;
+        }
+        if (i(n)) {
+            if (typeof o.onIgnore === "function") {
+                o.onIgnore(f);
+            }
+            f.isMatch = false;
+            return u ? f : false;
+        }
+        if (typeof o.onMatch === "function") {
+            o.onMatch(f);
+        }
+        return u ? f : true;
+    };
+    if (n) {
+        c.state = a;
+    }
+    return c;
+};
+
+ft.test = (t, e, n, {glob: u, posix: o} = {}) => {
+    if (typeof t !== "string") {
+        throw new TypeError("Expected input to be a string");
+    }
+    if (t === "") {
+        return {
+            isMatch: false,
+            output: ""
+        };
+    }
+    const s = n || {};
+    const r = s.format || (o ? ct.toPosixSlashes : null);
+    let a = t === u;
+    let i = a && r ? r(t) : t;
+    if (a === false) {
+        i = r ? r(t) : t;
+        a = i === u;
+    }
+    if (a === false || s.capture === true) {
+        if (s.matchBase === true || s.basename === true) {
+            a = ft.matchBase(t, e, n, o);
         } else {
-            return n;
+            a = e.exec(i);
         }
     }
-}
+    return {
+        isMatch: Boolean(a),
+        match: a,
+        output: i
+    };
+};
+
+ft.matchBase = (t, e, n, u = ct.isWindows(n)) => {
+    const o = e instanceof RegExp ? e : ft.makeRe(e, n);
+    return o.test(rt.basename(t));
+};
+
+ft.isMatch = (t, e, n) => ft(e, n)(t);
+
+ft.parse = (t, e) => {
+    if (Array.isArray(t)) return t.map(t => ft.parse(t, e));
+    return it(t, {
+        ...e,
+        fastpaths: false
+    });
+};
+
+ft.scan = (t, e) => at(t, e);
+
+ft.compileRe = (t, e, n = false, u = false) => {
+    if (n === true) {
+        return t.output;
+    }
+    const o = e || {};
+    const s = o.contains ? "" : "^";
+    const r = o.contains ? "" : "$";
+    let a = `${s}(?:${t.output})${r}`;
+    if (t && t.negated === true) {
+        a = `^(?!${a}).*$`;
+    }
+    const i = ft.toRegex(a, e);
+    if (u === true) {
+        i.state = t;
+    }
+    return i;
+};
 
-function s(e) {
-    if (e && e.indexOf(".") !== -1) {
-        e = e.replace(/0+$/, "");
-        if (e === ".") e = "0"; else if (e[0] === ".") e = "0" + e; else if (e[e.length - 1] === ".") e = e.substr(0, e.length - 1);
-        return e;
+ft.makeRe = (t, e = {}, n = false, u = false) => {
+    if (!t || typeof t !== "string") {
+        throw new TypeError("Expected a non-empty string");
+    }
+    let o = {
+        negated: false,
+        fastpaths: true
+    };
+    if (e.fastpaths !== false && (t[0] === "." || t[0] === "*")) {
+        o.output = it.fastpaths(t, e);
     }
-    return e;
-}
+    if (!o.output) {
+        o = it(t, e);
+    }
+    return ft.compileRe(o, e, n, u);
+};
+
+ft.toRegex = (t, e) => {
+    try {
+        const n = e || {};
+        return new RegExp(t, n.flags || (n.nocase ? "i" : ""));
+    } catch (t) {
+        if (e && e.debug === true) throw t;
+        return /$^/;
+    }
+};
+
+ft.constants = lt;
+
+var At = ft;
+
+var Rt = At;
+
+const ht = o.default;
+
+const _t = e.braces_1;
+
+const Et = Rt;
+
+const gt = r;
+
+const bt = t => t === "" || t === "./";
+
+const yt = t => {
+    const e = t.indexOf("{");
+    return e > -1 && t.indexOf("}", e) > -1;
+};
+
+const St = (t, e, n) => {
+    e = [].concat(e);
+    t = [].concat(t);
+    let u = new Set;
+    let o = new Set;
+    let s = new Set;
+    let r = 0;
+    let a = t => {
+        s.add(t.output);
+        if (n && n.onResult) {
+            n.onResult(t);
+        }
+    };
+    for (let s = 0; s < e.length; s++) {
+        let i = Et(String(e[s]), {
+            ...n,
+            onResult: a
+        }, true);
+        let c = i.state.negated || i.state.negatedExtglob;
+        if (c) r++;
+        for (let e of t) {
+            let t = i(e, true);
+            let n = c ? !t.isMatch : t.isMatch;
+            if (!n) continue;
+            if (c) {
+                u.add(t.output);
+            } else {
+                u.delete(t.output);
+                o.add(t.output);
+            }
+        }
+    }
+    let i = r === e.length ? [ ...s ] : [ ...o ];
+    let c = i.filter(t => !u.has(t));
+    if (n && c.length === 0) {
+        if (n.failglob === true) {
+            throw new Error(`No matches found for "${e.join(", ")}"`);
+        }
+        if (n.nonull === true || n.nullglob === true) {
+            return n.unescape ? e.map(t => t.replace(/\\/g, "")) : e;
+        }
+    }
+    return c;
+};
+
+St.match = St;
+
+St.matcher = (t, e) => Et(t, e);
+
+St.isMatch = (t, e, n) => Et(e, n)(t);
+
+St.any = St.isMatch;
+
+St.not = (t, e, n = {}) => {
+    e = [].concat(e).map(String);
+    let u = new Set;
+    let o = [];
+    let s = t => {
+        if (n.onResult) n.onResult(t);
+        o.push(t.output);
+    };
+    let r = new Set(St(t, e, {
+        ...n,
+        onResult: s
+    }));
+    for (let t of o) {
+        if (!r.has(t)) {
+            u.add(t);
+        }
+    }
+    return [ ...u ];
+};
+
+St.contains = (t, e, n) => {
+    if (typeof t !== "string") {
+        throw new TypeError(`Expected a string: "${ht.inspect(t)}"`);
+    }
+    if (Array.isArray(e)) {
+        return e.some(e => St.contains(t, e, n));
+    }
+    if (typeof e === "string") {
+        if (bt(t) || bt(e)) {
+            return false;
+        }
+        if (t.includes(e) || t.startsWith("./") && t.slice(2).includes(e)) {
+            return true;
+        }
+    }
+    return St.isMatch(t, e, {
+        ...n,
+        contains: true
+    });
+};
+
+St.matchKeys = (t, e, n) => {
+    if (!gt.isObject(t)) {
+        throw new TypeError("Expected the first argument to be an object");
+    }
+    let u = St(Object.keys(t), e, n);
+    let o = {};
+    for (let e of u) o[e] = t[e];
+    return o;
+};
+
+St.some = (t, e, n) => {
+    let u = [].concat(t);
+    for (let t of [].concat(e)) {
+        let e = Et(String(t), n);
+        if (u.some(t => e(t))) {
+            return true;
+        }
+    }
+    return false;
+};
+
+St.every = (t, e, n) => {
+    let u = [].concat(t);
+    for (let t of [].concat(e)) {
+        let e = Et(String(t), n);
+        if (!u.every(t => e(t))) {
+            return false;
+        }
+    }
+    return true;
+};
+
+St.all = (t, e, n) => {
+    if (typeof t !== "string") {
+        throw new TypeError(`Expected a string: "${ht.inspect(t)}"`);
+    }
+    return [].concat(e).every(e => Et(e, n)(t));
+};
+
+St.capture = (t, e, n) => {
+    let u = gt.isWindows(n);
+    let o = Et.makeRe(String(t), {
+        ...n,
+        capture: true
+    });
+    let s = o.exec(u ? gt.toPosixSlashes(e) : e);
+    if (s) {
+        return s.slice(1).map(t => t === void 0 ? "" : t);
+    }
+};
+
+St.makeRe = (...t) => Et.makeRe(...t);
+
+St.scan = (...t) => Et.scan(...t);
+
+St.parse = (t, e) => {
+    let n = [];
+    for (let u of [].concat(t || [])) {
+        for (let t of _t(String(u), e)) {
+            n.push(Et.parse(t, e));
+        }
+    }
+    return n;
+};
+
+St.braces = (t, e) => {
+    if (typeof t !== "string") throw new TypeError("Expected a string");
+    if (e && e.nobrace === true || !yt(t)) {
+        return [ t ];
+    }
+    return _t(t, e);
+};
+
+St.braceExpand = (t, e) => {
+    if (typeof t !== "string") throw new TypeError("Expected a string");
+    return St.braces(t, {
+        ...e,
+        expand: true
+    });
+};
 
-function i(e, r) {
-    if (parseInt) return parseInt(e, r); else if (Number.parseInt) return Number.parseInt(e, r); else if (window && window.parseInt) return window.parseInt(e, r); else throw new Error("parseInt, Number.parseInt, window.parseInt are not supported");
-}
+St.hasBraces = yt;
 
-exports.strnum = n;
+exports.micromatch_1 = St;