@graphql-eslint/eslint-plugin 4.0.0-alpha.0 → 4.0.0-alpha.2

package/{index.browser.mjs → index.browser.js}

@@ -237,9 +237,31 @@ var require_schema_relay = __commonJS({
 });
 
 // src/parser.ts
+import debugFactory2 from "debug";
+import { buildSchema, GraphQLError } from "graphql";
 import { parseGraphQLSDL } from "@graphql-tools/utils";
+
+// src/cache.ts
 import debugFactory from "debug";
-import { buildSchema, GraphQLError } from "graphql";
+var log = debugFactory("graphql-eslint:ModuleCache"), ModuleCache = class {
+  map = /* @__PURE__ */ new Map();
+  set(cacheKey, result) {
+    this.map.set(cacheKey, { lastSeen: process.hrtime(), result }), log("setting entry for", cacheKey);
+  }
+  get(cacheKey, settings = {
+    lifetime: 10
+    /* seconds */
+  }) {
+    let value = this.map.get(cacheKey);
+    if (!value) {
+      log("cache miss for", cacheKey);
+      return;
+    }
+    let { lastSeen, result } = value;
+    if (process.env.NODE || process.hrtime(lastSeen)[0] < settings.lifetime)
+      return result;
+  }
+};
 
 // src/estree-converter/converter.ts
 import {
@@ -374,6 +396,84 @@ function convertToESTree(node, schema15) {
   );
 }
 
+// package.json
+var package_default = {
+  name: "@graphql-eslint/eslint-plugin",
+  version: "4.0.0-alpha.2",
+  type: "module",
+  description: "GraphQL plugin for ESLint",
+  repository: "https://github.com/B2o5T/graphql-eslint",
+  author: "Dotan Simha <dotansimha@gmail.com>",
+  license: "MIT",
+  engines: {
+    node: ">=18"
+  },
+  main: "dist/cjs/index.js",
+  exports: {
+    "./package.json": "./package.json",
+    ".": {
+      require: {
+        types: "./dist/cjs/index.d.ts",
+        default: "./dist/cjs/index.js"
+      },
+      import: {
+        types: "./dist/esm/index.d.ts",
+        default: "./dist/esm/index.js"
+      },
+      default: {
+        types: "./dist/esm/index.d.ts",
+        default: "./dist/esm/index.js"
+      }
+    }
+  },
+  types: "dist/esm/index.d.ts",
+  keywords: [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "graphql"
+  ],
+  scripts: {
+    build: "tsup",
+    test: "vitest",
+    typecheck: "tsc --noEmit"
+  },
+  peerDependencies: {
+    eslint: ">=8.44.0",
+    graphql: "^16"
+  },
+  dependencies: {
+    "@graphql-tools/code-file-loader": "^8.0.0",
+    "@graphql-tools/graphql-tag-pluck": "^8.0.0",
+    "@graphql-tools/utils": "^10.0.0",
+    debug: "^4.3.4",
+    "fast-glob": "^3.2.12",
+    "graphql-config": "^5.0.0",
+    "graphql-depth-limit": "^1.1.0",
+    "lodash.lowercase": "^4.3.0"
+  },
+  devDependencies: {
+    "@theguild/eslint-rule-tester": "workspace:*",
+    "@types/debug": "4.1.12",
+    "@types/eslint": "9.6.0",
+    "@types/estree": "1.0.5",
+    "@types/graphql-depth-limit": "1.1.6",
+    "@types/json-schema": "7.0.15",
+    "@types/lodash.lowercase": "4.3.9",
+    graphql: "16.9.0",
+    "json-schema-to-ts": "2.12.0",
+    "vite-tsconfig-paths": "^4.3.2"
+  },
+  publishConfig: {
+    directory: "dist",
+    access: "public"
+  },
+  sideEffects: !1
+};
+
+// src/meta.ts
+var { name, version } = package_default;
+
 // src/siblings.ts
 import {
   Kind as Kind3,
@@ -550,7 +650,7 @@ function getSiblings(documents) {
       cachedOperations = result;
     }
     return cachedOperations;
-  }, getFragment = (name) => getFragments().filter((f) => f.document.name.value === name), collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => (visit2(selectable, {
+  }, getFragment = (name2) => getFragments().filter((f) => f.document.name.value === name2), collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => (visit2(selectable, {
     FragmentSpread(spread) {
       let fragmentName = spread.name.value, [fragment] = getFragment(fragmentName);
       if (!fragment) {
@@ -567,7 +667,7 @@ function getSiblings(documents) {
     getFragments,
     getFragmentByType: (typeName) => getFragments().filter((f) => f.document.typeCondition.name.value === typeName),
     getFragmentsInUse: (selectable, recursive = !0) => Array.from(collectFragments(selectable, recursive).values()),
-    getOperation: (name) => getOperations().filter((o) => o.document.name?.value === name),
+    getOperation: (name2) => getOperations().filter((o) => o.document.name?.value === name2),
     getOperations,
     getOperationByType: (type) => getOperations().filter((o) => o.document.operation === type)
   };
@@ -575,7 +675,7 @@ function getSiblings(documents) {
 }
 
 // src/parser.ts
-var debug = debugFactory("graphql-eslint:parser");
+var debug = debugFactory2("graphql-eslint:parser");
 debug("cwd %o", CWD);
 var LEGACY_PARSER_OPTIONS_KEYS = [
   "schema",
@@ -640,222 +740,603 @@ function parseForESLint(code, options) {
     throw error;
   }
 }
+var parser = {
+  parseForESLint,
+  meta: {
+    name: "@graphql-eslint/parser",
+    version
+  }
+};
 
-// src/rules/graphql-js-validation.ts
+// src/rules/alphabetize.ts
 import {
-  Kind as Kind4,
-  validate,
-  visit as visit3
+  Kind as Kind4
 } from "graphql";
-import {
-  ExecutableDefinitionsRule,
-  FieldsOnCorrectTypeRule,
-  FragmentsOnCompositeTypesRule,
-  KnownArgumentNamesRule,
-  KnownDirectivesRule,
-  KnownFragmentNamesRule,
-  KnownTypeNamesRule,
-  LoneAnonymousOperationRule,
-  LoneSchemaDefinitionRule,
-  NoFragmentCyclesRule,
-  NoUndefinedVariablesRule,
-  NoUnusedFragmentsRule,
-  NoUnusedVariablesRule,
-  OverlappingFieldsCanBeMergedRule,
-  PossibleFragmentSpreadsRule,
-  PossibleTypeExtensionsRule,
-  ProvidedRequiredArgumentsRule,
-  ScalarLeafsRule,
-  SingleFieldSubscriptionsRule,
-  UniqueArgumentNamesRule,
-  UniqueDirectiveNamesRule,
-  UniqueDirectivesPerLocationRule,
-  UniqueFieldDefinitionNamesRule,
-  UniqueInputFieldNamesRule,
-  UniqueOperationTypesRule,
-  UniqueTypeNamesRule,
-  UniqueVariableNamesRule,
-  ValuesOfCorrectTypeRule,
-  VariablesAreInputTypesRule,
-  VariablesInAllowedPositionRule
-} from "graphql/validation/index.js";
-import { validateSDL } from "graphql/validation/validate.js";
-function validateDocument({
-  context,
-  schema: schema15 = null,
-  documentNode,
-  rule: rule35,
-  hasDidYouMeanSuggestions
-}) {
-  if (documentNode.definitions.length !== 0)
-    try {
-      let validationErrors = schema15 ? validate(schema15, documentNode, [rule35]) : validateSDL(documentNode, null, [rule35]);
-      for (let error of validationErrors) {
-        let { line, column } = error.locations[0], sourceCode = context.getSourceCode(), { tokens } = sourceCode.ast, token = tokens.find(
-          (token2) => token2.loc.start.line === line && token2.loc.start.column === column - 1
-        ), loc = {
-          line,
-          column: column - 1
-        };
-        token && (loc = // if cursor on `@` symbol than use next node
-        token.type === "@" ? sourceCode.getNodeByRangeIndex(token.range[1] + 1).loc : token.loc);
-        let didYouMeanContent = error.message.match(/Did you mean (?<content>.*)\?$/)?.groups.content, matches = didYouMeanContent ? [...didYouMeanContent.matchAll(/"(?<name>[^"]*)"/g)] : [];
-        context.report({
-          loc,
-          message: error.message,
-          suggest: hasDidYouMeanSuggestions ? matches.map((match) => {
-            let { name } = match.groups;
-            return {
-              desc: `Rename to \`${name}\``,
-              fix: (fixer) => fixer.replaceText(token, name)
-            };
-          }) : []
-        });
-      }
-    } catch (error) {
-      context.report({
-        loc: REPORT_ON_FIRST_CHARACTER,
-        message: error.message
-      });
-    }
-}
-var getFragmentDefsAndFragmentSpreads = (node) => {
-  let fragmentDefs = /* @__PURE__ */ new Set(), fragmentSpreads = /* @__PURE__ */ new Set();
-  return visit3(node, {
-    FragmentDefinition(node2) {
-      fragmentDefs.add(node2.name.value);
-    },
-    FragmentSpread(node2) {
-      fragmentSpreads.add(node2.name.value);
-    }
-  }), { fragmentDefs, fragmentSpreads };
-}, getMissingFragments = (node) => {
-  let { fragmentDefs, fragmentSpreads } = getFragmentDefsAndFragmentSpreads(node);
-  return [...fragmentSpreads].filter((name) => !fragmentDefs.has(name));
-}, handleMissingFragments = ({ ruleId, context, node }) => {
-  let missingFragments = getMissingFragments(node);
-  if (missingFragments.length > 0) {
-    let siblings = requireSiblingsOperations(ruleId, context), fragmentsToAdd = [];
-    for (let fragmentName of missingFragments) {
-      let [foundFragment] = siblings.getFragment(fragmentName).map((source) => source.document);
-      foundFragment && fragmentsToAdd.push(foundFragment);
-    }
-    if (fragmentsToAdd.length > 0)
-      return handleMissingFragments({
-        ruleId,
-        context,
-        node: {
-          kind: Kind4.DOCUMENT,
-          definitions: [...node.definitions, ...fragmentsToAdd]
-        }
-      });
-  }
-  return node;
-}, validationToRule = ({
-  ruleId,
-  rule: rule35,
-  getDocumentNode,
-  schema: schema15 = [],
-  hasDidYouMeanSuggestions
-}, docs) => ({
-  [ruleId]: {
-    meta: {
-      docs: {
-        recommended: !0,
-        ...docs,
-        graphQLJSRuleName: rule35.name,
-        url: `https://the-guild.dev/graphql/eslint/rules/${ruleId}`,
-        description: `${docs.description}
-> This rule is a wrapper around a \`graphql-js\` validation function.`
+import lowerCase2 from "lodash.lowercase";
+var RULE_ID = "alphabetize", fieldsEnum = [
+  Kind4.OBJECT_TYPE_DEFINITION,
+  Kind4.INTERFACE_TYPE_DEFINITION,
+  Kind4.INPUT_OBJECT_TYPE_DEFINITION
+], selectionsEnum = [
+  Kind4.OPERATION_DEFINITION,
+  Kind4.FRAGMENT_DEFINITION
+], argumentsEnum = [
+  Kind4.FIELD_DEFINITION,
+  Kind4.FIELD,
+  Kind4.DIRECTIVE_DEFINITION,
+  Kind4.DIRECTIVE
+], schema = {
+  type: "array",
+  minItems: 1,
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: !1,
+    minProperties: 1,
+    properties: {
+      fields: {
+        ...ARRAY_DEFAULT_OPTIONS,
+        items: {
+          enum: fieldsEnum
+        },
+        description: "Fields of `type`, `interface`, and `input`."
       },
-      schema: schema15,
-      hasSuggestions: hasDidYouMeanSuggestions
-    },
-    create(context) {
-      return {
-        Document(node) {
-          let schema16 = docs.requiresSchema ? requireGraphQLSchemaFromContext(ruleId, context) : null, documentNode = getDocumentNode ? getDocumentNode({ ruleId, context, node: node.rawNode() }) : node.rawNode();
-          validateDocument({
-            context,
-            schema: schema16,
-            documentNode,
-            rule: rule35,
-            hasDidYouMeanSuggestions
-          });
-        }
-      };
-    }
-  }
-}), GRAPHQL_JS_VALIDATIONS = Object.assign(
-  {},
-  validationToRule(
-    {
-      ruleId: "executable-definitions",
-      rule: ExecutableDefinitionsRule
-    },
-    {
-      category: "Operations",
-      description: "A GraphQL document is only valid for execution if all definitions are either operation or fragment definitions.",
-      requiresSchema: !0
-    }
-  ),
-  validationToRule(
-    {
-      ruleId: "fields-on-correct-type",
-      rule: FieldsOnCorrectTypeRule,
-      hasDidYouMeanSuggestions: !0
-    },
-    {
-      category: "Operations",
-      description: "A GraphQL document is only valid if all fields selected are defined by the parent type, or are an allowed meta field such as `__typename`.",
-      requiresSchema: !0
-    }
-  ),
-  validationToRule(
-    {
-      ruleId: "fragments-on-composite-type",
-      rule: FragmentsOnCompositeTypesRule
-    },
-    {
-      category: "Operations",
-      description: "Fragments use a type condition to determine if they apply, since fragments can only be spread into a composite type (object, interface, or union), the type condition must also be a composite type.",
-      requiresSchema: !0
-    }
-  ),
-  validationToRule(
-    {
-      ruleId: "known-argument-names",
-      rule: KnownArgumentNamesRule,
-      hasDidYouMeanSuggestions: !0
-    },
-    {
-      category: ["Schema", "Operations"],
-      description: "A GraphQL field is only valid if all supplied arguments are defined by that field.",
-      requiresSchema: !0
-    }
-  ),
-  validationToRule(
-    {
-      ruleId: "known-directives",
-      rule: KnownDirectivesRule,
-      getDocumentNode({ context, node: documentNode }) {
-        let { ignoreClientDirectives = [] } = context.options[0] || {};
-        if (ignoreClientDirectives.length === 0)
-          return documentNode;
-        let filterDirectives = (node) => ({
-          ...node,
-          directives: node.directives?.filter(
-            (directive) => !ignoreClientDirectives.includes(directive.name.value)
-          )
-        });
-        return visit3(documentNode, {
-          Field: filterDirectives,
-          OperationDefinition: filterDirectives
-        });
+      values: {
+        type: "boolean",
+        description: "Values of `enum`."
       },
-      schema: {
-        type: "array",
-        maxItems: 1,
+      selections: {
+        ...ARRAY_DEFAULT_OPTIONS,
+        items: {
+          enum: selectionsEnum
+        },
+        description: "Selections of `fragment` and operations `query`, `mutation` and `subscription`."
+      },
+      variables: {
+        type: "boolean",
+        description: "Variables of operations `query`, `mutation` and `subscription`."
+      },
+      arguments: {
+        ...ARRAY_DEFAULT_OPTIONS,
+        items: {
+          enum: argumentsEnum
+        },
+        description: "Arguments of fields and directives."
+      },
+      definitions: {
+        type: "boolean",
+        description: "Definitions \u2013 `type`, `interface`, `enum`, `scalar`, `input`, `union` and `directive`."
+      },
+      groups: {
+        ...ARRAY_DEFAULT_OPTIONS,
+        minItems: 2,
+        description: "Custom order group. Example: `['id', '*', 'createdAt', 'updatedAt']` where `*` says for everything else."
+      }
+    }
+  }
+}, rule = {
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    docs: {
+      category: ["Schema", "Operations"],
+      description: "Enforce arrange in alphabetical order for type fields, enum values, input object fields, operation selections and more.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      examples: [
+        {
+          title: "Incorrect",
+          usage: [{ fields: [Kind4.OBJECT_TYPE_DEFINITION] }],
+          code: (
+            /* GraphQL */
+            `
+            type User {
+              password: String
+              firstName: String! # should be before "password"
+              age: Int # should be before "firstName"
+              lastName: String!
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [{ fields: [Kind4.OBJECT_TYPE_DEFINITION] }],
+          code: (
+            /* GraphQL */
+            `
+            type User {
+              age: Int
+              firstName: String!
+              lastName: String!
+              password: String
+            }
+          `
+          )
+        },
+        {
+          title: "Incorrect",
+          usage: [{ values: !0 }],
+          code: (
+            /* GraphQL */
+            `
+            enum Role {
+              SUPER_ADMIN
+              ADMIN # should be before "SUPER_ADMIN"
+              USER
+              GOD # should be before "USER"
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [{ values: !0 }],
+          code: (
+            /* GraphQL */
+            `
+            enum Role {
+              ADMIN
+              GOD
+              SUPER_ADMIN
+              USER
+            }
+          `
+          )
+        },
+        {
+          title: "Incorrect",
+          usage: [{ selections: [Kind4.OPERATION_DEFINITION] }],
+          code: (
+            /* GraphQL */
+            `
+            query {
+              me {
+                firstName
+                lastName
+                email # should be before "lastName"
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [{ selections: [Kind4.OPERATION_DEFINITION] }],
+          code: (
+            /* GraphQL */
+            `
+            query {
+              me {
+                email
+                firstName
+                lastName
+              }
+            }
+          `
+          )
+        }
+      ],
+      configOptions: {
+        schema: [
+          {
+            definitions: !0,
+            fields: fieldsEnum,
+            values: !0,
+            arguments: argumentsEnum,
+            groups: ["id", "*", "createdAt", "updatedAt"]
+          }
+        ],
+        operations: [
+          {
+            definitions: !0,
+            selections: selectionsEnum,
+            variables: !0,
+            arguments: [Kind4.FIELD, Kind4.DIRECTIVE],
+            groups: ["id", "*", "createdAt", "updatedAt"]
+          }
+        ]
+      }
+    },
+    messages: {
+      [RULE_ID]: "{{ currNode }} should be before {{ prevNode }}"
+    },
+    schema
+  },
+  create(context) {
+    let sourceCode = context.getSourceCode();
+    function isNodeAndCommentOnSameLine(node, comment) {
+      return node.loc.end.line === comment.loc.start.line;
+    }
+    function getBeforeComments(node) {
+      let commentsBefore = sourceCode.getCommentsBefore(node);
+      if (commentsBefore.length === 0)
+        return [];
+      let tokenBefore = sourceCode.getTokenBefore(node);
+      if (tokenBefore)
+        return commentsBefore.filter((comment) => !isNodeAndCommentOnSameLine(tokenBefore, comment));
+      let filteredComments = [], nodeLine = node.loc.start.line;
+      for (let i = commentsBefore.length - 1; i >= 0; i -= 1) {
+        let comment = commentsBefore[i];
+        if (nodeLine - comment.loc.start.line - filteredComments.length > 1)
+          break;
+        filteredComments.unshift(comment);
+      }
+      return filteredComments;
+    }
+    function getRangeWithComments(node) {
+      node.kind === Kind4.VARIABLE && (node = node.parent);
+      let [firstBeforeComment] = getBeforeComments(node), [firstAfterComment] = sourceCode.getCommentsAfter(node), from = firstBeforeComment || node, to = firstAfterComment && isNodeAndCommentOnSameLine(node, firstAfterComment) ? firstAfterComment : node;
+      return [from.range[0], to.range[1]];
+    }
+    function checkNodes(nodes = []) {
+      for (let i = 1; i < nodes.length; i += 1) {
+        let currNode = nodes[i], currName = "alias" in currNode && currNode.alias?.value || "name" in currNode && currNode.name?.value;
+        if (!currName)
+          continue;
+        let prevNode = nodes[i - 1], prevName = "alias" in prevNode && prevNode.alias?.value || "name" in prevNode && prevNode.name?.value;
+        if (prevName) {
+          let compareResult = prevName.localeCompare(currName), { groups } = opts, shouldSortByGroup = !1;
+          if (groups?.length) {
+            if (!groups.includes("*"))
+              throw new Error("`groups` option should contain `*` string.");
+            let indexForPrev = groups.indexOf(prevName);
+            indexForPrev === -1 && (indexForPrev = groups.indexOf("*"));
+            let indexForCurr = groups.indexOf(currName);
+            if (indexForCurr === -1 && (indexForCurr = groups.indexOf("*")), shouldSortByGroup = indexForPrev - indexForCurr > 0, indexForPrev < indexForCurr)
+              continue;
+          }
+          if (!shouldSortByGroup && !(compareResult === 1) && (!(compareResult === 0) || !prevNode.kind.endsWith("Extension") || currNode.kind.endsWith("Extension")))
+            continue;
+        }
+        context.report({
+          // @ts-expect-error can't be undefined
+          node: "alias" in currNode && currNode.alias || currNode.name,
+          messageId: RULE_ID,
+          data: {
+            currNode: displayNodeName(currNode),
+            prevNode: prevName ? displayNodeName(prevNode) : lowerCase2(prevNode.kind)
+          },
+          *fix(fixer) {
+            let prevRange = getRangeWithComments(prevNode), currRange = getRangeWithComments(currNode);
+            yield fixer.replaceTextRange(
+              prevRange,
+              sourceCode.getText({ range: currRange })
+            ), yield fixer.replaceTextRange(
+              currRange,
+              sourceCode.getText({ range: prevRange })
+            );
+          }
+        });
+      }
+    }
+    let opts = context.options[0], fields = new Set(opts.fields ?? []), listeners = {}, fieldsSelector = [
+      fields.has(Kind4.OBJECT_TYPE_DEFINITION) && [
+        Kind4.OBJECT_TYPE_DEFINITION,
+        Kind4.OBJECT_TYPE_EXTENSION
+      ],
+      fields.has(Kind4.INTERFACE_TYPE_DEFINITION) && [
+        Kind4.INTERFACE_TYPE_DEFINITION,
+        Kind4.INTERFACE_TYPE_EXTENSION
+      ],
+      fields.has(Kind4.INPUT_OBJECT_TYPE_DEFINITION) && [
+        Kind4.INPUT_OBJECT_TYPE_DEFINITION,
+        Kind4.INPUT_OBJECT_TYPE_EXTENSION
+      ]
+    ].filter(truthy).flat().join(","), selectionsSelector = opts.selections?.join(","), argumentsSelector = opts.arguments?.join(",");
+    if (fieldsSelector && (listeners[fieldsSelector] = (node) => {
+      checkNodes(node.fields);
+    }), opts.values) {
+      let enumValuesSelector = [Kind4.ENUM_TYPE_DEFINITION, Kind4.ENUM_TYPE_EXTENSION].join(",");
+      listeners[enumValuesSelector] = (node) => {
+        checkNodes(node.values);
+      };
+    }
+    return selectionsSelector && (listeners[`:matches(${selectionsSelector}) SelectionSet`] = (node) => {
+      checkNodes(node.selections);
+    }), opts.variables && (listeners.OperationDefinition = (node) => {
+      checkNodes(node.variableDefinitions?.map((varDef) => varDef.variable));
+    }), argumentsSelector && (listeners[argumentsSelector] = (node) => {
+      checkNodes(node.arguments);
+    }), opts.definitions && (listeners.Document = (node) => {
+      checkNodes(node.definitions);
+    }), listeners;
+  }
+};
+
+// src/rules/description-style.ts
+var schema2 = {
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: !1,
+    minProperties: 1,
+    properties: {
+      style: {
+        enum: ["block", "inline"],
+        default: "block"
+      }
+    }
+  }
+}, rule2 = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: !0,
+    docs: {
+      examples: [
+        {
+          title: "Incorrect",
+          usage: [{ style: "inline" }],
+          code: (
+            /* GraphQL */
+            `
+            """ Description """
+            type someTypeName {
+              # ...
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [{ style: "inline" }],
+          code: (
+            /* GraphQL */
+            `
+            " Description "
+            type someTypeName {
+              # ...
+            }
+          `
+          )
+        }
+      ],
+      description: "Require all comments to follow the same style (either block or inline).",
+      category: "Schema",
+      url: "https://the-guild.dev/graphql/eslint/rules/description-style",
+      recommended: !0
+    },
+    schema: schema2
+  },
+  create(context) {
+    let { style = "block" } = context.options[0] || {}, isBlock = style === "block";
+    return {
+      [`.description[type=StringValue][block!=${isBlock}]`](node) {
+        context.report({
+          loc: isBlock ? node.loc : node.loc.start,
+          message: `Unexpected ${isBlock ? "inline" : "block"} description for ${getNodeName(
+            node.parent
+          )}`,
+          suggest: [
+            {
+              desc: `Change to ${isBlock ? "block" : "inline"} style description`,
+              fix(fixer) {
+                let originalText = context.getSourceCode().getText(node), newText = isBlock ? originalText.replace(/(^")|("$)/g, '"""') : originalText.replace(/(^""")|("""$)/g, '"').replace(/\s+/g, " ");
+                return fixer.replaceText(node, newText);
+              }
+            }
+          ]
+        });
+      }
+    };
+  }
+};
+
+// src/rules/graphql-js-validation.ts
+import {
+  Kind as Kind5,
+  validate,
+  visit as visit3
+} from "graphql";
+import {
+  ExecutableDefinitionsRule,
+  FieldsOnCorrectTypeRule,
+  FragmentsOnCompositeTypesRule,
+  KnownArgumentNamesRule,
+  KnownDirectivesRule,
+  KnownFragmentNamesRule,
+  KnownTypeNamesRule,
+  LoneAnonymousOperationRule,
+  LoneSchemaDefinitionRule,
+  NoFragmentCyclesRule,
+  NoUndefinedVariablesRule,
+  NoUnusedFragmentsRule,
+  NoUnusedVariablesRule,
+  OverlappingFieldsCanBeMergedRule,
+  PossibleFragmentSpreadsRule,
+  PossibleTypeExtensionsRule,
+  ProvidedRequiredArgumentsRule,
+  ScalarLeafsRule,
+  SingleFieldSubscriptionsRule,
+  UniqueArgumentNamesRule,
+  UniqueDirectiveNamesRule,
+  UniqueDirectivesPerLocationRule,
+  UniqueFieldDefinitionNamesRule,
+  UniqueInputFieldNamesRule,
+  UniqueOperationTypesRule,
+  UniqueTypeNamesRule,
+  UniqueVariableNamesRule,
+  ValuesOfCorrectTypeRule,
+  VariablesAreInputTypesRule,
+  VariablesInAllowedPositionRule
+} from "graphql/validation/index.js";
+import { validateSDL } from "graphql/validation/validate.js";
+function validateDocument({
+  context,
+  schema: schema15 = null,
+  documentNode,
+  rule: rule35,
+  hasDidYouMeanSuggestions
+}) {
+  if (documentNode.definitions.length !== 0)
+    try {
+      let validationErrors = schema15 ? validate(schema15, documentNode, [rule35]) : validateSDL(documentNode, null, [rule35]);
+      for (let error of validationErrors) {
+        let { line, column } = error.locations[0], sourceCode = context.getSourceCode(), { tokens } = sourceCode.ast, token = tokens.find(
+          (token2) => token2.loc.start.line === line && token2.loc.start.column === column - 1
+        ), loc = {
+          line,
+          column: column - 1
+        };
+        token && (loc = // if cursor on `@` symbol than use next node
+        token.type === "@" ? sourceCode.getNodeByRangeIndex(token.range[1] + 1).loc : token.loc);
+        let didYouMeanContent = error.message.match(/Did you mean (?<content>.*)\?$/)?.groups.content, matches = didYouMeanContent ? [...didYouMeanContent.matchAll(/"(?<name>[^"]*)"/g)] : [];
+        context.report({
+          loc,
+          message: error.message,
+          suggest: hasDidYouMeanSuggestions ? matches.map((match) => {
+            let { name: name2 } = match.groups;
+            return {
+              desc: `Rename to \`${name2}\``,
+              fix: (fixer) => fixer.replaceText(token, name2)
+            };
+          }) : []
+        });
+      }
+    } catch (error) {
+      context.report({
+        loc: REPORT_ON_FIRST_CHARACTER,
+        message: error.message
+      });
+    }
+}
+var getFragmentDefsAndFragmentSpreads = (node) => {
+  let fragmentDefs = /* @__PURE__ */ new Set(), fragmentSpreads = /* @__PURE__ */ new Set();
+  return visit3(node, {
+    FragmentDefinition(node2) {
+      fragmentDefs.add(node2.name.value);
+    },
+    FragmentSpread(node2) {
+      fragmentSpreads.add(node2.name.value);
+    }
+  }), { fragmentDefs, fragmentSpreads };
+}, getMissingFragments = (node) => {
+  let { fragmentDefs, fragmentSpreads } = getFragmentDefsAndFragmentSpreads(node);
+  return [...fragmentSpreads].filter((name2) => !fragmentDefs.has(name2));
+}, handleMissingFragments = ({ ruleId, context, node }) => {
+  let missingFragments = getMissingFragments(node);
+  if (missingFragments.length > 0) {
+    let siblings = requireSiblingsOperations(ruleId, context), fragmentsToAdd = [];
+    for (let fragmentName of missingFragments) {
+      let [foundFragment] = siblings.getFragment(fragmentName).map((source) => source.document);
+      foundFragment && fragmentsToAdd.push(foundFragment);
+    }
+    if (fragmentsToAdd.length > 0)
+      return handleMissingFragments({
+        ruleId,
+        context,
+        node: {
+          kind: Kind5.DOCUMENT,
+          definitions: [...node.definitions, ...fragmentsToAdd]
+        }
+      });
+  }
+  return node;
+}, validationToRule = ({
+  ruleId,
+  rule: rule35,
+  getDocumentNode,
+  schema: schema15 = [],
+  hasDidYouMeanSuggestions
+}, docs) => ({
+  [ruleId]: {
+    meta: {
+      docs: {
+        recommended: !0,
+        ...docs,
+        graphQLJSRuleName: rule35.name,
+        url: `https://the-guild.dev/graphql/eslint/rules/${ruleId}`,
+        description: `${docs.description}
+> This rule is a wrapper around a \`graphql-js\` validation function.`
+      },
+      schema: schema15,
+      hasSuggestions: hasDidYouMeanSuggestions
+    },
+    create(context) {
+      return {
+        Document(node) {
+          let schema16 = docs.requiresSchema ? requireGraphQLSchemaFromContext(ruleId, context) : null, documentNode = getDocumentNode ? getDocumentNode({ ruleId, context, node: node.rawNode() }) : node.rawNode();
+          validateDocument({
+            context,
+            schema: schema16,
+            documentNode,
+            rule: rule35,
+            hasDidYouMeanSuggestions
+          });
+        }
+      };
+    }
+  }
+}), GRAPHQL_JS_VALIDATIONS = Object.assign(
+  {},
+  validationToRule(
+    {
+      ruleId: "executable-definitions",
+      rule: ExecutableDefinitionsRule
+    },
+    {
+      category: "Operations",
+      description: "A GraphQL document is only valid for execution if all definitions are either operation or fragment definitions.",
+      requiresSchema: !0
+    }
+  ),
+  validationToRule(
+    {
+      ruleId: "fields-on-correct-type",
+      rule: FieldsOnCorrectTypeRule,
+      hasDidYouMeanSuggestions: !0
+    },
+    {
+      category: "Operations",
+      description: "A GraphQL document is only valid if all fields selected are defined by the parent type, or are an allowed meta field such as `__typename`.",
+      requiresSchema: !0
+    }
+  ),
+  validationToRule(
+    {
+      ruleId: "fragments-on-composite-type",
+      rule: FragmentsOnCompositeTypesRule
+    },
+    {
+      category: "Operations",
+      description: "Fragments use a type condition to determine if they apply, since fragments can only be spread into a composite type (object, interface, or union), the type condition must also be a composite type.",
+      requiresSchema: !0
+    }
+  ),
+  validationToRule(
+    {
+      ruleId: "known-argument-names",
+      rule: KnownArgumentNamesRule,
+      hasDidYouMeanSuggestions: !0
+    },
+    {
+      category: ["Schema", "Operations"],
+      description: "A GraphQL field is only valid if all supplied arguments are defined by that field.",
+      requiresSchema: !0
+    }
+  ),
+  validationToRule(
+    {
+      ruleId: "known-directives",
+      rule: KnownDirectivesRule,
+      getDocumentNode({ context, node: documentNode }) {
+        let { ignoreClientDirectives = [] } = context.options[0] || {};
+        if (ignoreClientDirectives.length === 0)
+          return documentNode;
+        let filterDirectives = (node) => ({
+          ...node,
+          directives: node.directives?.filter(
+            (directive) => !ignoreClientDirectives.includes(directive.name.value)
+          )
+        });
+        return visit3(documentNode, {
+          Field: filterDirectives,
+          OperationDefinition: filterDirectives
+        });
+      },
+      schema: {
+        type: "array",
+        maxItems: 1,
         items: {
           type: "object",
           additionalProperties: !1,
@@ -1028,13 +1509,13 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
           delete FilePathToDocumentsMap[currentFilePath];
           for (let [filePath, documents] of Object.entries(FilePathToDocumentsMap))
             if (getMissingFragments({
-              kind: Kind4.DOCUMENT,
+              kind: Kind5.DOCUMENT,
               definitions: documents
             }).some(
               (fragment) => fragmentDefs.has(fragment)
             ))
               return getParentNode(filePath, {
-                kind: Kind4.DOCUMENT,
+                kind: Kind5.DOCUMENT,
                 definitions: [...node2.definitions, ...documents]
               });
           return node2;
@@ -1043,586 +1524,212 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
       }
     },
     {
-      category: "Operations",
-      description: "A GraphQL document is only valid if all fragment definitions are spread within operations, or spread within other fragments spread within operations.",
-      requiresSchema: !0,
-      requiresSiblings: !0
-    }
-  ),
-  validationToRule(
-    {
-      ruleId: "no-unused-variables",
-      rule: NoUnusedVariablesRule,
-      getDocumentNode: handleMissingFragments
-    },
-    {
-      category: "Operations",
-      description: "A GraphQL operation is only valid if all variables defined by an operation are used, either directly or within a spread fragment.",
-      requiresSchema: !0,
-      requiresSiblings: !0
-    }
-  ),
-  validationToRule(
-    {
-      ruleId: "overlapping-fields-can-be-merged",
-      rule: OverlappingFieldsCanBeMergedRule
-    },
-    {
-      category: "Operations",
-      description: "A selection set is only valid if all fields (including spreading any fragments) either correspond to distinct response names or can be merged without ambiguity.",
-      requiresSchema: !0
-    }
-  ),
-  validationToRule(
-    {
-      ruleId: "possible-fragment-spread",
-      rule: PossibleFragmentSpreadsRule
-    },
-    {
-      category: "Operations",
-      description: "A fragment spread is only valid if the type condition could ever possibly be true: if there is a non-empty intersection of the possible parent types, and possible types which pass the type condition.",
-      requiresSchema: !0
-    }
-  ),
-  validationToRule(
-    {
-      ruleId: "possible-type-extension",
-      rule: PossibleTypeExtensionsRule,
-      hasDidYouMeanSuggestions: !0
-    },
-    {
-      category: "Schema",
-      description: "A type extension is only valid if the type is defined and has the same kind.",
-      recommended: !0,
-      requiresSchema: !0
-    }
-  ),
-  validationToRule(
-    {
-      ruleId: "provided-required-arguments",
-      rule: ProvidedRequiredArgumentsRule
-    },
-    {
-      category: ["Schema", "Operations"],
-      description: "A field or directive is only valid if all required (non-null without a default value) field arguments have been provided.",
-      requiresSchema: !0
-    }
-  ),
-  validationToRule(
-    {
-      ruleId: "scalar-leafs",
-      rule: ScalarLeafsRule,
-      hasDidYouMeanSuggestions: !0
-    },
-    {
-      category: "Operations",
-      description: "A GraphQL document is valid only if all leaf fields (fields without sub selections) are of scalar or enum types.",
-      requiresSchema: !0
-    }
-  ),
-  validationToRule(
-    {
-      ruleId: "one-field-subscriptions",
-      rule: SingleFieldSubscriptionsRule
-    },
-    {
-      category: "Operations",
-      description: "A GraphQL subscription is valid only if it contains a single root field.",
-      requiresSchema: !0
-    }
-  ),
-  validationToRule(
-    {
-      ruleId: "unique-argument-names",
-      rule: UniqueArgumentNamesRule
-    },
-    {
-      category: "Operations",
-      description: "A GraphQL field or directive is only valid if all supplied arguments are uniquely named.",
-      requiresSchema: !0
-    }
-  ),
-  validationToRule(
-    {
-      ruleId: "unique-directive-names",
-      rule: UniqueDirectiveNamesRule
-    },
-    {
-      category: "Schema",
-      description: "A GraphQL document is only valid if all defined directives have unique names."
-    }
-  ),
-  validationToRule(
-    {
-      ruleId: "unique-directive-names-per-location",
-      rule: UniqueDirectivesPerLocationRule
-    },
-    {
-      category: ["Schema", "Operations"],
-      description: "A GraphQL document is only valid if all non-repeatable directives at a given location are uniquely named.",
-      requiresSchema: !0
+      category: "Operations",
+      description: "A GraphQL document is only valid if all fragment definitions are spread within operations, or spread within other fragments spread within operations.",
+      requiresSchema: !0,
+      requiresSiblings: !0
     }
   ),
   validationToRule(
     {
-      ruleId: "unique-field-definition-names",
-      rule: UniqueFieldDefinitionNamesRule
+      ruleId: "no-unused-variables",
+      rule: NoUnusedVariablesRule,
+      getDocumentNode: handleMissingFragments
     },
     {
-      category: "Schema",
-      description: "A GraphQL complex type is only valid if all its fields are uniquely named."
+      category: "Operations",
+      description: "A GraphQL operation is only valid if all variables defined by an operation are used, either directly or within a spread fragment.",
+      requiresSchema: !0,
+      requiresSiblings: !0
     }
   ),
   validationToRule(
     {
-      ruleId: "unique-input-field-names",
-      rule: UniqueInputFieldNamesRule
+      ruleId: "overlapping-fields-can-be-merged",
+      rule: OverlappingFieldsCanBeMergedRule
     },
     {
       category: "Operations",
-      description: "A GraphQL input object value is only valid if all supplied fields are uniquely named."
+      description: "A selection set is only valid if all fields (including spreading any fragments) either correspond to distinct response names or can be merged without ambiguity.",
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
-      ruleId: "unique-operation-types",
-      rule: UniqueOperationTypesRule
+      ruleId: "possible-fragment-spread",
+      rule: PossibleFragmentSpreadsRule
     },
     {
-      category: "Schema",
-      description: "A GraphQL document is only valid if it has only one type per operation."
+      category: "Operations",
+      description: "A fragment spread is only valid if the type condition could ever possibly be true: if there is a non-empty intersection of the possible parent types, and possible types which pass the type condition.",
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
-      ruleId: "unique-type-names",
-      rule: UniqueTypeNamesRule
+      ruleId: "possible-type-extension",
+      rule: PossibleTypeExtensionsRule,
+      hasDidYouMeanSuggestions: !0
     },
     {
       category: "Schema",
-      description: "A GraphQL document is only valid if all defined types have unique names."
+      description: "A type extension is only valid if the type is defined and has the same kind.",
+      recommended: !0,
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
-      ruleId: "unique-variable-names",
-      rule: UniqueVariableNamesRule
+      ruleId: "provided-required-arguments",
+      rule: ProvidedRequiredArgumentsRule
     },
     {
-      category: "Operations",
-      description: "A GraphQL operation is only valid if all its variables are uniquely named.",
+      category: ["Schema", "Operations"],
+      description: "A field or directive is only valid if all required (non-null without a default value) field arguments have been provided.",
       requiresSchema: !0
     }
   ),
   validationToRule(
     {
-      ruleId: "value-literals-of-correct-type",
-      rule: ValuesOfCorrectTypeRule,
+      ruleId: "scalar-leafs",
+      rule: ScalarLeafsRule,
       hasDidYouMeanSuggestions: !0
     },
     {
       category: "Operations",
-      description: "A GraphQL document is only valid if all value literals are of the type expected at their position.",
+      description: "A GraphQL document is valid only if all leaf fields (fields without sub selections) are of scalar or enum types.",
       requiresSchema: !0
     }
   ),
   validationToRule(
     {
-      ruleId: "variables-are-input-types",
-      rule: VariablesAreInputTypesRule
+      ruleId: "one-field-subscriptions",
+      rule: SingleFieldSubscriptionsRule
     },
     {
       category: "Operations",
-      description: "A GraphQL operation is only valid if all the variables it defines are of input types (scalar, enum, or input object).",
+      description: "A GraphQL subscription is valid only if it contains a single root field.",
       requiresSchema: !0
     }
   ),
   validationToRule(
     {
-      ruleId: "variables-in-allowed-position",
-      rule: VariablesInAllowedPositionRule
+      ruleId: "unique-argument-names",
+      rule: UniqueArgumentNamesRule
     },
     {
       category: "Operations",
-      description: "Variables passed to field arguments conform to type.",
+      description: "A GraphQL field or directive is only valid if all supplied arguments are uniquely named.",
       requiresSchema: !0
     }
-  )
-);
-
-// src/rules/alphabetize.ts
-import {
-  Kind as Kind5
-} from "graphql";
-import lowerCase2 from "lodash.lowercase";
-var RULE_ID = "alphabetize", fieldsEnum = [
-  Kind5.OBJECT_TYPE_DEFINITION,
-  Kind5.INTERFACE_TYPE_DEFINITION,
-  Kind5.INPUT_OBJECT_TYPE_DEFINITION
-], selectionsEnum = [
-  Kind5.OPERATION_DEFINITION,
-  Kind5.FRAGMENT_DEFINITION
-], argumentsEnum = [
-  Kind5.FIELD_DEFINITION,
-  Kind5.FIELD,
-  Kind5.DIRECTIVE_DEFINITION,
-  Kind5.DIRECTIVE
-], schema = {
-  type: "array",
-  minItems: 1,
-  maxItems: 1,
-  items: {
-    type: "object",
-    additionalProperties: !1,
-    minProperties: 1,
-    properties: {
-      fields: {
-        ...ARRAY_DEFAULT_OPTIONS,
-        items: {
-          enum: fieldsEnum
-        },
-        description: "Fields of `type`, `interface`, and `input`."
-      },
-      values: {
-        type: "boolean",
-        description: "Values of `enum`."
-      },
-      selections: {
-        ...ARRAY_DEFAULT_OPTIONS,
-        items: {
-          enum: selectionsEnum
-        },
-        description: "Selections of `fragment` and operations `query`, `mutation` and `subscription`."
-      },
-      variables: {
-        type: "boolean",
-        description: "Variables of operations `query`, `mutation` and `subscription`."
-      },
-      arguments: {
-        ...ARRAY_DEFAULT_OPTIONS,
-        items: {
-          enum: argumentsEnum
-        },
-        description: "Arguments of fields and directives."
-      },
-      definitions: {
-        type: "boolean",
-        description: "Definitions \u2013 `type`, `interface`, `enum`, `scalar`, `input`, `union` and `directive`."
-      },
-      groups: {
-        ...ARRAY_DEFAULT_OPTIONS,
-        minItems: 2,
-        description: "Custom order group. Example: `['id', '*', 'createdAt', 'updatedAt']` where `*` says for everything else."
-      }
+  ),
+  validationToRule(
+    {
+      ruleId: "unique-directive-names",
+      rule: UniqueDirectiveNamesRule
+    },
+    {
+      category: "Schema",
+      description: "A GraphQL document is only valid if all defined directives have unique names."
     }
-  }
-}, rule = {
-  meta: {
-    type: "suggestion",
-    fixable: "code",
-    docs: {
+  ),
+  validationToRule(
+    {
+      ruleId: "unique-directive-names-per-location",
+      rule: UniqueDirectivesPerLocationRule
+    },
+    {
       category: ["Schema", "Operations"],
-      description: "Enforce arrange in alphabetical order for type fields, enum values, input object fields, operation selections and more.",
-      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-      examples: [
-        {
-          title: "Incorrect",
-          usage: [{ fields: [Kind5.OBJECT_TYPE_DEFINITION] }],
-          code: (
-            /* GraphQL */
-            `
-            type User {
-              password: String
-              firstName: String! # should be before "password"
-              age: Int # should be before "firstName"
-              lastName: String!
-            }
-          `
-          )
-        },
-        {
-          title: "Correct",
-          usage: [{ fields: [Kind5.OBJECT_TYPE_DEFINITION] }],
-          code: (
-            /* GraphQL */
-            `
-            type User {
-              age: Int
-              firstName: String!
-              lastName: String!
-              password: String
-            }
-          `
-          )
-        },
-        {
-          title: "Incorrect",
-          usage: [{ values: !0 }],
-          code: (
-            /* GraphQL */
-            `
-            enum Role {
-              SUPER_ADMIN
-              ADMIN # should be before "SUPER_ADMIN"
-              USER
-              GOD # should be before "USER"
-            }
-          `
-          )
-        },
-        {
-          title: "Correct",
-          usage: [{ values: !0 }],
-          code: (
-            /* GraphQL */
-            `
-            enum Role {
-              ADMIN
-              GOD
-              SUPER_ADMIN
-              USER
-            }
-          `
-          )
-        },
-        {
-          title: "Incorrect",
-          usage: [{ selections: [Kind5.OPERATION_DEFINITION] }],
-          code: (
-            /* GraphQL */
-            `
-            query {
-              me {
-                firstName
-                lastName
-                email # should be before "lastName"
-              }
-            }
-          `
-          )
-        },
-        {
-          title: "Correct",
-          usage: [{ selections: [Kind5.OPERATION_DEFINITION] }],
-          code: (
-            /* GraphQL */
-            `
-            query {
-              me {
-                email
-                firstName
-                lastName
-              }
-            }
-          `
-          )
-        }
-      ],
-      configOptions: {
-        schema: [
-          {
-            definitions: !0,
-            fields: fieldsEnum,
-            values: !0,
-            arguments: argumentsEnum,
-            groups: ["id", "*", "createdAt", "updatedAt"]
-          }
-        ],
-        operations: [
-          {
-            definitions: !0,
-            selections: selectionsEnum,
-            variables: !0,
-            arguments: [Kind5.FIELD, Kind5.DIRECTIVE],
-            groups: ["id", "*", "createdAt", "updatedAt"]
-          }
-        ]
-      }
+      description: "A GraphQL document is only valid if all non-repeatable directives at a given location are uniquely named.",
+      requiresSchema: !0
+    }
+  ),
+  validationToRule(
+    {
+      ruleId: "unique-field-definition-names",
+      rule: UniqueFieldDefinitionNamesRule
     },
-    messages: {
-      [RULE_ID]: "{{ currNode }} should be before {{ prevNode }}"
+    {
+      category: "Schema",
+      description: "A GraphQL complex type is only valid if all its fields are uniquely named."
+    }
+  ),
+  validationToRule(
+    {
+      ruleId: "unique-input-field-names",
+      rule: UniqueInputFieldNamesRule
     },
-    schema
-  },
-  create(context) {
-    let sourceCode = context.getSourceCode();
-    function isNodeAndCommentOnSameLine(node, comment) {
-      return node.loc.end.line === comment.loc.start.line;
+    {
+      category: "Operations",
+      description: "A GraphQL input object value is only valid if all supplied fields are uniquely named."
     }
-    function getBeforeComments(node) {
-      let commentsBefore = sourceCode.getCommentsBefore(node);
-      if (commentsBefore.length === 0)
-        return [];
-      let tokenBefore = sourceCode.getTokenBefore(node);
-      if (tokenBefore)
-        return commentsBefore.filter((comment) => !isNodeAndCommentOnSameLine(tokenBefore, comment));
-      let filteredComments = [], nodeLine = node.loc.start.line;
-      for (let i = commentsBefore.length - 1; i >= 0; i -= 1) {
-        let comment = commentsBefore[i];
-        if (nodeLine - comment.loc.start.line - filteredComments.length > 1)
-          break;
-        filteredComments.unshift(comment);
-      }
-      return filteredComments;
+  ),
+  validationToRule(
+    {
+      ruleId: "unique-operation-types",
+      rule: UniqueOperationTypesRule
+    },
+    {
+      category: "Schema",
+      description: "A GraphQL document is only valid if it has only one type per operation."
     }
-    function getRangeWithComments(node) {
-      node.kind === Kind5.VARIABLE && (node = node.parent);
-      let [firstBeforeComment] = getBeforeComments(node), [firstAfterComment] = sourceCode.getCommentsAfter(node), from = firstBeforeComment || node, to = firstAfterComment && isNodeAndCommentOnSameLine(node, firstAfterComment) ? firstAfterComment : node;
-      return [from.range[0], to.range[1]];
+  ),
+  validationToRule(
+    {
+      ruleId: "unique-type-names",
+      rule: UniqueTypeNamesRule
+    },
+    {
+      category: "Schema",
+      description: "A GraphQL document is only valid if all defined types have unique names."
     }
-    function checkNodes(nodes = []) {
-      for (let i = 1; i < nodes.length; i += 1) {
-        let currNode = nodes[i], currName = "alias" in currNode && currNode.alias?.value || "name" in currNode && currNode.name?.value;
-        if (!currName)
-          continue;
-        let prevNode = nodes[i - 1], prevName = "alias" in prevNode && prevNode.alias?.value || "name" in prevNode && prevNode.name?.value;
-        if (prevName) {
-          let compareResult = prevName.localeCompare(currName), { groups } = opts, shouldSortByGroup = !1;
-          if (groups?.length) {
-            if (!groups.includes("*"))
-              throw new Error("`groups` option should contain `*` string.");
-            let indexForPrev = groups.indexOf(prevName);
-            indexForPrev === -1 && (indexForPrev = groups.indexOf("*"));
-            let indexForCurr = groups.indexOf(currName);
-            if (indexForCurr === -1 && (indexForCurr = groups.indexOf("*")), shouldSortByGroup = indexForPrev - indexForCurr > 0, indexForPrev < indexForCurr)
-              continue;
-          }
-          if (!shouldSortByGroup && !(compareResult === 1) && (!(compareResult === 0) || !prevNode.kind.endsWith("Extension") || currNode.kind.endsWith("Extension")))
-            continue;
-        }
-        context.report({
-          // @ts-expect-error can't be undefined
-          node: "alias" in currNode && currNode.alias || currNode.name,
-          messageId: RULE_ID,
-          data: {
-            currNode: displayNodeName(currNode),
-            prevNode: prevName ? displayNodeName(prevNode) : lowerCase2(prevNode.kind)
-          },
-          *fix(fixer) {
-            let prevRange = getRangeWithComments(prevNode), currRange = getRangeWithComments(currNode);
-            yield fixer.replaceTextRange(
-              prevRange,
-              sourceCode.getText({ range: currRange })
-            ), yield fixer.replaceTextRange(
-              currRange,
-              sourceCode.getText({ range: prevRange })
-            );
-          }
-        });
-      }
+  ),
+  validationToRule(
+    {
+      ruleId: "unique-variable-names",
+      rule: UniqueVariableNamesRule
+    },
+    {
+      category: "Operations",
+      description: "A GraphQL operation is only valid if all its variables are uniquely named.",
+      requiresSchema: !0
     }
-    let opts = context.options[0], fields = new Set(opts.fields ?? []), listeners = {}, fieldsSelector = [
-      fields.has(Kind5.OBJECT_TYPE_DEFINITION) && [
-        Kind5.OBJECT_TYPE_DEFINITION,
-        Kind5.OBJECT_TYPE_EXTENSION
-      ],
-      fields.has(Kind5.INTERFACE_TYPE_DEFINITION) && [
-        Kind5.INTERFACE_TYPE_DEFINITION,
-        Kind5.INTERFACE_TYPE_EXTENSION
-      ],
-      fields.has(Kind5.INPUT_OBJECT_TYPE_DEFINITION) && [
-        Kind5.INPUT_OBJECT_TYPE_DEFINITION,
-        Kind5.INPUT_OBJECT_TYPE_EXTENSION
-      ]
-    ].filter(truthy).flat().join(","), selectionsSelector = opts.selections?.join(","), argumentsSelector = opts.arguments?.join(",");
-    if (fieldsSelector && (listeners[fieldsSelector] = (node) => {
-      checkNodes(node.fields);
-    }), opts.values) {
-      let enumValuesSelector = [Kind5.ENUM_TYPE_DEFINITION, Kind5.ENUM_TYPE_EXTENSION].join(",");
-      listeners[enumValuesSelector] = (node) => {
-        checkNodes(node.values);
-      };
+  ),
+  validationToRule(
+    {
+      ruleId: "value-literals-of-correct-type",
+      rule: ValuesOfCorrectTypeRule,
+      hasDidYouMeanSuggestions: !0
+    },
+    {
+      category: "Operations",
+      description: "A GraphQL document is only valid if all value literals are of the type expected at their position.",
+      requiresSchema: !0
     }
-    return selectionsSelector && (listeners[`:matches(${selectionsSelector}) SelectionSet`] = (node) => {
-      checkNodes(node.selections);
-    }), opts.variables && (listeners.OperationDefinition = (node) => {
-      checkNodes(node.variableDefinitions?.map((varDef) => varDef.variable));
-    }), argumentsSelector && (listeners[argumentsSelector] = (node) => {
-      checkNodes(node.arguments);
-    }), opts.definitions && (listeners.Document = (node) => {
-      checkNodes(node.definitions);
-    }), listeners;
-  }
-};
-
-// src/rules/description-style.ts
-var schema2 = {
-  type: "array",
-  maxItems: 1,
-  items: {
-    type: "object",
-    additionalProperties: !1,
-    minProperties: 1,
-    properties: {
-      style: {
-        enum: ["block", "inline"],
-        default: "block"
-      }
+  ),
+  validationToRule(
+    {
+      ruleId: "variables-are-input-types",
+      rule: VariablesAreInputTypesRule
+    },
+    {
+      category: "Operations",
+      description: "A GraphQL operation is only valid if all the variables it defines are of input types (scalar, enum, or input object).",
+      requiresSchema: !0
     }
-  }
-}, rule2 = {
-  meta: {
-    type: "suggestion",
-    hasSuggestions: !0,
-    docs: {
-      examples: [
-        {
-          title: "Incorrect",
-          usage: [{ style: "inline" }],
-          code: (
-            /* GraphQL */
-            `
-            """ Description """
-            type someTypeName {
-              # ...
-            }
-          `
-          )
-        },
-        {
-          title: "Correct",
-          usage: [{ style: "inline" }],
-          code: (
-            /* GraphQL */
-            `
-            " Description "
-            type someTypeName {
-              # ...
-            }
-          `
-          )
-        }
-      ],
-      description: "Require all comments to follow the same style (either block or inline).",
-      category: "Schema",
-      url: "https://the-guild.dev/graphql/eslint/rules/description-style",
-      recommended: !0
+  ),
+  validationToRule(
+    {
+      ruleId: "variables-in-allowed-position",
+      rule: VariablesInAllowedPositionRule
     },
-    schema: schema2
-  },
-  create(context) {
-    let { style = "block" } = context.options[0] || {}, isBlock = style === "block";
-    return {
-      [`.description[type=StringValue][block!=${isBlock}]`](node) {
-        context.report({
-          loc: isBlock ? node.loc : node.loc.start,
-          message: `Unexpected ${isBlock ? "inline" : "block"} description for ${getNodeName(
-            node.parent
-          )}`,
-          suggest: [
-            {
-              desc: `Change to ${isBlock ? "block" : "inline"} style description`,
-              fix(fixer) {
-                let originalText = context.getSourceCode().getText(node), newText = isBlock ? originalText.replace(/(^")|("$)/g, '"""') : originalText.replace(/(^""")|("""$)/g, '"').replace(/\s+/g, " ");
-                return fixer.replaceText(node, newText);
-              }
-            }
-          ]
-        });
-      }
-    };
-  }
-};
+    {
+      category: "Operations",
+      description: "Variables passed to field arguments conform to type.",
+      requiresSchema: !0
+    }
+  )
+);
 
 // src/rules/input-name.ts
 import {
@@ -1742,10 +1849,10 @@ Using the same name for all input parameters will make your schemas easier to co
         return currentNode;
       })(node);
       if (shouldCheckType(inputValueNode.parent.parent)) {
-        let mutationName = `${inputValueNode.parent.name.value}Input`, name = node.name.value;
-        (options.caseSensitiveInputType && node.name.value !== mutationName || name.toLowerCase() !== mutationName.toLowerCase()) && context.report({
+        let mutationName = `${inputValueNode.parent.name.value}Input`, name2 = node.name.value;
+        (options.caseSensitiveInputType && node.name.value !== mutationName || name2.toLowerCase() !== mutationName.toLowerCase()) && context.report({
           node: node.name,
-          message: `Input type \`${name}\` name should be \`${mutationName}\`.`,
+          message: `Input type \`${name2}\` name should be \`${mutationName}\`.`,
           suggest: [
             {
               desc: `Rename to \`${mutationName}\``,
@@ -1828,11 +1935,11 @@ var RULE_ID2 = "lone-executable-definition", definitionTypes = ["fragment", ...O
       },
       "Document:exit"() {
         for (let { node, type } of definitions.slice(1)) {
-          let name = pascalCase(type), definitionName = node.name?.value;
-          definitionName && (name += ` "${definitionName}"`), context.report({
+          let name2 = pascalCase(type), definitionName = node.name?.value;
+          definitionName && (name2 += ` "${definitionName}"`), context.report({
             loc: node.name?.loc || getLocation(node.loc.start, type),
             messageId: RULE_ID2,
-            data: { name }
+            data: { name: name2 }
           });
         }
       }
@@ -2399,51 +2506,51 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         report(node, `${nodeType} "${nodeName}" should ${errorMessage}`, suggestedNames);
       }
       function getError() {
-        let name = nodeName.replace(/(^_+)|(_+$)/g, "");
-        if (ignorePattern && new RegExp(ignorePattern, "u").test(name))
+        let name2 = nodeName.replace(/(^_+)|(_+$)/g, "");
+        if (ignorePattern && new RegExp(ignorePattern, "u").test(name2))
           return;
-        if (prefix && !name.startsWith(prefix))
+        if (prefix && !name2.startsWith(prefix))
           return {
             errorMessage: `have "${prefix}" prefix`,
-            renameToNames: [prefix + name]
+            renameToNames: [prefix + name2]
           };
-        if (suffix && !name.endsWith(suffix))
+        if (suffix && !name2.endsWith(suffix))
           return {
             errorMessage: `have "${suffix}" suffix`,
-            renameToNames: [name + suffix]
+            renameToNames: [name2 + suffix]
           };
-        let forbiddenPrefix = forbiddenPrefixes?.find((prefix2) => name.startsWith(prefix2));
+        let forbiddenPrefix = forbiddenPrefixes?.find((prefix2) => name2.startsWith(prefix2));
         if (forbiddenPrefix)
           return {
             errorMessage: `not have "${forbiddenPrefix}" prefix`,
-            renameToNames: [name.replace(new RegExp(`^${forbiddenPrefix}`), "")]
+            renameToNames: [name2.replace(new RegExp(`^${forbiddenPrefix}`), "")]
           };
-        let forbiddenSuffix = forbiddenSuffixes?.find((suffix2) => name.endsWith(suffix2));
+        let forbiddenSuffix = forbiddenSuffixes?.find((suffix2) => name2.endsWith(suffix2));
         if (forbiddenSuffix)
           return {
             errorMessage: `not have "${forbiddenSuffix}" suffix`,
-            renameToNames: [name.replace(new RegExp(`${forbiddenSuffix}$`), "")]
+            renameToNames: [name2.replace(new RegExp(`${forbiddenSuffix}$`), "")]
           };
-        if (requiredPrefixes && !requiredPrefixes.some((requiredPrefix) => name.startsWith(requiredPrefix)))
+        if (requiredPrefixes && !requiredPrefixes.some((requiredPrefix) => name2.startsWith(requiredPrefix)))
           return {
             errorMessage: `have one of the following prefixes: ${englishJoinWords(
               requiredPrefixes
             )}`,
-            renameToNames: style ? requiredPrefixes.map((prefix2) => convertCase(style, `${prefix2} ${name}`)) : requiredPrefixes.map((prefix2) => `${prefix2}${name}`)
+            renameToNames: style ? requiredPrefixes.map((prefix2) => convertCase(style, `${prefix2} ${name2}`)) : requiredPrefixes.map((prefix2) => `${prefix2}${name2}`)
           };
-        if (requiredSuffixes && !requiredSuffixes.some((requiredSuffix) => name.endsWith(requiredSuffix)))
+        if (requiredSuffixes && !requiredSuffixes.some((requiredSuffix) => name2.endsWith(requiredSuffix)))
           return {
             errorMessage: `have one of the following suffixes: ${englishJoinWords(
               requiredSuffixes
             )}`,
-            renameToNames: style ? requiredSuffixes.map((suffix2) => convertCase(style, `${name} ${suffix2}`)) : requiredSuffixes.map((suffix2) => `${name}${suffix2}`)
+            renameToNames: style ? requiredSuffixes.map((suffix2) => convertCase(style, `${name2} ${suffix2}`)) : requiredSuffixes.map((suffix2) => `${name2}${suffix2}`)
           };
         if (!style)
           return;
-        if (!StyleToRegex[style].test(name))
+        if (!StyleToRegex[style].test(name2))
           return {
             errorMessage: `be in ${style} format`,
-            renameToNames: [convertCase(style, name)]
+            renameToNames: [convertCase(style, name2)]
           };
       }
     }, checkUnderscore = (isLeading) => (node) => {
@@ -2930,8 +3037,8 @@ var RULE_ID7 = "no-one-place-fragments", rule11 = {
     for (let { document, filePath } of allDocuments) {
       let relativeFilePath = relative(CWD, filePath);
       visit4(document, {
-        FragmentSpread({ name }) {
-          let spreadName = name.value;
+        FragmentSpread({ name: name2 }) {
+          let spreadName = name2.value;
           usedFragmentsMap[spreadName] ||= [], usedFragmentsMap[spreadName].push(relativeFilePath);
         }
       });
@@ -3186,7 +3293,7 @@ var RULE_ID9 = "no-unreachable-types", KINDS = [
   Kind13.UNION_TYPE_EXTENSION,
   Kind13.ENUM_TYPE_DEFINITION,
   Kind13.ENUM_TYPE_EXTENSION
-], reachableTypesCache, RequestDirectiveLocations = /* @__PURE__ */ new Set([
+], reachableTypesCache = new ModuleCache(), RequestDirectiveLocations = /* @__PURE__ */ new Set([
   DirectiveLocation.QUERY,
   DirectiveLocation.MUTATION,
   DirectiveLocation.SUBSCRIPTION,
@@ -3197,8 +3304,9 @@ var RULE_ID9 = "no-unreachable-types", KINDS = [
   DirectiveLocation.VARIABLE_DEFINITION
 ]);
 function getReachableTypes(schema15) {
-  if (reachableTypesCache)
-    return reachableTypesCache;
+  let cachedValue = reachableTypesCache.get(schema15);
+  if (cachedValue)
+    return cachedValue;
   let reachableTypes = /* @__PURE__ */ new Set(), collect = (node) => {
     let typeName = getTypeName(node);
     if (reachableTypes.has(typeName))
@@ -3209,8 +3317,7 @@ function getReachableTypes(schema15) {
       let { objects, interfaces } = schema15.getImplementations(type);
       for (let { astNode } of [...objects, ...interfaces])
         visit5(astNode, visitor);
-    } else
-      type?.astNode && visit5(type.astNode, visitor);
+    } else type?.astNode && visit5(type.astNode, visitor);
   }, visitor = {
     InterfaceTypeDefinition: collect,
     ObjectTypeDefinition: collect,
@@ -3236,7 +3343,7 @@ function getReachableTypes(schema15) {
         argTypeName && reachableTypes.add(argTypeName);
       }
     }
-  return reachableTypesCache = reachableTypes, reachableTypesCache;
+  return reachableTypesCache.set(schema15, reachableTypes), reachableTypes;
 }
 var rule15 = {
   meta: {
@@ -3317,10 +3424,11 @@ var rule15 = {
 
 // src/rules/no-unused-fields.ts
 import { TypeInfo as TypeInfo2, visit as visit6, visitWithTypeInfo as visitWithTypeInfo2 } from "graphql";
-var RULE_ID10 = "no-unused-fields", usedFieldsCache;
+var RULE_ID10 = "no-unused-fields", usedFieldsCache = new ModuleCache();
 function getUsedFields(schema15, operations) {
-  if (usedFieldsCache)
-    return usedFieldsCache;
+  let cachedValue = usedFieldsCache.get(schema15);
+  if (cachedValue)
+    return cachedValue;
   let usedFields = /* @__PURE__ */ Object.create(null), typeInfo = new TypeInfo2(schema15), visitor = visitWithTypeInfo2(typeInfo, {
     Field(node) {
       if (!typeInfo.getFieldDef())
@@ -3331,7 +3439,7 @@ function getUsedFields(schema15, operations) {
   }), allDocuments = [...operations.getOperations(), ...operations.getFragments()];
   for (let { document } of allDocuments)
     visit6(document, visitor);
-  return usedFieldsCache = usedFields, usedFieldsCache;
+  return usedFieldsCache.set(schema15, usedFields), usedFields;
 }
 var rule16 = {
   meta: {
@@ -3615,13 +3723,13 @@ var MUST_BE_OBJECT_TYPE = "MUST_BE_OBJECT_TYPE", MUST_CONTAIN_FIELD_EDGES = "MUS
 };
 
 // src/rules/relay-edge-types.ts
-import { getDocumentNodeFromSchema } from "@graphql-tools/utils";
 import {
   isObjectType as isObjectType2,
   isScalarType as isScalarType3,
   Kind as Kind16,
   visit as visit7
 } from "graphql";
+import { getDocumentNodeFromSchema } from "@graphql-tools/utils";
 var RULE_ID12 = "relay-edge-types", MESSAGE_MUST_BE_OBJECT_TYPE = "MESSAGE_MUST_BE_OBJECT_TYPE", MESSAGE_MISSING_EDGE_SUFFIX = "MESSAGE_MISSING_EDGE_SUFFIX", MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE = "MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE", MESSAGE_SHOULD_IMPLEMENTS_NODE = "MESSAGE_SHOULD_IMPLEMENTS_NODE", edgeTypesCache;
 function getEdgeTypes(schema15) {
   if (edgeTypesCache)
@@ -4019,8 +4127,8 @@ var rule22 = {
 };
 
 // src/rules/require-description.ts
-import { getRootTypeNames } from "@graphql-tools/utils";
 import { Kind as Kind18, TokenKind as TokenKind3 } from "graphql";
+import { getRootTypeNames } from "@graphql-tools/utils";
 var RULE_ID14 = "require-description", ALLOWED_KINDS2 = [
   ...TYPES_KINDS,
   Kind18.DIRECTIVE_DEFINITION,
@@ -4321,21 +4429,17 @@ var RULE_ID16 = "require-import-fragment", SUGGESTION_ID = "add-import-expressio
         for (let comment of comments) {
           if (comment.type !== "Line" || !new RegExp(
             `^\\s*import\\s+(${fragmentName}\\s+from\\s+)?['"]`
-          ).test(comment.value))
-            continue;
+          ).test(comment.value)) continue;
           let extractedImportPath = comment.value.match(/(["'])((?:\1|.)*?)\1/)?.[2];
-          if (!extractedImportPath)
-            continue;
+          if (!extractedImportPath) continue;
           let importPath = path.join(path.dirname(filePath), extractedImportPath);
           if (fragmentsFromSiblings.some(
             (source) => source.filePath === importPath
-          ))
-            return;
+          )) return;
         }
         if (fragmentsFromSiblings.some(
           (source) => source.filePath === filePath
-        ))
-          return;
+        )) return;
         let suggestedFilePaths = fragmentsFromSiblings.length ? fragmentsFromSiblings.map((o) => path.relative(path.dirname(filePath), o.filePath)) : ["CHANGE_ME.graphql"];
         context.report({
           node,
@@ -4468,7 +4572,7 @@ var RULE_ID18 = "require-nullable-result-in-root", rule27 = {
           for (let field of node.fields || []) {
             if (field.gqlType.type !== Kind20.NON_NULL_TYPE || field.gqlType.gqlType.type !== Kind20.NAMED_TYPE)
               continue;
-            let name = field.gqlType.gqlType.name.value, type = schema15.getType(name), resultType = type?.astNode ? getNodeName(type.astNode) : type?.name;
+            let name2 = field.gqlType.gqlType.name.value, type = schema15.getType(name2), resultType = type?.astNode ? getNodeName(type.astNode) : type?.name;
             context.report({
               node: field.gqlType,
               messageId: RULE_ID18,
@@ -4493,7 +4597,6 @@ var RULE_ID18 = "require-nullable-result-in-root", rule27 = {
 };
 
 // src/rules/require-selections.ts
-import { asArray } from "@graphql-tools/utils";
 import {
   GraphQLInterfaceType,
   GraphQLObjectType,
@@ -4503,6 +4606,7 @@ import {
   visit as visit8,
   visitWithTypeInfo as visitWithTypeInfo3
 } from "graphql";
+import { asArray } from "@graphql-tools/utils";
 var RULE_ID19 = "require-selections", DEFAULT_ID_FIELD_NAME = "id", schema12 = {
   definitions: {
     asString: {
@@ -4525,6 +4629,7 @@ var RULE_ID19 = "require-selections", DEFAULT_ID_FIELD_NAME = "id", schema12 = {
 }, rule28 = {
   meta: {
     type: "suggestion",
+    // eslint-disable-next-line eslint-plugin/require-meta-has-suggestions -- false positive since we assign `problem.suggest` conditionally
     hasSuggestions: !0,
     docs: {
       category: "Operations",
@@ -4627,7 +4732,7 @@ Include it in your selection set{{ addition }}.`
       }
       function checkFields(rawType2) {
         let fields = rawType2.getFields();
-        if (!idNames.some((name) => fields[name]))
+        if (!idNames.some((name2) => fields[name2]))
           return;
         function hasIdField({ selections }) {
           return selections.some((selection) => {
@@ -4649,8 +4754,8 @@ Include it in your selection set{{ addition }}.`
         if (checkFragments(node), hasId)
           return;
         let pluralSuffix = idNames.length > 1 ? "s" : "", fieldName2 = englishJoinWords(
-          idNames.map((name) => `\`${(parent.alias || parent.name).value}.${name}\``)
-        ), addition = checkedFragmentSpreads.size === 0 ? "" : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? "s" : ""} ${englishJoinWords([...checkedFragmentSpreads].map((name) => `\`${name}\``))}`, problem = {
+          idNames.map((name2) => `\`${(parent.alias || parent.name).value}.${name2}\``)
+        ), addition = checkedFragmentSpreads.size === 0 ? "" : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? "s" : ""} ${englishJoinWords([...checkedFragmentSpreads].map((name2) => `\`${name2}\``))}`, problem = {
           loc,
           messageId: RULE_ID19,
           data: {
@@ -4830,7 +4935,7 @@ var RULE_ID21 = "selection-set-depth", schema13 = {
           checkFn({
             getDocument: () => document,
             reportError(error) {
-              let { line, column } = error.locations[0], token = context.getAncestors()[0].tokens.find(
+              let { line, column } = error.locations[0], token = context.sourceCode.getAncestors(node)[0].tokens.find(
                 (token2) => token2.loc.start.line === line && token2.loc.start.column === column - 1
               );
               context.report({
@@ -5274,7 +5379,7 @@ var rules = {
 };
 
 // src/configs/index.ts
-var import_operations_all = __toESM(require_operations_all()), import_operations_recommended = __toESM(require_operations_recommended()), import_schema_all = __toESM(require_schema_all()), import_schema_recommended = __toESM(require_schema_recommended()), import_schema_relay = __toESM(require_schema_relay()), configs = {
+var import_operations_all = __toESM(require_operations_all(), 1), import_operations_recommended = __toESM(require_operations_recommended(), 1), import_schema_all = __toESM(require_schema_all(), 1), import_schema_recommended = __toESM(require_schema_recommended(), 1), import_schema_relay = __toESM(require_schema_relay(), 1), configs = {
   "schema-recommended": import_schema_recommended.default,
   "schema-all": import_schema_all.default,
   "schema-relay": import_schema_relay.default,
@@ -5283,9 +5388,7 @@ var import_operations_all = __toESM(require_operations_all()), import_operations
 };
 
 // src/flat-configs.ts
-var languageOptions = {
-  parser: { parseForESLint }
-}, flatConfigs = {
+var languageOptions = { parser }, flatConfigs = {
   "operations-all": {
     languageOptions,
     rules: {
@@ -5314,10 +5417,7 @@ var languageOptions = {
   }
 };
 export {
-  configs,
   flatConfigs,
-  parseForESLint,
-  requireGraphQLSchemaFromContext,
-  requireSiblingsOperations,
+  parser,
   rules
 };