@qwik.dev/devtools 0.2.4 → 0.2.6

package/dist/ui/node_modules/.pnpm/minimatch@10.2.4/node_modules/minimatch/dist/esm/ast.qwik.mjs

@@ -0,0 +1,537 @@
+import { _classPrivateMethodInitSpec } from "../../../../../../../_virtual/_@oxc-project_runtime@0.115.0/helpers/classPrivateMethodInitSpec.qwik.mjs";
+import { _defineProperty } from "../../../../../../../_virtual/_@oxc-project_runtime@0.115.0/helpers/defineProperty.qwik.mjs";
+import { _classPrivateFieldInitSpec } from "../../../../../../../_virtual/_@oxc-project_runtime@0.115.0/helpers/classPrivateFieldInitSpec.qwik.mjs";
+import { _assertClassBrand } from "../../../../../../../_virtual/_@oxc-project_runtime@0.115.0/helpers/assertClassBrand.qwik.mjs";
+import { _classPrivateFieldGet2 } from "../../../../../../../_virtual/_@oxc-project_runtime@0.115.0/helpers/classPrivateFieldGet2.qwik.mjs";
+import { _classPrivateFieldSet2 } from "../../../../../../../_virtual/_@oxc-project_runtime@0.115.0/helpers/classPrivateFieldSet2.qwik.mjs";
+import { parseClass } from "./brace-expressions.qwik.mjs";
+import { unescape } from "./unescape.qwik.mjs";
+//#region ../../node_modules/.pnpm/minimatch@10.2.4/node_modules/minimatch/dist/esm/ast.js
+var _AST;
+var _Symbol$for;
+var _a;
+var types = new Set([
+	"!",
+	"?",
+	"+",
+	"*",
+	"@"
+]);
+var isExtglobType = (c) => types.has(c);
+var isExtglobAST = (c) => isExtglobType(c.type);
+var adoptionMap = new Map([
+	["!", ["@"]],
+	["?", ["?", "@"]],
+	["@", ["@"]],
+	["*", [
+		"*",
+		"+",
+		"?",
+		"@"
+	]],
+	["+", ["+", "@"]]
+]);
+var adoptionWithSpaceMap = new Map([
+	["!", ["?"]],
+	["@", ["?"]],
+	["+", ["?", "*"]]
+]);
+var adoptionAnyMap = new Map([
+	["!", ["?", "@"]],
+	["?", ["?", "@"]],
+	["@", ["?", "@"]],
+	["*", [
+		"*",
+		"+",
+		"?",
+		"@"
+	]],
+	["+", [
+		"+",
+		"@",
+		"?",
+		"*"
+	]]
+]);
+var usurpMap = new Map([
+	["!", new Map([["!", "@"]])],
+	["?", new Map([["*", "*"], ["+", "*"]])],
+	["@", new Map([
+		["!", "!"],
+		["?", "?"],
+		["@", "@"],
+		["*", "*"],
+		["+", "+"]
+	])],
+	["+", new Map([["?", "*"], ["*", "*"]])]
+]);
+var startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
+var startNoDot = "(?!\\.)";
+var addPatternStart = new Set(["[", "."]);
+var justDots = new Set(["..", "."]);
+var reSpecials = /* @__PURE__ */ new Set("().*{}+?[]^$\\!");
+var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var qmark = "[^/]";
+var star = qmark + "*?";
+var starNoEmpty = qmark + "+?";
+var ID = 0;
+var _root = /* @__PURE__ */ new WeakMap();
+var _hasMagic2 = /* @__PURE__ */ new WeakMap();
+var _uflag = /* @__PURE__ */ new WeakMap();
+var _parts = /* @__PURE__ */ new WeakMap();
+var _parent = /* @__PURE__ */ new WeakMap();
+var _parentIndex = /* @__PURE__ */ new WeakMap();
+var _negs = /* @__PURE__ */ new WeakMap();
+var _filledNegs = /* @__PURE__ */ new WeakMap();
+var _options = /* @__PURE__ */ new WeakMap();
+var _toString = /* @__PURE__ */ new WeakMap();
+var _emptyExt = /* @__PURE__ */ new WeakMap();
+var _AST_brand = /* @__PURE__ */ new WeakSet();
+_Symbol$for = Symbol.for("nodejs.util.inspect.custom");
+var AST = class AST {
+	get depth() {
+		return (_classPrivateFieldGet2(_parent, this)?.depth ?? -1) + 1;
+	}
+	[_Symbol$for]() {
+		return {
+			"@@type": "AST",
+			id: this.id,
+			type: this.type,
+			root: _classPrivateFieldGet2(_root, this).id,
+			parent: _classPrivateFieldGet2(_parent, this)?.id,
+			depth: this.depth,
+			partsLength: _classPrivateFieldGet2(_parts, this).length,
+			parts: _classPrivateFieldGet2(_parts, this)
+		};
+	}
+	constructor(type, parent, options = {}) {
+		_classPrivateMethodInitSpec(this, _AST_brand);
+		_defineProperty(this, "type", void 0);
+		_classPrivateFieldInitSpec(this, _root, void 0);
+		_classPrivateFieldInitSpec(this, _hasMagic2, void 0);
+		_classPrivateFieldInitSpec(this, _uflag, false);
+		_classPrivateFieldInitSpec(this, _parts, []);
+		_classPrivateFieldInitSpec(this, _parent, void 0);
+		_classPrivateFieldInitSpec(this, _parentIndex, void 0);
+		_classPrivateFieldInitSpec(this, _negs, void 0);
+		_classPrivateFieldInitSpec(this, _filledNegs, false);
+		_classPrivateFieldInitSpec(this, _options, void 0);
+		_classPrivateFieldInitSpec(this, _toString, void 0);
+		_classPrivateFieldInitSpec(this, _emptyExt, false);
+		_defineProperty(this, "id", ++ID);
+		this.type = type;
+		if (type) _classPrivateFieldSet2(_hasMagic2, this, true);
+		_classPrivateFieldSet2(_parent, this, parent);
+		_classPrivateFieldSet2(_root, this, _classPrivateFieldGet2(_parent, this) ? _classPrivateFieldGet2(_root, _classPrivateFieldGet2(_parent, this)) : this);
+		_classPrivateFieldSet2(_options, this, _classPrivateFieldGet2(_root, this) === this ? options : _classPrivateFieldGet2(_options, _classPrivateFieldGet2(_root, this)));
+		_classPrivateFieldSet2(_negs, this, _classPrivateFieldGet2(_root, this) === this ? [] : _classPrivateFieldGet2(_negs, _classPrivateFieldGet2(_root, this)));
+		if (type === "!" && !_classPrivateFieldGet2(_filledNegs, _classPrivateFieldGet2(_root, this))) _classPrivateFieldGet2(_negs, this).push(this);
+		_classPrivateFieldSet2(_parentIndex, this, _classPrivateFieldGet2(_parent, this) ? _classPrivateFieldGet2(_parts, _classPrivateFieldGet2(_parent, this)).length : 0);
+	}
+	get hasMagic() {
+		/* c8 ignore start */
+		if (_classPrivateFieldGet2(_hasMagic2, this) !== void 0) return _classPrivateFieldGet2(_hasMagic2, this);
+		/* c8 ignore stop */
+		for (const p of _classPrivateFieldGet2(_parts, this)) {
+			if (typeof p === "string") continue;
+			if (p.type || p.hasMagic) return _classPrivateFieldSet2(_hasMagic2, this, true);
+		}
+		return _classPrivateFieldGet2(_hasMagic2, this);
+	}
+	toString() {
+		if (_classPrivateFieldGet2(_toString, this) !== void 0) return _classPrivateFieldGet2(_toString, this);
+		if (!this.type) return _classPrivateFieldSet2(_toString, this, _classPrivateFieldGet2(_parts, this).map((p) => String(p)).join(""));
+		else return _classPrivateFieldSet2(_toString, this, this.type + "(" + _classPrivateFieldGet2(_parts, this).map((p) => String(p)).join("|") + ")");
+	}
+	push(...parts) {
+		for (const p of parts) {
+			if (p === "") continue;
+			/* c8 ignore start */
+			if (typeof p !== "string" && !(p instanceof _a && _classPrivateFieldGet2(_parent, p) === this)) throw new Error("invalid part: " + p);
+			/* c8 ignore stop */
+			_classPrivateFieldGet2(_parts, this).push(p);
+		}
+	}
+	toJSON() {
+		const ret = this.type === null ? _classPrivateFieldGet2(_parts, this).slice().map((p) => typeof p === "string" ? p : p.toJSON()) : [this.type, ..._classPrivateFieldGet2(_parts, this).map((p) => p.toJSON())];
+		if (this.isStart() && !this.type) ret.unshift([]);
+		if (this.isEnd() && (this === _classPrivateFieldGet2(_root, this) || _classPrivateFieldGet2(_filledNegs, _classPrivateFieldGet2(_root, this)) && _classPrivateFieldGet2(_parent, this)?.type === "!")) ret.push({});
+		return ret;
+	}
+	isStart() {
+		if (_classPrivateFieldGet2(_root, this) === this) return true;
+		if (!_classPrivateFieldGet2(_parent, this)?.isStart()) return false;
+		if (_classPrivateFieldGet2(_parentIndex, this) === 0) return true;
+		const p = _classPrivateFieldGet2(_parent, this);
+		for (let i = 0; i < _classPrivateFieldGet2(_parentIndex, this); i++) {
+			const pp = _classPrivateFieldGet2(_parts, p)[i];
+			if (!(pp instanceof _a && pp.type === "!")) return false;
+		}
+		return true;
+	}
+	isEnd() {
+		if (_classPrivateFieldGet2(_root, this) === this) return true;
+		if (_classPrivateFieldGet2(_parent, this)?.type === "!") return true;
+		if (!_classPrivateFieldGet2(_parent, this)?.isEnd()) return false;
+		if (!this.type) return _classPrivateFieldGet2(_parent, this)?.isEnd();
+		/* c8 ignore start */
+		const pl = _classPrivateFieldGet2(_parent, this) ? _classPrivateFieldGet2(_parts, _classPrivateFieldGet2(_parent, this)).length : 0;
+		/* c8 ignore stop */
+		return _classPrivateFieldGet2(_parentIndex, this) === pl - 1;
+	}
+	copyIn(part) {
+		if (typeof part === "string") this.push(part);
+		else this.push(part.clone(this));
+	}
+	clone(parent) {
+		const c = new _a(this.type, parent);
+		for (const p of _classPrivateFieldGet2(_parts, this)) c.copyIn(p);
+		return c;
+	}
+	static fromGlob(pattern, options = {}) {
+		const ast = new _a(null, void 0, options);
+		_assertClassBrand(AST, _a, _parseAST).call(_a, pattern, ast, 0, options, 0);
+		return ast;
+	}
+	toMMPattern() {
+		/* c8 ignore start */
+		if (this !== _classPrivateFieldGet2(_root, this)) return _classPrivateFieldGet2(_root, this).toMMPattern();
+		/* c8 ignore stop */
+		const glob = this.toString();
+		const [re, body, hasMagic, uflag] = this.toRegExpSource();
+		if (!(hasMagic || _classPrivateFieldGet2(_hasMagic2, this) || _classPrivateFieldGet2(_options, this).nocase && !_classPrivateFieldGet2(_options, this).nocaseMagicOnly && glob.toUpperCase() !== glob.toLowerCase())) return body;
+		const flags = (_classPrivateFieldGet2(_options, this).nocase ? "i" : "") + (uflag ? "u" : "");
+		return Object.assign(new RegExp(`^${re}$`, flags), {
+			_src: re,
+			_glob: glob
+		});
+	}
+	get options() {
+		return _classPrivateFieldGet2(_options, this);
+	}
+	toRegExpSource(allowDot) {
+		const dot = allowDot ?? !!_classPrivateFieldGet2(_options, this).dot;
+		if (_classPrivateFieldGet2(_root, this) === this) {
+			_assertClassBrand(_AST_brand, this, _flatten).call(this);
+			_assertClassBrand(_AST_brand, this, _fillNegs).call(this);
+		}
+		if (!isExtglobAST(this)) {
+			const noEmpty = this.isStart() && this.isEnd() && !_classPrivateFieldGet2(_parts, this).some((s) => typeof s !== "string");
+			const src = _classPrivateFieldGet2(_parts, this).map((p) => {
+				const [re, _, hasMagic, uflag] = typeof p === "string" ? _assertClassBrand(AST, _a, _parseGlob).call(_a, p, _classPrivateFieldGet2(_hasMagic2, this), noEmpty) : p.toRegExpSource(allowDot);
+				_classPrivateFieldSet2(_hasMagic2, this, _classPrivateFieldGet2(_hasMagic2, this) || hasMagic);
+				_classPrivateFieldSet2(_uflag, this, _classPrivateFieldGet2(_uflag, this) || uflag);
+				return re;
+			}).join("");
+			let start = "";
+			if (this.isStart()) {
+				if (typeof _classPrivateFieldGet2(_parts, this)[0] === "string") {
+					if (!(_classPrivateFieldGet2(_parts, this).length === 1 && justDots.has(_classPrivateFieldGet2(_parts, this)[0]))) {
+						const aps = addPatternStart;
+						const needNoTrav = dot && aps.has(src.charAt(0)) || src.startsWith("\\.") && aps.has(src.charAt(2)) || src.startsWith("\\.\\.") && aps.has(src.charAt(4));
+						const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
+						start = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : "";
+					}
+				}
+			}
+			let end = "";
+			if (this.isEnd() && _classPrivateFieldGet2(_filledNegs, _classPrivateFieldGet2(_root, this)) && _classPrivateFieldGet2(_parent, this)?.type === "!") end = "(?:$|\\/)";
+			return [
+				start + src + end,
+				unescape(src),
+				_classPrivateFieldSet2(_hasMagic2, this, !!_classPrivateFieldGet2(_hasMagic2, this)),
+				_classPrivateFieldGet2(_uflag, this)
+			];
+		}
+		const repeated = this.type === "*" || this.type === "+";
+		const start = this.type === "!" ? "(?:(?!(?:" : "(?:";
+		let body = _assertClassBrand(_AST_brand, this, _partsToRegExp).call(this, dot);
+		if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
+			const s = this.toString();
+			const me = this;
+			_classPrivateFieldSet2(_parts, me, [s]);
+			me.type = null;
+			_classPrivateFieldSet2(_hasMagic2, me, void 0);
+			return [
+				s,
+				unescape(this.toString()),
+				false,
+				false
+			];
+		}
+		let bodyDotAllowed = !repeated || allowDot || dot || false ? "" : _assertClassBrand(_AST_brand, this, _partsToRegExp).call(this, true);
+		if (bodyDotAllowed === body) bodyDotAllowed = "";
+		if (bodyDotAllowed) body = `(?:${body})(?:${bodyDotAllowed})*?`;
+		let final = "";
+		if (this.type === "!" && _classPrivateFieldGet2(_emptyExt, this)) final = (this.isStart() && !dot ? startNoDot : "") + starNoEmpty;
+		else {
+			const close = this.type === "!" ? "))" + (this.isStart() && !dot && !allowDot ? startNoDot : "") + star + ")" : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
+			final = start + body + close;
+		}
+		return [
+			final,
+			unescape(body),
+			_classPrivateFieldSet2(_hasMagic2, this, !!_classPrivateFieldGet2(_hasMagic2, this)),
+			_classPrivateFieldGet2(_uflag, this)
+		];
+	}
+};
+_AST = AST;
+function _fillNegs() {
+	/* c8 ignore start */
+	if (this !== _classPrivateFieldGet2(_root, this)) throw new Error("should only call on root");
+	if (_classPrivateFieldGet2(_filledNegs, this)) return this;
+	/* c8 ignore stop */
+	this.toString();
+	_classPrivateFieldSet2(_filledNegs, this, true);
+	let n;
+	while (n = _classPrivateFieldGet2(_negs, this).pop()) {
+		if (n.type !== "!") continue;
+		let p = n;
+		let pp = _classPrivateFieldGet2(_parent, p);
+		while (pp) {
+			for (let i = _classPrivateFieldGet2(_parentIndex, p) + 1; !pp.type && i < _classPrivateFieldGet2(_parts, pp).length; i++) for (const part of _classPrivateFieldGet2(_parts, n)) {
+				/* c8 ignore start */
+				if (typeof part === "string") throw new Error("string part in extglob AST??");
+				/* c8 ignore stop */
+				part.copyIn(_classPrivateFieldGet2(_parts, pp)[i]);
+			}
+			p = pp;
+			pp = _classPrivateFieldGet2(_parent, p);
+		}
+	}
+	return this;
+}
+function _parseAST(str, ast, pos, opt, extDepth) {
+	const maxDepth = opt.maxExtglobRecursion ?? 2;
+	let escaping = false;
+	let inBrace = false;
+	let braceStart = -1;
+	let braceNeg = false;
+	if (ast.type === null) {
+		let i = pos;
+		let acc = "";
+		while (i < str.length) {
+			const c = str.charAt(i++);
+			if (escaping || c === "\\") {
+				escaping = !escaping;
+				acc += c;
+				continue;
+			}
+			if (inBrace) {
+				if (i === braceStart + 1) {
+					if (c === "^" || c === "!") braceNeg = true;
+				} else if (c === "]" && !(i === braceStart + 2 && braceNeg)) inBrace = false;
+				acc += c;
+				continue;
+			} else if (c === "[") {
+				inBrace = true;
+				braceStart = i;
+				braceNeg = false;
+				acc += c;
+				continue;
+			}
+			if (!opt.noext && isExtglobType(c) && str.charAt(i) === "(" && extDepth <= maxDepth) {
+				ast.push(acc);
+				acc = "";
+				const ext = new _a(c, ast);
+				i = _assertClassBrand(_AST, _a, _parseAST).call(_a, str, ext, i, opt, extDepth + 1);
+				ast.push(ext);
+				continue;
+			}
+			acc += c;
+		}
+		ast.push(acc);
+		return i;
+	}
+	let i = pos + 1;
+	let part = new _a(null, ast);
+	const parts = [];
+	let acc = "";
+	while (i < str.length) {
+		const c = str.charAt(i++);
+		if (escaping || c === "\\") {
+			escaping = !escaping;
+			acc += c;
+			continue;
+		}
+		if (inBrace) {
+			if (i === braceStart + 1) {
+				if (c === "^" || c === "!") braceNeg = true;
+			} else if (c === "]" && !(i === braceStart + 2 && braceNeg)) inBrace = false;
+			acc += c;
+			continue;
+		} else if (c === "[") {
+			inBrace = true;
+			braceStart = i;
+			braceNeg = false;
+			acc += c;
+			continue;
+		}
+		/* c8 ignore stop */
+		if (!opt.noext && isExtglobType(c) && str.charAt(i) === "(" && (extDepth <= maxDepth || ast && _assertClassBrand(_AST_brand, ast, _canAdoptType).call(ast, c))) {
+			const depthAdd = ast && _assertClassBrand(_AST_brand, ast, _canAdoptType).call(ast, c) ? 0 : 1;
+			part.push(acc);
+			acc = "";
+			const ext = new _a(c, part);
+			part.push(ext);
+			i = _assertClassBrand(_AST, _a, _parseAST).call(_a, str, ext, i, opt, extDepth + depthAdd);
+			continue;
+		}
+		if (c === "|") {
+			part.push(acc);
+			acc = "";
+			parts.push(part);
+			part = new _a(null, ast);
+			continue;
+		}
+		if (c === ")") {
+			if (acc === "" && _classPrivateFieldGet2(_parts, ast).length === 0) _classPrivateFieldSet2(_emptyExt, ast, true);
+			part.push(acc);
+			acc = "";
+			ast.push(...parts, part);
+			return i;
+		}
+		acc += c;
+	}
+	ast.type = null;
+	_classPrivateFieldSet2(_hasMagic2, ast, void 0);
+	_classPrivateFieldSet2(_parts, ast, [str.substring(pos - 1)]);
+	return i;
+}
+function _canAdoptWithSpace(child) {
+	return _assertClassBrand(_AST_brand, this, _canAdopt).call(this, child, adoptionWithSpaceMap);
+}
+function _canAdopt(child, map = adoptionMap) {
+	if (!child || typeof child !== "object" || child.type !== null || _classPrivateFieldGet2(_parts, child).length !== 1 || this.type === null) return false;
+	const gc = _classPrivateFieldGet2(_parts, child)[0];
+	if (!gc || typeof gc !== "object" || gc.type === null) return false;
+	return _assertClassBrand(_AST_brand, this, _canAdoptType).call(this, gc.type, map);
+}
+function _canAdoptType(c, map = adoptionAnyMap) {
+	return !!map.get(this.type)?.includes(c);
+}
+function _adoptWithSpace(child, index) {
+	const gc = _classPrivateFieldGet2(_parts, child)[0];
+	const blank = new _a(null, gc, this.options);
+	_classPrivateFieldGet2(_parts, blank).push("");
+	gc.push(blank);
+	_assertClassBrand(_AST_brand, this, _adopt).call(this, child, index);
+}
+function _adopt(child, index) {
+	const gc = _classPrivateFieldGet2(_parts, child)[0];
+	_classPrivateFieldGet2(_parts, this).splice(index, 1, ..._classPrivateFieldGet2(_parts, gc));
+	for (const p of _classPrivateFieldGet2(_parts, gc)) if (typeof p === "object") _classPrivateFieldSet2(_parent, p, this);
+	_classPrivateFieldSet2(_toString, this, void 0);
+}
+function _canUsurpType(c) {
+	return !!usurpMap.get(this.type)?.has(c);
+}
+function _canUsurp(child) {
+	if (!child || typeof child !== "object" || child.type !== null || _classPrivateFieldGet2(_parts, child).length !== 1 || this.type === null || _classPrivateFieldGet2(_parts, this).length !== 1) return false;
+	const gc = _classPrivateFieldGet2(_parts, child)[0];
+	if (!gc || typeof gc !== "object" || gc.type === null) return false;
+	return _assertClassBrand(_AST_brand, this, _canUsurpType).call(this, gc.type);
+}
+function _usurp(child) {
+	const m = usurpMap.get(this.type);
+	const gc = _classPrivateFieldGet2(_parts, child)[0];
+	const nt = m?.get(gc.type);
+	/* c8 ignore start - impossible */
+	if (!nt) return false;
+	/* c8 ignore stop */
+	_classPrivateFieldSet2(_parts, this, _classPrivateFieldGet2(_parts, gc));
+	for (const p of _classPrivateFieldGet2(_parts, this)) if (typeof p === "object") _classPrivateFieldSet2(_parent, p, this);
+	this.type = nt;
+	_classPrivateFieldSet2(_toString, this, void 0);
+	_classPrivateFieldSet2(_emptyExt, this, false);
+}
+function _flatten() {
+	if (!isExtglobAST(this)) {
+		for (const p of _classPrivateFieldGet2(_parts, this)) if (typeof p === "object") _assertClassBrand(_AST_brand, p, _flatten).call(p);
+	} else {
+		let iterations = 0;
+		let done = false;
+		do {
+			done = true;
+			for (let i = 0; i < _classPrivateFieldGet2(_parts, this).length; i++) {
+				const c = _classPrivateFieldGet2(_parts, this)[i];
+				if (typeof c === "object") {
+					_assertClassBrand(_AST_brand, c, _flatten).call(c);
+					if (_assertClassBrand(_AST_brand, this, _canAdopt).call(this, c)) {
+						done = false;
+						_assertClassBrand(_AST_brand, this, _adopt).call(this, c, i);
+					} else if (_assertClassBrand(_AST_brand, this, _canAdoptWithSpace).call(this, c)) {
+						done = false;
+						_assertClassBrand(_AST_brand, this, _adoptWithSpace).call(this, c, i);
+					} else if (_assertClassBrand(_AST_brand, this, _canUsurp).call(this, c)) {
+						done = false;
+						_assertClassBrand(_AST_brand, this, _usurp).call(this, c);
+					}
+				}
+			}
+		} while (!done && ++iterations < 10);
+	}
+	_classPrivateFieldSet2(_toString, this, void 0);
+}
+function _partsToRegExp(dot) {
+	return _classPrivateFieldGet2(_parts, this).map((p) => {
+		/* c8 ignore start */
+		if (typeof p === "string") throw new Error("string type in extglob ast??");
+		/* c8 ignore stop */
+		const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);
+		_classPrivateFieldSet2(_uflag, this, _classPrivateFieldGet2(_uflag, this) || uflag);
+		return re;
+	}).filter((p) => !(this.isStart() && this.isEnd()) || !!p).join("|");
+}
+function _parseGlob(glob, hasMagic, noEmpty = false) {
+	let escaping = false;
+	let re = "";
+	let uflag = false;
+	let inStar = false;
+	for (let i = 0; i < glob.length; i++) {
+		const c = glob.charAt(i);
+		if (escaping) {
+			escaping = false;
+			re += (reSpecials.has(c) ? "\\" : "") + c;
+			continue;
+		}
+		if (c === "*") {
+			if (inStar) continue;
+			inStar = true;
+			re += noEmpty && /^[*]+$/.test(glob) ? starNoEmpty : star;
+			hasMagic = true;
+			continue;
+		} else inStar = false;
+		if (c === "\\") {
+			if (i === glob.length - 1) re += "\\\\";
+			else escaping = true;
+			continue;
+		}
+		if (c === "[") {
+			const [src, needUflag, consumed, magic] = parseClass(glob, i);
+			if (consumed) {
+				re += src;
+				uflag = uflag || needUflag;
+				i += consumed - 1;
+				hasMagic = hasMagic || magic;
+				continue;
+			}
+		}
+		if (c === "?") {
+			re += qmark;
+			hasMagic = true;
+			continue;
+		}
+		re += regExpEscape(c);
+	}
+	return [
+		re,
+		unescape(glob),
+		!!hasMagic,
+		uflag
+	];
+}
+_a = AST;
+//#endregion
+export { AST };

package/dist/ui/node_modules/.pnpm/minimatch@10.2.4/node_modules/minimatch/dist/esm/brace-expressions.qwik.mjs

@@ -0,0 +1,122 @@
+//#region ../../node_modules/.pnpm/minimatch@10.2.4/node_modules/minimatch/dist/esm/brace-expressions.js
+var posixClasses = {
+	"[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
+	"[:alpha:]": ["\\p{L}\\p{Nl}", true],
+	"[:ascii:]": ["\\x00-\\x7f", false],
+	"[:blank:]": ["\\p{Zs}\\t", true],
+	"[:cntrl:]": ["\\p{Cc}", true],
+	"[:digit:]": ["\\p{Nd}", true],
+	"[:graph:]": [
+		"\\p{Z}\\p{C}",
+		true,
+		true
+	],
+	"[:lower:]": ["\\p{Ll}", true],
+	"[:print:]": ["\\p{C}", true],
+	"[:punct:]": ["\\p{P}", true],
+	"[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
+	"[:upper:]": ["\\p{Lu}", true],
+	"[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
+	"[:xdigit:]": ["A-Fa-f0-9", false]
+};
+var braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&");
+var regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var rangesToString = (ranges) => ranges.join("");
+var parseClass = (glob, position) => {
+	const pos = position;
+	/* c8 ignore start */
+	if (glob.charAt(pos) !== "[") throw new Error("not in a brace expression");
+	/* c8 ignore stop */
+	const ranges = [];
+	const negs = [];
+	let i = pos + 1;
+	let sawStart = false;
+	let uflag = false;
+	let escaping = false;
+	let negate = false;
+	let endPos = pos;
+	let rangeStart = "";
+	WHILE: while (i < glob.length) {
+		const c = glob.charAt(i);
+		if ((c === "!" || c === "^") && i === pos + 1) {
+			negate = true;
+			i++;
+			continue;
+		}
+		if (c === "]" && sawStart && !escaping) {
+			endPos = i + 1;
+			break;
+		}
+		sawStart = true;
+		if (c === "\\") {
+			if (!escaping) {
+				escaping = true;
+				i++;
+				continue;
+			}
+		}
+		if (c === "[" && !escaping) {
+			for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) if (glob.startsWith(cls, i)) {
+				if (rangeStart) return [
+					"$.",
+					false,
+					glob.length - pos,
+					true
+				];
+				i += cls.length;
+				if (neg) negs.push(unip);
+				else ranges.push(unip);
+				uflag = uflag || u;
+				continue WHILE;
+			}
+		}
+		escaping = false;
+		if (rangeStart) {
+			if (c > rangeStart) ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c));
+			else if (c === rangeStart) ranges.push(braceEscape(c));
+			rangeStart = "";
+			i++;
+			continue;
+		}
+		if (glob.startsWith("-]", i + 1)) {
+			ranges.push(braceEscape(c + "-"));
+			i += 2;
+			continue;
+		}
+		if (glob.startsWith("-", i + 1)) {
+			rangeStart = c;
+			i += 2;
+			continue;
+		}
+		ranges.push(braceEscape(c));
+		i++;
+	}
+	if (endPos < i) return [
+		"",
+		false,
+		0,
+		false
+	];
+	if (!ranges.length && !negs.length) return [
+		"$.",
+		false,
+		glob.length - pos,
+		true
+	];
+	if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate) return [
+		regexpEscape(ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0]),
+		false,
+		endPos - pos,
+		false
+	];
+	const sranges = "[" + (negate ? "^" : "") + rangesToString(ranges) + "]";
+	const snegs = "[" + (negate ? "" : "^") + rangesToString(negs) + "]";
+	return [
+		ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs,
+		uflag,
+		endPos - pos,
+		true
+	];
+};
+//#endregion
+export { parseClass };

package/dist/ui/node_modules/.pnpm/minimatch@10.2.4/node_modules/minimatch/dist/esm/escape.qwik.mjs

@@ -0,0 +1,19 @@
+//#region ../../node_modules/.pnpm/minimatch@10.2.4/node_modules/minimatch/dist/esm/escape.js
+/**
+* Escape all magic characters in a glob pattern.
+*
+* If the {@link MinimatchOptions.windowsPathsNoEscape}
+* option is used, then characters are escaped by wrapping in `[]`, because
+* a magic character wrapped in a character class can only be satisfied by
+* that exact character.  In this mode, `\` is _not_ escaped, because it is
+* not interpreted as a magic character, but instead as a path separator.
+*
+* If the {@link MinimatchOptions.magicalBraces} option is used,
+* then braces (`{` and `}`) will be escaped.
+*/
+var escape = (s, { windowsPathsNoEscape = false, magicalBraces = false } = {}) => {
+	if (magicalBraces) return windowsPathsNoEscape ? s.replace(/[?*()[\]{}]/g, "[$&]") : s.replace(/[?*()[\]\\{}]/g, "\\$&");
+	return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
+};
+//#endregion
+export { escape };