lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.90.cjs

@@ -1,1822 +1,351 @@
-/* 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 t = require("util");
+exports.cjs = {};
 
-const e = require("./Package.internal.41.cjs");
+Object.defineProperty(exports.cjs, "__esModule", {
+    value: true
+});
 
-const n = require("path");
+var r = Function.prototype.toString;
 
-const u = t => t && t.__esModule ? t : {
-    default: t
-};
-
-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}${_}`;
+var t = Object.create;
 
-const b = `(?!${l})`;
+var e = Object.prototype.toString;
 
-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;
+var n = function() {
+    function r() {
+        this._keys = [];
+        this._values = [];
     }
-};
-
-(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)}`;
+    r.prototype.has = function(r) {
+        return !!~this._keys.indexOf(r);
     };
-    t.removePrefix = (t, e = {}) => {
-        let n = t;
-        if (n.startsWith("./")) {
-            n = n.slice(2);
-            e.prefix = "./";
-        }
-        return n;
+    r.prototype.get = function(r) {
+        return this._values[this._keys.indexOf(r)];
     };
-    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.prototype.set = function(r, t) {
+        this._keys.push(r);
+        this._values.push(t);
     };
-})(r);
+    return r;
+}();
 
-const L = r;
+function o() {
+    return new n;
+}
 
-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;
+function a() {
+    return new WeakMap;
+}
 
-const Q = t => t === M || t === m;
+var c = typeof WeakMap !== "undefined" ? a : o;
 
-const W = t => {
-    if (t.isPrefix !== true) {
-        t.depth = t.isGlobstar ? Infinity : 1;
+function u(e) {
+    if (!e) {
+        return t(null);
     }
-};
-
-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;
-                    }
-                }
-            }
-            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;
-        }
+    var n = e.constructor;
+    if (n === Object) {
+        return e === Object.prototype ? {} : t(e);
     }
-    if (n.noext === true) {
-        h = false;
-        R = false;
+    if (n && ~r.call(n).indexOf("[native code]")) {
+        try {
+            return new n;
+        } catch (r) {}
     }
-    let q = i;
-    let j = "";
-    let Z = "";
-    if (l > 0) {
-        j = i.slice(0, l);
-        i = i.slice(l);
-        p -= l;
+    return t(e);
+}
+
+function i(r) {
+    var t = "";
+    if (r.global) {
+        t += "g";
     }
-    if (q && R === true && p > 0) {
-        q = i.slice(0, p);
-        Z = i.slice(p);
-    } else if (R === true) {
-        q = "";
-        Z = i;
-    } else {
-        q = i;
+    if (r.ignoreCase) {
+        t += "i";
     }
-    if (q && q !== "" && q !== "/" && q !== i) {
-        if (Q(q.charCodeAt(q.length - 1))) {
-            q = q.slice(0, -1);
-        }
+    if (r.multiline) {
+        t += "m";
     }
-    if (n.unescape === true) {
-        if (Z) Z = L.removeBackslashes(Z);
-        if (q && g === true) {
-            q = L.removeBackslashes(q);
-        }
+    if (r.unicode) {
+        t += "u";
     }
-    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 (r.sticky) {
+        t += "y";
     }
-    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 {
-                    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;
-};
+    return t;
+}
 
-var j = q;
+function f(r) {
+    return r.flags;
+}
 
-const Z = T;
+var s = /test/g.flags === "g" ? f : i;
 
-const Y = r;
+function p(r) {
+    var t = e.call(r);
+    return t.substring(8, t.length - 1);
+}
 
-const {MAX_LENGTH: z, POSIX_REGEX_SOURCE: V, REGEX_NON_SPECIAL_CHARS: J, REGEX_SPECIAL_CHARS_BACKREF: tt, REPLACEMENTS: et} = Z;
+function y(r) {
+    return r[Symbol.toStringTag] || p(r);
+}
 
-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;
-};
+var v = typeof Symbol !== "undefined" ? y : p;
 
-const ut = (t, e) => `Missing ${t}: "${e}" - use "\\\\${e}" to match literal characters`;
+var l = Object.defineProperty, b = Object.getOwnPropertyDescriptor, d = Object.getOwnPropertyNames, h = Object.getOwnPropertySymbols;
 
-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);
+var g = Object.prototype, j = g.hasOwnProperty, O = g.propertyIsEnumerable;
+
+var w = typeof h === "function";
+
+function C(r) {
+    return d(r).concat(h(r));
+}
+
+var A = w ? C : d;
+
+function m(r, t, e) {
+    var n = A(r);
+    for (var o = 0, a = n.length, c = void 0, u = void 0; o < a; ++o) {
+        c = n[o];
+        if (c === "callee" || c === "caller") {
             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);
+        u = b(r, c);
+        if (!u) {
+            t[c] = e.copier(r[c], e);
             continue;
         }
-        if (k && (k.type === "bracket" || k.type === "paren") && n.regex === true) {
-            u.output = m;
-            U(u);
-            continue;
+        if (!u.get && !u.set) {
+            u.value = e.copier(u.value, e);
         }
-        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;
-            }
+        try {
+            l(t, c, u);
+        } catch (r) {
+            t[c] = u.value;
         }
-        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;
-};
+    return t;
+}
 
-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}`);
+function B(r, t) {
+    var e = new t.Constructor;
+    t.cache.set(r, e);
+    for (var n = 0, o = r.length; n < o; ++n) {
+        e[n] = t.copier(r[n], t);
     }
-    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}`;
+    return e;
+}
 
-          case ".*":
-            return `${r}${i}${b}`;
+function x(r, t) {
+    var e = new t.Constructor;
+    t.cache.set(r, e);
+    return m(r, e, t);
+}
 
-          case "*.*":
-            return `${h}${b}${r}${i}${b}`;
+function _(r, t) {
+    return r.slice(0);
+}
 
-          case "*/*":
-            return `${h}${b}${a}${i}${_}${b}`;
+function S(r, t) {
+    return r.slice(0, r.size, r.type);
+}
 
-          case "**":
-            return h + y(n);
+function k(r, t) {
+    return new t.Constructor(_(r.buffer));
+}
 
-          case "**/*":
-            return `(?:${h}${y(n)}${a})?${_}${i}${b}`;
+function P(r, t) {
+    return new t.Constructor(r.getTime());
+}
 
-          case "**/*.*":
-            return `(?:${h}${y(n)}${a})?${_}${b}${r}${i}${b}`;
+function E(r, t) {
+    var e = new t.Constructor;
+    t.cache.set(r, e);
+    r.forEach(function(r, n) {
+        e.set(n, t.copier(r, t));
+    });
+    return e;
+}
 
-          case "**/.*":
-            return `(?:${h}${y(n)}${a})?${r}${i}${b}`;
+function I(r, t) {
+    return m(r, E(r, t), t);
+}
 
-          default:
-            {
-                const e = /^(.*?)\.(\w+)$/.exec(t);
-                if (!e) return;
-                const n = S(e[1]);
-                if (!n) return;
-                return n + r + e[2];
-            }
+function M(r, t) {
+    var e = u(t.prototype);
+    t.cache.set(r, e);
+    for (var n in r) {
+        if (j.call(r, n)) {
+            e[n] = t.copier(r[n], t);
         }
-    };
-    const $ = Y.removePrefix(t, g);
-    let C = S($);
-    if (C && n.strictSlashes !== true) {
-        C += `${a}?`;
     }
-    return C;
-};
-
-var st = ot;
+    return e;
+}
 
-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;
+function U(r, t) {
+    var e = u(t.prototype);
+    t.cache.set(r, e);
+    for (var n in r) {
+        if (j.call(r, n)) {
+            e[n] = t.copier(r[n], t);
         }
-        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 {
-            a = e.exec(i);
+    var o = h(r);
+    for (var a = 0, c = o.length, i = void 0; a < c; ++a) {
+        i = o[a];
+        if (O.call(r, i)) {
+            e[i] = t.copier(r[i], t);
         }
     }
-    return {
-        isMatch: Boolean(a),
-        match: a,
-        output: i
-    };
-};
+    return e;
+}
 
-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));
-};
+var W = w ? U : M;
 
-ft.isMatch = (t, e, n) => ft(e, n)(t);
+function D(r, t) {
+    var e = u(t.prototype);
+    t.cache.set(r, e);
+    return m(r, e, t);
+}
 
-ft.parse = (t, e) => {
-    if (Array.isArray(t)) return t.map(t => ft.parse(t, e));
-    return it(t, {
-        ...e,
-        fastpaths: false
-    });
-};
+function F(r, t) {
+    return new t.Constructor(r.valueOf());
+}
 
-ft.scan = (t, e) => at(t, e);
+function V(r, t) {
+    var e = new t.Constructor(r.source, s(r));
+    e.lastIndex = r.lastIndex;
+    return 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 N(r, t) {
+    return r;
+}
 
-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);
-    }
-    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;
+function T(r, t) {
+    var e = new t.Constructor;
+    t.cache.set(r, e);
+    r.forEach(function(r) {
+        e.add(t.copier(r, t));
+    });
+    return e;
+}
 
-const Et = Rt;
+function z(r, t) {
+    return m(r, T(r, t), t);
+}
 
-const gt = r;
+var R = Array.isArray;
 
-const bt = t => t === "" || t === "./";
+var q = Object.assign;
 
-const yt = t => {
-    const e = t.indexOf("{");
-    return e > -1 && t.indexOf("}", e) > -1;
+var G = Object.getPrototypeOf || function(r) {
+    return r.__proto__;
 };
 
-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;
+var H = {
+    array: B,
+    arrayBuffer: _,
+    blob: S,
+    dataView: k,
+    date: P,
+    error: N,
+    map: E,
+    object: W,
+    regExp: V,
+    set: T
 };
 
-St.match = St;
-
-St.matcher = (t, e) => Et(t, e);
+var J = q({}, H, {
+    array: x,
+    map: I,
+    object: D,
+    set: z
+});
 
-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);
+function K(r) {
+    return {
+        Arguments: r.object,
+        Array: r.array,
+        ArrayBuffer: r.arrayBuffer,
+        Blob: r.blob,
+        Boolean: F,
+        DataView: r.dataView,
+        Date: r.date,
+        Error: r.error,
+        Float32Array: r.arrayBuffer,
+        Float64Array: r.arrayBuffer,
+        Int8Array: r.arrayBuffer,
+        Int16Array: r.arrayBuffer,
+        Int32Array: r.arrayBuffer,
+        Map: r.map,
+        Number: F,
+        Object: r.object,
+        Promise: N,
+        RegExp: r.regExp,
+        Set: r.set,
+        String: F,
+        WeakMap: N,
+        WeakSet: N,
+        Uint8Array: r.arrayBuffer,
+        Uint8ClampedArray: r.arrayBuffer,
+        Uint16Array: r.arrayBuffer,
+        Uint32Array: r.arrayBuffer,
+        Uint64Array: r.arrayBuffer
     };
-    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));
-};
+}
+
+function L(r) {
+    var t = q({}, H, r);
+    var e = K(t);
+    var n = e.Array, o = e.Object;
+    function a(r, t) {
+        t.prototype = t.Constructor = undefined;
+        if (!r || typeof r !== "object") {
+            return r;
+        }
+        if (t.cache.has(r)) {
+            return t.cache.get(r);
+        }
+        t.prototype = G(r);
+        t.Constructor = t.prototype && t.prototype.constructor;
+        if (!t.Constructor || t.Constructor === Object) {
+            return o(r, t);
+        }
+        if (R(r)) {
+            return n(r, t);
+        }
+        var a = e[v(r)];
+        if (a) {
+            return a(r, t);
+        }
+        return typeof r.then === "function" ? r : o(r, t);
+    }
+    return function r(t) {
+        return a(t, {
+            Constructor: undefined,
+            cache: c(),
+            copier: a,
+            prototype: undefined
+        });
+    };
+}
 
-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);
-    }
-};
+function Q(r) {
+    return L(q({}, J, r));
+}
 
-St.makeRe = (...t) => Et.makeRe(...t);
+var X = Q({});
 
-St.scan = (...t) => Et.scan(...t);
+var Y = L({});
 
-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;
-};
+exports.cjs.copyStrict = X;
 
-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
-    });
-};
+exports.cjs.createCopier = L;
 
-St.hasBraces = yt;
+exports.cjs.createStrictCopier = Q;
 
-exports.micromatch_1 = St;
+exports.cjs.default = Y;