@amoa/casting 0.1.4 → 0.1.6

package/dist/node_modules/next/dist/compiled/picomatch/index.js

@@ -1,1662 +0,0 @@
-import { __module as picomatch } from '../../../../../_virtual/index3.js';
-
-var hasRequiredPicomatch;
-
-function requirePicomatch () {
-	if (hasRequiredPicomatch) return picomatch.exports;
-	hasRequiredPicomatch = 1;
-	(() => {
-
-	  var t = {
-	    170: (t, e, u) => {
-	      const n = u(510);
-	      const isWindows = () => {
-	        if (typeof navigator !== "undefined" && navigator.platform) {
-	          const t = navigator.platform.toLowerCase();
-	          return t === "win32" || t === "windows";
-	        }
-	        if (typeof process !== "undefined" && process.platform) {
-	          return process.platform === "win32";
-	        }
-	        return false;
-	      };
-	      function picomatch(t, e, u = false) {
-	        if (e && (e.windows === null || e.windows === undefined)) {
-	          e = {
-	            ...e,
-	            windows: isWindows()
-	          };
-	        }
-	        return n(t, e, u);
-	      }
-	      Object.assign(picomatch, n);
-	      t.exports = picomatch;
-	    },
-	    154: t => {
-	      const e = "\\\\/";
-	      const u = `[^${e}]`;
-	      const n = "\\.";
-	      const o = "\\+";
-	      const s = "\\?";
-	      const r = "\\/";
-	      const a = "(?=.)";
-	      const i = "[^/]";
-	      const c = `(?:${r}|$)`;
-	      const p = `(?:^|${r})`;
-	      const l = `${n}{1,2}${c}`;
-	      const f = `(?!${n})`;
-	      const A = `(?!${p}${l})`;
-	      const _ = `(?!${n}{0,1}${c})`;
-	      const R = `(?!${l})`;
-	      const E = `[^.${r}]`;
-	      const h = `${i}*?`;
-	      const g = "/";
-	      const b = {
-	        DOT_LITERAL: n,
-	        PLUS_LITERAL: o,
-	        QMARK_LITERAL: s,
-	        SLASH_LITERAL: r,
-	        ONE_CHAR: a,
-	        QMARK: i,
-	        END_ANCHOR: c,
-	        DOTS_SLASH: l,
-	        NO_DOT: f,
-	        NO_DOTS: A,
-	        NO_DOT_SLASH: _,
-	        NO_DOTS_SLASH: R,
-	        QMARK_NO_DOT: E,
-	        STAR: h,
-	        START_ANCHOR: p,
-	        SEP: g
-	      };
-	      const C = {
-	        ...b,
-	        SLASH_LITERAL: `[${e}]`,
-	        QMARK: u,
-	        STAR: `${u}*?`,
-	        DOTS_SLASH: `${n}{1,2}(?:[${e}]|$)`,
-	        NO_DOT: `(?!${n})`,
-	        NO_DOTS: `(?!(?:^|[${e}])${n}{1,2}(?:[${e}]|$))`,
-	        NO_DOT_SLASH: `(?!${n}{0,1}(?:[${e}]|$))`,
-	        NO_DOTS_SLASH: `(?!${n}{1,2}(?:[${e}]|$))`,
-	        QMARK_NO_DOT: `[^.${e}]`,
-	        START_ANCHOR: `(?:^|[${e}])`,
-	        END_ANCHOR: `(?:[${e}]|$)`,
-	        SEP: "\\"
-	      };
-	      const y = {
-	        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"
-	      };
-	      t.exports = {
-	        MAX_LENGTH: 1024 * 64,
-	        POSIX_REGEX_SOURCE: y,
-	        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,
-	        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 : b;
-	        }
-	      };
-	    },
-	    697: (t, e, u) => {
-	      const n = u(154);
-	      const o = u(96);
-	      const {
-	        MAX_LENGTH: s,
-	        POSIX_REGEX_SOURCE: r,
-	        REGEX_NON_SPECIAL_CHARS: a,
-	        REGEX_SPECIAL_CHARS_BACKREF: i,
-	        REPLACEMENTS: c
-	      } = n;
-	      const expandRange = (t, e) => {
-	        if (typeof e.expandRange === "function") {
-	          return e.expandRange(...t, e);
-	        }
-	        t.sort();
-	        const u = `[${t.join("-")}]`;
-	        try {
-	          new RegExp(u);
-	        } catch (e) {
-	          return t.map(t => o.escapeRegex(t)).join("..");
-	        }
-	        return u;
-	      };
-	      const syntaxError = (t, e) => `Missing ${t}: "${e}" - use "\\\\${e}" to match literal characters`;
-	      const parse = (t, e) => {
-	        if (typeof t !== "string") {
-	          throw new TypeError("Expected a string");
-	        }
-	        t = c[t] || t;
-	        const u = {
-	          ...e
-	        };
-	        const p = typeof u.maxLength === "number" ? Math.min(s, u.maxLength) : s;
-	        let l = t.length;
-	        if (l > p) {
-	          throw new SyntaxError(`Input length: ${l}, exceeds maximum allowed length: ${p}`);
-	        }
-	        const f = {
-	          type: "bos",
-	          value: "",
-	          output: u.prepend || ""
-	        };
-	        const A = [f];
-	        const _ = u.capture ? "" : "?:";
-	        const R = n.globChars(u.windows);
-	        const E = n.extglobChars(R);
-	        const {
-	          DOT_LITERAL: h,
-	          PLUS_LITERAL: g,
-	          SLASH_LITERAL: b,
-	          ONE_CHAR: C,
-	          DOTS_SLASH: y,
-	          NO_DOT: $,
-	          NO_DOT_SLASH: x,
-	          NO_DOTS_SLASH: S,
-	          QMARK: H,
-	          QMARK_NO_DOT: v,
-	          STAR: d,
-	          START_ANCHOR: L
-	        } = R;
-	        const globstar = t => `(${_}(?:(?!${L}${t.dot ? y : h}).)*?)`;
-	        const T = u.dot ? "" : $;
-	        const O = u.dot ? H : v;
-	        let k = u.bash === true ? globstar(u) : d;
-	        if (u.capture) {
-	          k = `(${k})`;
-	        }
-	        if (typeof u.noext === "boolean") {
-	          u.noextglob = u.noext;
-	        }
-	        const m = {
-	          input: t,
-	          index: -1,
-	          start: 0,
-	          dot: u.dot === true,
-	          consumed: "",
-	          output: "",
-	          prefix: "",
-	          backtrack: false,
-	          negated: false,
-	          brackets: 0,
-	          braces: 0,
-	          parens: 0,
-	          quotes: 0,
-	          globstar: false,
-	          tokens: A
-	        };
-	        t = o.removePrefix(t, m);
-	        l = t.length;
-	        const w = [];
-	        const N = [];
-	        const I = [];
-	        let B = f;
-	        let G;
-	        const eos = () => m.index === l - 1;
-	        const D = m.peek = (e = 1) => t[m.index + e];
-	        const M = m.advance = () => t[++m.index] || "";
-	        const remaining = () => t.slice(m.index + 1);
-	        const consume = (t = "", e = 0) => {
-	          m.consumed += t;
-	          m.index += e;
-	        };
-	        const append = t => {
-	          m.output += t.output != null ? t.output : t.value;
-	          consume(t.value);
-	        };
-	        const negate = () => {
-	          let t = 1;
-	          while (D() === "!" && (D(2) !== "(" || D(3) === "?")) {
-	            M();
-	            m.start++;
-	            t++;
-	          }
-	          if (t % 2 === 0) {
-	            return false;
-	          }
-	          m.negated = true;
-	          m.start++;
-	          return true;
-	        };
-	        const increment = t => {
-	          m[t]++;
-	          I.push(t);
-	        };
-	        const decrement = t => {
-	          m[t]--;
-	          I.pop();
-	        };
-	        const push = t => {
-	          if (B.type === "globstar") {
-	            const e = m.braces > 0 && (t.type === "comma" || t.type === "brace");
-	            const u = t.extglob === true || w.length && (t.type === "pipe" || t.type === "paren");
-	            if (t.type !== "slash" && t.type !== "paren" && !e && !u) {
-	              m.output = m.output.slice(0, -B.output.length);
-	              B.type = "star";
-	              B.value = "*";
-	              B.output = k;
-	              m.output += B.output;
-	            }
-	          }
-	          if (w.length && t.type !== "paren") {
-	            w[w.length - 1].inner += t.value;
-	          }
-	          if (t.value || t.output) append(t);
-	          if (B && B.type === "text" && t.type === "text") {
-	            B.output = (B.output || B.value) + t.value;
-	            B.value += t.value;
-	            return;
-	          }
-	          t.prev = B;
-	          A.push(t);
-	          B = t;
-	        };
-	        const extglobOpen = (t, e) => {
-	          const n = {
-	            ...E[e],
-	            conditions: 1,
-	            inner: ""
-	          };
-	          n.prev = B;
-	          n.parens = m.parens;
-	          n.output = m.output;
-	          const o = (u.capture ? "(" : "") + n.open;
-	          increment("parens");
-	          push({
-	            type: t,
-	            value: e,
-	            output: m.output ? "" : C
-	          });
-	          push({
-	            type: "paren",
-	            extglob: true,
-	            value: M(),
-	            output: o
-	          });
-	          w.push(n);
-	        };
-	        const extglobClose = t => {
-	          let n = t.close + (u.capture ? ")" : "");
-	          let o;
-	          if (t.type === "negate") {
-	            let s = k;
-	            if (t.inner && t.inner.length > 1 && t.inner.includes("/")) {
-	              s = globstar(u);
-	            }
-	            if (s !== k || eos() || /^\)+$/.test(remaining())) {
-	              n = t.close = `)$))${s}`;
-	            }
-	            if (t.inner.includes("*") && (o = remaining()) && /^\.[^\\/.]+$/.test(o)) {
-	              const u = parse(o, {
-	                ...e,
-	                fastpaths: false
-	              }).output;
-	              n = t.close = `)${u})${s})`;
-	            }
-	            if (t.prev.type === "bos") {
-	              m.negatedExtglob = true;
-	            }
-	          }
-	          push({
-	            type: "paren",
-	            extglob: true,
-	            value: G,
-	            output: n
-	          });
-	          decrement("parens");
-	        };
-	        if (u.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(t)) {
-	          let n = false;
-	          let s = t.replace(i, (t, e, u, o, s, r) => {
-	            if (o === "\\") {
-	              n = true;
-	              return t;
-	            }
-	            if (o === "?") {
-	              if (e) {
-	                return e + o + (s ? H.repeat(s.length) : "");
-	              }
-	              if (r === 0) {
-	                return O + (s ? H.repeat(s.length) : "");
-	              }
-	              return H.repeat(u.length);
-	            }
-	            if (o === ".") {
-	              return h.repeat(u.length);
-	            }
-	            if (o === "*") {
-	              if (e) {
-	                return e + o + (s ? k : "");
-	              }
-	              return k;
-	            }
-	            return e ? t : `\\${t}`;
-	          });
-	          if (n === true) {
-	            if (u.unescape === true) {
-	              s = s.replace(/\\/g, "");
-	            } else {
-	              s = s.replace(/\\+/g, t => t.length % 2 === 0 ? "\\\\" : t ? "\\" : "");
-	            }
-	          }
-	          if (s === t && u.contains === true) {
-	            m.output = t;
-	            return m;
-	          }
-	          m.output = o.wrapOutput(s, m, e);
-	          return m;
-	        }
-	        while (!eos()) {
-	          G = M();
-	          if (G === "\0") {
-	            continue;
-	          }
-	          if (G === "\\") {
-	            const t = D();
-	            if (t === "/" && u.bash !== true) {
-	              continue;
-	            }
-	            if (t === "." || t === ";") {
-	              continue;
-	            }
-	            if (!t) {
-	              G += "\\";
-	              push({
-	                type: "text",
-	                value: G
-	              });
-	              continue;
-	            }
-	            const e = /^\\+/.exec(remaining());
-	            let n = 0;
-	            if (e && e[0].length > 2) {
-	              n = e[0].length;
-	              m.index += n;
-	              if (n % 2 !== 0) {
-	                G += "\\";
-	              }
-	            }
-	            if (u.unescape === true) {
-	              G = M();
-	            } else {
-	              G += M();
-	            }
-	            if (m.brackets === 0) {
-	              push({
-	                type: "text",
-	                value: G
-	              });
-	              continue;
-	            }
-	          }
-	          if (m.brackets > 0 && (G !== "]" || B.value === "[" || B.value === "[^")) {
-	            if (u.posix !== false && G === ":") {
-	              const t = B.value.slice(1);
-	              if (t.includes("[")) {
-	                B.posix = true;
-	                if (t.includes(":")) {
-	                  const t = B.value.lastIndexOf("[");
-	                  const e = B.value.slice(0, t);
-	                  const u = B.value.slice(t + 2);
-	                  const n = r[u];
-	                  if (n) {
-	                    B.value = e + n;
-	                    m.backtrack = true;
-	                    M();
-	                    if (!f.output && A.indexOf(B) === 1) {
-	                      f.output = C;
-	                    }
-	                    continue;
-	                  }
-	                }
-	              }
-	            }
-	            if (G === "[" && D() !== ":" || G === "-" && D() === "]") {
-	              G = `\\${G}`;
-	            }
-	            if (G === "]" && (B.value === "[" || B.value === "[^")) {
-	              G = `\\${G}`;
-	            }
-	            if (u.posix === true && G === "!" && B.value === "[") {
-	              G = "^";
-	            }
-	            B.value += G;
-	            append({
-	              value: G
-	            });
-	            continue;
-	          }
-	          if (m.quotes === 1 && G !== '"') {
-	            G = o.escapeRegex(G);
-	            B.value += G;
-	            append({
-	              value: G
-	            });
-	            continue;
-	          }
-	          if (G === '"') {
-	            m.quotes = m.quotes === 1 ? 0 : 1;
-	            if (u.keepQuotes === true) {
-	              push({
-	                type: "text",
-	                value: G
-	              });
-	            }
-	            continue;
-	          }
-	          if (G === "(") {
-	            increment("parens");
-	            push({
-	              type: "paren",
-	              value: G
-	            });
-	            continue;
-	          }
-	          if (G === ")") {
-	            if (m.parens === 0 && u.strictBrackets === true) {
-	              throw new SyntaxError(syntaxError("opening", "("));
-	            }
-	            const t = w[w.length - 1];
-	            if (t && m.parens === t.parens + 1) {
-	              extglobClose(w.pop());
-	              continue;
-	            }
-	            push({
-	              type: "paren",
-	              value: G,
-	              output: m.parens ? ")" : "\\)"
-	            });
-	            decrement("parens");
-	            continue;
-	          }
-	          if (G === "[") {
-	            if (u.nobracket === true || !remaining().includes("]")) {
-	              if (u.nobracket !== true && u.strictBrackets === true) {
-	                throw new SyntaxError(syntaxError("closing", "]"));
-	              }
-	              G = `\\${G}`;
-	            } else {
-	              increment("brackets");
-	            }
-	            push({
-	              type: "bracket",
-	              value: G
-	            });
-	            continue;
-	          }
-	          if (G === "]") {
-	            if (u.nobracket === true || B && B.type === "bracket" && B.value.length === 1) {
-	              push({
-	                type: "text",
-	                value: G,
-	                output: `\\${G}`
-	              });
-	              continue;
-	            }
-	            if (m.brackets === 0) {
-	              if (u.strictBrackets === true) {
-	                throw new SyntaxError(syntaxError("opening", "["));
-	              }
-	              push({
-	                type: "text",
-	                value: G,
-	                output: `\\${G}`
-	              });
-	              continue;
-	            }
-	            decrement("brackets");
-	            const t = B.value.slice(1);
-	            if (B.posix !== true && t[0] === "^" && !t.includes("/")) {
-	              G = `/${G}`;
-	            }
-	            B.value += G;
-	            append({
-	              value: G
-	            });
-	            if (u.literalBrackets === false || o.hasRegexChars(t)) {
-	              continue;
-	            }
-	            const e = o.escapeRegex(B.value);
-	            m.output = m.output.slice(0, -B.value.length);
-	            if (u.literalBrackets === true) {
-	              m.output += e;
-	              B.value = e;
-	              continue;
-	            }
-	            B.value = `(${_}${e}|${B.value})`;
-	            m.output += B.value;
-	            continue;
-	          }
-	          if (G === "{" && u.nobrace !== true) {
-	            increment("braces");
-	            const t = {
-	              type: "brace",
-	              value: G,
-	              output: "(",
-	              outputIndex: m.output.length,
-	              tokensIndex: m.tokens.length
-	            };
-	            N.push(t);
-	            push(t);
-	            continue;
-	          }
-	          if (G === "}") {
-	            const t = N[N.length - 1];
-	            if (u.nobrace === true || !t) {
-	              push({
-	                type: "text",
-	                value: G,
-	                output: G
-	              });
-	              continue;
-	            }
-	            let e = ")";
-	            if (t.dots === true) {
-	              const t = A.slice();
-	              const n = [];
-	              for (let e = t.length - 1; e >= 0; e--) {
-	                A.pop();
-	                if (t[e].type === "brace") {
-	                  break;
-	                }
-	                if (t[e].type !== "dots") {
-	                  n.unshift(t[e].value);
-	                }
-	              }
-	              e = expandRange(n, u);
-	              m.backtrack = true;
-	            }
-	            if (t.comma !== true && t.dots !== true) {
-	              const u = m.output.slice(0, t.outputIndex);
-	              const n = m.tokens.slice(t.tokensIndex);
-	              t.value = t.output = "\\{";
-	              G = e = "\\}";
-	              m.output = u;
-	              for (const t of n) {
-	                m.output += t.output || t.value;
-	              }
-	            }
-	            push({
-	              type: "brace",
-	              value: G,
-	              output: e
-	            });
-	            decrement("braces");
-	            N.pop();
-	            continue;
-	          }
-	          if (G === "|") {
-	            if (w.length > 0) {
-	              w[w.length - 1].conditions++;
-	            }
-	            push({
-	              type: "text",
-	              value: G
-	            });
-	            continue;
-	          }
-	          if (G === ",") {
-	            let t = G;
-	            const e = N[N.length - 1];
-	            if (e && I[I.length - 1] === "braces") {
-	              e.comma = true;
-	              t = "|";
-	            }
-	            push({
-	              type: "comma",
-	              value: G,
-	              output: t
-	            });
-	            continue;
-	          }
-	          if (G === "/") {
-	            if (B.type === "dot" && m.index === m.start + 1) {
-	              m.start = m.index + 1;
-	              m.consumed = "";
-	              m.output = "";
-	              A.pop();
-	              B = f;
-	              continue;
-	            }
-	            push({
-	              type: "slash",
-	              value: G,
-	              output: b
-	            });
-	            continue;
-	          }
-	          if (G === ".") {
-	            if (m.braces > 0 && B.type === "dot") {
-	              if (B.value === ".") B.output = h;
-	              const t = N[N.length - 1];
-	              B.type = "dots";
-	              B.output += G;
-	              B.value += G;
-	              t.dots = true;
-	              continue;
-	            }
-	            if (m.braces + m.parens === 0 && B.type !== "bos" && B.type !== "slash") {
-	              push({
-	                type: "text",
-	                value: G,
-	                output: h
-	              });
-	              continue;
-	            }
-	            push({
-	              type: "dot",
-	              value: G,
-	              output: h
-	            });
-	            continue;
-	          }
-	          if (G === "?") {
-	            const t = B && B.value === "(";
-	            if (!t && u.noextglob !== true && D() === "(" && D(2) !== "?") {
-	              extglobOpen("qmark", G);
-	              continue;
-	            }
-	            if (B && B.type === "paren") {
-	              const t = D();
-	              let e = G;
-	              if (B.value === "(" && !/[!=<:]/.test(t) || t === "<" && !/<([!=]|\w+>)/.test(remaining())) {
-	                e = `\\${G}`;
-	              }
-	              push({
-	                type: "text",
-	                value: G,
-	                output: e
-	              });
-	              continue;
-	            }
-	            if (u.dot !== true && (B.type === "slash" || B.type === "bos")) {
-	              push({
-	                type: "qmark",
-	                value: G,
-	                output: v
-	              });
-	              continue;
-	            }
-	            push({
-	              type: "qmark",
-	              value: G,
-	              output: H
-	            });
-	            continue;
-	          }
-	          if (G === "!") {
-	            if (u.noextglob !== true && D() === "(") {
-	              if (D(2) !== "?" || !/[!=<:]/.test(D(3))) {
-	                extglobOpen("negate", G);
-	                continue;
-	              }
-	            }
-	            if (u.nonegate !== true && m.index === 0) {
-	              negate();
-	              continue;
-	            }
-	          }
-	          if (G === "+") {
-	            if (u.noextglob !== true && D() === "(" && D(2) !== "?") {
-	              extglobOpen("plus", G);
-	              continue;
-	            }
-	            if (B && B.value === "(" || u.regex === false) {
-	              push({
-	                type: "plus",
-	                value: G,
-	                output: g
-	              });
-	              continue;
-	            }
-	            if (B && (B.type === "bracket" || B.type === "paren" || B.type === "brace") || m.parens > 0) {
-	              push({
-	                type: "plus",
-	                value: G
-	              });
-	              continue;
-	            }
-	            push({
-	              type: "plus",
-	              value: g
-	            });
-	            continue;
-	          }
-	          if (G === "@") {
-	            if (u.noextglob !== true && D() === "(" && D(2) !== "?") {
-	              push({
-	                type: "at",
-	                extglob: true,
-	                value: G,
-	                output: ""
-	              });
-	              continue;
-	            }
-	            push({
-	              type: "text",
-	              value: G
-	            });
-	            continue;
-	          }
-	          if (G !== "*") {
-	            if (G === "$" || G === "^") {
-	              G = `\\${G}`;
-	            }
-	            const t = a.exec(remaining());
-	            if (t) {
-	              G += t[0];
-	              m.index += t[0].length;
-	            }
-	            push({
-	              type: "text",
-	              value: G
-	            });
-	            continue;
-	          }
-	          if (B && (B.type === "globstar" || B.star === true)) {
-	            B.type = "star";
-	            B.star = true;
-	            B.value += G;
-	            B.output = k;
-	            m.backtrack = true;
-	            m.globstar = true;
-	            consume(G);
-	            continue;
-	          }
-	          let e = remaining();
-	          if (u.noextglob !== true && /^\([^?]/.test(e)) {
-	            extglobOpen("star", G);
-	            continue;
-	          }
-	          if (B.type === "star") {
-	            if (u.noglobstar === true) {
-	              consume(G);
-	              continue;
-	            }
-	            const n = B.prev;
-	            const o = n.prev;
-	            const s = n.type === "slash" || n.type === "bos";
-	            const r = o && (o.type === "star" || o.type === "globstar");
-	            if (u.bash === true && (!s || e[0] && e[0] !== "/")) {
-	              push({
-	                type: "star",
-	                value: G,
-	                output: ""
-	              });
-	              continue;
-	            }
-	            const a = m.braces > 0 && (n.type === "comma" || n.type === "brace");
-	            const i = w.length && (n.type === "pipe" || n.type === "paren");
-	            if (!s && n.type !== "paren" && !a && !i) {
-	              push({
-	                type: "star",
-	                value: G,
-	                output: ""
-	              });
-	              continue;
-	            }
-	            while (e.slice(0, 3) === "/**") {
-	              const u = t[m.index + 4];
-	              if (u && u !== "/") {
-	                break;
-	              }
-	              e = e.slice(3);
-	              consume("/**", 3);
-	            }
-	            if (n.type === "bos" && eos()) {
-	              B.type = "globstar";
-	              B.value += G;
-	              B.output = globstar(u);
-	              m.output = B.output;
-	              m.globstar = true;
-	              consume(G);
-	              continue;
-	            }
-	            if (n.type === "slash" && n.prev.type !== "bos" && !r && eos()) {
-	              m.output = m.output.slice(0, -(n.output + B.output).length);
-	              n.output = `(?:${n.output}`;
-	              B.type = "globstar";
-	              B.output = globstar(u) + (u.strictSlashes ? ")" : "|$)");
-	              B.value += G;
-	              m.globstar = true;
-	              m.output += n.output + B.output;
-	              consume(G);
-	              continue;
-	            }
-	            if (n.type === "slash" && n.prev.type !== "bos" && e[0] === "/") {
-	              const t = e[1] !== void 0 ? "|$" : "";
-	              m.output = m.output.slice(0, -(n.output + B.output).length);
-	              n.output = `(?:${n.output}`;
-	              B.type = "globstar";
-	              B.output = `${globstar(u)}${b}|${b}${t})`;
-	              B.value += G;
-	              m.output += n.output + B.output;
-	              m.globstar = true;
-	              consume(G + M());
-	              push({
-	                type: "slash",
-	                value: "/",
-	                output: ""
-	              });
-	              continue;
-	            }
-	            if (n.type === "bos" && e[0] === "/") {
-	              B.type = "globstar";
-	              B.value += G;
-	              B.output = `(?:^|${b}|${globstar(u)}${b})`;
-	              m.output = B.output;
-	              m.globstar = true;
-	              consume(G + M());
-	              push({
-	                type: "slash",
-	                value: "/",
-	                output: ""
-	              });
-	              continue;
-	            }
-	            m.output = m.output.slice(0, -B.output.length);
-	            B.type = "globstar";
-	            B.output = globstar(u);
-	            B.value += G;
-	            m.output += B.output;
-	            m.globstar = true;
-	            consume(G);
-	            continue;
-	          }
-	          const n = {
-	            type: "star",
-	            value: G,
-	            output: k
-	          };
-	          if (u.bash === true) {
-	            n.output = ".*?";
-	            if (B.type === "bos" || B.type === "slash") {
-	              n.output = T + n.output;
-	            }
-	            push(n);
-	            continue;
-	          }
-	          if (B && (B.type === "bracket" || B.type === "paren") && u.regex === true) {
-	            n.output = G;
-	            push(n);
-	            continue;
-	          }
-	          if (m.index === m.start || B.type === "slash" || B.type === "dot") {
-	            if (B.type === "dot") {
-	              m.output += x;
-	              B.output += x;
-	            } else if (u.dot === true) {
-	              m.output += S;
-	              B.output += S;
-	            } else {
-	              m.output += T;
-	              B.output += T;
-	            }
-	            if (D() !== "*") {
-	              m.output += C;
-	              B.output += C;
-	            }
-	          }
-	          push(n);
-	        }
-	        while (m.brackets > 0) {
-	          if (u.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
-	          m.output = o.escapeLast(m.output, "[");
-	          decrement("brackets");
-	        }
-	        while (m.parens > 0) {
-	          if (u.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
-	          m.output = o.escapeLast(m.output, "(");
-	          decrement("parens");
-	        }
-	        while (m.braces > 0) {
-	          if (u.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
-	          m.output = o.escapeLast(m.output, "{");
-	          decrement("braces");
-	        }
-	        if (u.strictSlashes !== true && (B.type === "star" || B.type === "bracket")) {
-	          push({
-	            type: "maybe_slash",
-	            value: "",
-	            output: `${b}?`
-	          });
-	        }
-	        if (m.backtrack === true) {
-	          m.output = "";
-	          for (const t of m.tokens) {
-	            m.output += t.output != null ? t.output : t.value;
-	            if (t.suffix) {
-	              m.output += t.suffix;
-	            }
-	          }
-	        }
-	        return m;
-	      };
-	      parse.fastpaths = (t, e) => {
-	        const u = {
-	          ...e
-	        };
-	        const r = typeof u.maxLength === "number" ? Math.min(s, u.maxLength) : s;
-	        const a = t.length;
-	        if (a > r) {
-	          throw new SyntaxError(`Input length: ${a}, exceeds maximum allowed length: ${r}`);
-	        }
-	        t = c[t] || t;
-	        const {
-	          DOT_LITERAL: i,
-	          SLASH_LITERAL: p,
-	          ONE_CHAR: l,
-	          DOTS_SLASH: f,
-	          NO_DOT: A,
-	          NO_DOTS: _,
-	          NO_DOTS_SLASH: R,
-	          STAR: E,
-	          START_ANCHOR: h
-	        } = n.globChars(u.windows);
-	        const g = u.dot ? _ : A;
-	        const b = u.dot ? R : A;
-	        const C = u.capture ? "" : "?:";
-	        const y = {
-	          negated: false,
-	          prefix: ""
-	        };
-	        let $ = u.bash === true ? ".*?" : E;
-	        if (u.capture) {
-	          $ = `(${$})`;
-	        }
-	        const globstar = t => {
-	          if (t.noglobstar === true) return $;
-	          return `(${C}(?:(?!${h}${t.dot ? f : i}).)*?)`;
-	        };
-	        const create = t => {
-	          switch (t) {
-	            case "*":
-	              return `${g}${l}${$}`;
-	            case ".*":
-	              return `${i}${l}${$}`;
-	            case "*.*":
-	              return `${g}${$}${i}${l}${$}`;
-	            case "*/*":
-	              return `${g}${$}${p}${l}${b}${$}`;
-	            case "**":
-	              return g + globstar(u);
-	            case "**/*":
-	              return `(?:${g}${globstar(u)}${p})?${b}${l}${$}`;
-	            case "**/*.*":
-	              return `(?:${g}${globstar(u)}${p})?${b}${$}${i}${l}${$}`;
-	            case "**/.*":
-	              return `(?:${g}${globstar(u)}${p})?${i}${l}${$}`;
-	            default:
-	              {
-	                const e = /^(.*?)\.(\w+)$/.exec(t);
-	                if (!e) return;
-	                const u = create(e[1]);
-	                if (!u) return;
-	                return u + i + e[2];
-	              }
-	          }
-	        };
-	        const x = o.removePrefix(t, y);
-	        let S = create(x);
-	        if (S && u.strictSlashes !== true) {
-	          S += `${p}?`;
-	        }
-	        return S;
-	      };
-	      t.exports = parse;
-	    },
-	    510: (t, e, u) => {
-	      const n = u(716);
-	      const o = u(697);
-	      const s = u(96);
-	      const r = u(154);
-	      const isObject = t => t && typeof t === "object" && !Array.isArray(t);
-	      const picomatch = (t, e, u = false) => {
-	        if (Array.isArray(t)) {
-	          const n = t.map(t => picomatch(t, e, u));
-	          const arrayMatcher = t => {
-	            for (const e of n) {
-	              const u = e(t);
-	              if (u) return u;
-	            }
-	            return false;
-	          };
-	          return arrayMatcher;
-	        }
-	        const n = isObject(t) && t.tokens && t.input;
-	        if (t === "" || typeof t !== "string" && !n) {
-	          throw new TypeError("Expected pattern to be a non-empty string");
-	        }
-	        const o = e || {};
-	        const s = o.windows;
-	        const r = n ? picomatch.compileRe(t, e) : picomatch.makeRe(t, e, false, true);
-	        const a = r.state;
-	        delete r.state;
-	        let isIgnored = () => false;
-	        if (o.ignore) {
-	          const t = {
-	            ...e,
-	            ignore: null,
-	            onMatch: null,
-	            onResult: null
-	          };
-	          isIgnored = picomatch(o.ignore, t, u);
-	        }
-	        const matcher = (u, n = false) => {
-	          const {
-	            isMatch: i,
-	            match: c,
-	            output: p
-	          } = picomatch.test(u, r, e, {
-	            glob: t,
-	            posix: s
-	          });
-	          const l = {
-	            glob: t,
-	            state: a,
-	            regex: r,
-	            posix: s,
-	            input: u,
-	            output: p,
-	            match: c,
-	            isMatch: i
-	          };
-	          if (typeof o.onResult === "function") {
-	            o.onResult(l);
-	          }
-	          if (i === false) {
-	            l.isMatch = false;
-	            return n ? l : false;
-	          }
-	          if (isIgnored(u)) {
-	            if (typeof o.onIgnore === "function") {
-	              o.onIgnore(l);
-	            }
-	            l.isMatch = false;
-	            return n ? l : false;
-	          }
-	          if (typeof o.onMatch === "function") {
-	            o.onMatch(l);
-	          }
-	          return n ? l : true;
-	        };
-	        if (u) {
-	          matcher.state = a;
-	        }
-	        return matcher;
-	      };
-	      picomatch.test = (t, e, u, {
-	        glob: n,
-	        posix: o
-	      } = {}) => {
-	        if (typeof t !== "string") {
-	          throw new TypeError("Expected input to be a string");
-	        }
-	        if (t === "") {
-	          return {
-	            isMatch: false,
-	            output: ""
-	          };
-	        }
-	        const r = u || {};
-	        const a = r.format || (o ? s.toPosixSlashes : null);
-	        let i = t === n;
-	        let c = i && a ? a(t) : t;
-	        if (i === false) {
-	          c = a ? a(t) : t;
-	          i = c === n;
-	        }
-	        if (i === false || r.capture === true) {
-	          if (r.matchBase === true || r.basename === true) {
-	            i = picomatch.matchBase(t, e, u, o);
-	          } else {
-	            i = e.exec(c);
-	          }
-	        }
-	        return {
-	          isMatch: Boolean(i),
-	          match: i,
-	          output: c
-	        };
-	      };
-	      picomatch.matchBase = (t, e, u) => {
-	        const n = e instanceof RegExp ? e : picomatch.makeRe(e, u);
-	        return n.test(s.basename(t));
-	      };
-	      picomatch.isMatch = (t, e, u) => picomatch(e, u)(t);
-	      picomatch.parse = (t, e) => {
-	        if (Array.isArray(t)) return t.map(t => picomatch.parse(t, e));
-	        return o(t, {
-	          ...e,
-	          fastpaths: false
-	        });
-	      };
-	      picomatch.scan = (t, e) => n(t, e);
-	      picomatch.compileRe = (t, e, u = false, n = false) => {
-	        if (u === 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 = picomatch.toRegex(a, e);
-	        if (n === true) {
-	          i.state = t;
-	        }
-	        return i;
-	      };
-	      picomatch.makeRe = (t, e = {}, u = false, n = false) => {
-	        if (!t || typeof t !== "string") {
-	          throw new TypeError("Expected a non-empty string");
-	        }
-	        let s = {
-	          negated: false,
-	          fastpaths: true
-	        };
-	        if (e.fastpaths !== false && (t[0] === "." || t[0] === "*")) {
-	          s.output = o.fastpaths(t, e);
-	        }
-	        if (!s.output) {
-	          s = o(t, e);
-	        }
-	        return picomatch.compileRe(s, e, u, n);
-	      };
-	      picomatch.toRegex = (t, e) => {
-	        try {
-	          const u = e || {};
-	          return new RegExp(t, u.flags || (u.nocase ? "i" : ""));
-	        } catch (t) {
-	          if (e && e.debug === true) throw t;
-	          return /$^/;
-	        }
-	      };
-	      picomatch.constants = r;
-	      t.exports = picomatch;
-	    },
-	    716: (t, e, u) => {
-	      const n = u(96);
-	      const {
-	        CHAR_ASTERISK: o,
-	        CHAR_AT: s,
-	        CHAR_BACKWARD_SLASH: r,
-	        CHAR_COMMA: a,
-	        CHAR_DOT: i,
-	        CHAR_EXCLAMATION_MARK: c,
-	        CHAR_FORWARD_SLASH: p,
-	        CHAR_LEFT_CURLY_BRACE: l,
-	        CHAR_LEFT_PARENTHESES: f,
-	        CHAR_LEFT_SQUARE_BRACKET: A,
-	        CHAR_PLUS: _,
-	        CHAR_QUESTION_MARK: R,
-	        CHAR_RIGHT_CURLY_BRACE: E,
-	        CHAR_RIGHT_PARENTHESES: h,
-	        CHAR_RIGHT_SQUARE_BRACKET: g
-	      } = u(154);
-	      const isPathSeparator = t => t === p || t === r;
-	      const depth = t => {
-	        if (t.isPrefix !== true) {
-	          t.depth = t.isGlobstar ? Infinity : 1;
-	        }
-	      };
-	      const scan = (t, e) => {
-	        const u = e || {};
-	        const b = t.length - 1;
-	        const C = u.parts === true || u.scanToEnd === true;
-	        const y = [];
-	        const $ = [];
-	        const x = [];
-	        let S = t;
-	        let H = -1;
-	        let v = 0;
-	        let d = 0;
-	        let L = false;
-	        let T = false;
-	        let O = false;
-	        let k = false;
-	        let m = false;
-	        let w = false;
-	        let N = false;
-	        let I = false;
-	        let B = false;
-	        let G = false;
-	        let D = 0;
-	        let M;
-	        let P;
-	        let K = {
-	          value: "",
-	          depth: 0,
-	          isGlob: false
-	        };
-	        const eos = () => H >= b;
-	        const peek = () => S.charCodeAt(H + 1);
-	        const advance = () => {
-	          M = P;
-	          return S.charCodeAt(++H);
-	        };
-	        while (H < b) {
-	          P = advance();
-	          let t;
-	          if (P === r) {
-	            N = K.backslashes = true;
-	            P = advance();
-	            if (P === l) {
-	              w = true;
-	            }
-	            continue;
-	          }
-	          if (w === true || P === l) {
-	            D++;
-	            while (eos() !== true && (P = advance())) {
-	              if (P === r) {
-	                N = K.backslashes = true;
-	                advance();
-	                continue;
-	              }
-	              if (P === l) {
-	                D++;
-	                continue;
-	              }
-	              if (w !== true && P === i && (P = advance()) === i) {
-	                L = K.isBrace = true;
-	                O = K.isGlob = true;
-	                G = true;
-	                if (C === true) {
-	                  continue;
-	                }
-	                break;
-	              }
-	              if (w !== true && P === a) {
-	                L = K.isBrace = true;
-	                O = K.isGlob = true;
-	                G = true;
-	                if (C === true) {
-	                  continue;
-	                }
-	                break;
-	              }
-	              if (P === E) {
-	                D--;
-	                if (D === 0) {
-	                  w = false;
-	                  L = K.isBrace = true;
-	                  G = true;
-	                  break;
-	                }
-	              }
-	            }
-	            if (C === true) {
-	              continue;
-	            }
-	            break;
-	          }
-	          if (P === p) {
-	            y.push(H);
-	            $.push(K);
-	            K = {
-	              value: "",
-	              depth: 0,
-	              isGlob: false
-	            };
-	            if (G === true) continue;
-	            if (M === i && H === v + 1) {
-	              v += 2;
-	              continue;
-	            }
-	            d = H + 1;
-	            continue;
-	          }
-	          if (u.noext !== true) {
-	            const t = P === _ || P === s || P === o || P === R || P === c;
-	            if (t === true && peek() === f) {
-	              O = K.isGlob = true;
-	              k = K.isExtglob = true;
-	              G = true;
-	              if (P === c && H === v) {
-	                B = true;
-	              }
-	              if (C === true) {
-	                while (eos() !== true && (P = advance())) {
-	                  if (P === r) {
-	                    N = K.backslashes = true;
-	                    P = advance();
-	                    continue;
-	                  }
-	                  if (P === h) {
-	                    O = K.isGlob = true;
-	                    G = true;
-	                    break;
-	                  }
-	                }
-	                continue;
-	              }
-	              break;
-	            }
-	          }
-	          if (P === o) {
-	            if (M === o) m = K.isGlobstar = true;
-	            O = K.isGlob = true;
-	            G = true;
-	            if (C === true) {
-	              continue;
-	            }
-	            break;
-	          }
-	          if (P === R) {
-	            O = K.isGlob = true;
-	            G = true;
-	            if (C === true) {
-	              continue;
-	            }
-	            break;
-	          }
-	          if (P === A) {
-	            while (eos() !== true && (t = advance())) {
-	              if (t === r) {
-	                N = K.backslashes = true;
-	                advance();
-	                continue;
-	              }
-	              if (t === g) {
-	                T = K.isBracket = true;
-	                O = K.isGlob = true;
-	                G = true;
-	                break;
-	              }
-	            }
-	            if (C === true) {
-	              continue;
-	            }
-	            break;
-	          }
-	          if (u.nonegate !== true && P === c && H === v) {
-	            I = K.negated = true;
-	            v++;
-	            continue;
-	          }
-	          if (u.noparen !== true && P === f) {
-	            O = K.isGlob = true;
-	            if (C === true) {
-	              while (eos() !== true && (P = advance())) {
-	                if (P === f) {
-	                  N = K.backslashes = true;
-	                  P = advance();
-	                  continue;
-	                }
-	                if (P === h) {
-	                  G = true;
-	                  break;
-	                }
-	              }
-	              continue;
-	            }
-	            break;
-	          }
-	          if (O === true) {
-	            G = true;
-	            if (C === true) {
-	              continue;
-	            }
-	            break;
-	          }
-	        }
-	        if (u.noext === true) {
-	          k = false;
-	          O = false;
-	        }
-	        let U = S;
-	        let X = "";
-	        let F = "";
-	        if (v > 0) {
-	          X = S.slice(0, v);
-	          S = S.slice(v);
-	          d -= v;
-	        }
-	        if (U && O === true && d > 0) {
-	          U = S.slice(0, d);
-	          F = S.slice(d);
-	        } else if (O === true) {
-	          U = "";
-	          F = S;
-	        } else {
-	          U = S;
-	        }
-	        if (U && U !== "" && U !== "/" && U !== S) {
-	          if (isPathSeparator(U.charCodeAt(U.length - 1))) {
-	            U = U.slice(0, -1);
-	          }
-	        }
-	        if (u.unescape === true) {
-	          if (F) F = n.removeBackslashes(F);
-	          if (U && N === true) {
-	            U = n.removeBackslashes(U);
-	          }
-	        }
-	        const Q = {
-	          prefix: X,
-	          input: t,
-	          start: v,
-	          base: U,
-	          glob: F,
-	          isBrace: L,
-	          isBracket: T,
-	          isGlob: O,
-	          isExtglob: k,
-	          isGlobstar: m,
-	          negated: I,
-	          negatedExtglob: B
-	        };
-	        if (u.tokens === true) {
-	          Q.maxDepth = 0;
-	          if (!isPathSeparator(P)) {
-	            $.push(K);
-	          }
-	          Q.tokens = $;
-	        }
-	        if (u.parts === true || u.tokens === true) {
-	          let e;
-	          for (let n = 0; n < y.length; n++) {
-	            const o = e ? e + 1 : v;
-	            const s = y[n];
-	            const r = t.slice(o, s);
-	            if (u.tokens) {
-	              if (n === 0 && v !== 0) {
-	                $[n].isPrefix = true;
-	                $[n].value = X;
-	              } else {
-	                $[n].value = r;
-	              }
-	              depth($[n]);
-	              Q.maxDepth += $[n].depth;
-	            }
-	            if (n !== 0 || r !== "") {
-	              x.push(r);
-	            }
-	            e = s;
-	          }
-	          if (e && e + 1 < t.length) {
-	            const n = t.slice(e + 1);
-	            x.push(n);
-	            if (u.tokens) {
-	              $[$.length - 1].value = n;
-	              depth($[$.length - 1]);
-	              Q.maxDepth += $[$.length - 1].depth;
-	            }
-	          }
-	          Q.slashes = y;
-	          Q.parts = x;
-	        }
-	        return Q;
-	      };
-	      t.exports = scan;
-	    },
-	    96: (t, e, u) => {
-	      const {
-	        REGEX_BACKSLASH: n,
-	        REGEX_REMOVE_BACKSLASH: o,
-	        REGEX_SPECIAL_CHARS: s,
-	        REGEX_SPECIAL_CHARS_GLOBAL: r
-	      } = u(154);
-	      e.isObject = t => t !== null && typeof t === "object" && !Array.isArray(t);
-	      e.hasRegexChars = t => s.test(t);
-	      e.isRegexChar = t => t.length === 1 && e.hasRegexChars(t);
-	      e.escapeRegex = t => t.replace(r, "\\$1");
-	      e.toPosixSlashes = t => t.replace(n, "/");
-	      e.removeBackslashes = t => t.replace(o, t => t === "\\" ? "" : t);
-	      e.escapeLast = (t, u, n) => {
-	        const o = t.lastIndexOf(u, n);
-	        if (o === -1) return t;
-	        if (t[o - 1] === "\\") return e.escapeLast(t, u, o - 1);
-	        return `${t.slice(0, o)}\\${t.slice(o)}`;
-	      };
-	      e.removePrefix = (t, e = {}) => {
-	        let u = t;
-	        if (u.startsWith("./")) {
-	          u = u.slice(2);
-	          e.prefix = "./";
-	        }
-	        return u;
-	      };
-	      e.wrapOutput = (t, e = {}, u = {}) => {
-	        const n = u.contains ? "" : "^";
-	        const o = u.contains ? "" : "$";
-	        let s = `${n}(?:${t})${o}`;
-	        if (e.negated === true) {
-	          s = `(?:^(?!${s}).*$)`;
-	        }
-	        return s;
-	      };
-	      e.basename = (t, {
-	        windows: e
-	      } = {}) => {
-	        const u = t.split(e ? /[\\/]/ : "/");
-	        const n = u[u.length - 1];
-	        if (n === "") {
-	          return u[u.length - 2];
-	        }
-	        return n;
-	      };
-	    }
-	  };
-	  var e = {};
-	  function __nccwpck_require__(u) {
-	    var n = e[u];
-	    if (n !== undefined) {
-	      return n.exports;
-	    }
-	    var o = e[u] = {
-	      exports: {}
-	    };
-	    var s = true;
-	    try {
-	      t[u](o, o.exports, __nccwpck_require__);
-	      s = false;
-	    } finally {
-	      if (s) delete e[u];
-	    }
-	    return o.exports;
-	  }
-	  if (typeof __nccwpck_require__ !== "undefined") __nccwpck_require__.ab = __dirname + "/";
-	  var u = __nccwpck_require__(170);
-	  picomatch.exports = u;
-	})();
-	return picomatch.exports;
-}
-
-export { requirePicomatch as __require };