lakutata 2.0.95 → 2.0.96

package/vendor/Package.internal.90.mjs

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