graphql 17.0.0-beta.0 → 17.0.0-beta.1

package/language/parser.js

@@ -6,14 +6,14 @@ exports.parseValue = parseValue;
 exports.parseConstValue = parseConstValue;
 exports.parseType = parseType;
 exports.parseSchemaCoordinate = parseSchemaCoordinate;
-const syntaxError_js_1 = require("../error/syntaxError.js");
-const ast_js_1 = require("./ast.js");
-const directiveLocation_js_1 = require("./directiveLocation.js");
-const kinds_js_1 = require("./kinds.js");
-const lexer_js_1 = require("./lexer.js");
-const schemaCoordinateLexer_js_1 = require("./schemaCoordinateLexer.js");
-const source_js_1 = require("./source.js");
-const tokenKind_js_1 = require("./tokenKind.js");
+const syntaxError_ts_1 = require("../error/syntaxError.js");
+const ast_ts_1 = require("./ast.js");
+const directiveLocation_ts_1 = require("./directiveLocation.js");
+const kinds_ts_1 = require("./kinds.js");
+const lexer_ts_1 = require("./lexer.js");
+const schemaCoordinateLexer_ts_1 = require("./schemaCoordinateLexer.js");
+const source_ts_1 = require("./source.js");
+const tokenKind_ts_1 = require("./tokenKind.js");
 /**
  * Given a GraphQL source, parses it into a Document.
  * Throws GraphQLError if a syntax error is encountered.
@@ -37,9 +37,9 @@ function parse(source, options) {
  */
 function parseValue(source, options) {
     const parser = new Parser(source, options);
-    parser.expectToken(tokenKind_js_1.TokenKind.SOF);
+    parser.expectToken(tokenKind_ts_1.TokenKind.SOF);
     const value = parser.parseValueLiteral(false);
-    parser.expectToken(tokenKind_js_1.TokenKind.EOF);
+    parser.expectToken(tokenKind_ts_1.TokenKind.EOF);
     return value;
 }
 /**
@@ -48,9 +48,9 @@ function parseValue(source, options) {
  */
 function parseConstValue(source, options) {
     const parser = new Parser(source, options);
-    parser.expectToken(tokenKind_js_1.TokenKind.SOF);
+    parser.expectToken(tokenKind_ts_1.TokenKind.SOF);
     const value = parser.parseConstValueLiteral();
-    parser.expectToken(tokenKind_js_1.TokenKind.EOF);
+    parser.expectToken(tokenKind_ts_1.TokenKind.EOF);
     return value;
 }
 /**
@@ -65,9 +65,9 @@ function parseConstValue(source, options) {
  */
 function parseType(source, options) {
     const parser = new Parser(source, options);
-    parser.expectToken(tokenKind_js_1.TokenKind.SOF);
+    parser.expectToken(tokenKind_ts_1.TokenKind.SOF);
     const type = parser.parseTypeReference();
-    parser.expectToken(tokenKind_js_1.TokenKind.EOF);
+    parser.expectToken(tokenKind_ts_1.TokenKind.EOF);
     return type;
 }
 /**
@@ -80,12 +80,12 @@ function parseType(source, options) {
  * with an unparsed source.
  */
 function parseSchemaCoordinate(source) {
-    const sourceObj = (0, source_js_1.isSource)(source) ? source : new source_js_1.Source(source);
-    const lexer = new schemaCoordinateLexer_js_1.SchemaCoordinateLexer(sourceObj);
+    const sourceObj = (0, source_ts_1.isSource)(source) ? source : new source_ts_1.Source(source);
+    const lexer = new schemaCoordinateLexer_ts_1.SchemaCoordinateLexer(sourceObj);
     const parser = new Parser(source, { lexer });
-    parser.expectToken(tokenKind_js_1.TokenKind.SOF);
+    parser.expectToken(tokenKind_ts_1.TokenKind.SOF);
     const coordinate = parser.parseSchemaCoordinate();
-    parser.expectToken(tokenKind_js_1.TokenKind.EOF);
+    parser.expectToken(tokenKind_ts_1.TokenKind.EOF);
     return coordinate;
 }
 /**
@@ -106,8 +106,8 @@ class Parser {
             this._lexer = lexer;
         }
         else {
-            const sourceObj = (0, source_js_1.isSource)(source) ? source : new source_js_1.Source(source);
-            this._lexer = new lexer_js_1.Lexer(sourceObj);
+            const sourceObj = (0, source_ts_1.isSource)(source) ? source : new source_ts_1.Source(source);
+            this._lexer = new lexer_ts_1.Lexer(sourceObj);
         }
         this._options = _options;
         this._tokenCounter = 0;
@@ -119,9 +119,9 @@ class Parser {
      * Converts a name lex token into a name parse node.
      */
     parseName() {
-        const token = this.expectToken(tokenKind_js_1.TokenKind.NAME);
+        const token = this.expectToken(tokenKind_ts_1.TokenKind.NAME);
         return this.node(token, {
-            kind: kinds_js_1.Kind.NAME,
+            kind: kinds_ts_1.Kind.NAME,
             value: token.value,
         });
     }
@@ -131,8 +131,8 @@ class Parser {
      */
     parseDocument() {
         return this.node(this._lexer.token, {
-            kind: kinds_js_1.Kind.DOCUMENT,
-            definitions: this.many(tokenKind_js_1.TokenKind.SOF, this.parseDefinition, tokenKind_js_1.TokenKind.EOF),
+            kind: kinds_ts_1.Kind.DOCUMENT,
+            definitions: this.many(tokenKind_ts_1.TokenKind.SOF, this.parseDefinition, tokenKind_ts_1.TokenKind.EOF),
         });
     }
     /**
@@ -159,7 +159,7 @@ class Parser {
      *   - InputObjectTypeDefinition
      */
     parseDefinition() {
-        if (this.peek(tokenKind_js_1.TokenKind.BRACE_L)) {
+        if (this.peek(tokenKind_ts_1.TokenKind.BRACE_L)) {
             return this.parseOperationDefinition();
         }
         // Many definitions begin with a description and require a lookahead.
@@ -167,10 +167,10 @@ class Parser {
         const keywordToken = hasDescription
             ? this._lexer.lookahead()
             : this._lexer.token;
-        if (hasDescription && keywordToken.kind === tokenKind_js_1.TokenKind.BRACE_L) {
-            throw (0, syntaxError_js_1.syntaxError)(this._lexer.source, this._lexer.token.start, 'Unexpected description, descriptions are not supported on shorthand queries.');
+        if (hasDescription && keywordToken.kind === tokenKind_ts_1.TokenKind.BRACE_L) {
+            throw (0, syntaxError_ts_1.syntaxError)(this._lexer.source, this._lexer.token.start, 'Unexpected description, descriptions are not supported on shorthand queries.');
         }
-        if (keywordToken.kind === tokenKind_js_1.TokenKind.NAME) {
+        if (keywordToken.kind === tokenKind_ts_1.TokenKind.NAME) {
             switch (keywordToken.value) {
                 case 'schema':
                     return this.parseSchemaDefinition();
@@ -198,7 +198,7 @@ class Parser {
                     return this.parseFragmentDefinition();
             }
             if (hasDescription) {
-                throw (0, syntaxError_js_1.syntaxError)(this._lexer.source, this._lexer.token.start, 'Unexpected description, only GraphQL definitions support descriptions.');
+                throw (0, syntaxError_ts_1.syntaxError)(this._lexer.source, this._lexer.token.start, 'Unexpected description, only GraphQL definitions support descriptions.');
             }
             switch (keywordToken.value) {
                 case 'extend':
@@ -215,10 +215,10 @@ class Parser {
      */
     parseOperationDefinition() {
         const start = this._lexer.token;
-        if (this.peek(tokenKind_js_1.TokenKind.BRACE_L)) {
+        if (this.peek(tokenKind_ts_1.TokenKind.BRACE_L)) {
             return this.node(start, {
-                kind: kinds_js_1.Kind.OPERATION_DEFINITION,
-                operation: ast_js_1.OperationTypeNode.QUERY,
+                kind: kinds_ts_1.Kind.OPERATION_DEFINITION,
+                operation: ast_ts_1.OperationTypeNode.QUERY,
                 description: undefined,
                 name: undefined,
                 variableDefinitions: undefined,
@@ -229,11 +229,11 @@ class Parser {
         const description = this.parseDescription();
         const operation = this.parseOperationType();
         let name;
-        if (this.peek(tokenKind_js_1.TokenKind.NAME)) {
+        if (this.peek(tokenKind_ts_1.TokenKind.NAME)) {
             name = this.parseName();
         }
         return this.node(start, {
-            kind: kinds_js_1.Kind.OPERATION_DEFINITION,
+            kind: kinds_ts_1.Kind.OPERATION_DEFINITION,
             operation,
             description,
             name,
@@ -246,14 +246,14 @@ class Parser {
      * OperationType : one of query mutation subscription
      */
     parseOperationType() {
-        const operationToken = this.expectToken(tokenKind_js_1.TokenKind.NAME);
+        const operationToken = this.expectToken(tokenKind_ts_1.TokenKind.NAME);
         switch (operationToken.value) {
             case 'query':
-                return ast_js_1.OperationTypeNode.QUERY;
+                return ast_ts_1.OperationTypeNode.QUERY;
             case 'mutation':
-                return ast_js_1.OperationTypeNode.MUTATION;
+                return ast_ts_1.OperationTypeNode.MUTATION;
             case 'subscription':
-                return ast_js_1.OperationTypeNode.SUBSCRIPTION;
+                return ast_ts_1.OperationTypeNode.SUBSCRIPTION;
         }
         throw this.unexpected(operationToken);
     }
@@ -261,18 +261,18 @@ class Parser {
      * VariableDefinitions : ( VariableDefinition+ )
      */
     parseVariableDefinitions() {
-        return this.optionalMany(tokenKind_js_1.TokenKind.PAREN_L, this.parseVariableDefinition, tokenKind_js_1.TokenKind.PAREN_R);
+        return this.optionalMany(tokenKind_ts_1.TokenKind.PAREN_L, this.parseVariableDefinition, tokenKind_ts_1.TokenKind.PAREN_R);
     }
     /**
      * VariableDefinition : Variable : Type DefaultValue? Directives[Const]?
      */
     parseVariableDefinition() {
         return this.node(this._lexer.token, {
-            kind: kinds_js_1.Kind.VARIABLE_DEFINITION,
+            kind: kinds_ts_1.Kind.VARIABLE_DEFINITION,
             description: this.parseDescription(),
             variable: this.parseVariable(),
-            type: (this.expectToken(tokenKind_js_1.TokenKind.COLON), this.parseTypeReference()),
-            defaultValue: this.expectOptionalToken(tokenKind_js_1.TokenKind.EQUALS)
+            type: (this.expectToken(tokenKind_ts_1.TokenKind.COLON), this.parseTypeReference()),
+            defaultValue: this.expectOptionalToken(tokenKind_ts_1.TokenKind.EQUALS)
                 ? this.parseConstValueLiteral()
                 : undefined,
             directives: this.parseConstDirectives(),
@@ -283,9 +283,9 @@ class Parser {
      */
     parseVariable() {
         const start = this._lexer.token;
-        this.expectToken(tokenKind_js_1.TokenKind.DOLLAR);
+        this.expectToken(tokenKind_ts_1.TokenKind.DOLLAR);
         return this.node(start, {
-            kind: kinds_js_1.Kind.VARIABLE,
+            kind: kinds_ts_1.Kind.VARIABLE,
             name: this.parseName(),
         });
     }
@@ -296,8 +296,8 @@ class Parser {
      */
     parseSelectionSet() {
         return this.node(this._lexer.token, {
-            kind: kinds_js_1.Kind.SELECTION_SET,
-            selections: this.many(tokenKind_js_1.TokenKind.BRACE_L, this.parseSelection, tokenKind_js_1.TokenKind.BRACE_R),
+            kind: kinds_ts_1.Kind.SELECTION_SET,
+            selections: this.many(tokenKind_ts_1.TokenKind.BRACE_L, this.parseSelection, tokenKind_ts_1.TokenKind.BRACE_R),
         });
     }
     /**
@@ -307,7 +307,7 @@ class Parser {
      *   - InlineFragment
      */
     parseSelection() {
-        return this.peek(tokenKind_js_1.TokenKind.SPREAD)
+        return this.peek(tokenKind_ts_1.TokenKind.SPREAD)
             ? this.parseFragment()
             : this.parseField();
     }
@@ -321,7 +321,7 @@ class Parser {
         const nameOrAlias = this.parseName();
         let alias;
         let name;
-        if (this.expectOptionalToken(tokenKind_js_1.TokenKind.COLON)) {
+        if (this.expectOptionalToken(tokenKind_ts_1.TokenKind.COLON)) {
             alias = nameOrAlias;
             name = this.parseName();
         }
@@ -329,31 +329,31 @@ class Parser {
             name = nameOrAlias;
         }
         return this.node(start, {
-            kind: kinds_js_1.Kind.FIELD,
+            kind: kinds_ts_1.Kind.FIELD,
             alias,
             name,
             arguments: this.parseArguments(false),
             directives: this.parseDirectives(false),
-            selectionSet: this.peek(tokenKind_js_1.TokenKind.BRACE_L)
+            selectionSet: this.peek(tokenKind_ts_1.TokenKind.BRACE_L)
                 ? this.parseSelectionSet()
                 : undefined,
         });
     }
     parseArguments(isConst) {
         const item = isConst ? this.parseConstArgument : this.parseArgument;
-        return this.optionalMany(tokenKind_js_1.TokenKind.PAREN_L, item, tokenKind_js_1.TokenKind.PAREN_R);
+        return this.optionalMany(tokenKind_ts_1.TokenKind.PAREN_L, item, tokenKind_ts_1.TokenKind.PAREN_R);
     }
     /* experimental */
     parseFragmentArguments() {
         const item = this.parseFragmentArgument;
-        return this.optionalMany(tokenKind_js_1.TokenKind.PAREN_L, item, tokenKind_js_1.TokenKind.PAREN_R);
+        return this.optionalMany(tokenKind_ts_1.TokenKind.PAREN_L, item, tokenKind_ts_1.TokenKind.PAREN_R);
     }
     parseArgument(isConst = false) {
         const start = this._lexer.token;
         const name = this.parseName();
-        this.expectToken(tokenKind_js_1.TokenKind.COLON);
+        this.expectToken(tokenKind_ts_1.TokenKind.COLON);
         return this.node(start, {
-            kind: kinds_js_1.Kind.ARGUMENT,
+            kind: kinds_ts_1.Kind.ARGUMENT,
             name,
             value: this.parseValueLiteral(isConst),
         });
@@ -365,9 +365,9 @@ class Parser {
     parseFragmentArgument() {
         const start = this._lexer.token;
         const name = this.parseName();
-        this.expectToken(tokenKind_js_1.TokenKind.COLON);
+        this.expectToken(tokenKind_ts_1.TokenKind.COLON);
         return this.node(start, {
-            kind: kinds_js_1.Kind.FRAGMENT_ARGUMENT,
+            kind: kinds_ts_1.Kind.FRAGMENT_ARGUMENT,
             name,
             value: this.parseValueLiteral(false),
         });
@@ -382,27 +382,27 @@ class Parser {
      */
     parseFragment() {
         const start = this._lexer.token;
-        this.expectToken(tokenKind_js_1.TokenKind.SPREAD);
+        this.expectToken(tokenKind_ts_1.TokenKind.SPREAD);
         const hasTypeCondition = this.expectOptionalKeyword('on');
-        if (!hasTypeCondition && this.peek(tokenKind_js_1.TokenKind.NAME)) {
+        if (!hasTypeCondition && this.peek(tokenKind_ts_1.TokenKind.NAME)) {
             const name = this.parseFragmentName();
-            if (this.peek(tokenKind_js_1.TokenKind.PAREN_L) &&
+            if (this.peek(tokenKind_ts_1.TokenKind.PAREN_L) &&
                 this._options.experimentalFragmentArguments) {
                 return this.node(start, {
-                    kind: kinds_js_1.Kind.FRAGMENT_SPREAD,
+                    kind: kinds_ts_1.Kind.FRAGMENT_SPREAD,
                     name,
                     arguments: this.parseFragmentArguments(),
                     directives: this.parseDirectives(false),
                 });
             }
             return this.node(start, {
-                kind: kinds_js_1.Kind.FRAGMENT_SPREAD,
+                kind: kinds_ts_1.Kind.FRAGMENT_SPREAD,
                 name,
                 directives: this.parseDirectives(false),
             });
         }
         return this.node(start, {
-            kind: kinds_js_1.Kind.INLINE_FRAGMENT,
+            kind: kinds_ts_1.Kind.INLINE_FRAGMENT,
             typeCondition: hasTypeCondition ? this.parseNamedType() : undefined,
             directives: this.parseDirectives(false),
             selectionSet: this.parseSelectionSet(),
@@ -420,7 +420,7 @@ class Parser {
         this.expectKeyword('fragment');
         if (this._options.experimentalFragmentArguments === true) {
             return this.node(start, {
-                kind: kinds_js_1.Kind.FRAGMENT_DEFINITION,
+                kind: kinds_ts_1.Kind.FRAGMENT_DEFINITION,
                 description,
                 name: this.parseFragmentName(),
                 variableDefinitions: this.parseVariableDefinitions(),
@@ -430,7 +430,7 @@ class Parser {
             });
         }
         return this.node(start, {
-            kind: kinds_js_1.Kind.FRAGMENT_DEFINITION,
+            kind: kinds_ts_1.Kind.FRAGMENT_DEFINITION,
             description,
             name: this.parseFragmentName(),
             typeCondition: (this.expectKeyword('on'), this.parseNamedType()),
@@ -450,52 +450,52 @@ class Parser {
     parseValueLiteral(isConst) {
         const token = this._lexer.token;
         switch (token.kind) {
-            case tokenKind_js_1.TokenKind.BRACKET_L:
+            case tokenKind_ts_1.TokenKind.BRACKET_L:
                 return this.parseList(isConst);
-            case tokenKind_js_1.TokenKind.BRACE_L:
+            case tokenKind_ts_1.TokenKind.BRACE_L:
                 return this.parseObject(isConst);
-            case tokenKind_js_1.TokenKind.INT:
+            case tokenKind_ts_1.TokenKind.INT:
                 this.advanceLexer();
                 return this.node(token, {
-                    kind: kinds_js_1.Kind.INT,
+                    kind: kinds_ts_1.Kind.INT,
                     value: token.value,
                 });
-            case tokenKind_js_1.TokenKind.FLOAT:
+            case tokenKind_ts_1.TokenKind.FLOAT:
                 this.advanceLexer();
                 return this.node(token, {
-                    kind: kinds_js_1.Kind.FLOAT,
+                    kind: kinds_ts_1.Kind.FLOAT,
                     value: token.value,
                 });
-            case tokenKind_js_1.TokenKind.STRING:
-            case tokenKind_js_1.TokenKind.BLOCK_STRING:
+            case tokenKind_ts_1.TokenKind.STRING:
+            case tokenKind_ts_1.TokenKind.BLOCK_STRING:
                 return this.parseStringLiteral();
-            case tokenKind_js_1.TokenKind.NAME:
+            case tokenKind_ts_1.TokenKind.NAME:
                 this.advanceLexer();
                 switch (token.value) {
                     case 'true':
                         return this.node(token, {
-                            kind: kinds_js_1.Kind.BOOLEAN,
+                            kind: kinds_ts_1.Kind.BOOLEAN,
                             value: true,
                         });
                     case 'false':
                         return this.node(token, {
-                            kind: kinds_js_1.Kind.BOOLEAN,
+                            kind: kinds_ts_1.Kind.BOOLEAN,
                             value: false,
                         });
                     case 'null':
-                        return this.node(token, { kind: kinds_js_1.Kind.NULL });
+                        return this.node(token, { kind: kinds_ts_1.Kind.NULL });
                     default:
                         return this.node(token, {
-                            kind: kinds_js_1.Kind.ENUM,
+                            kind: kinds_ts_1.Kind.ENUM,
                             value: token.value,
                         });
                 }
-            case tokenKind_js_1.TokenKind.DOLLAR:
+            case tokenKind_ts_1.TokenKind.DOLLAR:
                 if (isConst) {
-                    this.expectToken(tokenKind_js_1.TokenKind.DOLLAR);
-                    if (this._lexer.token.kind === tokenKind_js_1.TokenKind.NAME) {
+                    this.expectToken(tokenKind_ts_1.TokenKind.DOLLAR);
+                    if (this._lexer.token.kind === tokenKind_ts_1.TokenKind.NAME) {
                         const varName = this._lexer.token.value;
-                        throw (0, syntaxError_js_1.syntaxError)(this._lexer.source, token.start, `Unexpected variable "$${varName}" in constant value.`);
+                        throw (0, syntaxError_ts_1.syntaxError)(this._lexer.source, token.start, `Unexpected variable "$${varName}" in constant value.`);
                     }
                     else {
                         throw this.unexpected(token);
@@ -513,38 +513,38 @@ class Parser {
         const token = this._lexer.token;
         this.advanceLexer();
         return this.node(token, {
-            kind: kinds_js_1.Kind.STRING,
+            kind: kinds_ts_1.Kind.STRING,
             value: token.value,
-            block: token.kind === tokenKind_js_1.TokenKind.BLOCK_STRING,
+            block: token.kind === tokenKind_ts_1.TokenKind.BLOCK_STRING,
         });
     }
     parseList(isConst) {
         const item = () => this.parseValueLiteral(isConst);
         return this.node(this._lexer.token, {
-            kind: kinds_js_1.Kind.LIST,
-            values: this.any(tokenKind_js_1.TokenKind.BRACKET_L, item, tokenKind_js_1.TokenKind.BRACKET_R),
+            kind: kinds_ts_1.Kind.LIST,
+            values: this.any(tokenKind_ts_1.TokenKind.BRACKET_L, item, tokenKind_ts_1.TokenKind.BRACKET_R),
         });
     }
     parseObject(isConst) {
         const item = () => this.parseObjectField(isConst);
         return this.node(this._lexer.token, {
-            kind: kinds_js_1.Kind.OBJECT,
-            fields: this.any(tokenKind_js_1.TokenKind.BRACE_L, item, tokenKind_js_1.TokenKind.BRACE_R),
+            kind: kinds_ts_1.Kind.OBJECT,
+            fields: this.any(tokenKind_ts_1.TokenKind.BRACE_L, item, tokenKind_ts_1.TokenKind.BRACE_R),
         });
     }
     parseObjectField(isConst) {
         const start = this._lexer.token;
         const name = this.parseName();
-        this.expectToken(tokenKind_js_1.TokenKind.COLON);
+        this.expectToken(tokenKind_ts_1.TokenKind.COLON);
         return this.node(start, {
-            kind: kinds_js_1.Kind.OBJECT_FIELD,
+            kind: kinds_ts_1.Kind.OBJECT_FIELD,
             name,
             value: this.parseValueLiteral(isConst),
         });
     }
     parseDirectives(isConst) {
         const directives = [];
-        while (this.peek(tokenKind_js_1.TokenKind.AT)) {
+        while (this.peek(tokenKind_ts_1.TokenKind.AT)) {
             directives.push(this.parseDirective(isConst));
         }
         if (directives.length) {
@@ -557,9 +557,9 @@ class Parser {
     }
     parseDirective(isConst) {
         const start = this._lexer.token;
-        this.expectToken(tokenKind_js_1.TokenKind.AT);
+        this.expectToken(tokenKind_ts_1.TokenKind.AT);
         return this.node(start, {
-            kind: kinds_js_1.Kind.DIRECTIVE,
+            kind: kinds_ts_1.Kind.DIRECTIVE,
             name: this.parseName(),
             arguments: this.parseArguments(isConst),
         });
@@ -574,20 +574,20 @@ class Parser {
     parseTypeReference() {
         const start = this._lexer.token;
         let type;
-        if (this.expectOptionalToken(tokenKind_js_1.TokenKind.BRACKET_L)) {
+        if (this.expectOptionalToken(tokenKind_ts_1.TokenKind.BRACKET_L)) {
             const innerType = this.parseTypeReference();
-            this.expectToken(tokenKind_js_1.TokenKind.BRACKET_R);
+            this.expectToken(tokenKind_ts_1.TokenKind.BRACKET_R);
             type = this.node(start, {
-                kind: kinds_js_1.Kind.LIST_TYPE,
+                kind: kinds_ts_1.Kind.LIST_TYPE,
                 type: innerType,
             });
         }
         else {
             type = this.parseNamedType();
         }
-        if (this.expectOptionalToken(tokenKind_js_1.TokenKind.BANG)) {
+        if (this.expectOptionalToken(tokenKind_ts_1.TokenKind.BANG)) {
             return this.node(start, {
-                kind: kinds_js_1.Kind.NON_NULL_TYPE,
+                kind: kinds_ts_1.Kind.NON_NULL_TYPE,
                 type,
             });
         }
@@ -598,13 +598,13 @@ class Parser {
      */
     parseNamedType() {
         return this.node(this._lexer.token, {
-            kind: kinds_js_1.Kind.NAMED_TYPE,
+            kind: kinds_ts_1.Kind.NAMED_TYPE,
             name: this.parseName(),
         });
     }
     // Implements the parsing rules in the Type Definition section.
     peekDescription() {
-        return this.peek(tokenKind_js_1.TokenKind.STRING) || this.peek(tokenKind_js_1.TokenKind.BLOCK_STRING);
+        return this.peek(tokenKind_ts_1.TokenKind.STRING) || this.peek(tokenKind_ts_1.TokenKind.BLOCK_STRING);
     }
     /**
      * Description : StringValue
@@ -624,9 +624,9 @@ class Parser {
         const description = this.parseDescription();
         this.expectKeyword('schema');
         const directives = this.parseConstDirectives();
-        const operationTypes = this.many(tokenKind_js_1.TokenKind.BRACE_L, this.parseOperationTypeDefinition, tokenKind_js_1.TokenKind.BRACE_R);
+        const operationTypes = this.many(tokenKind_ts_1.TokenKind.BRACE_L, this.parseOperationTypeDefinition, tokenKind_ts_1.TokenKind.BRACE_R);
         return this.node(start, {
-            kind: kinds_js_1.Kind.SCHEMA_DEFINITION,
+            kind: kinds_ts_1.Kind.SCHEMA_DEFINITION,
             description,
             directives,
             operationTypes,
@@ -638,10 +638,10 @@ class Parser {
     parseOperationTypeDefinition() {
         const start = this._lexer.token;
         const operation = this.parseOperationType();
-        this.expectToken(tokenKind_js_1.TokenKind.COLON);
+        this.expectToken(tokenKind_ts_1.TokenKind.COLON);
         const type = this.parseNamedType();
         return this.node(start, {
-            kind: kinds_js_1.Kind.OPERATION_TYPE_DEFINITION,
+            kind: kinds_ts_1.Kind.OPERATION_TYPE_DEFINITION,
             operation,
             type,
         });
@@ -656,7 +656,7 @@ class Parser {
         const name = this.parseName();
         const directives = this.parseConstDirectives();
         return this.node(start, {
-            kind: kinds_js_1.Kind.SCALAR_TYPE_DEFINITION,
+            kind: kinds_ts_1.Kind.SCALAR_TYPE_DEFINITION,
             description,
             name,
             directives,
@@ -676,7 +676,7 @@ class Parser {
         const directives = this.parseConstDirectives();
         const fields = this.parseFieldsDefinition();
         return this.node(start, {
-            kind: kinds_js_1.Kind.OBJECT_TYPE_DEFINITION,
+            kind: kinds_ts_1.Kind.OBJECT_TYPE_DEFINITION,
             description,
             name,
             interfaces,
@@ -691,7 +691,7 @@ class Parser {
      */
     parseImplementsInterfaces() {
         return this.expectOptionalKeyword('implements')
-            ? this.delimitedMany(tokenKind_js_1.TokenKind.AMP, this.parseNamedType)
+            ? this.delimitedMany(tokenKind_ts_1.TokenKind.AMP, this.parseNamedType)
             : undefined;
     }
     /**
@@ -700,7 +700,7 @@ class Parser {
      * ```
      */
     parseFieldsDefinition() {
-        return this.optionalMany(tokenKind_js_1.TokenKind.BRACE_L, this.parseFieldDefinition, tokenKind_js_1.TokenKind.BRACE_R);
+        return this.optionalMany(tokenKind_ts_1.TokenKind.BRACE_L, this.parseFieldDefinition, tokenKind_ts_1.TokenKind.BRACE_R);
     }
     /**
      * FieldDefinition :
@@ -711,11 +711,11 @@ class Parser {
         const description = this.parseDescription();
         const name = this.parseName();
         const args = this.parseArgumentDefs();
-        this.expectToken(tokenKind_js_1.TokenKind.COLON);
+        this.expectToken(tokenKind_ts_1.TokenKind.COLON);
         const type = this.parseTypeReference();
         const directives = this.parseConstDirectives();
         return this.node(start, {
-            kind: kinds_js_1.Kind.FIELD_DEFINITION,
+            kind: kinds_ts_1.Kind.FIELD_DEFINITION,
             description,
             name,
             arguments: args,
@@ -727,7 +727,7 @@ class Parser {
      * ArgumentsDefinition : ( InputValueDefinition+ )
      */
     parseArgumentDefs() {
-        return this.optionalMany(tokenKind_js_1.TokenKind.PAREN_L, this.parseInputValueDef, tokenKind_js_1.TokenKind.PAREN_R);
+        return this.optionalMany(tokenKind_ts_1.TokenKind.PAREN_L, this.parseInputValueDef, tokenKind_ts_1.TokenKind.PAREN_R);
     }
     /**
      * InputValueDefinition :
@@ -737,15 +737,15 @@ class Parser {
         const start = this._lexer.token;
         const description = this.parseDescription();
         const name = this.parseName();
-        this.expectToken(tokenKind_js_1.TokenKind.COLON);
+        this.expectToken(tokenKind_ts_1.TokenKind.COLON);
         const type = this.parseTypeReference();
         let defaultValue;
-        if (this.expectOptionalToken(tokenKind_js_1.TokenKind.EQUALS)) {
+        if (this.expectOptionalToken(tokenKind_ts_1.TokenKind.EQUALS)) {
             defaultValue = this.parseConstValueLiteral();
         }
         const directives = this.parseConstDirectives();
         return this.node(start, {
-            kind: kinds_js_1.Kind.INPUT_VALUE_DEFINITION,
+            kind: kinds_ts_1.Kind.INPUT_VALUE_DEFINITION,
             description,
             name,
             type,
@@ -766,7 +766,7 @@ class Parser {
         const directives = this.parseConstDirectives();
         const fields = this.parseFieldsDefinition();
         return this.node(start, {
-            kind: kinds_js_1.Kind.INTERFACE_TYPE_DEFINITION,
+            kind: kinds_ts_1.Kind.INTERFACE_TYPE_DEFINITION,
             description,
             name,
             interfaces,
@@ -786,7 +786,7 @@ class Parser {
         const directives = this.parseConstDirectives();
         const types = this.parseUnionMemberTypes();
         return this.node(start, {
-            kind: kinds_js_1.Kind.UNION_TYPE_DEFINITION,
+            kind: kinds_ts_1.Kind.UNION_TYPE_DEFINITION,
             description,
             name,
             directives,
@@ -799,8 +799,8 @@ class Parser {
      *   - UnionMemberTypes | NamedType
      */
     parseUnionMemberTypes() {
-        return this.expectOptionalToken(tokenKind_js_1.TokenKind.EQUALS)
-            ? this.delimitedMany(tokenKind_js_1.TokenKind.PIPE, this.parseNamedType)
+        return this.expectOptionalToken(tokenKind_ts_1.TokenKind.EQUALS)
+            ? this.delimitedMany(tokenKind_ts_1.TokenKind.PIPE, this.parseNamedType)
             : undefined;
     }
     /**
@@ -815,7 +815,7 @@ class Parser {
         const directives = this.parseConstDirectives();
         const values = this.parseEnumValuesDefinition();
         return this.node(start, {
-            kind: kinds_js_1.Kind.ENUM_TYPE_DEFINITION,
+            kind: kinds_ts_1.Kind.ENUM_TYPE_DEFINITION,
             description,
             name,
             directives,
@@ -828,7 +828,7 @@ class Parser {
      * ```
      */
     parseEnumValuesDefinition() {
-        return this.optionalMany(tokenKind_js_1.TokenKind.BRACE_L, this.parseEnumValueDefinition, tokenKind_js_1.TokenKind.BRACE_R);
+        return this.optionalMany(tokenKind_ts_1.TokenKind.BRACE_L, this.parseEnumValueDefinition, tokenKind_ts_1.TokenKind.BRACE_R);
     }
     /**
      * EnumValueDefinition : Description? EnumValue Directives[Const]?
@@ -839,7 +839,7 @@ class Parser {
         const name = this.parseEnumValueName();
         const directives = this.parseConstDirectives();
         return this.node(start, {
-            kind: kinds_js_1.Kind.ENUM_VALUE_DEFINITION,
+            kind: kinds_ts_1.Kind.ENUM_VALUE_DEFINITION,
             description,
             name,
             directives,
@@ -852,7 +852,7 @@ class Parser {
         if (this._lexer.token.value === 'true' ||
             this._lexer.token.value === 'false' ||
             this._lexer.token.value === 'null') {
-            throw (0, syntaxError_js_1.syntaxError)(this._lexer.source, this._lexer.token.start, `${getTokenDesc(this._lexer.token)} is reserved and cannot be used for an enum value.`);
+            throw (0, syntaxError_ts_1.syntaxError)(this._lexer.source, this._lexer.token.start, `${getTokenDesc(this._lexer.token)} is reserved and cannot be used for an enum value.`);
         }
         return this.parseName();
     }
@@ -868,7 +868,7 @@ class Parser {
         const directives = this.parseConstDirectives();
         const fields = this.parseInputFieldsDefinition();
         return this.node(start, {
-            kind: kinds_js_1.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+            kind: kinds_ts_1.Kind.INPUT_OBJECT_TYPE_DEFINITION,
             description,
             name,
             directives,
@@ -881,7 +881,7 @@ class Parser {
      * ```
      */
     parseInputFieldsDefinition() {
-        return this.optionalMany(tokenKind_js_1.TokenKind.BRACE_L, this.parseInputValueDef, tokenKind_js_1.TokenKind.BRACE_R);
+        return this.optionalMany(tokenKind_ts_1.TokenKind.BRACE_L, this.parseInputValueDef, tokenKind_ts_1.TokenKind.BRACE_R);
     }
     /**
      * TypeSystemExtension :
@@ -895,10 +895,11 @@ class Parser {
      *   - UnionTypeExtension
      *   - EnumTypeExtension
      *   - InputObjectTypeDefinition
+     *   - DirectiveDefinitionExtension
      */
     parseTypeSystemExtension() {
         const keywordToken = this._lexer.lookahead();
-        if (keywordToken.kind === tokenKind_js_1.TokenKind.NAME) {
+        if (keywordToken.kind === tokenKind_ts_1.TokenKind.NAME) {
             switch (keywordToken.value) {
                 case 'schema':
                     return this.parseSchemaExtension();
@@ -914,6 +915,11 @@ class Parser {
                     return this.parseEnumTypeExtension();
                 case 'input':
                     return this.parseInputObjectTypeExtension();
+                case 'directive':
+                    if (this._options.experimentalDirectivesOnDirectiveDefinitions) {
+                        return this.parseDirectiveDefinitionExtension();
+                    }
+                    break;
             }
         }
         throw this.unexpected(keywordToken);
@@ -930,12 +936,12 @@ class Parser {
         this.expectKeyword('extend');
         this.expectKeyword('schema');
         const directives = this.parseConstDirectives();
-        const operationTypes = this.optionalMany(tokenKind_js_1.TokenKind.BRACE_L, this.parseOperationTypeDefinition, tokenKind_js_1.TokenKind.BRACE_R);
+        const operationTypes = this.optionalMany(tokenKind_ts_1.TokenKind.BRACE_L, this.parseOperationTypeDefinition, tokenKind_ts_1.TokenKind.BRACE_R);
         if (directives === undefined && operationTypes === undefined) {
             throw this.unexpected();
         }
         return this.node(start, {
-            kind: kinds_js_1.Kind.SCHEMA_EXTENSION,
+            kind: kinds_ts_1.Kind.SCHEMA_EXTENSION,
             directives,
             operationTypes,
         });
@@ -954,7 +960,7 @@ class Parser {
             throw this.unexpected();
         }
         return this.node(start, {
-            kind: kinds_js_1.Kind.SCALAR_TYPE_EXTENSION,
+            kind: kinds_ts_1.Kind.SCALAR_TYPE_EXTENSION,
             name,
             directives,
         });
@@ -979,7 +985,7 @@ class Parser {
             throw this.unexpected();
         }
         return this.node(start, {
-            kind: kinds_js_1.Kind.OBJECT_TYPE_EXTENSION,
+            kind: kinds_ts_1.Kind.OBJECT_TYPE_EXTENSION,
             name,
             interfaces,
             directives,
@@ -1006,7 +1012,7 @@ class Parser {
             throw this.unexpected();
         }
         return this.node(start, {
-            kind: kinds_js_1.Kind.INTERFACE_TYPE_EXTENSION,
+            kind: kinds_ts_1.Kind.INTERFACE_TYPE_EXTENSION,
             name,
             interfaces,
             directives,
@@ -1029,7 +1035,7 @@ class Parser {
             throw this.unexpected();
         }
         return this.node(start, {
-            kind: kinds_js_1.Kind.UNION_TYPE_EXTENSION,
+            kind: kinds_ts_1.Kind.UNION_TYPE_EXTENSION,
             name,
             directives,
             types,
@@ -1051,7 +1057,7 @@ class Parser {
             throw this.unexpected();
         }
         return this.node(start, {
-            kind: kinds_js_1.Kind.ENUM_TYPE_EXTENSION,
+            kind: kinds_ts_1.Kind.ENUM_TYPE_EXTENSION,
             name,
             directives,
             values,
@@ -1073,12 +1079,28 @@ class Parser {
             throw this.unexpected();
         }
         return this.node(start, {
-            kind: kinds_js_1.Kind.INPUT_OBJECT_TYPE_EXTENSION,
+            kind: kinds_ts_1.Kind.INPUT_OBJECT_TYPE_EXTENSION,
             name,
             directives,
             fields,
         });
     }
+    parseDirectiveDefinitionExtension() {
+        const start = this._lexer.token;
+        this.expectKeyword('extend');
+        this.expectKeyword('directive');
+        this.expectToken(tokenKind_ts_1.TokenKind.AT);
+        const name = this.parseName();
+        const directives = this.parseConstDirectives();
+        if (directives === undefined) {
+            throw this.unexpected();
+        }
+        return this.node(start, {
+            kind: kinds_ts_1.Kind.DIRECTIVE_EXTENSION,
+            name,
+            directives,
+        });
+    }
     /**
      * ```
      * DirectiveDefinition :
@@ -1089,17 +1111,22 @@ class Parser {
         const start = this._lexer.token;
         const description = this.parseDescription();
         this.expectKeyword('directive');
-        this.expectToken(tokenKind_js_1.TokenKind.AT);
+        this.expectToken(tokenKind_ts_1.TokenKind.AT);
         const name = this.parseName();
         const args = this.parseArgumentDefs();
+        const directives = this._options
+            .experimentalDirectivesOnDirectiveDefinitions
+            ? this.parseConstDirectives()
+            : undefined;
         const repeatable = this.expectOptionalKeyword('repeatable');
         this.expectKeyword('on');
         const locations = this.parseDirectiveLocations();
         return this.node(start, {
-            kind: kinds_js_1.Kind.DIRECTIVE_DEFINITION,
+            kind: kinds_ts_1.Kind.DIRECTIVE_DEFINITION,
             description,
             name,
             arguments: args,
+            directives,
             repeatable,
             locations,
         });
@@ -1110,7 +1137,7 @@ class Parser {
      *   - DirectiveLocations | DirectiveLocation
      */
     parseDirectiveLocations() {
-        return this.delimitedMany(tokenKind_js_1.TokenKind.PIPE, this.parseDirectiveLocation);
+        return this.delimitedMany(tokenKind_ts_1.TokenKind.PIPE, this.parseDirectiveLocation);
     }
     /*
      * DirectiveLocation :
@@ -1125,6 +1152,8 @@ class Parser {
      *   `FRAGMENT_DEFINITION`
      *   `FRAGMENT_SPREAD`
      *   `INLINE_FRAGMENT`
+     *   `VARIABLE_DEFINITION`
+     *   `FRAGMENT_VARIABLE_DEFINITION`
      *
      * TypeSystemDirectiveLocation : one of
      *   `SCHEMA`
@@ -1138,11 +1167,12 @@ class Parser {
      *   `ENUM_VALUE`
      *   `INPUT_OBJECT`
      *   `INPUT_FIELD_DEFINITION`
+     *   `DIRECTIVE_DEFINITION`
      */
     parseDirectiveLocation() {
         const start = this._lexer.token;
         const name = this.parseName();
-        if (Object.hasOwn(directiveLocation_js_1.DirectiveLocation, name.value)) {
+        if (Object.hasOwn(directiveLocation_ts_1.DirectiveLocation, name.value)) {
             return name;
         }
         throw this.unexpected(start);
@@ -1158,49 +1188,49 @@ class Parser {
      */
     parseSchemaCoordinate() {
         const start = this._lexer.token;
-        const ofDirective = this.expectOptionalToken(tokenKind_js_1.TokenKind.AT);
+        const ofDirective = this.expectOptionalToken(tokenKind_ts_1.TokenKind.AT);
         const name = this.parseName();
         let memberName;
-        if (!ofDirective && this.expectOptionalToken(tokenKind_js_1.TokenKind.DOT)) {
+        if (!ofDirective && this.expectOptionalToken(tokenKind_ts_1.TokenKind.DOT)) {
             memberName = this.parseName();
         }
         let argumentName;
         if ((ofDirective || memberName) &&
-            this.expectOptionalToken(tokenKind_js_1.TokenKind.PAREN_L)) {
+            this.expectOptionalToken(tokenKind_ts_1.TokenKind.PAREN_L)) {
             argumentName = this.parseName();
-            this.expectToken(tokenKind_js_1.TokenKind.COLON);
-            this.expectToken(tokenKind_js_1.TokenKind.PAREN_R);
+            this.expectToken(tokenKind_ts_1.TokenKind.COLON);
+            this.expectToken(tokenKind_ts_1.TokenKind.PAREN_R);
         }
         if (ofDirective) {
             if (argumentName) {
                 return this.node(start, {
-                    kind: kinds_js_1.Kind.DIRECTIVE_ARGUMENT_COORDINATE,
+                    kind: kinds_ts_1.Kind.DIRECTIVE_ARGUMENT_COORDINATE,
                     name,
                     argumentName,
                 });
             }
             return this.node(start, {
-                kind: kinds_js_1.Kind.DIRECTIVE_COORDINATE,
+                kind: kinds_ts_1.Kind.DIRECTIVE_COORDINATE,
                 name,
             });
         }
         else if (memberName) {
             if (argumentName) {
                 return this.node(start, {
-                    kind: kinds_js_1.Kind.ARGUMENT_COORDINATE,
+                    kind: kinds_ts_1.Kind.ARGUMENT_COORDINATE,
                     name,
                     fieldName: memberName,
                     argumentName,
                 });
             }
             return this.node(start, {
-                kind: kinds_js_1.Kind.MEMBER_COORDINATE,
+                kind: kinds_ts_1.Kind.MEMBER_COORDINATE,
                 name,
                 memberName,
             });
         }
         return this.node(start, {
-            kind: kinds_js_1.Kind.TYPE_COORDINATE,
+            kind: kinds_ts_1.Kind.TYPE_COORDINATE,
             name,
         });
     }
@@ -1212,7 +1242,7 @@ class Parser {
      */
     node(startToken, node) {
         if (this._options.noLocation !== true) {
-            node.loc = new ast_js_1.Location(startToken, this._lexer.lastToken, this._lexer.source);
+            node.loc = new ast_ts_1.Location(startToken, this._lexer.lastToken, this._lexer.source);
         }
         return node;
     }
@@ -1232,7 +1262,7 @@ class Parser {
             this.advanceLexer();
             return token;
         }
-        throw (0, syntaxError_js_1.syntaxError)(this._lexer.source, token.start, `Expected ${getTokenKindDesc(kind)}, found ${getTokenDesc(token)}.`);
+        throw (0, syntaxError_ts_1.syntaxError)(this._lexer.source, token.start, `Expected ${getTokenKindDesc(kind)}, found ${getTokenDesc(token)}.`);
     }
     /**
      * If the next token is of the given kind, return "true" after advancing the lexer.
@@ -1252,11 +1282,11 @@ class Parser {
      */
     expectKeyword(value) {
         const token = this._lexer.token;
-        if (token.kind === tokenKind_js_1.TokenKind.NAME && token.value === value) {
+        if (token.kind === tokenKind_ts_1.TokenKind.NAME && token.value === value) {
             this.advanceLexer();
         }
         else {
-            throw (0, syntaxError_js_1.syntaxError)(this._lexer.source, token.start, `Expected "${value}", found ${getTokenDesc(token)}.`);
+            throw (0, syntaxError_ts_1.syntaxError)(this._lexer.source, token.start, `Expected "${value}", found ${getTokenDesc(token)}.`);
         }
     }
     /**
@@ -1265,7 +1295,7 @@ class Parser {
      */
     expectOptionalKeyword(value) {
         const token = this._lexer.token;
-        if (token.kind === tokenKind_js_1.TokenKind.NAME && token.value === value) {
+        if (token.kind === tokenKind_ts_1.TokenKind.NAME && token.value === value) {
             this.advanceLexer();
             return true;
         }
@@ -1276,7 +1306,7 @@ class Parser {
      */
     unexpected(atToken) {
         const token = atToken ?? this._lexer.token;
-        return (0, syntaxError_js_1.syntaxError)(this._lexer.source, token.start, `Unexpected ${getTokenDesc(token)}.`);
+        return (0, syntaxError_ts_1.syntaxError)(this._lexer.source, token.start, `Unexpected ${getTokenDesc(token)}.`);
     }
     /**
      * Returns a possibly empty list of parse nodes, determined by the parseFn.
@@ -1336,10 +1366,10 @@ class Parser {
     advanceLexer() {
         const { maxTokens } = this._options;
         const token = this._lexer.advance();
-        if (token.kind !== tokenKind_js_1.TokenKind.EOF) {
+        if (token.kind !== tokenKind_ts_1.TokenKind.EOF) {
             ++this._tokenCounter;
             if (maxTokens !== undefined && this._tokenCounter > maxTokens) {
-                throw (0, syntaxError_js_1.syntaxError)(this._lexer.source, token.start, `Document contains more than ${maxTokens} tokens. Parsing aborted.`);
+                throw (0, syntaxError_ts_1.syntaxError)(this._lexer.source, token.start, `Document contains more than ${maxTokens} tokens. Parsing aborted.`);
             }
         }
     }
@@ -1356,6 +1386,6 @@ function getTokenDesc(token) {
  * A helper function to describe a token kind as a string for debugging.
  */
 function getTokenKindDesc(kind) {
-    return (0, lexer_js_1.isPunctuatorTokenKind)(kind) ? `"${kind}"` : kind;
+    return (0, lexer_ts_1.isPunctuatorTokenKind)(kind) ? `"${kind}"` : kind;
 }
 //# sourceMappingURL=parser.js.map