@builder.io/fusion 0.0.1

package/graphql-9ZKKjw7o.js

@@ -0,0 +1,1869 @@
+import { n as e } from "./chunk-hvVJRdgc.js";
+//#region ../../node_modules/prettier/plugins/graphql.mjs
+function t(e) {
+	return M(e), {
+		type: $e,
+		contents: e
+	};
+}
+function n(e, t = {}) {
+	return M(e), N(t.expandedStates, !0), {
+		type: et,
+		id: t.id,
+		contents: e,
+		break: !!t.shouldBreak,
+		expandedStates: t.expandedStates
+	};
+}
+function r(e, t = "", n = {}) {
+	return M(e), t !== "" && M(t), {
+		type: tt,
+		breakContents: e,
+		flatContents: t,
+		groupId: n.groupId
+	};
+}
+function i(e, t) {
+	M(e), N(t);
+	let n = [];
+	for (let r = 0; r < t.length; r++) r !== 0 && n.push(e), n.push(t[r]);
+	return n;
+}
+function a(e) {
+	return (t, n, r) => {
+		let i = !!r?.backwards;
+		if (n === !1) return !1;
+		let { length: a } = t, o = n;
+		for (; o >= 0 && o < a;) {
+			let n = t.charAt(o);
+			if (e instanceof RegExp) {
+				if (!e.test(n)) return o;
+			} else if (!e.includes(n)) return o;
+			i ? o-- : o++;
+		}
+		return o === -1 || o === a ? o : !1;
+	};
+}
+function o(e, t, n) {
+	let r = !!n?.backwards;
+	if (t === !1) return !1;
+	let i = e.charAt(t);
+	if (r) {
+		if (e.charAt(t - 1) === "\r" && i === "\n") return t - 2;
+		if (R(i)) return t - 1;
+	} else {
+		if (i === "\r" && e.charAt(t + 1) === "\n") return t + 2;
+		if (R(i)) return t + 1;
+	}
+	return t;
+}
+function s(e, t, n = {}) {
+	let r = L(e, n.backwards ? t - 1 : t, n);
+	return r !== z(e, r, n);
+}
+function c(e, t) {
+	if (t === !1) return !1;
+	if (e.charAt(t) === "/" && e.charAt(t + 1) === "*") {
+		for (let n = t + 2; n < e.length; ++n) if (e.charAt(n) === "*" && e.charAt(n + 1) === "/") return n + 2;
+	}
+	return t;
+}
+function l(e, t) {
+	return t === !1 ? !1 : e.charAt(t) === "/" && e.charAt(t + 1) === "/" ? at(e, t) : t;
+}
+function u(e, t) {
+	let n = null, r = t;
+	for (; r !== n;) n = r, r = it(e, r), r = st(e, r), r = L(e, r);
+	return r = ct(e, r), r = z(e, r), r !== !1 && ot(e, r);
+}
+function d(e) {
+	return Array.isArray(e) && e.length > 0;
+}
+function f(e) {
+	if (V !== null && typeof V.property) {
+		let e = V;
+		return V = f.prototype = null, e;
+	}
+	return V = f.prototype = e ?? Object.create(null), new f();
+}
+function ee(e) {
+	return f(e);
+}
+function te(e, t = "type") {
+	ee(e);
+	function n(n) {
+		let r = n[t], i = e[r];
+		if (!Array.isArray(i)) throw Object.assign(/* @__PURE__ */ Error(`Missing visitor keys for '${r}'.`), { node: n });
+		return i;
+	}
+	return n;
+}
+function ne(e, t, n) {
+	let { node: r } = e;
+	if (!r.description) return "";
+	let i = [n("description")];
+	return r.kind === "InputValueDefinition" && !r.description.block ? i.push(P) : i.push(I), i;
+}
+function re(e, a, o) {
+	let { node: s } = e;
+	switch (s.kind) {
+		case "Document": return [...i(I, m(e, a, o, "definitions")), I];
+		case "OperationDefinition": {
+			let t = a.originalText[K(s)] !== "{", n = !!s.name;
+			return [
+				q(e, a, o),
+				t ? s.operation : "",
+				t && n ? [" ", o("name")] : "",
+				t && !n && B(s.variableDefinitions) ? " " : "",
+				se(e, o),
+				p(e, o, s),
+				!t && !n ? "" : " ",
+				o("selectionSet")
+			];
+		}
+		case "FragmentDefinition": return [
+			q(e, a, o),
+			"fragment ",
+			o("name"),
+			se(e, o),
+			" on ",
+			o("typeCondition"),
+			p(e, o, s),
+			" ",
+			o("selectionSet")
+		];
+		case "SelectionSet": return [
+			"{",
+			t([I, i(I, m(e, a, o, "selections"))]),
+			I,
+			"}"
+		];
+		case "Field": return n([
+			s.alias ? [o("alias"), ": "] : "",
+			o("name"),
+			s.arguments.length > 0 ? n([
+				"(",
+				t([F, i([r("", ", "), F], m(e, a, o, "arguments"))]),
+				F,
+				")"
+			]) : "",
+			p(e, o, s),
+			s.selectionSet ? " " : "",
+			o("selectionSet")
+		]);
+		case "Name": return s.value;
+		case "StringValue":
+			if (s.block) {
+				let e = k(0, s.value, "\"\"\"", "\\\"\"\"").split("\n");
+				return e.length === 1 && (e[0] = e[0].trim()), e.every((e) => e === "") && (e.length = 0), i(I, [
+					"\"\"\"",
+					...e,
+					"\"\"\""
+				]);
+			}
+			return [
+				"\"",
+				k(0, k(0, s.value, /["\\]/gu, "\\$&"), "\n", "\\n"),
+				"\""
+			];
+		case "IntValue":
+		case "FloatValue":
+		case "EnumValue": return s.value;
+		case "BooleanValue": return s.value ? "true" : "false";
+		case "NullValue": return "null";
+		case "Variable": return ["$", o("name")];
+		case "ListValue": return n([
+			"[",
+			t([F, i([r("", ", "), F], e.map(o, "values"))]),
+			F,
+			"]"
+		]);
+		case "ObjectValue": {
+			let c = a.bracketSpacing && s.fields.length > 0 ? " " : "";
+			return n([
+				"{",
+				c,
+				t([F, i([r("", ", "), F], e.map(o, "fields"))]),
+				F,
+				r("", c),
+				"}"
+			]);
+		}
+		case "ObjectField":
+		case "Argument": return [
+			o("name"),
+			": ",
+			o("value")
+		];
+		case "Directive": return [
+			"@",
+			o("name"),
+			s.arguments.length > 0 ? n([
+				"(",
+				t([F, i([r("", ", "), F], m(e, a, o, "arguments"))]),
+				F,
+				")"
+			]) : ""
+		];
+		case "NamedType": return o("name");
+		case "VariableDefinition": return [
+			q(e, a, o),
+			o("variable"),
+			": ",
+			o("type"),
+			s.defaultValue ? [" = ", o("defaultValue")] : "",
+			p(e, o, s)
+		];
+		case "ObjectTypeExtension":
+		case "ObjectTypeDefinition":
+		case "InputObjectTypeExtension":
+		case "InputObjectTypeDefinition":
+		case "InterfaceTypeExtension":
+		case "InterfaceTypeDefinition": {
+			let { kind: n } = s, r = [];
+			return n.endsWith("TypeDefinition") ? r.push(q(e, a, o)) : r.push("extend "), n.startsWith("ObjectType") ? r.push("type") : n.startsWith("InputObjectType") ? r.push("input") : r.push("interface"), r.push(" ", o("name")), !n.startsWith("InputObjectType") && s.interfaces.length > 0 && r.push(" implements ", ...oe(e, a, o)), r.push(p(e, o, s)), s.fields.length > 0 && r.push([
+				" {",
+				t([I, i(I, m(e, a, o, "fields"))]),
+				I,
+				"}"
+			]), r;
+		}
+		case "FieldDefinition": return [
+			q(e, a, o),
+			o("name"),
+			s.arguments.length > 0 ? n([
+				"(",
+				t([F, i([r("", ", "), F], m(e, a, o, "arguments"))]),
+				F,
+				")"
+			]) : "",
+			": ",
+			o("type"),
+			p(e, o, s)
+		];
+		case "DirectiveDefinition": return [
+			q(e, a, o),
+			"directive ",
+			"@",
+			o("name"),
+			s.arguments.length > 0 ? n([
+				"(",
+				t([F, i([r("", ", "), F], m(e, a, o, "arguments"))]),
+				F,
+				")"
+			]) : "",
+			s.repeatable ? " repeatable" : "",
+			" on ",
+			...i(" | ", e.map(o, "locations"))
+		];
+		case "EnumTypeExtension":
+		case "EnumTypeDefinition": return [
+			q(e, a, o),
+			s.kind === "EnumTypeExtension" ? "extend " : "",
+			"enum ",
+			o("name"),
+			p(e, o, s),
+			s.values.length > 0 ? [
+				" {",
+				t([I, i(I, m(e, a, o, "values"))]),
+				I,
+				"}"
+			] : ""
+		];
+		case "EnumValueDefinition": return [
+			q(e, a, o),
+			o("name"),
+			p(e, o, s)
+		];
+		case "InputValueDefinition": return [
+			q(e, a, o),
+			o("name"),
+			": ",
+			o("type"),
+			s.defaultValue ? [" = ", o("defaultValue")] : "",
+			p(e, o, s)
+		];
+		case "SchemaExtension": return [
+			"extend schema",
+			p(e, o, s),
+			...s.operationTypes.length > 0 ? [
+				" {",
+				t([I, i(I, m(e, a, o, "operationTypes"))]),
+				I,
+				"}"
+			] : []
+		];
+		case "SchemaDefinition": return [
+			q(e, a, o),
+			"schema",
+			p(e, o, s),
+			" {",
+			s.operationTypes.length > 0 ? t([I, i(I, m(e, a, o, "operationTypes"))]) : "",
+			I,
+			"}"
+		];
+		case "OperationTypeDefinition": return [
+			s.operation,
+			": ",
+			o("type")
+		];
+		case "FragmentSpread": return [
+			"...",
+			o("name"),
+			p(e, o, s)
+		];
+		case "InlineFragment": return [
+			"...",
+			s.typeCondition ? [" on ", o("typeCondition")] : "",
+			p(e, o, s),
+			" ",
+			o("selectionSet")
+		];
+		case "UnionTypeExtension":
+		case "UnionTypeDefinition": return n([q(e, a, o), n([
+			s.kind === "UnionTypeExtension" ? "extend " : "",
+			"union ",
+			o("name"),
+			p(e, o, s),
+			s.types.length > 0 ? [
+				" =",
+				r("", " "),
+				t([r([P, "| "]), i([P, "| "], e.map(o, "types"))])
+			] : ""
+		])]);
+		case "ScalarTypeExtension":
+		case "ScalarTypeDefinition": return [
+			q(e, a, o),
+			s.kind === "ScalarTypeExtension" ? "extend " : "",
+			"scalar ",
+			o("name"),
+			p(e, o, s)
+		];
+		case "NonNullType": return [o("type"), "!"];
+		case "ListType": return [
+			"[",
+			o("type"),
+			"]"
+		];
+		default: throw new dt(s, "Graphql", "kind");
+	}
+}
+function p(e, r, a) {
+	if (a.directives.length === 0) return "";
+	let o = i(P, e.map(r, "directives"));
+	return a.kind === "FragmentDefinition" || a.kind === "OperationDefinition" ? n([P, o]) : [" ", n(t([F, o]))];
+}
+function m(e, t, n, r) {
+	return e.map(({ isLast: e, node: r }) => {
+		let i = n();
+		return !e && lt(t.originalText, gt(r)) ? [i, I] : i;
+	}, r);
+}
+function ie(e) {
+	return e.kind !== "Comment";
+}
+function ae({ node: e }) {
+	if (e.kind === "Comment") return "#" + e.value.trimEnd();
+	throw Error("Not a comment: " + JSON.stringify(e));
+}
+function oe(e, t, n) {
+	let { node: r } = e, i = [], { interfaces: a } = r, o = e.map(n, "interfaces");
+	for (let e = 0; e < a.length; e++) {
+		let n = a[e];
+		i.push(o[e]);
+		let r = a[e + 1];
+		if (r) {
+			let e = t.originalText.slice(n.loc.end, r.loc.start).includes("#");
+			i.push(" &", e ? P : " ");
+		}
+	}
+	return i;
+}
+function se(e, a) {
+	let { node: o } = e;
+	return B(o.variableDefinitions) ? n([
+		"(",
+		t([F, i([r("", ", "), F], e.map(a, "variableDefinitions"))]),
+		F,
+		")"
+	]) : "";
+}
+function ce(e, t) {
+	e.kind === "StringValue" && e.block && !e.value.includes("\n") && (t.value = e.value.trim());
+}
+function le(e) {
+	let { node: t } = e;
+	return t?.comments?.some((e) => e.value.trim() === "prettier-ignore");
+}
+function ue(e) {
+	return typeof e == "object" && !!e;
+}
+function de(e, t) {
+	if (!e) throw Error(t ?? "Unexpected invariant triggered.");
+}
+function h(e, t) {
+	let n = 0, r = 1;
+	for (let i of e.body.matchAll(Tt)) {
+		if (typeof i.index == "number" || de(!1), i.index >= t) break;
+		n = i.index + i[0].length, r += 1;
+	}
+	return {
+		line: r,
+		column: t + 1 - n
+	};
+}
+function fe(e) {
+	return pe(e.source, h(e.source, e.start));
+}
+function pe(e, t) {
+	let n = e.locationOffset.column - 1, r = "".padStart(n) + e.body, i = t.line - 1, a = e.locationOffset.line - 1, o = t.line + a, s = t.line === 1 ? n : 0, c = t.column + s, l = `${e.name}:${o}:${c}
+`, u = r.split(/\r\n|[\n\r]/g), d = u[i];
+	if (d.length > 120) {
+		let e = Math.floor(c / 80), t = c % 80, n = [];
+		for (let e = 0; e < d.length; e += 80) n.push(d.slice(e, e + 80));
+		return l + me([
+			[`${o} |`, n[0]],
+			...n.slice(1, e + 1).map((e) => ["|", e]),
+			["|", "^".padStart(t)],
+			["|", n[e + 1]]
+		]);
+	}
+	return l + me([
+		[`${o - 1} |`, u[i - 1]],
+		[`${o} |`, d],
+		["|", "^".padStart(c)],
+		[`${o + 1} |`, u[i + 1]]
+	]);
+}
+function me(e) {
+	let t = e.filter(([e, t]) => t !== void 0), n = Math.max(...t.map(([e]) => e.length));
+	return t.map(([e, t]) => e.padStart(n) + (t ? " " + t : "")).join("\n");
+}
+function he(e) {
+	let t = e[0];
+	return t == null || "kind" in t || "length" in t ? {
+		nodes: t,
+		source: e[1],
+		positions: e[2],
+		path: e[3],
+		originalError: e[4],
+		extensions: e[5]
+	} : t;
+}
+function ge(e) {
+	return e === void 0 || e.length === 0 ? void 0 : e;
+}
+function g(e, t, n) {
+	return new Et(`Syntax Error: ${n}`, {
+		source: e,
+		positions: [t]
+	});
+}
+function _e(e) {
+	return e === 9 || e === 32;
+}
+function _(e) {
+	return e >= 48 && e <= 57;
+}
+function ve(e) {
+	return e >= 97 && e <= 122 || e >= 65 && e <= 90;
+}
+function ye(e) {
+	return ve(e) || e === 95;
+}
+function be(e) {
+	return ve(e) || _(e) || e === 95;
+}
+function xe(e) {
+	let t = 2 ** 53 - 1, n = null, r = -1;
+	for (let i = 0; i < e.length; ++i) {
+		let a = e[i], o = Se(a);
+		o !== a.length && (n ??= i, r = i, i !== 0 && o < t && (t = o));
+	}
+	return e.map((e, n) => n === 0 ? e : e.slice(t)).slice(n ?? 0, r + 1);
+}
+function Se(e) {
+	let t = 0;
+	for (; t < e.length && _e(e.charCodeAt(t));) ++t;
+	return t;
+}
+function Ce(e) {
+	return e === Z.BANG || e === Z.DOLLAR || e === Z.AMP || e === Z.PAREN_L || e === Z.PAREN_R || e === Z.DOT || e === Z.SPREAD || e === Z.COLON || e === Z.EQUALS || e === Z.AT || e === Z.BRACKET_L || e === Z.BRACKET_R || e === Z.BRACE_L || e === Z.PIPE || e === Z.BRACE_R;
+}
+function v(e) {
+	return e >= 0 && e <= 55295 || e >= 57344 && e <= 1114111;
+}
+function y(e, t) {
+	return we(e.charCodeAt(t)) && Te(e.charCodeAt(t + 1));
+}
+function we(e) {
+	return e >= 55296 && e <= 56319;
+}
+function Te(e) {
+	return e >= 56320 && e <= 57343;
+}
+function b(e, t) {
+	let n = e.source.body.codePointAt(t);
+	if (n === void 0) return Z.EOF;
+	if (n >= 32 && n <= 126) {
+		let e = String.fromCodePoint(n);
+		return e === "\"" ? "'\"'" : `"${e}"`;
+	}
+	return "U+" + n.toString(16).toUpperCase().padStart(4, "0");
+}
+function x(e, t, n, r, i) {
+	let a = e.line;
+	return new H(t, n, r, a, 1 + n - e.lineStart, i);
+}
+function Ee(e, t) {
+	let n = e.source.body, r = n.length, i = t;
+	for (; i < r;) {
+		let t = n.charCodeAt(i);
+		switch (t) {
+			case 65279:
+			case 9:
+			case 32:
+			case 44:
+				++i;
+				continue;
+			case 10:
+				++i, ++e.line, e.lineStart = i;
+				continue;
+			case 13:
+				n.charCodeAt(i + 1) === 10 ? i += 2 : ++i, ++e.line, e.lineStart = i;
+				continue;
+			case 35: return De(e, i);
+			case 33: return x(e, Z.BANG, i, i + 1);
+			case 36: return x(e, Z.DOLLAR, i, i + 1);
+			case 38: return x(e, Z.AMP, i, i + 1);
+			case 40: return x(e, Z.PAREN_L, i, i + 1);
+			case 41: return x(e, Z.PAREN_R, i, i + 1);
+			case 46:
+				if (n.charCodeAt(i + 1) === 46 && n.charCodeAt(i + 2) === 46) return x(e, Z.SPREAD, i, i + 3);
+				break;
+			case 58: return x(e, Z.COLON, i, i + 1);
+			case 61: return x(e, Z.EQUALS, i, i + 1);
+			case 64: return x(e, Z.AT, i, i + 1);
+			case 91: return x(e, Z.BRACKET_L, i, i + 1);
+			case 93: return x(e, Z.BRACKET_R, i, i + 1);
+			case 123: return x(e, Z.BRACE_L, i, i + 1);
+			case 124: return x(e, Z.PIPE, i, i + 1);
+			case 125: return x(e, Z.BRACE_R, i, i + 1);
+			case 34: return n.charCodeAt(i + 1) === 34 && n.charCodeAt(i + 2) === 34 ? Pe(e, i) : ke(e, i);
+		}
+		if (_(t) || t === 45) return Oe(e, i, t);
+		if (ye(t)) return Fe(e, i);
+		throw g(e.source, i, t === 39 ? "Unexpected single quote character ('), did you mean to use a double quote (\")?" : v(t) || y(n, i) ? `Unexpected character: ${b(e, i)}.` : `Invalid character: ${b(e, i)}.`);
+	}
+	return x(e, Z.EOF, r, r);
+}
+function De(e, t) {
+	let n = e.source.body, r = n.length, i = t + 1;
+	for (; i < r;) {
+		let e = n.charCodeAt(i);
+		if (e === 10 || e === 13) break;
+		if (v(e)) ++i;
+		else if (y(n, i)) i += 2;
+		else break;
+	}
+	return x(e, Z.COMMENT, t, i, n.slice(t + 1, i));
+}
+function Oe(e, t, n) {
+	let r = e.source.body, i = t, a = n, o = !1;
+	if (a === 45 && (a = r.charCodeAt(++i)), a === 48) {
+		if (a = r.charCodeAt(++i), _(a)) throw g(e.source, i, `Invalid number, unexpected digit after 0: ${b(e, i)}.`);
+	} else i = S(e, i, a), a = r.charCodeAt(i);
+	if (a === 46 && (o = !0, a = r.charCodeAt(++i), i = S(e, i, a), a = r.charCodeAt(i)), (a === 69 || a === 101) && (o = !0, a = r.charCodeAt(++i), (a === 43 || a === 45) && (a = r.charCodeAt(++i)), i = S(e, i, a), a = r.charCodeAt(i)), a === 46 || ye(a)) throw g(e.source, i, `Invalid number, expected digit but got: ${b(e, i)}.`);
+	return x(e, o ? Z.FLOAT : Z.INT, t, i, r.slice(t, i));
+}
+function S(e, t, n) {
+	if (!_(n)) throw g(e.source, t, `Invalid number, expected digit but got: ${b(e, t)}.`);
+	let r = e.source.body, i = t + 1;
+	for (; _(r.charCodeAt(i));) ++i;
+	return i;
+}
+function ke(e, t) {
+	let n = e.source.body, r = n.length, i = t + 1, a = i, o = "";
+	for (; i < r;) {
+		let r = n.charCodeAt(i);
+		if (r === 34) return o += n.slice(a, i), x(e, Z.STRING, t, i + 1, o);
+		if (r === 92) {
+			o += n.slice(a, i);
+			let t = n.charCodeAt(i + 1) === 117 ? n.charCodeAt(i + 2) === 123 ? Ae(e, i) : je(e, i) : Ne(e, i);
+			o += t.value, i += t.size, a = i;
+			continue;
+		}
+		if (r === 10 || r === 13) break;
+		if (v(r)) ++i;
+		else if (y(n, i)) i += 2;
+		else throw g(e.source, i, `Invalid character within String: ${b(e, i)}.`);
+	}
+	throw g(e.source, i, "Unterminated string.");
+}
+function Ae(e, t) {
+	let n = e.source.body, r = 0, i = 3;
+	for (; i < 12;) {
+		let e = n.charCodeAt(t + i++);
+		if (e === 125) {
+			if (i < 5 || !v(r)) break;
+			return {
+				value: String.fromCodePoint(r),
+				size: i
+			};
+		}
+		if (r = r << 4 | C(e), r < 0) break;
+	}
+	throw g(e.source, t, `Invalid Unicode escape sequence: "${n.slice(t, t + i)}".`);
+}
+function je(e, t) {
+	let n = e.source.body, r = Me(n, t + 2);
+	if (v(r)) return {
+		value: String.fromCodePoint(r),
+		size: 6
+	};
+	if (we(r) && n.charCodeAt(t + 6) === 92 && n.charCodeAt(t + 7) === 117) {
+		let e = Me(n, t + 8);
+		if (Te(e)) return {
+			value: String.fromCodePoint(r, e),
+			size: 12
+		};
+	}
+	throw g(e.source, t, `Invalid Unicode escape sequence: "${n.slice(t, t + 6)}".`);
+}
+function Me(e, t) {
+	return C(e.charCodeAt(t)) << 12 | C(e.charCodeAt(t + 1)) << 8 | C(e.charCodeAt(t + 2)) << 4 | C(e.charCodeAt(t + 3));
+}
+function C(e) {
+	return e >= 48 && e <= 57 ? e - 48 : e >= 65 && e <= 70 ? e - 55 : e >= 97 && e <= 102 ? e - 87 : -1;
+}
+function Ne(e, t) {
+	let n = e.source.body;
+	switch (n.charCodeAt(t + 1)) {
+		case 34: return {
+			value: "\"",
+			size: 2
+		};
+		case 92: return {
+			value: "\\",
+			size: 2
+		};
+		case 47: return {
+			value: "/",
+			size: 2
+		};
+		case 98: return {
+			value: "\b",
+			size: 2
+		};
+		case 102: return {
+			value: "\f",
+			size: 2
+		};
+		case 110: return {
+			value: "\n",
+			size: 2
+		};
+		case 114: return {
+			value: "\r",
+			size: 2
+		};
+		case 116: return {
+			value: "	",
+			size: 2
+		};
+	}
+	throw g(e.source, t, `Invalid character escape sequence: "${n.slice(t, t + 2)}".`);
+}
+function Pe(e, t) {
+	let n = e.source.body, r = n.length, i = e.lineStart, a = t + 3, o = a, s = "", c = [];
+	for (; a < r;) {
+		let r = n.charCodeAt(a);
+		if (r === 34 && n.charCodeAt(a + 1) === 34 && n.charCodeAt(a + 2) === 34) {
+			s += n.slice(o, a), c.push(s);
+			let r = x(e, Z.BLOCK_STRING, t, a + 3, xe(c).join("\n"));
+			return e.line += c.length - 1, e.lineStart = i, r;
+		}
+		if (r === 92 && n.charCodeAt(a + 1) === 34 && n.charCodeAt(a + 2) === 34 && n.charCodeAt(a + 3) === 34) {
+			s += n.slice(o, a), o = a + 1, a += 4;
+			continue;
+		}
+		if (r === 10 || r === 13) {
+			s += n.slice(o, a), c.push(s), r === 13 && n.charCodeAt(a + 1) === 10 ? a += 2 : ++a, s = "", o = a, i = a;
+			continue;
+		}
+		if (v(r)) ++a;
+		else if (y(n, a)) a += 2;
+		else throw g(e.source, a, `Invalid character within String: ${b(e, a)}.`);
+	}
+	throw g(e.source, a, "Unterminated string.");
+}
+function Fe(e, t) {
+	let n = e.source.body, r = n.length, i = t + 1;
+	for (; i < r && be(n.charCodeAt(i));) ++i;
+	return x(e, Z.NAME, t, i, n.slice(t, i));
+}
+function w(e, t) {
+	if (!e) throw Error(t);
+}
+function Ie(e) {
+	return T(e, []);
+}
+function T(e, t) {
+	switch (typeof e) {
+		case "string": return JSON.stringify(e);
+		case "function": return e.name ? `[function ${e.name}]` : "[function]";
+		case "object": return Le(e, t);
+		default: return String(e);
+	}
+}
+function Le(e, t) {
+	if (e === null) return "null";
+	if (t.includes(e)) return "[Circular]";
+	let n = [...t, e];
+	if (Re(e)) {
+		let t = e.toJSON();
+		if (t !== e) return typeof t == "string" ? t : T(t, n);
+	} else if (Array.isArray(e)) return Be(e, n);
+	return ze(e, n);
+}
+function Re(e) {
+	return typeof e.toJSON == "function";
+}
+function ze(e, t) {
+	let n = Object.entries(e);
+	return n.length === 0 ? "{}" : t.length > 2 ? "[" + Ve(e) + "]" : "{ " + n.map(([e, n]) => e + ": " + T(n, t)).join(", ") + " }";
+}
+function Be(e, t) {
+	if (e.length === 0) return "[]";
+	if (t.length > 2) return "[Array]";
+	let n = Math.min(10, e.length), r = e.length - n, i = [];
+	for (let r = 0; r < n; ++r) i.push(T(e[r], t));
+	return r === 1 ? i.push("... 1 more item") : r > 1 && i.push(`... ${r} more items`), "[" + i.join(", ") + "]";
+}
+function Ve(e) {
+	let t = Object.prototype.toString.call(e).replace(/^\[object /, "").replace(/]$/, "");
+	if (t === "Object" && typeof e.constructor == "function") {
+		let t = e.constructor.name;
+		if (typeof t == "string" && t !== "") return t;
+	}
+	return t;
+}
+function He(e) {
+	return kt(e, Q);
+}
+function Ue(e, t) {
+	let n = new At(e, t), r = n.parseDocument();
+	return Object.defineProperty(r, "tokenCount", {
+		enumerable: !1,
+		value: n.tokenCount
+	}), r;
+}
+function E(e) {
+	let t = e.value;
+	return We(e.kind) + (t == null ? "" : ` "${t}"`);
+}
+function We(e) {
+	return Ce(e) ? `"${e}"` : e;
+}
+function Ge(e, t) {
+	let n = /* @__PURE__ */ SyntaxError(e + " (" + t.loc.start.line + ":" + t.loc.start.column + ")");
+	return Object.assign(n, t);
+}
+function Ke(e) {
+	let t = [], { startToken: n, endToken: r } = e.loc;
+	for (let e = n; e !== r; e = e.next) e.kind === "Comment" && t.push({
+		...e,
+		loc: {
+			start: e.start,
+			end: e.end
+		}
+	});
+	return t;
+}
+function qe(e) {
+	if (e?.name === "GraphQLError") {
+		let { message: t, locations: [n] } = e;
+		return jt(t, {
+			loc: { start: n },
+			cause: e
+		});
+	}
+	return e;
+}
+function Je(e) {
+	let t;
+	try {
+		t = Ue(e, Mt);
+	} catch (e) {
+		throw qe(e);
+	}
+	return t.comments = Ke(t), t;
+}
+var Ye, D, O, Xe, Ze, k, Qe, A, $e, et, tt, j, nt, M, N, rt, P, F, I, L, it, at, R, z, ot, st, ct, lt, B, ut, dt, V, ft, pt, mt, H, U, W, G, ht, K, gt, _t, vt, yt, bt, xt, St, q, Ct, wt, J, Y, Tt, Et, Dt, X, Z, Ot, kt, Q, At, jt, Mt, Nt, $;
+//#endregion
+e((() => {
+	Ye = Object.defineProperty, D = (e, t) => {
+		for (var n in t) Ye(e, n, {
+			get: t[n],
+			enumerable: !0
+		});
+	}, O = {}, D(O, {
+		languages: () => wt,
+		options: () => J,
+		parsers: () => Y,
+		printers: () => $
+	}), Xe = (e, t) => (n, r, ...i) => n | 1 && r == null ? void 0 : (t.call(r) ?? r[e]).apply(r, i), Ze = String.prototype.replaceAll ?? function(e, t) {
+		return e.global ? this.replace(e, t) : this.split(e).join(t);
+	}, k = Xe("replaceAll", function() {
+		if (typeof this == "string") return Ze;
+	}), Qe = () => {}, A = Qe, $e = "indent", et = "group", tt = "if-break", j = "line", nt = "break-parent", M = A, N = A, rt = { type: nt }, P = { type: j }, F = {
+		type: j,
+		soft: !0
+	}, I = [{
+		type: j,
+		hard: !0
+	}, rt], L = a(" 	"), it = a(",; 	"), at = a(/[^\n\r]/u), R = (e) => e === "\n" || e === "\r" || e === "\u2028" || e === "\u2029", z = o, ot = s, st = c, ct = l, lt = u, B = d, ut = class extends Error {
+		name = "UnexpectedNodeError";
+		constructor(e, t, n = "type") {
+			super(`Unexpected ${t} node ${n}: ${JSON.stringify(e[n])}.`), this.node = e;
+		}
+	}, dt = ut, V = null, ft = 10;
+	for (let e = 0; e <= ft; e++) f();
+	pt = te, mt = class {
+		constructor(e, t, n) {
+			this.start = e.start, this.end = t.end, this.startToken = e, this.endToken = t, this.source = n;
+		}
+		get [Symbol.toStringTag]() {
+			return "Location";
+		}
+		toJSON() {
+			return {
+				start: this.start,
+				end: this.end
+			};
+		}
+	}, H = class {
+		constructor(e, t, n, r, i, a) {
+			this.kind = e, this.start = t, this.end = n, this.line = r, this.column = i, this.value = a, this.prev = null, this.next = null;
+		}
+		get [Symbol.toStringTag]() {
+			return "Token";
+		}
+		toJSON() {
+			return {
+				kind: this.kind,
+				value: this.value,
+				line: this.line,
+				column: this.column
+			};
+		}
+	}, U = {
+		Name: [],
+		Document: ["definitions"],
+		OperationDefinition: [
+			"description",
+			"name",
+			"variableDefinitions",
+			"directives",
+			"selectionSet"
+		],
+		VariableDefinition: [
+			"description",
+			"variable",
+			"type",
+			"defaultValue",
+			"directives"
+		],
+		Variable: ["name"],
+		SelectionSet: ["selections"],
+		Field: [
+			"alias",
+			"name",
+			"arguments",
+			"directives",
+			"selectionSet"
+		],
+		Argument: ["name", "value"],
+		FragmentSpread: ["name", "directives"],
+		InlineFragment: [
+			"typeCondition",
+			"directives",
+			"selectionSet"
+		],
+		FragmentDefinition: [
+			"description",
+			"name",
+			"variableDefinitions",
+			"typeCondition",
+			"directives",
+			"selectionSet"
+		],
+		IntValue: [],
+		FloatValue: [],
+		StringValue: [],
+		BooleanValue: [],
+		NullValue: [],
+		EnumValue: [],
+		ListValue: ["values"],
+		ObjectValue: ["fields"],
+		ObjectField: ["name", "value"],
+		Directive: ["name", "arguments"],
+		NamedType: ["name"],
+		ListType: ["type"],
+		NonNullType: ["type"],
+		SchemaDefinition: [
+			"description",
+			"directives",
+			"operationTypes"
+		],
+		OperationTypeDefinition: ["type"],
+		ScalarTypeDefinition: [
+			"description",
+			"name",
+			"directives"
+		],
+		ObjectTypeDefinition: [
+			"description",
+			"name",
+			"interfaces",
+			"directives",
+			"fields"
+		],
+		FieldDefinition: [
+			"description",
+			"name",
+			"arguments",
+			"type",
+			"directives"
+		],
+		InputValueDefinition: [
+			"description",
+			"name",
+			"type",
+			"defaultValue",
+			"directives"
+		],
+		InterfaceTypeDefinition: [
+			"description",
+			"name",
+			"interfaces",
+			"directives",
+			"fields"
+		],
+		UnionTypeDefinition: [
+			"description",
+			"name",
+			"directives",
+			"types"
+		],
+		EnumTypeDefinition: [
+			"description",
+			"name",
+			"directives",
+			"values"
+		],
+		EnumValueDefinition: [
+			"description",
+			"name",
+			"directives"
+		],
+		InputObjectTypeDefinition: [
+			"description",
+			"name",
+			"directives",
+			"fields"
+		],
+		DirectiveDefinition: [
+			"description",
+			"name",
+			"arguments",
+			"locations"
+		],
+		SchemaExtension: ["directives", "operationTypes"],
+		ScalarTypeExtension: ["name", "directives"],
+		ObjectTypeExtension: [
+			"name",
+			"interfaces",
+			"directives",
+			"fields"
+		],
+		InterfaceTypeExtension: [
+			"name",
+			"interfaces",
+			"directives",
+			"fields"
+		],
+		UnionTypeExtension: [
+			"name",
+			"directives",
+			"types"
+		],
+		EnumTypeExtension: [
+			"name",
+			"directives",
+			"values"
+		],
+		InputObjectTypeExtension: [
+			"name",
+			"directives",
+			"fields"
+		],
+		TypeCoordinate: ["name"],
+		MemberCoordinate: ["name", "memberName"],
+		ArgumentCoordinate: [
+			"name",
+			"fieldName",
+			"argumentName"
+		],
+		DirectiveCoordinate: ["name"],
+		DirectiveArgumentCoordinate: ["name", "argumentName"]
+	}, new Set(Object.keys(U)), (function(e) {
+		e.QUERY = "query", e.MUTATION = "mutation", e.SUBSCRIPTION = "subscription";
+	})(W ||= {}), G = { ...U };
+	for (let e of [
+		"ArgumentCoordinate",
+		"DirectiveArgumentCoordinate",
+		"DirectiveCoordinate",
+		"MemberCoordinate",
+		"TypeCoordinate"
+	]) delete G[e];
+	ht = pt(G, "kind"), K = (e) => e.loc.start, gt = (e) => e.loc.end, _t = "format", vt = /^\s*#[^\S\n]*@(?:noformat|noprettier)\s*(?:\n|$)/u, yt = /^\s*#[^\S\n]*@(?:format|prettier)\s*(?:\n|$)/u, bt = (e) => yt.test(e), xt = (e) => vt.test(e), St = (e) => `# @${_t}
+
+${e}`, q = ne, ce.ignoredProperties = new Set(["loc", "comments"]), Ct = {
+		print: re,
+		massageAstNode: ce,
+		hasPrettierIgnore: le,
+		insertPragma: St,
+		printComment: ae,
+		canAttachComment: ie,
+		getVisitorKeys: ht
+	}, wt = [{
+		name: "GraphQL",
+		type: "data",
+		aceMode: "graphqlschema",
+		extensions: [
+			".graphql",
+			".gql",
+			".graphqls"
+		],
+		tmScope: "source.graphql",
+		parsers: ["graphql"],
+		vscodeLanguageIds: ["graphql"],
+		linguistLanguageId: 139
+	}], J = { bracketSpacing: {
+		bracketSpacing: {
+			category: "Common",
+			type: "boolean",
+			default: !0,
+			description: "Print spaces between brackets.",
+			oppositeDescription: "Do not print spaces between brackets."
+		},
+		objectWrap: {
+			category: "Common",
+			type: "choice",
+			default: "preserve",
+			description: "How to wrap object literals.",
+			choices: [{
+				value: "preserve",
+				description: "Keep as multi-line, if there is a newline between the opening brace and first property."
+			}, {
+				value: "collapse",
+				description: "Fit to a single line when possible."
+			}]
+		},
+		singleQuote: {
+			category: "Common",
+			type: "boolean",
+			default: !1,
+			description: "Use single quotes instead of double quotes."
+		},
+		proseWrap: {
+			category: "Common",
+			type: "choice",
+			default: "preserve",
+			description: "How to wrap prose.",
+			choices: [
+				{
+					value: "always",
+					description: "Wrap prose if it exceeds the print width."
+				},
+				{
+					value: "never",
+					description: "Do not wrap prose."
+				},
+				{
+					value: "preserve",
+					description: "Wrap prose as-is."
+				}
+			]
+		},
+		bracketSameLine: {
+			category: "Common",
+			type: "boolean",
+			default: !1,
+			description: "Put > of opening tags on the last line instead of on a new line."
+		},
+		singleAttributePerLine: {
+			category: "Common",
+			type: "boolean",
+			default: !1,
+			description: "Enforce single attribute per line in HTML, Vue and JSX."
+		}
+	}.bracketSpacing }, Y = {}, D(Y, { graphql: () => Nt }), Tt = /\r\n|[\n\r]/g, Et = class e extends Error {
+		constructor(t, ...n) {
+			var r;
+			let { nodes: i, source: a, positions: o, path: s, originalError: c, extensions: l } = he(n);
+			super(t), this.name = "GraphQLError", this.path = s ?? void 0, this.originalError = c ?? void 0, this.nodes = ge(Array.isArray(i) ? i : i ? [i] : void 0);
+			let u = ge(this.nodes?.map((e) => e.loc).filter((e) => e != null));
+			this.source = a ?? (u == null || (r = u[0]) == null ? void 0 : r.source), this.positions = o ?? u?.map((e) => e.start), this.locations = o && a ? o.map((e) => h(a, e)) : u?.map((e) => h(e.source, e.start));
+			let d = ue(c?.extensions) ? c?.extensions : void 0;
+			this.extensions = l ?? d ?? Object.create(null), Object.defineProperties(this, {
+				message: {
+					writable: !0,
+					enumerable: !0
+				},
+				name: { enumerable: !1 },
+				nodes: { enumerable: !1 },
+				source: { enumerable: !1 },
+				positions: { enumerable: !1 },
+				originalError: { enumerable: !1 }
+			}), c != null && c.stack ? Object.defineProperty(this, "stack", {
+				value: c.stack,
+				writable: !0,
+				configurable: !0
+			}) : Error.captureStackTrace ? Error.captureStackTrace(this, e) : Object.defineProperty(this, "stack", {
+				value: Error().stack,
+				writable: !0,
+				configurable: !0
+			});
+		}
+		get [Symbol.toStringTag]() {
+			return "GraphQLError";
+		}
+		toString() {
+			let e = this.message;
+			if (this.nodes) for (let t of this.nodes) t.loc && (e += "\n\n" + fe(t.loc));
+			else if (this.source && this.locations) for (let t of this.locations) e += "\n\n" + pe(this.source, t);
+			return e;
+		}
+		toJSON() {
+			let e = { message: this.message };
+			return this.locations != null && (e.locations = this.locations), this.path != null && (e.path = this.path), this.extensions != null && Object.keys(this.extensions).length > 0 && (e.extensions = this.extensions), e;
+		}
+	}, (function(e) {
+		e.QUERY = "QUERY", e.MUTATION = "MUTATION", e.SUBSCRIPTION = "SUBSCRIPTION", e.FIELD = "FIELD", e.FRAGMENT_DEFINITION = "FRAGMENT_DEFINITION", e.FRAGMENT_SPREAD = "FRAGMENT_SPREAD", e.INLINE_FRAGMENT = "INLINE_FRAGMENT", e.VARIABLE_DEFINITION = "VARIABLE_DEFINITION", e.SCHEMA = "SCHEMA", e.SCALAR = "SCALAR", e.OBJECT = "OBJECT", e.FIELD_DEFINITION = "FIELD_DEFINITION", e.ARGUMENT_DEFINITION = "ARGUMENT_DEFINITION", e.INTERFACE = "INTERFACE", e.UNION = "UNION", e.ENUM = "ENUM", e.ENUM_VALUE = "ENUM_VALUE", e.INPUT_OBJECT = "INPUT_OBJECT", e.INPUT_FIELD_DEFINITION = "INPUT_FIELD_DEFINITION";
+	})(Dt ||= {}), (function(e) {
+		e.NAME = "Name", e.DOCUMENT = "Document", e.OPERATION_DEFINITION = "OperationDefinition", e.VARIABLE_DEFINITION = "VariableDefinition", e.SELECTION_SET = "SelectionSet", e.FIELD = "Field", e.ARGUMENT = "Argument", e.FRAGMENT_SPREAD = "FragmentSpread", e.INLINE_FRAGMENT = "InlineFragment", e.FRAGMENT_DEFINITION = "FragmentDefinition", e.VARIABLE = "Variable", e.INT = "IntValue", e.FLOAT = "FloatValue", e.STRING = "StringValue", e.BOOLEAN = "BooleanValue", e.NULL = "NullValue", e.ENUM = "EnumValue", e.LIST = "ListValue", e.OBJECT = "ObjectValue", e.OBJECT_FIELD = "ObjectField", e.DIRECTIVE = "Directive", e.NAMED_TYPE = "NamedType", e.LIST_TYPE = "ListType", e.NON_NULL_TYPE = "NonNullType", e.SCHEMA_DEFINITION = "SchemaDefinition", e.OPERATION_TYPE_DEFINITION = "OperationTypeDefinition", e.SCALAR_TYPE_DEFINITION = "ScalarTypeDefinition", e.OBJECT_TYPE_DEFINITION = "ObjectTypeDefinition", e.FIELD_DEFINITION = "FieldDefinition", e.INPUT_VALUE_DEFINITION = "InputValueDefinition", e.INTERFACE_TYPE_DEFINITION = "InterfaceTypeDefinition", e.UNION_TYPE_DEFINITION = "UnionTypeDefinition", e.ENUM_TYPE_DEFINITION = "EnumTypeDefinition", e.ENUM_VALUE_DEFINITION = "EnumValueDefinition", e.INPUT_OBJECT_TYPE_DEFINITION = "InputObjectTypeDefinition", e.DIRECTIVE_DEFINITION = "DirectiveDefinition", e.SCHEMA_EXTENSION = "SchemaExtension", e.SCALAR_TYPE_EXTENSION = "ScalarTypeExtension", e.OBJECT_TYPE_EXTENSION = "ObjectTypeExtension", e.INTERFACE_TYPE_EXTENSION = "InterfaceTypeExtension", e.UNION_TYPE_EXTENSION = "UnionTypeExtension", e.ENUM_TYPE_EXTENSION = "EnumTypeExtension", e.INPUT_OBJECT_TYPE_EXTENSION = "InputObjectTypeExtension", e.TYPE_COORDINATE = "TypeCoordinate", e.MEMBER_COORDINATE = "MemberCoordinate", e.ARGUMENT_COORDINATE = "ArgumentCoordinate", e.DIRECTIVE_COORDINATE = "DirectiveCoordinate", e.DIRECTIVE_ARGUMENT_COORDINATE = "DirectiveArgumentCoordinate";
+	})(X ||= {}), (function(e) {
+		e.SOF = "<SOF>", e.EOF = "<EOF>", e.BANG = "!", e.DOLLAR = "$", e.AMP = "&", e.PAREN_L = "(", e.PAREN_R = ")", e.DOT = ".", e.SPREAD = "...", e.COLON = ":", e.EQUALS = "=", e.AT = "@", e.BRACKET_L = "[", e.BRACKET_R = "]", e.BRACE_L = "{", e.PIPE = "|", e.BRACE_R = "}", e.NAME = "Name", e.INT = "Int", e.FLOAT = "Float", e.STRING = "String", e.BLOCK_STRING = "BlockString", e.COMMENT = "Comment";
+	})(Z ||= {}), Ot = class {
+		constructor(e) {
+			let t = new H(Z.SOF, 0, 0, 0, 0);
+			this.source = e, this.lastToken = t, this.token = t, this.line = 1, this.lineStart = 0;
+		}
+		get [Symbol.toStringTag]() {
+			return "Lexer";
+		}
+		advance() {
+			return this.lastToken = this.token, this.token = this.lookahead();
+		}
+		lookahead() {
+			let e = this.token;
+			if (e.kind !== Z.EOF) do
+				if (e.next) e = e.next;
+				else {
+					let t = Ee(this, e.end);
+					e.next = t, t.prev = e, e = t;
+				}
+			while (e.kind === Z.COMMENT);
+			return e;
+		}
+	}, kt = globalThis.process ? function(e, t) {
+		return e instanceof t;
+	} : function(e, t) {
+		if (e instanceof t) return !0;
+		if (typeof e == "object" && e) {
+			let n = t.prototype[Symbol.toStringTag];
+			if (n === (Symbol.toStringTag in e ? e[Symbol.toStringTag] : e.constructor?.name)) {
+				let t = Ie(e);
+				throw Error(`Cannot use ${n} "${t}" from another module or realm.
+
+Ensure that there is only one instance of "graphql" in the node_modules
+directory. If different versions of "graphql" are the dependencies of other
+relied on modules, use "resolutions" to ensure only one version is installed.
+
+https://yarnpkg.com/en/docs/selective-version-resolutions
+
+Duplicate "graphql" modules cannot be used at the same time since different
+versions may have different capabilities and behavior. The data from one
+version used in the function from another could produce confusing and
+spurious results.`);
+			}
+		}
+		return !1;
+	}, Q = class {
+		constructor(e, t = "GraphQL request", n = {
+			line: 1,
+			column: 1
+		}) {
+			typeof e == "string" || w(!1, `Body must be a string. Received: ${Ie(e)}.`), this.body = e, this.name = t, this.locationOffset = n, this.locationOffset.line > 0 || w(!1, "line in locationOffset is 1-indexed and must be positive."), this.locationOffset.column > 0 || w(!1, "column in locationOffset is 1-indexed and must be positive.");
+		}
+		get [Symbol.toStringTag]() {
+			return "Source";
+		}
+	}, At = class {
+		constructor(e, t = {}) {
+			let { lexer: n, ...r } = t;
+			n ? this._lexer = n : this._lexer = new Ot(He(e) ? e : new Q(e)), this._options = r, this._tokenCounter = 0;
+		}
+		get tokenCount() {
+			return this._tokenCounter;
+		}
+		parseName() {
+			let e = this.expectToken(Z.NAME);
+			return this.node(e, {
+				kind: X.NAME,
+				value: e.value
+			});
+		}
+		parseDocument() {
+			return this.node(this._lexer.token, {
+				kind: X.DOCUMENT,
+				definitions: this.many(Z.SOF, this.parseDefinition, Z.EOF)
+			});
+		}
+		parseDefinition() {
+			if (this.peek(Z.BRACE_L)) return this.parseOperationDefinition();
+			let e = this.peekDescription(), t = e ? this._lexer.lookahead() : this._lexer.token;
+			if (e && t.kind === Z.BRACE_L) throw g(this._lexer.source, this._lexer.token.start, "Unexpected description, descriptions are not supported on shorthand queries.");
+			if (t.kind === Z.NAME) {
+				switch (t.value) {
+					case "schema": return this.parseSchemaDefinition();
+					case "scalar": return this.parseScalarTypeDefinition();
+					case "type": return this.parseObjectTypeDefinition();
+					case "interface": return this.parseInterfaceTypeDefinition();
+					case "union": return this.parseUnionTypeDefinition();
+					case "enum": return this.parseEnumTypeDefinition();
+					case "input": return this.parseInputObjectTypeDefinition();
+					case "directive": return this.parseDirectiveDefinition();
+				}
+				switch (t.value) {
+					case "query":
+					case "mutation":
+					case "subscription": return this.parseOperationDefinition();
+					case "fragment": return this.parseFragmentDefinition();
+				}
+				if (e) throw g(this._lexer.source, this._lexer.token.start, "Unexpected description, only GraphQL definitions support descriptions.");
+				switch (t.value) {
+					case "extend": return this.parseTypeSystemExtension();
+				}
+			}
+			throw this.unexpected(t);
+		}
+		parseOperationDefinition() {
+			let e = this._lexer.token;
+			if (this.peek(Z.BRACE_L)) return this.node(e, {
+				kind: X.OPERATION_DEFINITION,
+				operation: W.QUERY,
+				description: void 0,
+				name: void 0,
+				variableDefinitions: [],
+				directives: [],
+				selectionSet: this.parseSelectionSet()
+			});
+			let t = this.parseDescription(), n = this.parseOperationType(), r;
+			return this.peek(Z.NAME) && (r = this.parseName()), this.node(e, {
+				kind: X.OPERATION_DEFINITION,
+				operation: n,
+				description: t,
+				name: r,
+				variableDefinitions: this.parseVariableDefinitions(),
+				directives: this.parseDirectives(!1),
+				selectionSet: this.parseSelectionSet()
+			});
+		}
+		parseOperationType() {
+			let e = this.expectToken(Z.NAME);
+			switch (e.value) {
+				case "query": return W.QUERY;
+				case "mutation": return W.MUTATION;
+				case "subscription": return W.SUBSCRIPTION;
+			}
+			throw this.unexpected(e);
+		}
+		parseVariableDefinitions() {
+			return this.optionalMany(Z.PAREN_L, this.parseVariableDefinition, Z.PAREN_R);
+		}
+		parseVariableDefinition() {
+			return this.node(this._lexer.token, {
+				kind: X.VARIABLE_DEFINITION,
+				description: this.parseDescription(),
+				variable: this.parseVariable(),
+				type: (this.expectToken(Z.COLON), this.parseTypeReference()),
+				defaultValue: this.expectOptionalToken(Z.EQUALS) ? this.parseConstValueLiteral() : void 0,
+				directives: this.parseConstDirectives()
+			});
+		}
+		parseVariable() {
+			let e = this._lexer.token;
+			return this.expectToken(Z.DOLLAR), this.node(e, {
+				kind: X.VARIABLE,
+				name: this.parseName()
+			});
+		}
+		parseSelectionSet() {
+			return this.node(this._lexer.token, {
+				kind: X.SELECTION_SET,
+				selections: this.many(Z.BRACE_L, this.parseSelection, Z.BRACE_R)
+			});
+		}
+		parseSelection() {
+			return this.peek(Z.SPREAD) ? this.parseFragment() : this.parseField();
+		}
+		parseField() {
+			let e = this._lexer.token, t = this.parseName(), n, r;
+			return this.expectOptionalToken(Z.COLON) ? (n = t, r = this.parseName()) : r = t, this.node(e, {
+				kind: X.FIELD,
+				alias: n,
+				name: r,
+				arguments: this.parseArguments(!1),
+				directives: this.parseDirectives(!1),
+				selectionSet: this.peek(Z.BRACE_L) ? this.parseSelectionSet() : void 0
+			});
+		}
+		parseArguments(e) {
+			let t = e ? this.parseConstArgument : this.parseArgument;
+			return this.optionalMany(Z.PAREN_L, t, Z.PAREN_R);
+		}
+		parseArgument(e = !1) {
+			let t = this._lexer.token, n = this.parseName();
+			return this.expectToken(Z.COLON), this.node(t, {
+				kind: X.ARGUMENT,
+				name: n,
+				value: this.parseValueLiteral(e)
+			});
+		}
+		parseConstArgument() {
+			return this.parseArgument(!0);
+		}
+		parseFragment() {
+			let e = this._lexer.token;
+			this.expectToken(Z.SPREAD);
+			let t = this.expectOptionalKeyword("on");
+			return !t && this.peek(Z.NAME) ? this.node(e, {
+				kind: X.FRAGMENT_SPREAD,
+				name: this.parseFragmentName(),
+				directives: this.parseDirectives(!1)
+			}) : this.node(e, {
+				kind: X.INLINE_FRAGMENT,
+				typeCondition: t ? this.parseNamedType() : void 0,
+				directives: this.parseDirectives(!1),
+				selectionSet: this.parseSelectionSet()
+			});
+		}
+		parseFragmentDefinition() {
+			let e = this._lexer.token, t = this.parseDescription();
+			return this.expectKeyword("fragment"), this._options.allowLegacyFragmentVariables === !0 ? this.node(e, {
+				kind: X.FRAGMENT_DEFINITION,
+				description: t,
+				name: this.parseFragmentName(),
+				variableDefinitions: this.parseVariableDefinitions(),
+				typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
+				directives: this.parseDirectives(!1),
+				selectionSet: this.parseSelectionSet()
+			}) : this.node(e, {
+				kind: X.FRAGMENT_DEFINITION,
+				description: t,
+				name: this.parseFragmentName(),
+				typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
+				directives: this.parseDirectives(!1),
+				selectionSet: this.parseSelectionSet()
+			});
+		}
+		parseFragmentName() {
+			if (this._lexer.token.value === "on") throw this.unexpected();
+			return this.parseName();
+		}
+		parseValueLiteral(e) {
+			let t = this._lexer.token;
+			switch (t.kind) {
+				case Z.BRACKET_L: return this.parseList(e);
+				case Z.BRACE_L: return this.parseObject(e);
+				case Z.INT: return this.advanceLexer(), this.node(t, {
+					kind: X.INT,
+					value: t.value
+				});
+				case Z.FLOAT: return this.advanceLexer(), this.node(t, {
+					kind: X.FLOAT,
+					value: t.value
+				});
+				case Z.STRING:
+				case Z.BLOCK_STRING: return this.parseStringLiteral();
+				case Z.NAME: switch (this.advanceLexer(), t.value) {
+					case "true": return this.node(t, {
+						kind: X.BOOLEAN,
+						value: !0
+					});
+					case "false": return this.node(t, {
+						kind: X.BOOLEAN,
+						value: !1
+					});
+					case "null": return this.node(t, { kind: X.NULL });
+					default: return this.node(t, {
+						kind: X.ENUM,
+						value: t.value
+					});
+				}
+				case Z.DOLLAR:
+					if (e) if (this.expectToken(Z.DOLLAR), this._lexer.token.kind === Z.NAME) {
+						let e = this._lexer.token.value;
+						throw g(this._lexer.source, t.start, `Unexpected variable "$${e}" in constant value.`);
+					} else throw this.unexpected(t);
+					return this.parseVariable();
+				default: throw this.unexpected();
+			}
+		}
+		parseConstValueLiteral() {
+			return this.parseValueLiteral(!0);
+		}
+		parseStringLiteral() {
+			let e = this._lexer.token;
+			return this.advanceLexer(), this.node(e, {
+				kind: X.STRING,
+				value: e.value,
+				block: e.kind === Z.BLOCK_STRING
+			});
+		}
+		parseList(e) {
+			return this.node(this._lexer.token, {
+				kind: X.LIST,
+				values: this.any(Z.BRACKET_L, () => this.parseValueLiteral(e), Z.BRACKET_R)
+			});
+		}
+		parseObject(e) {
+			return this.node(this._lexer.token, {
+				kind: X.OBJECT,
+				fields: this.any(Z.BRACE_L, () => this.parseObjectField(e), Z.BRACE_R)
+			});
+		}
+		parseObjectField(e) {
+			let t = this._lexer.token, n = this.parseName();
+			return this.expectToken(Z.COLON), this.node(t, {
+				kind: X.OBJECT_FIELD,
+				name: n,
+				value: this.parseValueLiteral(e)
+			});
+		}
+		parseDirectives(e) {
+			let t = [];
+			for (; this.peek(Z.AT);) t.push(this.parseDirective(e));
+			return t;
+		}
+		parseConstDirectives() {
+			return this.parseDirectives(!0);
+		}
+		parseDirective(e) {
+			let t = this._lexer.token;
+			return this.expectToken(Z.AT), this.node(t, {
+				kind: X.DIRECTIVE,
+				name: this.parseName(),
+				arguments: this.parseArguments(e)
+			});
+		}
+		parseTypeReference() {
+			let e = this._lexer.token, t;
+			if (this.expectOptionalToken(Z.BRACKET_L)) {
+				let n = this.parseTypeReference();
+				this.expectToken(Z.BRACKET_R), t = this.node(e, {
+					kind: X.LIST_TYPE,
+					type: n
+				});
+			} else t = this.parseNamedType();
+			return this.expectOptionalToken(Z.BANG) ? this.node(e, {
+				kind: X.NON_NULL_TYPE,
+				type: t
+			}) : t;
+		}
+		parseNamedType() {
+			return this.node(this._lexer.token, {
+				kind: X.NAMED_TYPE,
+				name: this.parseName()
+			});
+		}
+		peekDescription() {
+			return this.peek(Z.STRING) || this.peek(Z.BLOCK_STRING);
+		}
+		parseDescription() {
+			if (this.peekDescription()) return this.parseStringLiteral();
+		}
+		parseSchemaDefinition() {
+			let e = this._lexer.token, t = this.parseDescription();
+			this.expectKeyword("schema");
+			let n = this.parseConstDirectives(), r = this.many(Z.BRACE_L, this.parseOperationTypeDefinition, Z.BRACE_R);
+			return this.node(e, {
+				kind: X.SCHEMA_DEFINITION,
+				description: t,
+				directives: n,
+				operationTypes: r
+			});
+		}
+		parseOperationTypeDefinition() {
+			let e = this._lexer.token, t = this.parseOperationType();
+			this.expectToken(Z.COLON);
+			let n = this.parseNamedType();
+			return this.node(e, {
+				kind: X.OPERATION_TYPE_DEFINITION,
+				operation: t,
+				type: n
+			});
+		}
+		parseScalarTypeDefinition() {
+			let e = this._lexer.token, t = this.parseDescription();
+			this.expectKeyword("scalar");
+			let n = this.parseName(), r = this.parseConstDirectives();
+			return this.node(e, {
+				kind: X.SCALAR_TYPE_DEFINITION,
+				description: t,
+				name: n,
+				directives: r
+			});
+		}
+		parseObjectTypeDefinition() {
+			let e = this._lexer.token, t = this.parseDescription();
+			this.expectKeyword("type");
+			let n = this.parseName(), r = this.parseImplementsInterfaces(), i = this.parseConstDirectives(), a = this.parseFieldsDefinition();
+			return this.node(e, {
+				kind: X.OBJECT_TYPE_DEFINITION,
+				description: t,
+				name: n,
+				interfaces: r,
+				directives: i,
+				fields: a
+			});
+		}
+		parseImplementsInterfaces() {
+			return this.expectOptionalKeyword("implements") ? this.delimitedMany(Z.AMP, this.parseNamedType) : [];
+		}
+		parseFieldsDefinition() {
+			return this.optionalMany(Z.BRACE_L, this.parseFieldDefinition, Z.BRACE_R);
+		}
+		parseFieldDefinition() {
+			let e = this._lexer.token, t = this.parseDescription(), n = this.parseName(), r = this.parseArgumentDefs();
+			this.expectToken(Z.COLON);
+			let i = this.parseTypeReference(), a = this.parseConstDirectives();
+			return this.node(e, {
+				kind: X.FIELD_DEFINITION,
+				description: t,
+				name: n,
+				arguments: r,
+				type: i,
+				directives: a
+			});
+		}
+		parseArgumentDefs() {
+			return this.optionalMany(Z.PAREN_L, this.parseInputValueDef, Z.PAREN_R);
+		}
+		parseInputValueDef() {
+			let e = this._lexer.token, t = this.parseDescription(), n = this.parseName();
+			this.expectToken(Z.COLON);
+			let r = this.parseTypeReference(), i;
+			this.expectOptionalToken(Z.EQUALS) && (i = this.parseConstValueLiteral());
+			let a = this.parseConstDirectives();
+			return this.node(e, {
+				kind: X.INPUT_VALUE_DEFINITION,
+				description: t,
+				name: n,
+				type: r,
+				defaultValue: i,
+				directives: a
+			});
+		}
+		parseInterfaceTypeDefinition() {
+			let e = this._lexer.token, t = this.parseDescription();
+			this.expectKeyword("interface");
+			let n = this.parseName(), r = this.parseImplementsInterfaces(), i = this.parseConstDirectives(), a = this.parseFieldsDefinition();
+			return this.node(e, {
+				kind: X.INTERFACE_TYPE_DEFINITION,
+				description: t,
+				name: n,
+				interfaces: r,
+				directives: i,
+				fields: a
+			});
+		}
+		parseUnionTypeDefinition() {
+			let e = this._lexer.token, t = this.parseDescription();
+			this.expectKeyword("union");
+			let n = this.parseName(), r = this.parseConstDirectives(), i = this.parseUnionMemberTypes();
+			return this.node(e, {
+				kind: X.UNION_TYPE_DEFINITION,
+				description: t,
+				name: n,
+				directives: r,
+				types: i
+			});
+		}
+		parseUnionMemberTypes() {
+			return this.expectOptionalToken(Z.EQUALS) ? this.delimitedMany(Z.PIPE, this.parseNamedType) : [];
+		}
+		parseEnumTypeDefinition() {
+			let e = this._lexer.token, t = this.parseDescription();
+			this.expectKeyword("enum");
+			let n = this.parseName(), r = this.parseConstDirectives(), i = this.parseEnumValuesDefinition();
+			return this.node(e, {
+				kind: X.ENUM_TYPE_DEFINITION,
+				description: t,
+				name: n,
+				directives: r,
+				values: i
+			});
+		}
+		parseEnumValuesDefinition() {
+			return this.optionalMany(Z.BRACE_L, this.parseEnumValueDefinition, Z.BRACE_R);
+		}
+		parseEnumValueDefinition() {
+			let e = this._lexer.token, t = this.parseDescription(), n = this.parseEnumValueName(), r = this.parseConstDirectives();
+			return this.node(e, {
+				kind: X.ENUM_VALUE_DEFINITION,
+				description: t,
+				name: n,
+				directives: r
+			});
+		}
+		parseEnumValueName() {
+			if (this._lexer.token.value === "true" || this._lexer.token.value === "false" || this._lexer.token.value === "null") throw g(this._lexer.source, this._lexer.token.start, `${E(this._lexer.token)} is reserved and cannot be used for an enum value.`);
+			return this.parseName();
+		}
+		parseInputObjectTypeDefinition() {
+			let e = this._lexer.token, t = this.parseDescription();
+			this.expectKeyword("input");
+			let n = this.parseName(), r = this.parseConstDirectives(), i = this.parseInputFieldsDefinition();
+			return this.node(e, {
+				kind: X.INPUT_OBJECT_TYPE_DEFINITION,
+				description: t,
+				name: n,
+				directives: r,
+				fields: i
+			});
+		}
+		parseInputFieldsDefinition() {
+			return this.optionalMany(Z.BRACE_L, this.parseInputValueDef, Z.BRACE_R);
+		}
+		parseTypeSystemExtension() {
+			let e = this._lexer.lookahead();
+			if (e.kind === Z.NAME) switch (e.value) {
+				case "schema": return this.parseSchemaExtension();
+				case "scalar": return this.parseScalarTypeExtension();
+				case "type": return this.parseObjectTypeExtension();
+				case "interface": return this.parseInterfaceTypeExtension();
+				case "union": return this.parseUnionTypeExtension();
+				case "enum": return this.parseEnumTypeExtension();
+				case "input": return this.parseInputObjectTypeExtension();
+			}
+			throw this.unexpected(e);
+		}
+		parseSchemaExtension() {
+			let e = this._lexer.token;
+			this.expectKeyword("extend"), this.expectKeyword("schema");
+			let t = this.parseConstDirectives(), n = this.optionalMany(Z.BRACE_L, this.parseOperationTypeDefinition, Z.BRACE_R);
+			if (t.length === 0 && n.length === 0) throw this.unexpected();
+			return this.node(e, {
+				kind: X.SCHEMA_EXTENSION,
+				directives: t,
+				operationTypes: n
+			});
+		}
+		parseScalarTypeExtension() {
+			let e = this._lexer.token;
+			this.expectKeyword("extend"), this.expectKeyword("scalar");
+			let t = this.parseName(), n = this.parseConstDirectives();
+			if (n.length === 0) throw this.unexpected();
+			return this.node(e, {
+				kind: X.SCALAR_TYPE_EXTENSION,
+				name: t,
+				directives: n
+			});
+		}
+		parseObjectTypeExtension() {
+			let e = this._lexer.token;
+			this.expectKeyword("extend"), this.expectKeyword("type");
+			let t = this.parseName(), n = this.parseImplementsInterfaces(), r = this.parseConstDirectives(), i = this.parseFieldsDefinition();
+			if (n.length === 0 && r.length === 0 && i.length === 0) throw this.unexpected();
+			return this.node(e, {
+				kind: X.OBJECT_TYPE_EXTENSION,
+				name: t,
+				interfaces: n,
+				directives: r,
+				fields: i
+			});
+		}
+		parseInterfaceTypeExtension() {
+			let e = this._lexer.token;
+			this.expectKeyword("extend"), this.expectKeyword("interface");
+			let t = this.parseName(), n = this.parseImplementsInterfaces(), r = this.parseConstDirectives(), i = this.parseFieldsDefinition();
+			if (n.length === 0 && r.length === 0 && i.length === 0) throw this.unexpected();
+			return this.node(e, {
+				kind: X.INTERFACE_TYPE_EXTENSION,
+				name: t,
+				interfaces: n,
+				directives: r,
+				fields: i
+			});
+		}
+		parseUnionTypeExtension() {
+			let e = this._lexer.token;
+			this.expectKeyword("extend"), this.expectKeyword("union");
+			let t = this.parseName(), n = this.parseConstDirectives(), r = this.parseUnionMemberTypes();
+			if (n.length === 0 && r.length === 0) throw this.unexpected();
+			return this.node(e, {
+				kind: X.UNION_TYPE_EXTENSION,
+				name: t,
+				directives: n,
+				types: r
+			});
+		}
+		parseEnumTypeExtension() {
+			let e = this._lexer.token;
+			this.expectKeyword("extend"), this.expectKeyword("enum");
+			let t = this.parseName(), n = this.parseConstDirectives(), r = this.parseEnumValuesDefinition();
+			if (n.length === 0 && r.length === 0) throw this.unexpected();
+			return this.node(e, {
+				kind: X.ENUM_TYPE_EXTENSION,
+				name: t,
+				directives: n,
+				values: r
+			});
+		}
+		parseInputObjectTypeExtension() {
+			let e = this._lexer.token;
+			this.expectKeyword("extend"), this.expectKeyword("input");
+			let t = this.parseName(), n = this.parseConstDirectives(), r = this.parseInputFieldsDefinition();
+			if (n.length === 0 && r.length === 0) throw this.unexpected();
+			return this.node(e, {
+				kind: X.INPUT_OBJECT_TYPE_EXTENSION,
+				name: t,
+				directives: n,
+				fields: r
+			});
+		}
+		parseDirectiveDefinition() {
+			let e = this._lexer.token, t = this.parseDescription();
+			this.expectKeyword("directive"), this.expectToken(Z.AT);
+			let n = this.parseName(), r = this.parseArgumentDefs(), i = this.expectOptionalKeyword("repeatable");
+			this.expectKeyword("on");
+			let a = this.parseDirectiveLocations();
+			return this.node(e, {
+				kind: X.DIRECTIVE_DEFINITION,
+				description: t,
+				name: n,
+				arguments: r,
+				repeatable: i,
+				locations: a
+			});
+		}
+		parseDirectiveLocations() {
+			return this.delimitedMany(Z.PIPE, this.parseDirectiveLocation);
+		}
+		parseDirectiveLocation() {
+			let e = this._lexer.token, t = this.parseName();
+			if (Object.prototype.hasOwnProperty.call(Dt, t.value)) return t;
+			throw this.unexpected(e);
+		}
+		parseSchemaCoordinate() {
+			let e = this._lexer.token, t = this.expectOptionalToken(Z.AT), n = this.parseName(), r;
+			!t && this.expectOptionalToken(Z.DOT) && (r = this.parseName());
+			let i;
+			return (t || r) && this.expectOptionalToken(Z.PAREN_L) && (i = this.parseName(), this.expectToken(Z.COLON), this.expectToken(Z.PAREN_R)), t ? i ? this.node(e, {
+				kind: X.DIRECTIVE_ARGUMENT_COORDINATE,
+				name: n,
+				argumentName: i
+			}) : this.node(e, {
+				kind: X.DIRECTIVE_COORDINATE,
+				name: n
+			}) : r ? i ? this.node(e, {
+				kind: X.ARGUMENT_COORDINATE,
+				name: n,
+				fieldName: r,
+				argumentName: i
+			}) : this.node(e, {
+				kind: X.MEMBER_COORDINATE,
+				name: n,
+				memberName: r
+			}) : this.node(e, {
+				kind: X.TYPE_COORDINATE,
+				name: n
+			});
+		}
+		node(e, t) {
+			return this._options.noLocation !== !0 && (t.loc = new mt(e, this._lexer.lastToken, this._lexer.source)), t;
+		}
+		peek(e) {
+			return this._lexer.token.kind === e;
+		}
+		expectToken(e) {
+			let t = this._lexer.token;
+			if (t.kind === e) return this.advanceLexer(), t;
+			throw g(this._lexer.source, t.start, `Expected ${We(e)}, found ${E(t)}.`);
+		}
+		expectOptionalToken(e) {
+			return this._lexer.token.kind === e ? (this.advanceLexer(), !0) : !1;
+		}
+		expectKeyword(e) {
+			let t = this._lexer.token;
+			if (t.kind === Z.NAME && t.value === e) this.advanceLexer();
+			else throw g(this._lexer.source, t.start, `Expected "${e}", found ${E(t)}.`);
+		}
+		expectOptionalKeyword(e) {
+			let t = this._lexer.token;
+			return t.kind === Z.NAME && t.value === e ? (this.advanceLexer(), !0) : !1;
+		}
+		unexpected(e) {
+			let t = e ?? this._lexer.token;
+			return g(this._lexer.source, t.start, `Unexpected ${E(t)}.`);
+		}
+		any(e, t, n) {
+			this.expectToken(e);
+			let r = [];
+			for (; !this.expectOptionalToken(n);) r.push(t.call(this));
+			return r;
+		}
+		optionalMany(e, t, n) {
+			if (this.expectOptionalToken(e)) {
+				let e = [];
+				do
+					e.push(t.call(this));
+				while (!this.expectOptionalToken(n));
+				return e;
+			}
+			return [];
+		}
+		many(e, t, n) {
+			this.expectToken(e);
+			let r = [];
+			do
+				r.push(t.call(this));
+			while (!this.expectOptionalToken(n));
+			return r;
+		}
+		delimitedMany(e, t) {
+			this.expectOptionalToken(e);
+			let n = [];
+			do
+				n.push(t.call(this));
+			while (this.expectOptionalToken(e));
+			return n;
+		}
+		advanceLexer() {
+			let { maxTokens: e } = this._options, t = this._lexer.advance();
+			if (t.kind !== Z.EOF && (++this._tokenCounter, e !== void 0 && this._tokenCounter > e)) throw g(this._lexer.source, t.start, `Document contains more that ${e} tokens. Parsing aborted.`);
+		}
+	}, jt = Ge, Mt = { allowLegacyFragmentVariables: !0 }, Nt = {
+		parse: Je,
+		astFormat: "graphql",
+		hasPragma: bt,
+		hasIgnorePragma: xt,
+		locStart: K,
+		locEnd: gt
+	}, $ = { graphql: Ct };
+}))();
+export { O as default, wt as languages, J as options, Y as parsers, $ as printers };