···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
---

     

       
2
       
+
       
'@0no-co/graphql.web': patch

     

       
3
       
+
       
---

     

       
4
       
+
       


     

       
5
       
+
       
Improve parser performance.

     

···

       
8
       
 
       
coverage/

     

       
9
       
 
       
package-lock.json

     

       
10
       
 
       
.DS_Store

     

       
0
       
 
       

     

···

       
8
       
 
       
coverage/

     

       
9
       
 
       
package-lock.json

     

       
10
       
 
       
.DS_Store

     

       
11
       
+
       
tsconfig.vitest-temp.json

     

···

       
6
       
 
       
    {

     

       
7
       
 
       
      "directives": [

     

       
8
       
 
       
        {

     

       
9
       
-
       
          "arguments": [],

     

       
10
       
 
       
          "kind": "Directive",

     

       
11
       
 
       
          "name": {

     

       
12
       
 
       
            "kind": "Name",

     
···

       
50
       
 
       
                },

     

       
51
       
 
       
              },

     

       
52
       
 
       
            ],

     

       
53
       
-
       
            "directives": [],

     

       
54
       
 
       
            "kind": "Field",

     

       
55
       
 
       
            "name": {

     

       
56
       
 
       
              "kind": "Name",

     
···

       
61
       
 
       
              "selections": [

     

       
62
       
 
       
                {

     

       
63
       
 
       
                  "alias": undefined,

     

       
64
       
-
       
                  "arguments": [],

     

       
65
       
-
       
                  "directives": [],

     

       
66
       
 
       
                  "kind": "Field",

     

       
67
       
 
       
                  "name": {

     

       
68
       
 
       
                    "kind": "Name",

     
···

       
73
       
 
       
                {

     

       
74
       
 
       
                  "directives": [

     

       
75
       
 
       
                    {

     

       
76
       
-
       
                      "arguments": [],

     

       
77
       
 
       
                      "kind": "Directive",

     

       
78
       
 
       
                      "name": {

     

       
79
       
 
       
                        "kind": "Name",

     
···

       
87
       
 
       
                    "selections": [

     

       
88
       
 
       
                      {

     

       
89
       
 
       
                        "alias": undefined,

     

       
90
       
-
       
                        "arguments": [],

     

       
91
       
-
       
                        "directives": [],

     

       
92
       
 
       
                        "kind": "Field",

     

       
93
       
 
       
                        "name": {

     

       
94
       
 
       
                          "kind": "Name",

     
···

       
99
       
 
       
                          "selections": [

     

       
100
       
 
       
                            {

     

       
101
       
 
       
                              "alias": undefined,

     

       
102
       
-
       
                              "arguments": [],

     

       
103
       
-
       
                              "directives": [],

     

       
104
       
 
       
                              "kind": "Field",

     

       
105
       
 
       
                              "name": {

     

       
106
       
 
       
                                "kind": "Name",

     
···

       
175
       
 
       
                                "selections": [

     

       
176
       
 
       
                                  {

     

       
177
       
 
       
                                    "alias": undefined,

     

       
178
       
-
       
                                    "arguments": [],

     

       
179
       
-
       
                                    "directives": [],

     

       
180
       
 
       
                                    "kind": "Field",

     

       
181
       
 
       
                                    "name": {

     

       
182
       
 
       
                                      "kind": "Name",

     
···

       
187
       
 
       
                                  {

     

       
188
       
 
       
                                    "directives": [

     

       
189
       
 
       
                                      {

     

       
190
       
-
       
                                        "arguments": [],

     

       
191
       
 
       
                                        "kind": "Directive",

     

       
192
       
 
       
                                        "name": {

     

       
193
       
 
       
                                          "kind": "Name",

     
···

       
249
       
 
       
                    "selections": [

     

       
250
       
 
       
                      {

     

       
251
       
 
       
                        "alias": undefined,

     

       
252
       
-
       
                        "arguments": [],

     

       
253
       
-
       
                        "directives": [],

     

       
254
       
 
       
                        "kind": "Field",

     

       
255
       
 
       
                        "name": {

     

       
256
       
 
       
                          "kind": "Name",

     
···

       
263
       
 
       
                  "typeCondition": undefined,

     

       
264
       
 
       
                },

     

       
265
       
 
       
                {

     

       
266
       
-
       
                  "directives": [],

     

       
267
       
 
       
                  "kind": "InlineFragment",

     

       
268
       
 
       
                  "selectionSet": {

     

       
269
       
 
       
                    "kind": "SelectionSet",

     

       
270
       
 
       
                    "selections": [

     

       
271
       
 
       
                      {

     

       
272
       
 
       
                        "alias": undefined,

     

       
273
       
-
       
                        "arguments": [],

     

       
274
       
-
       
                        "directives": [],

     

       
275
       
 
       
                        "kind": "Field",

     

       
276
       
 
       
                        "name": {

     

       
277
       
 
       
                          "kind": "Name",

     
···

       
291
       
 
       
      "variableDefinitions": [

     

       
292
       
 
       
        {

     

       
293
       
 
       
          "defaultValue": undefined,

     

       
294
       
-
       
          "directives": [],

     

       
295
       
 
       
          "kind": "VariableDefinition",

     

       
296
       
 
       
          "type": {

     

       
297
       
 
       
            "kind": "NamedType",

     
···

       
313
       
 
       
            "kind": "EnumValue",

     

       
314
       
 
       
            "value": "MOBILE",

     

       
315
       
 
       
          },

     

       
316
       
-
       
          "directives": [],

     

       
317
       
 
       
          "kind": "VariableDefinition",

     

       
318
       
 
       
          "type": {

     

       
319
       
 
       
            "kind": "NamedType",

     
···

       
335
       
 
       
    {

     

       
336
       
 
       
      "directives": [

     

       
337
       
 
       
        {

     

       
338
       
-
       
          "arguments": [],

     

       
339
       
 
       
          "kind": "Directive",

     

       
340
       
 
       
          "name": {

     

       
341
       
 
       
            "kind": "Name",

     
···

       
369
       
 
       
            ],

     

       
370
       
 
       
            "directives": [

     

       
371
       
 
       
              {

     

       
372
       
-
       
                "arguments": [],

     

       
373
       
 
       
                "kind": "Directive",

     

       
374
       
 
       
                "name": {

     

       
375
       
 
       
                  "kind": "Name",

     
···

       
387
       
 
       
              "selections": [

     

       
388
       
 
       
                {

     

       
389
       
 
       
                  "alias": undefined,

     

       
390
       
-
       
                  "arguments": [],

     

       
391
       
-
       
                  "directives": [],

     

       
392
       
 
       
                  "kind": "Field",

     

       
393
       
 
       
                  "name": {

     

       
394
       
 
       
                    "kind": "Name",

     
···

       
399
       
 
       
                    "selections": [

     

       
400
       
 
       
                      {

     

       
401
       
 
       
                        "alias": undefined,

     

       
402
       
-
       
                        "arguments": [],

     

       
403
       
 
       
                        "directives": [

     

       
404
       
 
       
                          {

     

       
405
       
-
       
                            "arguments": [],

     

       
406
       
 
       
                            "kind": "Directive",

     

       
407
       
 
       
                            "name": {

     

       
408
       
 
       
                              "kind": "Name",

     
···

       
425
       
 
       
          },

     

       
426
       
 
       
        ],

     

       
427
       
 
       
      },

     

       
428
       
-
       
      "variableDefinitions": [],

     

       
429
       
 
       
    },

     

       
430
       
 
       
    {

     

       
431
       
 
       
      "directives": [

     

       
432
       
 
       
        {

     

       
433
       
-
       
          "arguments": [],

     

       
434
       
 
       
          "kind": "Directive",

     

       
435
       
 
       
          "name": {

     

       
436
       
 
       
            "kind": "Name",

     
···

       
465
       
 
       
                },

     

       
466
       
 
       
              },

     

       
467
       
 
       
            ],

     

       
468
       
-
       
            "directives": [],

     

       
469
       
 
       
            "kind": "Field",

     

       
470
       
 
       
            "name": {

     

       
471
       
 
       
              "kind": "Name",

     
···

       
476
       
 
       
              "selections": [

     

       
477
       
 
       
                {

     

       
478
       
 
       
                  "alias": undefined,

     

       
479
       
-
       
                  "arguments": [],

     

       
480
       
-
       
                  "directives": [],

     

       
481
       
 
       
                  "kind": "Field",

     

       
482
       
 
       
                  "name": {

     

       
483
       
 
       
                    "kind": "Name",

     
···

       
488
       
 
       
                    "selections": [

     

       
489
       
 
       
                      {

     

       
490
       
 
       
                        "alias": undefined,

     

       
491
       
-
       
                        "arguments": [],

     

       
492
       
-
       
                        "directives": [],

     

       
493
       
 
       
                        "kind": "Field",

     

       
494
       
 
       
                        "name": {

     

       
495
       
 
       
                          "kind": "Name",

     
···

       
500
       
 
       
                          "selections": [

     

       
501
       
 
       
                            {

     

       
502
       
 
       
                              "alias": undefined,

     

       
503
       
-
       
                              "arguments": [],

     

       
504
       
-
       
                              "directives": [],

     

       
505
       
 
       
                              "kind": "Field",

     

       
506
       
 
       
                              "name": {

     

       
507
       
 
       
                                "kind": "Name",

     
···

       
514
       
 
       
                      },

     

       
515
       
 
       
                      {

     

       
516
       
 
       
                        "alias": undefined,

     

       
517
       
-
       
                        "arguments": [],

     

       
518
       
-
       
                        "directives": [],

     

       
519
       
 
       
                        "kind": "Field",

     

       
520
       
 
       
                        "name": {

     

       
521
       
 
       
                          "kind": "Name",

     
···

       
526
       
 
       
                          "selections": [

     

       
527
       
 
       
                            {

     

       
528
       
 
       
                              "alias": undefined,

     

       
529
       
-
       
                              "arguments": [],

     

       
530
       
-
       
                              "directives": [],

     

       
531
       
 
       
                              "kind": "Field",

     

       
532
       
 
       
                              "name": {

     

       
533
       
 
       
                                "kind": "Name",

     
···

       
549
       
 
       
      "variableDefinitions": [

     

       
550
       
 
       
        {

     

       
551
       
 
       
          "defaultValue": undefined,

     

       
552
       
-
       
          "directives": [],

     

       
553
       
 
       
          "kind": "VariableDefinition",

     

       
554
       
 
       
          "type": {

     

       
555
       
 
       
            "kind": "NamedType",

     
···

       
571
       
 
       
    {

     

       
572
       
 
       
      "directives": [

     

       
573
       
 
       
        {

     

       
574
       
-
       
          "arguments": [],

     

       
575
       
 
       
          "kind": "Directive",

     

       
576
       
 
       
          "name": {

     

       
577
       
 
       
            "kind": "Name",

     
···

       
652
       
 
       
                },

     

       
653
       
 
       
              },

     

       
654
       
 
       
            ],

     

       
655
       
-
       
            "directives": [],

     

       
656
       
 
       
            "kind": "Field",

     

       
657
       
 
       
            "name": {

     

       
658
       
 
       
              "kind": "Name",

     
···

       
671
       
 
       
      },

     

       
672
       
 
       
    },

     

       
673
       
 
       
    {

     

       
674
       
-
       
      "directives": [],

     

       
675
       
 
       
      "kind": "OperationDefinition",

     

       
676
       
 
       
      "name": {

     

       
677
       
 
       
        "kind": "Name",

     
···

       
717
       
 
       
                },

     

       
718
       
 
       
              },

     

       
719
       
 
       
            ],

     

       
720
       
-
       
            "directives": [],

     

       
721
       
 
       
            "kind": "Field",

     

       
722
       
 
       
            "name": {

     

       
723
       
 
       
              "kind": "Name",

     
···

       
727
       
 
       
          },

     

       
728
       
 
       
          {

     

       
729
       
 
       
            "alias": undefined,

     

       
730
       
-
       
            "arguments": [],

     

       
731
       
-
       
            "directives": [],

     

       
732
       
 
       
            "kind": "Field",

     

       
733
       
 
       
            "name": {

     

       
734
       
 
       
              "kind": "Name",

     
···

       
738
       
 
       
          },

     

       
739
       
 
       
        ],

     

       
740
       
 
       
      },

     

       
741
       
-
       
      "variableDefinitions": [],

     

       
742
       
 
       
    },

     

       
743
       
 
       
    {

     

       
744
       
-
       
      "directives": [],

     

       
745
       
 
       
      "kind": "OperationDefinition",

     

       
746
       
 
       
      "name": {

     

       
747
       
 
       
        "kind": "Name",

     
···

       
753
       
 
       
        "selections": [

     

       
754
       
 
       
          {

     

       
755
       
 
       
            "alias": undefined,

     

       
756
       
-
       
            "arguments": [],

     

       
757
       
-
       
            "directives": [],

     

       
758
       
 
       
            "kind": "Field",

     

       
759
       
 
       
            "name": {

     

       
760
       
 
       
              "kind": "Name",

     
···

       
764
       
 
       
          },

     

       
765
       
 
       
        ],

     

       
766
       
 
       
      },

     

       
767
       
-
       
      "variableDefinitions": [],

     

       
768
       
 
       
    },

     

       
769
       
 
       
  ],

     

       
770
       
 
       
  "kind": "Document",

     

···

       
6
       
 
       
    {

     

       
7
       
 
       
      "directives": [

     

       
8
       
 
       
        {

     

       
9
       
+
       
          "arguments": undefined,

     

       
10
       
 
       
          "kind": "Directive",

     

       
11
       
 
       
          "name": {

     

       
12
       
 
       
            "kind": "Name",

     
···

       
50
       
 
       
                },

     

       
51
       
 
       
              },

     

       
52
       
 
       
            ],

     

       
53
       
+
       
            "directives": undefined,

     

       
54
       
 
       
            "kind": "Field",

     

       
55
       
 
       
            "name": {

     

       
56
       
 
       
              "kind": "Name",

     
···

       
61
       
 
       
              "selections": [

     

       
62
       
 
       
                {

     

       
63
       
 
       
                  "alias": undefined,

     

       
64
       
+
       
                  "arguments": undefined,

     

       
65
       
+
       
                  "directives": undefined,

     

       
66
       
 
       
                  "kind": "Field",

     

       
67
       
 
       
                  "name": {

     

       
68
       
 
       
                    "kind": "Name",

     
···

       
73
       
 
       
                {

     

       
74
       
 
       
                  "directives": [

     

       
75
       
 
       
                    {

     

       
76
       
+
       
                      "arguments": undefined,

     

       
77
       
 
       
                      "kind": "Directive",

     

       
78
       
 
       
                      "name": {

     

       
79
       
 
       
                        "kind": "Name",

     
···

       
87
       
 
       
                    "selections": [

     

       
88
       
 
       
                      {

     

       
89
       
 
       
                        "alias": undefined,

     

       
90
       
+
       
                        "arguments": undefined,

     

       
91
       
+
       
                        "directives": undefined,

     

       
92
       
 
       
                        "kind": "Field",

     

       
93
       
 
       
                        "name": {

     

       
94
       
 
       
                          "kind": "Name",

     
···

       
99
       
 
       
                          "selections": [

     

       
100
       
 
       
                            {

     

       
101
       
 
       
                              "alias": undefined,

     

       
102
       
+
       
                              "arguments": undefined,

     

       
103
       
+
       
                              "directives": undefined,

     

       
104
       
 
       
                              "kind": "Field",

     

       
105
       
 
       
                              "name": {

     

       
106
       
 
       
                                "kind": "Name",

     
···

       
175
       
 
       
                                "selections": [

     

       
176
       
 
       
                                  {

     

       
177
       
 
       
                                    "alias": undefined,

     

       
178
       
+
       
                                    "arguments": undefined,

     

       
179
       
+
       
                                    "directives": undefined,

     

       
180
       
 
       
                                    "kind": "Field",

     

       
181
       
 
       
                                    "name": {

     

       
182
       
 
       
                                      "kind": "Name",

     
···

       
187
       
 
       
                                  {

     

       
188
       
 
       
                                    "directives": [

     

       
189
       
 
       
                                      {

     

       
190
       
+
       
                                        "arguments": undefined,

     

       
191
       
 
       
                                        "kind": "Directive",

     

       
192
       
 
       
                                        "name": {

     

       
193
       
 
       
                                          "kind": "Name",

     
···

       
249
       
 
       
                    "selections": [

     

       
250
       
 
       
                      {

     

       
251
       
 
       
                        "alias": undefined,

     

       
252
       
+
       
                        "arguments": undefined,

     

       
253
       
+
       
                        "directives": undefined,

     

       
254
       
 
       
                        "kind": "Field",

     

       
255
       
 
       
                        "name": {

     

       
256
       
 
       
                          "kind": "Name",

     
···

       
263
       
 
       
                  "typeCondition": undefined,

     

       
264
       
 
       
                },

     

       
265
       
 
       
                {

     

       
266
       
+
       
                  "directives": undefined,

     

       
267
       
 
       
                  "kind": "InlineFragment",

     

       
268
       
 
       
                  "selectionSet": {

     

       
269
       
 
       
                    "kind": "SelectionSet",

     

       
270
       
 
       
                    "selections": [

     

       
271
       
 
       
                      {

     

       
272
       
 
       
                        "alias": undefined,

     

       
273
       
+
       
                        "arguments": undefined,

     

       
274
       
+
       
                        "directives": undefined,

     

       
275
       
 
       
                        "kind": "Field",

     

       
276
       
 
       
                        "name": {

     

       
277
       
 
       
                          "kind": "Name",

     
···

       
291
       
 
       
      "variableDefinitions": [

     

       
292
       
 
       
        {

     

       
293
       
 
       
          "defaultValue": undefined,

     

       
294
       
+
       
          "directives": undefined,

     

       
295
       
 
       
          "kind": "VariableDefinition",

     

       
296
       
 
       
          "type": {

     

       
297
       
 
       
            "kind": "NamedType",

     
···

       
313
       
 
       
            "kind": "EnumValue",

     

       
314
       
 
       
            "value": "MOBILE",

     

       
315
       
 
       
          },

     

       
316
       
+
       
          "directives": undefined,

     

       
317
       
 
       
          "kind": "VariableDefinition",

     

       
318
       
 
       
          "type": {

     

       
319
       
 
       
            "kind": "NamedType",

     
···

       
335
       
 
       
    {

     

       
336
       
 
       
      "directives": [

     

       
337
       
 
       
        {

     

       
338
       
+
       
          "arguments": undefined,

     

       
339
       
 
       
          "kind": "Directive",

     

       
340
       
 
       
          "name": {

     

       
341
       
 
       
            "kind": "Name",

     
···

       
369
       
 
       
            ],

     

       
370
       
 
       
            "directives": [

     

       
371
       
 
       
              {

     

       
372
       
+
       
                "arguments": undefined,

     

       
373
       
 
       
                "kind": "Directive",

     

       
374
       
 
       
                "name": {

     

       
375
       
 
       
                  "kind": "Name",

     
···

       
387
       
 
       
              "selections": [

     

       
388
       
 
       
                {

     

       
389
       
 
       
                  "alias": undefined,

     

       
390
       
+
       
                  "arguments": undefined,

     

       
391
       
+
       
                  "directives": undefined,

     

       
392
       
 
       
                  "kind": "Field",

     

       
393
       
 
       
                  "name": {

     

       
394
       
 
       
                    "kind": "Name",

     
···

       
399
       
 
       
                    "selections": [

     

       
400
       
 
       
                      {

     

       
401
       
 
       
                        "alias": undefined,

     

       
402
       
+
       
                        "arguments": undefined,

     

       
403
       
 
       
                        "directives": [

     

       
404
       
 
       
                          {

     

       
405
       
+
       
                            "arguments": undefined,

     

       
406
       
 
       
                            "kind": "Directive",

     

       
407
       
 
       
                            "name": {

     

       
408
       
 
       
                              "kind": "Name",

     
···

       
425
       
 
       
          },

     

       
426
       
 
       
        ],

     

       
427
       
 
       
      },

     

       
428
       
+
       
      "variableDefinitions": undefined,

     

       
429
       
 
       
    },

     

       
430
       
 
       
    {

     

       
431
       
 
       
      "directives": [

     

       
432
       
 
       
        {

     

       
433
       
+
       
          "arguments": undefined,

     

       
434
       
 
       
          "kind": "Directive",

     

       
435
       
 
       
          "name": {

     

       
436
       
 
       
            "kind": "Name",

     
···

       
465
       
 
       
                },

     

       
466
       
 
       
              },

     

       
467
       
 
       
            ],

     

       
468
       
+
       
            "directives": undefined,

     

       
469
       
 
       
            "kind": "Field",

     

       
470
       
 
       
            "name": {

     

       
471
       
 
       
              "kind": "Name",

     
···

       
476
       
 
       
              "selections": [

     

       
477
       
 
       
                {

     

       
478
       
 
       
                  "alias": undefined,

     

       
479
       
+
       
                  "arguments": undefined,

     

       
480
       
+
       
                  "directives": undefined,

     

       
481
       
 
       
                  "kind": "Field",

     

       
482
       
 
       
                  "name": {

     

       
483
       
 
       
                    "kind": "Name",

     
···

       
488
       
 
       
                    "selections": [

     

       
489
       
 
       
                      {

     

       
490
       
 
       
                        "alias": undefined,

     

       
491
       
+
       
                        "arguments": undefined,

     

       
492
       
+
       
                        "directives": undefined,

     

       
493
       
 
       
                        "kind": "Field",

     

       
494
       
 
       
                        "name": {

     

       
495
       
 
       
                          "kind": "Name",

     
···

       
500
       
 
       
                          "selections": [

     

       
501
       
 
       
                            {

     

       
502
       
 
       
                              "alias": undefined,

     

       
503
       
+
       
                              "arguments": undefined,

     

       
504
       
+
       
                              "directives": undefined,

     

       
505
       
 
       
                              "kind": "Field",

     

       
506
       
 
       
                              "name": {

     

       
507
       
 
       
                                "kind": "Name",

     
···

       
514
       
 
       
                      },

     

       
515
       
 
       
                      {

     

       
516
       
 
       
                        "alias": undefined,

     

       
517
       
+
       
                        "arguments": undefined,

     

       
518
       
+
       
                        "directives": undefined,

     

       
519
       
 
       
                        "kind": "Field",

     

       
520
       
 
       
                        "name": {

     

       
521
       
 
       
                          "kind": "Name",

     
···

       
526
       
 
       
                          "selections": [

     

       
527
       
 
       
                            {

     

       
528
       
 
       
                              "alias": undefined,

     

       
529
       
+
       
                              "arguments": undefined,

     

       
530
       
+
       
                              "directives": undefined,

     

       
531
       
 
       
                              "kind": "Field",

     

       
532
       
 
       
                              "name": {

     

       
533
       
 
       
                                "kind": "Name",

     
···

       
549
       
 
       
      "variableDefinitions": [

     

       
550
       
 
       
        {

     

       
551
       
 
       
          "defaultValue": undefined,

     

       
552
       
+
       
          "directives": undefined,

     

       
553
       
 
       
          "kind": "VariableDefinition",

     

       
554
       
 
       
          "type": {

     

       
555
       
 
       
            "kind": "NamedType",

     
···

       
571
       
 
       
    {

     

       
572
       
 
       
      "directives": [

     

       
573
       
 
       
        {

     

       
574
       
+
       
          "arguments": undefined,

     

       
575
       
 
       
          "kind": "Directive",

     

       
576
       
 
       
          "name": {

     

       
577
       
 
       
            "kind": "Name",

     
···

       
652
       
 
       
                },

     

       
653
       
 
       
              },

     

       
654
       
 
       
            ],

     

       
655
       
+
       
            "directives": undefined,

     

       
656
       
 
       
            "kind": "Field",

     

       
657
       
 
       
            "name": {

     

       
658
       
 
       
              "kind": "Name",

     
···

       
671
       
 
       
      },

     

       
672
       
 
       
    },

     

       
673
       
 
       
    {

     

       
674
       
+
       
      "directives": undefined,

     

       
675
       
 
       
      "kind": "OperationDefinition",

     

       
676
       
 
       
      "name": {

     

       
677
       
 
       
        "kind": "Name",

     
···

       
717
       
 
       
                },

     

       
718
       
 
       
              },

     

       
719
       
 
       
            ],

     

       
720
       
+
       
            "directives": undefined,

     

       
721
       
 
       
            "kind": "Field",

     

       
722
       
 
       
            "name": {

     

       
723
       
 
       
              "kind": "Name",

     
···

       
727
       
 
       
          },

     

       
728
       
 
       
          {

     

       
729
       
 
       
            "alias": undefined,

     

       
730
       
+
       
            "arguments": undefined,

     

       
731
       
+
       
            "directives": undefined,

     

       
732
       
 
       
            "kind": "Field",

     

       
733
       
 
       
            "name": {

     

       
734
       
 
       
              "kind": "Name",

     
···

       
738
       
 
       
          },

     

       
739
       
 
       
        ],

     

       
740
       
 
       
      },

     

       
741
       
+
       
      "variableDefinitions": undefined,

     

       
742
       
 
       
    },

     

       
743
       
 
       
    {

     

       
744
       
+
       
      "directives": undefined,

     

       
745
       
 
       
      "kind": "OperationDefinition",

     

       
746
       
 
       
      "name": {

     

       
747
       
 
       
        "kind": "Name",

     
···

       
753
       
 
       
        "selections": [

     

       
754
       
 
       
          {

     

       
755
       
 
       
            "alias": undefined,

     

       
756
       
+
       
            "arguments": undefined,

     

       
757
       
+
       
            "directives": undefined,

     

       
758
       
 
       
            "kind": "Field",

     

       
759
       
 
       
            "name": {

     

       
760
       
 
       
              "kind": "Name",

     
···

       
764
       
 
       
          },

     

       
765
       
 
       
        ],

     

       
766
       
 
       
      },

     

       
767
       
+
       
      "variableDefinitions": undefined,

     

       
768
       
 
       
    },

     

       
769
       
 
       
  ],

     

       
770
       
 
       
  "kind": "Document",

     

···

       
1
       
 
       
import { describe, it, expect } from 'vitest';

     

       
2
       
-
       
import * as graphql16 from 'graphql16';

     

       
3
       
 
       


     

       
4
       
 
       
import kitchenSinkDocument from './fixtures/kitchen_sink.graphql?raw';

     

       
5
       
 
       
import { parse, parseType, parseValue } from '../parser';

     
···

       
9
       
 
       
  it('parses the kitchen sink document like graphql.js does', () => {

     

       
10
       
 
       
    const doc = parse(kitchenSinkDocument);

     

       
11
       
 
       
    expect(doc).toMatchSnapshot();

     

       
12
       
-
       
    expect(doc).toEqual(graphql16.parse(kitchenSinkDocument, { noLocation: true }));

     

       
13
       
 
       
  });

     

       
14
       
 
       


     

       
15
       
 
       
  it('parses basic documents', () => {

     
···

       
46
       
 
       
    }).toThrow();

     

       
47
       
 
       
  });

     

       
48
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
49
       
 
       
  it('parses multi-byte characters', () => {

     

       
50
       
 
       
    // Note: \u0A0A could be naively interpreted as two line-feed chars.

     

       
51
       
 
       
    const ast = parse(`

     
···

       
102
       
 
       
  it('parses fragment definitions', () => {

     

       
103
       
 
       
    expect(() => parse('fragment { test }')).toThrow();

     

       
104
       
 
       
    expect(() => parse('fragment name { test }')).toThrow();

     

       
0
       
 
       

     

       
105
       
 
       
    expect(() => parse('fragment name on name')).toThrow();

     

       
106
       
 
       
    expect(() => parse('fragment Name on Type { field }')).not.toThrow();

     

       
107
       
 
       
  });

     
···

       
114
       
 
       
      'selectionSet.selections.0',

     

       
115
       
 
       
      {

     

       
116
       
 
       
        kind: Kind.FIELD,

     

       
117
       
-
       
        directives: [],

     

       
118
       
-
       
        arguments: [],

     

       
119
       
 
       
        alias: {

     

       
120
       
 
       
          kind: Kind.NAME,

     

       
121
       
 
       
          value: 'alias',

     
···

       
129
       
 
       
          selections: [

     

       
130
       
 
       
            {

     

       
131
       
 
       
              kind: Kind.FIELD,

     

       
132
       
-
       
              directives: [],

     

       
133
       
-
       
              arguments: [],

     

       
134
       
 
       
              name: {

     

       
135
       
 
       
                kind: Kind.NAME,

     

       
136
       
 
       
                value: 'child',

     
···

       
145
       
 
       
  it('parses arguments', () => {

     

       
146
       
 
       
    expect(() => parse('{ field() }')).toThrow();

     

       
147
       
 
       
    expect(() => parse('{ field(name) }')).toThrow();

     

       
148
       
-
       
    expect(() => parse('{ field(name:) }')).toThrow();

     

       
149
       
 
       
    expect(() => parse('{ field(name: null }')).toThrow();

     

       
0
       
 
       

     

       
150
       
 
       


     

       
151
       
 
       
    expect(parse('{ field(name: null) }').definitions[0]).toMatchObject({

     

       
152
       
 
       
      kind: Kind.OPERATION_DEFINITION,

     
···

       
177
       
 
       
    });

     

       
178
       
 
       
  });

     

       
179
       
 
       


     

       
180
       
-
       
  it('parses directives', () => {

     

       
181
       
 
       
    expect(() => parse('{ field @ }')).toThrow();

     

       
182
       
 
       
    expect(() => parse('{ field @(test: null) }')).toThrow();

     

       
183
       
 
       


     
···

       
214
       
 
       
      'definitions.0.selectionSet.selections.0',

     

       
215
       
 
       
      {

     

       
216
       
 
       
        kind: Kind.INLINE_FRAGMENT,

     

       
217
       
-
       
        directives: [],

     

       
218
       
 
       
        typeCondition: {

     

       
219
       
 
       
          kind: Kind.NAMED_TYPE,

     

       
220
       
 
       
          name: {

     
···

       
228
       
 
       


     

       
229
       
 
       
    expect(parse('{ ... { field } }')).toHaveProperty('definitions.0.selectionSet.selections.0', {

     

       
230
       
 
       
      kind: Kind.INLINE_FRAGMENT,

     

       
231
       
-
       
      directives: [],

     

       
232
       
 
       
      typeCondition: undefined,

     

       
233
       
 
       
      selectionSet: expect.any(Object),

     

       
234
       
 
       
    });

     

       
235
       
 
       
  });

     

       
236
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
237
       
 
       
  it('parses variable definitions', () => {

     

       
238
       
 
       
    expect(() => parse('query ( { test }')).toThrow();

     

       
0
       
 
       

     

       
239
       
 
       
    expect(() => parse('query ($var) { test }')).toThrow();

     

       
240
       
 
       
    expect(() => parse('query ($var:) { test }')).toThrow();

     

       
241
       
 
       
    expect(() => parse('query ($var: Int =) { test }')).toThrow();

     
···

       
243
       
 
       
    expect(parse('query ($var: Int = 1) { test }').definitions[0]).toMatchObject({

     

       
244
       
 
       
      kind: Kind.OPERATION_DEFINITION,

     

       
245
       
 
       
      operation: 'query',

     

       
246
       
-
       
      directives: [],

     

       
247
       
 
       
      selectionSet: expect.any(Object),

     

       
248
       
 
       
      variableDefinitions: [

     

       
249
       
 
       
        {

     
···

       
271
       
 
       
    });

     

       
272
       
 
       
  });

     

       
273
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
274
       
 
       
  it('creates ast', () => {

     

       
275
       
 
       
    const result = parse(`

     

       
276
       
 
       
      {

     
···

       
288
       
 
       
          kind: Kind.OPERATION_DEFINITION,

     

       
289
       
 
       
          operation: 'query',

     

       
290
       
 
       
          name: undefined,

     

       
291
       
-
       
          variableDefinitions: [],

     

       
292
       
-
       
          directives: [],

     

       
293
       
 
       
          selectionSet: {

     

       
294
       
 
       
            kind: Kind.SELECTION_SET,

     

       
295
       
 
       
            selections: [

     
···

       
313
       
 
       
                    },

     

       
314
       
 
       
                  },

     

       
315
       
 
       
                ],

     

       
316
       
-
       
                directives: [],

     

       
317
       
 
       
                selectionSet: {

     

       
318
       
 
       
                  kind: Kind.SELECTION_SET,

     

       
319
       
 
       
                  selections: [

     
···

       
324
       
 
       
                        kind: Kind.NAME,

     

       
325
       
 
       
                        value: 'id',

     

       
326
       
 
       
                      },

     

       
327
       
-
       
                      arguments: [],

     

       
328
       
-
       
                      directives: [],

     

       
329
       
 
       
                      selectionSet: undefined,

     

       
330
       
 
       
                    },

     

       
331
       
 
       
                    {

     
···

       
335
       
 
       
                        kind: Kind.NAME,

     

       
336
       
 
       
                        value: 'name',

     

       
337
       
 
       
                      },

     

       
338
       
-
       
                      arguments: [],

     

       
339
       
-
       
                      directives: [],

     

       
340
       
 
       
                      selectionSet: undefined,

     

       
341
       
 
       
                    },

     

       
342
       
 
       
                  ],

     
···

       
365
       
 
       
          kind: Kind.OPERATION_DEFINITION,

     

       
366
       
 
       
          operation: 'query',

     

       
367
       
 
       
          name: undefined,

     

       
368
       
-
       
          variableDefinitions: [],

     

       
369
       
-
       
          directives: [],

     

       
370
       
 
       
          selectionSet: {

     

       
371
       
 
       
            kind: Kind.SELECTION_SET,

     

       
372
       
 
       
            selections: [

     
···

       
377
       
 
       
                  kind: Kind.NAME,

     

       
378
       
 
       
                  value: 'node',

     

       
379
       
 
       
                },

     

       
380
       
-
       
                arguments: [],

     

       
381
       
-
       
                directives: [],

     

       
382
       
 
       
                selectionSet: {

     

       
383
       
 
       
                  kind: Kind.SELECTION_SET,

     

       
384
       
 
       
                  selections: [

     
···

       
389
       
 
       
                        kind: Kind.NAME,

     

       
390
       
 
       
                        value: 'id',

     

       
391
       
 
       
                      },

     

       
392
       
-
       
                      arguments: [],

     

       
393
       
-
       
                      directives: [],

     

       
394
       
 
       
                      selectionSet: undefined,

     

       
395
       
 
       
                    },

     

       
396
       
 
       
                  ],

     
···

       
642
       
 
       
    expect(() => parseType('!')).toThrow();

     

       
643
       
 
       
    expect(() => parseType('[String')).toThrow();

     

       
644
       
 
       
    expect(() => parseType('[String!')).toThrow();

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
645
       
 
       
  });

     

       
646
       
 
       


     

       
647
       
 
       
  it('parses well known types', () => {

     
···

       
695
       
 
       
  });

     

       
696
       
 
       


     

       
697
       
 
       
  it('parses nested types', () => {

     

       
698
       
-
       
    const result = parseType('[MyType!]');

     

       
699
       
 
       
    expect(result).toEqual({

     

       
700
       
 
       
      kind: Kind.LIST_TYPE,

     

       
701
       
 
       
      type: {

     
···

       
705
       
 
       
          name: {

     

       
706
       
 
       
            kind: Kind.NAME,

     

       
707
       
 
       
            value: 'MyType',

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
708
       
 
       
          },

     

       
709
       
 
       
        },

     

       
710
       
 
       
      },

     

···

       
1
       
 
       
import { describe, it, expect } from 'vitest';

     

       
0
       
 
       

     

       
2
       
 
       


     

       
3
       
 
       
import kitchenSinkDocument from './fixtures/kitchen_sink.graphql?raw';

     

       
4
       
 
       
import { parse, parseType, parseValue } from '../parser';

     
···

       
8
       
 
       
  it('parses the kitchen sink document like graphql.js does', () => {

     

       
9
       
 
       
    const doc = parse(kitchenSinkDocument);

     

       
10
       
 
       
    expect(doc).toMatchSnapshot();

     

       
0
       
 
       

     

       
11
       
 
       
  });

     

       
12
       
 
       


     

       
13
       
 
       
  it('parses basic documents', () => {

     
···

       
44
       
 
       
    }).toThrow();

     

       
45
       
 
       
  });

     

       
46
       
 
       


     

       
47
       
+
       
  it('parses directives on fragment spread', () => {

     

       
48
       
+
       
    expect(() => parse('{ ...Frag @ }')).toThrow();

     

       
49
       
+
       
    expect(() => parse('{ ...Frag @() }')).toThrow();

     

       
50
       
+
       


     

       
51
       
+
       
    expect(parse('{ ...Frag @test }')).toHaveProperty(

     

       
52
       
+
       
      'definitions.0.selectionSet.selections.0.directives.0',

     

       
53
       
+
       
      {

     

       
54
       
+
       
        kind: Kind.DIRECTIVE,

     

       
55
       
+
       
        name: {

     

       
56
       
+
       
          kind: Kind.NAME,

     

       
57
       
+
       
          value: 'test',

     

       
58
       
+
       
        },

     

       
59
       
+
       
        arguments: undefined,

     

       
60
       
+
       
      }

     

       
61
       
+
       
    );

     

       
62
       
+
       
  });

     

       
63
       
+
       


     

       
64
       
+
       
  it('does not accept empty documents', () => {

     

       
65
       
+
       
    expect(() => {

     

       
66
       
+
       
      return parse('');

     

       
67
       
+
       
    }).toThrow();

     

       
68
       
+
       
  });

     

       
69
       
+
       


     

       
70
       
+
       
  it('does not accept incomplete definitions', () => {

     

       
71
       
+
       
    expect(() => {

     

       
72
       
+
       
      return parse('{} query');

     

       
73
       
+
       
    }).toThrow();

     

       
74
       
+
       
  });

     

       
75
       
+
       


     

       
76
       
 
       
  it('parses multi-byte characters', () => {

     

       
77
       
 
       
    // Note: \u0A0A could be naively interpreted as two line-feed chars.

     

       
78
       
 
       
    const ast = parse(`

     
···

       
129
       
 
       
  it('parses fragment definitions', () => {

     

       
130
       
 
       
    expect(() => parse('fragment { test }')).toThrow();

     

       
131
       
 
       
    expect(() => parse('fragment name { test }')).toThrow();

     

       
132
       
+
       
    expect(() => parse('fragment name on ')).toThrow();

     

       
133
       
 
       
    expect(() => parse('fragment name on name')).toThrow();

     

       
134
       
 
       
    expect(() => parse('fragment Name on Type { field }')).not.toThrow();

     

       
135
       
 
       
  });

     
···

       
142
       
 
       
      'selectionSet.selections.0',

     

       
143
       
 
       
      {

     

       
144
       
 
       
        kind: Kind.FIELD,

     

       
145
       
+
       
        directives: undefined,

     

       
146
       
+
       
        arguments: undefined,

     

       
147
       
 
       
        alias: {

     

       
148
       
 
       
          kind: Kind.NAME,

     

       
149
       
 
       
          value: 'alias',

     
···

       
157
       
 
       
          selections: [

     

       
158
       
 
       
            {

     

       
159
       
 
       
              kind: Kind.FIELD,

     

       
160
       
+
       
              directives: undefined,

     

       
161
       
+
       
              arguments: undefined,

     

       
162
       
 
       
              name: {

     

       
163
       
 
       
                kind: Kind.NAME,

     

       
164
       
 
       
                value: 'child',

     
···

       
173
       
 
       
  it('parses arguments', () => {

     

       
174
       
 
       
    expect(() => parse('{ field() }')).toThrow();

     

       
175
       
 
       
    expect(() => parse('{ field(name) }')).toThrow();

     

       
176
       
+
       
    expect(() => parse('{ field(name: ) }')).toThrow();

     

       
177
       
 
       
    expect(() => parse('{ field(name: null }')).toThrow();

     

       
178
       
+
       
    expect(() => parse('{ field(name: % )')).toThrow();

     

       
179
       
 
       


     

       
180
       
 
       
    expect(parse('{ field(name: null) }').definitions[0]).toMatchObject({

     

       
181
       
 
       
      kind: Kind.OPERATION_DEFINITION,

     
···

       
206
       
 
       
    });

     

       
207
       
 
       
  });

     

       
208
       
 
       


     

       
209
       
+
       
  it('parses directives on fields', () => {

     

       
210
       
 
       
    expect(() => parse('{ field @ }')).toThrow();

     

       
211
       
 
       
    expect(() => parse('{ field @(test: null) }')).toThrow();

     

       
212
       
 
       


     
···

       
243
       
 
       
      'definitions.0.selectionSet.selections.0',

     

       
244
       
 
       
      {

     

       
245
       
 
       
        kind: Kind.INLINE_FRAGMENT,

     

       
246
       
+
       
        directives: undefined,

     

       
247
       
 
       
        typeCondition: {

     

       
248
       
 
       
          kind: Kind.NAMED_TYPE,

     

       
249
       
 
       
          name: {

     
···

       
257
       
 
       


     

       
258
       
 
       
    expect(parse('{ ... { field } }')).toHaveProperty('definitions.0.selectionSet.selections.0', {

     

       
259
       
 
       
      kind: Kind.INLINE_FRAGMENT,

     

       
260
       
+
       
      directives: undefined,

     

       
261
       
 
       
      typeCondition: undefined,

     

       
262
       
 
       
      selectionSet: expect.any(Object),

     

       
263
       
 
       
    });

     

       
264
       
 
       
  });

     

       
265
       
 
       


     

       
266
       
+
       
  it('parses directives on inline fragments', () => {

     

       
267
       
+
       
    expect(() => parse('{ ... @ { field } }')).toThrow();

     

       
268
       
+
       
    expect(() => parse('{ ... @() { field } }')).toThrow();

     

       
269
       
+
       


     

       
270
       
+
       
    expect(parse('{ field @test { field } }')).toHaveProperty(

     

       
271
       
+
       
      'definitions.0.selectionSet.selections.0.directives.0',

     

       
272
       
+
       
      {

     

       
273
       
+
       
        kind: Kind.DIRECTIVE,

     

       
274
       
+
       
        name: {

     

       
275
       
+
       
          kind: Kind.NAME,

     

       
276
       
+
       
          value: 'test',

     

       
277
       
+
       
        },

     

       
278
       
+
       
        arguments: undefined,

     

       
279
       
+
       
      }

     

       
280
       
+
       
    );

     

       
281
       
+
       
  });

     

       
282
       
+
       


     

       
283
       
 
       
  it('parses variable definitions', () => {

     

       
284
       
 
       
    expect(() => parse('query ( { test }')).toThrow();

     

       
285
       
+
       
    expect(() => parse('query ($) { test }')).toThrow();

     

       
286
       
 
       
    expect(() => parse('query ($var) { test }')).toThrow();

     

       
287
       
 
       
    expect(() => parse('query ($var:) { test }')).toThrow();

     

       
288
       
 
       
    expect(() => parse('query ($var: Int =) { test }')).toThrow();

     
···

       
290
       
 
       
    expect(parse('query ($var: Int = 1) { test }').definitions[0]).toMatchObject({

     

       
291
       
 
       
      kind: Kind.OPERATION_DEFINITION,

     

       
292
       
 
       
      operation: 'query',

     

       
293
       
+
       
      directives: undefined,

     

       
294
       
 
       
      selectionSet: expect.any(Object),

     

       
295
       
 
       
      variableDefinitions: [

     

       
296
       
 
       
        {

     
···

       
318
       
 
       
    });

     

       
319
       
 
       
  });

     

       
320
       
 
       


     

       
321
       
+
       
  it('parses directives on variable definitions', () => {

     

       
322
       
+
       
    expect(() => parse('query ($var: Int @) { field }')).toThrow();

     

       
323
       
+
       
    expect(() => parse('query ($var: Int @test()) { field }')).toThrow();

     

       
324
       
+
       


     

       
325
       
+
       
    expect(parse('query ($var: Int @test) { field }')).toHaveProperty(

     

       
326
       
+
       
      'definitions.0.variableDefinitions.0.directives.0',

     

       
327
       
+
       
      {

     

       
328
       
+
       
        kind: Kind.DIRECTIVE,

     

       
329
       
+
       
        name: {

     

       
330
       
+
       
          kind: Kind.NAME,

     

       
331
       
+
       
          value: 'test',

     

       
332
       
+
       
        },

     

       
333
       
+
       
        arguments: undefined,

     

       
334
       
+
       
      }

     

       
335
       
+
       
    );

     

       
336
       
+
       
  });

     

       
337
       
+
       


     

       
338
       
 
       
  it('creates ast', () => {

     

       
339
       
 
       
    const result = parse(`

     

       
340
       
 
       
      {

     
···

       
352
       
 
       
          kind: Kind.OPERATION_DEFINITION,

     

       
353
       
 
       
          operation: 'query',

     

       
354
       
 
       
          name: undefined,

     

       
355
       
+
       
          variableDefinitions: undefined,

     

       
356
       
+
       
          directives: undefined,

     

       
357
       
 
       
          selectionSet: {

     

       
358
       
 
       
            kind: Kind.SELECTION_SET,

     

       
359
       
 
       
            selections: [

     
···

       
377
       
 
       
                    },

     

       
378
       
 
       
                  },

     

       
379
       
 
       
                ],

     

       
380
       
+
       
                directives: undefined,

     

       
381
       
 
       
                selectionSet: {

     

       
382
       
 
       
                  kind: Kind.SELECTION_SET,

     

       
383
       
 
       
                  selections: [

     
···

       
388
       
 
       
                        kind: Kind.NAME,

     

       
389
       
 
       
                        value: 'id',

     

       
390
       
 
       
                      },

     

       
391
       
+
       
                      arguments: undefined,

     

       
392
       
+
       
                      directives: undefined,

     

       
393
       
 
       
                      selectionSet: undefined,

     

       
394
       
 
       
                    },

     

       
395
       
 
       
                    {

     
···

       
399
       
 
       
                        kind: Kind.NAME,

     

       
400
       
 
       
                        value: 'name',

     

       
401
       
 
       
                      },

     

       
402
       
+
       
                      arguments: undefined,

     

       
403
       
+
       
                      directives: undefined,

     

       
404
       
 
       
                      selectionSet: undefined,

     

       
405
       
 
       
                    },

     

       
406
       
 
       
                  ],

     
···

       
429
       
 
       
          kind: Kind.OPERATION_DEFINITION,

     

       
430
       
 
       
          operation: 'query',

     

       
431
       
 
       
          name: undefined,

     

       
432
       
+
       
          variableDefinitions: undefined,

     

       
433
       
+
       
          directives: undefined,

     

       
434
       
 
       
          selectionSet: {

     

       
435
       
 
       
            kind: Kind.SELECTION_SET,

     

       
436
       
 
       
            selections: [

     
···

       
441
       
 
       
                  kind: Kind.NAME,

     

       
442
       
 
       
                  value: 'node',

     

       
443
       
 
       
                },

     

       
444
       
+
       
                arguments: undefined,

     

       
445
       
+
       
                directives: undefined,

     

       
446
       
 
       
                selectionSet: {

     

       
447
       
 
       
                  kind: Kind.SELECTION_SET,

     

       
448
       
 
       
                  selections: [

     
···

       
453
       
 
       
                        kind: Kind.NAME,

     

       
454
       
 
       
                        value: 'id',

     

       
455
       
 
       
                      },

     

       
456
       
+
       
                      arguments: undefined,

     

       
457
       
+
       
                      directives: undefined,

     

       
458
       
 
       
                      selectionSet: undefined,

     

       
459
       
 
       
                    },

     

       
460
       
 
       
                  ],

     
···

       
706
       
 
       
    expect(() => parseType('!')).toThrow();

     

       
707
       
 
       
    expect(() => parseType('[String')).toThrow();

     

       
708
       
 
       
    expect(() => parseType('[String!')).toThrow();

     

       
709
       
+
       
    expect(() => parseType('[[String!')).toThrow();

     

       
710
       
+
       
    expect(() => parseType('[[String]!')).toThrow();

     

       
711
       
+
       
    expect(() => parseType('[[String]')).toThrow();

     

       
712
       
 
       
  });

     

       
713
       
 
       


     

       
714
       
 
       
  it('parses well known types', () => {

     
···

       
762
       
 
       
  });

     

       
763
       
 
       


     

       
764
       
 
       
  it('parses nested types', () => {

     

       
765
       
+
       
    let result = parseType('[MyType!]');

     

       
766
       
 
       
    expect(result).toEqual({

     

       
767
       
 
       
      kind: Kind.LIST_TYPE,

     

       
768
       
 
       
      type: {

     
···

       
772
       
 
       
          name: {

     

       
773
       
 
       
            kind: Kind.NAME,

     

       
774
       
 
       
            value: 'MyType',

     

       
775
       
+
       
          },

     

       
776
       
+
       
        },

     

       
777
       
+
       
      },

     

       
778
       
+
       
    });

     

       
779
       
+
       


     

       
780
       
+
       
    result = parseType('[[MyType!]]');

     

       
781
       
+
       
    expect(result).toEqual({

     

       
782
       
+
       
      kind: Kind.LIST_TYPE,

     

       
783
       
+
       
      type: {

     

       
784
       
+
       
        kind: Kind.LIST_TYPE,

     

       
785
       
+
       
        type: {

     

       
786
       
+
       
          kind: Kind.NON_NULL_TYPE,

     

       
787
       
+
       
          type: {

     

       
788
       
+
       
            kind: Kind.NAMED_TYPE,

     

       
789
       
+
       
            name: {

     

       
790
       
+
       
              kind: Kind.NAME,

     

       
791
       
+
       
              value: 'MyType',

     

       
792
       
+
       
            },

     

       
793
       
+
       
          },

     

       
794
       
+
       
        },

     

       
795
       
+
       
      },

     

       
796
       
+
       
    });

     

       
797
       
+
       


     

       
798
       
+
       
    result = parseType('[[MyType!]]!');

     

       
799
       
+
       
    expect(result).toEqual({

     

       
800
       
+
       
      kind: Kind.NON_NULL_TYPE,

     

       
801
       
+
       
      type: {

     

       
802
       
+
       
        kind: Kind.LIST_TYPE,

     

       
803
       
+
       
        type: {

     

       
804
       
+
       
          kind: Kind.LIST_TYPE,

     

       
805
       
+
       
          type: {

     

       
806
       
+
       
            kind: Kind.NON_NULL_TYPE,

     

       
807
       
+
       
            type: {

     

       
808
       
+
       
              kind: Kind.NAMED_TYPE,

     

       
809
       
+
       
              name: {

     

       
810
       
+
       
                kind: Kind.NAME,

     

       
811
       
+
       
                value: 'MyType',

     

       
812
       
+
       
              },

     

       
813
       
+
       
            },

     

       
814
       
 
       
          },

     

       
815
       
 
       
        },

     

       
816
       
 
       
      },

     

···

       
66
       
 
       
}

     

       
67
       
 
       


     

       
68
       
 
       
const nameRe = /[_A-Za-z]\w*/y;

     

       
69
       
-
       
function name(): ast.NameNode | undefined {

     

       
70
       
-
       
  let match: string | undefined;

     

       
71
       
-
       
  if ((match = advance(nameRe))) {

     

       
72
       
-
       
    return {

     

       
73
       
-
       
      kind: 'Name' as Kind.NAME,

     

       
74
       
-
       
      value: match,

     

       
75
       
-
       
    };

     

       
76
       
-
       
  }

     

       
77
       
-
       
}

     

       
78
       
 
       


     

       
79
       
-
       
// NOTE(Safari10 Quirk): This needs to be wrapped in a non-capturing group

     

       
80
       
-
       
const constRe = /(?:null|true|false)/y;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
81
       
 
       


     

       
82
       
-
       
const variableRe = /\$[_A-Za-z]\w*/y;

     

       
83
       
-
       
const intRe = /-?\d+/y;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
84
       
 
       


     

       
85
       
-
       
// NOTE(Safari10 Quirk): This cannot be further simplified

     

       
86
       
-
       
const floatPartRe = /(?:\.\d+)?[eE][+-]?\d+|\.\d+/y;

     

       
0
       
 
       

     

       
87
       
 
       


     

       
88
       
 
       
const complexStringRe = /\\/g;

     

       
89
       
-
       
const blockStringRe = /"""(?:"""|(?:[\s\S]*?[^\\])""")/y;

     

       
90
       
-
       
const stringRe = /"(?:"|[^\r\n]*?[^\\]")/y;

     

       
91
       
 
       


     

       
92
       
 
       
function value(constant: true): ast.ConstValueNode;

     

       
93
       
 
       
function value(constant: boolean): ast.ValueNode;

     

       
94
       
 
       


     

       
95
       
-
       
function value(constant: boolean): ast.ValueNode | undefined {

     

       
96
       
-
       
  let out: ast.ValueNode | undefined;

     

       
97
       
 
       
  let match: string | undefined;

     

       
98
       
-
       
  if ((match = advance(constRe))) {

     

       
99
       
-
       
    out =

     

       
100
       
-
       
      match === 'null'

     

       
101
       
-
       
        ? {

     

       
102
       
-
       
            kind: 'NullValue' as Kind.NULL,

     

       
103
       
-
       
          }

     

       
104
       
-
       
        : {

     

       
105
       
-
       
            kind: 'BooleanValue' as Kind.BOOLEAN,

     

       
106
       
-
       
            value: match === 'true',

     

       
107
       
-
       
          };

     

       
108
       
-
       
  } else if (!constant && (match = advance(variableRe))) {

     

       
109
       
-
       
    out = {

     

       
110
       
-
       
      kind: 'Variable' as Kind.VARIABLE,

     

       
111
       
-
       
      name: {

     

       
112
       
-
       
        kind: 'Name' as Kind.NAME,

     

       
113
       
-
       
        value: match.slice(1),

     

       
114
       
-
       
      },

     

       
115
       
-
       
    };

     

       
116
       
-
       
  } else if ((match = advance(intRe))) {

     

       
117
       
-
       
    const intPart = match;

     

       
118
       
-
       
    if ((match = advance(floatPartRe))) {

     

       
119
       
-
       
      out = {

     

       
120
       
-
       
        kind: 'FloatValue' as Kind.FLOAT,

     

       
121
       
-
       
        value: intPart + match,

     

       
122
       
-
       
      };

     

       
123
       
-
       
    } else {

     

       
124
       
-
       
      out = {

     

       
125
       
-
       
        kind: 'IntValue' as Kind.INT,

     

       
126
       
-
       
        value: intPart,

     

       
127
       
-
       
      };

     

       
128
       
-
       
    }

     

       
129
       
-
       
  } else if ((match = advance(nameRe))) {

     

       
130
       
-
       
    out = {

     

       
131
       
-
       
      kind: 'EnumValue' as Kind.ENUM,

     

       
132
       
-
       
      value: match,

     

       
133
       
-
       
    };

     

       
134
       
-
       
  } else if ((match = advance(blockStringRe))) {

     

       
135
       
-
       
    out = {

     

       
136
       
-
       
      kind: 'StringValue' as Kind.STRING,

     

       
137
       
-
       
      value: blockString(match.slice(3, -3)),

     

       
138
       
-
       
      block: true,

     

       
139
       
-
       
    };

     

       
140
       
-
       
  } else if ((match = advance(stringRe))) {

     

       
141
       
-
       
    out = {

     

       
142
       
-
       
      kind: 'StringValue' as Kind.STRING,

     

       
143
       
-
       
      value: complexStringRe.test(match) ? (JSON.parse(match) as string) : match.slice(1, -1),

     

       
144
       
-
       
      block: false,

     

       
145
       
-
       
    };

     

       
146
       
-
       
  } else if ((out = list(constant) || object(constant))) {

     

       
147
       
-
       
    return out;

     

       
148
       
-
       
  }

     

       
149
       
-
       


     

       
150
       
-
       
  ignored();

     

       
151
       
-
       
  return out;

     

       
152
       
-
       
}

     

       
153
       
-
       


     

       
154
       
-
       
function list(constant: boolean): ast.ListValueNode | undefined {

     

       
155
       
-
       
  let match: ast.ValueNode | undefined;

     

       
156
       
 
       
  if (input.charCodeAt(idx) === 91 /*'['*/) {

     

       
0
       
 
       

     

       
157
       
 
       
    idx++;

     

       
158
       
 
       
    ignored();

     

       
159
       
 
       
    const values: ast.ValueNode[] = [];

     

       
160
       
-
       
    while ((match = value(constant))) values.push(match);

     

       
161
       
-
       
    if (input.charCodeAt(idx++) !== 93 /*']'*/) throw error('ListValue');

     

       
162
       
 
       
    ignored();

     

       
163
       
 
       
    return {

     

       
164
       
 
       
      kind: 'ListValue' as Kind.LIST,

     

       
165
       
 
       
      values,

     

       
166
       
 
       
    };

     

       
167
       
-
       
  }

     

       
168
       
-
       
}

     

       
169
       
-
       


     

       
170
       
-
       
function object(constant: boolean): ast.ObjectValueNode | undefined {

     

       
171
       
-
       
  if (input.charCodeAt(idx) === 123 /*'{'*/) {

     

       
172
       
 
       
    idx++;

     

       
173
       
 
       
    ignored();

     

       
174
       
 
       
    const fields: ast.ObjectFieldNode[] = [];

     

       
175
       
-
       
    let _name: ast.NameNode | undefined;

     

       
176
       
-
       
    while ((_name = name())) {

     

       
177
       
 
       
      ignored();

     

       
178
       
-
       
      if (input.charCodeAt(idx++) !== 58 /*':'*/) throw error('ObjectField' as Kind.OBJECT_FIELD);

     

       
179
       
 
       
      ignored();

     

       
180
       
-
       
      const _value = value(constant);

     

       
181
       
-
       
      if (!_value) throw error('ObjectField');

     

       
182
       
 
       
      fields.push({

     

       
183
       
 
       
        kind: 'ObjectField' as Kind.OBJECT_FIELD,

     

       
184
       
-
       
        name: _name,

     

       
185
       
-
       
        value: _value,

     

       
186
       
 
       
      });

     

       
187
       
 
       
    }

     

       
188
       
-
       
    if (input.charCodeAt(idx++) !== 125 /*'}'*/) throw error('ObjectValue');

     

       
189
       
 
       
    ignored();

     

       
190
       
 
       
    return {

     

       
191
       
 
       
      kind: 'ObjectValue' as Kind.OBJECT,

     

       
192
       
 
       
      fields,

     

       
193
       
 
       
    };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
194
       
 
       
  }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
195
       
 
       
}

     

       
196
       
 
       


     

       
197
       
-
       
function arguments_(constant: boolean): ast.ArgumentNode[] {

     

       
198
       
-
       
  const args: ast.ArgumentNode[] = [];

     

       
199
       
-
       
  ignored();

     

       
200
       
 
       
  if (input.charCodeAt(idx) === 40 /*'('*/) {

     

       
0
       
 
       

     

       
201
       
 
       
    idx++;

     

       
202
       
 
       
    ignored();

     

       
203
       
-
       
    let _name: ast.NameNode | undefined;

     

       
204
       
-
       
    while ((_name = name())) {

     

       
0
       
 
       

     

       
205
       
 
       
      ignored();

     

       
206
       
 
       
      if (input.charCodeAt(idx++) !== 58 /*':'*/) throw error('Argument');

     

       
207
       
 
       
      ignored();

     

       
208
       
-
       
      const _value = value(constant);

     

       
209
       
-
       
      if (!_value) throw error('Argument');

     

       
210
       
 
       
      args.push({

     

       
211
       
 
       
        kind: 'Argument' as Kind.ARGUMENT,

     

       
212
       
-
       
        name: _name,

     

       
213
       
-
       
        value: _value,

     

       
214
       
 
       
      });

     

       
215
       
-
       
    }

     

       
216
       
-
       
    if (!args.length || input.charCodeAt(idx++) !== 41 /*')'*/) throw error('Argument');

     

       
217
       
-
       
    ignored();

     

       
218
       
-
       
  }

     

       
219
       
-
       
  return args;

     

       
220
       
-
       
}

     

       
221
       
-
       


     

       
222
       
-
       
function directives(constant: true): ast.ConstDirectiveNode[];

     

       
223
       
-
       
function directives(constant: boolean): ast.DirectiveNode[];

     

       
224
       
-
       


     

       
225
       
-
       
function directives(constant: boolean): ast.DirectiveNode[] {

     

       
226
       
-
       
  const directives: ast.DirectiveNode[] = [];

     

       
227
       
-
       
  ignored();

     

       
228
       
-
       
  while (input.charCodeAt(idx) === 64 /*'@'*/) {

     

       
229
       
 
       
    idx++;

     

       
230
       
-
       
    const _name = name();

     

       
231
       
-
       
    if (!_name) throw error('Directive');

     

       
232
       
 
       
    ignored();

     

       
233
       
-
       
    directives.push({

     

       
234
       
-
       
      kind: 'Directive' as Kind.DIRECTIVE,

     

       
235
       
-
       
      name: _name,

     

       
236
       
-
       
      arguments: arguments_(constant),

     

       
237
       
-
       
    });

     

       
238
       
 
       
  }

     

       
239
       
-
       
  return directives;

     

       
240
       
 
       
}

     

       
241
       
 
       


     

       
242
       
-
       
function field(): ast.FieldNode | undefined {

     

       
243
       
-
       
  let _name = name();

     

       
244
       
-
       
  if (_name) {

     

       
245
       
-
       
    ignored();

     

       
246
       
-
       
    let _alias: ast.NameNode | undefined;

     

       
247
       
-
       
    if (input.charCodeAt(idx) === 58 /*':'*/) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
248
       
 
       
      idx++;

     

       
0
       
 
       

     

       
249
       
 
       
      ignored();

     

       
250
       
-
       
      _alias = _name;

     

       
251
       
-
       
      _name = name();

     

       
252
       
-
       
      if (!_name) throw error('Field');

     

       
253
       
-
       
      ignored();

     

       
254
       
-
       
    }

     

       
255
       
-
       
    return {

     

       
256
       
-
       
      kind: 'Field' as Kind.FIELD,

     

       
257
       
-
       
      alias: _alias,

     

       
258
       
-
       
      name: _name,

     

       
259
       
-
       
      arguments: arguments_(false),

     

       
260
       
-
       
      directives: directives(false),

     

       
261
       
-
       
      selectionSet: selectionSet(),

     

       
262
       
-
       
    };

     

       
263
       
 
       
  }

     

       
264
       
 
       
}

     

       
265
       
 
       


     

       
266
       
 
       
function type(): ast.TypeNode {

     

       
267
       
-
       
  let match: ast.NameNode | ast.TypeNode | undefined;

     

       
268
       
-
       
  ignored();

     

       
269
       
-
       
  if (input.charCodeAt(idx) === 91 /*'['*/) {

     

       
0
       
 
       

     

       
270
       
 
       
    idx++;

     

       
271
       
 
       
    ignored();

     

       
272
       
-
       
    const _type = type();

     

       
273
       
-
       
    if (!_type || input.charCodeAt(idx++) !== 93 /*']'*/) throw error('ListType');

     

       
274
       
-
       
    match = {

     

       
275
       
-
       
      kind: 'ListType' as Kind.LIST_TYPE,

     

       
276
       
-
       
      type: _type,

     

       
277
       
-
       
    };

     

       
278
       
-
       
  } else if ((match = name())) {

     

       
279
       
-
       
    match = {

     

       
280
       
-
       
      kind: 'NamedType' as Kind.NAMED_TYPE,

     

       
281
       
-
       
      name: match,

     

       
282
       
-
       
    };

     

       
283
       
-
       
  } else {

     

       
284
       
-
       
    throw error('NamedType');

     

       
285
       
 
       
  }

     

       
286
       
-
       


     

       
287
       
 
       
  ignored();

     

       
288
       
-
       
  if (input.charCodeAt(idx) === 33 /*'!'*/) {

     

       
289
       
-
       
    idx++;

     

       
290
       
-
       
    ignored();

     

       
291
       
-
       
    return {

     

       
292
       
-
       
      kind: 'NonNullType' as Kind.NON_NULL_TYPE,

     

       
293
       
-
       
      type: match,

     

       
294
       
-
       
    };

     

       
295
       
-
       
  } else {

     

       
296
       
-
       
    return match;

     

       
297
       
-
       
  }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
298
       
 
       
}

     

       
299
       
 
       


     

       
300
       
-
       
const typeConditionRe = /on/y;

     

       
301
       
-
       
function typeCondition(): ast.NamedTypeNode | undefined {

     

       
302
       
-
       
  if (advance(typeConditionRe)) {

     

       
303
       
-
       
    ignored();

     

       
304
       
-
       
    const _name = name();

     

       
305
       
-
       
    if (!_name) throw error('NamedType');

     

       
306
       
-
       
    ignored();

     

       
307
       
-
       
    return {

     

       
308
       
-
       
      kind: 'NamedType' as Kind.NAMED_TYPE,

     

       
309
       
-
       
      name: _name,

     

       
310
       
-
       
    };

     

       
311
       
-
       
  }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
312
       
 
       
}

     

       
313
       
 
       


     

       
314
       
-
       
const fragmentSpreadRe = /\.\.\./y;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
315
       
 
       


     

       
316
       
-
       
function fragmentSpread(): ast.FragmentSpreadNode | ast.InlineFragmentNode | undefined {

     

       
317
       
-
       
  if (advance(fragmentSpreadRe)) {

     

       
318
       
-
       
    ignored();

     

       
319
       
-
       
    const _idx = idx;

     

       
320
       
-
       
    let _name: ast.NameNode | undefined;

     

       
321
       
-
       
    if ((_name = name()) && _name.value !== 'on') {

     

       
322
       
-
       
      return {

     

       
323
       
-
       
        kind: 'FragmentSpread' as Kind.FRAGMENT_SPREAD,

     

       
324
       
-
       
        name: _name,

     

       
325
       
-
       
        directives: directives(false),

     

       
326
       
-
       
      };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
327
       
 
       
    } else {

     

       
328
       
-
       
      idx = _idx;

     

       
329
       
-
       
      const _typeCondition = typeCondition();

     

       
330
       
-
       
      const _directives = directives(false);

     

       
331
       
-
       
      const _selectionSet = selectionSet();

     

       
332
       
-
       
      if (!_selectionSet) throw error('InlineFragment');

     

       
333
       
-
       
      return {

     

       
334
       
-
       
        kind: 'InlineFragment' as Kind.INLINE_FRAGMENT,

     

       
335
       
-
       
        typeCondition: _typeCondition,

     

       
336
       
-
       
        directives: _directives,

     

       
337
       
-
       
        selectionSet: _selectionSet,

     

       
338
       
-
       
      };

     

       
339
       
 
       
    }

     

       
340
       
-
       
  }

     

       
341
       
-
       
}

     

       
342
       
-
       


     

       
343
       
-
       
function selectionSet(): ast.SelectionSetNode | undefined {

     

       
344
       
-
       
  let match: ast.SelectionNode | undefined;

     

       
345
       
 
       
  ignored();

     

       
346
       
-
       
  if (input.charCodeAt(idx) === 123 /*'{'*/) {

     

       
347
       
-
       
    idx++;

     

       
348
       
-
       
    ignored();

     

       
349
       
-
       
    const selections: ast.SelectionNode[] = [];

     

       
350
       
-
       
    while ((match = fragmentSpread() || field())) selections.push(match);

     

       
351
       
-
       
    if (!selections.length || input.charCodeAt(idx++) !== 125 /*'}'*/) throw error('SelectionSet');

     

       
352
       
-
       
    ignored();

     

       
353
       
-
       
    return {

     

       
354
       
-
       
      kind: 'SelectionSet' as Kind.SELECTION_SET,

     

       
355
       
-
       
      selections,

     

       
356
       
-
       
    };

     

       
357
       
-
       
  }

     

       
358
       
 
       
}

     

       
359
       
 
       


     

       
360
       
-
       
function variableDefinitions(): ast.VariableDefinitionNode[] {

     

       
361
       
-
       
  let match: string | undefined;

     

       
362
       
-
       
  const vars: ast.VariableDefinitionNode[] = [];

     

       
363
       
 
       
  ignored();

     

       
364
       
 
       
  if (input.charCodeAt(idx) === 40 /*'('*/) {

     

       
0
       
 
       

     

       
365
       
 
       
    idx++;

     

       
366
       
 
       
    ignored();

     

       
367
       
-
       
    while ((match = advance(variableRe))) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
368
       
 
       
      ignored();

     

       
369
       
 
       
      if (input.charCodeAt(idx++) !== 58 /*':'*/) throw error('VariableDefinition');

     

       
0
       
 
       

     

       
370
       
 
       
      const _type = type();

     

       
371
       
-
       
      let _defaultValue: ast.ValueNode | undefined;

     

       
372
       
 
       
      if (input.charCodeAt(idx) === 61 /*'='*/) {

     

       
373
       
 
       
        idx++;

     

       
374
       
 
       
        ignored();

     

       
375
       
 
       
        _defaultValue = value(true);

     

       
376
       
-
       
        if (!_defaultValue) throw error('VariableDefinition');

     

       
377
       
 
       
      }

     

       
378
       
 
       
      ignored();

     

       
379
       
 
       
      vars.push({

     

       
380
       
 
       
        kind: 'VariableDefinition' as Kind.VARIABLE_DEFINITION,

     

       
381
       
 
       
        variable: {

     

       
382
       
 
       
          kind: 'Variable' as Kind.VARIABLE,

     

       
383
       
-
       
          name: {

     

       
384
       
-
       
            kind: 'Name' as Kind.NAME,

     

       
385
       
-
       
            value: match.slice(1),

     

       
386
       
-
       
          },

     

       
387
       
 
       
        },

     

       
388
       
 
       
        type: _type,

     

       
389
       
-
       
        defaultValue: _defaultValue as ast.ConstValueNode,

     

       
390
       
 
       
        directives: directives(true),

     

       
391
       
 
       
      });

     

       
392
       
-
       
    }

     

       
393
       
-
       
    if (input.charCodeAt(idx++) !== 41 /*')'*/) throw error('VariableDefinition');

     

       
394
       
 
       
    ignored();

     

       
0
       
 
       

     

       
395
       
 
       
  }

     

       
396
       
-
       
  return vars;

     

       
397
       
 
       
}

     

       
398
       
 
       


     

       
399
       
-
       
const fragmentDefinitionRe = /fragment/y;

     

       
400
       
-
       
function fragmentDefinition(): ast.FragmentDefinitionNode | undefined {

     

       
401
       
-
       
  if (advance(fragmentDefinitionRe)) {

     

       
402
       
-
       
    ignored();

     

       
403
       
-
       
    const _name = name();

     

       
404
       
-
       
    if (!_name) throw error('FragmentDefinition');

     

       
405
       
-
       
    ignored();

     

       
406
       
-
       
    const _typeCondition = typeCondition();

     

       
407
       
-
       
    if (!_typeCondition) throw error('FragmentDefinition');

     

       
408
       
-
       
    const _directives = directives(false);

     

       
409
       
-
       
    const _selectionSet = selectionSet();

     

       
410
       
-
       
    if (!_selectionSet) throw error('FragmentDefinition');

     

       
411
       
-
       
    return {

     

       
412
       
-
       
      kind: 'FragmentDefinition' as Kind.FRAGMENT_DEFINITION,

     

       
413
       
-
       
      name: _name,

     

       
414
       
-
       
      typeCondition: _typeCondition,

     

       
415
       
-
       
      directives: _directives,

     

       
416
       
-
       
      selectionSet: _selectionSet,

     

       
417
       
-
       
    };

     

       
418
       
-
       
  }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
419
       
 
       
}

     

       
420
       
 
       


     

       
421
       
-
       
// NOTE(Safari10 Quirk): This *might* need to be wrapped in a group, but worked without it too

     

       
422
       
-
       
const operationDefinitionRe = /(?:query|mutation|subscription)/y;

     

       
423
       
 
       


     

       
424
       
-
       
function operationDefinition(): ast.OperationDefinitionNode | undefined {

     

       
425
       
-
       
  let _operation: string | undefined;

     

       
426
       
-
       
  let _name: ast.NameNode | undefined;

     

       
427
       
-
       
  let _variableDefinitions: ast.VariableDefinitionNode[] = [];

     

       
428
       
-
       
  let _directives: ast.DirectiveNode[] = [];

     

       
429
       
-
       
  if ((_operation = advance(operationDefinitionRe))) {

     

       
0
       
 
       

     

       
430
       
 
       
    ignored();

     

       
431
       
-
       
    _name = name();

     

       
432
       
 
       
    _variableDefinitions = variableDefinitions();

     

       
433
       
 
       
    _directives = directives(false);

     

       
434
       
 
       
  }

     

       
435
       
-
       
  const _selectionSet = selectionSet();

     

       
436
       
-
       
  if (_selectionSet) {

     

       
0
       
 
       

     

       
437
       
 
       
    return {

     

       
438
       
 
       
      kind: 'OperationDefinition' as Kind.OPERATION_DEFINITION,

     

       
439
       
-
       
      operation: (_operation || 'query') as OperationTypeNode,

     

       
440
       
-
       
      name: _name,

     

       
441
       
 
       
      variableDefinitions: _variableDefinitions,

     

       
442
       
 
       
      directives: _directives,

     

       
443
       
-
       
      selectionSet: _selectionSet,

     

       
444
       
 
       
    };

     

       
445
       
 
       
  }

     

       
446
       
 
       
}

     

       
447
       
 
       


     

       
448
       
 
       
function document(): ast.DocumentNode {

     

       
449
       
-
       
  let match: ast.ExecutableDefinitionNode | void;

     

       
0
       
 
       

     

       
450
       
 
       
  ignored();

     

       
451
       
 
       
  const definitions: ast.ExecutableDefinitionNode[] = [];

     

       
452
       
-
       
  while ((match = fragmentDefinition() || operationDefinition())) definitions.push(match);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
453
       
 
       
  return {

     

       
454
       
 
       
    kind: 'Document' as Kind.DOCUMENT,

     

       
455
       
 
       
    definitions,

     
···

       
476
       
 
       
  input = typeof string.body === 'string' ? string.body : string;

     

       
477
       
 
       
  idx = 0;

     

       
478
       
 
       
  ignored();

     

       
479
       
-
       
  const _value = value(false);

     

       
480
       
-
       
  if (!_value) throw error('ValueNode');

     

       
481
       
-
       
  return _value;

     

       
482
       
 
       
}

     

       
483
       
 
       


     

       
484
       
 
       
export function parseType(