{"version":3,"file":"NoDeprecatedCustomRule-5076586f.js","sources":["../../../node_modules/graphql/language/predicates.mjs","../../../node_modules/graphql/validation/rules/ExecutableDefinitionsRule.mjs","../../../node_modules/graphql/validation/rules/FieldsOnCorrectTypeRule.mjs","../../../node_modules/graphql/validation/rules/FragmentsOnCompositeTypesRule.mjs","../../../node_modules/graphql/validation/rules/KnownArgumentNamesRule.mjs","../../../node_modules/graphql/validation/rules/KnownDirectivesRule.mjs","../../../node_modules/graphql/validation/rules/KnownFragmentNamesRule.mjs","../../../node_modules/graphql/validation/rules/KnownTypeNamesRule.mjs","../../../node_modules/graphql/validation/rules/LoneAnonymousOperationRule.mjs","../../../node_modules/graphql/validation/rules/LoneSchemaDefinitionRule.mjs","../../../node_modules/graphql/validation/rules/NoFragmentCyclesRule.mjs","../../../node_modules/graphql/validation/rules/NoUndefinedVariablesRule.mjs","../../../node_modules/graphql/validation/rules/NoUnusedFragmentsRule.mjs","../../../node_modules/graphql/validation/rules/NoUnusedVariablesRule.mjs","../../../node_modules/graphql/utilities/sortValueNode.mjs","../../../node_modules/graphql/validation/rules/OverlappingFieldsCanBeMergedRule.mjs","../../../node_modules/graphql/validation/rules/PossibleFragmentSpreadsRule.mjs","../../../node_modules/graphql/validation/rules/PossibleTypeExtensionsRule.mjs","../../../node_modules/graphql/validation/rules/ProvidedRequiredArgumentsRule.mjs","../../../node_modules/graphql/validation/rules/ScalarLeafsRule.mjs","../../../node_modules/graphql/jsutils/printPathArray.mjs","../../../node_modules/graphql/jsutils/Path.mjs","../../../node_modules/graphql/utilities/coerceInputValue.mjs","../../../node_modules/graphql/execution/values.mjs","../../../node_modules/graphql/execution/collectFields.mjs","../../../node_modules/graphql/validation/rules/SingleFieldSubscriptionsRule.mjs","../../../node_modules/graphql/jsutils/groupBy.mjs","../../../node_modules/graphql/validation/rules/UniqueArgumentDefinitionNamesRule.mjs","../../../node_modules/graphql/validation/rules/UniqueArgumentNamesRule.mjs","../../../node_modules/graphql/validation/rules/UniqueDirectiveNamesRule.mjs","../../../node_modules/graphql/validation/rules/UniqueDirectivesPerLocationRule.mjs","../../../node_modules/graphql/validation/rules/UniqueEnumValueNamesRule.mjs","../../../node_modules/graphql/validation/rules/UniqueFieldDefinitionNamesRule.mjs","../../../node_modules/graphql/validation/rules/UniqueFragmentNamesRule.mjs","../../../node_modules/graphql/validation/rules/UniqueInputFieldNamesRule.mjs","../../../node_modules/graphql/validation/rules/UniqueOperationNamesRule.mjs","../../../node_modules/graphql/validation/rules/UniqueOperationTypesRule.mjs","../../../node_modules/graphql/validation/rules/UniqueTypeNamesRule.mjs","../../../node_modules/graphql/validation/rules/UniqueVariableNamesRule.mjs","../../../node_modules/graphql/validation/rules/ValuesOfCorrectTypeRule.mjs","../../../node_modules/graphql/validation/rules/VariablesAreInputTypesRule.mjs","../../../node_modules/graphql/validation/rules/VariablesInAllowedPositionRule.mjs","../../../node_modules/graphql/validation/specifiedRules.mjs","../../../node_modules/graphql/validation/ValidationContext.mjs","../../../node_modules/graphql/validation/validate.mjs","../../../node_modules/graphql/validation/rules/custom/NoDeprecatedCustomRule.mjs"],"sourcesContent":["import { Kind } from './kinds.mjs';\nexport function isDefinitionNode(node) {\n  return (\n    isExecutableDefinitionNode(node) ||\n    isTypeSystemDefinitionNode(node) ||\n    isTypeSystemExtensionNode(node)\n  );\n}\nexport function isExecutableDefinitionNode(node) {\n  return (\n    node.kind === Kind.OPERATION_DEFINITION ||\n    node.kind === Kind.FRAGMENT_DEFINITION\n  );\n}\nexport function isSelectionNode(node) {\n  return (\n    node.kind === Kind.FIELD ||\n    node.kind === Kind.FRAGMENT_SPREAD ||\n    node.kind === Kind.INLINE_FRAGMENT\n  );\n}\nexport function isValueNode(node) {\n  return (\n    node.kind === Kind.VARIABLE ||\n    node.kind === Kind.INT ||\n    node.kind === Kind.FLOAT ||\n    node.kind === Kind.STRING ||\n    node.kind === Kind.BOOLEAN ||\n    node.kind === Kind.NULL ||\n    node.kind === Kind.ENUM ||\n    node.kind === Kind.LIST ||\n    node.kind === Kind.OBJECT\n  );\n}\nexport function isConstValueNode(node) {\n  return (\n    isValueNode(node) &&\n    (node.kind === Kind.LIST\n      ? node.values.some(isConstValueNode)\n      : node.kind === Kind.OBJECT\n      ? node.fields.some((field) => isConstValueNode(field.value))\n      : node.kind !== Kind.VARIABLE)\n  );\n}\nexport function isTypeNode(node) {\n  return (\n    node.kind === Kind.NAMED_TYPE ||\n    node.kind === Kind.LIST_TYPE ||\n    node.kind === Kind.NON_NULL_TYPE\n  );\n}\nexport function isTypeSystemDefinitionNode(node) {\n  return (\n    node.kind === Kind.SCHEMA_DEFINITION ||\n    isTypeDefinitionNode(node) ||\n    node.kind === Kind.DIRECTIVE_DEFINITION\n  );\n}\nexport function isTypeDefinitionNode(node) {\n  return (\n    node.kind === Kind.SCALAR_TYPE_DEFINITION ||\n    node.kind === Kind.OBJECT_TYPE_DEFINITION ||\n    node.kind === Kind.INTERFACE_TYPE_DEFINITION ||\n    node.kind === Kind.UNION_TYPE_DEFINITION ||\n    node.kind === Kind.ENUM_TYPE_DEFINITION ||\n    node.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION\n  );\n}\nexport function isTypeSystemExtensionNode(node) {\n  return node.kind === Kind.SCHEMA_EXTENSION || isTypeExtensionNode(node);\n}\nexport function isTypeExtensionNode(node) {\n  return (\n    node.kind === Kind.SCALAR_TYPE_EXTENSION ||\n    node.kind === Kind.OBJECT_TYPE_EXTENSION ||\n    node.kind === Kind.INTERFACE_TYPE_EXTENSION ||\n    node.kind === Kind.UNION_TYPE_EXTENSION ||\n    node.kind === Kind.ENUM_TYPE_EXTENSION ||\n    node.kind === Kind.INPUT_OBJECT_TYPE_EXTENSION\n  );\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { Kind } from '../../language/kinds.mjs';\nimport { isExecutableDefinitionNode } from '../../language/predicates.mjs';\n\n/**\n * Executable definitions\n *\n * A GraphQL document is only valid for execution if all definitions are either\n * operation or fragment definitions.\n *\n * See https://spec.graphql.org/draft/#sec-Executable-Definitions\n */\nexport function ExecutableDefinitionsRule(context) {\n  return {\n    Document(node) {\n      for (const definition of node.definitions) {\n        if (!isExecutableDefinitionNode(definition)) {\n          const defName =\n            definition.kind === Kind.SCHEMA_DEFINITION ||\n            definition.kind === Kind.SCHEMA_EXTENSION\n              ? 'schema'\n              : '\"' + definition.name.value + '\"';\n          context.reportError(\n            new GraphQLError(`The ${defName} definition is not executable.`, {\n              nodes: definition,\n            }),\n          );\n        }\n      }\n\n      return false;\n    },\n  };\n}\n","import { didYouMean } from '../../jsutils/didYouMean.mjs';\nimport { naturalCompare } from '../../jsutils/naturalCompare.mjs';\nimport { suggestionList } from '../../jsutils/suggestionList.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport {\n  isAbstractType,\n  isInterfaceType,\n  isObjectType,\n} from '../../type/definition.mjs';\n\n/**\n * Fields on correct type\n *\n * A GraphQL document is only valid if all fields selected are defined by the\n * parent type, or are an allowed meta field such as __typename.\n *\n * See https://spec.graphql.org/draft/#sec-Field-Selections\n */\nexport function FieldsOnCorrectTypeRule(context) {\n  return {\n    Field(node) {\n      const type = context.getParentType();\n\n      if (type) {\n        const fieldDef = context.getFieldDef();\n\n        if (!fieldDef) {\n          // This field doesn't exist, lets look for suggestions.\n          const schema = context.getSchema();\n          const fieldName = node.name.value; // First determine if there are any suggested types to condition on.\n\n          let suggestion = didYouMean(\n            'to use an inline fragment on',\n            getSuggestedTypeNames(schema, type, fieldName),\n          ); // If there are no suggested types, then perhaps this was a typo?\n\n          if (suggestion === '') {\n            suggestion = didYouMean(getSuggestedFieldNames(type, fieldName));\n          } // Report an error, including helpful suggestions.\n\n          context.reportError(\n            new GraphQLError(\n              `Cannot query field \"${fieldName}\" on type \"${type.name}\".` +\n                suggestion,\n              {\n                nodes: node,\n              },\n            ),\n          );\n        }\n      }\n    },\n  };\n}\n/**\n * Go through all of the implementations of type, as well as the interfaces that\n * they implement. If any of those types include the provided field, suggest them,\n * sorted by how often the type is referenced.\n */\n\nfunction getSuggestedTypeNames(schema, type, fieldName) {\n  if (!isAbstractType(type)) {\n    // Must be an Object type, which does not have possible fields.\n    return [];\n  }\n\n  const suggestedTypes = new Set();\n  const usageCount = Object.create(null);\n\n  for (const possibleType of schema.getPossibleTypes(type)) {\n    if (!possibleType.getFields()[fieldName]) {\n      continue;\n    } // This object type defines this field.\n\n    suggestedTypes.add(possibleType);\n    usageCount[possibleType.name] = 1;\n\n    for (const possibleInterface of possibleType.getInterfaces()) {\n      var _usageCount$possibleI;\n\n      if (!possibleInterface.getFields()[fieldName]) {\n        continue;\n      } // This interface type defines this field.\n\n      suggestedTypes.add(possibleInterface);\n      usageCount[possibleInterface.name] =\n        ((_usageCount$possibleI = usageCount[possibleInterface.name]) !==\n          null && _usageCount$possibleI !== void 0\n          ? _usageCount$possibleI\n          : 0) + 1;\n    }\n  }\n\n  return [...suggestedTypes]\n    .sort((typeA, typeB) => {\n      // Suggest both interface and object types based on how common they are.\n      const usageCountDiff = usageCount[typeB.name] - usageCount[typeA.name];\n\n      if (usageCountDiff !== 0) {\n        return usageCountDiff;\n      } // Suggest super types first followed by subtypes\n\n      if (isInterfaceType(typeA) && schema.isSubType(typeA, typeB)) {\n        return -1;\n      }\n\n      if (isInterfaceType(typeB) && schema.isSubType(typeB, typeA)) {\n        return 1;\n      }\n\n      return naturalCompare(typeA.name, typeB.name);\n    })\n    .map((x) => x.name);\n}\n/**\n * For the field name provided, determine if there are any similar field names\n * that may be the result of a typo.\n */\n\nfunction getSuggestedFieldNames(type, fieldName) {\n  if (isObjectType(type) || isInterfaceType(type)) {\n    const possibleFieldNames = Object.keys(type.getFields());\n    return suggestionList(fieldName, possibleFieldNames);\n  } // Otherwise, must be a Union type, which does not define fields.\n\n  return [];\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { print } from '../../language/printer.mjs';\nimport { isCompositeType } from '../../type/definition.mjs';\nimport { typeFromAST } from '../../utilities/typeFromAST.mjs';\n\n/**\n * Fragments on composite type\n *\n * Fragments use a type condition to determine if they apply, since fragments\n * can only be spread into a composite type (object, interface, or union), the\n * type condition must also be a composite type.\n *\n * See https://spec.graphql.org/draft/#sec-Fragments-On-Composite-Types\n */\nexport function FragmentsOnCompositeTypesRule(context) {\n  return {\n    InlineFragment(node) {\n      const typeCondition = node.typeCondition;\n\n      if (typeCondition) {\n        const type = typeFromAST(context.getSchema(), typeCondition);\n\n        if (type && !isCompositeType(type)) {\n          const typeStr = print(typeCondition);\n          context.reportError(\n            new GraphQLError(\n              `Fragment cannot condition on non composite type \"${typeStr}\".`,\n              {\n                nodes: typeCondition,\n              },\n            ),\n          );\n        }\n      }\n    },\n\n    FragmentDefinition(node) {\n      const type = typeFromAST(context.getSchema(), node.typeCondition);\n\n      if (type && !isCompositeType(type)) {\n        const typeStr = print(node.typeCondition);\n        context.reportError(\n          new GraphQLError(\n            `Fragment \"${node.name.value}\" cannot condition on non composite type \"${typeStr}\".`,\n            {\n              nodes: node.typeCondition,\n            },\n          ),\n        );\n      }\n    },\n  };\n}\n","import { didYouMean } from '../../jsutils/didYouMean.mjs';\nimport { suggestionList } from '../../jsutils/suggestionList.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { Kind } from '../../language/kinds.mjs';\nimport { specifiedDirectives } from '../../type/directives.mjs';\n\n/**\n * Known argument names\n *\n * A GraphQL field is only valid if all supplied arguments are defined by\n * that field.\n *\n * See https://spec.graphql.org/draft/#sec-Argument-Names\n * See https://spec.graphql.org/draft/#sec-Directives-Are-In-Valid-Locations\n */\nexport function KnownArgumentNamesRule(context) {\n  return {\n    // eslint-disable-next-line new-cap\n    ...KnownArgumentNamesOnDirectivesRule(context),\n\n    Argument(argNode) {\n      const argDef = context.getArgument();\n      const fieldDef = context.getFieldDef();\n      const parentType = context.getParentType();\n\n      if (!argDef && fieldDef && parentType) {\n        const argName = argNode.name.value;\n        const knownArgsNames = fieldDef.args.map((arg) => arg.name);\n        const suggestions = suggestionList(argName, knownArgsNames);\n        context.reportError(\n          new GraphQLError(\n            `Unknown argument \"${argName}\" on field \"${parentType.name}.${fieldDef.name}\".` +\n              didYouMean(suggestions),\n            {\n              nodes: argNode,\n            },\n          ),\n        );\n      }\n    },\n  };\n}\n/**\n * @internal\n */\n\nexport function KnownArgumentNamesOnDirectivesRule(context) {\n  const directiveArgs = Object.create(null);\n  const schema = context.getSchema();\n  const definedDirectives = schema\n    ? schema.getDirectives()\n    : specifiedDirectives;\n\n  for (const directive of definedDirectives) {\n    directiveArgs[directive.name] = directive.args.map((arg) => arg.name);\n  }\n\n  const astDefinitions = context.getDocument().definitions;\n\n  for (const def of astDefinitions) {\n    if (def.kind === Kind.DIRECTIVE_DEFINITION) {\n      var _def$arguments;\n\n      // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n      /* c8 ignore next */\n      const argsNodes =\n        (_def$arguments = def.arguments) !== null && _def$arguments !== void 0\n          ? _def$arguments\n          : [];\n      directiveArgs[def.name.value] = argsNodes.map((arg) => arg.name.value);\n    }\n  }\n\n  return {\n    Directive(directiveNode) {\n      const directiveName = directiveNode.name.value;\n      const knownArgs = directiveArgs[directiveName];\n\n      if (directiveNode.arguments && knownArgs) {\n        for (const argNode of directiveNode.arguments) {\n          const argName = argNode.name.value;\n\n          if (!knownArgs.includes(argName)) {\n            const suggestions = suggestionList(argName, knownArgs);\n            context.reportError(\n              new GraphQLError(\n                `Unknown argument \"${argName}\" on directive \"@${directiveName}\".` +\n                  didYouMean(suggestions),\n                {\n                  nodes: argNode,\n                },\n              ),\n            );\n          }\n        }\n      }\n\n      return false;\n    },\n  };\n}\n","import { inspect } from '../../jsutils/inspect.mjs';\nimport { invariant } from '../../jsutils/invariant.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { OperationTypeNode } from '../../language/ast.mjs';\nimport { DirectiveLocation } from '../../language/directiveLocation.mjs';\nimport { Kind } from '../../language/kinds.mjs';\nimport { specifiedDirectives } from '../../type/directives.mjs';\n\n/**\n * Known directives\n *\n * A GraphQL document is only valid if all `@directives` are known by the\n * schema and legally positioned.\n *\n * See https://spec.graphql.org/draft/#sec-Directives-Are-Defined\n */\nexport function KnownDirectivesRule(context) {\n  const locationsMap = Object.create(null);\n  const schema = context.getSchema();\n  const definedDirectives = schema\n    ? schema.getDirectives()\n    : specifiedDirectives;\n\n  for (const directive of definedDirectives) {\n    locationsMap[directive.name] = directive.locations;\n  }\n\n  const astDefinitions = context.getDocument().definitions;\n\n  for (const def of astDefinitions) {\n    if (def.kind === Kind.DIRECTIVE_DEFINITION) {\n      locationsMap[def.name.value] = def.locations.map((name) => name.value);\n    }\n  }\n\n  return {\n    Directive(node, _key, _parent, _path, ancestors) {\n      const name = node.name.value;\n      const locations = locationsMap[name];\n\n      if (!locations) {\n        context.reportError(\n          new GraphQLError(`Unknown directive \"@${name}\".`, {\n            nodes: node,\n          }),\n        );\n        return;\n      }\n\n      const candidateLocation = getDirectiveLocationForASTPath(ancestors);\n\n      if (candidateLocation && !locations.includes(candidateLocation)) {\n        context.reportError(\n          new GraphQLError(\n            `Directive \"@${name}\" may not be used on ${candidateLocation}.`,\n            {\n              nodes: node,\n            },\n          ),\n        );\n      }\n    },\n  };\n}\n\nfunction getDirectiveLocationForASTPath(ancestors) {\n  const appliedTo = ancestors[ancestors.length - 1];\n  'kind' in appliedTo || invariant(false);\n\n  switch (appliedTo.kind) {\n    case Kind.OPERATION_DEFINITION:\n      return getDirectiveLocationForOperation(appliedTo.operation);\n\n    case Kind.FIELD:\n      return DirectiveLocation.FIELD;\n\n    case Kind.FRAGMENT_SPREAD:\n      return DirectiveLocation.FRAGMENT_SPREAD;\n\n    case Kind.INLINE_FRAGMENT:\n      return DirectiveLocation.INLINE_FRAGMENT;\n\n    case Kind.FRAGMENT_DEFINITION:\n      return DirectiveLocation.FRAGMENT_DEFINITION;\n\n    case Kind.VARIABLE_DEFINITION:\n      return DirectiveLocation.VARIABLE_DEFINITION;\n\n    case Kind.SCHEMA_DEFINITION:\n    case Kind.SCHEMA_EXTENSION:\n      return DirectiveLocation.SCHEMA;\n\n    case Kind.SCALAR_TYPE_DEFINITION:\n    case Kind.SCALAR_TYPE_EXTENSION:\n      return DirectiveLocation.SCALAR;\n\n    case Kind.OBJECT_TYPE_DEFINITION:\n    case Kind.OBJECT_TYPE_EXTENSION:\n      return DirectiveLocation.OBJECT;\n\n    case Kind.FIELD_DEFINITION:\n      return DirectiveLocation.FIELD_DEFINITION;\n\n    case Kind.INTERFACE_TYPE_DEFINITION:\n    case Kind.INTERFACE_TYPE_EXTENSION:\n      return DirectiveLocation.INTERFACE;\n\n    case Kind.UNION_TYPE_DEFINITION:\n    case Kind.UNION_TYPE_EXTENSION:\n      return DirectiveLocation.UNION;\n\n    case Kind.ENUM_TYPE_DEFINITION:\n    case Kind.ENUM_TYPE_EXTENSION:\n      return DirectiveLocation.ENUM;\n\n    case Kind.ENUM_VALUE_DEFINITION:\n      return DirectiveLocation.ENUM_VALUE;\n\n    case Kind.INPUT_OBJECT_TYPE_DEFINITION:\n    case Kind.INPUT_OBJECT_TYPE_EXTENSION:\n      return DirectiveLocation.INPUT_OBJECT;\n\n    case Kind.INPUT_VALUE_DEFINITION: {\n      const parentNode = ancestors[ancestors.length - 3];\n      'kind' in parentNode || invariant(false);\n      return parentNode.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION\n        ? DirectiveLocation.INPUT_FIELD_DEFINITION\n        : DirectiveLocation.ARGUMENT_DEFINITION;\n    }\n    // Not reachable, all possible types have been considered.\n\n    /* c8 ignore next */\n\n    default:\n      false || invariant(false, 'Unexpected kind: ' + inspect(appliedTo.kind));\n  }\n}\n\nfunction getDirectiveLocationForOperation(operation) {\n  switch (operation) {\n    case OperationTypeNode.QUERY:\n      return DirectiveLocation.QUERY;\n\n    case OperationTypeNode.MUTATION:\n      return DirectiveLocation.MUTATION;\n\n    case OperationTypeNode.SUBSCRIPTION:\n      return DirectiveLocation.SUBSCRIPTION;\n  }\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Known fragment names\n *\n * A GraphQL document is only valid if all `...Fragment` fragment spreads refer\n * to fragments defined in the same document.\n *\n * See https://spec.graphql.org/draft/#sec-Fragment-spread-target-defined\n */\nexport function KnownFragmentNamesRule(context) {\n  return {\n    FragmentSpread(node) {\n      const fragmentName = node.name.value;\n      const fragment = context.getFragment(fragmentName);\n\n      if (!fragment) {\n        context.reportError(\n          new GraphQLError(`Unknown fragment \"${fragmentName}\".`, {\n            nodes: node.name,\n          }),\n        );\n      }\n    },\n  };\n}\n","import { didYouMean } from '../../jsutils/didYouMean.mjs';\nimport { suggestionList } from '../../jsutils/suggestionList.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport {\n  isTypeDefinitionNode,\n  isTypeSystemDefinitionNode,\n  isTypeSystemExtensionNode,\n} from '../../language/predicates.mjs';\nimport { introspectionTypes } from '../../type/introspection.mjs';\nimport { specifiedScalarTypes } from '../../type/scalars.mjs';\n\n/**\n * Known type names\n *\n * A GraphQL document is only valid if referenced types (specifically\n * variable definitions and fragment conditions) are defined by the type schema.\n *\n * See https://spec.graphql.org/draft/#sec-Fragment-Spread-Type-Existence\n */\nexport function KnownTypeNamesRule(context) {\n  const schema = context.getSchema();\n  const existingTypesMap = schema ? schema.getTypeMap() : Object.create(null);\n  const definedTypes = Object.create(null);\n\n  for (const def of context.getDocument().definitions) {\n    if (isTypeDefinitionNode(def)) {\n      definedTypes[def.name.value] = true;\n    }\n  }\n\n  const typeNames = [\n    ...Object.keys(existingTypesMap),\n    ...Object.keys(definedTypes),\n  ];\n  return {\n    NamedType(node, _1, parent, _2, ancestors) {\n      const typeName = node.name.value;\n\n      if (!existingTypesMap[typeName] && !definedTypes[typeName]) {\n        var _ancestors$;\n\n        const definitionNode =\n          (_ancestors$ = ancestors[2]) !== null && _ancestors$ !== void 0\n            ? _ancestors$\n            : parent;\n        const isSDL = definitionNode != null && isSDLNode(definitionNode);\n\n        if (isSDL && standardTypeNames.includes(typeName)) {\n          return;\n        }\n\n        const suggestedTypes = suggestionList(\n          typeName,\n          isSDL ? standardTypeNames.concat(typeNames) : typeNames,\n        );\n        context.reportError(\n          new GraphQLError(\n            `Unknown type \"${typeName}\".` + didYouMean(suggestedTypes),\n            {\n              nodes: node,\n            },\n          ),\n        );\n      }\n    },\n  };\n}\nconst standardTypeNames = [...specifiedScalarTypes, ...introspectionTypes].map(\n  (type) => type.name,\n);\n\nfunction isSDLNode(value) {\n  return (\n    'kind' in value &&\n    (isTypeSystemDefinitionNode(value) || isTypeSystemExtensionNode(value))\n  );\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { Kind } from '../../language/kinds.mjs';\n\n/**\n * Lone anonymous operation\n *\n * A GraphQL document is only valid if when it contains an anonymous operation\n * (the query short-hand) that it contains only that one operation definition.\n *\n * See https://spec.graphql.org/draft/#sec-Lone-Anonymous-Operation\n */\nexport function LoneAnonymousOperationRule(context) {\n  let operationCount = 0;\n  return {\n    Document(node) {\n      operationCount = node.definitions.filter(\n        (definition) => definition.kind === Kind.OPERATION_DEFINITION,\n      ).length;\n    },\n\n    OperationDefinition(node) {\n      if (!node.name && operationCount > 1) {\n        context.reportError(\n          new GraphQLError(\n            'This anonymous operation must be the only defined operation.',\n            {\n              nodes: node,\n            },\n          ),\n        );\n      }\n    },\n  };\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Lone Schema definition\n *\n * A GraphQL document is only valid if it contains only one schema definition.\n */\nexport function LoneSchemaDefinitionRule(context) {\n  var _ref, _ref2, _oldSchema$astNode;\n\n  const oldSchema = context.getSchema();\n  const alreadyDefined =\n    (_ref =\n      (_ref2 =\n        (_oldSchema$astNode =\n          oldSchema === null || oldSchema === void 0\n            ? void 0\n            : oldSchema.astNode) !== null && _oldSchema$astNode !== void 0\n          ? _oldSchema$astNode\n          : oldSchema === null || oldSchema === void 0\n          ? void 0\n          : oldSchema.getQueryType()) !== null && _ref2 !== void 0\n        ? _ref2\n        : oldSchema === null || oldSchema === void 0\n        ? void 0\n        : oldSchema.getMutationType()) !== null && _ref !== void 0\n      ? _ref\n      : oldSchema === null || oldSchema === void 0\n      ? void 0\n      : oldSchema.getSubscriptionType();\n  let schemaDefinitionsCount = 0;\n  return {\n    SchemaDefinition(node) {\n      if (alreadyDefined) {\n        context.reportError(\n          new GraphQLError(\n            'Cannot define a new schema within a schema extension.',\n            {\n              nodes: node,\n            },\n          ),\n        );\n        return;\n      }\n\n      if (schemaDefinitionsCount > 0) {\n        context.reportError(\n          new GraphQLError('Must provide only one schema definition.', {\n            nodes: node,\n          }),\n        );\n      }\n\n      ++schemaDefinitionsCount;\n    },\n  };\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * No fragment cycles\n *\n * The graph of fragment spreads must not form any cycles including spreading itself.\n * Otherwise an operation could infinitely spread or infinitely execute on cycles in the underlying data.\n *\n * See https://spec.graphql.org/draft/#sec-Fragment-spreads-must-not-form-cycles\n */\nexport function NoFragmentCyclesRule(context) {\n  // Tracks already visited fragments to maintain O(N) and to ensure that cycles\n  // are not redundantly reported.\n  const visitedFrags = Object.create(null); // Array of AST nodes used to produce meaningful errors\n\n  const spreadPath = []; // Position in the spread path\n\n  const spreadPathIndexByName = Object.create(null);\n  return {\n    OperationDefinition: () => false,\n\n    FragmentDefinition(node) {\n      detectCycleRecursive(node);\n      return false;\n    },\n  }; // This does a straight-forward DFS to find cycles.\n  // It does not terminate when a cycle was found but continues to explore\n  // the graph to find all possible cycles.\n\n  function detectCycleRecursive(fragment) {\n    if (visitedFrags[fragment.name.value]) {\n      return;\n    }\n\n    const fragmentName = fragment.name.value;\n    visitedFrags[fragmentName] = true;\n    const spreadNodes = context.getFragmentSpreads(fragment.selectionSet);\n\n    if (spreadNodes.length === 0) {\n      return;\n    }\n\n    spreadPathIndexByName[fragmentName] = spreadPath.length;\n\n    for (const spreadNode of spreadNodes) {\n      const spreadName = spreadNode.name.value;\n      const cycleIndex = spreadPathIndexByName[spreadName];\n      spreadPath.push(spreadNode);\n\n      if (cycleIndex === undefined) {\n        const spreadFragment = context.getFragment(spreadName);\n\n        if (spreadFragment) {\n          detectCycleRecursive(spreadFragment);\n        }\n      } else {\n        const cyclePath = spreadPath.slice(cycleIndex);\n        const viaPath = cyclePath\n          .slice(0, -1)\n          .map((s) => '\"' + s.name.value + '\"')\n          .join(', ');\n        context.reportError(\n          new GraphQLError(\n            `Cannot spread fragment \"${spreadName}\" within itself` +\n              (viaPath !== '' ? ` via ${viaPath}.` : '.'),\n            {\n              nodes: cyclePath,\n            },\n          ),\n        );\n      }\n\n      spreadPath.pop();\n    }\n\n    spreadPathIndexByName[fragmentName] = undefined;\n  }\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * No undefined variables\n *\n * A GraphQL operation is only valid if all variables encountered, both directly\n * and via fragment spreads, are defined by that operation.\n *\n * See https://spec.graphql.org/draft/#sec-All-Variable-Uses-Defined\n */\nexport function NoUndefinedVariablesRule(context) {\n  let variableNameDefined = Object.create(null);\n  return {\n    OperationDefinition: {\n      enter() {\n        variableNameDefined = Object.create(null);\n      },\n\n      leave(operation) {\n        const usages = context.getRecursiveVariableUsages(operation);\n\n        for (const { node } of usages) {\n          const varName = node.name.value;\n\n          if (variableNameDefined[varName] !== true) {\n            context.reportError(\n              new GraphQLError(\n                operation.name\n                  ? `Variable \"$${varName}\" is not defined by operation \"${operation.name.value}\".`\n                  : `Variable \"$${varName}\" is not defined.`,\n                {\n                  nodes: [node, operation],\n                },\n              ),\n            );\n          }\n        }\n      },\n    },\n\n    VariableDefinition(node) {\n      variableNameDefined[node.variable.name.value] = true;\n    },\n  };\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * No unused fragments\n *\n * A GraphQL document is only valid if all fragment definitions are spread\n * within operations, or spread within other fragments spread within operations.\n *\n * See https://spec.graphql.org/draft/#sec-Fragments-Must-Be-Used\n */\nexport function NoUnusedFragmentsRule(context) {\n  const operationDefs = [];\n  const fragmentDefs = [];\n  return {\n    OperationDefinition(node) {\n      operationDefs.push(node);\n      return false;\n    },\n\n    FragmentDefinition(node) {\n      fragmentDefs.push(node);\n      return false;\n    },\n\n    Document: {\n      leave() {\n        const fragmentNameUsed = Object.create(null);\n\n        for (const operation of operationDefs) {\n          for (const fragment of context.getRecursivelyReferencedFragments(\n            operation,\n          )) {\n            fragmentNameUsed[fragment.name.value] = true;\n          }\n        }\n\n        for (const fragmentDef of fragmentDefs) {\n          const fragName = fragmentDef.name.value;\n\n          if (fragmentNameUsed[fragName] !== true) {\n            context.reportError(\n              new GraphQLError(`Fragment \"${fragName}\" is never used.`, {\n                nodes: fragmentDef,\n              }),\n            );\n          }\n        }\n      },\n    },\n  };\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * No unused variables\n *\n * A GraphQL operation is only valid if all variables defined by an operation\n * are used, either directly or within a spread fragment.\n *\n * See https://spec.graphql.org/draft/#sec-All-Variables-Used\n */\nexport function NoUnusedVariablesRule(context) {\n  let variableDefs = [];\n  return {\n    OperationDefinition: {\n      enter() {\n        variableDefs = [];\n      },\n\n      leave(operation) {\n        const variableNameUsed = Object.create(null);\n        const usages = context.getRecursiveVariableUsages(operation);\n\n        for (const { node } of usages) {\n          variableNameUsed[node.name.value] = true;\n        }\n\n        for (const variableDef of variableDefs) {\n          const variableName = variableDef.variable.name.value;\n\n          if (variableNameUsed[variableName] !== true) {\n            context.reportError(\n              new GraphQLError(\n                operation.name\n                  ? `Variable \"$${variableName}\" is never used in operation \"${operation.name.value}\".`\n                  : `Variable \"$${variableName}\" is never used.`,\n                {\n                  nodes: variableDef,\n                },\n              ),\n            );\n          }\n        }\n      },\n    },\n\n    VariableDefinition(def) {\n      variableDefs.push(def);\n    },\n  };\n}\n","import { naturalCompare } from '../jsutils/naturalCompare.mjs';\nimport { Kind } from '../language/kinds.mjs';\n/**\n * Sort ValueNode.\n *\n * This function returns a sorted copy of the given ValueNode.\n *\n * @internal\n */\n\nexport function sortValueNode(valueNode) {\n  switch (valueNode.kind) {\n    case Kind.OBJECT:\n      return { ...valueNode, fields: sortFields(valueNode.fields) };\n\n    case Kind.LIST:\n      return { ...valueNode, values: valueNode.values.map(sortValueNode) };\n\n    case Kind.INT:\n    case Kind.FLOAT:\n    case Kind.STRING:\n    case Kind.BOOLEAN:\n    case Kind.NULL:\n    case Kind.ENUM:\n    case Kind.VARIABLE:\n      return valueNode;\n  }\n}\n\nfunction sortFields(fields) {\n  return fields\n    .map((fieldNode) => ({\n      ...fieldNode,\n      value: sortValueNode(fieldNode.value),\n    }))\n    .sort((fieldA, fieldB) =>\n      naturalCompare(fieldA.name.value, fieldB.name.value),\n    );\n}\n","import { inspect } from '../../jsutils/inspect.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { Kind } from '../../language/kinds.mjs';\nimport { print } from '../../language/printer.mjs';\nimport {\n  getNamedType,\n  isInterfaceType,\n  isLeafType,\n  isListType,\n  isNonNullType,\n  isObjectType,\n} from '../../type/definition.mjs';\nimport { sortValueNode } from '../../utilities/sortValueNode.mjs';\nimport { typeFromAST } from '../../utilities/typeFromAST.mjs';\n\nfunction reasonMessage(reason) {\n  if (Array.isArray(reason)) {\n    return reason\n      .map(\n        ([responseName, subReason]) =>\n          `subfields \"${responseName}\" conflict because ` +\n          reasonMessage(subReason),\n      )\n      .join(' and ');\n  }\n\n  return reason;\n}\n/**\n * Overlapping fields can be merged\n *\n * A selection set is only valid if all fields (including spreading any\n * fragments) either correspond to distinct response names or can be merged\n * without ambiguity.\n *\n * See https://spec.graphql.org/draft/#sec-Field-Selection-Merging\n */\n\nexport function OverlappingFieldsCanBeMergedRule(context) {\n  // A memoization for when two fragments are compared \"between\" each other for\n  // conflicts. Two fragments may be compared many times, so memoizing this can\n  // dramatically improve the performance of this validator.\n  const comparedFragmentPairs = new PairSet(); // A cache for the \"field map\" and list of fragment names found in any given\n  // selection set. Selection sets may be asked for this information multiple\n  // times, so this improves the performance of this validator.\n\n  const cachedFieldsAndFragmentNames = new Map();\n  return {\n    SelectionSet(selectionSet) {\n      const conflicts = findConflictsWithinSelectionSet(\n        context,\n        cachedFieldsAndFragmentNames,\n        comparedFragmentPairs,\n        context.getParentType(),\n        selectionSet,\n      );\n\n      for (const [[responseName, reason], fields1, fields2] of conflicts) {\n        const reasonMsg = reasonMessage(reason);\n        context.reportError(\n          new GraphQLError(\n            `Fields \"${responseName}\" conflict because ${reasonMsg}. Use different aliases on the fields to fetch both if this was intentional.`,\n            {\n              nodes: fields1.concat(fields2),\n            },\n          ),\n        );\n      }\n    },\n  };\n}\n\n/**\n * Algorithm:\n *\n * Conflicts occur when two fields exist in a query which will produce the same\n * response name, but represent differing values, thus creating a conflict.\n * The algorithm below finds all conflicts via making a series of comparisons\n * between fields. In order to compare as few fields as possible, this makes\n * a series of comparisons \"within\" sets of fields and \"between\" sets of fields.\n *\n * Given any selection set, a collection produces both a set of fields by\n * also including all inline fragments, as well as a list of fragments\n * referenced by fragment spreads.\n *\n * A) Each selection set represented in the document first compares \"within\" its\n * collected set of fields, finding any conflicts between every pair of\n * overlapping fields.\n * Note: This is the *only time* that a the fields \"within\" a set are compared\n * to each other. After this only fields \"between\" sets are compared.\n *\n * B) Also, if any fragment is referenced in a selection set, then a\n * comparison is made \"between\" the original set of fields and the\n * referenced fragment.\n *\n * C) Also, if multiple fragments are referenced, then comparisons\n * are made \"between\" each referenced fragment.\n *\n * D) When comparing \"between\" a set of fields and a referenced fragment, first\n * a comparison is made between each field in the original set of fields and\n * each field in the the referenced set of fields.\n *\n * E) Also, if any fragment is referenced in the referenced selection set,\n * then a comparison is made \"between\" the original set of fields and the\n * referenced fragment (recursively referring to step D).\n *\n * F) When comparing \"between\" two fragments, first a comparison is made between\n * each field in the first referenced set of fields and each field in the the\n * second referenced set of fields.\n *\n * G) Also, any fragments referenced by the first must be compared to the\n * second, and any fragments referenced by the second must be compared to the\n * first (recursively referring to step F).\n *\n * H) When comparing two fields, if both have selection sets, then a comparison\n * is made \"between\" both selection sets, first comparing the set of fields in\n * the first selection set with the set of fields in the second.\n *\n * I) Also, if any fragment is referenced in either selection set, then a\n * comparison is made \"between\" the other set of fields and the\n * referenced fragment.\n *\n * J) Also, if two fragments are referenced in both selection sets, then a\n * comparison is made \"between\" the two fragments.\n *\n */\n// Find all conflicts found \"within\" a selection set, including those found\n// via spreading in fragments. Called when visiting each SelectionSet in the\n// GraphQL Document.\nfunction findConflictsWithinSelectionSet(\n  context,\n  cachedFieldsAndFragmentNames,\n  comparedFragmentPairs,\n  parentType,\n  selectionSet,\n) {\n  const conflicts = [];\n  const [fieldMap, fragmentNames] = getFieldsAndFragmentNames(\n    context,\n    cachedFieldsAndFragmentNames,\n    parentType,\n    selectionSet,\n  ); // (A) Find find all conflicts \"within\" the fields of this selection set.\n  // Note: this is the *only place* `collectConflictsWithin` is called.\n\n  collectConflictsWithin(\n    context,\n    conflicts,\n    cachedFieldsAndFragmentNames,\n    comparedFragmentPairs,\n    fieldMap,\n  );\n\n  if (fragmentNames.length !== 0) {\n    // (B) Then collect conflicts between these fields and those represented by\n    // each spread fragment name found.\n    for (let i = 0; i < fragmentNames.length; i++) {\n      collectConflictsBetweenFieldsAndFragment(\n        context,\n        conflicts,\n        cachedFieldsAndFragmentNames,\n        comparedFragmentPairs,\n        false,\n        fieldMap,\n        fragmentNames[i],\n      ); // (C) Then compare this fragment with all other fragments found in this\n      // selection set to collect conflicts between fragments spread together.\n      // This compares each item in the list of fragment names to every other\n      // item in that same list (except for itself).\n\n      for (let j = i + 1; j < fragmentNames.length; j++) {\n        collectConflictsBetweenFragments(\n          context,\n          conflicts,\n          cachedFieldsAndFragmentNames,\n          comparedFragmentPairs,\n          false,\n          fragmentNames[i],\n          fragmentNames[j],\n        );\n      }\n    }\n  }\n\n  return conflicts;\n} // Collect all conflicts found between a set of fields and a fragment reference\n// including via spreading in any nested fragments.\n\nfunction collectConflictsBetweenFieldsAndFragment(\n  context,\n  conflicts,\n  cachedFieldsAndFragmentNames,\n  comparedFragmentPairs,\n  areMutuallyExclusive,\n  fieldMap,\n  fragmentName,\n) {\n  const fragment = context.getFragment(fragmentName);\n\n  if (!fragment) {\n    return;\n  }\n\n  const [fieldMap2, referencedFragmentNames] =\n    getReferencedFieldsAndFragmentNames(\n      context,\n      cachedFieldsAndFragmentNames,\n      fragment,\n    ); // Do not compare a fragment's fieldMap to itself.\n\n  if (fieldMap === fieldMap2) {\n    return;\n  } // (D) First collect any conflicts between the provided collection of fields\n  // and the collection of fields represented by the given fragment.\n\n  collectConflictsBetween(\n    context,\n    conflicts,\n    cachedFieldsAndFragmentNames,\n    comparedFragmentPairs,\n    areMutuallyExclusive,\n    fieldMap,\n    fieldMap2,\n  ); // (E) Then collect any conflicts between the provided collection of fields\n  // and any fragment names found in the given fragment.\n\n  for (const referencedFragmentName of referencedFragmentNames) {\n    // Memoize so two fragments are not compared for conflicts more than once.\n    if (\n      comparedFragmentPairs.has(\n        referencedFragmentName,\n        fragmentName,\n        areMutuallyExclusive,\n      )\n    ) {\n      continue;\n    }\n\n    comparedFragmentPairs.add(\n      referencedFragmentName,\n      fragmentName,\n      areMutuallyExclusive,\n    );\n    collectConflictsBetweenFieldsAndFragment(\n      context,\n      conflicts,\n      cachedFieldsAndFragmentNames,\n      comparedFragmentPairs,\n      areMutuallyExclusive,\n      fieldMap,\n      referencedFragmentName,\n    );\n  }\n} // Collect all conflicts found between two fragments, including via spreading in\n// any nested fragments.\n\nfunction collectConflictsBetweenFragments(\n  context,\n  conflicts,\n  cachedFieldsAndFragmentNames,\n  comparedFragmentPairs,\n  areMutuallyExclusive,\n  fragmentName1,\n  fragmentName2,\n) {\n  // No need to compare a fragment to itself.\n  if (fragmentName1 === fragmentName2) {\n    return;\n  } // Memoize so two fragments are not compared for conflicts more than once.\n\n  if (\n    comparedFragmentPairs.has(\n      fragmentName1,\n      fragmentName2,\n      areMutuallyExclusive,\n    )\n  ) {\n    return;\n  }\n\n  comparedFragmentPairs.add(fragmentName1, fragmentName2, areMutuallyExclusive);\n  const fragment1 = context.getFragment(fragmentName1);\n  const fragment2 = context.getFragment(fragmentName2);\n\n  if (!fragment1 || !fragment2) {\n    return;\n  }\n\n  const [fieldMap1, referencedFragmentNames1] =\n    getReferencedFieldsAndFragmentNames(\n      context,\n      cachedFieldsAndFragmentNames,\n      fragment1,\n    );\n  const [fieldMap2, referencedFragmentNames2] =\n    getReferencedFieldsAndFragmentNames(\n      context,\n      cachedFieldsAndFragmentNames,\n      fragment2,\n    ); // (F) First, collect all conflicts between these two collections of fields\n  // (not including any nested fragments).\n\n  collectConflictsBetween(\n    context,\n    conflicts,\n    cachedFieldsAndFragmentNames,\n    comparedFragmentPairs,\n    areMutuallyExclusive,\n    fieldMap1,\n    fieldMap2,\n  ); // (G) Then collect conflicts between the first fragment and any nested\n  // fragments spread in the second fragment.\n\n  for (const referencedFragmentName2 of referencedFragmentNames2) {\n    collectConflictsBetweenFragments(\n      context,\n      conflicts,\n      cachedFieldsAndFragmentNames,\n      comparedFragmentPairs,\n      areMutuallyExclusive,\n      fragmentName1,\n      referencedFragmentName2,\n    );\n  } // (G) Then collect conflicts between the second fragment and any nested\n  // fragments spread in the first fragment.\n\n  for (const referencedFragmentName1 of referencedFragmentNames1) {\n    collectConflictsBetweenFragments(\n      context,\n      conflicts,\n      cachedFieldsAndFragmentNames,\n      comparedFragmentPairs,\n      areMutuallyExclusive,\n      referencedFragmentName1,\n      fragmentName2,\n    );\n  }\n} // Find all conflicts found between two selection sets, including those found\n// via spreading in fragments. Called when determining if conflicts exist\n// between the sub-fields of two overlapping fields.\n\nfunction findConflictsBetweenSubSelectionSets(\n  context,\n  cachedFieldsAndFragmentNames,\n  comparedFragmentPairs,\n  areMutuallyExclusive,\n  parentType1,\n  selectionSet1,\n  parentType2,\n  selectionSet2,\n) {\n  const conflicts = [];\n  const [fieldMap1, fragmentNames1] = getFieldsAndFragmentNames(\n    context,\n    cachedFieldsAndFragmentNames,\n    parentType1,\n    selectionSet1,\n  );\n  const [fieldMap2, fragmentNames2] = getFieldsAndFragmentNames(\n    context,\n    cachedFieldsAndFragmentNames,\n    parentType2,\n    selectionSet2,\n  ); // (H) First, collect all conflicts between these two collections of field.\n\n  collectConflictsBetween(\n    context,\n    conflicts,\n    cachedFieldsAndFragmentNames,\n    comparedFragmentPairs,\n    areMutuallyExclusive,\n    fieldMap1,\n    fieldMap2,\n  ); // (I) Then collect conflicts between the first collection of fields and\n  // those referenced by each fragment name associated with the second.\n\n  for (const fragmentName2 of fragmentNames2) {\n    collectConflictsBetweenFieldsAndFragment(\n      context,\n      conflicts,\n      cachedFieldsAndFragmentNames,\n      comparedFragmentPairs,\n      areMutuallyExclusive,\n      fieldMap1,\n      fragmentName2,\n    );\n  } // (I) Then collect conflicts between the second collection of fields and\n  // those referenced by each fragment name associated with the first.\n\n  for (const fragmentName1 of fragmentNames1) {\n    collectConflictsBetweenFieldsAndFragment(\n      context,\n      conflicts,\n      cachedFieldsAndFragmentNames,\n      comparedFragmentPairs,\n      areMutuallyExclusive,\n      fieldMap2,\n      fragmentName1,\n    );\n  } // (J) Also collect conflicts between any fragment names by the first and\n  // fragment names by the second. This compares each item in the first set of\n  // names to each item in the second set of names.\n\n  for (const fragmentName1 of fragmentNames1) {\n    for (const fragmentName2 of fragmentNames2) {\n      collectConflictsBetweenFragments(\n        context,\n        conflicts,\n        cachedFieldsAndFragmentNames,\n        comparedFragmentPairs,\n        areMutuallyExclusive,\n        fragmentName1,\n        fragmentName2,\n      );\n    }\n  }\n\n  return conflicts;\n} // Collect all Conflicts \"within\" one collection of fields.\n\nfunction collectConflictsWithin(\n  context,\n  conflicts,\n  cachedFieldsAndFragmentNames,\n  comparedFragmentPairs,\n  fieldMap,\n) {\n  // A field map is a keyed collection, where each key represents a response\n  // name and the value at that key is a list of all fields which provide that\n  // response name. For every response name, if there are multiple fields, they\n  // must be compared to find a potential conflict.\n  for (const [responseName, fields] of Object.entries(fieldMap)) {\n    // This compares every field in the list to every other field in this list\n    // (except to itself). If the list only has one item, nothing needs to\n    // be compared.\n    if (fields.length > 1) {\n      for (let i = 0; i < fields.length; i++) {\n        for (let j = i + 1; j < fields.length; j++) {\n          const conflict = findConflict(\n            context,\n            cachedFieldsAndFragmentNames,\n            comparedFragmentPairs,\n            false, // within one collection is never mutually exclusive\n            responseName,\n            fields[i],\n            fields[j],\n          );\n\n          if (conflict) {\n            conflicts.push(conflict);\n          }\n        }\n      }\n    }\n  }\n} // Collect all Conflicts between two collections of fields. This is similar to,\n// but different from the `collectConflictsWithin` function above. This check\n// assumes that `collectConflictsWithin` has already been called on each\n// provided collection of fields. This is true because this validator traverses\n// each individual selection set.\n\nfunction collectConflictsBetween(\n  context,\n  conflicts,\n  cachedFieldsAndFragmentNames,\n  comparedFragmentPairs,\n  parentFieldsAreMutuallyExclusive,\n  fieldMap1,\n  fieldMap2,\n) {\n  // A field map is a keyed collection, where each key represents a response\n  // name and the value at that key is a list of all fields which provide that\n  // response name. For any response name which appears in both provided field\n  // maps, each field from the first field map must be compared to every field\n  // in the second field map to find potential conflicts.\n  for (const [responseName, fields1] of Object.entries(fieldMap1)) {\n    const fields2 = fieldMap2[responseName];\n\n    if (fields2) {\n      for (const field1 of fields1) {\n        for (const field2 of fields2) {\n          const conflict = findConflict(\n            context,\n            cachedFieldsAndFragmentNames,\n            comparedFragmentPairs,\n            parentFieldsAreMutuallyExclusive,\n            responseName,\n            field1,\n            field2,\n          );\n\n          if (conflict) {\n            conflicts.push(conflict);\n          }\n        }\n      }\n    }\n  }\n} // Determines if there is a conflict between two particular fields, including\n// comparing their sub-fields.\n\nfunction findConflict(\n  context,\n  cachedFieldsAndFragmentNames,\n  comparedFragmentPairs,\n  parentFieldsAreMutuallyExclusive,\n  responseName,\n  field1,\n  field2,\n) {\n  const [parentType1, node1, def1] = field1;\n  const [parentType2, node2, def2] = field2; // If it is known that two fields could not possibly apply at the same\n  // time, due to the parent types, then it is safe to permit them to diverge\n  // in aliased field or arguments used as they will not present any ambiguity\n  // by differing.\n  // It is known that two parent types could never overlap if they are\n  // different Object types. Interface or Union types might overlap - if not\n  // in the current state of the schema, then perhaps in some future version,\n  // thus may not safely diverge.\n\n  const areMutuallyExclusive =\n    parentFieldsAreMutuallyExclusive ||\n    (parentType1 !== parentType2 &&\n      isObjectType(parentType1) &&\n      isObjectType(parentType2));\n\n  if (!areMutuallyExclusive) {\n    // Two aliases must refer to the same field.\n    const name1 = node1.name.value;\n    const name2 = node2.name.value;\n\n    if (name1 !== name2) {\n      return [\n        [responseName, `\"${name1}\" and \"${name2}\" are different fields`],\n        [node1],\n        [node2],\n      ];\n    } // Two field calls must have the same arguments.\n\n    if (stringifyArguments(node1) !== stringifyArguments(node2)) {\n      return [\n        [responseName, 'they have differing arguments'],\n        [node1],\n        [node2],\n      ];\n    }\n  } // The return type for each field.\n\n  const type1 = def1 === null || def1 === void 0 ? void 0 : def1.type;\n  const type2 = def2 === null || def2 === void 0 ? void 0 : def2.type;\n\n  if (type1 && type2 && doTypesConflict(type1, type2)) {\n    return [\n      [\n        responseName,\n        `they return conflicting types \"${inspect(type1)}\" and \"${inspect(\n          type2,\n        )}\"`,\n      ],\n      [node1],\n      [node2],\n    ];\n  } // Collect and compare sub-fields. Use the same \"visited fragment names\" list\n  // for both collections so fields in a fragment reference are never\n  // compared to themselves.\n\n  const selectionSet1 = node1.selectionSet;\n  const selectionSet2 = node2.selectionSet;\n\n  if (selectionSet1 && selectionSet2) {\n    const conflicts = findConflictsBetweenSubSelectionSets(\n      context,\n      cachedFieldsAndFragmentNames,\n      comparedFragmentPairs,\n      areMutuallyExclusive,\n      getNamedType(type1),\n      selectionSet1,\n      getNamedType(type2),\n      selectionSet2,\n    );\n    return subfieldConflicts(conflicts, responseName, node1, node2);\n  }\n}\n\nfunction stringifyArguments(fieldNode) {\n  var _fieldNode$arguments;\n\n  // FIXME https://github.com/graphql/graphql-js/issues/2203\n  const args =\n    /* c8 ignore next */\n    (_fieldNode$arguments = fieldNode.arguments) !== null &&\n    _fieldNode$arguments !== void 0\n      ? _fieldNode$arguments\n      : [];\n  const inputObjectWithArgs = {\n    kind: Kind.OBJECT,\n    fields: args.map((argNode) => ({\n      kind: Kind.OBJECT_FIELD,\n      name: argNode.name,\n      value: argNode.value,\n    })),\n  };\n  return print(sortValueNode(inputObjectWithArgs));\n} // Two types conflict if both types could not apply to a value simultaneously.\n// Composite types are ignored as their individual field types will be compared\n// later recursively. However List and Non-Null types must match.\n\nfunction doTypesConflict(type1, type2) {\n  if (isListType(type1)) {\n    return isListType(type2)\n      ? doTypesConflict(type1.ofType, type2.ofType)\n      : true;\n  }\n\n  if (isListType(type2)) {\n    return true;\n  }\n\n  if (isNonNullType(type1)) {\n    return isNonNullType(type2)\n      ? doTypesConflict(type1.ofType, type2.ofType)\n      : true;\n  }\n\n  if (isNonNullType(type2)) {\n    return true;\n  }\n\n  if (isLeafType(type1) || isLeafType(type2)) {\n    return type1 !== type2;\n  }\n\n  return false;\n} // Given a selection set, return the collection of fields (a mapping of response\n// name to field nodes and definitions) as well as a list of fragment names\n// referenced via fragment spreads.\n\nfunction getFieldsAndFragmentNames(\n  context,\n  cachedFieldsAndFragmentNames,\n  parentType,\n  selectionSet,\n) {\n  const cached = cachedFieldsAndFragmentNames.get(selectionSet);\n\n  if (cached) {\n    return cached;\n  }\n\n  const nodeAndDefs = Object.create(null);\n  const fragmentNames = Object.create(null);\n\n  _collectFieldsAndFragmentNames(\n    context,\n    parentType,\n    selectionSet,\n    nodeAndDefs,\n    fragmentNames,\n  );\n\n  const result = [nodeAndDefs, Object.keys(fragmentNames)];\n  cachedFieldsAndFragmentNames.set(selectionSet, result);\n  return result;\n} // Given a reference to a fragment, return the represented collection of fields\n// as well as a list of nested fragment names referenced via fragment spreads.\n\nfunction getReferencedFieldsAndFragmentNames(\n  context,\n  cachedFieldsAndFragmentNames,\n  fragment,\n) {\n  // Short-circuit building a type from the node if possible.\n  const cached = cachedFieldsAndFragmentNames.get(fragment.selectionSet);\n\n  if (cached) {\n    return cached;\n  }\n\n  const fragmentType = typeFromAST(context.getSchema(), fragment.typeCondition);\n  return getFieldsAndFragmentNames(\n    context,\n    cachedFieldsAndFragmentNames,\n    fragmentType,\n    fragment.selectionSet,\n  );\n}\n\nfunction _collectFieldsAndFragmentNames(\n  context,\n  parentType,\n  selectionSet,\n  nodeAndDefs,\n  fragmentNames,\n) {\n  for (const selection of selectionSet.selections) {\n    switch (selection.kind) {\n      case Kind.FIELD: {\n        const fieldName = selection.name.value;\n        let fieldDef;\n\n        if (isObjectType(parentType) || isInterfaceType(parentType)) {\n          fieldDef = parentType.getFields()[fieldName];\n        }\n\n        const responseName = selection.alias\n          ? selection.alias.value\n          : fieldName;\n\n        if (!nodeAndDefs[responseName]) {\n          nodeAndDefs[responseName] = [];\n        }\n\n        nodeAndDefs[responseName].push([parentType, selection, fieldDef]);\n        break;\n      }\n\n      case Kind.FRAGMENT_SPREAD:\n        fragmentNames[selection.name.value] = true;\n        break;\n\n      case Kind.INLINE_FRAGMENT: {\n        const typeCondition = selection.typeCondition;\n        const inlineFragmentType = typeCondition\n          ? typeFromAST(context.getSchema(), typeCondition)\n          : parentType;\n\n        _collectFieldsAndFragmentNames(\n          context,\n          inlineFragmentType,\n          selection.selectionSet,\n          nodeAndDefs,\n          fragmentNames,\n        );\n\n        break;\n      }\n    }\n  }\n} // Given a series of Conflicts which occurred between two sub-fields, generate\n// a single Conflict.\n\nfunction subfieldConflicts(conflicts, responseName, node1, node2) {\n  if (conflicts.length > 0) {\n    return [\n      [responseName, conflicts.map(([reason]) => reason)],\n      [node1, ...conflicts.map(([, fields1]) => fields1).flat()],\n      [node2, ...conflicts.map(([, , fields2]) => fields2).flat()],\n    ];\n  }\n}\n/**\n * A way to keep track of pairs of things when the ordering of the pair does not matter.\n */\n\nclass PairSet {\n  constructor() {\n    this._data = new Map();\n  }\n\n  has(a, b, areMutuallyExclusive) {\n    var _this$_data$get;\n\n    const [key1, key2] = a < b ? [a, b] : [b, a];\n    const result =\n      (_this$_data$get = this._data.get(key1)) === null ||\n      _this$_data$get === void 0\n        ? void 0\n        : _this$_data$get.get(key2);\n\n    if (result === undefined) {\n      return false;\n    } // areMutuallyExclusive being false is a superset of being true, hence if\n    // we want to know if this PairSet \"has\" these two with no exclusivity,\n    // we have to ensure it was added as such.\n\n    return areMutuallyExclusive ? true : areMutuallyExclusive === result;\n  }\n\n  add(a, b, areMutuallyExclusive) {\n    const [key1, key2] = a < b ? [a, b] : [b, a];\n\n    const map = this._data.get(key1);\n\n    if (map === undefined) {\n      this._data.set(key1, new Map([[key2, areMutuallyExclusive]]));\n    } else {\n      map.set(key2, areMutuallyExclusive);\n    }\n  }\n}\n","import { inspect } from '../../jsutils/inspect.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { isCompositeType } from '../../type/definition.mjs';\nimport { doTypesOverlap } from '../../utilities/typeComparators.mjs';\nimport { typeFromAST } from '../../utilities/typeFromAST.mjs';\n\n/**\n * Possible fragment spread\n *\n * A fragment spread is only valid if the type condition could ever possibly\n * be true: if there is a non-empty intersection of the possible parent types,\n * and possible types which pass the type condition.\n */\nexport function PossibleFragmentSpreadsRule(context) {\n  return {\n    InlineFragment(node) {\n      const fragType = context.getType();\n      const parentType = context.getParentType();\n\n      if (\n        isCompositeType(fragType) &&\n        isCompositeType(parentType) &&\n        !doTypesOverlap(context.getSchema(), fragType, parentType)\n      ) {\n        const parentTypeStr = inspect(parentType);\n        const fragTypeStr = inspect(fragType);\n        context.reportError(\n          new GraphQLError(\n            `Fragment cannot be spread here as objects of type \"${parentTypeStr}\" can never be of type \"${fragTypeStr}\".`,\n            {\n              nodes: node,\n            },\n          ),\n        );\n      }\n    },\n\n    FragmentSpread(node) {\n      const fragName = node.name.value;\n      const fragType = getFragmentType(context, fragName);\n      const parentType = context.getParentType();\n\n      if (\n        fragType &&\n        parentType &&\n        !doTypesOverlap(context.getSchema(), fragType, parentType)\n      ) {\n        const parentTypeStr = inspect(parentType);\n        const fragTypeStr = inspect(fragType);\n        context.reportError(\n          new GraphQLError(\n            `Fragment \"${fragName}\" cannot be spread here as objects of type \"${parentTypeStr}\" can never be of type \"${fragTypeStr}\".`,\n            {\n              nodes: node,\n            },\n          ),\n        );\n      }\n    },\n  };\n}\n\nfunction getFragmentType(context, name) {\n  const frag = context.getFragment(name);\n\n  if (frag) {\n    const type = typeFromAST(context.getSchema(), frag.typeCondition);\n\n    if (isCompositeType(type)) {\n      return type;\n    }\n  }\n}\n","import { didYouMean } from '../../jsutils/didYouMean.mjs';\nimport { inspect } from '../../jsutils/inspect.mjs';\nimport { invariant } from '../../jsutils/invariant.mjs';\nimport { suggestionList } from '../../jsutils/suggestionList.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { Kind } from '../../language/kinds.mjs';\nimport { isTypeDefinitionNode } from '../../language/predicates.mjs';\nimport {\n  isEnumType,\n  isInputObjectType,\n  isInterfaceType,\n  isObjectType,\n  isScalarType,\n  isUnionType,\n} from '../../type/definition.mjs';\n\n/**\n * Possible type extension\n *\n * A type extension is only valid if the type is defined and has the same kind.\n */\nexport function PossibleTypeExtensionsRule(context) {\n  const schema = context.getSchema();\n  const definedTypes = Object.create(null);\n\n  for (const def of context.getDocument().definitions) {\n    if (isTypeDefinitionNode(def)) {\n      definedTypes[def.name.value] = def;\n    }\n  }\n\n  return {\n    ScalarTypeExtension: checkExtension,\n    ObjectTypeExtension: checkExtension,\n    InterfaceTypeExtension: checkExtension,\n    UnionTypeExtension: checkExtension,\n    EnumTypeExtension: checkExtension,\n    InputObjectTypeExtension: checkExtension,\n  };\n\n  function checkExtension(node) {\n    const typeName = node.name.value;\n    const defNode = definedTypes[typeName];\n    const existingType =\n      schema === null || schema === void 0 ? void 0 : schema.getType(typeName);\n    let expectedKind;\n\n    if (defNode) {\n      expectedKind = defKindToExtKind[defNode.kind];\n    } else if (existingType) {\n      expectedKind = typeToExtKind(existingType);\n    }\n\n    if (expectedKind) {\n      if (expectedKind !== node.kind) {\n        const kindStr = extensionKindToTypeName(node.kind);\n        context.reportError(\n          new GraphQLError(`Cannot extend non-${kindStr} type \"${typeName}\".`, {\n            nodes: defNode ? [defNode, node] : node,\n          }),\n        );\n      }\n    } else {\n      const allTypeNames = Object.keys({\n        ...definedTypes,\n        ...(schema === null || schema === void 0\n          ? void 0\n          : schema.getTypeMap()),\n      });\n      const suggestedTypes = suggestionList(typeName, allTypeNames);\n      context.reportError(\n        new GraphQLError(\n          `Cannot extend type \"${typeName}\" because it is not defined.` +\n            didYouMean(suggestedTypes),\n          {\n            nodes: node.name,\n          },\n        ),\n      );\n    }\n  }\n}\nconst defKindToExtKind = {\n  [Kind.SCALAR_TYPE_DEFINITION]: Kind.SCALAR_TYPE_EXTENSION,\n  [Kind.OBJECT_TYPE_DEFINITION]: Kind.OBJECT_TYPE_EXTENSION,\n  [Kind.INTERFACE_TYPE_DEFINITION]: Kind.INTERFACE_TYPE_EXTENSION,\n  [Kind.UNION_TYPE_DEFINITION]: Kind.UNION_TYPE_EXTENSION,\n  [Kind.ENUM_TYPE_DEFINITION]: Kind.ENUM_TYPE_EXTENSION,\n  [Kind.INPUT_OBJECT_TYPE_DEFINITION]: Kind.INPUT_OBJECT_TYPE_EXTENSION,\n};\n\nfunction typeToExtKind(type) {\n  if (isScalarType(type)) {\n    return Kind.SCALAR_TYPE_EXTENSION;\n  }\n\n  if (isObjectType(type)) {\n    return Kind.OBJECT_TYPE_EXTENSION;\n  }\n\n  if (isInterfaceType(type)) {\n    return Kind.INTERFACE_TYPE_EXTENSION;\n  }\n\n  if (isUnionType(type)) {\n    return Kind.UNION_TYPE_EXTENSION;\n  }\n\n  if (isEnumType(type)) {\n    return Kind.ENUM_TYPE_EXTENSION;\n  }\n\n  if (isInputObjectType(type)) {\n    return Kind.INPUT_OBJECT_TYPE_EXTENSION;\n  }\n  /* c8 ignore next 3 */\n  // Not reachable. All possible types have been considered\n\n  false || invariant(false, 'Unexpected type: ' + inspect(type));\n}\n\nfunction extensionKindToTypeName(kind) {\n  switch (kind) {\n    case Kind.SCALAR_TYPE_EXTENSION:\n      return 'scalar';\n\n    case Kind.OBJECT_TYPE_EXTENSION:\n      return 'object';\n\n    case Kind.INTERFACE_TYPE_EXTENSION:\n      return 'interface';\n\n    case Kind.UNION_TYPE_EXTENSION:\n      return 'union';\n\n    case Kind.ENUM_TYPE_EXTENSION:\n      return 'enum';\n\n    case Kind.INPUT_OBJECT_TYPE_EXTENSION:\n      return 'input object';\n    // Not reachable. All possible types have been considered\n\n    /* c8 ignore next */\n\n    default:\n      false || invariant(false, 'Unexpected kind: ' + inspect(kind));\n  }\n}\n","import { inspect } from '../../jsutils/inspect.mjs';\nimport { keyMap } from '../../jsutils/keyMap.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { Kind } from '../../language/kinds.mjs';\nimport { print } from '../../language/printer.mjs';\nimport { isRequiredArgument, isType } from '../../type/definition.mjs';\nimport { specifiedDirectives } from '../../type/directives.mjs';\n\n/**\n * Provided required arguments\n *\n * A field or directive is only valid if all required (non-null without a\n * default value) field arguments have been provided.\n */\nexport function ProvidedRequiredArgumentsRule(context) {\n  return {\n    // eslint-disable-next-line new-cap\n    ...ProvidedRequiredArgumentsOnDirectivesRule(context),\n    Field: {\n      // Validate on leave to allow for deeper errors to appear first.\n      leave(fieldNode) {\n        var _fieldNode$arguments;\n\n        const fieldDef = context.getFieldDef();\n\n        if (!fieldDef) {\n          return false;\n        }\n\n        const providedArgs = new Set( // FIXME: https://github.com/graphql/graphql-js/issues/2203\n          /* c8 ignore next */\n          (_fieldNode$arguments = fieldNode.arguments) === null ||\n          _fieldNode$arguments === void 0\n            ? void 0\n            : _fieldNode$arguments.map((arg) => arg.name.value),\n        );\n\n        for (const argDef of fieldDef.args) {\n          if (!providedArgs.has(argDef.name) && isRequiredArgument(argDef)) {\n            const argTypeStr = inspect(argDef.type);\n            context.reportError(\n              new GraphQLError(\n                `Field \"${fieldDef.name}\" argument \"${argDef.name}\" of type \"${argTypeStr}\" is required, but it was not provided.`,\n                {\n                  nodes: fieldNode,\n                },\n              ),\n            );\n          }\n        }\n      },\n    },\n  };\n}\n/**\n * @internal\n */\n\nexport function ProvidedRequiredArgumentsOnDirectivesRule(context) {\n  var _schema$getDirectives;\n\n  const requiredArgsMap = Object.create(null);\n  const schema = context.getSchema();\n  const definedDirectives =\n    (_schema$getDirectives =\n      schema === null || schema === void 0\n        ? void 0\n        : schema.getDirectives()) !== null && _schema$getDirectives !== void 0\n      ? _schema$getDirectives\n      : specifiedDirectives;\n\n  for (const directive of definedDirectives) {\n    requiredArgsMap[directive.name] = keyMap(\n      directive.args.filter(isRequiredArgument),\n      (arg) => arg.name,\n    );\n  }\n\n  const astDefinitions = context.getDocument().definitions;\n\n  for (const def of astDefinitions) {\n    if (def.kind === Kind.DIRECTIVE_DEFINITION) {\n      var _def$arguments;\n\n      // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n      /* c8 ignore next */\n      const argNodes =\n        (_def$arguments = def.arguments) !== null && _def$arguments !== void 0\n          ? _def$arguments\n          : [];\n      requiredArgsMap[def.name.value] = keyMap(\n        argNodes.filter(isRequiredArgumentNode),\n        (arg) => arg.name.value,\n      );\n    }\n  }\n\n  return {\n    Directive: {\n      // Validate on leave to allow for deeper errors to appear first.\n      leave(directiveNode) {\n        const directiveName = directiveNode.name.value;\n        const requiredArgs = requiredArgsMap[directiveName];\n\n        if (requiredArgs) {\n          var _directiveNode$argume;\n\n          // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n          /* c8 ignore next */\n          const argNodes =\n            (_directiveNode$argume = directiveNode.arguments) !== null &&\n            _directiveNode$argume !== void 0\n              ? _directiveNode$argume\n              : [];\n          const argNodeMap = new Set(argNodes.map((arg) => arg.name.value));\n\n          for (const [argName, argDef] of Object.entries(requiredArgs)) {\n            if (!argNodeMap.has(argName)) {\n              const argType = isType(argDef.type)\n                ? inspect(argDef.type)\n                : print(argDef.type);\n              context.reportError(\n                new GraphQLError(\n                  `Directive \"@${directiveName}\" argument \"${argName}\" of type \"${argType}\" is required, but it was not provided.`,\n                  {\n                    nodes: directiveNode,\n                  },\n                ),\n              );\n            }\n          }\n        }\n      },\n    },\n  };\n}\n\nfunction isRequiredArgumentNode(arg) {\n  return arg.type.kind === Kind.NON_NULL_TYPE && arg.defaultValue == null;\n}\n","import { inspect } from '../../jsutils/inspect.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { getNamedType, isLeafType } from '../../type/definition.mjs';\n\n/**\n * Scalar leafs\n *\n * A GraphQL document is valid only if all leaf fields (fields without\n * sub selections) are of scalar or enum types.\n */\nexport function ScalarLeafsRule(context) {\n  return {\n    Field(node) {\n      const type = context.getType();\n      const selectionSet = node.selectionSet;\n\n      if (type) {\n        if (isLeafType(getNamedType(type))) {\n          if (selectionSet) {\n            const fieldName = node.name.value;\n            const typeStr = inspect(type);\n            context.reportError(\n              new GraphQLError(\n                `Field \"${fieldName}\" must not have a selection since type \"${typeStr}\" has no subfields.`,\n                {\n                  nodes: selectionSet,\n                },\n              ),\n            );\n          }\n        } else if (!selectionSet) {\n          const fieldName = node.name.value;\n          const typeStr = inspect(type);\n          context.reportError(\n            new GraphQLError(\n              `Field \"${fieldName}\" of type \"${typeStr}\" must have a selection of subfields. Did you mean \"${fieldName} { ... }\"?`,\n              {\n                nodes: node,\n              },\n            ),\n          );\n        }\n      }\n    },\n  };\n}\n","/**\n * Build a string describing the path.\n */\nexport function printPathArray(path) {\n  return path\n    .map((key) =>\n      typeof key === 'number' ? '[' + key.toString() + ']' : '.' + key,\n    )\n    .join('');\n}\n","/**\n * Given a Path and a key, return a new Path containing the new key.\n */\nexport function addPath(prev, key, typename) {\n  return {\n    prev,\n    key,\n    typename,\n  };\n}\n/**\n * Given a Path, return an Array of the path keys.\n */\n\nexport function pathToArray(path) {\n  const flattened = [];\n  let curr = path;\n\n  while (curr) {\n    flattened.push(curr.key);\n    curr = curr.prev;\n  }\n\n  return flattened.reverse();\n}\n","import { didYouMean } from '../jsutils/didYouMean.mjs';\nimport { inspect } from '../jsutils/inspect.mjs';\nimport { invariant } from '../jsutils/invariant.mjs';\nimport { isIterableObject } from '../jsutils/isIterableObject.mjs';\nimport { isObjectLike } from '../jsutils/isObjectLike.mjs';\nimport { addPath, pathToArray } from '../jsutils/Path.mjs';\nimport { printPathArray } from '../jsutils/printPathArray.mjs';\nimport { suggestionList } from '../jsutils/suggestionList.mjs';\nimport { GraphQLError } from '../error/GraphQLError.mjs';\nimport {\n  isInputObjectType,\n  isLeafType,\n  isListType,\n  isNonNullType,\n} from '../type/definition.mjs';\n\n/**\n * Coerces a JavaScript value given a GraphQL Input Type.\n */\nexport function coerceInputValue(inputValue, type, onError = defaultOnError) {\n  return coerceInputValueImpl(inputValue, type, onError, undefined);\n}\n\nfunction defaultOnError(path, invalidValue, error) {\n  let errorPrefix = 'Invalid value ' + inspect(invalidValue);\n\n  if (path.length > 0) {\n    errorPrefix += ` at \"value${printPathArray(path)}\"`;\n  }\n\n  error.message = errorPrefix + ': ' + error.message;\n  throw error;\n}\n\nfunction coerceInputValueImpl(inputValue, type, onError, path) {\n  if (isNonNullType(type)) {\n    if (inputValue != null) {\n      return coerceInputValueImpl(inputValue, type.ofType, onError, path);\n    }\n\n    onError(\n      pathToArray(path),\n      inputValue,\n      new GraphQLError(\n        `Expected non-nullable type \"${inspect(type)}\" not to be null.`,\n      ),\n    );\n    return;\n  }\n\n  if (inputValue == null) {\n    // Explicitly return the value null.\n    return null;\n  }\n\n  if (isListType(type)) {\n    const itemType = type.ofType;\n\n    if (isIterableObject(inputValue)) {\n      return Array.from(inputValue, (itemValue, index) => {\n        const itemPath = addPath(path, index, undefined);\n        return coerceInputValueImpl(itemValue, itemType, onError, itemPath);\n      });\n    } // Lists accept a non-list value as a list of one.\n\n    return [coerceInputValueImpl(inputValue, itemType, onError, path)];\n  }\n\n  if (isInputObjectType(type)) {\n    if (!isObjectLike(inputValue)) {\n      onError(\n        pathToArray(path),\n        inputValue,\n        new GraphQLError(`Expected type \"${type.name}\" to be an object.`),\n      );\n      return;\n    }\n\n    const coercedValue = {};\n    const fieldDefs = type.getFields();\n\n    for (const field of Object.values(fieldDefs)) {\n      const fieldValue = inputValue[field.name];\n\n      if (fieldValue === undefined) {\n        if (field.defaultValue !== undefined) {\n          coercedValue[field.name] = field.defaultValue;\n        } else if (isNonNullType(field.type)) {\n          const typeStr = inspect(field.type);\n          onError(\n            pathToArray(path),\n            inputValue,\n            new GraphQLError(\n              `Field \"${field.name}\" of required type \"${typeStr}\" was not provided.`,\n            ),\n          );\n        }\n\n        continue;\n      }\n\n      coercedValue[field.name] = coerceInputValueImpl(\n        fieldValue,\n        field.type,\n        onError,\n        addPath(path, field.name, type.name),\n      );\n    } // Ensure every provided field is defined.\n\n    for (const fieldName of Object.keys(inputValue)) {\n      if (!fieldDefs[fieldName]) {\n        const suggestions = suggestionList(\n          fieldName,\n          Object.keys(type.getFields()),\n        );\n        onError(\n          pathToArray(path),\n          inputValue,\n          new GraphQLError(\n            `Field \"${fieldName}\" is not defined by type \"${type.name}\".` +\n              didYouMean(suggestions),\n          ),\n        );\n      }\n    }\n\n    return coercedValue;\n  }\n\n  if (isLeafType(type)) {\n    let parseResult; // Scalars and Enums determine if a input value is valid via parseValue(),\n    // which can throw to indicate failure. If it throws, maintain a reference\n    // to the original error.\n\n    try {\n      parseResult = type.parseValue(inputValue);\n    } catch (error) {\n      if (error instanceof GraphQLError) {\n        onError(pathToArray(path), inputValue, error);\n      } else {\n        onError(\n          pathToArray(path),\n          inputValue,\n          new GraphQLError(`Expected type \"${type.name}\". ` + error.message, {\n            originalError: error,\n          }),\n        );\n      }\n\n      return;\n    }\n\n    if (parseResult === undefined) {\n      onError(\n        pathToArray(path),\n        inputValue,\n        new GraphQLError(`Expected type \"${type.name}\".`),\n      );\n    }\n\n    return parseResult;\n  }\n  /* c8 ignore next 3 */\n  // Not reachable, all possible types have been considered.\n\n  false || invariant(false, 'Unexpected input type: ' + inspect(type));\n}\n","import { inspect } from '../jsutils/inspect.mjs';\nimport { keyMap } from '../jsutils/keyMap.mjs';\nimport { printPathArray } from '../jsutils/printPathArray.mjs';\nimport { GraphQLError } from '../error/GraphQLError.mjs';\nimport { Kind } from '../language/kinds.mjs';\nimport { print } from '../language/printer.mjs';\nimport { isInputType, isNonNullType } from '../type/definition.mjs';\nimport { coerceInputValue } from '../utilities/coerceInputValue.mjs';\nimport { typeFromAST } from '../utilities/typeFromAST.mjs';\nimport { valueFromAST } from '../utilities/valueFromAST.mjs';\n\n/**\n * Prepares an object map of variableValues of the correct type based on the\n * provided variable definitions and arbitrary input. If the input cannot be\n * parsed to match the variable definitions, a GraphQLError will be thrown.\n *\n * Note: The returned value is a plain Object with a prototype, since it is\n * exposed to user code. Care should be taken to not pull values from the\n * Object prototype.\n */\nexport function getVariableValues(schema, varDefNodes, inputs, options) {\n  const errors = [];\n  const maxErrors =\n    options === null || options === void 0 ? void 0 : options.maxErrors;\n\n  try {\n    const coerced = coerceVariableValues(\n      schema,\n      varDefNodes,\n      inputs,\n      (error) => {\n        if (maxErrors != null && errors.length >= maxErrors) {\n          throw new GraphQLError(\n            'Too many errors processing variables, error limit reached. Execution aborted.',\n          );\n        }\n\n        errors.push(error);\n      },\n    );\n\n    if (errors.length === 0) {\n      return {\n        coerced,\n      };\n    }\n  } catch (error) {\n    errors.push(error);\n  }\n\n  return {\n    errors,\n  };\n}\n\nfunction coerceVariableValues(schema, varDefNodes, inputs, onError) {\n  const coercedValues = {};\n\n  for (const varDefNode of varDefNodes) {\n    const varName = varDefNode.variable.name.value;\n    const varType = typeFromAST(schema, varDefNode.type);\n\n    if (!isInputType(varType)) {\n      // Must use input types for variables. This should be caught during\n      // validation, however is checked again here for safety.\n      const varTypeStr = print(varDefNode.type);\n      onError(\n        new GraphQLError(\n          `Variable \"$${varName}\" expected value of type \"${varTypeStr}\" which cannot be used as an input type.`,\n          {\n            nodes: varDefNode.type,\n          },\n        ),\n      );\n      continue;\n    }\n\n    if (!hasOwnProperty(inputs, varName)) {\n      if (varDefNode.defaultValue) {\n        coercedValues[varName] = valueFromAST(varDefNode.defaultValue, varType);\n      } else if (isNonNullType(varType)) {\n        const varTypeStr = inspect(varType);\n        onError(\n          new GraphQLError(\n            `Variable \"$${varName}\" of required type \"${varTypeStr}\" was not provided.`,\n            {\n              nodes: varDefNode,\n            },\n          ),\n        );\n      }\n\n      continue;\n    }\n\n    const value = inputs[varName];\n\n    if (value === null && isNonNullType(varType)) {\n      const varTypeStr = inspect(varType);\n      onError(\n        new GraphQLError(\n          `Variable \"$${varName}\" of non-null type \"${varTypeStr}\" must not be null.`,\n          {\n            nodes: varDefNode,\n          },\n        ),\n      );\n      continue;\n    }\n\n    coercedValues[varName] = coerceInputValue(\n      value,\n      varType,\n      (path, invalidValue, error) => {\n        let prefix =\n          `Variable \"$${varName}\" got invalid value ` + inspect(invalidValue);\n\n        if (path.length > 0) {\n          prefix += ` at \"${varName}${printPathArray(path)}\"`;\n        }\n\n        onError(\n          new GraphQLError(prefix + '; ' + error.message, {\n            nodes: varDefNode,\n            originalError: error,\n          }),\n        );\n      },\n    );\n  }\n\n  return coercedValues;\n}\n/**\n * Prepares an object map of argument values given a list of argument\n * definitions and list of argument AST nodes.\n *\n * Note: The returned value is a plain Object with a prototype, since it is\n * exposed to user code. Care should be taken to not pull values from the\n * Object prototype.\n */\n\nexport function getArgumentValues(def, node, variableValues) {\n  var _node$arguments;\n\n  const coercedValues = {}; // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n  /* c8 ignore next */\n\n  const argumentNodes =\n    (_node$arguments = node.arguments) !== null && _node$arguments !== void 0\n      ? _node$arguments\n      : [];\n  const argNodeMap = keyMap(argumentNodes, (arg) => arg.name.value);\n\n  for (const argDef of def.args) {\n    const name = argDef.name;\n    const argType = argDef.type;\n    const argumentNode = argNodeMap[name];\n\n    if (!argumentNode) {\n      if (argDef.defaultValue !== undefined) {\n        coercedValues[name] = argDef.defaultValue;\n      } else if (isNonNullType(argType)) {\n        throw new GraphQLError(\n          `Argument \"${name}\" of required type \"${inspect(argType)}\" ` +\n            'was not provided.',\n          {\n            nodes: node,\n          },\n        );\n      }\n\n      continue;\n    }\n\n    const valueNode = argumentNode.value;\n    let isNull = valueNode.kind === Kind.NULL;\n\n    if (valueNode.kind === Kind.VARIABLE) {\n      const variableName = valueNode.name.value;\n\n      if (\n        variableValues == null ||\n        !hasOwnProperty(variableValues, variableName)\n      ) {\n        if (argDef.defaultValue !== undefined) {\n          coercedValues[name] = argDef.defaultValue;\n        } else if (isNonNullType(argType)) {\n          throw new GraphQLError(\n            `Argument \"${name}\" of required type \"${inspect(argType)}\" ` +\n              `was provided the variable \"$${variableName}\" which was not provided a runtime value.`,\n            {\n              nodes: valueNode,\n            },\n          );\n        }\n\n        continue;\n      }\n\n      isNull = variableValues[variableName] == null;\n    }\n\n    if (isNull && isNonNullType(argType)) {\n      throw new GraphQLError(\n        `Argument \"${name}\" of non-null type \"${inspect(argType)}\" ` +\n          'must not be null.',\n        {\n          nodes: valueNode,\n        },\n      );\n    }\n\n    const coercedValue = valueFromAST(valueNode, argType, variableValues);\n\n    if (coercedValue === undefined) {\n      // Note: ValuesOfCorrectTypeRule validation should catch this before\n      // execution. This is a runtime check to ensure execution does not\n      // continue with an invalid argument value.\n      throw new GraphQLError(\n        `Argument \"${name}\" has invalid value ${print(valueNode)}.`,\n        {\n          nodes: valueNode,\n        },\n      );\n    }\n\n    coercedValues[name] = coercedValue;\n  }\n\n  return coercedValues;\n}\n/**\n * Prepares an object map of argument values given a directive definition\n * and a AST node which may contain directives. Optionally also accepts a map\n * of variable values.\n *\n * If the directive does not exist on the node, returns undefined.\n *\n * Note: The returned value is a plain Object with a prototype, since it is\n * exposed to user code. Care should be taken to not pull values from the\n * Object prototype.\n */\n\nexport function getDirectiveValues(directiveDef, node, variableValues) {\n  var _node$directives;\n\n  const directiveNode =\n    (_node$directives = node.directives) === null || _node$directives === void 0\n      ? void 0\n      : _node$directives.find(\n          (directive) => directive.name.value === directiveDef.name,\n        );\n\n  if (directiveNode) {\n    return getArgumentValues(directiveDef, directiveNode, variableValues);\n  }\n}\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n","import { Kind } from '../language/kinds.mjs';\nimport { isAbstractType } from '../type/definition.mjs';\nimport {\n  GraphQLIncludeDirective,\n  GraphQLSkipDirective,\n} from '../type/directives.mjs';\nimport { typeFromAST } from '../utilities/typeFromAST.mjs';\nimport { getDirectiveValues } from './values.mjs';\n/**\n * Given a selectionSet, collects all of the fields and returns them.\n *\n * CollectFields requires the \"runtime type\" of an object. For a field that\n * returns an Interface or Union type, the \"runtime type\" will be the actual\n * object type returned by that field.\n *\n * @internal\n */\n\nexport function collectFields(\n  schema,\n  fragments,\n  variableValues,\n  runtimeType,\n  selectionSet,\n) {\n  const fields = new Map();\n  collectFieldsImpl(\n    schema,\n    fragments,\n    variableValues,\n    runtimeType,\n    selectionSet,\n    fields,\n    new Set(),\n  );\n  return fields;\n}\n/**\n * Given an array of field nodes, collects all of the subfields of the passed\n * in fields, and returns them at the end.\n *\n * CollectSubFields requires the \"return type\" of an object. For a field that\n * returns an Interface or Union type, the \"return type\" will be the actual\n * object type returned by that field.\n *\n * @internal\n */\n\nexport function collectSubfields(\n  schema,\n  fragments,\n  variableValues,\n  returnType,\n  fieldNodes,\n) {\n  const subFieldNodes = new Map();\n  const visitedFragmentNames = new Set();\n\n  for (const node of fieldNodes) {\n    if (node.selectionSet) {\n      collectFieldsImpl(\n        schema,\n        fragments,\n        variableValues,\n        returnType,\n        node.selectionSet,\n        subFieldNodes,\n        visitedFragmentNames,\n      );\n    }\n  }\n\n  return subFieldNodes;\n}\n\nfunction collectFieldsImpl(\n  schema,\n  fragments,\n  variableValues,\n  runtimeType,\n  selectionSet,\n  fields,\n  visitedFragmentNames,\n) {\n  for (const selection of selectionSet.selections) {\n    switch (selection.kind) {\n      case Kind.FIELD: {\n        if (!shouldIncludeNode(variableValues, selection)) {\n          continue;\n        }\n\n        const name = getFieldEntryKey(selection);\n        const fieldList = fields.get(name);\n\n        if (fieldList !== undefined) {\n          fieldList.push(selection);\n        } else {\n          fields.set(name, [selection]);\n        }\n\n        break;\n      }\n\n      case Kind.INLINE_FRAGMENT: {\n        if (\n          !shouldIncludeNode(variableValues, selection) ||\n          !doesFragmentConditionMatch(schema, selection, runtimeType)\n        ) {\n          continue;\n        }\n\n        collectFieldsImpl(\n          schema,\n          fragments,\n          variableValues,\n          runtimeType,\n          selection.selectionSet,\n          fields,\n          visitedFragmentNames,\n        );\n        break;\n      }\n\n      case Kind.FRAGMENT_SPREAD: {\n        const fragName = selection.name.value;\n\n        if (\n          visitedFragmentNames.has(fragName) ||\n          !shouldIncludeNode(variableValues, selection)\n        ) {\n          continue;\n        }\n\n        visitedFragmentNames.add(fragName);\n        const fragment = fragments[fragName];\n\n        if (\n          !fragment ||\n          !doesFragmentConditionMatch(schema, fragment, runtimeType)\n        ) {\n          continue;\n        }\n\n        collectFieldsImpl(\n          schema,\n          fragments,\n          variableValues,\n          runtimeType,\n          fragment.selectionSet,\n          fields,\n          visitedFragmentNames,\n        );\n        break;\n      }\n    }\n  }\n}\n/**\n * Determines if a field should be included based on the `@include` and `@skip`\n * directives, where `@skip` has higher precedence than `@include`.\n */\n\nfunction shouldIncludeNode(variableValues, node) {\n  const skip = getDirectiveValues(GraphQLSkipDirective, node, variableValues);\n\n  if ((skip === null || skip === void 0 ? void 0 : skip.if) === true) {\n    return false;\n  }\n\n  const include = getDirectiveValues(\n    GraphQLIncludeDirective,\n    node,\n    variableValues,\n  );\n\n  if (\n    (include === null || include === void 0 ? void 0 : include.if) === false\n  ) {\n    return false;\n  }\n\n  return true;\n}\n/**\n * Determines if a fragment is applicable to the given type.\n */\n\nfunction doesFragmentConditionMatch(schema, fragment, type) {\n  const typeConditionNode = fragment.typeCondition;\n\n  if (!typeConditionNode) {\n    return true;\n  }\n\n  const conditionalType = typeFromAST(schema, typeConditionNode);\n\n  if (conditionalType === type) {\n    return true;\n  }\n\n  if (isAbstractType(conditionalType)) {\n    return schema.isSubType(conditionalType, type);\n  }\n\n  return false;\n}\n/**\n * Implements the logic to compute the key of a given field's entry\n */\n\nfunction getFieldEntryKey(node) {\n  return node.alias ? node.alias.value : node.name.value;\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { Kind } from '../../language/kinds.mjs';\nimport { collectFields } from '../../execution/collectFields.mjs';\n\n/**\n * Subscriptions must only include a non-introspection field.\n *\n * A GraphQL subscription is valid only if it contains a single root field and\n * that root field is not an introspection field.\n *\n * See https://spec.graphql.org/draft/#sec-Single-root-field\n */\nexport function SingleFieldSubscriptionsRule(context) {\n  return {\n    OperationDefinition(node) {\n      if (node.operation === 'subscription') {\n        const schema = context.getSchema();\n        const subscriptionType = schema.getSubscriptionType();\n\n        if (subscriptionType) {\n          const operationName = node.name ? node.name.value : null;\n          const variableValues = Object.create(null);\n          const document = context.getDocument();\n          const fragments = Object.create(null);\n\n          for (const definition of document.definitions) {\n            if (definition.kind === Kind.FRAGMENT_DEFINITION) {\n              fragments[definition.name.value] = definition;\n            }\n          }\n\n          const fields = collectFields(\n            schema,\n            fragments,\n            variableValues,\n            subscriptionType,\n            node.selectionSet,\n          );\n\n          if (fields.size > 1) {\n            const fieldSelectionLists = [...fields.values()];\n            const extraFieldSelectionLists = fieldSelectionLists.slice(1);\n            const extraFieldSelections = extraFieldSelectionLists.flat();\n            context.reportError(\n              new GraphQLError(\n                operationName != null\n                  ? `Subscription \"${operationName}\" must select only one top level field.`\n                  : 'Anonymous Subscription must select only one top level field.',\n                {\n                  nodes: extraFieldSelections,\n                },\n              ),\n            );\n          }\n\n          for (const fieldNodes of fields.values()) {\n            const field = fieldNodes[0];\n            const fieldName = field.name.value;\n\n            if (fieldName.startsWith('__')) {\n              context.reportError(\n                new GraphQLError(\n                  operationName != null\n                    ? `Subscription \"${operationName}\" must not select an introspection top level field.`\n                    : 'Anonymous Subscription must not select an introspection top level field.',\n                  {\n                    nodes: fieldNodes,\n                  },\n                ),\n              );\n            }\n          }\n        }\n      }\n    },\n  };\n}\n","/**\n * Groups array items into a Map, given a function to produce grouping key.\n */\nexport function groupBy(list, keyFn) {\n  const result = new Map();\n\n  for (const item of list) {\n    const key = keyFn(item);\n    const group = result.get(key);\n\n    if (group === undefined) {\n      result.set(key, [item]);\n    } else {\n      group.push(item);\n    }\n  }\n\n  return result;\n}\n","import { groupBy } from '../../jsutils/groupBy.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique argument definition names\n *\n * A GraphQL Object or Interface type is only valid if all its fields have uniquely named arguments.\n * A GraphQL Directive is only valid if all its arguments are uniquely named.\n */\nexport function UniqueArgumentDefinitionNamesRule(context) {\n  return {\n    DirectiveDefinition(directiveNode) {\n      var _directiveNode$argume;\n\n      // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n      /* c8 ignore next */\n      const argumentNodes =\n        (_directiveNode$argume = directiveNode.arguments) !== null &&\n        _directiveNode$argume !== void 0\n          ? _directiveNode$argume\n          : [];\n      return checkArgUniqueness(`@${directiveNode.name.value}`, argumentNodes);\n    },\n\n    InterfaceTypeDefinition: checkArgUniquenessPerField,\n    InterfaceTypeExtension: checkArgUniquenessPerField,\n    ObjectTypeDefinition: checkArgUniquenessPerField,\n    ObjectTypeExtension: checkArgUniquenessPerField,\n  };\n\n  function checkArgUniquenessPerField(typeNode) {\n    var _typeNode$fields;\n\n    const typeName = typeNode.name.value; // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n    /* c8 ignore next */\n\n    const fieldNodes =\n      (_typeNode$fields = typeNode.fields) !== null &&\n      _typeNode$fields !== void 0\n        ? _typeNode$fields\n        : [];\n\n    for (const fieldDef of fieldNodes) {\n      var _fieldDef$arguments;\n\n      const fieldName = fieldDef.name.value; // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n      /* c8 ignore next */\n\n      const argumentNodes =\n        (_fieldDef$arguments = fieldDef.arguments) !== null &&\n        _fieldDef$arguments !== void 0\n          ? _fieldDef$arguments\n          : [];\n      checkArgUniqueness(`${typeName}.${fieldName}`, argumentNodes);\n    }\n\n    return false;\n  }\n\n  function checkArgUniqueness(parentName, argumentNodes) {\n    const seenArgs = groupBy(argumentNodes, (arg) => arg.name.value);\n\n    for (const [argName, argNodes] of seenArgs) {\n      if (argNodes.length > 1) {\n        context.reportError(\n          new GraphQLError(\n            `Argument \"${parentName}(${argName}:)\" can only be defined once.`,\n            {\n              nodes: argNodes.map((node) => node.name),\n            },\n          ),\n        );\n      }\n    }\n\n    return false;\n  }\n}\n","import { groupBy } from '../../jsutils/groupBy.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique argument names\n *\n * A GraphQL field or directive is only valid if all supplied arguments are\n * uniquely named.\n *\n * See https://spec.graphql.org/draft/#sec-Argument-Names\n */\nexport function UniqueArgumentNamesRule(context) {\n  return {\n    Field: checkArgUniqueness,\n    Directive: checkArgUniqueness,\n  };\n\n  function checkArgUniqueness(parentNode) {\n    var _parentNode$arguments;\n\n    // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n    /* c8 ignore next */\n    const argumentNodes =\n      (_parentNode$arguments = parentNode.arguments) !== null &&\n      _parentNode$arguments !== void 0\n        ? _parentNode$arguments\n        : [];\n    const seenArgs = groupBy(argumentNodes, (arg) => arg.name.value);\n\n    for (const [argName, argNodes] of seenArgs) {\n      if (argNodes.length > 1) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one argument named \"${argName}\".`,\n            {\n              nodes: argNodes.map((node) => node.name),\n            },\n          ),\n        );\n      }\n    }\n  }\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique directive names\n *\n * A GraphQL document is only valid if all defined directives have unique names.\n */\nexport function UniqueDirectiveNamesRule(context) {\n  const knownDirectiveNames = Object.create(null);\n  const schema = context.getSchema();\n  return {\n    DirectiveDefinition(node) {\n      const directiveName = node.name.value;\n\n      if (\n        schema !== null &&\n        schema !== void 0 &&\n        schema.getDirective(directiveName)\n      ) {\n        context.reportError(\n          new GraphQLError(\n            `Directive \"@${directiveName}\" already exists in the schema. It cannot be redefined.`,\n            {\n              nodes: node.name,\n            },\n          ),\n        );\n        return;\n      }\n\n      if (knownDirectiveNames[directiveName]) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one directive named \"@${directiveName}\".`,\n            {\n              nodes: [knownDirectiveNames[directiveName], node.name],\n            },\n          ),\n        );\n      } else {\n        knownDirectiveNames[directiveName] = node.name;\n      }\n\n      return false;\n    },\n  };\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { Kind } from '../../language/kinds.mjs';\nimport {\n  isTypeDefinitionNode,\n  isTypeExtensionNode,\n} from '../../language/predicates.mjs';\nimport { specifiedDirectives } from '../../type/directives.mjs';\n\n/**\n * Unique directive names per location\n *\n * A GraphQL document is only valid if all non-repeatable directives at\n * a given location are uniquely named.\n *\n * See https://spec.graphql.org/draft/#sec-Directives-Are-Unique-Per-Location\n */\nexport function UniqueDirectivesPerLocationRule(context) {\n  const uniqueDirectiveMap = Object.create(null);\n  const schema = context.getSchema();\n  const definedDirectives = schema\n    ? schema.getDirectives()\n    : specifiedDirectives;\n\n  for (const directive of definedDirectives) {\n    uniqueDirectiveMap[directive.name] = !directive.isRepeatable;\n  }\n\n  const astDefinitions = context.getDocument().definitions;\n\n  for (const def of astDefinitions) {\n    if (def.kind === Kind.DIRECTIVE_DEFINITION) {\n      uniqueDirectiveMap[def.name.value] = !def.repeatable;\n    }\n  }\n\n  const schemaDirectives = Object.create(null);\n  const typeDirectivesMap = Object.create(null);\n  return {\n    // Many different AST nodes may contain directives. Rather than listing\n    // them all, just listen for entering any node, and check to see if it\n    // defines any directives.\n    enter(node) {\n      if (!('directives' in node) || !node.directives) {\n        return;\n      }\n\n      let seenDirectives;\n\n      if (\n        node.kind === Kind.SCHEMA_DEFINITION ||\n        node.kind === Kind.SCHEMA_EXTENSION\n      ) {\n        seenDirectives = schemaDirectives;\n      } else if (isTypeDefinitionNode(node) || isTypeExtensionNode(node)) {\n        const typeName = node.name.value;\n        seenDirectives = typeDirectivesMap[typeName];\n\n        if (seenDirectives === undefined) {\n          typeDirectivesMap[typeName] = seenDirectives = Object.create(null);\n        }\n      } else {\n        seenDirectives = Object.create(null);\n      }\n\n      for (const directive of node.directives) {\n        const directiveName = directive.name.value;\n\n        if (uniqueDirectiveMap[directiveName]) {\n          if (seenDirectives[directiveName]) {\n            context.reportError(\n              new GraphQLError(\n                `The directive \"@${directiveName}\" can only be used once at this location.`,\n                {\n                  nodes: [seenDirectives[directiveName], directive],\n                },\n              ),\n            );\n          } else {\n            seenDirectives[directiveName] = directive;\n          }\n        }\n      }\n    },\n  };\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { isEnumType } from '../../type/definition.mjs';\n\n/**\n * Unique enum value names\n *\n * A GraphQL enum type is only valid if all its values are uniquely named.\n */\nexport function UniqueEnumValueNamesRule(context) {\n  const schema = context.getSchema();\n  const existingTypeMap = schema ? schema.getTypeMap() : Object.create(null);\n  const knownValueNames = Object.create(null);\n  return {\n    EnumTypeDefinition: checkValueUniqueness,\n    EnumTypeExtension: checkValueUniqueness,\n  };\n\n  function checkValueUniqueness(node) {\n    var _node$values;\n\n    const typeName = node.name.value;\n\n    if (!knownValueNames[typeName]) {\n      knownValueNames[typeName] = Object.create(null);\n    } // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n    /* c8 ignore next */\n\n    const valueNodes =\n      (_node$values = node.values) !== null && _node$values !== void 0\n        ? _node$values\n        : [];\n    const valueNames = knownValueNames[typeName];\n\n    for (const valueDef of valueNodes) {\n      const valueName = valueDef.name.value;\n      const existingType = existingTypeMap[typeName];\n\n      if (isEnumType(existingType) && existingType.getValue(valueName)) {\n        context.reportError(\n          new GraphQLError(\n            `Enum value \"${typeName}.${valueName}\" already exists in the schema. It cannot also be defined in this type extension.`,\n            {\n              nodes: valueDef.name,\n            },\n          ),\n        );\n      } else if (valueNames[valueName]) {\n        context.reportError(\n          new GraphQLError(\n            `Enum value \"${typeName}.${valueName}\" can only be defined once.`,\n            {\n              nodes: [valueNames[valueName], valueDef.name],\n            },\n          ),\n        );\n      } else {\n        valueNames[valueName] = valueDef.name;\n      }\n    }\n\n    return false;\n  }\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\nimport {\n  isInputObjectType,\n  isInterfaceType,\n  isObjectType,\n} from '../../type/definition.mjs';\n\n/**\n * Unique field definition names\n *\n * A GraphQL complex type is only valid if all its fields are uniquely named.\n */\nexport function UniqueFieldDefinitionNamesRule(context) {\n  const schema = context.getSchema();\n  const existingTypeMap = schema ? schema.getTypeMap() : Object.create(null);\n  const knownFieldNames = Object.create(null);\n  return {\n    InputObjectTypeDefinition: checkFieldUniqueness,\n    InputObjectTypeExtension: checkFieldUniqueness,\n    InterfaceTypeDefinition: checkFieldUniqueness,\n    InterfaceTypeExtension: checkFieldUniqueness,\n    ObjectTypeDefinition: checkFieldUniqueness,\n    ObjectTypeExtension: checkFieldUniqueness,\n  };\n\n  function checkFieldUniqueness(node) {\n    var _node$fields;\n\n    const typeName = node.name.value;\n\n    if (!knownFieldNames[typeName]) {\n      knownFieldNames[typeName] = Object.create(null);\n    } // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n    /* c8 ignore next */\n\n    const fieldNodes =\n      (_node$fields = node.fields) !== null && _node$fields !== void 0\n        ? _node$fields\n        : [];\n    const fieldNames = knownFieldNames[typeName];\n\n    for (const fieldDef of fieldNodes) {\n      const fieldName = fieldDef.name.value;\n\n      if (hasField(existingTypeMap[typeName], fieldName)) {\n        context.reportError(\n          new GraphQLError(\n            `Field \"${typeName}.${fieldName}\" already exists in the schema. It cannot also be defined in this type extension.`,\n            {\n              nodes: fieldDef.name,\n            },\n          ),\n        );\n      } else if (fieldNames[fieldName]) {\n        context.reportError(\n          new GraphQLError(\n            `Field \"${typeName}.${fieldName}\" can only be defined once.`,\n            {\n              nodes: [fieldNames[fieldName], fieldDef.name],\n            },\n          ),\n        );\n      } else {\n        fieldNames[fieldName] = fieldDef.name;\n      }\n    }\n\n    return false;\n  }\n}\n\nfunction hasField(type, fieldName) {\n  if (isObjectType(type) || isInterfaceType(type) || isInputObjectType(type)) {\n    return type.getFields()[fieldName] != null;\n  }\n\n  return false;\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique fragment names\n *\n * A GraphQL document is only valid if all defined fragments have unique names.\n *\n * See https://spec.graphql.org/draft/#sec-Fragment-Name-Uniqueness\n */\nexport function UniqueFragmentNamesRule(context) {\n  const knownFragmentNames = Object.create(null);\n  return {\n    OperationDefinition: () => false,\n\n    FragmentDefinition(node) {\n      const fragmentName = node.name.value;\n\n      if (knownFragmentNames[fragmentName]) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one fragment named \"${fragmentName}\".`,\n            {\n              nodes: [knownFragmentNames[fragmentName], node.name],\n            },\n          ),\n        );\n      } else {\n        knownFragmentNames[fragmentName] = node.name;\n      }\n\n      return false;\n    },\n  };\n}\n","import { invariant } from '../../jsutils/invariant.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique input field names\n *\n * A GraphQL input object value is only valid if all supplied fields are\n * uniquely named.\n *\n * See https://spec.graphql.org/draft/#sec-Input-Object-Field-Uniqueness\n */\nexport function UniqueInputFieldNamesRule(context) {\n  const knownNameStack = [];\n  let knownNames = Object.create(null);\n  return {\n    ObjectValue: {\n      enter() {\n        knownNameStack.push(knownNames);\n        knownNames = Object.create(null);\n      },\n\n      leave() {\n        const prevKnownNames = knownNameStack.pop();\n        prevKnownNames || invariant(false);\n        knownNames = prevKnownNames;\n      },\n    },\n\n    ObjectField(node) {\n      const fieldName = node.name.value;\n\n      if (knownNames[fieldName]) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one input field named \"${fieldName}\".`,\n            {\n              nodes: [knownNames[fieldName], node.name],\n            },\n          ),\n        );\n      } else {\n        knownNames[fieldName] = node.name;\n      }\n    },\n  };\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique operation names\n *\n * A GraphQL document is only valid if all defined operations have unique names.\n *\n * See https://spec.graphql.org/draft/#sec-Operation-Name-Uniqueness\n */\nexport function UniqueOperationNamesRule(context) {\n  const knownOperationNames = Object.create(null);\n  return {\n    OperationDefinition(node) {\n      const operationName = node.name;\n\n      if (operationName) {\n        if (knownOperationNames[operationName.value]) {\n          context.reportError(\n            new GraphQLError(\n              `There can be only one operation named \"${operationName.value}\".`,\n              {\n                nodes: [\n                  knownOperationNames[operationName.value],\n                  operationName,\n                ],\n              },\n            ),\n          );\n        } else {\n          knownOperationNames[operationName.value] = operationName;\n        }\n      }\n\n      return false;\n    },\n\n    FragmentDefinition: () => false,\n  };\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique operation types\n *\n * A GraphQL document is only valid if it has only one type per operation.\n */\nexport function UniqueOperationTypesRule(context) {\n  const schema = context.getSchema();\n  const definedOperationTypes = Object.create(null);\n  const existingOperationTypes = schema\n    ? {\n        query: schema.getQueryType(),\n        mutation: schema.getMutationType(),\n        subscription: schema.getSubscriptionType(),\n      }\n    : {};\n  return {\n    SchemaDefinition: checkOperationTypes,\n    SchemaExtension: checkOperationTypes,\n  };\n\n  function checkOperationTypes(node) {\n    var _node$operationTypes;\n\n    // See: https://github.com/graphql/graphql-js/issues/2203\n\n    /* c8 ignore next */\n    const operationTypesNodes =\n      (_node$operationTypes = node.operationTypes) !== null &&\n      _node$operationTypes !== void 0\n        ? _node$operationTypes\n        : [];\n\n    for (const operationType of operationTypesNodes) {\n      const operation = operationType.operation;\n      const alreadyDefinedOperationType = definedOperationTypes[operation];\n\n      if (existingOperationTypes[operation]) {\n        context.reportError(\n          new GraphQLError(\n            `Type for ${operation} already defined in the schema. It cannot be redefined.`,\n            {\n              nodes: operationType,\n            },\n          ),\n        );\n      } else if (alreadyDefinedOperationType) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one ${operation} type in schema.`,\n            {\n              nodes: [alreadyDefinedOperationType, operationType],\n            },\n          ),\n        );\n      } else {\n        definedOperationTypes[operation] = operationType;\n      }\n    }\n\n    return false;\n  }\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique type names\n *\n * A GraphQL document is only valid if all defined types have unique names.\n */\nexport function UniqueTypeNamesRule(context) {\n  const knownTypeNames = Object.create(null);\n  const schema = context.getSchema();\n  return {\n    ScalarTypeDefinition: checkTypeName,\n    ObjectTypeDefinition: checkTypeName,\n    InterfaceTypeDefinition: checkTypeName,\n    UnionTypeDefinition: checkTypeName,\n    EnumTypeDefinition: checkTypeName,\n    InputObjectTypeDefinition: checkTypeName,\n  };\n\n  function checkTypeName(node) {\n    const typeName = node.name.value;\n\n    if (schema !== null && schema !== void 0 && schema.getType(typeName)) {\n      context.reportError(\n        new GraphQLError(\n          `Type \"${typeName}\" already exists in the schema. It cannot also be defined in this type definition.`,\n          {\n            nodes: node.name,\n          },\n        ),\n      );\n      return;\n    }\n\n    if (knownTypeNames[typeName]) {\n      context.reportError(\n        new GraphQLError(`There can be only one type named \"${typeName}\".`, {\n          nodes: [knownTypeNames[typeName], node.name],\n        }),\n      );\n    } else {\n      knownTypeNames[typeName] = node.name;\n    }\n\n    return false;\n  }\n}\n","import { groupBy } from '../../jsutils/groupBy.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique variable names\n *\n * A GraphQL operation is only valid if all its variables are uniquely named.\n */\nexport function UniqueVariableNamesRule(context) {\n  return {\n    OperationDefinition(operationNode) {\n      var _operationNode$variab;\n\n      // See: https://github.com/graphql/graphql-js/issues/2203\n\n      /* c8 ignore next */\n      const variableDefinitions =\n        (_operationNode$variab = operationNode.variableDefinitions) !== null &&\n        _operationNode$variab !== void 0\n          ? _operationNode$variab\n          : [];\n      const seenVariableDefinitions = groupBy(\n        variableDefinitions,\n        (node) => node.variable.name.value,\n      );\n\n      for (const [variableName, variableNodes] of seenVariableDefinitions) {\n        if (variableNodes.length > 1) {\n          context.reportError(\n            new GraphQLError(\n              `There can be only one variable named \"$${variableName}\".`,\n              {\n                nodes: variableNodes.map((node) => node.variable.name),\n              },\n            ),\n          );\n        }\n      }\n    },\n  };\n}\n","import { didYouMean } from '../../jsutils/didYouMean.mjs';\nimport { inspect } from '../../jsutils/inspect.mjs';\nimport { keyMap } from '../../jsutils/keyMap.mjs';\nimport { suggestionList } from '../../jsutils/suggestionList.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { print } from '../../language/printer.mjs';\nimport {\n  getNamedType,\n  getNullableType,\n  isInputObjectType,\n  isLeafType,\n  isListType,\n  isNonNullType,\n  isRequiredInputField,\n} from '../../type/definition.mjs';\n\n/**\n * Value literals of correct type\n *\n * A GraphQL document is only valid if all value literals are of the type\n * expected at their position.\n *\n * See https://spec.graphql.org/draft/#sec-Values-of-Correct-Type\n */\nexport function ValuesOfCorrectTypeRule(context) {\n  return {\n    ListValue(node) {\n      // Note: TypeInfo will traverse into a list's item type, so look to the\n      // parent input type to check if it is a list.\n      const type = getNullableType(context.getParentInputType());\n\n      if (!isListType(type)) {\n        isValidValueNode(context, node);\n        return false; // Don't traverse further.\n      }\n    },\n\n    ObjectValue(node) {\n      const type = getNamedType(context.getInputType());\n\n      if (!isInputObjectType(type)) {\n        isValidValueNode(context, node);\n        return false; // Don't traverse further.\n      } // Ensure every required field exists.\n\n      const fieldNodeMap = keyMap(node.fields, (field) => field.name.value);\n\n      for (const fieldDef of Object.values(type.getFields())) {\n        const fieldNode = fieldNodeMap[fieldDef.name];\n\n        if (!fieldNode && isRequiredInputField(fieldDef)) {\n          const typeStr = inspect(fieldDef.type);\n          context.reportError(\n            new GraphQLError(\n              `Field \"${type.name}.${fieldDef.name}\" of required type \"${typeStr}\" was not provided.`,\n              {\n                nodes: node,\n              },\n            ),\n          );\n        }\n      }\n    },\n\n    ObjectField(node) {\n      const parentType = getNamedType(context.getParentInputType());\n      const fieldType = context.getInputType();\n\n      if (!fieldType && isInputObjectType(parentType)) {\n        const suggestions = suggestionList(\n          node.name.value,\n          Object.keys(parentType.getFields()),\n        );\n        context.reportError(\n          new GraphQLError(\n            `Field \"${node.name.value}\" is not defined by type \"${parentType.name}\".` +\n              didYouMean(suggestions),\n            {\n              nodes: node,\n            },\n          ),\n        );\n      }\n    },\n\n    NullValue(node) {\n      const type = context.getInputType();\n\n      if (isNonNullType(type)) {\n        context.reportError(\n          new GraphQLError(\n            `Expected value of type \"${inspect(type)}\", found ${print(node)}.`,\n            {\n              nodes: node,\n            },\n          ),\n        );\n      }\n    },\n\n    EnumValue: (node) => isValidValueNode(context, node),\n    IntValue: (node) => isValidValueNode(context, node),\n    FloatValue: (node) => isValidValueNode(context, node),\n    StringValue: (node) => isValidValueNode(context, node),\n    BooleanValue: (node) => isValidValueNode(context, node),\n  };\n}\n/**\n * Any value literal may be a valid representation of a Scalar, depending on\n * that scalar type.\n */\n\nfunction isValidValueNode(context, node) {\n  // Report any error at the full type expected by the location.\n  const locationType = context.getInputType();\n\n  if (!locationType) {\n    return;\n  }\n\n  const type = getNamedType(locationType);\n\n  if (!isLeafType(type)) {\n    const typeStr = inspect(locationType);\n    context.reportError(\n      new GraphQLError(\n        `Expected value of type \"${typeStr}\", found ${print(node)}.`,\n        {\n          nodes: node,\n        },\n      ),\n    );\n    return;\n  } // Scalars and Enums determine if a literal value is valid via parseLiteral(),\n  // which may throw or return an invalid value to indicate failure.\n\n  try {\n    const parseResult = type.parseLiteral(\n      node,\n      undefined,\n      /* variables */\n    );\n\n    if (parseResult === undefined) {\n      const typeStr = inspect(locationType);\n      context.reportError(\n        new GraphQLError(\n          `Expected value of type \"${typeStr}\", found ${print(node)}.`,\n          {\n            nodes: node,\n          },\n        ),\n      );\n    }\n  } catch (error) {\n    const typeStr = inspect(locationType);\n\n    if (error instanceof GraphQLError) {\n      context.reportError(error);\n    } else {\n      context.reportError(\n        new GraphQLError(\n          `Expected value of type \"${typeStr}\", found ${print(node)}; ` +\n            error.message,\n          {\n            nodes: node,\n            originalError: error,\n          },\n        ),\n      );\n    }\n  }\n}\n","import { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { print } from '../../language/printer.mjs';\nimport { isInputType } from '../../type/definition.mjs';\nimport { typeFromAST } from '../../utilities/typeFromAST.mjs';\n\n/**\n * Variables are input types\n *\n * A GraphQL operation is only valid if all the variables it defines are of\n * input types (scalar, enum, or input object).\n *\n * See https://spec.graphql.org/draft/#sec-Variables-Are-Input-Types\n */\nexport function VariablesAreInputTypesRule(context) {\n  return {\n    VariableDefinition(node) {\n      const type = typeFromAST(context.getSchema(), node.type);\n\n      if (type !== undefined && !isInputType(type)) {\n        const variableName = node.variable.name.value;\n        const typeName = print(node.type);\n        context.reportError(\n          new GraphQLError(\n            `Variable \"$${variableName}\" cannot be non-input type \"${typeName}\".`,\n            {\n              nodes: node.type,\n            },\n          ),\n        );\n      }\n    },\n  };\n}\n","import { inspect } from '../../jsutils/inspect.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { Kind } from '../../language/kinds.mjs';\nimport { isNonNullType } from '../../type/definition.mjs';\nimport { isTypeSubTypeOf } from '../../utilities/typeComparators.mjs';\nimport { typeFromAST } from '../../utilities/typeFromAST.mjs';\n\n/**\n * Variables in allowed position\n *\n * Variable usages must be compatible with the arguments they are passed to.\n *\n * See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed\n */\nexport function VariablesInAllowedPositionRule(context) {\n  let varDefMap = Object.create(null);\n  return {\n    OperationDefinition: {\n      enter() {\n        varDefMap = Object.create(null);\n      },\n\n      leave(operation) {\n        const usages = context.getRecursiveVariableUsages(operation);\n\n        for (const { node, type, defaultValue } of usages) {\n          const varName = node.name.value;\n          const varDef = varDefMap[varName];\n\n          if (varDef && type) {\n            // A var type is allowed if it is the same or more strict (e.g. is\n            // a subtype of) than the expected type. It can be more strict if\n            // the variable type is non-null when the expected type is nullable.\n            // If both are list types, the variable item type can be more strict\n            // than the expected item type (contravariant).\n            const schema = context.getSchema();\n            const varType = typeFromAST(schema, varDef.type);\n\n            if (\n              varType &&\n              !allowedVariableUsage(\n                schema,\n                varType,\n                varDef.defaultValue,\n                type,\n                defaultValue,\n              )\n            ) {\n              const varTypeStr = inspect(varType);\n              const typeStr = inspect(type);\n              context.reportError(\n                new GraphQLError(\n                  `Variable \"$${varName}\" of type \"${varTypeStr}\" used in position expecting type \"${typeStr}\".`,\n                  {\n                    nodes: [varDef, node],\n                  },\n                ),\n              );\n            }\n          }\n        }\n      },\n    },\n\n    VariableDefinition(node) {\n      varDefMap[node.variable.name.value] = node;\n    },\n  };\n}\n/**\n * Returns true if the variable is allowed in the location it was found,\n * which includes considering if default values exist for either the variable\n * or the location at which it is located.\n */\n\nfunction allowedVariableUsage(\n  schema,\n  varType,\n  varDefaultValue,\n  locationType,\n  locationDefaultValue,\n) {\n  if (isNonNullType(locationType) && !isNonNullType(varType)) {\n    const hasNonNullVariableDefaultValue =\n      varDefaultValue != null && varDefaultValue.kind !== Kind.NULL;\n    const hasLocationDefaultValue = locationDefaultValue !== undefined;\n\n    if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) {\n      return false;\n    }\n\n    const nullableLocationType = locationType.ofType;\n    return isTypeSubTypeOf(schema, varType, nullableLocationType);\n  }\n\n  return isTypeSubTypeOf(schema, varType, locationType);\n}\n","// Spec Section: \"Executable Definitions\"\nimport { ExecutableDefinitionsRule } from './rules/ExecutableDefinitionsRule.mjs'; // Spec Section: \"Field Selections on Objects, Interfaces, and Unions Types\"\n\nimport { FieldsOnCorrectTypeRule } from './rules/FieldsOnCorrectTypeRule.mjs'; // Spec Section: \"Fragments on Composite Types\"\n\nimport { FragmentsOnCompositeTypesRule } from './rules/FragmentsOnCompositeTypesRule.mjs'; // Spec Section: \"Argument Names\"\n\nimport {\n  KnownArgumentNamesOnDirectivesRule,\n  KnownArgumentNamesRule,\n} from './rules/KnownArgumentNamesRule.mjs'; // Spec Section: \"Directives Are Defined\"\n\nimport { KnownDirectivesRule } from './rules/KnownDirectivesRule.mjs'; // Spec Section: \"Fragment spread target defined\"\n\nimport { KnownFragmentNamesRule } from './rules/KnownFragmentNamesRule.mjs'; // Spec Section: \"Fragment Spread Type Existence\"\n\nimport { KnownTypeNamesRule } from './rules/KnownTypeNamesRule.mjs'; // Spec Section: \"Lone Anonymous Operation\"\n\nimport { LoneAnonymousOperationRule } from './rules/LoneAnonymousOperationRule.mjs'; // SDL-specific validation rules\n\nimport { LoneSchemaDefinitionRule } from './rules/LoneSchemaDefinitionRule.mjs'; // Spec Section: \"Fragments must not form cycles\"\n\nimport { NoFragmentCyclesRule } from './rules/NoFragmentCyclesRule.mjs'; // Spec Section: \"All Variable Used Defined\"\n\nimport { NoUndefinedVariablesRule } from './rules/NoUndefinedVariablesRule.mjs'; // Spec Section: \"Fragments must be used\"\n\nimport { NoUnusedFragmentsRule } from './rules/NoUnusedFragmentsRule.mjs'; // Spec Section: \"All Variables Used\"\n\nimport { NoUnusedVariablesRule } from './rules/NoUnusedVariablesRule.mjs'; // Spec Section: \"Field Selection Merging\"\n\nimport { OverlappingFieldsCanBeMergedRule } from './rules/OverlappingFieldsCanBeMergedRule.mjs'; // Spec Section: \"Fragment spread is possible\"\n\nimport { PossibleFragmentSpreadsRule } from './rules/PossibleFragmentSpreadsRule.mjs';\nimport { PossibleTypeExtensionsRule } from './rules/PossibleTypeExtensionsRule.mjs'; // Spec Section: \"Argument Optionality\"\n\nimport {\n  ProvidedRequiredArgumentsOnDirectivesRule,\n  ProvidedRequiredArgumentsRule,\n} from './rules/ProvidedRequiredArgumentsRule.mjs'; // Spec Section: \"Leaf Field Selections\"\n\nimport { ScalarLeafsRule } from './rules/ScalarLeafsRule.mjs'; // Spec Section: \"Subscriptions with Single Root Field\"\n\nimport { SingleFieldSubscriptionsRule } from './rules/SingleFieldSubscriptionsRule.mjs';\nimport { UniqueArgumentDefinitionNamesRule } from './rules/UniqueArgumentDefinitionNamesRule.mjs'; // Spec Section: \"Argument Uniqueness\"\n\nimport { UniqueArgumentNamesRule } from './rules/UniqueArgumentNamesRule.mjs';\nimport { UniqueDirectiveNamesRule } from './rules/UniqueDirectiveNamesRule.mjs'; // Spec Section: \"Directives Are Unique Per Location\"\n\nimport { UniqueDirectivesPerLocationRule } from './rules/UniqueDirectivesPerLocationRule.mjs';\nimport { UniqueEnumValueNamesRule } from './rules/UniqueEnumValueNamesRule.mjs';\nimport { UniqueFieldDefinitionNamesRule } from './rules/UniqueFieldDefinitionNamesRule.mjs'; // Spec Section: \"Fragment Name Uniqueness\"\n\nimport { UniqueFragmentNamesRule } from './rules/UniqueFragmentNamesRule.mjs'; // Spec Section: \"Input Object Field Uniqueness\"\n\nimport { UniqueInputFieldNamesRule } from './rules/UniqueInputFieldNamesRule.mjs'; // Spec Section: \"Operation Name Uniqueness\"\n\nimport { UniqueOperationNamesRule } from './rules/UniqueOperationNamesRule.mjs';\nimport { UniqueOperationTypesRule } from './rules/UniqueOperationTypesRule.mjs';\nimport { UniqueTypeNamesRule } from './rules/UniqueTypeNamesRule.mjs'; // Spec Section: \"Variable Uniqueness\"\n\nimport { UniqueVariableNamesRule } from './rules/UniqueVariableNamesRule.mjs'; // Spec Section: \"Value Type Correctness\"\n\nimport { ValuesOfCorrectTypeRule } from './rules/ValuesOfCorrectTypeRule.mjs'; // Spec Section: \"Variables are Input Types\"\n\nimport { VariablesAreInputTypesRule } from './rules/VariablesAreInputTypesRule.mjs'; // Spec Section: \"All Variable Usages Are Allowed\"\n\nimport { VariablesInAllowedPositionRule } from './rules/VariablesInAllowedPositionRule.mjs';\n\n/**\n * This set includes all validation rules defined by the GraphQL spec.\n *\n * The order of the rules in this list has been adjusted to lead to the\n * most clear output when encountering multiple validation errors.\n */\nexport const specifiedRules = Object.freeze([\n  ExecutableDefinitionsRule,\n  UniqueOperationNamesRule,\n  LoneAnonymousOperationRule,\n  SingleFieldSubscriptionsRule,\n  KnownTypeNamesRule,\n  FragmentsOnCompositeTypesRule,\n  VariablesAreInputTypesRule,\n  ScalarLeafsRule,\n  FieldsOnCorrectTypeRule,\n  UniqueFragmentNamesRule,\n  KnownFragmentNamesRule,\n  NoUnusedFragmentsRule,\n  PossibleFragmentSpreadsRule,\n  NoFragmentCyclesRule,\n  UniqueVariableNamesRule,\n  NoUndefinedVariablesRule,\n  NoUnusedVariablesRule,\n  KnownDirectivesRule,\n  UniqueDirectivesPerLocationRule,\n  KnownArgumentNamesRule,\n  UniqueArgumentNamesRule,\n  ValuesOfCorrectTypeRule,\n  ProvidedRequiredArgumentsRule,\n  VariablesInAllowedPositionRule,\n  OverlappingFieldsCanBeMergedRule,\n  UniqueInputFieldNamesRule,\n]);\n/**\n * @internal\n */\n\nexport const specifiedSDLRules = Object.freeze([\n  LoneSchemaDefinitionRule,\n  UniqueOperationTypesRule,\n  UniqueTypeNamesRule,\n  UniqueEnumValueNamesRule,\n  UniqueFieldDefinitionNamesRule,\n  UniqueArgumentDefinitionNamesRule,\n  UniqueDirectiveNamesRule,\n  KnownTypeNamesRule,\n  KnownDirectivesRule,\n  UniqueDirectivesPerLocationRule,\n  PossibleTypeExtensionsRule,\n  KnownArgumentNamesOnDirectivesRule,\n  UniqueArgumentNamesRule,\n  UniqueInputFieldNamesRule,\n  ProvidedRequiredArgumentsOnDirectivesRule,\n]);\n","import { Kind } from '../language/kinds.mjs';\nimport { visit } from '../language/visitor.mjs';\nimport { TypeInfo, visitWithTypeInfo } from '../utilities/TypeInfo.mjs';\n\n/**\n * An instance of this class is passed as the \"this\" context to all validators,\n * allowing access to commonly useful contextual information from within a\n * validation rule.\n */\nexport class ASTValidationContext {\n  constructor(ast, onError) {\n    this._ast = ast;\n    this._fragments = undefined;\n    this._fragmentSpreads = new Map();\n    this._recursivelyReferencedFragments = new Map();\n    this._onError = onError;\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'ASTValidationContext';\n  }\n\n  reportError(error) {\n    this._onError(error);\n  }\n\n  getDocument() {\n    return this._ast;\n  }\n\n  getFragment(name) {\n    let fragments;\n\n    if (this._fragments) {\n      fragments = this._fragments;\n    } else {\n      fragments = Object.create(null);\n\n      for (const defNode of this.getDocument().definitions) {\n        if (defNode.kind === Kind.FRAGMENT_DEFINITION) {\n          fragments[defNode.name.value] = defNode;\n        }\n      }\n\n      this._fragments = fragments;\n    }\n\n    return fragments[name];\n  }\n\n  getFragmentSpreads(node) {\n    let spreads = this._fragmentSpreads.get(node);\n\n    if (!spreads) {\n      spreads = [];\n      const setsToVisit = [node];\n      let set;\n\n      while ((set = setsToVisit.pop())) {\n        for (const selection of set.selections) {\n          if (selection.kind === Kind.FRAGMENT_SPREAD) {\n            spreads.push(selection);\n          } else if (selection.selectionSet) {\n            setsToVisit.push(selection.selectionSet);\n          }\n        }\n      }\n\n      this._fragmentSpreads.set(node, spreads);\n    }\n\n    return spreads;\n  }\n\n  getRecursivelyReferencedFragments(operation) {\n    let fragments = this._recursivelyReferencedFragments.get(operation);\n\n    if (!fragments) {\n      fragments = [];\n      const collectedNames = Object.create(null);\n      const nodesToVisit = [operation.selectionSet];\n      let node;\n\n      while ((node = nodesToVisit.pop())) {\n        for (const spread of this.getFragmentSpreads(node)) {\n          const fragName = spread.name.value;\n\n          if (collectedNames[fragName] !== true) {\n            collectedNames[fragName] = true;\n            const fragment = this.getFragment(fragName);\n\n            if (fragment) {\n              fragments.push(fragment);\n              nodesToVisit.push(fragment.selectionSet);\n            }\n          }\n        }\n      }\n\n      this._recursivelyReferencedFragments.set(operation, fragments);\n    }\n\n    return fragments;\n  }\n}\nexport class SDLValidationContext extends ASTValidationContext {\n  constructor(ast, schema, onError) {\n    super(ast, onError);\n    this._schema = schema;\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'SDLValidationContext';\n  }\n\n  getSchema() {\n    return this._schema;\n  }\n}\nexport class ValidationContext extends ASTValidationContext {\n  constructor(schema, ast, typeInfo, onError) {\n    super(ast, onError);\n    this._schema = schema;\n    this._typeInfo = typeInfo;\n    this._variableUsages = new Map();\n    this._recursiveVariableUsages = new Map();\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'ValidationContext';\n  }\n\n  getSchema() {\n    return this._schema;\n  }\n\n  getVariableUsages(node) {\n    let usages = this._variableUsages.get(node);\n\n    if (!usages) {\n      const newUsages = [];\n      const typeInfo = new TypeInfo(this._schema);\n      visit(\n        node,\n        visitWithTypeInfo(typeInfo, {\n          VariableDefinition: () => false,\n\n          Variable(variable) {\n            newUsages.push({\n              node: variable,\n              type: typeInfo.getInputType(),\n              defaultValue: typeInfo.getDefaultValue(),\n            });\n          },\n        }),\n      );\n      usages = newUsages;\n\n      this._variableUsages.set(node, usages);\n    }\n\n    return usages;\n  }\n\n  getRecursiveVariableUsages(operation) {\n    let usages = this._recursiveVariableUsages.get(operation);\n\n    if (!usages) {\n      usages = this.getVariableUsages(operation);\n\n      for (const frag of this.getRecursivelyReferencedFragments(operation)) {\n        usages = usages.concat(this.getVariableUsages(frag));\n      }\n\n      this._recursiveVariableUsages.set(operation, usages);\n    }\n\n    return usages;\n  }\n\n  getType() {\n    return this._typeInfo.getType();\n  }\n\n  getParentType() {\n    return this._typeInfo.getParentType();\n  }\n\n  getInputType() {\n    return this._typeInfo.getInputType();\n  }\n\n  getParentInputType() {\n    return this._typeInfo.getParentInputType();\n  }\n\n  getFieldDef() {\n    return this._typeInfo.getFieldDef();\n  }\n\n  getDirective() {\n    return this._typeInfo.getDirective();\n  }\n\n  getArgument() {\n    return this._typeInfo.getArgument();\n  }\n\n  getEnumValue() {\n    return this._typeInfo.getEnumValue();\n  }\n}\n","import { devAssert } from '../jsutils/devAssert.mjs';\nimport { GraphQLError } from '../error/GraphQLError.mjs';\nimport { visit, visitInParallel } from '../language/visitor.mjs';\nimport { assertValidSchema } from '../type/validate.mjs';\nimport { TypeInfo, visitWithTypeInfo } from '../utilities/TypeInfo.mjs';\nimport { specifiedRules, specifiedSDLRules } from './specifiedRules.mjs';\nimport {\n  SDLValidationContext,\n  ValidationContext,\n} from './ValidationContext.mjs';\n/**\n * Implements the \"Validation\" section of the spec.\n *\n * Validation runs synchronously, returning an array of encountered errors, or\n * an empty array if no errors were encountered and the document is valid.\n *\n * A list of specific validation rules may be provided. If not provided, the\n * default list of rules defined by the GraphQL specification will be used.\n *\n * Each validation rules is a function which returns a visitor\n * (see the language/visitor API). Visitor methods are expected to return\n * GraphQLErrors, or Arrays of GraphQLErrors when invalid.\n *\n * Validate will stop validation after a `maxErrors` limit has been reached.\n * Attackers can send pathologically invalid queries to induce a DoS attack,\n * so by default `maxErrors` set to 100 errors.\n *\n * Optionally a custom TypeInfo instance may be provided. If not provided, one\n * will be created from the provided schema.\n */\n\nexport function validate(\n  schema,\n  documentAST,\n  rules = specifiedRules,\n  options,\n  /** @deprecated will be removed in 17.0.0 */\n  typeInfo = new TypeInfo(schema),\n) {\n  var _options$maxErrors;\n\n  const maxErrors =\n    (_options$maxErrors =\n      options === null || options === void 0 ? void 0 : options.maxErrors) !==\n      null && _options$maxErrors !== void 0\n      ? _options$maxErrors\n      : 100;\n  documentAST || devAssert(false, 'Must provide document.'); // If the schema used for validation is invalid, throw an error.\n\n  assertValidSchema(schema);\n  const abortObj = Object.freeze({});\n  const errors = [];\n  const context = new ValidationContext(\n    schema,\n    documentAST,\n    typeInfo,\n    (error) => {\n      if (errors.length >= maxErrors) {\n        errors.push(\n          new GraphQLError(\n            'Too many validation errors, error limit reached. Validation aborted.',\n          ),\n        ); // eslint-disable-next-line @typescript-eslint/no-throw-literal\n\n        throw abortObj;\n      }\n\n      errors.push(error);\n    },\n  ); // This uses a specialized visitor which runs multiple visitors in parallel,\n  // while maintaining the visitor skip and break API.\n\n  const visitor = visitInParallel(rules.map((rule) => rule(context))); // Visit the whole document with each instance of all provided rules.\n\n  try {\n    visit(documentAST, visitWithTypeInfo(typeInfo, visitor));\n  } catch (e) {\n    if (e !== abortObj) {\n      throw e;\n    }\n  }\n\n  return errors;\n}\n/**\n * @internal\n */\n\nexport function validateSDL(\n  documentAST,\n  schemaToExtend,\n  rules = specifiedSDLRules,\n) {\n  const errors = [];\n  const context = new SDLValidationContext(\n    documentAST,\n    schemaToExtend,\n    (error) => {\n      errors.push(error);\n    },\n  );\n  const visitors = rules.map((rule) => rule(context));\n  visit(documentAST, visitInParallel(visitors));\n  return errors;\n}\n/**\n * Utility function which asserts a SDL document is valid by throwing an error\n * if it is invalid.\n *\n * @internal\n */\n\nexport function assertValidSDL(documentAST) {\n  const errors = validateSDL(documentAST);\n\n  if (errors.length !== 0) {\n    throw new Error(errors.map((error) => error.message).join('\\n\\n'));\n  }\n}\n/**\n * Utility function which asserts a SDL document is valid by throwing an error\n * if it is invalid.\n *\n * @internal\n */\n\nexport function assertValidSDLExtension(documentAST, schema) {\n  const errors = validateSDL(documentAST, schema);\n\n  if (errors.length !== 0) {\n    throw new Error(errors.map((error) => error.message).join('\\n\\n'));\n  }\n}\n","import { invariant } from '../../../jsutils/invariant.mjs';\nimport { GraphQLError } from '../../../error/GraphQLError.mjs';\nimport { getNamedType, isInputObjectType } from '../../../type/definition.mjs';\n\n/**\n * No deprecated\n *\n * A GraphQL document is only valid if all selected fields and all used enum values have not been\n * deprecated.\n *\n * Note: This rule is optional and is not part of the Validation section of the GraphQL\n * Specification. The main purpose of this rule is detection of deprecated usages and not\n * necessarily to forbid their use when querying a service.\n */\nexport function NoDeprecatedCustomRule(context) {\n  return {\n    Field(node) {\n      const fieldDef = context.getFieldDef();\n      const deprecationReason =\n        fieldDef === null || fieldDef === void 0\n          ? void 0\n          : fieldDef.deprecationReason;\n\n      if (fieldDef && deprecationReason != null) {\n        const parentType = context.getParentType();\n        parentType != null || invariant(false);\n        context.reportError(\n          new GraphQLError(\n            `The field ${parentType.name}.${fieldDef.name} is deprecated. ${deprecationReason}`,\n            {\n              nodes: node,\n            },\n          ),\n        );\n      }\n    },\n\n    Argument(node) {\n      const argDef = context.getArgument();\n      const deprecationReason =\n        argDef === null || argDef === void 0\n          ? void 0\n          : argDef.deprecationReason;\n\n      if (argDef && deprecationReason != null) {\n        const directiveDef = context.getDirective();\n\n        if (directiveDef != null) {\n          context.reportError(\n            new GraphQLError(\n              `Directive \"@${directiveDef.name}\" argument \"${argDef.name}\" is deprecated. ${deprecationReason}`,\n              {\n                nodes: node,\n              },\n            ),\n          );\n        } else {\n          const parentType = context.getParentType();\n          const fieldDef = context.getFieldDef();\n          (parentType != null && fieldDef != null) || invariant(false);\n          context.reportError(\n            new GraphQLError(\n              `Field \"${parentType.name}.${fieldDef.name}\" argument \"${argDef.name}\" is deprecated. ${deprecationReason}`,\n              {\n                nodes: node,\n              },\n            ),\n          );\n        }\n      }\n    },\n\n    ObjectField(node) {\n      const inputObjectDef = getNamedType(context.getParentInputType());\n\n      if (isInputObjectType(inputObjectDef)) {\n        const inputFieldDef = inputObjectDef.getFields()[node.name.value];\n        const deprecationReason =\n          inputFieldDef === null || inputFieldDef === void 0\n            ? void 0\n            : inputFieldDef.deprecationReason;\n\n        if (deprecationReason != null) {\n          context.reportError(\n            new GraphQLError(\n              `The input field ${inputObjectDef.name}.${inputFieldDef.name} is deprecated. ${deprecationReason}`,\n              {\n                nodes: node,\n              },\n            ),\n          );\n        }\n      }\n    },\n\n    EnumValue(node) {\n      const enumValueDef = context.getEnumValue();\n      const deprecationReason =\n        enumValueDef === null || enumValueDef === void 0\n          ? void 0\n          : enumValueDef.deprecationReason;\n\n      if (enumValueDef && deprecationReason != null) {\n        const enumTypeDef = getNamedType(context.getInputType());\n        enumTypeDef != null || invariant(false);\n        context.reportError(\n          new GraphQLError(\n            `The enum value \"${enumTypeDef.name}.${enumValueDef.name}\" is deprecated. ${deprecationReason}`,\n            {\n              nodes: node,\n            },\n          ),\n        );\n      }\n    },\n  };\n}\n"],"names":["isDefinitionNode","node","isExecutableDefinitionNode","isTypeSystemDefinitionNode","isTypeSystemExtensionNode","Kind","isSelectionNode","isValueNode","isConstValueNode","field","isTypeNode","isTypeDefinitionNode","isTypeExtensionNode","ExecutableDefinitionsRule","context","definition","defName","GraphQLError","FieldsOnCorrectTypeRule","type","schema","fieldName","suggestion","didYouMean","getSuggestedTypeNames","getSuggestedFieldNames","isAbstractType","suggestedTypes","usageCount","possibleType","possibleInterface","_usageCount$possibleI","typeA","typeB","usageCountDiff","isInterfaceType","naturalCompare","x","isObjectType","possibleFieldNames","suggestionList","FragmentsOnCompositeTypesRule","typeCondition","typeFromAST","isCompositeType","typeStr","print","KnownArgumentNamesRule","KnownArgumentNamesOnDirectivesRule","argNode","argDef","fieldDef","parentType","argName","knownArgsNames","arg","suggestions","directiveArgs","definedDirectives","specifiedDirectives","directive","astDefinitions","def","_def$arguments","argsNodes","directiveNode","directiveName","knownArgs","KnownDirectivesRule","locationsMap","name","_key","_parent","_path","ancestors","locations","candidateLocation","getDirectiveLocationForASTPath","appliedTo","invariant","getDirectiveLocationForOperation","DirectiveLocation","parentNode","inspect","operation","OperationTypeNode","KnownFragmentNamesRule","fragmentName","KnownTypeNamesRule","existingTypesMap","definedTypes","typeNames","_1","parent","_2","typeName","_ancestors$","definitionNode","isSDL","isSDLNode","standardTypeNames","specifiedScalarTypes","introspectionTypes","value","LoneAnonymousOperationRule","operationCount","LoneSchemaDefinitionRule","_ref","_ref2","_oldSchema$astNode","oldSchema","alreadyDefined","schemaDefinitionsCount","NoFragmentCyclesRule","visitedFrags","spreadPath","spreadPathIndexByName","detectCycleRecursive","fragment","spreadNodes","spreadNode","spreadName","cycleIndex","spreadFragment","cyclePath","viaPath","s","NoUndefinedVariablesRule","variableNameDefined","usages","varName","NoUnusedFragmentsRule","operationDefs","fragmentDefs","fragmentNameUsed","fragmentDef","fragName","NoUnusedVariablesRule","variableDefs","variableNameUsed","variableDef","variableName","sortValueNode","valueNode","sortFields","fields","fieldNode","fieldA","fieldB","reasonMessage","reason","responseName","subReason","OverlappingFieldsCanBeMergedRule","comparedFragmentPairs","PairSet","cachedFieldsAndFragmentNames","selectionSet","conflicts","findConflictsWithinSelectionSet","fields1","fields2","reasonMsg","fieldMap","fragmentNames","getFieldsAndFragmentNames","collectConflictsWithin","i","collectConflictsBetweenFieldsAndFragment","j","collectConflictsBetweenFragments","areMutuallyExclusive","fieldMap2","referencedFragmentNames","getReferencedFieldsAndFragmentNames","collectConflictsBetween","referencedFragmentName","fragmentName1","fragmentName2","fragment1","fragment2","fieldMap1","referencedFragmentNames1","referencedFragmentNames2","referencedFragmentName2","referencedFragmentName1","findConflictsBetweenSubSelectionSets","parentType1","selectionSet1","parentType2","selectionSet2","fragmentNames1","fragmentNames2","conflict","findConflict","parentFieldsAreMutuallyExclusive","field1","field2","node1","def1","node2","def2","name1","name2","stringifyArguments","type1","type2","doTypesConflict","getNamedType","subfieldConflicts","_fieldNode$arguments","args","inputObjectWithArgs","isListType","isNonNullType","isLeafType","cached","nodeAndDefs","_collectFieldsAndFragmentNames","result","fragmentType","selection","inlineFragmentType","a","b","_this$_data$get","key1","key2","map","PossibleFragmentSpreadsRule","fragType","doTypesOverlap","parentTypeStr","fragTypeStr","getFragmentType","frag","PossibleTypeExtensionsRule","checkExtension","defNode","existingType","expectedKind","defKindToExtKind","typeToExtKind","kindStr","extensionKindToTypeName","allTypeNames","isScalarType","isUnionType","isEnumType","isInputObjectType","kind","ProvidedRequiredArgumentsRule","ProvidedRequiredArgumentsOnDirectivesRule","providedArgs","isRequiredArgument","argTypeStr","_schema$getDirectives","requiredArgsMap","keyMap","argNodes","isRequiredArgumentNode","requiredArgs","_directiveNode$argume","argNodeMap","argType","isType","ScalarLeafsRule","printPathArray","path","key","addPath","prev","typename","pathToArray","flattened","curr","coerceInputValue","inputValue","onError","defaultOnError","coerceInputValueImpl","invalidValue","error","errorPrefix","itemType","isIterableObject","itemValue","index","itemPath","isObjectLike","coercedValue","fieldDefs","fieldValue","parseResult","getVariableValues","varDefNodes","inputs","options","errors","maxErrors","coerced","coerceVariableValues","coercedValues","varDefNode","varType","isInputType","varTypeStr","hasOwnProperty","valueFromAST","prefix","getArgumentValues","variableValues","_node$arguments","argumentNodes","argumentNode","isNull","getDirectiveValues","directiveDef","_node$directives","obj","prop","collectFields","fragments","runtimeType","collectFieldsImpl","collectSubfields","returnType","fieldNodes","subFieldNodes","visitedFragmentNames","shouldIncludeNode","getFieldEntryKey","fieldList","doesFragmentConditionMatch","skip","GraphQLSkipDirective","include","GraphQLIncludeDirective","typeConditionNode","conditionalType","SingleFieldSubscriptionsRule","subscriptionType","operationName","document","extraFieldSelections","groupBy","list","keyFn","item","group","UniqueArgumentDefinitionNamesRule","checkArgUniqueness","checkArgUniquenessPerField","typeNode","_typeNode$fields","_fieldDef$arguments","parentName","seenArgs","UniqueArgumentNamesRule","_parentNode$arguments","UniqueDirectiveNamesRule","knownDirectiveNames","UniqueDirectivesPerLocationRule","uniqueDirectiveMap","schemaDirectives","typeDirectivesMap","seenDirectives","UniqueEnumValueNamesRule","existingTypeMap","knownValueNames","checkValueUniqueness","_node$values","valueNodes","valueNames","valueDef","valueName","UniqueFieldDefinitionNamesRule","knownFieldNames","checkFieldUniqueness","_node$fields","fieldNames","hasField","UniqueFragmentNamesRule","knownFragmentNames","UniqueInputFieldNamesRule","knownNameStack","knownNames","prevKnownNames","UniqueOperationNamesRule","knownOperationNames","UniqueOperationTypesRule","definedOperationTypes","existingOperationTypes","checkOperationTypes","_node$operationTypes","operationTypesNodes","operationType","alreadyDefinedOperationType","UniqueTypeNamesRule","knownTypeNames","checkTypeName","UniqueVariableNamesRule","operationNode","_operationNode$variab","variableDefinitions","seenVariableDefinitions","variableNodes","ValuesOfCorrectTypeRule","getNullableType","isValidValueNode","fieldNodeMap","isRequiredInputField","locationType","VariablesAreInputTypesRule","VariablesInAllowedPositionRule","varDefMap","defaultValue","varDef","allowedVariableUsage","varDefaultValue","locationDefaultValue","nullableLocationType","isTypeSubTypeOf","specifiedRules","specifiedSDLRules","ASTValidationContext","ast","spreads","setsToVisit","set","collectedNames","nodesToVisit","spread","SDLValidationContext","ValidationContext","typeInfo","newUsages","TypeInfo","visit","visitWithTypeInfo","variable","validate","documentAST","rules","_options$maxErrors","devAssert","assertValidSchema","abortObj","visitor","visitInParallel","rule","e","validateSDL","schemaToExtend","visitors","assertValidSDL","assertValidSDLExtension","NoDeprecatedCustomRule","deprecationReason","inputObjectDef","inputFieldDef","enumValueDef","enumTypeDef"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45]}