@graphql-eslint/eslint-plugin 4.3.0 → 4.3.1-alpha-20241209185034-de2d7397da8c26620a8930dd12b6dff42e43f537

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

@@ -1,3 +1,223 @@
+// src/configs/operations-all.ts
+var operations_all_default = {
+  extends: "./configs/operations-recommended",
+  rules: {
+    "@graphql-eslint/alphabetize": [
+      "error",
+      {
+        definitions: true,
+        selections: ["OperationDefinition", "FragmentDefinition"],
+        variables: true,
+        arguments: ["Field", "Directive"],
+        groups: ["...", "id", "*", "{"]
+      }
+    ],
+    "@graphql-eslint/lone-executable-definition": "error",
+    "@graphql-eslint/match-document-filename": [
+      "error",
+      {
+        query: "kebab-case",
+        mutation: "kebab-case",
+        subscription: "kebab-case",
+        fragment: "kebab-case"
+      }
+    ],
+    "@graphql-eslint/no-one-place-fragments": "error",
+    "@graphql-eslint/require-import-fragment": "error"
+  }
+};
+
+// src/configs/operations-recommended.ts
+var operations_recommended_default = {
+  parser: "@graphql-eslint/eslint-plugin",
+  plugins: ["@graphql-eslint"],
+  rules: {
+    "@graphql-eslint/executable-definitions": "error",
+    "@graphql-eslint/fields-on-correct-type": "error",
+    "@graphql-eslint/fragments-on-composite-type": "error",
+    "@graphql-eslint/known-argument-names": "error",
+    "@graphql-eslint/known-directives": "error",
+    "@graphql-eslint/known-fragment-names": "error",
+    "@graphql-eslint/known-type-names": "error",
+    "@graphql-eslint/lone-anonymous-operation": "error",
+    "@graphql-eslint/naming-convention": [
+      "error",
+      {
+        VariableDefinition: "camelCase",
+        OperationDefinition: {
+          style: "PascalCase",
+          forbiddenPrefixes: ["Query", "Mutation", "Subscription", "Get"],
+          forbiddenSuffixes: ["Query", "Mutation", "Subscription"]
+        },
+        FragmentDefinition: {
+          style: "PascalCase",
+          forbiddenPrefixes: ["Fragment"],
+          forbiddenSuffixes: ["Fragment"]
+        }
+      }
+    ],
+    "@graphql-eslint/no-anonymous-operations": "error",
+    "@graphql-eslint/no-deprecated": "error",
+    "@graphql-eslint/no-duplicate-fields": "error",
+    "@graphql-eslint/no-fragment-cycles": "error",
+    "@graphql-eslint/no-undefined-variables": "error",
+    "@graphql-eslint/no-unused-fragments": "error",
+    "@graphql-eslint/no-unused-variables": "error",
+    "@graphql-eslint/one-field-subscriptions": "error",
+    "@graphql-eslint/overlapping-fields-can-be-merged": "error",
+    "@graphql-eslint/possible-fragment-spread": "error",
+    "@graphql-eslint/provided-required-arguments": "error",
+    "@graphql-eslint/require-selections": "error",
+    "@graphql-eslint/scalar-leafs": "error",
+    "@graphql-eslint/selection-set-depth": ["error", { maxDepth: 7 }],
+    "@graphql-eslint/unique-argument-names": "error",
+    "@graphql-eslint/unique-directive-names-per-location": "error",
+    "@graphql-eslint/unique-fragment-name": "error",
+    "@graphql-eslint/unique-input-field-names": "error",
+    "@graphql-eslint/unique-operation-name": "error",
+    "@graphql-eslint/unique-variable-names": "error",
+    "@graphql-eslint/value-literals-of-correct-type": "error",
+    "@graphql-eslint/variables-are-input-types": "error",
+    "@graphql-eslint/variables-in-allowed-position": "error"
+  }
+};
+
+// src/configs/schema-all.ts
+var schema_all_default = {
+  extends: "./configs/schema-recommended",
+  rules: {
+    "@graphql-eslint/alphabetize": [
+      "error",
+      {
+        definitions: true,
+        fields: ["ObjectTypeDefinition", "InterfaceTypeDefinition", "InputObjectTypeDefinition"],
+        values: true,
+        arguments: ["FieldDefinition", "Field", "DirectiveDefinition", "Directive"],
+        groups: ["id", "*", "createdAt", "updatedAt"]
+      }
+    ],
+    "@graphql-eslint/input-name": "error",
+    "@graphql-eslint/no-root-type": ["error", { disallow: ["mutation", "subscription"] }],
+    "@graphql-eslint/no-scalar-result-type-on-mutation": "error",
+    "@graphql-eslint/require-deprecation-date": "error",
+    "@graphql-eslint/require-field-of-type-query-in-mutation-result": "error",
+    "@graphql-eslint/require-nullable-fields-with-oneof": "error",
+    "@graphql-eslint/require-nullable-result-in-root": "error",
+    "@graphql-eslint/require-type-pattern-with-oneof": "error"
+  }
+};
+
+// src/configs/schema-recommended.ts
+var schema_recommended_default = {
+  parser: "@graphql-eslint/eslint-plugin",
+  plugins: ["@graphql-eslint"],
+  rules: {
+    "@graphql-eslint/description-style": "error",
+    "@graphql-eslint/known-argument-names": "error",
+    "@graphql-eslint/known-directives": "error",
+    "@graphql-eslint/known-type-names": "error",
+    "@graphql-eslint/lone-schema-definition": "error",
+    "@graphql-eslint/naming-convention": [
+      "error",
+      {
+        types: "PascalCase",
+        FieldDefinition: "camelCase",
+        InputValueDefinition: "camelCase",
+        Argument: "camelCase",
+        DirectiveDefinition: "camelCase",
+        EnumValueDefinition: "UPPER_CASE",
+        "FieldDefinition[parent.name.value=Query]": {
+          forbiddenPrefixes: ["query", "get"],
+          forbiddenSuffixes: ["Query"]
+        },
+        "FieldDefinition[parent.name.value=Mutation]": {
+          forbiddenPrefixes: ["mutation"],
+          forbiddenSuffixes: ["Mutation"]
+        },
+        "FieldDefinition[parent.name.value=Subscription]": {
+          forbiddenPrefixes: ["subscription"],
+          forbiddenSuffixes: ["Subscription"]
+        },
+        "EnumTypeDefinition,EnumTypeExtension": {
+          forbiddenPrefixes: ["Enum"],
+          forbiddenSuffixes: ["Enum"]
+        },
+        "InterfaceTypeDefinition,InterfaceTypeExtension": {
+          forbiddenPrefixes: ["Interface"],
+          forbiddenSuffixes: ["Interface"]
+        },
+        "UnionTypeDefinition,UnionTypeExtension": {
+          forbiddenPrefixes: ["Union"],
+          forbiddenSuffixes: ["Union"]
+        },
+        "ObjectTypeDefinition,ObjectTypeExtension": {
+          forbiddenPrefixes: ["Type"],
+          forbiddenSuffixes: ["Type"]
+        }
+      }
+    ],
+    "@graphql-eslint/no-hashtag-description": "error",
+    "@graphql-eslint/no-typename-prefix": "error",
+    "@graphql-eslint/no-unreachable-types": "error",
+    "@graphql-eslint/possible-type-extension": "error",
+    "@graphql-eslint/provided-required-arguments": "error",
+    "@graphql-eslint/require-deprecation-reason": "error",
+    "@graphql-eslint/require-description": [
+      "error",
+      { types: true, DirectiveDefinition: true, rootField: true }
+    ],
+    "@graphql-eslint/strict-id-in-types": "error",
+    "@graphql-eslint/unique-directive-names": "error",
+    "@graphql-eslint/unique-directive-names-per-location": "error",
+    "@graphql-eslint/unique-enum-value-names": "error",
+    "@graphql-eslint/unique-field-definition-names": "error",
+    "@graphql-eslint/unique-operation-types": "error",
+    "@graphql-eslint/unique-type-names": "error"
+  }
+};
+
+// src/configs/schema-relay.ts
+var schema_relay_default = {
+  parser: "@graphql-eslint/eslint-plugin",
+  plugins: ["@graphql-eslint"],
+  rules: {
+    "@graphql-eslint/relay-arguments": "error",
+    "@graphql-eslint/relay-connection-types": "error",
+    "@graphql-eslint/relay-edge-types": "error",
+    "@graphql-eslint/relay-page-info": "error"
+  }
+};
+
+// src/configs/index.ts
+var configs = {
+  "schema-recommended": schema_recommended_default,
+  "schema-all": schema_all_default,
+  "schema-relay": schema_relay_default,
+  "operations-recommended": operations_recommended_default,
+  "operations-all": operations_all_default,
+  "flat/schema-recommended": {
+    rules: schema_recommended_default.rules
+  },
+  "flat/schema-all": {
+    rules: {
+      ...schema_recommended_default.rules,
+      ...schema_all_default.rules
+    }
+  },
+  "flat/schema-relay": {
+    rules: schema_relay_default.rules
+  },
+  "flat/operations-recommended": {
+    rules: operations_recommended_default.rules
+  },
+  "flat/operations-all": {
+    rules: {
+      ...operations_recommended_default.rules,
+      ...operations_all_default.rules
+    }
+  }
+};
+
 // src/parser.ts
 import debugFactory2 from "debug";
 import { buildSchema, GraphQLError } from "graphql";
@@ -5,14 +225,28 @@ import { parseGraphQLSDL } from "@graphql-tools/utils";
 
 // src/cache.ts
 import debugFactory from "debug";
-var log = debugFactory("graphql-eslint:ModuleCache"), ModuleCache = class {
+var log = debugFactory("graphql-eslint:ModuleCache");
+var ModuleCache = class {
   map = /* @__PURE__ */ new Map();
   set(cacheKey, result) {
+    if (true) return;
+    this.map.set(cacheKey, { lastSeen: process.hrtime(), result });
+    log("setting entry for", cacheKey);
   }
   get(cacheKey, settings = {
     lifetime: 10
     /* seconds */
   }) {
+    if (true) return;
+    const value = this.map.get(cacheKey);
+    if (!value) {
+      log("cache miss for", cacheKey);
+      return;
+    }
+    const { lastSeen, result } = value;
+    if (process.env.NODE || process.hrtime(lastSeen)[0] < settings.lifetime) {
+      return result;
+    }
   }
 };
 
@@ -33,12 +267,17 @@ import {
   TokenKind
 } from "graphql";
 import { valueFromASTUntyped } from "graphql/utilities/valueFromASTUntyped.js";
-var valueFromNode = (...args) => valueFromASTUntyped(...args);
+var valueFromNode = (...args) => {
+  return valueFromASTUntyped(...args);
+};
 function getBaseType(type) {
-  return isNonNullType(type) || isListType(type) ? getBaseType(type.ofType) : type;
+  if (isNonNullType(type) || isListType(type)) {
+    return getBaseType(type.ofType);
+  }
+  return type;
 }
 function convertToken(token, type) {
-  let { line, column, end, start, value } = token;
+  const { line, column, end, start, value } = token;
   return {
     type,
     value,
@@ -60,20 +299,26 @@ function convertToken(token, type) {
   };
 }
 function extractTokens(filePath, code) {
-  let source = new Source(code, filePath), lexer = new Lexer(source), tokens = [], token = lexer.advance();
-  for (; token && token.kind !== TokenKind.EOF; ) {
-    let result = convertToken(token, token.kind);
-    tokens.push(result), token = lexer.advance();
+  const source = new Source(code, filePath);
+  const lexer = new Lexer(source);
+  const tokens = [];
+  let token = lexer.advance();
+  while (token && token.kind !== TokenKind.EOF) {
+    const result = convertToken(token, token.kind);
+    tokens.push(result);
+    token = lexer.advance();
   }
   return tokens;
 }
 function extractComments(loc) {
-  if (!loc)
+  if (!loc) {
     return [];
-  let comments = [], token = loc.startToken;
-  for (; token; ) {
+  }
+  const comments = [];
+  let token = loc.startToken;
+  while (token) {
     if (token.kind === TokenKind.COMMENT) {
-      let comment = convertToken(
+      const comment = convertToken(
         token,
         // `eslint-disable` directive works only with `Block` type comment
         token.value.trimStart().startsWith("eslint") ? "Block" : "Line"
@@ -85,7 +330,8 @@ function extractComments(loc) {
   return comments;
 }
 function convertLocation(location) {
-  let { startToken, endToken, source, start, end } = location, loc = {
+  const { startToken, endToken, source, start, end } = location;
+  const loc = {
     start: {
       /*
        * Kind.Document has startToken: { line: 0, column: 0 }, we set line as 1 and column as 0
@@ -99,19 +345,24 @@ function convertLocation(location) {
     },
     source: source.body
   };
-  return loc.start.column === loc.end.column && (loc.end.column += end - start), loc;
+  if (loc.start.column === loc.end.column) {
+    loc.end.column += end - start;
+  }
+  return loc;
 }
 
 // src/estree-converter/converter.ts
 function convertToESTree(node, schema16) {
-  let typeInfo = schema16 && new TypeInfo(schema16), visitor = {
+  const typeInfo = schema16 && new TypeInfo(schema16);
+  const visitor = {
     leave(node2, key, parent) {
-      let leadingComments = "description" in node2 && node2.description ? [
+      const leadingComments = "description" in node2 && node2.description ? [
         {
           type: node2.description.block ? "Block" : "Line",
           value: node2.description.value
         }
-      ] : [], calculatedTypeInfo = typeInfo ? {
+      ] : [];
+      const calculatedTypeInfo = typeInfo ? {
         argument: typeInfo.getArgument(),
         defaultValue: typeInfo.getDefaultValue(),
         directive: typeInfo.getDirective(),
@@ -121,12 +372,19 @@ function convertToESTree(node, schema16) {
         parentInputType: typeInfo.getParentInputType(),
         parentType: typeInfo.getParentType(),
         gqlType: typeInfo.getType()
-      } : {}, rawNode = () => parent && key !== void 0 ? parent[key] : node2.kind === Kind.DOCUMENT ? {
-        ...node2,
-        definitions: node2.definitions.map(
-          (definition) => definition.rawNode()
-        )
-      } : node2, commonFields = {
+      } : {};
+      const rawNode = () => {
+        if (parent && key !== void 0) {
+          return parent[key];
+        }
+        return node2.kind === Kind.DOCUMENT ? {
+          ...node2,
+          definitions: node2.definitions.map(
+            (definition) => definition.rawNode()
+          )
+        } : node2;
+      };
+      const commonFields = {
         ...node2,
         type: node2.kind,
         loc: convertLocation(node2.loc),
@@ -150,7 +408,7 @@ function convertToESTree(node, schema16) {
 }
 
 // src/meta.ts
-var version = "4.3.0";
+var version = "4.3.1-alpha-20241209185034-de2d7397da8c26620a8930dd12b6dff42e43f537";
 
 // src/siblings.ts
 import {
@@ -162,25 +420,28 @@ import {
 import { Kind as Kind2 } from "graphql";
 import lowerCase from "lodash.lowercase";
 function requireGraphQLOperations(ruleId, context) {
-  let { siblingOperations } = context.sourceCode.parserServices;
-  if (!siblingOperations.available)
+  const { siblingOperations } = context.sourceCode.parserServices;
+  if (!siblingOperations.available) {
     throw new Error(
       `Rule \`${ruleId}\` requires graphql-config \`documents\` field to be set and loaded. See https://the-guild.dev/graphql/eslint/docs/usage#providing-operations for more info`
     );
+  }
   return siblingOperations;
 }
 function requireGraphQLSchema(ruleId, context) {
-  let { schema: schema16 } = context.sourceCode.parserServices;
-  if (!schema16)
+  const { schema: schema16 } = context.sourceCode.parserServices;
+  if (!schema16) {
     throw new Error(
       `Rule \`${ruleId}\` requires graphql-config \`schema\` field to be set and loaded. See https://the-guild.dev/graphql/eslint/docs/usage#providing-schema for more info`
     );
+  }
   return schema16;
 }
 var chalk = {
   red: (str) => `\x1B[31m${str}\x1B[39m`,
   yellow: (str) => `\x1B[33m${str}\x1B[39m`
-}, logger = {
+};
+var logger = {
   error: (...args) => (
     // eslint-disable-next-line no-console
     console.error(chalk.red("error"), "[graphql-eslint]", ...args)
@@ -189,17 +450,25 @@ var chalk = {
     // eslint-disable-next-line no-console
     console.warn(chalk.yellow("warning"), "[graphql-eslint]", ...args)
   )
-}, slash = (path2) => path2.replaceAll("\\", "/"), VIRTUAL_DOCUMENT_REGEX = /[/\\]\d+_document.graphql$/, CWD = process.cwd(), getTypeName = (node) => "type" in node ? getTypeName(node.type) : "name" in node && node.name ? node.name.value : "", TYPES_KINDS = [
+};
+var slash = (path2) => path2.replaceAll("\\", "/");
+var VIRTUAL_DOCUMENT_REGEX = /[/\\]\d+_document.graphql$/;
+var CWD = process.cwd();
+var getTypeName = (node) => "type" in node ? getTypeName(node.type) : "name" in node && node.name ? node.name.value : "";
+var TYPES_KINDS = [
   Kind2.OBJECT_TYPE_DEFINITION,
   Kind2.INTERFACE_TYPE_DEFINITION,
   Kind2.ENUM_TYPE_DEFINITION,
   Kind2.SCALAR_TYPE_DEFINITION,
   Kind2.INPUT_OBJECT_TYPE_DEFINITION,
   Kind2.UNION_TYPE_DEFINITION
-], pascalCase = (str) => lowerCase(str).split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(""), camelCase = (str) => {
-  let result = pascalCase(str);
+];
+var pascalCase = (str) => lowerCase(str).split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+var camelCase = (str) => {
+  const result = pascalCase(str);
   return result.charAt(0).toLowerCase() + result.slice(1);
-}, convertCase = (style, str) => {
+};
+var convertCase = (style, str) => {
   switch (style) {
     case "camelCase":
       return camelCase(str);
@@ -214,7 +483,7 @@ var chalk = {
   }
 };
 function getLocation(start, fieldName = "") {
-  let { line, column } = start;
+  const { line, column } = start;
   return {
     start: {
       line,
@@ -226,14 +495,17 @@ function getLocation(start, fieldName = "") {
     }
   };
 }
-var REPORT_ON_FIRST_CHARACTER = { column: 0, line: 1 }, ARRAY_DEFAULT_OPTIONS = {
+var REPORT_ON_FIRST_CHARACTER = { column: 0, line: 1 };
+var ARRAY_DEFAULT_OPTIONS = {
   type: "array",
-  uniqueItems: !0,
+  uniqueItems: true,
   minItems: 1,
   items: {
     type: "string"
   }
-}, englishJoinWords = (words) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(words), DisplayNodeNameMap = {
+};
+var englishJoinWords = (words) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(words);
+var DisplayNodeNameMap = {
   [Kind2.ARGUMENT]: "argument",
   [Kind2.BOOLEAN]: "boolean",
   [Kind2.DIRECTIVE_DEFINITION]: "directive",
@@ -310,11 +582,18 @@ var eslintSelectorsTip = `> [!TIP]
 var siblingOperationsCache = /* @__PURE__ */ new Map();
 function getSiblings(documents) {
   if (documents.length === 0) {
-    let printed = !1, noopWarn = () => (printed || (logger.warn(
-      "getSiblingOperations was called without any operations. Make sure to set graphql-config `documents` field to make this feature available! See https://the-guild.dev/graphql/config/docs/user/documents for more info"
-    ), printed = !0), []);
+    let printed = false;
+    const noopWarn = () => {
+      if (!printed) {
+        logger.warn(
+          "getSiblingOperations was called without any operations. Make sure to set graphql-config `documents` field to make this feature available! See https://the-guild.dev/graphql/config/docs/user/documents for more info"
+        );
+        printed = true;
+      }
+      return [];
+    };
     return {
-      available: !1,
+      available: false,
       getFragment: noopWarn,
       getFragments: noopWarn,
       getFragmentByType: noopWarn,
@@ -324,55 +603,80 @@ function getSiblings(documents) {
       getOperationByType: noopWarn
     };
   }
-  let value = siblingOperationsCache.get(documents);
-  if (value)
+  const value = siblingOperationsCache.get(documents);
+  if (value) {
     return value;
-  let fragmentsCache = null, getFragments = () => {
+  }
+  let fragmentsCache = null;
+  const getFragments = () => {
     if (fragmentsCache === null) {
-      let result = [];
-      for (let source of documents)
-        for (let definition of source.document?.definitions || [])
-          definition.kind === Kind3.FRAGMENT_DEFINITION && result.push({
-            filePath: source.location,
-            document: definition
-          });
+      const result = [];
+      for (const source of documents) {
+        for (const definition of source.document?.definitions || []) {
+          if (definition.kind === Kind3.FRAGMENT_DEFINITION) {
+            result.push({
+              filePath: source.location,
+              document: definition
+            });
+          }
+        }
+      }
       fragmentsCache = result;
     }
     return fragmentsCache;
-  }, cachedOperations = null, getOperations = () => {
+  };
+  let cachedOperations = null;
+  const getOperations = () => {
     if (cachedOperations === null) {
-      let result = [];
-      for (let source of documents)
-        for (let definition of source.document?.definitions || [])
-          definition.kind === Kind3.OPERATION_DEFINITION && result.push({
-            filePath: source.location,
-            document: definition
-          });
+      const result = [];
+      for (const source of documents) {
+        for (const definition of source.document?.definitions || []) {
+          if (definition.kind === Kind3.OPERATION_DEFINITION) {
+            result.push({
+              filePath: source.location,
+              document: definition
+            });
+          }
+        }
+      }
       cachedOperations = result;
     }
     return cachedOperations;
-  }, getFragment = (name) => getFragments().filter((f) => f.document.name.value === name), collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => (visit2(selectable, {
-    FragmentSpread(spread) {
-      let fragmentName = spread.name.value, [fragment] = getFragment(fragmentName);
-      if (!fragment) {
-        logger.warn(
-          `Unable to locate fragment named "${fragmentName}", please make sure it's loaded using "parserOptions.operations"`
-        );
-        return;
+  };
+  const getFragment = (name) => getFragments().filter((f) => f.document.name.value === name);
+  const collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => {
+    visit2(selectable, {
+      FragmentSpread(spread) {
+        const fragmentName = spread.name.value;
+        const [fragment] = getFragment(fragmentName);
+        if (!fragment) {
+          logger.warn(
+            `Unable to locate fragment named "${fragmentName}", please make sure it's loaded using "parserOptions.operations"`
+          );
+          return;
+        }
+        if (!collected.has(fragmentName)) {
+          collected.set(fragmentName, fragment.document);
+          if (recursive) {
+            collectFragments(fragment.document, recursive, collected);
+          }
+        }
       }
-      collected.has(fragmentName) || (collected.set(fragmentName, fragment.document), recursive && collectFragments(fragment.document, recursive, collected));
-    }
-  }), collected), siblingOperations = {
-    available: !0,
+    });
+    return collected;
+  };
+  const siblingOperations = {
+    available: true,
     getFragment,
     getFragments,
     getFragmentByType: (typeName) => getFragments().filter((f) => f.document.typeCondition.name.value === typeName),
-    getFragmentsInUse: (selectable, recursive = !0) => Array.from(collectFragments(selectable, recursive).values()),
+    getFragmentsInUse: (selectable, recursive = true) => Array.from(collectFragments(selectable, recursive).values()),
     getOperation: (name) => getOperations().filter((o) => o.document.name?.value === name),
     getOperations,
     getOperationByType: (type) => getOperations().filter((o) => o.document.operation === type)
   };
-  return siblingOperationsCache.set(documents, siblingOperations), siblingOperations;
+  siblingOperationsCache.set(documents, siblingOperations);
+  return siblingOperations;
 }
 
 // src/parser.ts
@@ -391,26 +695,44 @@ var LEGACY_PARSER_OPTIONS_KEYS = [
   "operations"
 ];
 function parseForESLint(code, options) {
-  for (let key of LEGACY_PARSER_OPTIONS_KEYS)
-    if (key in options)
+  for (const key of LEGACY_PARSER_OPTIONS_KEYS) {
+    if (key in options) {
       throw new Error(
         `\`parserOptions.${key}\` was removed in graphql-eslint@4. Use physical graphql-config for setting schema and documents or \`parserOptions.graphQLConfig\` for programmatic usage.`
       );
+    }
+  }
   try {
-    let { filePath } = options, { document } = parseGraphQLSDL(filePath, code, { noLocation: !1 }), project, schema16, documents;
-    documents = [
-      parseGraphQLSDL(
-        "operation.graphql",
-        options.graphQLConfig.documents,
-        { noLocation: !0 }
-      )
-    ];
+    const { filePath } = options;
+    const { document } = parseGraphQLSDL(filePath, code, { noLocation: false });
+    let project;
+    let schema16, documents;
+    if (false) {
+      const gqlConfig = loadGraphQLConfig(options);
+      project = gqlConfig.getProjectForFile(getFirstExistingPath(filePath));
+      documents = getDocuments(project);
+    } else {
+      documents = [
+        parseGraphQLSDL(
+          "operation.graphql",
+          options.graphQLConfig.documents,
+          { noLocation: true }
+        )
+      ];
+    }
     try {
-      schema16 = buildSchema(options.graphQLConfig.schema);
+      if (false) {
+        schema16 = getSchema(project);
+      } else {
+        schema16 = buildSchema(options.graphQLConfig.schema);
+      }
     } catch (error) {
-      throw error instanceof Error && (error.message = `Error while loading schema: ${error.message}`), error;
+      if (error instanceof Error) {
+        error.message = `Error while loading schema: ${error.message}`;
+      }
+      throw error;
     }
-    let rootTree = convertToESTree(document, schema16);
+    const rootTree = convertToESTree(document, schema16);
     return {
       services: {
         schema: schema16,
@@ -427,9 +749,12 @@ function parseForESLint(code, options) {
       }
     };
   } catch (error) {
-    if (error instanceof Error && (error.message = `[graphql-eslint] ${error.message}`), error instanceof GraphQLError) {
-      let location = error.locations?.[0];
-      throw {
+    if (error instanceof Error) {
+      error.message = `[graphql-eslint] ${error.message}`;
+    }
+    if (error instanceof GraphQLError) {
+      const location = error.locations?.[0];
+      const eslintError = {
         index: error.positions?.[0],
         ...location && {
           lineNumber: location.line,
@@ -437,6 +762,7 @@ function parseForESLint(code, options) {
         },
         message: error.message
       };
+      throw eslintError;
     }
     throw error;
   }
@@ -449,30 +775,37 @@ var parser = {
   }
 };
 
+// src/processor.ts
+var processor = {};
+
 // src/rules/alphabetize/index.ts
 import {
   Kind as Kind4
 } from "graphql";
 import lowerCase2 from "lodash.lowercase";
-var RULE_ID = "alphabetize", fieldsEnum = [
+var RULE_ID = "alphabetize";
+var fieldsEnum = [
   Kind4.OBJECT_TYPE_DEFINITION,
   Kind4.INTERFACE_TYPE_DEFINITION,
   Kind4.INPUT_OBJECT_TYPE_DEFINITION
-], selectionsEnum = [
+];
+var selectionsEnum = [
   Kind4.OPERATION_DEFINITION,
   Kind4.FRAGMENT_DEFINITION
-], argumentsEnum = [
+];
+var argumentsEnum = [
   Kind4.FIELD_DEFINITION,
   Kind4.FIELD,
   Kind4.DIRECTIVE_DEFINITION,
   Kind4.DIRECTIVE
-], schema = {
+];
+var schema = {
   type: "array",
   minItems: 1,
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     minProperties: 1,
     properties: {
       fields: {
@@ -517,12 +850,12 @@ var RULE_ID = "alphabetize", fieldsEnum = [
           "- `id` stands for field with name `id`",
           "- `*` stands for everything else",
           "- `{` stands for fields `selection set`"
-        ].join(`
-`)
+        ].join("\n")
       }
     }
   }
-}, rule = {
+};
+var rule = {
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -563,7 +896,7 @@ var RULE_ID = "alphabetize", fieldsEnum = [
         },
         {
           title: "Incorrect",
-          usage: [{ values: !0 }],
+          usage: [{ values: true }],
           code: (
             /* GraphQL */
             `
@@ -578,7 +911,7 @@ var RULE_ID = "alphabetize", fieldsEnum = [
         },
         {
           title: "Correct",
-          usage: [{ values: !0 }],
+          usage: [{ values: true }],
           code: (
             /* GraphQL */
             `
@@ -627,18 +960,18 @@ var RULE_ID = "alphabetize", fieldsEnum = [
       configOptions: {
         schema: [
           {
-            definitions: !0,
+            definitions: true,
             fields: fieldsEnum,
-            values: !0,
+            values: true,
             arguments: argumentsEnum,
             groups: ["id", "*", "createdAt", "updatedAt"]
           }
         ],
         operations: [
           {
-            definitions: !0,
+            definitions: true,
             selections: selectionsEnum,
-            variables: !0,
+            variables: true,
             arguments: [Kind4.FIELD, Kind4.DIRECTIVE],
             groups: ["...", "id", "*", "{"]
           }
@@ -651,48 +984,71 @@ var RULE_ID = "alphabetize", fieldsEnum = [
     schema
   },
   create(context) {
-    let sourceCode = context.getSourceCode();
+    const 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)
+      const commentsBefore = sourceCode.getCommentsBefore(node);
+      if (commentsBefore.length === 0) {
         return [];
-      let tokenBefore = sourceCode.getTokenBefore(node);
-      if (tokenBefore)
+      }
+      const tokenBefore = sourceCode.getTokenBefore(node);
+      if (tokenBefore) {
         return commentsBefore.filter((comment) => !isNodeAndCommentOnSameLine(tokenBefore, comment));
-      let filteredComments = [], nodeLine = node.loc.start.line;
+      }
+      const filteredComments = [];
+      const 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)
+        const 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;
+      if (node.kind === Kind4.VARIABLE) {
+        node = node.parent;
+      }
+      const [firstBeforeComment] = getBeforeComments(node);
+      const [firstAfterComment] = sourceCode.getCommentsAfter(node);
+      const from = firstBeforeComment || node;
+      const 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 = getName(currNode);
-        if (!currName)
+        const currNode = nodes[i];
+        const currName = getName(currNode);
+        if (!currName) {
           continue;
-        let prevNode = nodes[i - 1], prevName = getName(prevNode);
+        }
+        const prevNode = nodes[i - 1];
+        const prevName = getName(prevNode);
         if (prevName) {
-          let compareResult = prevName.localeCompare(currName), { groups } = opts, shouldSortByGroup = !1;
+          const compareResult = prevName.localeCompare(currName);
+          const { groups } = opts;
+          let shouldSortByGroup = false;
           if (groups?.length) {
-            if (!groups.includes("*"))
+            if (!groups.includes("*")) {
               throw new Error("`groups` option should contain `*` string.");
-            let indexForPrev = getIndex({ node: prevNode, groups }), indexForCurr = getIndex({ node: currNode, groups });
-            if (shouldSortByGroup = indexForPrev - indexForCurr > 0, indexForPrev < indexForCurr)
+            }
+            const indexForPrev = getIndex({ node: prevNode, groups });
+            const indexForCurr = getIndex({ node: currNode, groups });
+            shouldSortByGroup = indexForPrev - indexForCurr > 0;
+            if (indexForPrev < indexForCurr) {
               continue;
+            }
+          }
+          const shouldSort = compareResult === 1;
+          if (!shouldSortByGroup && !shouldSort) {
+            const isSameName = compareResult === 0;
+            if (!isSameName || !prevNode.kind.endsWith("Extension") || currNode.kind.endsWith("Extension")) {
+              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
@@ -703,11 +1059,13 @@ var RULE_ID = "alphabetize", fieldsEnum = [
             prevNode: prevName ? displayNodeName(prevNode) : lowerCase2(prevNode.kind)
           },
           *fix(fixer) {
-            let prevRange = getRangeWithComments(prevNode), currRange = getRangeWithComments(currNode);
+            const prevRange = getRangeWithComments(prevNode);
+            const currRange = getRangeWithComments(currNode);
             yield fixer.replaceTextRange(
               prevRange,
               sourceCode.getText({ range: currRange })
-            ), yield fixer.replaceTextRange(
+            );
+            yield fixer.replaceTextRange(
               currRange,
               sourceCode.getText({ range: prevRange })
             );
@@ -715,7 +1073,10 @@ var RULE_ID = "alphabetize", fieldsEnum = [
         });
       }
     }
-    let opts = context.options[0], fields = new Set(opts.fields ?? []), listeners = {}, fieldsSelector = [
+    const opts = context.options[0];
+    const fields = new Set(opts.fields ?? []);
+    const listeners = {};
+    const kinds = [
       fields.has(Kind4.OBJECT_TYPE_DEFINITION) && [
         Kind4.OBJECT_TYPE_DEFINITION,
         Kind4.OBJECT_TYPE_EXTENSION
@@ -728,24 +1089,42 @@ var RULE_ID = "alphabetize", fieldsEnum = [
         Kind4.INPUT_OBJECT_TYPE_DEFINITION,
         Kind4.INPUT_OBJECT_TYPE_EXTENSION
       ]
-    ].filter((v) => !!v).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(",");
+    ].filter((v) => !!v).flat();
+    const fieldsSelector = kinds.join(",");
+    const selectionsSelector = opts.selections?.join(",");
+    const argumentsSelector = opts.arguments?.join(",");
+    if (fieldsSelector) {
+      listeners[fieldsSelector] = (node) => {
+        checkNodes(node.fields);
+      };
+    }
+    if (opts.values) {
+      const 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;
+    if (selectionsSelector) {
+      listeners[`:matches(${selectionsSelector}) SelectionSet`] = (node) => {
+        checkNodes(node.selections);
+      };
+    }
+    if (opts.variables) {
+      listeners.OperationDefinition = (node) => {
+        checkNodes(node.variableDefinitions?.map((varDef) => varDef.variable));
+      };
+    }
+    if (argumentsSelector) {
+      listeners[argumentsSelector] = (node) => {
+        checkNodes(node.arguments);
+      };
+    }
+    if (opts.definitions) {
+      listeners.Document = (node) => {
+        checkNodes(node.definitions);
+      };
+    }
+    return listeners;
   }
 };
 function getIndex({
@@ -753,7 +1132,10 @@ function getIndex({
   groups
 }) {
   let index = groups.indexOf(getName(node));
-  return index === -1 && "selectionSet" in node && node.selectionSet && (index = groups.indexOf("{")), index === -1 && node.kind === Kind4.FRAGMENT_SPREAD && (index = groups.indexOf("...")), index === -1 && (index = groups.indexOf("*")), index;
+  if (index === -1 && "selectionSet" in node && node.selectionSet) index = groups.indexOf("{");
+  if (index === -1 && node.kind === Kind4.FRAGMENT_SPREAD) index = groups.indexOf("...");
+  if (index === -1) index = groups.indexOf("*");
+  return index;
 }
 function getName(node) {
   return "alias" in node && node.alias?.value || //
@@ -766,7 +1148,7 @@ var schema2 = {
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     minProperties: 1,
     properties: {
       style: {
@@ -775,10 +1157,11 @@ var schema2 = {
       }
     }
   }
-}, rule2 = {
+};
+var rule2 = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       examples: [
         {
@@ -811,12 +1194,13 @@ var schema2 = {
       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
+      recommended: true
     },
     schema: schema2
   },
   create(context) {
-    let { style = "block" } = context.options[0] || {}, isBlock = style === "block";
+    const { style = "block" } = context.options[0] || {};
+    const isBlock = style === "block";
     return {
       [`.description[type=StringValue][block!=${isBlock}]`](node) {
         context.report({
@@ -828,7 +1212,9 @@ var schema2 = {
             {
               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, " ");
+                const sourceCode = context.getSourceCode();
+                const originalText = sourceCode.getText(node);
+                const newText = isBlock ? originalText.replace(/(^")|("$)/g, '"""') : originalText.replace(/(^""")|("""$)/g, '"').replace(/\s+/g, " ");
                 return fixer.replaceText(node, newText);
               }
             }
@@ -885,60 +1271,77 @@ function validateDocument({
   rule: rule35,
   hasDidYouMeanSuggestions
 }) {
-  if (documentNode.definitions.length !== 0)
-    try {
-      let validationErrors = schema16 ? validate(schema16, 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)
-            };
-          }) : []
-        });
+  if (documentNode.definitions.length === 0) {
+    return;
+  }
+  try {
+    const validationErrors = schema16 ? validate(schema16, documentNode, [rule35]) : validateSDL(documentNode, null, [rule35]);
+    for (const error of validationErrors) {
+      const { line, column } = error.locations[0];
+      const sourceCode = context.getSourceCode();
+      const { tokens } = sourceCode.ast;
+      const token = tokens.find(
+        (token2) => token2.loc.start.line === line && token2.loc.start.column === column - 1
+      );
+      let loc = {
+        line,
+        column: column - 1
+      };
+      if (token) {
+        loc = // if cursor on `@` symbol than use next node
+        token.type === "@" ? sourceCode.getNodeByRangeIndex(token.range[1] + 1).loc : token.loc;
       }
-    } catch (error) {
+      const didYouMeanContent = error.message.match(/Did you mean (?<content>.*)\?$/)?.groups.content;
+      const matches = didYouMeanContent ? [...didYouMeanContent.matchAll(/"(?<name>[^"]*)"/g)] : [];
       context.report({
-        loc: REPORT_ON_FIRST_CHARACTER,
-        message: error.message
+        loc,
+        message: error.message,
+        suggest: hasDidYouMeanSuggestions ? matches.map((match) => {
+          const { 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, {
+  const fragmentDefs = /* @__PURE__ */ new Set();
+  const fragmentSpreads = /* @__PURE__ */ new Set();
+  const visitor = {
     FragmentDefinition(node2) {
       fragmentDefs.add(node2.name.value);
     },
     FragmentSpread(node2) {
       fragmentSpreads.add(node2.name.value);
     }
-  }), { fragmentDefs, fragmentSpreads };
-}, getMissingFragments = (node) => {
-  let { fragmentDefs, fragmentSpreads } = getFragmentDefsAndFragmentSpreads(node);
+  };
+  visit3(node, visitor);
+  return { fragmentDefs, fragmentSpreads };
+};
+var getMissingFragments = (node) => {
+  const { fragmentDefs, fragmentSpreads } = getFragmentDefsAndFragmentSpreads(node);
   return [...fragmentSpreads].filter((name) => !fragmentDefs.has(name));
-}, handleMissingFragments = ({ ruleId, context, node }) => {
-  let missingFragments = getMissingFragments(node);
+};
+var handleMissingFragments = ({ ruleId, context, node }) => {
+  const missingFragments = getMissingFragments(node);
   if (missingFragments.length > 0) {
-    let siblings = requireGraphQLOperations(ruleId, context), fragmentsToAdd = [];
-    for (let fragmentName of missingFragments) {
-      let [foundFragment] = siblings.getFragment(fragmentName).map((source) => source.document);
-      foundFragment && fragmentsToAdd.push(foundFragment);
+    const siblings = requireGraphQLOperations(ruleId, context);
+    const fragmentsToAdd = [];
+    for (const fragmentName of missingFragments) {
+      const [foundFragment] = siblings.getFragment(fragmentName).map((source) => source.document);
+      if (foundFragment) {
+        fragmentsToAdd.push(foundFragment);
+      }
     }
-    if (fragmentsToAdd.length > 0)
+    if (fragmentsToAdd.length > 0) {
       return handleMissingFragments({
         ruleId,
         context,
@@ -947,44 +1350,50 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
           definitions: [...node.definitions, ...fragmentsToAdd]
         }
       });
+    }
   }
   return node;
-}, validationToRule = ({
+};
+var validationToRule = ({
   ruleId,
   rule: rule35,
   getDocumentNode,
   schema: schema16 = [],
   hasDidYouMeanSuggestions
-}, docs) => ({
-  [ruleId]: {
-    meta: {
-      docs: {
-        recommended: !0,
-        ...docs,
-        graphQLJSRuleName: rule35.name,
-        url: `https://the-guild.dev/graphql/eslint/rules/${ruleId}`,
-        description: `${docs.description}
+}, docs) => {
+  return {
+    [ruleId]: {
+      meta: {
+        docs: {
+          recommended: true,
+          ...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: schema16,
+        hasSuggestions: hasDidYouMeanSuggestions
       },
-      schema: schema16,
-      hasSuggestions: hasDidYouMeanSuggestions
-    },
-    create(context) {
-      return {
-        Document(node) {
-          let schema17 = docs.requiresSchema ? requireGraphQLSchema(ruleId, context) : null, documentNode = getDocumentNode ? getDocumentNode({ ruleId, context, node: node.rawNode() }) : node.rawNode();
-          validateDocument({
-            context,
-            schema: schema17,
-            documentNode,
-            rule: rule35,
-            hasDidYouMeanSuggestions
-          });
-        }
-      };
+      create(context) {
+        return {
+          Document(node) {
+            const schema17 = docs.requiresSchema ? requireGraphQLSchema(ruleId, context) : null;
+            const documentNode = getDocumentNode ? getDocumentNode({ ruleId, context, node: node.rawNode() }) : node.rawNode();
+            validateDocument({
+              context,
+              schema: schema17,
+              documentNode,
+              rule: rule35,
+              hasDidYouMeanSuggestions
+            });
+          }
+        };
+      }
     }
-  }
-}), GRAPHQL_JS_VALIDATIONS = Object.assign(
+  };
+};
+var GRAPHQL_JS_VALIDATIONS = Object.assign(
   {},
   validationToRule(
     {
@@ -994,19 +1403,19 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       category: "Operations",
       description: "A GraphQL document is only valid for execution if all definitions are either operation or fragment definitions.",
-      requiresSchema: !0
+      requiresSchema: true
     }
   ),
   validationToRule(
     {
       ruleId: "fields-on-correct-type",
       rule: FieldsOnCorrectTypeRule,
-      hasDidYouMeanSuggestions: !0
+      hasDidYouMeanSuggestions: true
     },
     {
       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
+      requiresSchema: true
     }
   ),
   validationToRule(
@@ -1017,19 +1426,19 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       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
+      requiresSchema: true
     }
   ),
   validationToRule(
     {
       ruleId: "known-argument-names",
       rule: KnownArgumentNamesRule,
-      hasDidYouMeanSuggestions: !0
+      hasDidYouMeanSuggestions: true
     },
     {
       category: ["Schema", "Operations"],
       description: "A GraphQL field is only valid if all supplied arguments are defined by that field.",
-      requiresSchema: !0
+      requiresSchema: true
     }
   ),
   validationToRule(
@@ -1037,10 +1446,11 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
       ruleId: "known-directives",
       rule: KnownDirectivesRule,
       getDocumentNode({ context, node: documentNode }) {
-        let { ignoreClientDirectives = [] } = context.options[0] || {};
-        if (ignoreClientDirectives.length === 0)
+        const { ignoreClientDirectives = [] } = context.options[0] || {};
+        if (ignoreClientDirectives.length === 0) {
           return documentNode;
-        let filterDirectives = (node) => ({
+        }
+        const filterDirectives = (node) => ({
           ...node,
           directives: node.directives?.filter(
             (directive) => !ignoreClientDirectives.includes(directive.name.value)
@@ -1056,7 +1466,7 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
         maxItems: 1,
         items: {
           type: "object",
-          additionalProperties: !1,
+          additionalProperties: false,
           required: ["ignoreClientDirectives"],
           properties: {
             ignoreClientDirectives: ARRAY_DEFAULT_OPTIONS
@@ -1067,7 +1477,7 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       category: ["Schema", "Operations"],
       description: "A GraphQL document is only valid if all `@directive`s are known by the schema and legally positioned.",
-      requiresSchema: !0,
+      requiresSchema: true,
       examples: [
         {
           title: "Valid",
@@ -1095,8 +1505,8 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       category: "Operations",
       description: "A GraphQL document is only valid if all `...Fragment` fragment spreads refer to fragments defined in the same document.",
-      requiresSchema: !0,
-      requiresSiblings: !0,
+      requiresSchema: true,
+      requiresSiblings: true,
       examples: [
         {
           title: "Incorrect",
@@ -1158,12 +1568,12 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       ruleId: "known-type-names",
       rule: KnownTypeNamesRule,
-      hasDidYouMeanSuggestions: !0
+      hasDidYouMeanSuggestions: true
     },
     {
       category: ["Schema", "Operations"],
       description: "A GraphQL document is only valid if referenced types (specifically variable definitions and fragment conditions) are defined by the type schema.",
-      requiresSchema: !0
+      requiresSchema: true
     }
   ),
   validationToRule(
@@ -1174,7 +1584,7 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       category: "Operations",
       description: "A GraphQL document that contains an anonymous operation (the `query` short-hand) is only valid if it contains only that one operation definition.",
-      requiresSchema: !0
+      requiresSchema: true
     }
   ),
   validationToRule(
@@ -1195,7 +1605,7 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       category: "Operations",
       description: "A GraphQL fragment is only valid when it does not have cycles in fragments usage.",
-      requiresSchema: !0
+      requiresSchema: true
     }
   ),
   validationToRule(
@@ -1207,8 +1617,8 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       category: "Operations",
       description: "A GraphQL operation is only valid if all variables encountered, both directly and via fragment spreads, are defined by that operation.",
-      requiresSchema: !0,
-      requiresSiblings: !0
+      requiresSchema: true,
+      requiresSiblings: true
     }
   ),
   validationToRule(
@@ -1216,25 +1626,36 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
       ruleId: "no-unused-fragments",
       rule: NoUnusedFragmentsRule,
       getDocumentNode: ({ ruleId, context, node }) => {
-        let siblings = requireGraphQLOperations(ruleId, context), FilePathToDocumentsMap = [
+        const siblings = requireGraphQLOperations(ruleId, context);
+        const FilePathToDocumentsMap = [
           ...siblings.getOperations(),
           ...siblings.getFragments()
-        ].reduce((map, { filePath, document }) => (map[filePath] ??= [], map[filePath].push(document), map), /* @__PURE__ */ Object.create(null)), getParentNode = (currentFilePath, node2) => {
-          let { fragmentDefs } = getFragmentDefsAndFragmentSpreads(node2);
-          if (fragmentDefs.size === 0)
+        ].reduce((map, { filePath, document }) => {
+          map[filePath] ??= [];
+          map[filePath].push(document);
+          return map;
+        }, /* @__PURE__ */ Object.create(null));
+        const getParentNode = (currentFilePath, node2) => {
+          const { fragmentDefs } = getFragmentDefsAndFragmentSpreads(node2);
+          if (fragmentDefs.size === 0) {
             return node2;
+          }
           delete FilePathToDocumentsMap[currentFilePath];
-          for (let [filePath, documents] of Object.entries(FilePathToDocumentsMap))
-            if (getMissingFragments({
+          for (const [filePath, documents] of Object.entries(FilePathToDocumentsMap)) {
+            const missingFragments = getMissingFragments({
               kind: Kind5.DOCUMENT,
               definitions: documents
-            }).some(
+            });
+            const isCurrentFileImportFragment = missingFragments.some(
               (fragment) => fragmentDefs.has(fragment)
-            ))
+            );
+            if (isCurrentFileImportFragment) {
               return getParentNode(filePath, {
                 kind: Kind5.DOCUMENT,
                 definitions: [...node2.definitions, ...documents]
               });
+            }
+          }
           return node2;
         };
         return getParentNode(context.filename, node);
@@ -1243,8 +1664,8 @@ 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
+      requiresSchema: true,
+      requiresSiblings: true
     }
   ),
   validationToRule(
@@ -1256,8 +1677,8 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       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
+      requiresSchema: true,
+      requiresSiblings: true
     }
   ),
   validationToRule(
@@ -1268,7 +1689,7 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       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
+      requiresSchema: true
     }
   ),
   validationToRule(
@@ -1279,20 +1700,20 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       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
+      requiresSchema: true
     }
   ),
   validationToRule(
     {
       ruleId: "possible-type-extension",
       rule: PossibleTypeExtensionsRule,
-      hasDidYouMeanSuggestions: !0
+      hasDidYouMeanSuggestions: true
     },
     {
       category: "Schema",
       description: "A type extension is only valid if the type is defined and has the same kind.",
-      recommended: !0,
-      requiresSchema: !0
+      recommended: true,
+      requiresSchema: true
     }
   ),
   validationToRule(
@@ -1303,19 +1724,19 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       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
+      requiresSchema: true
     }
   ),
   validationToRule(
     {
       ruleId: "scalar-leafs",
       rule: ScalarLeafsRule,
-      hasDidYouMeanSuggestions: !0
+      hasDidYouMeanSuggestions: true
     },
     {
       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
+      requiresSchema: true
     }
   ),
   validationToRule(
@@ -1326,7 +1747,7 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       category: "Operations",
       description: "A GraphQL subscription is valid only if it contains a single root field.",
-      requiresSchema: !0
+      requiresSchema: true
     }
   ),
   validationToRule(
@@ -1337,7 +1758,7 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       category: "Operations",
       description: "A GraphQL field or directive is only valid if all supplied arguments are uniquely named.",
-      requiresSchema: !0
+      requiresSchema: true
     }
   ),
   validationToRule(
@@ -1358,7 +1779,7 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       category: ["Schema", "Operations"],
       description: "A GraphQL document is only valid if all non-repeatable directives at a given location are uniquely named.",
-      requiresSchema: !0
+      requiresSchema: true
     }
   ),
   validationToRule(
@@ -1409,19 +1830,19 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       category: "Operations",
       description: "A GraphQL operation is only valid if all its variables are uniquely named.",
-      requiresSchema: !0
+      requiresSchema: true
     }
   ),
   validationToRule(
     {
       ruleId: "value-literals-of-correct-type",
       rule: ValuesOfCorrectTypeRule,
-      hasDidYouMeanSuggestions: !0
+      hasDidYouMeanSuggestions: true
     },
     {
       category: "Operations",
       description: "A GraphQL document is only valid if all value literals are of the type expected at their position.",
-      requiresSchema: !0
+      requiresSchema: true
     }
   ),
   validationToRule(
@@ -1432,7 +1853,7 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       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
+      requiresSchema: true
     }
   ),
   validationToRule(
@@ -1443,7 +1864,7 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
     {
       category: "Operations",
       description: "Variables passed to field arguments conform to type.",
-      requiresSchema: !0
+      requiresSchema: true
     }
   )
 );
@@ -1457,46 +1878,49 @@ var schema3 = {
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     properties: {
       checkInputType: {
         type: "boolean",
-        default: !1,
+        default: false,
         description: "Check that the input type name follows the convention \\<mutationName>Input"
       },
       caseSensitiveInputType: {
         type: "boolean",
-        default: !0,
+        default: true,
         description: "Allow for case discrepancies in the input type name"
       },
       checkQueries: {
         type: "boolean",
-        default: !1,
+        default: false,
         description: "Apply the rule to Queries"
       },
       checkMutations: {
         type: "boolean",
-        default: !0,
+        default: true,
         description: "Apply the rule to Mutations"
       }
     }
   }
-}, isObjectType = (node) => (
+};
+var isObjectType = (node) => (
   // TODO: remove `as any` when drop support of graphql@15
   [Kind6.OBJECT_TYPE_DEFINITION, Kind6.OBJECT_TYPE_EXTENSION].includes(node.type)
-), isQueryType = (node) => isObjectType(node) && node.name.value === "Query", isMutationType = (node) => isObjectType(node) && node.name.value === "Mutation", rule3 = {
+);
+var isQueryType = (node) => isObjectType(node) && node.name.value === "Query";
+var isMutationType = (node) => isObjectType(node) && node.name.value === "Mutation";
+var rule3 = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
-      description: `Require mutation argument to be always called "input" and input type to be called Mutation name + "Input".
-Using the same name for all input parameters will make your schemas easier to consume and more predictable. Using the same name as mutation for InputType will make it easier to find mutations that InputType belongs to.`,
+      description: 'Require mutation argument to be always called "input" and input type to be called Mutation name + "Input".\nUsing the same name for all input parameters will make your schemas easier to consume and more predictable. Using the same name as mutation for InputType will make it easier to find mutations that InputType belongs to.',
       category: "Schema",
       url: "https://the-guild.dev/graphql/eslint/rules/input-name",
       examples: [
         {
           title: "Incorrect",
-          usage: [{ checkInputType: !0 }],
+          usage: [{ checkInputType: true }],
           code: (
             /* GraphQL */
             `
@@ -1508,7 +1932,7 @@ Using the same name for all input parameters will make your schemas easier to co
         },
         {
           title: "Correct (with `checkInputType`)",
-          usage: [{ checkInputType: !0 }],
+          usage: [{ checkInputType: true }],
           code: (
             /* GraphQL */
             `
@@ -1520,7 +1944,7 @@ Using the same name for all input parameters will make your schemas easier to co
         },
         {
           title: "Correct (without `checkInputType`)",
-          usage: [{ checkInputType: !1 }],
+          usage: [{ checkInputType: false }],
           code: (
             /* GraphQL */
             `
@@ -1535,16 +1959,18 @@ Using the same name for all input parameters will make your schemas easier to co
     schema: schema3
   },
   create(context) {
-    let options = {
-      checkInputType: !1,
-      caseSensitiveInputType: !0,
-      checkMutations: !0,
+    const options = {
+      checkInputType: false,
+      caseSensitiveInputType: true,
+      checkMutations: true,
       ...context.options[0]
-    }, shouldCheckType = (node) => options.checkMutations && isMutationType(node) || options.checkQueries && isQueryType(node) || !1, listeners = {
+    };
+    const shouldCheckType = (node) => options.checkMutations && isMutationType(node) || options.checkQueries && isQueryType(node) || false;
+    const listeners = {
       "FieldDefinition > InputValueDefinition[name.value!=input] > Name"(node) {
-        let fieldDef = node.parent.parent;
+        const fieldDef = node.parent.parent;
         if (shouldCheckType(fieldDef.parent)) {
-          let inputName = node.value;
+          const inputName = node.value;
           context.report({
             node,
             message: `Input "${inputName}" should be named "input" for "${fieldDef.parent.name.value}.${fieldDef.name.value}"`,
@@ -1558,39 +1984,49 @@ Using the same name for all input parameters will make your schemas easier to co
         }
       }
     };
-    return options.checkInputType && (listeners["FieldDefinition > InputValueDefinition NamedType"] = (node) => {
-      let inputValueNode = ((item) => {
-        let currentNode = item;
-        for (; currentNode.type !== Kind6.INPUT_VALUE_DEFINITION; )
-          currentNode = currentNode.parent;
-        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({
-          node: node.name,
-          message: `Input type \`${name}\` name should be \`${mutationName}\`.`,
-          suggest: [
-            {
-              desc: `Rename to \`${mutationName}\``,
-              fix: (fixer) => fixer.replaceText(node, mutationName)
-            }
-          ]
-        });
-      }
-    }), listeners;
+    if (options.checkInputType) {
+      listeners["FieldDefinition > InputValueDefinition NamedType"] = (node) => {
+        const findInputType = (item) => {
+          let currentNode = item;
+          while (currentNode.type !== Kind6.INPUT_VALUE_DEFINITION) {
+            currentNode = currentNode.parent;
+          }
+          return currentNode;
+        };
+        const inputValueNode = findInputType(node);
+        if (shouldCheckType(inputValueNode.parent.parent)) {
+          const mutationName = `${inputValueNode.parent.name.value}Input`;
+          const name = node.name.value;
+          if (options.caseSensitiveInputType && node.name.value !== mutationName || name.toLowerCase() !== mutationName.toLowerCase()) {
+            context.report({
+              node: node.name,
+              message: `Input type \`${name}\` name should be \`${mutationName}\`.`,
+              suggest: [
+                {
+                  desc: `Rename to \`${mutationName}\``,
+                  fix: (fixer) => fixer.replaceText(node, mutationName)
+                }
+              ]
+            });
+          }
+        }
+      };
+    }
+    return listeners;
   }
 };
 
 // src/rules/lone-executable-definition/index.ts
 import { OperationTypeNode as OperationTypeNode2 } from "graphql";
-var RULE_ID2 = "lone-executable-definition", definitionTypes = ["fragment", ...Object.values(OperationTypeNode2)], schema4 = {
+var RULE_ID2 = "lone-executable-definition";
+var definitionTypes = ["fragment", ...Object.values(OperationTypeNode2)];
+var schema4 = {
   type: "array",
   maxItems: 1,
   items: {
     type: "object",
     minProperties: 1,
-    additionalProperties: !1,
+    additionalProperties: false,
     properties: {
       ignore: {
         ...ARRAY_DEFAULT_OPTIONS,
@@ -1603,7 +2039,8 @@ var RULE_ID2 = "lone-executable-definition", definitionTypes = ["fragment", ...O
       }
     }
   }
-}, rule4 = {
+};
+var rule4 = {
   meta: {
     type: "suggestion",
     docs: {
@@ -1644,16 +2081,23 @@ var RULE_ID2 = "lone-executable-definition", definitionTypes = ["fragment", ...O
     schema: schema4
   },
   create(context) {
-    let ignore = new Set(context.options[0]?.ignore || []), definitions = [];
+    const ignore = new Set(context.options[0]?.ignore || []);
+    const definitions = [];
     return {
       ":matches(OperationDefinition, FragmentDefinition)"(node) {
-        let type = "operation" in node ? node.operation : "fragment";
-        ignore.has(type) || definitions.push({ type, node });
+        const type = "operation" in node ? node.operation : "fragment";
+        if (!ignore.has(type)) {
+          definitions.push({ type, node });
+        }
       },
       "Document:exit"() {
-        for (let { node, type } of definitions.slice(1)) {
-          let name = pascalCase(type), definitionName = node.name?.value;
-          definitionName && (name += ` "${definitionName}"`), context.report({
+        for (const { node, type } of definitions.slice(1)) {
+          let name = pascalCase(type);
+          const definitionName = node.name?.value;
+          if (definitionName) {
+            name += ` "${definitionName}"`;
+          }
+          context.report({
             loc: node.name?.loc || getLocation(node.loc.start, type),
             messageId: RULE_ID2,
             data: { name }
@@ -1667,16 +2111,20 @@ var RULE_ID2 = "lone-executable-definition", definitionTypes = ["fragment", ...O
 // src/rules/match-document-filename/index.ts
 import { basename, extname } from "node:path";
 import { Kind as Kind7 } from "graphql";
-var MATCH_EXTENSION = "MATCH_EXTENSION", MATCH_STYLE = "MATCH_STYLE", CASE_STYLES = [
+var MATCH_EXTENSION = "MATCH_EXTENSION";
+var MATCH_STYLE = "MATCH_STYLE";
+var CASE_STYLES = [
   "camelCase",
   "PascalCase",
   "snake_case",
   "UPPER_CASE",
   "kebab-case",
   "matchDocumentStyle"
-], schemaOption = {
+];
+var schemaOption = {
   oneOf: [{ $ref: "#/definitions/asString" }, { $ref: "#/definitions/asObject" }]
-}, schema5 = {
+};
+var schema5 = {
   definitions: {
     asString: {
       enum: CASE_STYLES,
@@ -1684,7 +2132,7 @@ var MATCH_EXTENSION = "MATCH_EXTENSION", MATCH_STYLE = "MATCH_STYLE", CASE_STYLE
     },
     asObject: {
       type: "object",
-      additionalProperties: !1,
+      additionalProperties: false,
       minProperties: 1,
       properties: {
         style: { enum: CASE_STYLES },
@@ -1698,7 +2146,7 @@ var MATCH_EXTENSION = "MATCH_EXTENSION", MATCH_STYLE = "MATCH_STYLE", CASE_STYLE
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     minProperties: 1,
     properties: {
       fileExtension: { enum: [".gql", ".graphql"] },
@@ -1708,7 +2156,8 @@ var MATCH_EXTENSION = "MATCH_EXTENSION", MATCH_STYLE = "MATCH_STYLE", CASE_STYLE
       fragment: schemaOption
     }
   }
-}, rule5 = {
+};
+var rule5 = {
   meta: {
     type: "suggestion",
     docs: {
@@ -1846,47 +2295,69 @@ var MATCH_EXTENSION = "MATCH_EXTENSION", MATCH_STYLE = "MATCH_STYLE", CASE_STYLE
     schema: schema5
   },
   create(context) {
-    let options = context.options[0] || {
+    const options = context.options[0] || {
       fileExtension: null
-    }, filePath = context.filename;
-    if (VIRTUAL_DOCUMENT_REGEX.test(filePath))
+    };
+    const filePath = context.filename;
+    const isVirtualFile = VIRTUAL_DOCUMENT_REGEX.test(filePath);
+    if (isVirtualFile) {
       return {};
-    let fileExtension = extname(filePath), filename = basename(filePath, fileExtension);
+    }
+    const fileExtension = extname(filePath);
+    const filename = basename(filePath, fileExtension);
     return {
       Document(documentNode) {
-        options.fileExtension && options.fileExtension !== fileExtension && context.report({
-          loc: REPORT_ON_FIRST_CHARACTER,
-          messageId: MATCH_EXTENSION,
-          data: {
-            fileExtension,
-            expectedFileExtension: options.fileExtension
-          }
-        });
-        let firstOperation = documentNode.definitions.find(
+        if (options.fileExtension && options.fileExtension !== fileExtension) {
+          context.report({
+            loc: REPORT_ON_FIRST_CHARACTER,
+            messageId: MATCH_EXTENSION,
+            data: {
+              fileExtension,
+              expectedFileExtension: options.fileExtension
+            }
+          });
+        }
+        const firstOperation = documentNode.definitions.find(
           (n) => n.kind === Kind7.OPERATION_DEFINITION
-        ), firstFragment = documentNode.definitions.find(
+        );
+        const firstFragment = documentNode.definitions.find(
           (n) => n.kind === Kind7.FRAGMENT_DEFINITION
-        ), node = firstOperation || firstFragment;
-        if (!node)
+        );
+        const node = firstOperation || firstFragment;
+        if (!node) {
           return;
-        let docName = node.name?.value;
-        if (!docName)
+        }
+        const docName = node.name?.value;
+        if (!docName) {
           return;
-        let docType = "operation" in node ? node.operation : "fragment", option = options[docType];
-        if (!option)
+        }
+        const docType = "operation" in node ? node.operation : "fragment";
+        let option = options[docType];
+        if (!option) {
           return;
-        typeof option == "string" && (option = { style: option });
-        let expectedExtension = options.fileExtension || fileExtension, expectedFilename = option.prefix || "";
-        option.style ? expectedFilename += option.style === "matchDocumentStyle" ? docName : convertCase(option.style, docName) : expectedFilename += filename, expectedFilename += (option.suffix || "") + expectedExtension;
-        let filenameWithExtension = filename + expectedExtension;
-        expectedFilename !== filenameWithExtension && context.report({
-          loc: REPORT_ON_FIRST_CHARACTER,
-          messageId: MATCH_STYLE,
-          data: {
-            expectedFilename,
-            filename: filenameWithExtension
-          }
-        });
+        }
+        if (typeof option === "string") {
+          option = { style: option };
+        }
+        const expectedExtension = options.fileExtension || fileExtension;
+        let expectedFilename = option.prefix || "";
+        if (option.style) {
+          expectedFilename += option.style === "matchDocumentStyle" ? docName : convertCase(option.style, docName);
+        } else {
+          expectedFilename += filename;
+        }
+        expectedFilename += (option.suffix || "") + expectedExtension;
+        const filenameWithExtension = filename + expectedExtension;
+        if (expectedFilename !== filenameWithExtension) {
+          context.report({
+            loc: REPORT_ON_FIRST_CHARACTER,
+            messageId: MATCH_STYLE,
+            data: {
+              expectedFilename,
+              filename: filenameWithExtension
+            }
+          });
+        }
       }
     };
   }
@@ -1912,16 +2383,22 @@ var KindToDisplayName = {
   [Kind8.OPERATION_DEFINITION]: "Operation",
   [Kind8.FRAGMENT_DEFINITION]: "Fragment",
   [Kind8.VARIABLE_DEFINITION]: "Variable"
-}, StyleToRegex = {
+};
+var StyleToRegex = {
   camelCase: /^[a-z][\dA-Za-z]*$/,
   PascalCase: /^[A-Z][\dA-Za-z]*$/,
   snake_case: /^[a-z][\d_a-z]*[\da-z]*$/,
   UPPER_CASE: /^[A-Z][\dA-Z_]*[\dA-Z]*$/
-}, ALLOWED_KINDS = Object.keys(KindToDisplayName).sort(), ALLOWED_STYLES = Object.keys(StyleToRegex), schemaOption2 = {
+};
+var ALLOWED_KINDS = Object.keys(KindToDisplayName).sort();
+var ALLOWED_STYLES = Object.keys(StyleToRegex);
+var schemaOption2 = {
   oneOf: [{ $ref: "#/definitions/asString" }, { $ref: "#/definitions/asObject" }]
-}, descriptionPrefixesSuffixes = (name) => `> [!WARNING]
+};
+var descriptionPrefixesSuffixes = (name) => `> [!WARNING]
 >
-> This option is deprecated and will be removed in the next major release. Use [\`${name}\`](#${name.toLowerCase()}-array) instead.`, schema6 = {
+> This option is deprecated and will be removed in the next major release. Use [\`${name}\`](#${name.toLowerCase()}-array) instead.`;
+var schema6 = {
   definitions: {
     asString: {
       enum: ALLOWED_STYLES,
@@ -1929,7 +2406,7 @@ var KindToDisplayName = {
     },
     asObject: {
       type: "object",
-      additionalProperties: !1,
+      additionalProperties: false,
       properties: {
         style: { enum: ALLOWED_STYLES },
         prefix: { type: "string" },
@@ -1975,13 +2452,12 @@ var KindToDisplayName = {
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     properties: {
       types: {
         ...schemaOption2,
         description: `Includes:
-${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
-`)}`
+${TYPES_KINDS.map((kind) => `- \`${kind}\``).join("\n")}`
       },
       ...Object.fromEntries(
         ALLOWED_KINDS.map((kind) => [
@@ -1996,11 +2472,11 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
       ),
       allowLeadingUnderscore: {
         type: "boolean",
-        default: !1
+        default: false
       },
       allowTrailingUnderscore: {
         type: "boolean",
-        default: !1
+        default: false
       }
     },
     patternProperties: {
@@ -2012,16 +2488,16 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
       "> Paste or drop code into the editor in [ASTExplorer](https://astexplorer.net) and inspect the generated AST to compose your selector.",
       ">",
       "> Example: pattern property `FieldDefinition[parent.name.value=Query]` will match only fields for type `Query`."
-    ].join(`
-`)
+    ].join("\n")
   }
-}, rule6 = {
+};
+var rule6 = {
   meta: {
     type: "suggestion",
     docs: {
       description: "Require names to follow specified conventions.",
       category: ["Schema", "Operations"],
-      recommended: !0,
+      recommended: true,
       url: "https://the-guild.dev/graphql/eslint/rules/naming-convention",
       examples: [
         {
@@ -2213,14 +2689,16 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         ]
       }
     },
-    hasSuggestions: !0,
+    hasSuggestions: true,
     schema: schema6
   },
   create(context) {
-    let options = context.options[0] || {}, { allowLeadingUnderscore, allowTrailingUnderscore, types, ...restOptions } = options, ignoredNodes = /* @__PURE__ */ new Set();
+    const options = context.options[0] || {};
+    const { allowLeadingUnderscore, allowTrailingUnderscore, types, ...restOptions } = options;
+    const ignoredNodes = /* @__PURE__ */ new Set();
     function normalisePropertyOption(kind) {
-      let style = restOptions[kind] || types;
-      return typeof style == "object" ? style : { style };
+      const style = restOptions[kind] || types;
+      return typeof style === "object" ? style : { style };
     }
     function report(node, message, suggestedNames) {
       context.report({
@@ -2232,11 +2710,12 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         }))
       });
     }
-    let checkNode2 = (selector) => (n) => {
-      let { name: node } = n.kind === Kind8.VARIABLE_DEFINITION ? n.variable : n;
-      if (!node)
+    const checkNode2 = (selector) => (n) => {
+      const { name: node } = n.kind === Kind8.VARIABLE_DEFINITION ? n.variable : n;
+      if (!node) {
         return;
-      let {
+      }
+      const {
         prefix,
         suffix,
         forbiddenPrefixes,
@@ -2247,11 +2726,17 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         requiredSuffixes,
         forbiddenPatterns,
         requiredPatterns
-      } = normalisePropertyOption(selector), nodeName = node.value, error = getError();
+      } = normalisePropertyOption(selector);
+      const nodeName = node.value;
+      const error = getError();
       if (error) {
-        let { errorMessage, renameToNames } = error, [leadingUnderscores] = nodeName.match(/^_*/), [trailingUnderscores] = nodeName.match(/_*$/), suggestedNames = renameToNames.map(
+        const { errorMessage, renameToNames } = error;
+        const [leadingUnderscores] = nodeName.match(/^_*/);
+        const [trailingUnderscores] = nodeName.match(/_*$/);
+        const suggestedNames = renameToNames.map(
           (renameToName) => leadingUnderscores + renameToName + trailingUnderscores
-        ), name = displayNodeName(n);
+        );
+        const name = displayNodeName(n);
         report(
           node,
           `${name[0].toUpperCase()}${name.slice(1)} should ${errorMessage}`,
@@ -2259,94 +2744,120 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         );
       }
       function getError() {
-        let name = nodeName.replace(/(^_+)|(_+$)/g, "");
+        const name = nodeName.replace(/(^_+)|(_+$)/g, "");
         if (ignorePattern && new RegExp(ignorePattern, "u").test(name)) {
-          "name" in n && ignoredNodes.add(n.name);
+          if ("name" in n) {
+            ignoredNodes.add(n.name);
+          }
           return;
         }
-        if (prefix && !name.startsWith(prefix))
+        if (prefix && !name.startsWith(prefix)) {
           return {
             errorMessage: `have "${prefix}" prefix`,
             renameToNames: [prefix + name]
           };
-        if (suffix && !name.endsWith(suffix))
+        }
+        if (suffix && !name.endsWith(suffix)) {
           return {
             errorMessage: `have "${suffix}" suffix`,
             renameToNames: [name + suffix]
           };
-        let forbidden = forbiddenPatterns?.find((pattern) => pattern.test(name));
-        if (forbidden)
+        }
+        const forbidden = forbiddenPatterns?.find((pattern) => pattern.test(name));
+        if (forbidden) {
           return {
             errorMessage: `not contain the forbidden pattern "${forbidden}"`,
             renameToNames: [name.replace(forbidden, "")]
           };
-        if (requiredPatterns && !requiredPatterns.some((pattern) => pattern.test(name)))
+        }
+        if (requiredPatterns && !requiredPatterns.some((pattern) => pattern.test(name))) {
           return {
             errorMessage: `contain the required pattern: ${englishJoinWords(requiredPatterns.map((re) => re.source))}`,
             renameToNames: []
           };
-        let forbiddenPrefix = forbiddenPrefixes?.find((prefix2) => name.startsWith(prefix2));
-        if (forbiddenPrefix)
+        }
+        const forbiddenPrefix = forbiddenPrefixes?.find((prefix2) => name.startsWith(prefix2));
+        if (forbiddenPrefix) {
           return {
             errorMessage: `not have "${forbiddenPrefix}" prefix`,
             renameToNames: [name.replace(new RegExp(`^${forbiddenPrefix}`), "")]
           };
-        let forbiddenSuffix = forbiddenSuffixes?.find((suffix2) => name.endsWith(suffix2));
-        if (forbiddenSuffix)
+        }
+        const forbiddenSuffix = forbiddenSuffixes?.find((suffix2) => name.endsWith(suffix2));
+        if (forbiddenSuffix) {
           return {
             errorMessage: `not have "${forbiddenSuffix}" suffix`,
             renameToNames: [name.replace(new RegExp(`${forbiddenSuffix}$`), "")]
           };
-        if (requiredPrefixes && !requiredPrefixes.some((requiredPrefix) => name.startsWith(requiredPrefix)))
+        }
+        if (requiredPrefixes && !requiredPrefixes.some((requiredPrefix) => name.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}`)
           };
-        if (requiredSuffixes && !requiredSuffixes.some((requiredSuffix) => name.endsWith(requiredSuffix)))
+        }
+        if (requiredSuffixes && !requiredSuffixes.some((requiredSuffix) => name.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}`)
           };
-        if (!style)
+        }
+        if (!style) {
           return;
-        if (!StyleToRegex[style].test(name))
+        }
+        const caseRegex = StyleToRegex[style];
+        if (!caseRegex.test(name)) {
           return {
             errorMessage: `be in ${style} format`,
             renameToNames: [convertCase(style, name)]
           };
+        }
+      }
+    };
+    const checkUnderscore = (isLeading) => (node) => {
+      if (ignoredNodes.has(node)) {
+        return;
       }
-    }, checkUnderscore = (isLeading) => (node) => {
-      if (ignoredNodes.has(node) || node.parent.kind === "Field" && node.parent.alias !== node)
+      if (node.parent.kind === "Field" && node.parent.alias !== node) {
         return;
-      let suggestedName = node.value.replace(isLeading ? /^_+/ : /_+$/, "");
+      }
+      const suggestedName = node.value.replace(isLeading ? /^_+/ : /_+$/, "");
       report(node, `${isLeading ? "Leading" : "Trailing"} underscores are not allowed`, [
         suggestedName
       ]);
-    }, listeners = {};
-    allowLeadingUnderscore || (listeners["Name[value=/^_/]"] = checkUnderscore(!0)), allowTrailingUnderscore || (listeners["Name[value=/_$/]"] = checkUnderscore(!1));
-    let selectors = new Set(
+    };
+    const listeners = {};
+    if (!allowLeadingUnderscore) {
+      listeners["Name[value=/^_/]"] = checkUnderscore(true);
+    }
+    if (!allowTrailingUnderscore) {
+      listeners["Name[value=/_$/]"] = checkUnderscore(false);
+    }
+    const selectors = new Set(
       [types && TYPES_KINDS, Object.keys(restOptions)].filter((v) => !!v).flat()
     );
-    for (let selector of selectors)
+    for (const selector of selectors) {
       listeners[selector] = checkNode2(selector);
+    }
     return listeners;
   }
 };
 
 // src/rules/no-anonymous-operations/index.ts
 import { Kind as Kind9 } from "graphql";
-var RULE_ID3 = "no-anonymous-operations", rule7 = {
+var RULE_ID3 = "no-anonymous-operations";
+var rule7 = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       category: "Operations",
       description: "Require name for your GraphQL operations. This is useful since most GraphQL client libraries are using the operation name for caching purposes.",
-      recommended: !0,
+      recommended: true,
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID3}`,
       examples: [
         {
@@ -2381,7 +2892,8 @@ var RULE_ID3 = "no-anonymous-operations", rule7 = {
   create(context) {
     return {
       "OperationDefinition[name=undefined]"(node) {
-        let [firstSelection] = node.selectionSet.selections, suggestedName = firstSelection.kind === Kind9.FIELD ? (firstSelection.alias || firstSelection.name).value : node.operation;
+        const [firstSelection] = node.selectionSet.selections;
+        const suggestedName = firstSelection.kind === Kind9.FIELD ? (firstSelection.alias || firstSelection.name).value : node.operation;
         context.report({
           loc: getLocation(node.loc.start, node.operation),
           messageId: RULE_ID3,
@@ -2392,7 +2904,8 @@ var RULE_ID3 = "no-anonymous-operations", rule7 = {
             {
               desc: `Rename to \`${suggestedName}\``,
               fix(fixer) {
-                let hasQueryKeyword = context.getSourceCode().getText({ range: [node.range[0], node.range[0] + 1] }) !== "{";
+                const sourceCode = context.getSourceCode();
+                const hasQueryKeyword = sourceCode.getText({ range: [node.range[0], node.range[0] + 1] }) !== "{";
                 return fixer.insertTextAfterRange(
                   [node.range[0], node.range[0] + (hasQueryKeyword ? node.operation.length : 0)],
                   `${hasQueryKeyword ? "" : "query"} ${suggestedName}${hasQueryKeyword ? "" : " "}`
@@ -2407,15 +2920,16 @@ var RULE_ID3 = "no-anonymous-operations", rule7 = {
 };
 
 // src/rules/no-deprecated/index.ts
-var RULE_ID4 = "no-deprecated", rule8 = {
+var RULE_ID4 = "no-deprecated";
+var rule8 = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       category: "Operations",
       description: "Enforce that deprecated fields or enum values are not in use by operations.",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID4}`,
-      requiresSchema: !0,
+      requiresSchema: true,
       examples: [
         {
           title: "Incorrect (field)",
@@ -2487,7 +3001,7 @@ var RULE_ID4 = "no-deprecated", rule8 = {
           )
         }
       ],
-      recommended: !0
+      recommended: true
     },
     messages: {
       [RULE_ID4]: "{{ type }} is marked as deprecated in your GraphQL schema (reason: {{ reason }})"
@@ -2497,7 +3011,7 @@ var RULE_ID4 = "no-deprecated", rule8 = {
   create(context) {
     requireGraphQLSchema(RULE_ID4, context);
     function report(node, reason) {
-      let nodeType = displayNodeName(node);
+      const nodeType = displayNodeName(node);
       context.report({
         node,
         messageId: RULE_ID4,
@@ -2515,24 +3029,37 @@ var RULE_ID4 = "no-deprecated", rule8 = {
     }
     return {
       EnumValue(node) {
-        let reason = node.typeInfo().enumValue?.deprecationReason;
-        reason && report(node, reason);
+        const typeInfo = node.typeInfo();
+        const reason = typeInfo.enumValue?.deprecationReason;
+        if (reason) {
+          report(node, reason);
+        }
       },
       Field(node) {
-        let reason = node.typeInfo().fieldDef?.deprecationReason;
-        reason && report(node, reason);
+        const typeInfo = node.typeInfo();
+        const reason = typeInfo.fieldDef?.deprecationReason;
+        if (reason) {
+          report(node, reason);
+        }
       },
       Argument(node) {
-        let reason = node.typeInfo().argument?.deprecationReason;
-        reason && report(node, reason);
+        const typeInfo = node.typeInfo();
+        const reason = typeInfo.argument?.deprecationReason;
+        if (reason) {
+          report(node, reason);
+        }
       },
       ObjectValue(node) {
-        let { inputType } = node.typeInfo();
-        if (inputType && "getFields" in inputType) {
-          let fields = inputType.getFields();
-          for (let field of node.fields) {
-            let fieldName = field.name.value, reason = fields[fieldName].deprecationReason;
-            reason && report(field, reason);
+        const { inputType } = node.typeInfo();
+        if (!inputType) return;
+        if ("getFields" in inputType) {
+          const fields = inputType.getFields();
+          for (const field of node.fields) {
+            const fieldName = field.name.value;
+            const reason = fields[fieldName].deprecationReason;
+            if (reason) {
+              report(field, reason);
+            }
           }
         }
       }
@@ -2542,15 +3069,16 @@ var RULE_ID4 = "no-deprecated", rule8 = {
 
 // src/rules/no-duplicate-fields/index.ts
 import { Kind as Kind10 } from "graphql";
-var RULE_ID5 = "no-duplicate-fields", rule9 = {
+var RULE_ID5 = "no-duplicate-fields";
+var rule9 = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       description: "Checks for duplicate fields in selection set, variables in operation definition, or in arguments set of a field.",
       category: "Operations",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID5}`,
-      recommended: !0,
+      recommended: true,
       examples: [
         {
           title: "Incorrect",
@@ -2610,9 +3138,9 @@ var RULE_ID5 = "no-duplicate-fields", rule9 = {
   },
   create(context) {
     function checkNode2(usedFields, node) {
-      let fieldName = node.value;
+      const fieldName = node.value;
       if (usedFields.has(fieldName)) {
-        let { parent } = node;
+        const { parent } = node;
         context.report({
           node,
           messageId: RULE_ID5,
@@ -2631,24 +3159,30 @@ var RULE_ID5 = "no-duplicate-fields", rule9 = {
             }
           ]
         });
-      } else
+      } else {
         usedFields.add(fieldName);
+      }
     }
     return {
       OperationDefinition(node) {
-        let set = /* @__PURE__ */ new Set();
-        for (let varDef of node.variableDefinitions || [])
+        const set = /* @__PURE__ */ new Set();
+        for (const varDef of node.variableDefinitions || []) {
           checkNode2(set, varDef.variable.name);
+        }
       },
       Field(node) {
-        let set = /* @__PURE__ */ new Set();
-        for (let arg of node.arguments || [])
+        const set = /* @__PURE__ */ new Set();
+        for (const arg of node.arguments || []) {
           checkNode2(set, arg.name);
+        }
       },
       SelectionSet(node) {
-        let set = /* @__PURE__ */ new Set();
-        for (let selection of node.selections)
-          selection.kind === Kind10.FIELD && checkNode2(set, selection.alias || selection.name);
+        const set = /* @__PURE__ */ new Set();
+        for (const selection of node.selections) {
+          if (selection.kind === Kind10.FIELD) {
+            checkNode2(set, selection.alias || selection.name);
+          }
+        }
       }
     };
   }
@@ -2656,10 +3190,11 @@ var RULE_ID5 = "no-duplicate-fields", rule9 = {
 
 // src/rules/no-hashtag-description/index.ts
 import { TokenKind as TokenKind2 } from "graphql";
-var RULE_ID6 = "HASHTAG_COMMENT", rule10 = {
+var RULE_ID6 = "HASHTAG_COMMENT";
+var rule10 = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     schema: [],
     messages: {
       [RULE_ID6]: 'Unexpected GraphQL descriptions as hashtag `#` for {{ nodeName }}.\nPrefer using `"""` for multiline, or `"` for a single line description.'
@@ -2712,21 +3247,27 @@ var RULE_ID6 = "HASHTAG_COMMENT", rule10 = {
           )
         }
       ],
-      recommended: !0
+      recommended: true
     }
   },
   create(context) {
+    const selector = "Document[definitions.0.kind!=/^(OperationDefinition|FragmentDefinition)$/]";
     return {
-      ["Document[definitions.0.kind!=/^(OperationDefinition|FragmentDefinition)$/]"](node) {
-        let token = node.rawNode().loc.startToken;
-        for (; token; ) {
-          let { kind, prev, next, value, line, column } = token;
+      [selector](node) {
+        const rawNode = node.rawNode();
+        let token = rawNode.loc.startToken;
+        while (token) {
+          const { kind, prev, next, value, line, column } = token;
           if (kind === TokenKind2.COMMENT && prev && next) {
-            let isEslintComment = value.trimStart().startsWith("eslint"), linesAfter = next.line - line;
+            const isEslintComment = value.trimStart().startsWith("eslint");
+            const linesAfter = next.line - line;
             if (!isEslintComment && line !== prev.line && next.kind === TokenKind2.NAME && linesAfter < 2) {
-              let sourceCode = context.getSourceCode(), { tokens } = sourceCode.ast, t = tokens.find(
+              const sourceCode = context.getSourceCode();
+              const { tokens } = sourceCode.ast;
+              const t = tokens.find(
                 (token2) => token2.loc.start.line === next.line && token2.loc.start.column === next.column - 1
-              ), nextNode = sourceCode.getNodeByRangeIndex(t.range[1] + 1);
+              );
+              const nextNode = sourceCode.getNodeByRangeIndex(t.range[1] + 1);
               context.report({
                 messageId: RULE_ID6,
                 data: {
@@ -2748,8 +3289,9 @@ var RULE_ID6 = "HASHTAG_COMMENT", rule10 = {
               });
             }
           }
-          if (!next)
+          if (!next) {
             break;
+          }
           token = next;
         }
       }
@@ -2760,7 +3302,8 @@ var RULE_ID6 = "HASHTAG_COMMENT", rule10 = {
 // src/rules/no-one-place-fragments/index.ts
 import { relative } from "node:path";
 import { visit as visit4 } from "graphql";
-var RULE_ID7 = "no-one-place-fragments", rule11 = {
+var RULE_ID7 = "no-one-place-fragments";
+var rule11 = {
   meta: {
     type: "suggestion",
     docs: {
@@ -2806,7 +3349,7 @@ var RULE_ID7 = "no-one-place-fragments", rule11 = {
           )
         }
       ],
-      requiresSiblings: !0
+      requiresSiblings: true
     },
     messages: {
       [RULE_ID7]: 'Fragment `{{fragmentName}}` used only once. Inline him in "{{filePath}}".'
@@ -2814,24 +3357,30 @@ var RULE_ID7 = "no-one-place-fragments", rule11 = {
     schema: []
   },
   create(context) {
-    let operations = requireGraphQLOperations(RULE_ID7, context), allDocuments = [...operations.getOperations(), ...operations.getFragments()], usedFragmentsMap = /* @__PURE__ */ Object.create(null);
-    for (let { document, filePath } of allDocuments) {
-      let relativeFilePath = relative(CWD, filePath);
+    const operations = requireGraphQLOperations(RULE_ID7, context);
+    const allDocuments = [...operations.getOperations(), ...operations.getFragments()];
+    const usedFragmentsMap = /* @__PURE__ */ Object.create(null);
+    for (const { document, filePath } of allDocuments) {
+      const relativeFilePath = relative(CWD, filePath);
       visit4(document, {
         FragmentSpread({ name }) {
-          let spreadName = name.value;
-          usedFragmentsMap[spreadName] ||= [], usedFragmentsMap[spreadName].push(relativeFilePath);
+          const spreadName = name.value;
+          usedFragmentsMap[spreadName] ||= [];
+          usedFragmentsMap[spreadName].push(relativeFilePath);
         }
       });
     }
     return {
       "FragmentDefinition > Name"(node) {
-        let fragmentName = node.value, fragmentUsage = usedFragmentsMap[fragmentName];
-        fragmentUsage.length === 1 && context.report({
-          node,
-          messageId: RULE_ID7,
-          data: { fragmentName, filePath: fragmentUsage[0] }
-        });
+        const fragmentName = node.value;
+        const fragmentUsage = usedFragmentsMap[fragmentName];
+        if (fragmentUsage.length === 1) {
+          context.report({
+            node,
+            messageId: RULE_ID7,
+            data: { fragmentName, filePath: fragmentUsage[0] }
+          });
+        }
       }
     };
   }
@@ -2844,7 +3393,7 @@ var schema7 = {
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     required: ["disallow"],
     properties: {
       disallow: {
@@ -2855,15 +3404,16 @@ var schema7 = {
       }
     }
   }
-}, rule12 = {
+};
+var rule12 = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       category: "Schema",
       description: "Disallow using root types `mutation` and/or `subscription`.",
       url: "https://the-guild.dev/graphql/eslint/rules/no-root-type",
-      requiresSchema: !0,
+      requiresSchema: true,
       examples: [
         {
           title: "Incorrect",
@@ -2895,13 +3445,19 @@ var schema7 = {
     schema: schema7
   },
   create(context) {
-    let schema16 = requireGraphQLSchema("no-root-type", context), disallow = new Set(context.options[0].disallow), rootTypeNames = [
+    const schema16 = requireGraphQLSchema("no-root-type", context);
+    const disallow = new Set(context.options[0].disallow);
+    const rootTypeNames = [
       disallow.has("mutation") && schema16.getMutationType(),
       disallow.has("subscription") && schema16.getSubscriptionType()
     ].filter((v) => !!v).map((type) => type.name).join("|");
-    return rootTypeNames ? {
-      [`:matches(ObjectTypeDefinition, ObjectTypeExtension) > .name[value=/^(${rootTypeNames})$/]`](node) {
-        let typeName = node.value;
+    if (!rootTypeNames) {
+      return {};
+    }
+    const selector = `:matches(ObjectTypeDefinition, ObjectTypeExtension) > .name[value=/^(${rootTypeNames})$/]`;
+    return {
+      [selector](node) {
+        const typeName = node.value;
         context.report({
           node,
           message: `Root type \`${typeName}\` is forbidden.`,
@@ -2913,21 +3469,22 @@ var schema7 = {
           ]
         });
       }
-    } : {};
+    };
   }
 };
 
 // src/rules/no-scalar-result-type-on-mutation/index.ts
 import { isScalarType, Kind as Kind11 } from "graphql";
-var RULE_ID8 = "no-scalar-result-type-on-mutation", rule13 = {
+var RULE_ID8 = "no-scalar-result-type-on-mutation";
+var rule13 = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       category: "Schema",
       description: "Avoid scalar result type on mutation type to make sure to return a valid state.",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID8}`,
-      requiresSchema: !0,
+      requiresSchema: true,
       examples: [
         {
           title: "Incorrect",
@@ -2956,17 +3513,24 @@ var RULE_ID8 = "no-scalar-result-type-on-mutation", rule13 = {
     schema: []
   },
   create(context) {
-    let schema16 = requireGraphQLSchema(RULE_ID8, context), mutationType = schema16.getMutationType();
-    return mutationType ? {
-      [[
-        `:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=${mutationType.name}]`,
-        "> FieldDefinition > .gqlType Name"
-      ].join(" ")](node) {
-        let typeName = node.value, graphQLType = schema16.getType(typeName);
+    const schema16 = requireGraphQLSchema(RULE_ID8, context);
+    const mutationType = schema16.getMutationType();
+    if (!mutationType) {
+      return {};
+    }
+    const selector = [
+      `:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=${mutationType.name}]`,
+      "> FieldDefinition > .gqlType Name"
+    ].join(" ");
+    return {
+      [selector](node) {
+        const typeName = node.value;
+        const graphQLType = schema16.getType(typeName);
         if (isScalarType(graphQLType)) {
           let fieldDef = node.parent;
-          for (; fieldDef.kind !== Kind11.FIELD_DEFINITION; )
+          while (fieldDef.kind !== Kind11.FIELD_DEFINITION) {
             fieldDef = fieldDef.parent;
+          }
           context.report({
             node,
             message: `Unexpected scalar result type \`${typeName}\` for ${getNodeName(fieldDef)}`,
@@ -2979,19 +3543,20 @@ var RULE_ID8 = "no-scalar-result-type-on-mutation", rule13 = {
           });
         }
       }
-    } : {};
+    };
   }
 };
 
 // src/rules/no-typename-prefix/index.ts
-var NO_TYPENAME_PREFIX = "NO_TYPENAME_PREFIX", rule14 = {
+var NO_TYPENAME_PREFIX = "NO_TYPENAME_PREFIX";
+var rule14 = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       category: "Schema",
       description: "Enforces users to avoid using the type name in a field name while defining your schema.",
-      recommended: !0,
+      recommended: true,
       url: "https://the-guild.dev/graphql/eslint/rules/no-typename-prefix",
       examples: [
         {
@@ -3026,26 +3591,29 @@ var NO_TYPENAME_PREFIX = "NO_TYPENAME_PREFIX", rule14 = {
   create(context) {
     return {
       "ObjectTypeDefinition, ObjectTypeExtension, InterfaceTypeDefinition, InterfaceTypeExtension"(node) {
-        let typeName = node.name.value, lowerTypeName = typeName.toLowerCase();
-        for (let field of node.fields || []) {
-          let fieldName = field.name.value;
-          fieldName.toLowerCase().startsWith(lowerTypeName) && context.report({
-            data: {
-              fieldName,
-              typeName
-            },
-            messageId: NO_TYPENAME_PREFIX,
-            node: field.name,
-            suggest: [
-              {
-                desc: `Remove \`${fieldName.slice(0, typeName.length)}\` prefix`,
-                fix: (fixer) => fixer.replaceText(
-                  field.name,
-                  fieldName.replace(new RegExp(`^${typeName}`, "i"), "")
-                )
-              }
-            ]
-          });
+        const typeName = node.name.value;
+        const lowerTypeName = typeName.toLowerCase();
+        for (const field of node.fields || []) {
+          const fieldName = field.name.value;
+          if (fieldName.toLowerCase().startsWith(lowerTypeName)) {
+            context.report({
+              data: {
+                fieldName,
+                typeName
+              },
+              messageId: NO_TYPENAME_PREFIX,
+              node: field.name,
+              suggest: [
+                {
+                  desc: `Remove \`${fieldName.slice(0, typeName.length)}\` prefix`,
+                  fix: (fixer) => fixer.replaceText(
+                    field.name,
+                    fieldName.replace(new RegExp(`^${typeName}`, "i"), "")
+                  )
+                }
+              ]
+            });
+          }
         }
       }
     };
@@ -3061,7 +3629,8 @@ import {
   visit as visit5
 } from "graphql";
 import lowerCase3 from "lodash.lowercase";
-var RULE_ID9 = "no-unreachable-types", KINDS = [
+var RULE_ID9 = "no-unreachable-types";
+var KINDS = [
   Kind12.DIRECTIVE_DEFINITION,
   Kind12.OBJECT_TYPE_DEFINITION,
   Kind12.OBJECT_TYPE_EXTENSION,
@@ -3075,7 +3644,9 @@ var RULE_ID9 = "no-unreachable-types", KINDS = [
   Kind12.UNION_TYPE_EXTENSION,
   Kind12.ENUM_TYPE_DEFINITION,
   Kind12.ENUM_TYPE_EXTENSION
-], reachableTypesCache = new ModuleCache(), RequestDirectiveLocations = /* @__PURE__ */ new Set([
+];
+var reachableTypesCache = new ModuleCache();
+var RequestDirectiveLocations = /* @__PURE__ */ new Set([
   DirectiveLocation.QUERY,
   DirectiveLocation.MUTATION,
   DirectiveLocation.SUBSCRIPTION,
@@ -3086,21 +3657,28 @@ var RULE_ID9 = "no-unreachable-types", KINDS = [
   DirectiveLocation.VARIABLE_DEFINITION
 ]);
 function getReachableTypes(schema16) {
-  let cachedValue = reachableTypesCache.get(schema16);
-  if (cachedValue)
+  const cachedValue = reachableTypesCache.get(schema16);
+  if (cachedValue) {
     return cachedValue;
-  let reachableTypes = /* @__PURE__ */ new Set(), collect = (node) => {
-    let typeName = getTypeName(node);
-    if (reachableTypes.has(typeName))
+  }
+  const reachableTypes = /* @__PURE__ */ new Set();
+  const collect = (node) => {
+    const typeName = getTypeName(node);
+    if (reachableTypes.has(typeName)) {
       return;
+    }
     reachableTypes.add(typeName);
-    let type = schema16.getType(typeName) || schema16.getDirective(typeName);
+    const type = schema16.getType(typeName) || schema16.getDirective(typeName);
     if (isInterfaceType(type)) {
-      let { objects, interfaces } = schema16.getImplementations(type);
-      for (let { astNode } of [...objects, ...interfaces])
+      const { objects, interfaces } = schema16.getImplementations(type);
+      for (const { astNode } of [...objects, ...interfaces]) {
         visit5(astNode, visitor);
-    } else type?.astNode && visit5(type.astNode, visitor);
-  }, visitor = {
+      }
+    } else if (type?.astNode) {
+      visit5(type.astNode, visitor);
+    }
+  };
+  const visitor = {
     InterfaceTypeDefinition: collect,
     ObjectTypeDefinition: collect,
     InputValueDefinition: collect,
@@ -3109,21 +3687,27 @@ function getReachableTypes(schema16) {
     Directive: collect,
     NamedType: collect
   };
-  for (let type of [
+  for (const type of [
     schema16,
     // visiting SchemaDefinition node
     schema16.getQueryType(),
     schema16.getMutationType(),
     schema16.getSubscriptionType()
-  ])
-    type?.astNode && visit5(type.astNode, visitor);
-  for (let node of schema16.getDirectives())
+  ]) {
+    if (type?.astNode) {
+      visit5(type.astNode, visitor);
+    }
+  }
+  for (const node of schema16.getDirectives()) {
     if (node.locations.some((location) => RequestDirectiveLocations.has(location))) {
       reachableTypes.add(node.name);
-      for (let arg of node.args)
+      for (const arg of node.args) {
         reachableTypes.add(getNamedType(arg.type).name);
+      }
     }
-  return reachableTypesCache.set(schema16, reachableTypes), reachableTypes;
+  }
+  reachableTypesCache.set(schema16, reachableTypes);
+  return reachableTypes;
 }
 var rule15 = {
   meta: {
@@ -3134,7 +3718,7 @@ var rule15 = {
       description: "Requires all types to be reachable at some level by root level fields.",
       category: "Schema",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID9}`,
-      requiresSchema: !0,
+      requiresSchema: true,
       examples: [
         {
           title: "Incorrect",
@@ -3169,19 +3753,20 @@ var rule15 = {
           )
         }
       ],
-      recommended: !0
+      recommended: true
     },
     type: "suggestion",
     schema: [],
-    hasSuggestions: !0
+    hasSuggestions: true
   },
   create(context) {
-    let schema16 = requireGraphQLSchema(RULE_ID9, context), reachableTypes = getReachableTypes(schema16);
+    const schema16 = requireGraphQLSchema(RULE_ID9, context);
+    const reachableTypes = getReachableTypes(schema16);
     return {
       [`:matches(${KINDS}) > .name`](node) {
-        let typeName = node.value;
+        const typeName = node.value;
         if (!reachableTypes.has(typeName)) {
-          let type = lowerCase3(node.parent.kind.replace(/(Extension|Definition)$/, ""));
+          const type = lowerCase3(node.parent.kind.replace(/(Extension|Definition)$/, ""));
           context.report({
             node,
             messageId: RULE_ID9,
@@ -3204,7 +3789,8 @@ var rule15 = {
 
 // src/rules/no-unused-fields/index.ts
 import { TypeInfo as TypeInfo2, visit as visit6, visitWithTypeInfo as visitWithTypeInfo2 } from "graphql";
-var RULE_ID10 = "no-unused-fields", RELAY_SCHEMA = (
+var RULE_ID10 = "no-unused-fields";
+var RELAY_SCHEMA = (
   /* GraphQL */
   `
   # Root Query Type
@@ -3245,7 +3831,8 @@ var RULE_ID10 = "no-unused-fields", RELAY_SCHEMA = (
     endCursor: String
   }
 `
-), RELAY_QUERY = (
+);
+var RELAY_QUERY = (
   /* GraphQL */
   `
   query {
@@ -3263,20 +3850,22 @@ var RULE_ID10 = "no-unused-fields", RELAY_SCHEMA = (
     }
   }
 `
-), RELAY_DEFAULT_IGNORED_FIELD_SELECTORS = [
+);
+var RELAY_DEFAULT_IGNORED_FIELD_SELECTORS = [
   "[parent.name.value=PageInfo][name.value=/(endCursor|startCursor|hasNextPage|hasPreviousPage)/]",
   "[parent.name.value=/Edge$/][name.value=cursor]",
   "[parent.name.value=/Connection$/][name.value=pageInfo]"
-], schema8 = {
+];
+var schema8 = {
   type: "array",
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     properties: {
       ignoredFieldSelectors: {
         type: "array",
-        uniqueItems: !0,
+        uniqueItems: true,
         minItems: 1,
         description: [
           "Fields that will be ignored and are allowed to be unused.",
@@ -3286,8 +3875,7 @@ var RULE_ID10 = "no-unused-fields", RELAY_SCHEMA = (
           JSON.stringify(RELAY_DEFAULT_IGNORED_FIELD_SELECTORS, null, 2),
           "```",
           eslintSelectorsTip
-        ].join(`
-`),
+        ].join("\n"),
         items: {
           type: "string",
           pattern: "^\\[(.+)]$"
@@ -3295,22 +3883,33 @@ var RULE_ID10 = "no-unused-fields", RELAY_SCHEMA = (
       }
     }
   }
-}, usedFieldsCache = new ModuleCache();
+};
+var usedFieldsCache = new ModuleCache();
 function getUsedFields(schema16, operations) {
-  let cachedValue = usedFieldsCache.get(schema16);
-  if (cachedValue)
+  const cachedValue = usedFieldsCache.get(schema16);
+  if (cachedValue) {
     return cachedValue;
-  let usedFields = /* @__PURE__ */ Object.create(null), typeInfo = new TypeInfo2(schema16), visitor = visitWithTypeInfo2(typeInfo, {
+  }
+  const usedFields = /* @__PURE__ */ Object.create(null);
+  const typeInfo = new TypeInfo2(schema16);
+  const visitor = visitWithTypeInfo2(typeInfo, {
     Field(node) {
-      if (!typeInfo.getFieldDef())
-        return !1;
-      let parentTypeName = typeInfo.getParentType().name, fieldName = node.name.value;
-      usedFields[parentTypeName] ??= /* @__PURE__ */ new Set(), usedFields[parentTypeName].add(fieldName);
+      const fieldDef = typeInfo.getFieldDef();
+      if (!fieldDef) {
+        return false;
+      }
+      const parentTypeName = typeInfo.getParentType().name;
+      const fieldName = node.name.value;
+      usedFields[parentTypeName] ??= /* @__PURE__ */ new Set();
+      usedFields[parentTypeName].add(fieldName);
     }
-  }), allDocuments = [...operations.getOperations(), ...operations.getFragments()];
-  for (let { document } of allDocuments)
+  });
+  const allDocuments = [...operations.getOperations(), ...operations.getFragments()];
+  for (const { document } of allDocuments) {
     visit6(document, visitor);
-  return usedFieldsCache.set(schema16, usedFields), usedFields;
+  }
+  usedFieldsCache.set(schema16, usedFields);
+  return usedFields;
 }
 var rule16 = {
   meta: {
@@ -3321,10 +3920,10 @@ var rule16 = {
       description: "Requires all fields to be used at some level by siblings operations.",
       category: "Schema",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID10}`,
-      requiresSiblings: !0,
-      requiresSchema: !0,
+      requiresSiblings: true,
+      requiresSchema: true,
       // Requires documents to be set
-      isDisabledForAllConfig: !0,
+      isDisabledForAllConfig: true,
       examples: [
         {
           title: "Incorrect",
@@ -3391,17 +3990,26 @@ var rule16 = {
     },
     type: "suggestion",
     schema: schema8,
-    hasSuggestions: !0
+    hasSuggestions: true
   },
   create(context) {
-    let schema16 = requireGraphQLSchema(RULE_ID10, context), siblingsOperations = requireGraphQLOperations(RULE_ID10, context), usedFields = getUsedFields(schema16, siblingsOperations), { ignoredFieldSelectors } = context.options[0] || {};
+    const schema16 = requireGraphQLSchema(RULE_ID10, context);
+    const siblingsOperations = requireGraphQLOperations(RULE_ID10, context);
+    const usedFields = getUsedFields(schema16, siblingsOperations);
+    const { ignoredFieldSelectors } = context.options[0] || {};
+    const selector = (ignoredFieldSelectors || []).reduce(
+      (acc, selector2) => `${acc}:not(${selector2})`,
+      "FieldDefinition"
+    );
     return {
-      [(ignoredFieldSelectors || []).reduce(
-        (acc, selector2) => `${acc}:not(${selector2})`,
-        "FieldDefinition"
-      )](node) {
-        let fieldName = node.name.value, parentTypeName = node.parent.name.value;
-        usedFields[parentTypeName]?.has(fieldName) || context.report({
+      [selector](node) {
+        const fieldName = node.name.value;
+        const parentTypeName = node.parent.name.value;
+        const isUsed = usedFields[parentTypeName]?.has(fieldName);
+        if (isUsed) {
+          return;
+        }
+        context.report({
           node: node.name,
           messageId: RULE_ID10,
           data: { fieldName },
@@ -3409,7 +4017,10 @@ var rule16 = {
             {
               desc: `Remove \`${fieldName}\` field`,
               fix(fixer) {
-                let sourceCode = context.getSourceCode(), tokenBefore = sourceCode.getTokenBefore(node), tokenAfter = sourceCode.getTokenAfter(node), isEmptyType = tokenBefore.type === "{" && tokenAfter.type === "}";
+                const sourceCode = context.getSourceCode();
+                const tokenBefore = sourceCode.getTokenBefore(node);
+                const tokenAfter = sourceCode.getTokenAfter(node);
+                const isEmptyType = tokenBefore.type === "{" && tokenAfter.type === "}";
                 return fixer.remove(isEmptyType ? node.parent : node);
               }
             }
@@ -3422,22 +4033,25 @@ var rule16 = {
 
 // src/rules/relay-arguments/index.ts
 import { isScalarType as isScalarType2, Kind as Kind13 } from "graphql";
-var RULE_ID11 = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", schema9 = {
+var RULE_ID11 = "relay-arguments";
+var MISSING_ARGUMENTS = "MISSING_ARGUMENTS";
+var schema9 = {
   type: "array",
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     minProperties: 1,
     properties: {
       includeBoth: {
         type: "boolean",
-        default: !0,
+        default: true,
         description: "Enforce including both forward and backward pagination arguments"
       }
     }
   }
-}, rule17 = {
+};
+var rule17 = {
   meta: {
     type: "problem",
     docs: {
@@ -3456,8 +4070,7 @@ var RULE_ID11 = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", sche
         "",
         "- `last` takes a non-negative integer",
         "- `before` takes the Cursor type"
-      ].join(`
-`),
+      ].join("\n"),
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID11}`,
       examples: [
         {
@@ -3483,7 +4096,7 @@ var RULE_ID11 = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", sche
           )
         }
       ],
-      isDisabledForAllConfig: !0
+      isDisabledForAllConfig: true
     },
     messages: {
       [MISSING_ARGUMENTS]: "A field that returns a Connection type must include forward pagination arguments (`first` and `after`), backward pagination arguments (`last` and `before`), or both."
@@ -3491,15 +4104,19 @@ var RULE_ID11 = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", sche
     schema: schema9
   },
   create(context) {
-    let schema16 = requireGraphQLSchema(RULE_ID11, context), { includeBoth = !0 } = context.options[0] || {};
+    const schema16 = requireGraphQLSchema(RULE_ID11, context);
+    const { includeBoth = true } = context.options[0] || {};
     return {
       "FieldDefinition > .gqlType Name[value=/Connection$/]"(node) {
         let fieldNode = node.parent;
-        for (; fieldNode.kind !== Kind13.FIELD_DEFINITION; )
+        while (fieldNode.kind !== Kind13.FIELD_DEFINITION) {
           fieldNode = fieldNode.parent;
-        let args = Object.fromEntries(
+        }
+        const args = Object.fromEntries(
           fieldNode.arguments?.map((argument) => [argument.name.value, argument]) || []
-        ), hasForwardPagination = !!(args.first && args.after), hasBackwardPagination = !!(args.last && args.before);
+        );
+        const hasForwardPagination = !!(args.first && args.after);
+        const hasBackwardPagination = !!(args.last && args.before);
         if (!hasForwardPagination && !hasBackwardPagination) {
           context.report({
             node: fieldNode.name,
@@ -3508,16 +4125,29 @@ var RULE_ID11 = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", sche
           return;
         }
         function checkField(typeName, argumentName) {
-          let argument = args[argumentName], hasArgument = !!argument, type = argument;
-          if (hasArgument && type.gqlType.kind === Kind13.NON_NULL_TYPE && (type = type.gqlType), !(hasArgument && type.gqlType.kind === Kind13.NAMED_TYPE && (type.gqlType.name.value === typeName || typeName === "String" && isScalarType2(schema16.getType(type.gqlType.name.value))))) {
-            let returnType = typeName === "String" ? "String or Scalar" : typeName;
+          const argument = args[argumentName];
+          const hasArgument = !!argument;
+          let type = argument;
+          if (hasArgument && type.gqlType.kind === Kind13.NON_NULL_TYPE) {
+            type = type.gqlType;
+          }
+          const isAllowedNonNullType = hasArgument && type.gqlType.kind === Kind13.NAMED_TYPE && (type.gqlType.name.value === typeName || typeName === "String" && isScalarType2(schema16.getType(type.gqlType.name.value)));
+          if (!isAllowedNonNullType) {
+            const returnType = typeName === "String" ? "String or Scalar" : typeName;
             context.report({
               node: (argument || fieldNode).name,
               message: hasArgument ? `Argument \`${argumentName}\` must return ${returnType}.` : `Field \`${fieldNode.name.value}\` must contain an argument \`${argumentName}\`, that return ${returnType}.`
             });
           }
         }
-        (includeBoth || args.first || args.after) && (checkField("Int", "first"), checkField("String", "after")), (includeBoth || args.last || args.before) && (checkField("Int", "last"), checkField("String", "before"));
+        if (includeBoth || args.first || args.after) {
+          checkField("Int", "first");
+          checkField("String", "after");
+        }
+        if (includeBoth || args.last || args.before) {
+          checkField("Int", "last");
+          checkField("String", "before");
+        }
       }
     };
   }
@@ -3525,7 +4155,13 @@ var RULE_ID11 = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", sche
 
 // src/rules/relay-connection-types/index.ts
 import { Kind as Kind14 } from "graphql";
-var MUST_BE_OBJECT_TYPE = "MUST_BE_OBJECT_TYPE", MUST_CONTAIN_FIELD_EDGES = "MUST_CONTAIN_FIELD_EDGES", MUST_CONTAIN_FIELD_PAGE_INFO = "MUST_CONTAIN_FIELD_PAGE_INFO", MUST_HAVE_CONNECTION_SUFFIX = "MUST_HAVE_CONNECTION_SUFFIX", EDGES_FIELD_MUST_RETURN_LIST_TYPE = "EDGES_FIELD_MUST_RETURN_LIST_TYPE", PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE = "PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE", NON_OBJECT_TYPES = [
+var MUST_BE_OBJECT_TYPE = "MUST_BE_OBJECT_TYPE";
+var MUST_CONTAIN_FIELD_EDGES = "MUST_CONTAIN_FIELD_EDGES";
+var MUST_CONTAIN_FIELD_PAGE_INFO = "MUST_CONTAIN_FIELD_PAGE_INFO";
+var MUST_HAVE_CONNECTION_SUFFIX = "MUST_HAVE_CONNECTION_SUFFIX";
+var EDGES_FIELD_MUST_RETURN_LIST_TYPE = "EDGES_FIELD_MUST_RETURN_LIST_TYPE";
+var PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE = "PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE";
+var NON_OBJECT_TYPES = [
   Kind14.SCALAR_TYPE_DEFINITION,
   Kind14.UNION_TYPE_DEFINITION,
   Kind14.UNION_TYPE_EXTENSION,
@@ -3535,7 +4171,11 @@ var MUST_BE_OBJECT_TYPE = "MUST_BE_OBJECT_TYPE", MUST_CONTAIN_FIELD_EDGES = "MUS
   Kind14.ENUM_TYPE_EXTENSION,
   Kind14.INTERFACE_TYPE_DEFINITION,
   Kind14.INTERFACE_TYPE_EXTENSION
-], notConnectionTypesSelector = `:matches(${NON_OBJECT_TYPES})[name.value=/Connection$/] > .name`, hasEdgesField = (node) => node.fields?.some((field) => field.name.value === "edges"), hasPageInfoField = (node) => node.fields?.some((field) => field.name.value === "pageInfo"), rule18 = {
+];
+var notConnectionTypesSelector = `:matches(${NON_OBJECT_TYPES})[name.value=/Connection$/] > .name`;
+var hasEdgesField = (node) => node.fields?.some((field) => field.name.value === "edges");
+var hasPageInfoField = (node) => node.fields?.some((field) => field.name.value === "pageInfo");
+var rule18 = {
   meta: {
     type: "problem",
     docs: {
@@ -3547,10 +4187,9 @@ var MUST_BE_OBJECT_TYPE = "MUST_BE_OBJECT_TYPE", MUST_CONTAIN_FIELD_EDGES = "MUS
         "- Connection type must be an Object type",
         "- Connection type must contain a field `edges` that return a list type that wraps an edge type",
         "- Connection type must contain a field `pageInfo` that return a non-null `PageInfo` Object type"
-      ].join(`
-`),
+      ].join("\n"),
       url: "https://the-guild.dev/graphql/eslint/rules/relay-connection-types",
-      isDisabledForAllConfig: !0,
+      isDisabledForAllConfig: true,
       examples: [
         {
           title: "Incorrect",
@@ -3595,16 +4234,29 @@ var MUST_BE_OBJECT_TYPE = "MUST_BE_OBJECT_TYPE", MUST_CONTAIN_FIELD_EDGES = "MUS
         context.report({ node, messageId: MUST_BE_OBJECT_TYPE });
       },
       ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value!=/Connection$/]"(node) {
-        hasEdgesField(node) && hasPageInfoField(node) && context.report({ node: node.name, messageId: MUST_HAVE_CONNECTION_SUFFIX });
+        if (hasEdgesField(node) && hasPageInfoField(node)) {
+          context.report({ node: node.name, messageId: MUST_HAVE_CONNECTION_SUFFIX });
+        }
       },
       ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/]"(node) {
-        hasEdgesField(node) || context.report({ node: node.name, messageId: MUST_CONTAIN_FIELD_EDGES }), hasPageInfoField(node) || context.report({ node: node.name, messageId: MUST_CONTAIN_FIELD_PAGE_INFO });
+        if (!hasEdgesField(node)) {
+          context.report({ node: node.name, messageId: MUST_CONTAIN_FIELD_EDGES });
+        }
+        if (!hasPageInfoField(node)) {
+          context.report({ node: node.name, messageId: MUST_CONTAIN_FIELD_PAGE_INFO });
+        }
       },
       ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/] > FieldDefinition[name.value=edges] > .gqlType"(node) {
-        node.kind === Kind14.LIST_TYPE || node.kind === Kind14.NON_NULL_TYPE && node.gqlType.kind === Kind14.LIST_TYPE || context.report({ node, messageId: EDGES_FIELD_MUST_RETURN_LIST_TYPE });
+        const isListType2 = node.kind === Kind14.LIST_TYPE || node.kind === Kind14.NON_NULL_TYPE && node.gqlType.kind === Kind14.LIST_TYPE;
+        if (!isListType2) {
+          context.report({ node, messageId: EDGES_FIELD_MUST_RETURN_LIST_TYPE });
+        }
       },
       ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/] > FieldDefinition[name.value=pageInfo] > .gqlType"(node) {
-        node.kind === Kind14.NON_NULL_TYPE && node.gqlType.kind === Kind14.NAMED_TYPE && node.gqlType.name.value === "PageInfo" || context.report({ node, messageId: PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE });
+        const isNonNullPageInfoType = node.kind === Kind14.NON_NULL_TYPE && node.gqlType.kind === Kind14.NAMED_TYPE && node.gqlType.name.value === "PageInfo";
+        if (!isNonNullPageInfoType) {
+          context.report({ node, messageId: PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE });
+        }
       }
     };
   }
@@ -3618,49 +4270,66 @@ import {
   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;
+var RULE_ID12 = "relay-edge-types";
+var MESSAGE_MUST_BE_OBJECT_TYPE = "MESSAGE_MUST_BE_OBJECT_TYPE";
+var MESSAGE_MISSING_EDGE_SUFFIX = "MESSAGE_MISSING_EDGE_SUFFIX";
+var MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE = "MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE";
+var MESSAGE_SHOULD_IMPLEMENTS_NODE = "MESSAGE_SHOULD_IMPLEMENTS_NODE";
+var edgeTypesCache;
 function getEdgeTypes(schema16) {
-  if (edgeTypesCache)
+  if (edgeTypesCache) {
     return edgeTypesCache;
-  let edgeTypes = /* @__PURE__ */ new Set(), visitor = {
+  }
+  const edgeTypes = /* @__PURE__ */ new Set();
+  const visitor = {
     ObjectTypeDefinition(node) {
-      if (!node.name.value.endsWith("Connection"))
+      const typeName = node.name.value;
+      const hasConnectionSuffix = typeName.endsWith("Connection");
+      if (!hasConnectionSuffix) {
         return;
-      let edges = node.fields?.find((field) => field.name.value === "edges");
+      }
+      const edges = node.fields?.find((field) => field.name.value === "edges");
       if (edges) {
-        let edgesTypeName = getTypeName(edges), edgesType = schema16.getType(edgesTypeName);
-        isObjectType2(edgesType) && edgeTypes.add(edgesTypeName);
+        const edgesTypeName = getTypeName(edges);
+        const edgesType = schema16.getType(edgesTypeName);
+        if (isObjectType2(edgesType)) {
+          edgeTypes.add(edgesTypeName);
+        }
       }
     }
-  }, astNode = getDocumentNodeFromSchema(schema16);
-  return visit7(astNode, visitor), edgeTypesCache = edgeTypes, edgeTypesCache;
+  };
+  const astNode = getDocumentNodeFromSchema(schema16);
+  visit7(astNode, visitor);
+  edgeTypesCache = edgeTypes;
+  return edgeTypesCache;
 }
 var schema10 = {
   type: "array",
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     minProperties: 1,
     properties: {
       withEdgeSuffix: {
         type: "boolean",
-        default: !0,
+        default: true,
         description: 'Edge type name must end in "Edge".'
       },
       shouldImplementNode: {
         type: "boolean",
-        default: !0,
+        default: true,
         description: "Edge type's field `node` must implement `Node` interface."
       },
       listTypeCanWrapOnlyEdgeType: {
         type: "boolean",
-        default: !0,
+        default: true,
         description: "A list type should only wrap an edge type."
       }
     }
   }
-}, rule19 = {
+};
+var rule19 = {
   meta: {
     type: "problem",
     docs: {
@@ -3675,11 +4344,10 @@ var schema10 = {
         '- Edge type name must end in "Edge" _(optional)_',
         "- Edge type's field `node` must implement `Node` interface _(optional)_",
         "- A list type should only wrap an edge type _(optional)_"
-      ].join(`
-`),
+      ].join("\n"),
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID12}`,
-      isDisabledForAllConfig: !0,
-      requiresSchema: !0,
+      isDisabledForAllConfig: true,
+      requiresSchema: true,
       examples: [
         {
           title: "Correct",
@@ -3704,28 +4372,40 @@ var schema10 = {
     schema: schema10
   },
   create(context) {
-    let schema16 = requireGraphQLSchema(RULE_ID12, context), edgeTypes = getEdgeTypes(schema16), options = {
-      withEdgeSuffix: !0,
-      shouldImplementNode: !0,
-      listTypeCanWrapOnlyEdgeType: !0,
+    const schema16 = requireGraphQLSchema(RULE_ID12, context);
+    const edgeTypes = getEdgeTypes(schema16);
+    const options = {
+      withEdgeSuffix: true,
+      shouldImplementNode: true,
+      listTypeCanWrapOnlyEdgeType: true,
       ...context.options[0]
-    }, isNamedOrNonNullNamed = (node) => node.kind === Kind15.NAMED_TYPE || node.kind === Kind15.NON_NULL_TYPE && node.gqlType.kind === Kind15.NAMED_TYPE, checkNodeField = (node) => {
-      let nodeField = node.fields?.find((field) => field.name.value === "node"), message = "return either a Scalar, Enum, Object, Interface, Union, or a non-null wrapper around one of those types.";
-      if (!nodeField)
+    };
+    const isNamedOrNonNullNamed = (node) => node.kind === Kind15.NAMED_TYPE || node.kind === Kind15.NON_NULL_TYPE && node.gqlType.kind === Kind15.NAMED_TYPE;
+    const checkNodeField = (node) => {
+      const nodeField = node.fields?.find((field) => field.name.value === "node");
+      const message = "return either a Scalar, Enum, Object, Interface, Union, or a non-null wrapper around one of those types.";
+      if (!nodeField) {
         context.report({
           node: node.name,
           message: `Edge type must contain a field \`node\` that ${message}`
         });
-      else if (!isNamedOrNonNullNamed(nodeField.gqlType))
+      } else if (!isNamedOrNonNullNamed(nodeField.gqlType)) {
         context.report({ node: nodeField.name, message: `Field \`node\` must ${message}` });
-      else if (options.shouldImplementNode) {
-        let nodeReturnTypeName = getTypeName(nodeField.gqlType.rawNode()), type = schema16.getType(nodeReturnTypeName);
-        if (!isObjectType2(type))
+      } else if (options.shouldImplementNode) {
+        const nodeReturnTypeName = getTypeName(nodeField.gqlType.rawNode());
+        const type = schema16.getType(nodeReturnTypeName);
+        if (!isObjectType2(type)) {
           return;
-        type.astNode.interfaces?.some((n) => n.name.value === "Node") || context.report({ node: node.name, messageId: MESSAGE_SHOULD_IMPLEMENTS_NODE });
+        }
+        const implementsNode = type.astNode.interfaces?.some((n) => n.name.value === "Node");
+        if (!implementsNode) {
+          context.report({ node: node.name, messageId: MESSAGE_SHOULD_IMPLEMENTS_NODE });
+        }
       }
-    }, checkCursorField = (node) => {
-      let cursorField = node.fields?.find((field) => field.name.value === "cursor"), message = "return either a String, Scalar, or a non-null wrapper wrapper around one of those types.";
+    };
+    const checkCursorField = (node) => {
+      const cursorField = node.fields?.find((field) => field.name.value === "cursor");
+      const message = "return either a String, Scalar, or a non-null wrapper wrapper around one of those types.";
       if (!cursorField) {
         context.report({
           node: node.name,
@@ -3733,30 +4413,51 @@ var schema10 = {
         });
         return;
       }
-      let typeName = getTypeName(cursorField.rawNode());
-      (!isNamedOrNonNullNamed(cursorField.gqlType) || typeName !== "String" && !isScalarType3(schema16.getType(typeName))) && context.report({ node: cursorField.name, message: `Field \`cursor\` must ${message}` });
-    }, listeners = {
+      const typeName = getTypeName(cursorField.rawNode());
+      if (!isNamedOrNonNullNamed(cursorField.gqlType) || typeName !== "String" && !isScalarType3(schema16.getType(typeName))) {
+        context.report({ node: cursorField.name, message: `Field \`cursor\` must ${message}` });
+      }
+    };
+    const listeners = {
       ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/] > FieldDefinition[name.value=edges] > .gqlType Name"(node) {
-        let type = schema16.getType(node.value);
-        isObjectType2(type) || context.report({ node, messageId: MESSAGE_MUST_BE_OBJECT_TYPE });
+        const type = schema16.getType(node.value);
+        if (!isObjectType2(type)) {
+          context.report({ node, messageId: MESSAGE_MUST_BE_OBJECT_TYPE });
+        }
       },
       ":matches(ObjectTypeDefinition, ObjectTypeExtension)"(node) {
-        let typeName = node.name.value;
-        edgeTypes.has(typeName) && (checkNodeField(node), checkCursorField(node), options.withEdgeSuffix && !typeName.endsWith("Edge") && context.report({ node: node.name, messageId: MESSAGE_MISSING_EDGE_SUFFIX }));
+        const typeName = node.name.value;
+        if (edgeTypes.has(typeName)) {
+          checkNodeField(node);
+          checkCursorField(node);
+          if (options.withEdgeSuffix && !typeName.endsWith("Edge")) {
+            context.report({ node: node.name, messageId: MESSAGE_MISSING_EDGE_SUFFIX });
+          }
+        }
       }
     };
-    return options.listTypeCanWrapOnlyEdgeType && (listeners["FieldDefinition > .gqlType"] = (node) => {
-      if (node.kind === Kind15.LIST_TYPE || node.kind === Kind15.NON_NULL_TYPE && node.gqlType.kind === Kind15.LIST_TYPE) {
-        let typeName = getTypeName(node.rawNode());
-        edgeTypes.has(typeName) || context.report({ node, messageId: MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE });
-      }
-    }), listeners;
+    if (options.listTypeCanWrapOnlyEdgeType) {
+      listeners["FieldDefinition > .gqlType"] = (node) => {
+        if (node.kind === Kind15.LIST_TYPE || node.kind === Kind15.NON_NULL_TYPE && node.gqlType.kind === Kind15.LIST_TYPE) {
+          const typeName = getTypeName(node.rawNode());
+          if (!edgeTypes.has(typeName)) {
+            context.report({ node, messageId: MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE });
+          }
+        }
+      };
+    }
+    return listeners;
   }
 };
 
 // src/rules/relay-page-info/index.ts
 import { isScalarType as isScalarType4, Kind as Kind16 } from "graphql";
-var RULE_ID13 = "relay-page-info", MESSAGE_MUST_EXIST = "MESSAGE_MUST_EXIST", MESSAGE_MUST_BE_OBJECT_TYPE2 = "MESSAGE_MUST_BE_OBJECT_TYPE", notPageInfoTypesSelector = `:matches(${NON_OBJECT_TYPES})[name.value=PageInfo] > .name`, hasPageInfoChecked = !1, rule20 = {
+var RULE_ID13 = "relay-page-info";
+var MESSAGE_MUST_EXIST = "MESSAGE_MUST_EXIST";
+var MESSAGE_MUST_BE_OBJECT_TYPE2 = "MESSAGE_MUST_BE_OBJECT_TYPE";
+var notPageInfoTypesSelector = `:matches(${NON_OBJECT_TYPES})[name.value=PageInfo] > .name`;
+var hasPageInfoChecked = false;
+var rule20 = {
   meta: {
     type: "problem",
     docs: {
@@ -3767,8 +4468,7 @@ var RULE_ID13 = "relay-page-info", MESSAGE_MUST_EXIST = "MESSAGE_MUST_EXIST", ME
         "- `PageInfo` must be an Object type",
         "- `PageInfo` must contain fields `hasPreviousPage` and `hasNextPage`, that return non-null Boolean",
         "- `PageInfo` must contain fields `startCursor` and `endCursor`, that return either String or Scalar, which can be null if there are no results"
-      ].join(`
-`),
+      ].join("\n"),
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID13}`,
       examples: [
         {
@@ -3786,8 +4486,8 @@ var RULE_ID13 = "relay-page-info", MESSAGE_MUST_EXIST = "MESSAGE_MUST_EXIST", ME
           )
         }
       ],
-      isDisabledForAllConfig: !0,
-      requiresSchema: !0
+      isDisabledForAllConfig: true,
+      requiresSchema: true
     },
     messages: {
       [MESSAGE_MUST_EXIST]: "The server must provide a `PageInfo` object.",
@@ -3796,54 +4496,76 @@ var RULE_ID13 = "relay-page-info", MESSAGE_MUST_EXIST = "MESSAGE_MUST_EXIST", ME
     schema: []
   },
   create(context) {
-    let schema16 = requireGraphQLSchema(RULE_ID13, context);
-    return hasPageInfoChecked || (schema16.getType("PageInfo") || context.report({
-      loc: REPORT_ON_FIRST_CHARACTER,
-      messageId: MESSAGE_MUST_EXIST
-    }), hasPageInfoChecked = !0), {
+    const schema16 = requireGraphQLSchema(RULE_ID13, context);
+    if (!hasPageInfoChecked) {
+      const pageInfoType = schema16.getType("PageInfo");
+      if (!pageInfoType) {
+        context.report({
+          loc: REPORT_ON_FIRST_CHARACTER,
+          messageId: MESSAGE_MUST_EXIST
+        });
+      }
+      hasPageInfoChecked = true;
+    }
+    return {
       [notPageInfoTypesSelector](node) {
         context.report({ node, messageId: MESSAGE_MUST_BE_OBJECT_TYPE2 });
       },
       "ObjectTypeDefinition[name.value=PageInfo]"(node) {
-        let fieldMap = Object.fromEntries(
+        const fieldMap = Object.fromEntries(
           node.fields?.map((field) => [field.name.value, field]) || []
-        ), checkField = (fieldName, typeName) => {
-          let field = fieldMap[fieldName], isAllowedType = !1;
+        );
+        const checkField = (fieldName, typeName) => {
+          const field = fieldMap[fieldName];
+          let isAllowedType = false;
           if (field) {
-            let type = field.gqlType;
-            typeName === "Boolean" ? isAllowedType = type.kind === Kind16.NON_NULL_TYPE && type.gqlType.kind === Kind16.NAMED_TYPE && type.gqlType.name.value === "Boolean" : type.kind === Kind16.NAMED_TYPE && (isAllowedType = type.name.value === "String" || isScalarType4(schema16.getType(type.name.value)));
+            const type = field.gqlType;
+            if (typeName === "Boolean") {
+              isAllowedType = type.kind === Kind16.NON_NULL_TYPE && type.gqlType.kind === Kind16.NAMED_TYPE && type.gqlType.name.value === "Boolean";
+            } else if (type.kind === Kind16.NAMED_TYPE) {
+              isAllowedType = type.name.value === "String" || isScalarType4(schema16.getType(type.name.value));
+            }
           }
           if (!isAllowedType) {
-            let returnType = typeName === "Boolean" ? "non-null Boolean" : "either String or Scalar, which can be null if there are no results";
+            const returnType = typeName === "Boolean" ? "non-null Boolean" : "either String or Scalar, which can be null if there are no results";
             context.report({
               node: field ? field.name : node.name,
               message: field ? `Field \`${fieldName}\` must return ${returnType}.` : `\`PageInfo\` must contain a field \`${fieldName}\`, that return ${returnType}.`
             });
           }
         };
-        checkField("hasPreviousPage", "Boolean"), checkField("hasNextPage", "Boolean"), checkField("startCursor", "String"), checkField("endCursor", "String");
+        checkField("hasPreviousPage", "Boolean");
+        checkField("hasNextPage", "Boolean");
+        checkField("startCursor", "String");
+        checkField("endCursor", "String");
       }
     };
   }
 };
 
 // src/rules/require-deprecation-date/index.ts
-var DATE_REGEX = /^\d{2}\/\d{2}\/\d{4}$/, MESSAGE_REQUIRE_DATE = "MESSAGE_REQUIRE_DATE", MESSAGE_INVALID_FORMAT = "MESSAGE_INVALID_FORMAT", MESSAGE_INVALID_DATE = "MESSAGE_INVALID_DATE", MESSAGE_CAN_BE_REMOVED = "MESSAGE_CAN_BE_REMOVED", schema11 = {
+var DATE_REGEX = /^\d{2}\/\d{2}\/\d{4}$/;
+var MESSAGE_REQUIRE_DATE = "MESSAGE_REQUIRE_DATE";
+var MESSAGE_INVALID_FORMAT = "MESSAGE_INVALID_FORMAT";
+var MESSAGE_INVALID_DATE = "MESSAGE_INVALID_DATE";
+var MESSAGE_CAN_BE_REMOVED = "MESSAGE_CAN_BE_REMOVED";
+var schema11 = {
   type: "array",
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     properties: {
       argumentName: {
         type: "string"
       }
     }
   }
-}, rule21 = {
+};
+var rule21 = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       category: "Schema",
       description: "Require deletion date on `@deprecated` directive. Suggest removing deprecated things after deprecated date.",
@@ -3899,7 +4621,8 @@ var DATE_REGEX = /^\d{2}\/\d{2}\/\d{4}$/, MESSAGE_REQUIRE_DATE = "MESSAGE_REQUIR
   create(context) {
     return {
       "Directive[name.value=deprecated]"(node) {
-        let argName = context.options[0]?.argumentName || "deletionDate", deletionDateNode = node.arguments?.find((arg) => arg.name.value === argName);
+        const argName = context.options[0]?.argumentName || "deletionDate";
+        const deletionDateNode = node.arguments?.find((arg) => arg.name.value === argName);
         if (!deletionDateNode) {
           context.report({
             node: node.name,
@@ -3910,8 +4633,9 @@ var DATE_REGEX = /^\d{2}\/\d{2}\/\d{4}$/, MESSAGE_REQUIRE_DATE = "MESSAGE_REQUIR
           });
           return;
         }
-        let deletionDate = valueFromNode(deletionDateNode.value);
-        if (!DATE_REGEX.test(deletionDate)) {
+        const deletionDate = valueFromNode(deletionDateNode.value);
+        const isValidDate = DATE_REGEX.test(deletionDate);
+        if (!isValidDate) {
           context.report({
             node: deletionDateNode.value,
             messageId: MESSAGE_INVALID_FORMAT,
@@ -3920,8 +4644,9 @@ var DATE_REGEX = /^\d{2}\/\d{2}\/\d{4}$/, MESSAGE_REQUIRE_DATE = "MESSAGE_REQUIR
           return;
         }
         let [day, month, year] = deletionDate.split("/");
-        day = day.padStart(2, "0"), month = month.padStart(2, "0");
-        let deletionDateInMS = Date.parse(`${year}-${month}-${day}`);
+        day = day.padStart(2, "0");
+        month = month.padStart(2, "0");
+        const deletionDateInMS = Date.parse(`${year}-${month}-${day}`);
         if (Number.isNaN(deletionDateInMS)) {
           context.report({
             node: deletionDateNode.value,
@@ -3933,8 +4658,10 @@ var DATE_REGEX = /^\d{2}\/\d{2}\/\d{4}$/, MESSAGE_REQUIRE_DATE = "MESSAGE_REQUIR
           });
           return;
         }
-        if (Date.now() > deletionDateInMS) {
-          let { parent } = node, nodeName = parent.name.value;
+        const canRemove = Date.now() > deletionDateInMS;
+        if (canRemove) {
+          const { parent } = node;
+          const nodeName = parent.name.value;
           context.report({
             node: parent.name,
             messageId: MESSAGE_CAN_BE_REMOVED,
@@ -3959,7 +4686,7 @@ var rule22 = {
       description: "Require all deprecation directives to specify a reason.",
       category: "Schema",
       url: "https://the-guild.dev/graphql/eslint/rules/require-deprecation-reason",
-      recommended: !0,
+      recommended: true,
       examples: [
         {
           title: "Incorrect",
@@ -4002,13 +4729,16 @@ var rule22 = {
   create(context) {
     return {
       "Directive[name.value=deprecated]"(node) {
-        let reasonArgument = node.arguments?.find(
+        const reasonArgument = node.arguments?.find(
           (arg) => arg.name.value === "reason"
         );
-        reasonArgument && String(valueFromNode(reasonArgument.value)).trim() || context.report({
-          node: node.name,
-          message: `Deprecation reason is required for ${getNodeName(node.parent)}.`
-        });
+        const value = reasonArgument && String(valueFromNode(reasonArgument.value)).trim();
+        if (!value) {
+          context.report({
+            node: node.name,
+            message: `Deprecation reason is required for ${getNodeName(node.parent)}.`
+          });
+        }
       }
     };
   }
@@ -4017,57 +4747,60 @@ var rule22 = {
 // src/rules/require-description/index.ts
 import { Kind as Kind17, TokenKind as TokenKind3 } from "graphql";
 import { getRootTypeNames } from "@graphql-tools/utils";
-var RULE_ID14 = "require-description", ALLOWED_KINDS2 = [
+var RULE_ID14 = "require-description";
+var ALLOWED_KINDS2 = [
   ...TYPES_KINDS,
   Kind17.DIRECTIVE_DEFINITION,
   Kind17.FIELD_DEFINITION,
   Kind17.INPUT_VALUE_DEFINITION,
   Kind17.ENUM_VALUE_DEFINITION,
   Kind17.OPERATION_DEFINITION
-], schema12 = {
+];
+var schema12 = {
   type: "array",
   minItems: 1,
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     minProperties: 1,
     properties: {
       types: {
         type: "boolean",
-        enum: [!0],
+        enum: [true],
         description: `Includes:
-${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
-`)}`
+${TYPES_KINDS.map((kind) => `- \`${kind}\``).join("\n")}`
       },
       rootField: {
         type: "boolean",
-        enum: [!0],
+        enum: [true],
         description: "Definitions within `Query`, `Mutation`, and `Subscription` root types."
       },
       ignoredSelectors: {
         ...ARRAY_DEFAULT_OPTIONS,
-        description: ["Ignore specific selectors", eslintSelectorsTip].join(`
-`)
+        description: ["Ignore specific selectors", eslintSelectorsTip].join("\n")
       },
       ...Object.fromEntries(
         [...ALLOWED_KINDS2].sort().map((kind) => {
           let description = `> [!NOTE]
 >
 > Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October2021/#${kind}).`;
-          return kind === Kind17.OPERATION_DEFINITION && (description += [
-            "",
-            "",
-            "> [!WARNING]",
-            ">",
-            '> You must use only comment syntax `#` and not description syntax `"""` or `"`.'
-          ].join(`
-`)), [kind, { type: "boolean", description }];
+          if (kind === Kind17.OPERATION_DEFINITION) {
+            description += [
+              "",
+              "",
+              "> [!WARNING]",
+              ">",
+              '> You must use only comment syntax `#` and not description syntax `"""` or `"`.'
+            ].join("\n");
+          }
+          return [kind, { type: "boolean", description }];
         })
       )
     }
   }
-}, rule23 = {
+};
+var rule23 = {
   meta: {
     docs: {
       category: "Schema",
@@ -4076,7 +4809,7 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
       examples: [
         {
           title: "Incorrect",
-          usage: [{ types: !0, FieldDefinition: !0 }],
+          usage: [{ types: true, FieldDefinition: true }],
           code: (
             /* GraphQL */
             `
@@ -4088,7 +4821,7 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         },
         {
           title: "Correct",
-          usage: [{ types: !0, FieldDefinition: !0 }],
+          usage: [{ types: true, FieldDefinition: true }],
           code: (
             /* GraphQL */
             `
@@ -4106,7 +4839,7 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         },
         {
           title: "Correct",
-          usage: [{ OperationDefinition: !0 }],
+          usage: [{ OperationDefinition: true }],
           code: (
             /* GraphQL */
             `
@@ -4119,7 +4852,7 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         },
         {
           title: "Correct",
-          usage: [{ rootField: !0 }],
+          usage: [{ rootField: true }],
           code: (
             /* GraphQL */
             `
@@ -4167,12 +4900,12 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
       ],
       configOptions: [
         {
-          types: !0,
-          [Kind17.DIRECTIVE_DEFINITION]: !0,
-          rootField: !0
+          types: true,
+          [Kind17.DIRECTIVE_DEFINITION]: true,
+          rootField: true
         }
       ],
-      recommended: !0
+      recommended: true
     },
     type: "suggestion",
     messages: {
@@ -4181,11 +4914,18 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
     schema: schema12
   },
   create(context) {
-    let { types, rootField, ignoredSelectors = [], ...restOptions } = context.options[0] || {}, kinds = new Set(types ? TYPES_KINDS : []);
-    for (let [kind, isEnabled] of Object.entries(restOptions))
-      isEnabled ? kinds.add(kind) : kinds.delete(kind);
+    const { types, rootField, ignoredSelectors = [], ...restOptions } = context.options[0] || {};
+    const kinds = new Set(types ? TYPES_KINDS : []);
+    for (const [kind, isEnabled] of Object.entries(restOptions)) {
+      if (isEnabled) {
+        kinds.add(kind);
+      } else {
+        kinds.delete(kind);
+      }
+    }
     if (rootField) {
-      let schema16 = requireGraphQLSchema(RULE_ID14, context), rootTypeNames = getRootTypeNames(schema16);
+      const schema16 = requireGraphQLSchema(RULE_ID14, context);
+      const rootTypeNames = getRootTypeNames(schema16);
       kinds.add(
         `:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/^(${[
           ...rootTypeNames
@@ -4193,26 +4933,35 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
       );
     }
     let selector = `:matches(${[...kinds]})`;
-    for (let str of ignoredSelectors)
+    for (const str of ignoredSelectors) {
       selector += `:not(${str})`;
+    }
     return {
       [selector](node) {
-        let description = "", isOperation = node.kind === Kind17.OPERATION_DEFINITION;
+        let description = "";
+        const isOperation = node.kind === Kind17.OPERATION_DEFINITION;
         if (isOperation) {
-          let rawNode = node.rawNode(), { prev, line } = rawNode.loc.startToken;
+          const rawNode = node.rawNode();
+          const { prev, line } = rawNode.loc.startToken;
           if (prev?.kind === TokenKind3.COMMENT) {
-            let value = prev.value.trim(), linesBefore = line - prev.line;
-            !value.startsWith("eslint") && linesBefore === 1 && (description = value);
+            const value = prev.value.trim();
+            const linesBefore = line - prev.line;
+            if (!value.startsWith("eslint") && linesBefore === 1) {
+              description = value;
+            }
           }
-        } else
+        } else {
           description = node.description?.value.trim() || "";
-        description.length === 0 && context.report({
-          loc: isOperation ? getLocation(node.loc.start, node.operation) : node.name.loc,
-          messageId: RULE_ID14,
-          data: {
-            nodeName: getNodeName(node)
-          }
-        });
+        }
+        if (description.length === 0) {
+          context.report({
+            loc: isOperation ? getLocation(node.loc.start, node.operation) : node.name.loc,
+            messageId: RULE_ID14,
+            data: {
+              nodeName: getNodeName(node)
+            }
+          });
+        }
       }
     };
   }
@@ -4220,14 +4969,15 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
 
 // src/rules/require-field-of-type-query-in-mutation-result/index.ts
 import { isObjectType as isObjectType3 } from "graphql";
-var RULE_ID15 = "require-field-of-type-query-in-mutation-result", rule24 = {
+var RULE_ID15 = "require-field-of-type-query-in-mutation-result";
+var rule24 = {
   meta: {
     type: "suggestion",
     docs: {
       category: "Schema",
       description: "Allow the client in one round-trip not only to call mutation but also to get a wagon of data to update their application.\n> Currently, no errors are reported for result type `union`, `interface` and `scalar`.",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID15}`,
-      requiresSchema: !0,
+      requiresSchema: true,
       examples: [
         {
           title: "Incorrect",
@@ -4267,16 +5017,26 @@ var RULE_ID15 = "require-field-of-type-query-in-mutation-result", rule24 = {
     schema: []
   },
   create(context) {
-    let schema16 = requireGraphQLSchema(RULE_ID15, context), mutationType = schema16.getMutationType(), queryType = schema16.getQueryType();
-    return !mutationType || !queryType ? {} : {
-      [`:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=${mutationType.name}] > FieldDefinition > .gqlType Name`](node) {
-        let typeName = node.value, graphQLType = schema16.getType(typeName);
+    const schema16 = requireGraphQLSchema(RULE_ID15, context);
+    const mutationType = schema16.getMutationType();
+    const queryType = schema16.getQueryType();
+    if (!mutationType || !queryType) {
+      return {};
+    }
+    const selector = `:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=${mutationType.name}] > FieldDefinition > .gqlType Name`;
+    return {
+      [selector](node) {
+        const typeName = node.value;
+        const graphQLType = schema16.getType(typeName);
         if (isObjectType3(graphQLType)) {
-          let { fields } = graphQLType.astNode;
-          fields?.some((field) => getTypeName(field) === queryType.name) || context.report({
-            node,
-            message: `Mutation result type "${graphQLType.name}" must contain field of type "${queryType.name}"`
-          });
+          const { fields } = graphQLType.astNode;
+          const hasQueryType = fields?.some((field) => getTypeName(field) === queryType.name);
+          if (!hasQueryType) {
+            context.report({
+              node,
+              message: `Mutation result type "${graphQLType.name}" must contain field of type "${queryType.name}"`
+            });
+          }
         }
       }
     };
@@ -4285,7 +5045,9 @@ var RULE_ID15 = "require-field-of-type-query-in-mutation-result", rule24 = {
 
 // src/rules/require-import-fragment/index.ts
 import path from "node:path";
-var RULE_ID16 = "require-import-fragment", SUGGESTION_ID = "add-import-expression", rule25 = {
+var RULE_ID16 = "require-import-fragment";
+var SUGGESTION_ID = "add-import-expression";
+var rule25 = {
   meta: {
     type: "suggestion",
     docs: {
@@ -4349,9 +5111,9 @@ var RULE_ID16 = "require-import-fragment", SUGGESTION_ID = "add-import-expressio
           )
         }
       ],
-      requiresSiblings: !0
+      requiresSiblings: true
     },
-    hasSuggestions: !0,
+    hasSuggestions: true,
     messages: {
       [RULE_ID16]: 'Expected "{{fragmentName}}" fragment to be imported.',
       [SUGGESTION_ID]: 'Add import expression for "{{fragmentName}}".'
@@ -4359,25 +5121,32 @@ var RULE_ID16 = "require-import-fragment", SUGGESTION_ID = "add-import-expressio
     schema: []
   },
   create(context) {
-    let comments = context.getSourceCode().getAllComments(), siblings = requireGraphQLOperations(RULE_ID16, context), filePath = context.filename;
+    const comments = context.getSourceCode().getAllComments();
+    const siblings = requireGraphQLOperations(RULE_ID16, context);
+    const filePath = context.filename;
     return {
       "FragmentSpread > .name"(node) {
-        let fragmentName = node.value, fragmentsFromSiblings = siblings.getFragment(fragmentName);
-        for (let comment of comments) {
-          if (comment.type !== "Line" || !new RegExp(
+        const fragmentName = node.value;
+        const fragmentsFromSiblings = siblings.getFragment(fragmentName);
+        for (const comment of comments) {
+          if (comment.type !== "Line") continue;
+          const isPossibleImported = new RegExp(
             `^\\s*import\\s+(${fragmentName}\\s+from\\s+)?['"]`
-          ).test(comment.value)) continue;
-          let extractedImportPath = comment.value.match(/(["'])((?:\1|.)*?)\1/)?.[2];
+          ).test(comment.value);
+          if (!isPossibleImported) continue;
+          const extractedImportPath = comment.value.match(/(["'])((?:\1|.)*?)\1/)?.[2];
           if (!extractedImportPath) continue;
-          let importPath = path.join(filePath, "..", extractedImportPath);
-          if (fragmentsFromSiblings.some(
+          const importPath = path.join(filePath, "..", extractedImportPath);
+          const hasInSiblings = fragmentsFromSiblings.some(
             (source) => source.filePath === importPath
-          )) return;
+          );
+          if (hasInSiblings) return;
         }
-        if (fragmentsFromSiblings.some(
+        const fragmentInSameFile = fragmentsFromSiblings.some(
           (source) => source.filePath === filePath
-        )) return;
-        let suggestedFilePaths = fragmentsFromSiblings.length ? fragmentsFromSiblings.map(
+        );
+        if (fragmentInSameFile) return;
+        const suggestedFilePaths = fragmentsFromSiblings.length ? fragmentsFromSiblings.map(
           (o) => (
             // Use always forward slash for suggested import path
             slash(path.relative(path.dirname(filePath), o.filePath))
@@ -4404,7 +5173,8 @@ var RULE_ID16 = "require-import-fragment", SUGGESTION_ID = "add-import-expressio
 
 // src/rules/require-nullable-fields-with-oneof/index.ts
 import { Kind as Kind18 } from "graphql";
-var RULE_ID17 = "require-nullable-fields-with-oneof", rule26 = {
+var RULE_ID17 = "require-nullable-fields-with-oneof";
+var rule26 = {
   meta: {
     type: "suggestion",
     docs: {
@@ -4446,16 +5216,22 @@ var RULE_ID17 = "require-nullable-fields-with-oneof", rule26 = {
   create(context) {
     return {
       "Directive[name.value=oneOf]"({ parent }) {
-        if ([
+        const isTypeOrInput = [
           Kind18.OBJECT_TYPE_DEFINITION,
           Kind18.INPUT_OBJECT_TYPE_DEFINITION
-        ].includes(parent.kind))
-          for (let field of parent.fields || [])
-            field.gqlType.kind === Kind18.NON_NULL_TYPE && context.report({
+        ].includes(parent.kind);
+        if (!isTypeOrInput) {
+          return;
+        }
+        for (const field of parent.fields || []) {
+          if (field.gqlType.kind === Kind18.NON_NULL_TYPE) {
+            context.report({
               node: field.name,
               messageId: RULE_ID17,
               data: { nodeName: getNodeName(field) }
             });
+          }
+        }
       }
     };
   }
@@ -4463,15 +5239,16 @@ var RULE_ID17 = "require-nullable-fields-with-oneof", rule26 = {
 
 // src/rules/require-nullable-result-in-root/index.ts
 import { Kind as Kind19 } from "graphql";
-var RULE_ID18 = "require-nullable-result-in-root", rule27 = {
+var RULE_ID18 = "require-nullable-result-in-root";
+var rule27 = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       category: "Schema",
       description: "Require nullable fields in root types.",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID18}`,
-      requiresSchema: !0,
+      requiresSchema: true,
       examples: [
         {
           title: "Incorrect",
@@ -4505,34 +5282,38 @@ var RULE_ID18 = "require-nullable-result-in-root", rule27 = {
     schema: []
   },
   create(context) {
-    let schema16 = requireGraphQLSchema(RULE_ID18, context), rootTypeNames = new Set(
+    const schema16 = requireGraphQLSchema(RULE_ID18, context);
+    const rootTypeNames = new Set(
       [schema16.getQueryType(), schema16.getMutationType()].filter((v) => !!v).map((type) => type.name)
-    ), sourceCode = context.getSourceCode();
+    );
+    const sourceCode = context.getSourceCode();
     return {
       "ObjectTypeDefinition,ObjectTypeExtension"(node) {
-        if (rootTypeNames.has(node.name.value))
-          for (let field of node.fields || []) {
-            if (field.gqlType.type !== Kind19.NON_NULL_TYPE || field.gqlType.gqlType.type !== Kind19.NAMED_TYPE)
-              continue;
-            let name = field.gqlType.gqlType.name.value, type = schema16.getType(name), resultType = type?.astNode ? getNodeName(type.astNode) : type?.name;
-            context.report({
-              node: field.gqlType,
-              messageId: RULE_ID18,
-              data: {
-                resultType: resultType || "",
-                rootType: getNodeName(node)
-              },
-              suggest: [
-                {
-                  desc: `Make ${resultType} nullable`,
-                  fix(fixer) {
-                    let text = sourceCode.getText(field.gqlType);
-                    return fixer.replaceText(field.gqlType, text.replace("!", ""));
-                  }
+        if (!rootTypeNames.has(node.name.value)) return;
+        for (const field of node.fields || []) {
+          if (field.gqlType.type !== Kind19.NON_NULL_TYPE || field.gqlType.gqlType.type !== Kind19.NAMED_TYPE)
+            continue;
+          const name = field.gqlType.gqlType.name.value;
+          const type = schema16.getType(name);
+          const resultType = type?.astNode ? getNodeName(type.astNode) : type?.name;
+          context.report({
+            node: field.gqlType,
+            messageId: RULE_ID18,
+            data: {
+              resultType: resultType || "",
+              rootType: getNodeName(node)
+            },
+            suggest: [
+              {
+                desc: `Make ${resultType} nullable`,
+                fix(fixer) {
+                  const text = sourceCode.getText(field.gqlType);
+                  return fixer.replaceText(field.gqlType, text.replace("!", ""));
                 }
-              ]
-            });
-          }
+              }
+            ]
+          });
+        }
       }
     };
   }
@@ -4549,7 +5330,9 @@ import {
   visitWithTypeInfo as visitWithTypeInfo3
 } from "graphql";
 import { asArray } from "@graphql-tools/utils";
-var RULE_ID19 = "require-selections", DEFAULT_ID_FIELD_NAME = "id", schema13 = {
+var RULE_ID19 = "require-selections";
+var DEFAULT_ID_FIELD_NAME = "id";
+var schema13 = {
   definitions: {
     asString: {
       type: "string"
@@ -4560,7 +5343,7 @@ var RULE_ID19 = "require-selections", DEFAULT_ID_FIELD_NAME = "id", schema13 = {
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     properties: {
       fieldName: {
         oneOf: [{ $ref: "#/definitions/asString" }, { $ref: "#/definitions/asArray" }],
@@ -4572,16 +5355,17 @@ var RULE_ID19 = "require-selections", DEFAULT_ID_FIELD_NAME = "id", schema13 = {
       }
     }
   }
-}, rule28 = {
+};
+var rule28 = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       category: "Operations",
       description: "Enforce selecting specific fields when they are available on the GraphQL type.",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID19}`,
-      requiresSchema: !0,
-      requiresSiblings: !0,
+      requiresSchema: true,
+      requiresSiblings: true,
       examples: [
         {
           title: "Incorrect",
@@ -4632,87 +5416,120 @@ var RULE_ID19 = "require-selections", DEFAULT_ID_FIELD_NAME = "id", schema13 = {
           )
         }
       ],
-      recommended: !0,
+      recommended: true,
       whenNotToUseIt: "Relay Compiler automatically adds an `id` field to any type that has an `id` field, even if it hasn't been explicitly requested. Requesting a field that is not used directly in the code can conflict with another Relay rule: `relay/unused-fields`."
     },
     messages: {
-      [RULE_ID19]: `Field{{ pluralSuffix }} {{ fieldName }} must be selected when it's available on a type.
-Include it in your selection set{{ addition }}.`
+      [RULE_ID19]: "Field{{ pluralSuffix }} {{ fieldName }} must be selected when it's available on a type.\nInclude it in your selection set{{ addition }}."
     },
     schema: schema13
   },
   create(context) {
-    let schema16 = requireGraphQLSchema(RULE_ID19, context), siblings = requireGraphQLOperations(RULE_ID19, context), { fieldName = DEFAULT_ID_FIELD_NAME, requireAllFields } = context.options[0] || {}, idNames = asArray(fieldName), selector = "SelectionSet[parent.kind!=/(^OperationDefinition|InlineFragment)$/]", typeInfo = new TypeInfo3(schema16);
+    const schema16 = requireGraphQLSchema(RULE_ID19, context);
+    const siblings = requireGraphQLOperations(RULE_ID19, context);
+    const { fieldName = DEFAULT_ID_FIELD_NAME, requireAllFields } = context.options[0] || {};
+    const idNames = asArray(fieldName);
+    const selector = "SelectionSet[parent.kind!=/(^OperationDefinition|InlineFragment)$/]";
+    const typeInfo = new TypeInfo3(schema16);
     function checkFragments(node) {
-      for (let selection of node.selections) {
-        if (selection.kind !== Kind20.FRAGMENT_SPREAD)
+      for (const selection of node.selections) {
+        if (selection.kind !== Kind20.FRAGMENT_SPREAD) {
           continue;
-        let [foundSpread] = siblings.getFragment(selection.name.value);
-        if (!foundSpread)
+        }
+        const [foundSpread] = siblings.getFragment(selection.name.value);
+        if (!foundSpread) {
           continue;
-        let checkedFragmentSpreads = /* @__PURE__ */ new Set(), visitor = visitWithTypeInfo3(typeInfo, {
+        }
+        const checkedFragmentSpreads = /* @__PURE__ */ new Set();
+        const visitor = visitWithTypeInfo3(typeInfo, {
           SelectionSet(node2, key, _parent) {
-            let parent = _parent;
-            parent.kind === Kind20.FRAGMENT_DEFINITION ? checkedFragmentSpreads.add(parent.name.value) : parent.kind !== Kind20.INLINE_FRAGMENT && checkSelections(
-              node2,
-              typeInfo.getType(),
-              selection.loc.start,
-              parent,
-              checkedFragmentSpreads
-            );
+            const parent = _parent;
+            if (parent.kind === Kind20.FRAGMENT_DEFINITION) {
+              checkedFragmentSpreads.add(parent.name.value);
+            } else if (parent.kind !== Kind20.INLINE_FRAGMENT) {
+              checkSelections(
+                node2,
+                typeInfo.getType(),
+                selection.loc.start,
+                parent,
+                checkedFragmentSpreads
+              );
+            }
           }
         });
         visit8(foundSpread.document, visitor);
       }
     }
     function checkSelections(node, type, loc, parent, checkedFragmentSpreads = /* @__PURE__ */ new Set()) {
-      let rawType = getBaseType(type);
-      if (rawType instanceof GraphQLObjectType || rawType instanceof GraphQLInterfaceType)
+      const rawType = getBaseType(type);
+      if (rawType instanceof GraphQLObjectType || rawType instanceof GraphQLInterfaceType) {
         checkFields(rawType);
-      else if (rawType instanceof GraphQLUnionType)
-        for (let selection of node.selections) {
-          let types = rawType.getTypes();
+      } else if (rawType instanceof GraphQLUnionType) {
+        for (const selection of node.selections) {
+          const types = rawType.getTypes();
           if (selection.kind === Kind20.INLINE_FRAGMENT) {
-            let t = types.find((t2) => t2.name === selection.typeCondition.name.value);
-            t && checkFields(t);
+            const t = types.find((t2) => t2.name === selection.typeCondition.name.value);
+            if (t) {
+              checkFields(t);
+            }
           } else if (selection.kind === Kind20.FRAGMENT_SPREAD) {
-            let [foundSpread] = siblings.getFragment(selection.name.value);
+            const [foundSpread] = siblings.getFragment(selection.name.value);
             if (!foundSpread) return;
-            let fragmentSpread = foundSpread.document, t = fragmentSpread.typeCondition.name.value === rawType.name ? rawType : types.find((t2) => t2.name === fragmentSpread.typeCondition.name.value);
-            checkedFragmentSpreads.add(fragmentSpread.name.value), checkSelections(fragmentSpread.selectionSet, t, loc, parent, checkedFragmentSpreads);
+            const fragmentSpread = foundSpread.document;
+            const t = fragmentSpread.typeCondition.name.value === rawType.name ? rawType : types.find((t2) => t2.name === fragmentSpread.typeCondition.name.value);
+            checkedFragmentSpreads.add(fragmentSpread.name.value);
+            checkSelections(fragmentSpread.selectionSet, t, loc, parent, checkedFragmentSpreads);
           }
         }
+      }
       function checkFields(rawType2) {
-        let fields = rawType2.getFields();
-        if (idNames.some((name) => fields[name]))
-          if (checkFragments(node), requireAllFields)
-            for (let idName of idNames)
-              report([idName]);
-          else
-            report(idNames);
+        const fields = rawType2.getFields();
+        const hasIdFieldInType = idNames.some((name) => fields[name]);
+        if (!hasIdFieldInType) {
+          return;
+        }
+        checkFragments(node);
+        if (requireAllFields) {
+          for (const idName of idNames) {
+            report([idName]);
+          }
+        } else {
+          report(idNames);
+        }
       }
       function report(idNames2) {
         function hasIdField({ selections }) {
           return selections.some((selection) => {
-            if (selection.kind === Kind20.FIELD)
-              return selection.alias && idNames2.includes(selection.alias.value) ? !0 : idNames2.includes(selection.name.value);
-            if (selection.kind === Kind20.INLINE_FRAGMENT)
+            if (selection.kind === Kind20.FIELD) {
+              if (selection.alias && idNames2.includes(selection.alias.value)) {
+                return true;
+              }
+              return idNames2.includes(selection.name.value);
+            }
+            if (selection.kind === Kind20.INLINE_FRAGMENT) {
               return hasIdField(selection.selectionSet);
+            }
             if (selection.kind === Kind20.FRAGMENT_SPREAD) {
-              let [foundSpread] = siblings.getFragment(selection.name.value);
+              const [foundSpread] = siblings.getFragment(selection.name.value);
               if (foundSpread) {
-                let fragmentSpread = foundSpread.document;
-                return checkedFragmentSpreads.add(fragmentSpread.name.value), hasIdField(fragmentSpread.selectionSet);
+                const fragmentSpread = foundSpread.document;
+                checkedFragmentSpreads.add(fragmentSpread.name.value);
+                return hasIdField(fragmentSpread.selectionSet);
               }
             }
-            return !1;
+            return false;
           });
         }
-        if (hasIdField(node))
+        const hasId = hasIdField(node);
+        if (hasId) {
           return;
-        let fieldName2 = englishJoinWords(
+        }
+        const fieldName2 = englishJoinWords(
           idNames2.map((name) => `\`${(parent.alias || parent.name).value}.${name}\``)
-        ), pluralSuffix = idNames2.length > 1 ? "s" : "", addition = checkedFragmentSpreads.size === 0 ? "" : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? "s" : ""} ${englishJoinWords([...checkedFragmentSpreads].map((name) => `\`${name}\``))}`, problem = {
+        );
+        const pluralSuffix = idNames2.length > 1 ? "s" : "";
+        const addition = checkedFragmentSpreads.size === 0 ? "" : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? "s" : ""} ${englishJoinWords([...checkedFragmentSpreads].map((name) => `\`${name}\``))}`;
+        const problem = {
           loc,
           messageId: RULE_ID19,
           data: {
@@ -4721,26 +5538,33 @@ Include it in your selection set{{ addition }}.`
             addition
           }
         };
-        "type" in node && (problem.suggest = idNames2.map((idName) => ({
-          desc: `Add \`${idName}\` selection`,
-          fix: (fixer) => {
-            let insertNode = node.selections[0];
-            return insertNode = insertNode.kind === Kind20.INLINE_FRAGMENT ? insertNode.selectionSet.selections[0] : insertNode, fixer.insertTextBefore(insertNode, `${idName} `);
-          }
-        }))), context.report(problem);
+        if ("type" in node) {
+          problem.suggest = idNames2.map((idName) => ({
+            desc: `Add \`${idName}\` selection`,
+            fix: (fixer) => {
+              let insertNode = node.selections[0];
+              insertNode = insertNode.kind === Kind20.INLINE_FRAGMENT ? insertNode.selectionSet.selections[0] : insertNode;
+              return fixer.insertTextBefore(insertNode, `${idName} `);
+            }
+          }));
+        }
+        context.report(problem);
       }
     }
     return {
       [selector](node) {
-        let typeInfo2 = node.typeInfo();
-        typeInfo2.gqlType && checkSelections(node, typeInfo2.gqlType, node.loc.start, node.parent);
+        const typeInfo2 = node.typeInfo();
+        if (typeInfo2.gqlType) {
+          checkSelections(node, typeInfo2.gqlType, node.loc.start, node.parent);
+        }
       }
     };
   }
 };
 
 // src/rules/require-type-pattern-with-oneof/index.ts
-var RULE_ID20 = "require-type-pattern-with-oneof", rule29 = {
+var RULE_ID20 = "require-type-pattern-with-oneof";
+var rule29 = {
   meta: {
     type: "suggestion",
     docs: {
@@ -4784,16 +5608,19 @@ var RULE_ID20 = "require-type-pattern-with-oneof", rule29 = {
       "Directive[name.value=oneOf][parent.kind=ObjectTypeDefinition]"({
         parent
       }) {
-        let requiredFields = ["error", "ok"];
-        for (let fieldName of requiredFields)
-          parent.fields?.some((field) => field.name.value === fieldName) || context.report({
-            node: parent.name,
-            messageId: RULE_ID20,
-            data: {
-              nodeName: displayNodeName(parent),
-              fieldName
-            }
-          });
+        const requiredFields = ["error", "ok"];
+        for (const fieldName of requiredFields) {
+          if (!parent.fields?.some((field) => field.name.value === fieldName)) {
+            context.report({
+              node: parent.name,
+              messageId: RULE_ID20,
+              data: {
+                nodeName: displayNodeName(parent),
+                fieldName
+              }
+            });
+          }
+        }
       }
     };
   }
@@ -4802,13 +5629,14 @@ var RULE_ID20 = "require-type-pattern-with-oneof", rule29 = {
 // src/rules/selection-set-depth/index.ts
 import { Kind as Kind21 } from "graphql";
 import depthLimit from "graphql-depth-limit";
-var RULE_ID21 = "selection-set-depth", schema14 = {
+var RULE_ID21 = "selection-set-depth";
+var schema14 = {
   type: "array",
   minItems: 1,
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     required: ["maxDepth"],
     properties: {
       maxDepth: {
@@ -4817,15 +5645,16 @@ var RULE_ID21 = "selection-set-depth", schema14 = {
       ignore: ARRAY_DEFAULT_OPTIONS
     }
   }
-}, rule30 = {
+};
+var rule30 = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       category: "Operations",
       description: "Limit the complexity of the GraphQL operations solely by their depth. Based on [graphql-depth-limit](https://npmjs.com/package/graphql-depth-limit).",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID21}`,
-      requiresSiblings: !0,
+      requiresSiblings: true,
       examples: [
         {
           title: "Incorrect",
@@ -4867,7 +5696,7 @@ var RULE_ID21 = "selection-set-depth", schema14 = {
           `
         }
       ],
-      recommended: !0,
+      recommended: true,
       configOptions: [{ maxDepth: 7 }]
     },
     schema: schema14
@@ -4881,18 +5710,23 @@ var RULE_ID21 = "selection-set-depth", schema14 = {
         `Rule "${RULE_ID21}" works best with siblings operations loaded. See https://the-guild.dev/graphql/eslint/docs/usage#providing-operations for more info`
       );
     }
-    let { maxDepth, ignore = [] } = context.options[0], checkFn = depthLimit(maxDepth, { ignore });
+    const { maxDepth, ignore = [] } = context.options[0];
+    const checkFn = depthLimit(maxDepth, { ignore });
     return {
       "OperationDefinition, FragmentDefinition"(node) {
         try {
-          let rawNode = node.rawNode(), fragmentsInUse = siblings ? siblings.getFragmentsInUse(rawNode) : [], document = {
+          const rawNode = node.rawNode();
+          const fragmentsInUse = siblings ? siblings.getFragmentsInUse(rawNode) : [];
+          const document = {
             kind: Kind21.DOCUMENT,
             definitions: [rawNode, ...fragmentsInUse]
           };
           checkFn({
             getDocument: () => document,
             reportError(error) {
-              let { line, column } = error.locations[0], token = context.sourceCode.getAncestors(node)[0].tokens.find(
+              const { line, column } = error.locations[0];
+              const ancestors = context.sourceCode.getAncestors(node);
+              const token = ancestors[0].tokens.find(
                 (token2) => token2.loc.start.line === line && token2.loc.start.column === column - 1
               );
               context.report({
@@ -4907,7 +5741,9 @@ var RULE_ID21 = "selection-set-depth", schema14 = {
                     {
                       desc: "Remove selections",
                       fix(fixer) {
-                        let foundNode = context.getSourceCode().getNodeByRangeIndex(token.range[0]), parentNode = foundNode.parent.parent;
+                        const sourceCode = context.getSourceCode();
+                        const foundNode = sourceCode.getNodeByRangeIndex(token.range[0]);
+                        const parentNode = foundNode.parent.parent;
                         return fixer.remove(
                           foundNode.kind === "Name" ? parentNode.parent : parentNode
                         );
@@ -4931,12 +5767,13 @@ var RULE_ID21 = "selection-set-depth", schema14 = {
 
 // src/rules/strict-id-in-types/index.ts
 import { Kind as Kind22 } from "graphql";
-var RULE_ID22 = "strict-id-in-types", schema15 = {
+var RULE_ID22 = "strict-id-in-types";
+var schema15 = {
   type: "array",
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     properties: {
       acceptedIdNames: {
         ...ARRAY_DEFAULT_OPTIONS,
@@ -4948,7 +5785,7 @@ var RULE_ID22 = "strict-id-in-types", schema15 = {
       },
       exceptions: {
         type: "object",
-        additionalProperties: !1,
+        additionalProperties: false,
         properties: {
           types: {
             ...ARRAY_DEFAULT_OPTIONS,
@@ -4962,15 +5799,16 @@ var RULE_ID22 = "strict-id-in-types", schema15 = {
       }
     }
   }
-}, rule31 = {
+};
+var rule31 = {
   meta: {
     type: "suggestion",
     docs: {
       description: "Requires output types to have one unique identifier unless they do not have a logical one. Exceptions can be used to ignore output types that do not have unique identifiers.",
       category: "Schema",
-      recommended: !0,
+      recommended: true,
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID22}`,
-      requiresSchema: !0,
+      requiresSchema: true,
       examples: [
         {
           title: "Incorrect",
@@ -5042,26 +5880,38 @@ var RULE_ID22 = "strict-id-in-types", schema15 = {
     schema: schema15
   },
   create(context) {
-    let options = {
+    const options = {
       acceptedIdNames: ["id"],
       acceptedIdTypes: ["ID"],
       exceptions: {},
       ...context.options[0]
-    }, schema16 = requireGraphQLSchema(RULE_ID22, context);
+    };
+    const schema16 = requireGraphQLSchema(RULE_ID22, context);
+    const rootTypeNames = [
+      schema16.getQueryType(),
+      schema16.getMutationType(),
+      schema16.getSubscriptionType()
+    ].filter((v) => !!v).map((type) => type.name);
+    const selector = `ObjectTypeDefinition[name.value!=/^(${rootTypeNames.join("|")})$/]`;
     return {
-      [`ObjectTypeDefinition[name.value!=/^(${[
-        schema16.getQueryType(),
-        schema16.getMutationType(),
-        schema16.getSubscriptionType()
-      ].filter((v) => !!v).map((type) => type.name).join("|")})$/]`](node) {
-        let typeName = node.name.value;
-        if (options.exceptions.types?.includes(typeName) || options.exceptions.suffixes?.some((suffix) => typeName.endsWith(suffix)))
+      [selector](node) {
+        const typeName = node.name.value;
+        const shouldIgnoreNode = options.exceptions.types?.includes(typeName) || options.exceptions.suffixes?.some((suffix) => typeName.endsWith(suffix));
+        if (shouldIgnoreNode) {
           return;
-        if (node.fields?.filter((field) => {
-          let fieldNode = field.rawNode(), isValidIdName = options.acceptedIdNames.includes(fieldNode.name.value), isValidIdType = !1;
-          return fieldNode.type.kind === Kind22.NON_NULL_TYPE && fieldNode.type.type.kind === Kind22.NAMED_TYPE && (isValidIdType = options.acceptedIdTypes.includes(fieldNode.type.type.name.value)), isValidIdName && isValidIdType;
-        })?.length !== 1) {
-          let pluralNamesSuffix = options.acceptedIdNames.length > 1 ? "s" : "", pluralTypesSuffix = options.acceptedIdTypes.length > 1 ? "s" : "";
+        }
+        const validIds = node.fields?.filter((field) => {
+          const fieldNode = field.rawNode();
+          const isValidIdName = options.acceptedIdNames.includes(fieldNode.name.value);
+          let isValidIdType = false;
+          if (fieldNode.type.kind === Kind22.NON_NULL_TYPE && fieldNode.type.type.kind === Kind22.NAMED_TYPE) {
+            isValidIdType = options.acceptedIdTypes.includes(fieldNode.type.type.name.value);
+          }
+          return isValidIdName && isValidIdType;
+        });
+        if (validIds?.length !== 1) {
+          const pluralNamesSuffix = options.acceptedIdNames.length > 1 ? "s" : "";
+          const pluralTypesSuffix = options.acceptedIdTypes.length > 1 ? "s" : "";
           context.report({
             node: node.name,
             message: `${displayNodeName(node)} must have exactly one non-nullable unique identifier.
@@ -5079,11 +5929,11 @@ import { Kind as Kind23 } from "graphql";
 var rule32 = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       url: "https://the-guild.dev/graphql/eslint/rules/unique-enum-value-names",
       category: "Schema",
-      recommended: !0,
+      recommended: true,
       description: `A GraphQL enum type is only valid if all its values are uniquely named.
 > This rule disallows case-insensitive enum values duplicates too.`,
       examples: [
@@ -5118,13 +5968,14 @@ var rule32 = {
     schema: []
   },
   create(context) {
+    const selector = [Kind23.ENUM_TYPE_DEFINITION, Kind23.ENUM_TYPE_EXTENSION].join(",");
     return {
-      [[Kind23.ENUM_TYPE_DEFINITION, Kind23.ENUM_TYPE_EXTENSION].join(",")](node) {
-        let duplicates = node.values?.filter(
+      [selector](node) {
+        const duplicates = node.values?.filter(
           (item, index, array) => array.findIndex((v) => v.name.value.toLowerCase() === item.name.value.toLowerCase()) !== index
         );
-        for (let duplicate of duplicates || []) {
-          let enumName = duplicate.name.value;
+        for (const duplicate of duplicates || []) {
+          const enumName = duplicate.name.value;
           context.report({
             node: duplicate.name,
             message: `Unexpected case-insensitive enum values duplicates for ${getNodeName(
@@ -5146,30 +5997,38 @@ var rule32 = {
 // src/rules/unique-fragment-name/index.ts
 import { relative as relative2 } from "node:path";
 import { Kind as Kind24 } from "graphql";
-var RULE_ID23 = "unique-fragment-name", checkNode = (context, node, ruleId) => {
-  let documentName = node.name.value, siblings = requireGraphQLOperations(ruleId, context), siblingDocuments = node.kind === Kind24.FRAGMENT_DEFINITION ? siblings.getFragment(documentName) : siblings.getOperation(documentName), filepath = context.filename, conflictingDocuments = siblingDocuments.filter((f) => {
-    let isSameName = f.document.name?.value === documentName, isSamePath = slash(f.filePath) === slash(filepath);
+var RULE_ID23 = "unique-fragment-name";
+var checkNode = (context, node, ruleId) => {
+  const documentName = node.name.value;
+  const siblings = requireGraphQLOperations(ruleId, context);
+  const siblingDocuments = node.kind === Kind24.FRAGMENT_DEFINITION ? siblings.getFragment(documentName) : siblings.getOperation(documentName);
+  const filepath = context.filename;
+  const conflictingDocuments = siblingDocuments.filter((f) => {
+    const isSameName = f.document.name?.value === documentName;
+    const isSamePath = slash(f.filePath) === slash(filepath);
     return isSameName && !isSamePath;
   });
-  conflictingDocuments.length > 0 && context.report({
-    messageId: ruleId,
-    data: {
-      documentName,
-      summary: conflictingDocuments.map((f) => `	${relative2(CWD, f.filePath.replace(VIRTUAL_DOCUMENT_REGEX, ""))}`).join(`
-`)
-    },
-    // @ts-expect-error name will exist
-    node: node.name
-  });
-}, rule33 = {
+  if (conflictingDocuments.length > 0) {
+    context.report({
+      messageId: ruleId,
+      data: {
+        documentName,
+        summary: conflictingDocuments.map((f) => `	${relative2(CWD, f.filePath.replace(VIRTUAL_DOCUMENT_REGEX, ""))}`).join("\n")
+      },
+      // @ts-expect-error name will exist
+      node: node.name
+    });
+  }
+};
+var rule33 = {
   meta: {
     type: "suggestion",
     docs: {
       category: "Operations",
       description: "Enforce unique fragment names across your project.",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID23}`,
-      requiresSiblings: !0,
-      recommended: !0,
+      requiresSiblings: true,
+      recommended: true,
       examples: [
         {
           title: "Incorrect",
@@ -5212,8 +6071,7 @@ var RULE_ID23 = "unique-fragment-name", checkNode = (context, node, ruleId) => {
       ]
     },
     messages: {
-      [RULE_ID23]: `Fragment named "{{ documentName }}" already defined in:
-{{ summary }}`
+      [RULE_ID23]: 'Fragment named "{{ documentName }}" already defined in:\n{{ summary }}'
     },
     schema: []
   },
@@ -5227,15 +6085,16 @@ var RULE_ID23 = "unique-fragment-name", checkNode = (context, node, ruleId) => {
 };
 
 // src/rules/unique-operation-name/index.ts
-var RULE_ID24 = "unique-operation-name", rule34 = {
+var RULE_ID24 = "unique-operation-name";
+var rule34 = {
   meta: {
     type: "suggestion",
     docs: {
       category: "Operations",
       description: "Enforce unique operation names across your project.",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID24}`,
-      requiresSiblings: !0,
-      recommended: !0,
+      requiresSiblings: true,
+      recommended: true,
       examples: [
         {
           title: "Incorrect",
@@ -5282,8 +6141,7 @@ var RULE_ID24 = "unique-operation-name", rule34 = {
       ]
     },
     messages: {
-      [RULE_ID24]: `Operation named "{{ documentName }}" already defined in:
-{{ summary }}`
+      [RULE_ID24]: 'Operation named "{{ documentName }}" already defined in:\n{{ summary }}'
     },
     schema: []
   },
@@ -5335,227 +6193,21 @@ var rules = {
   "unique-operation-name": rule34
 };
 
-// src/configs/operations-all.ts
-var operations_all_default = {
-  extends: "./configs/operations-recommended",
-  rules: {
-    "@graphql-eslint/alphabetize": [
-      "error",
-      {
-        definitions: !0,
-        selections: ["OperationDefinition", "FragmentDefinition"],
-        variables: !0,
-        arguments: ["Field", "Directive"],
-        groups: ["...", "id", "*", "{"]
-      }
-    ],
-    "@graphql-eslint/lone-executable-definition": "error",
-    "@graphql-eslint/match-document-filename": [
-      "error",
-      {
-        query: "kebab-case",
-        mutation: "kebab-case",
-        subscription: "kebab-case",
-        fragment: "kebab-case"
-      }
-    ],
-    "@graphql-eslint/no-one-place-fragments": "error",
-    "@graphql-eslint/require-import-fragment": "error"
-  }
-};
-
-// src/configs/operations-recommended.ts
-var operations_recommended_default = {
-  parser: "@graphql-eslint/eslint-plugin",
-  plugins: ["@graphql-eslint"],
-  rules: {
-    "@graphql-eslint/executable-definitions": "error",
-    "@graphql-eslint/fields-on-correct-type": "error",
-    "@graphql-eslint/fragments-on-composite-type": "error",
-    "@graphql-eslint/known-argument-names": "error",
-    "@graphql-eslint/known-directives": "error",
-    "@graphql-eslint/known-fragment-names": "error",
-    "@graphql-eslint/known-type-names": "error",
-    "@graphql-eslint/lone-anonymous-operation": "error",
-    "@graphql-eslint/naming-convention": [
-      "error",
-      {
-        VariableDefinition: "camelCase",
-        OperationDefinition: {
-          style: "PascalCase",
-          forbiddenPrefixes: ["Query", "Mutation", "Subscription", "Get"],
-          forbiddenSuffixes: ["Query", "Mutation", "Subscription"]
-        },
-        FragmentDefinition: {
-          style: "PascalCase",
-          forbiddenPrefixes: ["Fragment"],
-          forbiddenSuffixes: ["Fragment"]
-        }
-      }
-    ],
-    "@graphql-eslint/no-anonymous-operations": "error",
-    "@graphql-eslint/no-deprecated": "error",
-    "@graphql-eslint/no-duplicate-fields": "error",
-    "@graphql-eslint/no-fragment-cycles": "error",
-    "@graphql-eslint/no-undefined-variables": "error",
-    "@graphql-eslint/no-unused-fragments": "error",
-    "@graphql-eslint/no-unused-variables": "error",
-    "@graphql-eslint/one-field-subscriptions": "error",
-    "@graphql-eslint/overlapping-fields-can-be-merged": "error",
-    "@graphql-eslint/possible-fragment-spread": "error",
-    "@graphql-eslint/provided-required-arguments": "error",
-    "@graphql-eslint/require-selections": "error",
-    "@graphql-eslint/scalar-leafs": "error",
-    "@graphql-eslint/selection-set-depth": ["error", { maxDepth: 7 }],
-    "@graphql-eslint/unique-argument-names": "error",
-    "@graphql-eslint/unique-directive-names-per-location": "error",
-    "@graphql-eslint/unique-fragment-name": "error",
-    "@graphql-eslint/unique-input-field-names": "error",
-    "@graphql-eslint/unique-operation-name": "error",
-    "@graphql-eslint/unique-variable-names": "error",
-    "@graphql-eslint/value-literals-of-correct-type": "error",
-    "@graphql-eslint/variables-are-input-types": "error",
-    "@graphql-eslint/variables-in-allowed-position": "error"
-  }
-};
-
-// src/configs/schema-all.ts
-var schema_all_default = {
-  extends: "./configs/schema-recommended",
-  rules: {
-    "@graphql-eslint/alphabetize": [
-      "error",
-      {
-        definitions: !0,
-        fields: ["ObjectTypeDefinition", "InterfaceTypeDefinition", "InputObjectTypeDefinition"],
-        values: !0,
-        arguments: ["FieldDefinition", "Field", "DirectiveDefinition", "Directive"],
-        groups: ["id", "*", "createdAt", "updatedAt"]
-      }
-    ],
-    "@graphql-eslint/input-name": "error",
-    "@graphql-eslint/no-root-type": ["error", { disallow: ["mutation", "subscription"] }],
-    "@graphql-eslint/no-scalar-result-type-on-mutation": "error",
-    "@graphql-eslint/require-deprecation-date": "error",
-    "@graphql-eslint/require-field-of-type-query-in-mutation-result": "error",
-    "@graphql-eslint/require-nullable-fields-with-oneof": "error",
-    "@graphql-eslint/require-nullable-result-in-root": "error",
-    "@graphql-eslint/require-type-pattern-with-oneof": "error"
-  }
-};
-
-// src/configs/schema-recommended.ts
-var schema_recommended_default = {
-  parser: "@graphql-eslint/eslint-plugin",
-  plugins: ["@graphql-eslint"],
-  rules: {
-    "@graphql-eslint/description-style": "error",
-    "@graphql-eslint/known-argument-names": "error",
-    "@graphql-eslint/known-directives": "error",
-    "@graphql-eslint/known-type-names": "error",
-    "@graphql-eslint/lone-schema-definition": "error",
-    "@graphql-eslint/naming-convention": [
-      "error",
-      {
-        types: "PascalCase",
-        FieldDefinition: "camelCase",
-        InputValueDefinition: "camelCase",
-        Argument: "camelCase",
-        DirectiveDefinition: "camelCase",
-        EnumValueDefinition: "UPPER_CASE",
-        "FieldDefinition[parent.name.value=Query]": {
-          forbiddenPrefixes: ["query", "get"],
-          forbiddenSuffixes: ["Query"]
-        },
-        "FieldDefinition[parent.name.value=Mutation]": {
-          forbiddenPrefixes: ["mutation"],
-          forbiddenSuffixes: ["Mutation"]
-        },
-        "FieldDefinition[parent.name.value=Subscription]": {
-          forbiddenPrefixes: ["subscription"],
-          forbiddenSuffixes: ["Subscription"]
-        },
-        "EnumTypeDefinition,EnumTypeExtension": {
-          forbiddenPrefixes: ["Enum"],
-          forbiddenSuffixes: ["Enum"]
-        },
-        "InterfaceTypeDefinition,InterfaceTypeExtension": {
-          forbiddenPrefixes: ["Interface"],
-          forbiddenSuffixes: ["Interface"]
-        },
-        "UnionTypeDefinition,UnionTypeExtension": {
-          forbiddenPrefixes: ["Union"],
-          forbiddenSuffixes: ["Union"]
-        },
-        "ObjectTypeDefinition,ObjectTypeExtension": {
-          forbiddenPrefixes: ["Type"],
-          forbiddenSuffixes: ["Type"]
-        }
-      }
-    ],
-    "@graphql-eslint/no-hashtag-description": "error",
-    "@graphql-eslint/no-typename-prefix": "error",
-    "@graphql-eslint/no-unreachable-types": "error",
-    "@graphql-eslint/possible-type-extension": "error",
-    "@graphql-eslint/provided-required-arguments": "error",
-    "@graphql-eslint/require-deprecation-reason": "error",
-    "@graphql-eslint/require-description": [
-      "error",
-      { types: !0, DirectiveDefinition: !0, rootField: !0 }
-    ],
-    "@graphql-eslint/strict-id-in-types": "error",
-    "@graphql-eslint/unique-directive-names": "error",
-    "@graphql-eslint/unique-directive-names-per-location": "error",
-    "@graphql-eslint/unique-enum-value-names": "error",
-    "@graphql-eslint/unique-field-definition-names": "error",
-    "@graphql-eslint/unique-operation-types": "error",
-    "@graphql-eslint/unique-type-names": "error"
-  }
-};
-
-// src/configs/schema-relay.ts
-var schema_relay_default = {
-  parser: "@graphql-eslint/eslint-plugin",
-  plugins: ["@graphql-eslint"],
-  rules: {
-    "@graphql-eslint/relay-arguments": "error",
-    "@graphql-eslint/relay-connection-types": "error",
-    "@graphql-eslint/relay-edge-types": "error",
-    "@graphql-eslint/relay-page-info": "error"
-  }
-};
-
-// src/configs/index.ts
-var configs = {
-  "schema-recommended": schema_recommended_default,
-  "schema-all": schema_all_default,
-  "schema-relay": schema_relay_default,
-  "operations-recommended": operations_recommended_default,
-  "operations-all": operations_all_default,
-  "flat/schema-recommended": {
-    rules: schema_recommended_default.rules
-  },
-  "flat/schema-all": {
-    rules: {
-      ...schema_recommended_default.rules,
-      ...schema_all_default.rules
-    }
-  },
-  "flat/schema-relay": {
-    rules: schema_relay_default.rules
-  },
-  "flat/operations-recommended": {
-    rules: operations_recommended_default.rules
-  },
-  "flat/operations-all": {
-    rules: {
-      ...operations_recommended_default.rules,
-      ...operations_all_default.rules
-    }
-  }
+// src/index.ts
+var processors = { graphql: processor };
+var src_default = {
+  parser,
+  processor,
+  rules,
+  configs
 };
 export {
   configs,
+  src_default as default,
+  parseForESLint,
   parser,
+  processors,
+  requireGraphQLOperations,
+  requireGraphQLSchema,
   rules
 };