@burdenoff/microfe-eventfullymanaged 2026.510.105

package/dist/node_modules/graphql/language/location.js

@@ -0,0 +1,18 @@
+import { invariant as e } from "../jsutils/invariant.js";
+//#region node_modules/graphql/language/location.mjs
+var t = /\r\n|[\n\r]/g;
+function n(n, r) {
+	let i = 0, a = 1;
+	for (let o of n.body.matchAll(t)) {
+		if (typeof o.index == "number" || e(!1), o.index >= r) break;
+		i = o.index + o[0].length, a += 1;
+	}
+	return {
+		line: a,
+		column: r + 1 - i
+	};
+}
+//#endregion
+export { n as getLocation };
+
+//# sourceMappingURL=location.js.map

package/dist/node_modules/graphql/language/location.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"location.js","names":[],"sources":["../../../../node_modules/graphql/language/location.mjs"],"sourcesContent":["import { invariant } from '../jsutils/invariant.mjs';\nconst LineRegExp = /\\r\\n|[\\n\\r]/g;\n/**\n * Represents a location in a Source.\n */\n\n/**\n * Takes a Source and a UTF-8 character offset, and returns the corresponding\n * line and column as a SourceLocation.\n */\nexport function getLocation(source, position) {\n  let lastLineStart = 0;\n  let line = 1;\n\n  for (const match of source.body.matchAll(LineRegExp)) {\n    typeof match.index === 'number' || invariant(false);\n\n    if (match.index >= position) {\n      break;\n    }\n\n    lastLineStart = match.index + match[0].length;\n    line += 1;\n  }\n\n  return {\n    line,\n    column: position + 1 - lastLineStart,\n  };\n}\n"],"x_google_ignoreList":[0],"mappings":";;AACA,IAAM,IAAa;AASnB,SAAgB,EAAY,GAAQ,GAAU;CAC5C,IAAI,IAAgB,GAChB,IAAO;AAEX,MAAK,IAAM,KAAS,EAAO,KAAK,SAAS,EAAW,EAAE;AAGpD,MAFA,OAAO,EAAM,SAAU,YAAY,EAAU,GAAM,EAE/C,EAAM,SAAS,EACjB;AAIF,EADA,IAAgB,EAAM,QAAQ,EAAM,GAAG,QACvC,KAAQ;;AAGV,QAAO;EACL;EACA,QAAQ,IAAW,IAAI;EACxB"}

package/dist/node_modules/graphql/language/parser.js

@@ -0,0 +1,688 @@
+import { syntaxError as e } from "../error/syntaxError.js";
+import { Location as t, OperationTypeNode as n } from "./ast.js";
+import { DirectiveLocation as r } from "./directiveLocation.js";
+import { Kind as i } from "./kinds.js";
+import { TokenKind as a } from "./tokenKind.js";
+import { Lexer as o, isPunctuatorTokenKind as s } from "./lexer.js";
+import { Source as c, isSource as l } from "./source.js";
+//#region node_modules/graphql/language/parser.mjs
+function u(e, t) {
+	let n = new d(e, t), r = n.parseDocument();
+	return Object.defineProperty(r, "tokenCount", {
+		enumerable: !1,
+		value: n.tokenCount
+	}), r;
+}
+var d = class {
+	constructor(e, t = {}) {
+		let { lexer: n, ...r } = t;
+		n ? this._lexer = n : this._lexer = new o(l(e) ? e : new c(e)), this._options = r, this._tokenCounter = 0;
+	}
+	get tokenCount() {
+		return this._tokenCounter;
+	}
+	parseName() {
+		let e = this.expectToken(a.NAME);
+		return this.node(e, {
+			kind: i.NAME,
+			value: e.value
+		});
+	}
+	parseDocument() {
+		return this.node(this._lexer.token, {
+			kind: i.DOCUMENT,
+			definitions: this.many(a.SOF, this.parseDefinition, a.EOF)
+		});
+	}
+	parseDefinition() {
+		if (this.peek(a.BRACE_L)) return this.parseOperationDefinition();
+		let t = this.peekDescription(), n = t ? this._lexer.lookahead() : this._lexer.token;
+		if (t && n.kind === a.BRACE_L) throw e(this._lexer.source, this._lexer.token.start, "Unexpected description, descriptions are not supported on shorthand queries.");
+		if (n.kind === a.NAME) {
+			switch (n.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 (n.value) {
+				case "query":
+				case "mutation":
+				case "subscription": return this.parseOperationDefinition();
+				case "fragment": return this.parseFragmentDefinition();
+			}
+			if (t) throw e(this._lexer.source, this._lexer.token.start, "Unexpected description, only GraphQL definitions support descriptions.");
+			switch (n.value) {
+				case "extend": return this.parseTypeSystemExtension();
+			}
+		}
+		throw this.unexpected(n);
+	}
+	parseOperationDefinition() {
+		let e = this._lexer.token;
+		if (this.peek(a.BRACE_L)) return this.node(e, {
+			kind: i.OPERATION_DEFINITION,
+			operation: n.QUERY,
+			description: void 0,
+			name: void 0,
+			variableDefinitions: [],
+			directives: [],
+			selectionSet: this.parseSelectionSet()
+		});
+		let t = this.parseDescription(), r = this.parseOperationType(), o;
+		return this.peek(a.NAME) && (o = this.parseName()), this.node(e, {
+			kind: i.OPERATION_DEFINITION,
+			operation: r,
+			description: t,
+			name: o,
+			variableDefinitions: this.parseVariableDefinitions(),
+			directives: this.parseDirectives(!1),
+			selectionSet: this.parseSelectionSet()
+		});
+	}
+	parseOperationType() {
+		let e = this.expectToken(a.NAME);
+		switch (e.value) {
+			case "query": return n.QUERY;
+			case "mutation": return n.MUTATION;
+			case "subscription": return n.SUBSCRIPTION;
+		}
+		throw this.unexpected(e);
+	}
+	parseVariableDefinitions() {
+		return this.optionalMany(a.PAREN_L, this.parseVariableDefinition, a.PAREN_R);
+	}
+	parseVariableDefinition() {
+		return this.node(this._lexer.token, {
+			kind: i.VARIABLE_DEFINITION,
+			description: this.parseDescription(),
+			variable: this.parseVariable(),
+			type: (this.expectToken(a.COLON), this.parseTypeReference()),
+			defaultValue: this.expectOptionalToken(a.EQUALS) ? this.parseConstValueLiteral() : void 0,
+			directives: this.parseConstDirectives()
+		});
+	}
+	parseVariable() {
+		let e = this._lexer.token;
+		return this.expectToken(a.DOLLAR), this.node(e, {
+			kind: i.VARIABLE,
+			name: this.parseName()
+		});
+	}
+	parseSelectionSet() {
+		return this.node(this._lexer.token, {
+			kind: i.SELECTION_SET,
+			selections: this.many(a.BRACE_L, this.parseSelection, a.BRACE_R)
+		});
+	}
+	parseSelection() {
+		return this.peek(a.SPREAD) ? this.parseFragment() : this.parseField();
+	}
+	parseField() {
+		let e = this._lexer.token, t = this.parseName(), n, r;
+		return this.expectOptionalToken(a.COLON) ? (n = t, r = this.parseName()) : r = t, this.node(e, {
+			kind: i.FIELD,
+			alias: n,
+			name: r,
+			arguments: this.parseArguments(!1),
+			directives: this.parseDirectives(!1),
+			selectionSet: this.peek(a.BRACE_L) ? this.parseSelectionSet() : void 0
+		});
+	}
+	parseArguments(e) {
+		let t = e ? this.parseConstArgument : this.parseArgument;
+		return this.optionalMany(a.PAREN_L, t, a.PAREN_R);
+	}
+	parseArgument(e = !1) {
+		let t = this._lexer.token, n = this.parseName();
+		return this.expectToken(a.COLON), this.node(t, {
+			kind: i.ARGUMENT,
+			name: n,
+			value: this.parseValueLiteral(e)
+		});
+	}
+	parseConstArgument() {
+		return this.parseArgument(!0);
+	}
+	parseFragment() {
+		let e = this._lexer.token;
+		this.expectToken(a.SPREAD);
+		let t = this.expectOptionalKeyword("on");
+		return !t && this.peek(a.NAME) ? this.node(e, {
+			kind: i.FRAGMENT_SPREAD,
+			name: this.parseFragmentName(),
+			directives: this.parseDirectives(!1)
+		}) : this.node(e, {
+			kind: i.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: i.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: i.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(t) {
+		let n = this._lexer.token;
+		switch (n.kind) {
+			case a.BRACKET_L: return this.parseList(t);
+			case a.BRACE_L: return this.parseObject(t);
+			case a.INT: return this.advanceLexer(), this.node(n, {
+				kind: i.INT,
+				value: n.value
+			});
+			case a.FLOAT: return this.advanceLexer(), this.node(n, {
+				kind: i.FLOAT,
+				value: n.value
+			});
+			case a.STRING:
+			case a.BLOCK_STRING: return this.parseStringLiteral();
+			case a.NAME: switch (this.advanceLexer(), n.value) {
+				case "true": return this.node(n, {
+					kind: i.BOOLEAN,
+					value: !0
+				});
+				case "false": return this.node(n, {
+					kind: i.BOOLEAN,
+					value: !1
+				});
+				case "null": return this.node(n, { kind: i.NULL });
+				default: return this.node(n, {
+					kind: i.ENUM,
+					value: n.value
+				});
+			}
+			case a.DOLLAR:
+				if (t) if (this.expectToken(a.DOLLAR), this._lexer.token.kind === a.NAME) {
+					let t = this._lexer.token.value;
+					throw e(this._lexer.source, n.start, `Unexpected variable "$${t}" in constant value.`);
+				} else throw this.unexpected(n);
+				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: i.STRING,
+			value: e.value,
+			block: e.kind === a.BLOCK_STRING
+		});
+	}
+	parseList(e) {
+		return this.node(this._lexer.token, {
+			kind: i.LIST,
+			values: this.any(a.BRACKET_L, () => this.parseValueLiteral(e), a.BRACKET_R)
+		});
+	}
+	parseObject(e) {
+		return this.node(this._lexer.token, {
+			kind: i.OBJECT,
+			fields: this.any(a.BRACE_L, () => this.parseObjectField(e), a.BRACE_R)
+		});
+	}
+	parseObjectField(e) {
+		let t = this._lexer.token, n = this.parseName();
+		return this.expectToken(a.COLON), this.node(t, {
+			kind: i.OBJECT_FIELD,
+			name: n,
+			value: this.parseValueLiteral(e)
+		});
+	}
+	parseDirectives(e) {
+		let t = [];
+		for (; this.peek(a.AT);) t.push(this.parseDirective(e));
+		return t;
+	}
+	parseConstDirectives() {
+		return this.parseDirectives(!0);
+	}
+	parseDirective(e) {
+		let t = this._lexer.token;
+		return this.expectToken(a.AT), this.node(t, {
+			kind: i.DIRECTIVE,
+			name: this.parseName(),
+			arguments: this.parseArguments(e)
+		});
+	}
+	parseTypeReference() {
+		let e = this._lexer.token, t;
+		if (this.expectOptionalToken(a.BRACKET_L)) {
+			let n = this.parseTypeReference();
+			this.expectToken(a.BRACKET_R), t = this.node(e, {
+				kind: i.LIST_TYPE,
+				type: n
+			});
+		} else t = this.parseNamedType();
+		return this.expectOptionalToken(a.BANG) ? this.node(e, {
+			kind: i.NON_NULL_TYPE,
+			type: t
+		}) : t;
+	}
+	parseNamedType() {
+		return this.node(this._lexer.token, {
+			kind: i.NAMED_TYPE,
+			name: this.parseName()
+		});
+	}
+	peekDescription() {
+		return this.peek(a.STRING) || this.peek(a.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(a.BRACE_L, this.parseOperationTypeDefinition, a.BRACE_R);
+		return this.node(e, {
+			kind: i.SCHEMA_DEFINITION,
+			description: t,
+			directives: n,
+			operationTypes: r
+		});
+	}
+	parseOperationTypeDefinition() {
+		let e = this._lexer.token, t = this.parseOperationType();
+		this.expectToken(a.COLON);
+		let n = this.parseNamedType();
+		return this.node(e, {
+			kind: i.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: i.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(), a = this.parseConstDirectives(), o = this.parseFieldsDefinition();
+		return this.node(e, {
+			kind: i.OBJECT_TYPE_DEFINITION,
+			description: t,
+			name: n,
+			interfaces: r,
+			directives: a,
+			fields: o
+		});
+	}
+	parseImplementsInterfaces() {
+		return this.expectOptionalKeyword("implements") ? this.delimitedMany(a.AMP, this.parseNamedType) : [];
+	}
+	parseFieldsDefinition() {
+		return this.optionalMany(a.BRACE_L, this.parseFieldDefinition, a.BRACE_R);
+	}
+	parseFieldDefinition() {
+		let e = this._lexer.token, t = this.parseDescription(), n = this.parseName(), r = this.parseArgumentDefs();
+		this.expectToken(a.COLON);
+		let o = this.parseTypeReference(), s = this.parseConstDirectives();
+		return this.node(e, {
+			kind: i.FIELD_DEFINITION,
+			description: t,
+			name: n,
+			arguments: r,
+			type: o,
+			directives: s
+		});
+	}
+	parseArgumentDefs() {
+		return this.optionalMany(a.PAREN_L, this.parseInputValueDef, a.PAREN_R);
+	}
+	parseInputValueDef() {
+		let e = this._lexer.token, t = this.parseDescription(), n = this.parseName();
+		this.expectToken(a.COLON);
+		let r = this.parseTypeReference(), o;
+		this.expectOptionalToken(a.EQUALS) && (o = this.parseConstValueLiteral());
+		let s = this.parseConstDirectives();
+		return this.node(e, {
+			kind: i.INPUT_VALUE_DEFINITION,
+			description: t,
+			name: n,
+			type: r,
+			defaultValue: o,
+			directives: s
+		});
+	}
+	parseInterfaceTypeDefinition() {
+		let e = this._lexer.token, t = this.parseDescription();
+		this.expectKeyword("interface");
+		let n = this.parseName(), r = this.parseImplementsInterfaces(), a = this.parseConstDirectives(), o = this.parseFieldsDefinition();
+		return this.node(e, {
+			kind: i.INTERFACE_TYPE_DEFINITION,
+			description: t,
+			name: n,
+			interfaces: r,
+			directives: a,
+			fields: o
+		});
+	}
+	parseUnionTypeDefinition() {
+		let e = this._lexer.token, t = this.parseDescription();
+		this.expectKeyword("union");
+		let n = this.parseName(), r = this.parseConstDirectives(), a = this.parseUnionMemberTypes();
+		return this.node(e, {
+			kind: i.UNION_TYPE_DEFINITION,
+			description: t,
+			name: n,
+			directives: r,
+			types: a
+		});
+	}
+	parseUnionMemberTypes() {
+		return this.expectOptionalToken(a.EQUALS) ? this.delimitedMany(a.PIPE, this.parseNamedType) : [];
+	}
+	parseEnumTypeDefinition() {
+		let e = this._lexer.token, t = this.parseDescription();
+		this.expectKeyword("enum");
+		let n = this.parseName(), r = this.parseConstDirectives(), a = this.parseEnumValuesDefinition();
+		return this.node(e, {
+			kind: i.ENUM_TYPE_DEFINITION,
+			description: t,
+			name: n,
+			directives: r,
+			values: a
+		});
+	}
+	parseEnumValuesDefinition() {
+		return this.optionalMany(a.BRACE_L, this.parseEnumValueDefinition, a.BRACE_R);
+	}
+	parseEnumValueDefinition() {
+		let e = this._lexer.token, t = this.parseDescription(), n = this.parseEnumValueName(), r = this.parseConstDirectives();
+		return this.node(e, {
+			kind: i.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 e(this._lexer.source, this._lexer.token.start, `${f(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(), a = this.parseInputFieldsDefinition();
+		return this.node(e, {
+			kind: i.INPUT_OBJECT_TYPE_DEFINITION,
+			description: t,
+			name: n,
+			directives: r,
+			fields: a
+		});
+	}
+	parseInputFieldsDefinition() {
+		return this.optionalMany(a.BRACE_L, this.parseInputValueDef, a.BRACE_R);
+	}
+	parseTypeSystemExtension() {
+		let e = this._lexer.lookahead();
+		if (e.kind === a.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();
+			case "directive":
+				if (this._options.experimentalDirectivesOnDirectiveDefinitions) return this.parseDirectiveDefinitionExtension();
+				break;
+		}
+		throw this.unexpected(e);
+	}
+	parseSchemaExtension() {
+		let e = this._lexer.token;
+		this.expectKeyword("extend"), this.expectKeyword("schema");
+		let t = this.parseConstDirectives(), n = this.optionalMany(a.BRACE_L, this.parseOperationTypeDefinition, a.BRACE_R);
+		if (t.length === 0 && n.length === 0) throw this.unexpected();
+		return this.node(e, {
+			kind: i.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: i.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(), a = this.parseFieldsDefinition();
+		if (n.length === 0 && r.length === 0 && a.length === 0) throw this.unexpected();
+		return this.node(e, {
+			kind: i.OBJECT_TYPE_EXTENSION,
+			name: t,
+			interfaces: n,
+			directives: r,
+			fields: a
+		});
+	}
+	parseInterfaceTypeExtension() {
+		let e = this._lexer.token;
+		this.expectKeyword("extend"), this.expectKeyword("interface");
+		let t = this.parseName(), n = this.parseImplementsInterfaces(), r = this.parseConstDirectives(), a = this.parseFieldsDefinition();
+		if (n.length === 0 && r.length === 0 && a.length === 0) throw this.unexpected();
+		return this.node(e, {
+			kind: i.INTERFACE_TYPE_EXTENSION,
+			name: t,
+			interfaces: n,
+			directives: r,
+			fields: a
+		});
+	}
+	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: i.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: i.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: i.INPUT_OBJECT_TYPE_EXTENSION,
+			name: t,
+			directives: n,
+			fields: r
+		});
+	}
+	parseDirectiveDefinitionExtension() {
+		let e = this._lexer.token;
+		this.expectKeyword("extend"), this.expectKeyword("directive"), this.expectToken(a.AT);
+		let t = this.parseName(), n = this.parseConstDirectives();
+		if (n.length === 0) throw this.unexpected();
+		return this.node(e, {
+			kind: i.DIRECTIVE_EXTENSION,
+			name: t,
+			directives: n
+		});
+	}
+	parseDirectiveDefinition() {
+		let e = this._lexer.token, t = this.parseDescription();
+		this.expectKeyword("directive"), this.expectToken(a.AT);
+		let n = this.parseName(), r = this.parseArgumentDefs(), o = this._options.experimentalDirectivesOnDirectiveDefinitions ? this.parseConstDirectives() : [], s = this.expectOptionalKeyword("repeatable");
+		this.expectKeyword("on");
+		let c = this.parseDirectiveLocations();
+		return this.node(e, {
+			kind: i.DIRECTIVE_DEFINITION,
+			description: t,
+			name: n,
+			arguments: r,
+			directives: o,
+			repeatable: s,
+			locations: c
+		});
+	}
+	parseDirectiveLocations() {
+		return this.delimitedMany(a.PIPE, this.parseDirectiveLocation);
+	}
+	parseDirectiveLocation() {
+		let e = this._lexer.token, t = this.parseName();
+		if (Object.prototype.hasOwnProperty.call(r, t.value)) return t;
+		throw this.unexpected(e);
+	}
+	parseSchemaCoordinate() {
+		let e = this._lexer.token, t = this.expectOptionalToken(a.AT), n = this.parseName(), r;
+		!t && this.expectOptionalToken(a.DOT) && (r = this.parseName());
+		let o;
+		return (t || r) && this.expectOptionalToken(a.PAREN_L) && (o = this.parseName(), this.expectToken(a.COLON), this.expectToken(a.PAREN_R)), t ? o ? this.node(e, {
+			kind: i.DIRECTIVE_ARGUMENT_COORDINATE,
+			name: n,
+			argumentName: o
+		}) : this.node(e, {
+			kind: i.DIRECTIVE_COORDINATE,
+			name: n
+		}) : r ? o ? this.node(e, {
+			kind: i.ARGUMENT_COORDINATE,
+			name: n,
+			fieldName: r,
+			argumentName: o
+		}) : this.node(e, {
+			kind: i.MEMBER_COORDINATE,
+			name: n,
+			memberName: r
+		}) : this.node(e, {
+			kind: i.TYPE_COORDINATE,
+			name: n
+		});
+	}
+	node(e, n) {
+		return this._options.noLocation !== !0 && (n.loc = new t(e, this._lexer.lastToken, this._lexer.source)), n;
+	}
+	peek(e) {
+		return this._lexer.token.kind === e;
+	}
+	expectToken(t) {
+		let n = this._lexer.token;
+		if (n.kind === t) return this.advanceLexer(), n;
+		throw e(this._lexer.source, n.start, `Expected ${p(t)}, found ${f(n)}.`);
+	}
+	expectOptionalToken(e) {
+		return this._lexer.token.kind === e ? (this.advanceLexer(), !0) : !1;
+	}
+	expectKeyword(t) {
+		let n = this._lexer.token;
+		if (n.kind === a.NAME && n.value === t) this.advanceLexer();
+		else throw e(this._lexer.source, n.start, `Expected "${t}", found ${f(n)}.`);
+	}
+	expectOptionalKeyword(e) {
+		let t = this._lexer.token;
+		return t.kind === a.NAME && t.value === e ? (this.advanceLexer(), !0) : !1;
+	}
+	unexpected(t) {
+		let n = t ?? this._lexer.token;
+		return e(this._lexer.source, n.start, `Unexpected ${f(n)}.`);
+	}
+	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: t } = this._options, n = this._lexer.advance();
+		if (n.kind !== a.EOF && (++this._tokenCounter, t !== void 0 && this._tokenCounter > t)) throw e(this._lexer.source, n.start, `Document contains more that ${t} tokens. Parsing aborted.`);
+	}
+};
+function f(e) {
+	let t = e.value;
+	return p(e.kind) + (t == null ? "" : ` "${t}"`);
+}
+function p(e) {
+	return s(e) ? `"${e}"` : e;
+}
+//#endregion
+export { u as parse };
+
+//# sourceMappingURL=parser.js.map