@genai-fi/nanogpt 0.20.0 → 0.20.1

package/dist/picomatch-3tUnMMbd.js

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