lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.94.mjs

@@ -1,74 +1,1814 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
-const e = /^[-+]?0x[a-fA-F0-9]+$/;
-
-const r = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
-
-const t = {
-    hex: true,
-    leadingZeros: true,
-    decimalPoint: ".",
-    eNotation: true
-};
-
-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;
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
+import t from "util";
+
+import { b as e } from "./Package.internal.45.mjs";
+
+import n from "path";
+
+var u = {};
+
+const o = n;
+
+const r = "\\\\/";
+
+const s = `[^${r}]`;
+
+const a = "\\.";
+
+const i = "\\+";
+
+const c = "\\?";
+
+const l = "\\/";
+
+const p = "(?=.)";
+
+const f = "[^/]";
+
+const A = `(?:${l}|$)`;
+
+const R = `(?:^|${l})`;
+
+const h = `${a}{1,2}${A}`;
+
+const _ = `(?!${a})`;
+
+const E = `(?!${R}${h})`;
+
+const g = `(?!${a}{0,1}${A})`;
+
+const b = `(?!${h})`;
+
+const y = `[^.${l}]`;
+
+const S = `${f}*?`;
+
+const $ = {
+    DOT_LITERAL: a,
+    PLUS_LITERAL: i,
+    QMARK_LITERAL: c,
+    SLASH_LITERAL: l,
+    ONE_CHAR: p,
+    QMARK: f,
+    END_ANCHOR: A,
+    DOTS_SLASH: h,
+    NO_DOT: _,
+    NO_DOTS: E,
+    NO_DOT_SLASH: g,
+    NO_DOTS_SLASH: b,
+    QMARK_NO_DOT: y,
+    STAR: S,
+    START_ANCHOR: R
+};
+
+const C = {
+    ...$,
+    SLASH_LITERAL: `[${r}]`,
+    QMARK: s,
+    STAR: `${s}*?`,
+    DOTS_SLASH: `${a}{1,2}(?:[${r}]|$)`,
+    NO_DOT: `(?!${a})`,
+    NO_DOTS: `(?!(?:^|[${r}])${a}{1,2}(?:[${r}]|$))`,
+    NO_DOT_SLASH: `(?!${a}{0,1}(?:[${r}]|$))`,
+    NO_DOTS_SLASH: `(?!${a}{1,2}(?:[${r}]|$))`,
+    QMARK_NO_DOT: `[^.${r}]`,
+    START_ANCHOR: `(?:^|[${r}])`,
+    END_ANCHOR: `(?:[${r}]|$)`
+};
+
+const x = {
+    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 d = {
+    MAX_LENGTH: 1024 * 64,
+    POSIX_REGEX_SOURCE: x,
+    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: o.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 ? C : $;
+    }
+};
+
+(function(t) {
+    const e = n;
+    const u = process.platform === "win32";
+    const {REGEX_BACKSLASH: o, REGEX_REMOVE_BACKSLASH: r, REGEX_SPECIAL_CHARS: s, REGEX_SPECIAL_CHARS_GLOBAL: a} = d;
+    t.isObject = t => t !== null && typeof t === "object" && !Array.isArray(t);
+    t.hasRegexChars = t => s.test(t);
+    t.isRegexChar = e => e.length === 1 && t.hasRegexChars(e);
+    t.escapeRegex = t => t.replace(a, "\\$1");
+    t.toPosixSlashes = t => t.replace(o, "/");
+    t.removeBackslashes = t => t.replace(r, 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 u === 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 r = `${u}(?:${t})${o}`;
+        if (e.negated === true) {
+            r = `(?:^(?!${r}).*$)`;
+        }
+        return r;
+    };
+})(u);
+
+const v = u;
+
+const {CHAR_ASTERISK: H, CHAR_AT: T, CHAR_BACKWARD_SLASH: L, CHAR_COMMA: O, CHAR_DOT: k, CHAR_EXCLAMATION_MARK: m, CHAR_FORWARD_SLASH: w, CHAR_LEFT_CURLY_BRACE: N, CHAR_LEFT_PARENTHESES: I, CHAR_LEFT_SQUARE_BRACKET: B, CHAR_PLUS: M, CHAR_QUESTION_MARK: G, CHAR_RIGHT_CURLY_BRACE: D, CHAR_RIGHT_PARENTHESES: P, CHAR_RIGHT_SQUARE_BRACKET: K} = d;
+
+const U = t => t === w || t === L;
+
+const X = t => {
+    if (t.isPrefix !== true) {
+        t.depth = t.isGlobstar ? Infinity : 1;
+    }
+};
+
+const F = (t, e) => {
+    const n = e || {};
+    const u = t.length - 1;
+    const o = n.parts === true || n.scanToEnd === true;
+    const r = [];
+    const s = [];
+    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 F = () => c >= u;
+    const Q = () => i.charCodeAt(c + 1);
+    const W = () => {
+        C = x;
+        return i.charCodeAt(++c);
+    };
+    while (c < u) {
+        x = W();
+        let t;
+        if (x === L) {
+            g = d.backslashes = true;
+            x = W();
+            if (x === N) {
+                E = true;
+            }
+            continue;
+        }
+        if (E === true || x === N) {
+            $++;
+            while (F() !== true && (x = W())) {
+                if (x === L) {
+                    g = d.backslashes = true;
+                    W();
+                    continue;
+                }
+                if (x === N) {
+                    $++;
+                    continue;
+                }
+                if (E !== true && x === k && (x = W()) === k) {
+                    f = d.isBrace = true;
+                    R = d.isGlob = true;
+                    S = true;
+                    if (o === true) {
+                        continue;
+                    }
+                    break;
+                }
+                if (E !== true && x === O) {
+                    f = d.isBrace = true;
+                    R = d.isGlob = true;
+                    S = true;
+                    if (o === true) {
+                        continue;
+                    }
+                    break;
+                }
+                if (x === D) {
+                    $--;
+                    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 === w) {
+            r.push(c);
+            s.push(d);
+            d = {
+                value: "",
+                depth: 0,
+                isGlob: false
+            };
+            if (S === true) continue;
+            if (C === k && c === l + 1) {
+                l += 2;
+                continue;
+            }
+            p = c + 1;
+            continue;
         }
+        if (n.noext !== true) {
+            const t = x === M || x === T || x === H || x === G || x === m;
+            if (t === true && Q() === I) {
+                R = d.isGlob = true;
+                h = d.isExtglob = true;
+                S = true;
+                if (x === m && c === l) {
+                    y = true;
+                }
+                if (o === true) {
+                    while (F() !== true && (x = W())) {
+                        if (x === L) {
+                            g = d.backslashes = true;
+                            x = W();
+                            continue;
+                        }
+                        if (x === P) {
+                            R = d.isGlob = true;
+                            S = true;
+                            break;
+                        }
+                    }
+                    continue;
+                }
+                break;
+            }
+        }
+        if (x === H) {
+            if (C === H) _ = d.isGlobstar = true;
+            R = d.isGlob = true;
+            S = true;
+            if (o === true) {
+                continue;
+            }
+            break;
+        }
+        if (x === G) {
+            R = d.isGlob = true;
+            S = true;
+            if (o === true) {
+                continue;
+            }
+            break;
+        }
+        if (x === B) {
+            while (F() !== true && (t = W())) {
+                if (t === L) {
+                    g = d.backslashes = true;
+                    W();
+                    continue;
+                }
+                if (t === K) {
+                    A = d.isBracket = true;
+                    R = d.isGlob = true;
+                    S = true;
+                    break;
+                }
+            }
+            if (o === true) {
+                continue;
+            }
+            break;
+        }
+        if (n.nonegate !== true && x === m && c === l) {
+            b = d.negated = true;
+            l++;
+            continue;
+        }
+        if (n.noparen !== true && x === I) {
+            R = d.isGlob = true;
+            if (o === true) {
+                while (F() !== true && (x = W())) {
+                    if (x === I) {
+                        g = d.backslashes = true;
+                        x = W();
+                        continue;
+                    }
+                    if (x === P) {
+                        S = true;
+                        break;
+                    }
+                }
+                continue;
+            }
+            break;
+        }
+        if (R === true) {
+            S = true;
+            if (o === true) {
+                continue;
+            }
+            break;
+        }
+    }
+    if (n.noext === true) {
+        h = false;
+        R = false;
+    }
+    let j = i;
+    let q = "";
+    let Z = "";
+    if (l > 0) {
+        q = i.slice(0, l);
+        i = i.slice(l);
+        p -= l;
+    }
+    if (j && R === true && p > 0) {
+        j = i.slice(0, p);
+        Z = i.slice(p);
+    } else if (R === true) {
+        j = "";
+        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;
+        j = i;
+    }
+    if (j && j !== "" && j !== "/" && j !== i) {
+        if (U(j.charCodeAt(j.length - 1))) {
+            j = j.slice(0, -1);
+        }
+    }
+    if (n.unescape === true) {
+        if (Z) Z = v.removeBackslashes(Z);
+        if (j && g === true) {
+            j = v.removeBackslashes(j);
+        }
+    }
+    const Y = {
+        prefix: q,
+        input: t,
+        start: l,
+        base: j,
+        glob: Z,
+        isBrace: f,
+        isBracket: A,
+        isGlob: R,
+        isExtglob: h,
+        isGlobstar: _,
+        negated: b,
+        negatedExtglob: y
+    };
+    if (n.tokens === true) {
+        Y.maxDepth = 0;
+        if (!U(x)) {
+            s.push(d);
+        }
+        Y.tokens = s;
+    }
+    if (n.parts === true || n.tokens === true) {
+        let e;
+        for (let u = 0; u < r.length; u++) {
+            const o = e ? e + 1 : l;
+            const i = r[u];
+            const c = t.slice(o, i);
+            if (n.tokens) {
+                if (u === 0 && l !== 0) {
+                    s[u].isPrefix = true;
+                    s[u].value = q;
                 } else {
-                    return l === s || l === r + s ? e : n;
+                    s[u].value = c;
+                }
+                X(s[u]);
+                Y.maxDepth += s[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) {
+                s[s.length - 1].value = u;
+                X(s[s.length - 1]);
+                Y.maxDepth += s[s.length - 1].depth;
+            }
+        }
+        Y.slashes = r;
+        Y.parts = a;
+    }
+    return Y;
+};
+
+var Q = F;
+
+const W = d;
+
+const j = u;
+
+const {MAX_LENGTH: q, POSIX_REGEX_SOURCE: Z, REGEX_NON_SPECIAL_CHARS: Y, REGEX_SPECIAL_CHARS_BACKREF: z, REPLACEMENTS: V} = W;
+
+const J = (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 => j.escapeRegex(t)).join("..");
+    }
+    return n;
+};
+
+const tt = (t, e) => `Missing ${t}: "${e}" - use "\\\\${e}" to match literal characters`;
+
+const et = (t, e) => {
+    if (typeof t !== "string") {
+        throw new TypeError("Expected a string");
+    }
+    t = V[t] || t;
+    const n = {
+        ...e
+    };
+    const u = typeof n.maxLength === "number" ? Math.min(q, n.maxLength) : q;
+    let o = t.length;
+    if (o > u) {
+        throw new SyntaxError(`Input length: ${o}, exceeds maximum allowed length: ${u}`);
+    }
+    const r = {
+        type: "bos",
+        value: "",
+        output: n.prepend || ""
+    };
+    const s = [ r ];
+    const a = n.capture ? "" : "?:";
+    const i = j.isWindows(e);
+    const c = W.globChars(i);
+    const l = W.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 v = n.bash === true ? C(n) : S;
+    if (n.capture) {
+        v = `(${v})`;
+    }
+    if (typeof n.noext === "boolean") {
+        n.noextglob = n.noext;
+    }
+    const H = {
+        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: s
+    };
+    t = j.removePrefix(t, H);
+    o = t.length;
+    const T = [];
+    const L = [];
+    const O = [];
+    let k = r;
+    let m;
+    const w = () => H.index === o - 1;
+    const N = H.peek = (e = 1) => t[H.index + e];
+    const I = H.advance = () => t[++H.index] || "";
+    const B = () => t.slice(H.index + 1);
+    const M = (t = "", e = 0) => {
+        H.consumed += t;
+        H.index += e;
+    };
+    const G = t => {
+        H.output += t.output != null ? t.output : t.value;
+        M(t.value);
+    };
+    const D = () => {
+        let t = 1;
+        while (N() === "!" && (N(2) !== "(" || N(3) === "?")) {
+            I();
+            H.start++;
+            t++;
+        }
+        if (t % 2 === 0) {
+            return false;
+        }
+        H.negated = true;
+        H.start++;
+        return true;
+    };
+    const P = t => {
+        H[t]++;
+        O.push(t);
+    };
+    const K = t => {
+        H[t]--;
+        O.pop();
+    };
+    const U = t => {
+        if (k.type === "globstar") {
+            const e = H.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) {
+                H.output = H.output.slice(0, -k.output.length);
+                k.type = "star";
+                k.value = "*";
+                k.output = v;
+                H.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;
+        s.push(t);
+        k = t;
+    };
+    const X = (t, e) => {
+        const u = {
+            ...l[e],
+            conditions: 1,
+            inner: ""
+        };
+        u.prev = k;
+        u.parens = H.parens;
+        u.output = H.output;
+        const o = (n.capture ? "(" : "") + u.open;
+        P("parens");
+        U({
+            type: t,
+            value: e,
+            output: H.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 r = v;
+            if (t.inner && t.inner.length > 1 && t.inner.includes("/")) {
+                r = C(n);
+            }
+            if (r !== v || w() || /^\)+$/.test(B())) {
+                u = t.close = `)$))${r}`;
+            }
+            if (t.inner.includes("*") && (o = B()) && /^\.[^\\/.]+$/.test(o)) {
+                const n = et(o, {
+                    ...e,
+                    fastpaths: false
+                }).output;
+                u = t.close = `)${n})${r})`;
+            }
+            if (t.prev.type === "bos") {
+                H.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(z, (t, e, n, o, r, s) => {
+            if (o === "\\") {
+                u = true;
+                return t;
+            }
+            if (o === "?") {
+                if (e) {
+                    return e + o + (r ? b.repeat(r.length) : "");
+                }
+                if (s === 0) {
+                    return d + (r ? b.repeat(r.length) : "");
+                }
+                return b.repeat(n.length);
+            }
+            if (o === ".") {
+                return p.repeat(n.length);
+            }
+            if (o === "*") {
+                if (e) {
+                    return e + o + (r ? v : "");
+                }
+                return v;
+            }
+            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) {
+            H.output = t;
+            return H;
+        }
+        H.output = j.wrapOutput(o, H, e);
+        return H;
+    }
+    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(B());
+            let u = 0;
+            if (e && e[0].length > 2) {
+                u = e[0].length;
+                H.index += u;
+                if (u % 2 !== 0) {
+                    m += "\\";
+                }
+            }
+            if (n.unescape === true) {
+                m = I();
+            } else {
+                m += I();
+            }
+            if (H.brackets === 0) {
+                U({
+                    type: "text",
+                    value: m
+                });
+                continue;
+            }
+        }
+        if (H.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 = Z[n];
+                        if (u) {
+                            k.value = e + u;
+                            H.backtrack = true;
+                            I();
+                            if (!r.output && s.indexOf(k) === 1) {
+                                r.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 (H.quotes === 1 && m !== '"') {
+            m = j.escapeRegex(m);
+            k.value += m;
+            G({
+                value: m
+            });
+            continue;
+        }
+        if (m === '"') {
+            H.quotes = H.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 (H.parens === 0 && n.strictBrackets === true) {
+                throw new SyntaxError(tt("opening", "("));
+            }
+            const t = T[T.length - 1];
+            if (t && H.parens === t.parens + 1) {
+                F(T.pop());
+                continue;
+            }
+            U({
+                type: "paren",
+                value: m,
+                output: H.parens ? ")" : "\\)"
+            });
+            K("parens");
+            continue;
+        }
+        if (m === "[") {
+            if (n.nobracket === true || !B().includes("]")) {
+                if (n.nobracket !== true && n.strictBrackets === true) {
+                    throw new SyntaxError(tt("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 (H.brackets === 0) {
+                if (n.strictBrackets === true) {
+                    throw new SyntaxError(tt("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 || j.hasRegexChars(t)) {
+                continue;
+            }
+            const e = j.escapeRegex(k.value);
+            H.output = H.output.slice(0, -k.value.length);
+            if (n.literalBrackets === true) {
+                H.output += e;
+                k.value = e;
+                continue;
+            }
+            k.value = `(${a}${e}|${k.value})`;
+            H.output += k.value;
+            continue;
+        }
+        if (m === "{" && n.nobrace !== true) {
+            P("braces");
+            const t = {
+                type: "brace",
+                value: m,
+                output: "(",
+                outputIndex: H.output.length,
+                tokensIndex: H.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 = s.slice();
+                const u = [];
+                for (let e = t.length - 1; e >= 0; e--) {
+                    s.pop();
+                    if (t[e].type === "brace") {
+                        break;
+                    }
+                    if (t[e].type !== "dots") {
+                        u.unshift(t[e].value);
+                    }
+                }
+                e = J(u, n);
+                H.backtrack = true;
+            }
+            if (t.comma !== true && t.dots !== true) {
+                const n = H.output.slice(0, t.outputIndex);
+                const u = H.tokens.slice(t.tokensIndex);
+                t.value = t.output = "\\{";
+                m = e = "\\}";
+                H.output = n;
+                for (const t of u) {
+                    H.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" && H.index === H.start + 1) {
+                H.start = H.index + 1;
+                H.consumed = "";
+                H.output = "";
+                s.pop();
+                k = r;
+                continue;
+            }
+            U({
+                type: "slash",
+                value: m,
+                output: A
+            });
+            continue;
+        }
+        if (m === ".") {
+            if (H.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 (H.braces + H.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 === "<" && !j.supportsLookbehinds()) {
+                    throw new Error("Node.js v10 or higher is required for regex lookbehinds");
+                }
+                if (k.value === "(" && !/[!=<:]/.test(t) || t === "<" && !/<([!=]|\w+>)/.test(B())) {
+                    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 && H.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") || H.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 = Y.exec(B());
+            if (t) {
+                m += t[0];
+                H.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 = v;
+            H.backtrack = true;
+            H.globstar = true;
+            M(m);
+            continue;
+        }
+        let e = B();
+        if (n.noextglob !== true && /^\([^?]/.test(e)) {
+            X("star", m);
+            continue;
+        }
+        if (k.type === "star") {
+            if (n.noglobstar === true) {
+                M(m);
+                continue;
+            }
+            const u = k.prev;
+            const o = u.prev;
+            const r = u.type === "slash" || u.type === "bos";
+            const s = o && (o.type === "star" || o.type === "globstar");
+            if (n.bash === true && (!r || e[0] && e[0] !== "/")) {
+                U({
+                    type: "star",
+                    value: m,
+                    output: ""
+                });
+                continue;
+            }
+            const a = H.braces > 0 && (u.type === "comma" || u.type === "brace");
+            const i = T.length && (u.type === "pipe" || u.type === "paren");
+            if (!r && u.type !== "paren" && !a && !i) {
+                U({
+                    type: "star",
+                    value: m,
+                    output: ""
+                });
+                continue;
+            }
+            while (e.slice(0, 3) === "/**") {
+                const n = t[H.index + 4];
+                if (n && n !== "/") {
+                    break;
+                }
+                e = e.slice(3);
+                M("/**", 3);
+            }
+            if (u.type === "bos" && w()) {
+                k.type = "globstar";
+                k.value += m;
+                k.output = C(n);
+                H.output = k.output;
+                H.globstar = true;
+                M(m);
+                continue;
+            }
+            if (u.type === "slash" && u.prev.type !== "bos" && !s && w()) {
+                H.output = H.output.slice(0, -(u.output + k.output).length);
+                u.output = `(?:${u.output}`;
+                k.type = "globstar";
+                k.output = C(n) + (n.strictSlashes ? ")" : "|$)");
+                k.value += m;
+                H.globstar = true;
+                H.output += u.output + k.output;
+                M(m);
+                continue;
+            }
+            if (u.type === "slash" && u.prev.type !== "bos" && e[0] === "/") {
+                const t = e[1] !== void 0 ? "|$" : "";
+                H.output = H.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;
+                H.output += u.output + k.output;
+                H.globstar = true;
+                M(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})`;
+                H.output = k.output;
+                H.globstar = true;
+                M(m + I());
+                U({
+                    type: "slash",
+                    value: "/",
+                    output: ""
+                });
+                continue;
+            }
+            H.output = H.output.slice(0, -k.output.length);
+            k.type = "globstar";
+            k.output = C(n);
+            k.value += m;
+            H.output += k.output;
+            H.globstar = true;
+            M(m);
+            continue;
+        }
+        const u = {
+            type: "star",
+            value: m,
+            output: v
+        };
+        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 (H.index === H.start || k.type === "slash" || k.type === "dot") {
+            if (k.type === "dot") {
+                H.output += E;
+                k.output += E;
+            } else if (n.dot === true) {
+                H.output += g;
+                k.output += g;
+            } else {
+                H.output += x;
+                k.output += x;
+            }
+            if (N() !== "*") {
+                H.output += R;
+                k.output += R;
+            }
+        }
+        U(u);
+    }
+    while (H.brackets > 0) {
+        if (n.strictBrackets === true) throw new SyntaxError(tt("closing", "]"));
+        H.output = j.escapeLast(H.output, "[");
+        K("brackets");
+    }
+    while (H.parens > 0) {
+        if (n.strictBrackets === true) throw new SyntaxError(tt("closing", ")"));
+        H.output = j.escapeLast(H.output, "(");
+        K("parens");
+    }
+    while (H.braces > 0) {
+        if (n.strictBrackets === true) throw new SyntaxError(tt("closing", "}"));
+        H.output = j.escapeLast(H.output, "{");
+        K("braces");
+    }
+    if (n.strictSlashes !== true && (k.type === "star" || k.type === "bracket")) {
+        U({
+            type: "maybe_slash",
+            value: "",
+            output: `${A}?`
+        });
+    }
+    if (H.backtrack === true) {
+        H.output = "";
+        for (const t of H.tokens) {
+            H.output += t.output != null ? t.output : t.value;
+            if (t.suffix) {
+                H.output += t.suffix;
+            }
+        }
+    }
+    return H;
+};
+
+et.fastpaths = (t, e) => {
+    const n = {
+        ...e
+    };
+    const u = typeof n.maxLength === "number" ? Math.min(q, n.maxLength) : q;
+    const o = t.length;
+    if (o > u) {
+        throw new SyntaxError(`Input length: ${o}, exceeds maximum allowed length: ${u}`);
+    }
+    t = V[t] || t;
+    const r = j.isWindows(e);
+    const {DOT_LITERAL: s, SLASH_LITERAL: a, ONE_CHAR: i, DOTS_SLASH: c, NO_DOT: l, NO_DOTS: p, NO_DOTS_SLASH: f, STAR: A, START_ANCHOR: R} = W.globChars(r);
+    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 : s}).)*?)`;
+    };
+    const S = t => {
+        switch (t) {
+          case "*":
+            return `${h}${i}${b}`;
+
+          case ".*":
+            return `${s}${i}${b}`;
+
+          case "*.*":
+            return `${h}${b}${s}${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}${s}${i}${b}`;
+
+          case "**/.*":
+            return `(?:${h}${y(n)}${a})?${s}${i}${b}`;
+
+          default:
+            {
+                const e = /^(.*?)\.(\w+)$/.exec(t);
+                if (!e) return;
+                const n = S(e[1]);
+                if (!n) return;
+                return n + s + e[2];
+            }
+        }
+    };
+    const $ = j.removePrefix(t, g);
+    let C = S($);
+    if (C && n.strictSlashes !== true) {
+        C += `${a}?`;
+    }
+    return C;
+};
+
+var nt = et;
+
+const ut = n;
+
+const ot = Q;
+
+const rt = nt;
+
+const st = u;
+
+const at = d;
+
+const it = t => t && typeof t === "object" && !Array.isArray(t);
+
+const ct = (t, e, n = false) => {
+    if (Array.isArray(t)) {
+        const u = t.map(t => ct(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 = it(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 r = st.isWindows(e);
+    const s = u ? ct.compileRe(t, e) : ct.makeRe(t, e, false, true);
+    const a = s.state;
+    delete s.state;
+    let i = () => false;
+    if (o.ignore) {
+        const t = {
+            ...e,
+            ignore: null,
+            onMatch: null,
+            onResult: null
+        };
+        i = ct(o.ignore, t, n);
+    }
+    const c = (n, u = false) => {
+        const {isMatch: c, match: l, output: p} = ct.test(n, s, e, {
+            glob: t,
+            posix: r
+        });
+        const f = {
+            glob: t,
+            state: a,
+            regex: s,
+            posix: r,
+            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;
+};
+
+ct.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 r = n || {};
+    const s = r.format || (o ? st.toPosixSlashes : null);
+    let a = t === u;
+    let i = a && s ? s(t) : t;
+    if (a === false) {
+        i = s ? s(t) : t;
+        a = i === u;
+    }
+    if (a === false || r.capture === true) {
+        if (r.matchBase === true || r.basename === true) {
+            a = ct.matchBase(t, e, n, o);
         } else {
-            return n;
+            a = e.exec(i);
         }
     }
-}
+    return {
+        isMatch: Boolean(a),
+        match: a,
+        output: i
+    };
+};
+
+ct.matchBase = (t, e, n, u = st.isWindows(n)) => {
+    const o = e instanceof RegExp ? e : ct.makeRe(e, n);
+    return o.test(ut.basename(t));
+};
+
+ct.isMatch = (t, e, n) => ct(e, n)(t);
+
+ct.parse = (t, e) => {
+    if (Array.isArray(t)) return t.map(t => ct.parse(t, e));
+    return rt(t, {
+        ...e,
+        fastpaths: false
+    });
+};
+
+ct.scan = (t, e) => ot(t, e);
+
+ct.compileRe = (t, e, n = false, u = false) => {
+    if (n === true) {
+        return t.output;
+    }
+    const o = e || {};
+    const r = o.contains ? "" : "^";
+    const s = o.contains ? "" : "$";
+    let a = `${r}(?:${t.output})${s}`;
+    if (t && t.negated === true) {
+        a = `^(?!${a}).*$`;
+    }
+    const i = ct.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;
+ct.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 = rt.fastpaths(t, e);
     }
-    return e;
-}
+    if (!o.output) {
+        o = rt(t, e);
+    }
+    return ct.compileRe(o, e, n, u);
+};
+
+ct.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 /$^/;
+    }
+};
+
+ct.constants = at;
+
+var lt = ct;
+
+var pt = lt;
+
+const ft = t;
+
+const At = e;
+
+const Rt = pt;
+
+const ht = u;
+
+const _t = t => t === "" || t === "./";
+
+const Et = t => {
+    const e = t.indexOf("{");
+    return e > -1 && t.indexOf("}", e) > -1;
+};
+
+const gt = (t, e, n) => {
+    e = [].concat(e);
+    t = [].concat(t);
+    let u = new Set;
+    let o = new Set;
+    let r = new Set;
+    let s = 0;
+    let a = t => {
+        r.add(t.output);
+        if (n && n.onResult) {
+            n.onResult(t);
+        }
+    };
+    for (let r = 0; r < e.length; r++) {
+        let i = Rt(String(e[r]), {
+            ...n,
+            onResult: a
+        }, true);
+        let c = i.state.negated || i.state.negatedExtglob;
+        if (c) s++;
+        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 = s === e.length ? [ ...r ] : [ ...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;
+};
+
+gt.match = gt;
+
+gt.matcher = (t, e) => Rt(t, e);
+
+gt.isMatch = (t, e, n) => Rt(e, n)(t);
+
+gt.any = gt.isMatch;
+
+gt.not = (t, e, n = {}) => {
+    e = [].concat(e).map(String);
+    let u = new Set;
+    let o = [];
+    let r = t => {
+        if (n.onResult) n.onResult(t);
+        o.push(t.output);
+    };
+    let s = new Set(gt(t, e, {
+        ...n,
+        onResult: r
+    }));
+    for (let t of o) {
+        if (!s.has(t)) {
+            u.add(t);
+        }
+    }
+    return [ ...u ];
+};
+
+gt.contains = (t, e, n) => {
+    if (typeof t !== "string") {
+        throw new TypeError(`Expected a string: "${ft.inspect(t)}"`);
+    }
+    if (Array.isArray(e)) {
+        return e.some(e => gt.contains(t, e, n));
+    }
+    if (typeof e === "string") {
+        if (_t(t) || _t(e)) {
+            return false;
+        }
+        if (t.includes(e) || t.startsWith("./") && t.slice(2).includes(e)) {
+            return true;
+        }
+    }
+    return gt.isMatch(t, e, {
+        ...n,
+        contains: true
+    });
+};
+
+gt.matchKeys = (t, e, n) => {
+    if (!ht.isObject(t)) {
+        throw new TypeError("Expected the first argument to be an object");
+    }
+    let u = gt(Object.keys(t), e, n);
+    let o = {};
+    for (let e of u) o[e] = t[e];
+    return o;
+};
+
+gt.some = (t, e, n) => {
+    let u = [].concat(t);
+    for (let t of [].concat(e)) {
+        let e = Rt(String(t), n);
+        if (u.some(t => e(t))) {
+            return true;
+        }
+    }
+    return false;
+};
+
+gt.every = (t, e, n) => {
+    let u = [].concat(t);
+    for (let t of [].concat(e)) {
+        let e = Rt(String(t), n);
+        if (!u.every(t => e(t))) {
+            return false;
+        }
+    }
+    return true;
+};
+
+gt.all = (t, e, n) => {
+    if (typeof t !== "string") {
+        throw new TypeError(`Expected a string: "${ft.inspect(t)}"`);
+    }
+    return [].concat(e).every(e => Rt(e, n)(t));
+};
+
+gt.capture = (t, e, n) => {
+    let u = ht.isWindows(n);
+    let o = Rt.makeRe(String(t), {
+        ...n,
+        capture: true
+    });
+    let r = o.exec(u ? ht.toPosixSlashes(e) : e);
+    if (r) {
+        return r.slice(1).map(t => t === void 0 ? "" : t);
+    }
+};
+
+gt.makeRe = (...t) => Rt.makeRe(...t);
+
+gt.scan = (...t) => Rt.scan(...t);
+
+gt.parse = (t, e) => {
+    let n = [];
+    for (let u of [].concat(t || [])) {
+        for (let t of At(String(u), e)) {
+            n.push(Rt.parse(t, e));
+        }
+    }
+    return n;
+};
+
+gt.braces = (t, e) => {
+    if (typeof t !== "string") throw new TypeError("Expected a string");
+    if (e && e.nobrace === true || !Et(t)) {
+        return [ t ];
+    }
+    return At(t, e);
+};
+
+gt.braceExpand = (t, e) => {
+    if (typeof t !== "string") throw new TypeError("Expected a string");
+    return gt.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");
-}
+gt.hasBraces = Et;
 
-var u = n;
+var bt = gt;
 
-export { u as s };
+export { bt as m };