@0no-co/graphql.web 0.1.3 → 0.1.4

package/dist/graphql.web.mjs

@@ -1,42 +1,31 @@
-var e;
-
-!function(e) {
-  e.QUERY = "query";
-  e.MUTATION = "mutation";
-  e.SUBSCRIPTION = "subscription";
-}(e || (e = {}));
-
-var r;
-
-!function(e) {
-  e.NAME = "Name";
-  e.DOCUMENT = "Document";
-  e.OPERATION_DEFINITION = "OperationDefinition";
-  e.VARIABLE_DEFINITION = "VariableDefinition";
-  e.SELECTION_SET = "SelectionSet";
-  e.FIELD = "Field";
-  e.ARGUMENT = "Argument";
-  e.FRAGMENT_SPREAD = "FragmentSpread";
-  e.INLINE_FRAGMENT = "InlineFragment";
-  e.FRAGMENT_DEFINITION = "FragmentDefinition";
-  e.VARIABLE = "Variable";
-  e.INT = "IntValue";
-  e.FLOAT = "FloatValue";
-  e.STRING = "StringValue";
-  e.BOOLEAN = "BooleanValue";
-  e.NULL = "NullValue";
-  e.ENUM = "EnumValue";
-  e.LIST = "ListValue";
-  e.OBJECT = "ObjectValue";
-  e.OBJECT_FIELD = "ObjectField";
-  e.DIRECTIVE = "Directive";
-  e.NAMED_TYPE = "NamedType";
-  e.LIST_TYPE = "ListType";
-  e.NON_NULL_TYPE = "NonNullType";
-}(r || (r = {}));
+var e = {
+  NAME: "Name",
+  DOCUMENT: "Document",
+  OPERATION_DEFINITION: "OperationDefinition",
+  VARIABLE_DEFINITION: "VariableDefinition",
+  SELECTION_SET: "SelectionSet",
+  FIELD: "Field",
+  ARGUMENT: "Argument",
+  FRAGMENT_SPREAD: "FragmentSpread",
+  INLINE_FRAGMENT: "InlineFragment",
+  FRAGMENT_DEFINITION: "FragmentDefinition",
+  VARIABLE: "Variable",
+  OBJECT: "ObjectValue",
+  OBJECT_FIELD: "ObjectField",
+  DIRECTIVE: "Directive",
+  NAMED_TYPE: "NamedType",
+  LIST_TYPE: "ListType",
+  NON_NULL_TYPE: "NonNullType"
+};
+
+var r = {
+  QUERY: "query",
+  MUTATION: "mutation",
+  SUBSCRIPTION: "subscription"
+};
 
 class GraphQLError extends Error {
-  constructor(e, r, n, i, t, a, o) {
+  constructor(e, r, i, n, t, a, o) {
     super(e);
     this.name = "GraphQLError";
     this.message = e;
@@ -46,19 +35,19 @@ class GraphQLError extends Error {
     if (r) {
       this.nodes = Array.isArray(r) ? r : [ r ];
     }
-    if (n) {
-      this.source = n;
-    }
     if (i) {
-      this.positions = i;
+      this.source = i;
+    }
+    if (n) {
+      this.positions = n;
     }
     if (a) {
       this.originalError = a;
     }
     if (!o && a) {
-      var u = a.extensions;
-      if (u && "object" == typeof u) {
-        u;
+      var l = a.extensions;
+      if (l && "object" == typeof l) {
+        l;
       }
     }
     this.extensions = o || {};
@@ -71,20 +60,23 @@ class GraphQLError extends Error {
   toString() {
     return this.message;
   }
+  get [Symbol.toStringTag]() {
+    return "GraphQLError";
+  }
 }
 
-var n;
-
 var i;
 
+var n;
+
 function error(e) {
-  return new GraphQLError(`Syntax Error: Unexpected token at ${i} in ${e}`);
+  return new GraphQLError(`Syntax Error: Unexpected token at ${n} in ${e}`);
 }
 
 function advance(e) {
-  e.lastIndex = i;
-  if (e.test(n)) {
-    return n.slice(i, i = e.lastIndex);
+  e.lastIndex = n;
+  if (e.test(i)) {
+    return i.slice(n, n = e.lastIndex);
   }
 }
 
@@ -92,25 +84,25 @@ var t = / +(?=[^\s])/y;
 
 function blockString(e) {
   var r = "";
-  var n = 0;
   var i = 0;
+  var n = 0;
   var a = -1;
   var o = e.split("\n");
-  for (var u = 0; u < o.length; u++) {
+  for (var l = 0; l < o.length; l++) {
     t.lastIndex = 0;
-    if (t.test(o[u])) {
-      if (u && (!n || t.lastIndex < n)) {
-        n = t.lastIndex;
+    if (t.test(o[l])) {
+      if (l && (!i || t.lastIndex < i)) {
+        i = t.lastIndex;
       }
-      i = i || u;
-      a = u;
+      n = n || l;
+      a = l;
     }
   }
-  for (var s = i; s <= a; s++) {
-    if (s !== i) {
+  for (var u = n; u <= a; u++) {
+    if (u !== n) {
       r += "\n";
     }
-    r += o[s].slice(n).replace(/\\"""/g, '"""');
+    r += o[u].slice(i).replace(/\\"""/g, '"""');
   }
   return r;
 }
@@ -118,9 +110,9 @@ function blockString(e) {
 var a = /(?:[\s,]*|#[^\n\r]*)*/y;
 
 function ignored() {
-  a.lastIndex = i;
-  a.test(n);
-  i = a.lastIndex;
+  a.lastIndex = n;
+  a.test(i);
+  n = a.lastIndex;
 }
 
 var o = /[_\w][_\d\w]*/y;
@@ -129,179 +121,175 @@ function name() {
   var e;
   if (e = advance(o)) {
     return {
-      kind: r.NAME,
+      kind: "Name",
       value: e
     };
   }
 }
 
-var u = /null/y;
-
-var s = /true|false/y;
+var l = /null|true|false/y;
 
-var l = /\$[_\w][_\d\w]*/y;
+var u = /\$[_\w][_\d\w]*/y;
 
-var v = /[-]?\d+/y;
+var s = /[-]?\d+/y;
 
 var d = /(?:[-]?\d+)?(?:\.\d+)(?:[eE][+-]?\d+)?/y;
 
-var c = /\\/g;
+var v = /\\/g;
 
-var f = /"""(?:[\s\S]+(?="""))?"""/y;
+var c = /"""(?:[\s\S]+(?="""))?"""/y;
 
-var E = /"(?:[^"\r\n]+)?"/y;
+var f = /"(?:[^"\r\n]+)?"/y;
 
 function value(e) {
+  var r;
   var t;
-  var a;
-  if (advance(u)) {
-    t = {
-      kind: r.NULL
-    };
-  } else if (a = advance(s)) {
-    t = {
-      kind: r.BOOLEAN,
-      value: "true" === a
+  if (t = advance(l)) {
+    r = "null" === t ? {
+      kind: "NullValue"
+    } : {
+      kind: "BooleanValue",
+      value: "true" === t
     };
-  } else if (!e && (a = advance(l))) {
-    t = {
-      kind: r.VARIABLE,
+  } else if (!e && (t = advance(u))) {
+    r = {
+      kind: "Variable",
       name: {
-        kind: r.NAME,
-        value: a.slice(1)
+        kind: "Name",
+        value: t.slice(1)
       }
     };
-  } else if (a = advance(d)) {
-    t = {
-      kind: r.FLOAT,
-      value: a
+  } else if (t = advance(d)) {
+    r = {
+      kind: "FloatValue",
+      value: t
     };
-  } else if (a = advance(v)) {
-    t = {
-      kind: r.INT,
-      value: a
+  } else if (t = advance(s)) {
+    r = {
+      kind: "IntValue",
+      value: t
     };
-  } else if (a = advance(o)) {
-    t = {
-      kind: r.ENUM,
-      value: a
+  } else if (t = advance(o)) {
+    r = {
+      kind: "EnumValue",
+      value: t
     };
-  } else if (a = advance(f)) {
-    t = {
-      kind: r.STRING,
-      value: blockString(a.slice(3, -3)),
+  } else if (t = advance(c)) {
+    r = {
+      kind: "StringValue",
+      value: blockString(t.slice(3, -3)),
       block: !0
     };
-  } else if (a = advance(E)) {
-    t = {
-      kind: r.STRING,
-      value: c.test(a) ? JSON.parse(a) : a.slice(1, -1),
+  } else if (t = advance(f)) {
+    r = {
+      kind: "StringValue",
+      value: v.test(t) ? JSON.parse(t) : t.slice(1, -1),
       block: !1
     };
-  } else if (t = function list(e) {
-    var t;
-    if (91 === n.charCodeAt(i)) {
-      i++;
+  } else if (r = function list(e) {
+    var r;
+    if (91 === i.charCodeAt(n)) {
+      n++;
       ignored();
-      var a = [];
-      while (t = value(e)) {
-        a.push(t);
+      var t = [];
+      while (r = value(e)) {
+        t.push(r);
       }
-      if (93 !== n.charCodeAt(i++)) {
-        throw error(r.LIST);
+      if (93 !== i.charCodeAt(n++)) {
+        throw error("ListValue");
       }
       ignored();
       return {
-        kind: r.LIST,
-        values: a
+        kind: "ListValue",
+        values: t
       };
     }
   }(e) || function object(e) {
-    if (123 === n.charCodeAt(i)) {
-      i++;
+    if (123 === i.charCodeAt(n)) {
+      n++;
       ignored();
-      var t = [];
-      var a;
-      while (a = name()) {
+      var r = [];
+      var t;
+      while (t = name()) {
         ignored();
-        if (58 !== n.charCodeAt(i++)) {
-          throw error(r.OBJECT_FIELD);
+        if (58 !== i.charCodeAt(n++)) {
+          throw error("ObjectField");
         }
         ignored();
-        var o = value(e);
-        if (!o) {
-          throw error(r.OBJECT_FIELD);
+        var a = value(e);
+        if (!a) {
+          throw error("ObjectField");
         }
-        t.push({
-          kind: r.OBJECT_FIELD,
-          name: a,
-          value: o
+        r.push({
+          kind: "ObjectField",
+          name: t,
+          value: a
         });
       }
-      if (125 !== n.charCodeAt(i++)) {
-        throw error(r.OBJECT);
+      if (125 !== i.charCodeAt(n++)) {
+        throw error("ObjectValue");
       }
       ignored();
       return {
-        kind: r.OBJECT,
-        fields: t
+        kind: "ObjectValue",
+        fields: r
       };
     }
   }(e)) {
-    return t;
+    return r;
   }
   ignored();
-  return t;
+  return r;
 }
 
 function arguments_(e) {
-  var t = [];
+  var r = [];
   ignored();
-  if (40 === n.charCodeAt(i)) {
-    i++;
+  if (40 === i.charCodeAt(n)) {
+    n++;
     ignored();
-    var a;
-    while (a = name()) {
+    var t;
+    while (t = name()) {
       ignored();
-      if (58 !== n.charCodeAt(i++)) {
-        throw error(r.ARGUMENT);
+      if (58 !== i.charCodeAt(n++)) {
+        throw error("Argument");
       }
       ignored();
-      var o = value(e);
-      if (!o) {
-        throw error(r.ARGUMENT);
+      var a = value(e);
+      if (!a) {
+        throw error("Argument");
       }
-      t.push({
-        kind: r.ARGUMENT,
-        name: a,
-        value: o
+      r.push({
+        kind: "Argument",
+        name: t,
+        value: a
       });
     }
-    if (!t.length || 41 !== n.charCodeAt(i++)) {
-      throw error(r.ARGUMENT);
+    if (!r.length || 41 !== i.charCodeAt(n++)) {
+      throw error("Argument");
     }
     ignored();
   }
-  return t;
+  return r;
 }
 
 function directives(e) {
-  var t = [];
+  var r = [];
   ignored();
-  while (64 === n.charCodeAt(i)) {
-    i++;
-    var a = name();
-    if (!a) {
-      throw error(r.DIRECTIVE);
+  while (64 === i.charCodeAt(n)) {
+    n++;
+    var t = name();
+    if (!t) {
+      throw error("Directive");
     }
     ignored();
-    t.push({
-      kind: r.DIRECTIVE,
-      name: a,
+    r.push({
+      kind: "Directive",
+      name: t,
       arguments: arguments_(e)
     });
   }
-  return t;
+  return r;
 }
 
 function field() {
@@ -309,19 +297,19 @@ function field() {
   var e = name();
   if (e) {
     ignored();
-    var t;
-    if (58 === n.charCodeAt(i)) {
-      i++;
+    var r;
+    if (58 === i.charCodeAt(n)) {
+      n++;
       ignored();
-      t = e;
+      r = e;
       if (!(e = name())) {
-        throw error(r.FIELD);
+        throw error("Field");
       }
       ignored();
     }
     return {
-      kind: r.FIELD,
-      alias: t,
+      kind: "Field",
+      alias: r,
       name: e,
       arguments: arguments_(!1),
       directives: directives(!1),
@@ -333,31 +321,31 @@ function field() {
 function type() {
   var e;
   ignored();
-  if (91 === n.charCodeAt(i)) {
-    i++;
+  if (91 === i.charCodeAt(n)) {
+    n++;
     ignored();
-    var t = type();
-    if (!t || 93 !== n.charCodeAt(i++)) {
-      throw error(r.LIST_TYPE);
+    var r = type();
+    if (!r || 93 !== i.charCodeAt(n++)) {
+      throw error("ListType");
     }
     e = {
-      kind: r.LIST_TYPE,
-      type: t
+      kind: "ListType",
+      type: r
     };
   } else if (e = name()) {
     e = {
-      kind: r.NAMED_TYPE,
+      kind: "NamedType",
       name: e
     };
   } else {
-    throw error(r.NAMED_TYPE);
+    throw error("NamedType");
   }
   ignored();
-  if (33 === n.charCodeAt(i)) {
-    i++;
+  if (33 === i.charCodeAt(n)) {
+    n++;
     ignored();
     return {
-      kind: r.NON_NULL_TYPE,
+      kind: "NonNullType",
       type: e
     };
   } else {
@@ -372,43 +360,43 @@ function typeCondition() {
     ignored();
     var e = name();
     if (!e) {
-      throw error(r.NAMED_TYPE);
+      throw error("NamedType");
     }
     ignored();
     return {
-      kind: r.NAMED_TYPE,
+      kind: "NamedType",
       name: e
     };
   }
 }
 
-var N = /\.\.\./y;
+var m = /\.\.\./y;
 
 function fragmentSpread() {
   ignored();
-  if (advance(N)) {
+  if (advance(m)) {
     ignored();
-    var e = i;
-    var n;
-    if ((n = name()) && "on" !== n.value) {
+    var e = n;
+    var r;
+    if ((r = name()) && "on" !== r.value) {
       return {
-        kind: r.FRAGMENT_SPREAD,
-        name: n,
+        kind: "FragmentSpread",
+        name: r,
         directives: directives(!1)
       };
     } else {
-      i = e;
-      var t = typeCondition();
-      var a = directives(!1);
-      var o = selectionSet();
-      if (!o) {
-        throw error(r.INLINE_FRAGMENT);
+      n = e;
+      var i = typeCondition();
+      var t = directives(!1);
+      var a = selectionSet();
+      if (!a) {
+        throw error("InlineFragment");
       }
       return {
-        kind: r.INLINE_FRAGMENT,
-        typeCondition: t,
-        directives: a,
-        selectionSet: o
+        kind: "InlineFragment",
+        typeCondition: i,
+        directives: t,
+        selectionSet: a
       };
     }
   }
@@ -417,236 +405,244 @@ function fragmentSpread() {
 function selectionSet() {
   var e;
   ignored();
-  if (123 === n.charCodeAt(i)) {
-    i++;
+  if (123 === i.charCodeAt(n)) {
+    n++;
     ignored();
-    var t = [];
+    var r = [];
     while (e = fragmentSpread() || field()) {
-      t.push(e);
+      r.push(e);
     }
-    if (!t.length || 125 !== n.charCodeAt(i++)) {
-      throw error(r.SELECTION_SET);
+    if (!r.length || 125 !== i.charCodeAt(n++)) {
+      throw error("SelectionSet");
     }
     ignored();
     return {
-      kind: r.SELECTION_SET,
-      selections: t
+      kind: "SelectionSet",
+      selections: r
     };
   }
 }
 
-var I = /fragment/y;
+var g = /fragment/y;
 
 function fragmentDefinition() {
-  if (advance(I)) {
+  if (advance(g)) {
     ignored();
     var e = name();
     if (!e) {
-      throw error(r.FRAGMENT_DEFINITION);
+      throw error("FragmentDefinition");
     }
     ignored();
-    var n = typeCondition();
-    if (!n) {
-      throw error(r.FRAGMENT_DEFINITION);
+    var r = typeCondition();
+    if (!r) {
+      throw error("FragmentDefinition");
     }
     var i = directives(!1);
-    var t = selectionSet();
-    if (!t) {
-      throw error(r.FRAGMENT_DEFINITION);
+    var n = selectionSet();
+    if (!n) {
+      throw error("FragmentDefinition");
     }
     return {
-      kind: r.FRAGMENT_DEFINITION,
+      kind: "FragmentDefinition",
       name: e,
-      typeCondition: n,
+      typeCondition: r,
       directives: i,
-      selectionSet: t
+      selectionSet: n
     };
   }
 }
 
-var T = /query|mutation|subscription/y;
+var h = /query|mutation|subscription/y;
 
 function operationDefinition() {
   var e;
-  var t;
+  var r;
+  var t = [];
   var a = [];
-  var o = [];
-  if (e = advance(T)) {
+  if (e = advance(h)) {
     ignored();
-    t = name();
-    a = function variableDefinitions() {
+    r = name();
+    t = function variableDefinitions() {
       var e;
-      var t = [];
+      var r = [];
       ignored();
-      if (40 === n.charCodeAt(i)) {
-        i++;
+      if (40 === i.charCodeAt(n)) {
+        n++;
         ignored();
-        while (e = advance(l)) {
+        while (e = advance(u)) {
           ignored();
-          if (58 !== n.charCodeAt(i++)) {
-            throw error(r.VARIABLE_DEFINITION);
+          if (58 !== i.charCodeAt(n++)) {
+            throw error("VariableDefinition");
           }
-          var a = type();
-          if (!a) {
-            throw error(r.VARIABLE_DEFINITION);
+          var t = type();
+          if (!t) {
+            throw error("VariableDefinition");
           }
-          var o = void 0;
-          if (61 === n.charCodeAt(i)) {
-            i++;
+          var a = void 0;
+          if (61 === i.charCodeAt(n)) {
+            n++;
             ignored();
-            if (!(o = value(!0))) {
-              throw error(r.VARIABLE_DEFINITION);
+            if (!(a = value(!0))) {
+              throw error("VariableDefinition");
             }
           }
           ignored();
-          t.push({
-            kind: r.VARIABLE_DEFINITION,
+          r.push({
+            kind: "VariableDefinition",
             variable: {
-              kind: r.VARIABLE,
+              kind: "Variable",
               name: {
-                kind: r.NAME,
+                kind: "Name",
                 value: e.slice(1)
               }
             },
-            type: a,
-            defaultValue: o,
+            type: t,
+            defaultValue: a,
             directives: directives(!0)
           });
         }
-        if (41 !== n.charCodeAt(i++)) {
-          throw error(r.VARIABLE_DEFINITION);
+        if (41 !== i.charCodeAt(n++)) {
+          throw error("VariableDefinition");
         }
         ignored();
       }
-      return t;
+      return r;
     }();
-    o = directives(!1);
+    a = directives(!1);
   }
-  var u = selectionSet();
-  if (u) {
+  var o = selectionSet();
+  if (o) {
     return {
-      kind: r.OPERATION_DEFINITION,
+      kind: "OperationDefinition",
       operation: e || "query",
-      name: t,
-      variableDefinitions: a,
-      directives: o,
-      selectionSet: u
+      name: r,
+      variableDefinitions: t,
+      directives: a,
+      selectionSet: o
     };
   }
 }
 
-function parse(e) {
-  n = e;
-  i = 0;
+function parse(e, r) {
+  i = "string" == typeof e.body ? e.body : e;
+  n = 0;
   return function document() {
     var e;
     ignored();
-    var t = [];
+    var r = [];
     while (e = fragmentDefinition() || operationDefinition()) {
-      t.push(e);
+      r.push(e);
     }
-    if (i !== n.length) {
-      throw error(r.DOCUMENT);
+    if (n !== i.length) {
+      throw error("Document");
     }
     return {
-      kind: r.DOCUMENT,
-      definitions: t
+      kind: "Document",
+      definitions: r
     };
   }();
 }
 
-function parseValue(e) {
-  n = e;
-  i = 0;
+function parseValue(e, r) {
+  i = "string" == typeof e.body ? e.body : e;
+  n = 0;
   ignored();
-  return value(!1);
+  var t = value(!1);
+  if (!t) {
+    throw error("ValueNode");
+  }
+  return t;
 }
 
-function parseType(e) {
-  n = e;
-  i = 0;
-  return type();
+function parseType(e, r) {
+  i = "string" == typeof e.body ? e.body : e;
+  n = 0;
+  var t = type();
+  if (!t) {
+    throw error("TypeNode");
+  }
+  return t;
 }
 
-var A = {};
+var y = {};
 
 function visit(e, r) {
-  var n = [];
   var i = [];
+  var n = [];
   try {
     var t = function traverse(e, t, a) {
       var o = !1;
-      var u = r[e.kind] && r[e.kind].enter || r[e.kind];
-      var s = u && u.call(r, e, t, a, i, n);
-      if (!1 === s) {
+      var l = r[e.kind] && r[e.kind].enter || r[e.kind];
+      var u = l && l.call(r, e, t, a, n, i);
+      if (!1 === u) {
         return e;
-      } else if (null === s) {
+      } else if (null === u) {
         return null;
-      } else if (s === A) {
-        throw A;
-      } else if (s && "string" == typeof s.kind) {
-        o = s !== e;
-        e = s;
+      } else if (u === y) {
+        throw y;
+      } else if (u && "string" == typeof u.kind) {
+        o = u !== e;
+        e = u;
       }
       if (a) {
-        n.push(a);
+        i.push(a);
       }
-      var l;
-      var v = {
+      var s;
+      var d = {
         ...e
       };
-      for (var d in e) {
-        i.push(d);
-        var c = e[d];
+      for (var v in e) {
+        n.push(v);
+        var c = e[v];
         if (Array.isArray(c)) {
           var f = [];
-          for (var E = 0; E < c.length; E++) {
-            if (null != c[E] && "string" == typeof c[E].kind) {
-              n.push(e);
-              i.push(E);
-              l = traverse(c[E], E, c);
-              i.pop();
+          for (var p = 0; p < c.length; p++) {
+            if (null != c[p] && "string" == typeof c[p].kind) {
+              i.push(e);
+              n.push(p);
+              s = traverse(c[p], p, c);
               n.pop();
-              if (void 0 === l) {
-                f.push(c[E]);
-              } else if (null === l) {
+              i.pop();
+              if (void 0 === s) {
+                f.push(c[p]);
+              } else if (null === s) {
                 o = !0;
               } else {
-                o = o || l !== c[E];
-                f.push(l);
+                o = o || s !== c[p];
+                f.push(s);
               }
             }
           }
           c = f;
         } else if (null != c && "string" == typeof c.kind) {
-          if (void 0 !== (l = traverse(c, d, e))) {
-            o = o || c !== l;
-            c = l;
+          if (void 0 !== (s = traverse(c, v, e))) {
+            o = o || c !== s;
+            c = s;
           }
         }
-        i.pop();
+        n.pop();
         if (o) {
-          v[d] = c;
+          d[v] = c;
         }
       }
       if (a) {
-        n.pop();
+        i.pop();
       }
-      var p = r[e.kind] && r[e.kind].leave;
-      var N = p && p.call(r, e, t, a, i, n);
-      if (N === A) {
-        throw A;
-      } else if (void 0 !== N) {
-        return N;
-      } else if (void 0 !== s) {
-        return o ? v : s;
+      var m = r[e.kind] && r[e.kind].leave;
+      var g = m && m.call(r, e, t, a, n, i);
+      if (g === y) {
+        throw y;
+      } else if (void 0 !== g) {
+        return g;
+      } else if (void 0 !== u) {
+        return o ? d : u;
       } else {
-        return o ? v : e;
+        return o ? d : e;
       }
     }(e);
     return void 0 !== t && !1 !== t ? t : e;
   } catch (r) {
-    if (r !== A) {
+    if (r !== y) {
       throw r;
     }
     return e;
@@ -663,194 +659,195 @@ function printBlockString(e) {
 
 var hasItems = e => !(!e || !e.length);
 
-var h = 80;
+var S = 80;
 
 function print(e) {
-  var n;
+  var r;
   switch (e.kind) {
-   case r.OPERATION_DEFINITION:
+   case "OperationDefinition":
     if ("query" === e.operation && !e.name && !hasItems(e.variableDefinitions) && !hasItems(e.directives)) {
       return print(e.selectionSet);
     }
-    n = e.operation;
+    r = e.operation;
     if (e.name) {
-      n += " " + e.name.value;
+      r += " " + e.name.value;
     }
     if (hasItems(e.variableDefinitions)) {
       if (!e.name) {
-        n += " ";
+        r += " ";
       }
-      n += "(" + e.variableDefinitions.map(print).join(", ") + ")";
+      r += "(" + e.variableDefinitions.map(print).join(", ") + ")";
     }
     if (hasItems(e.directives)) {
-      n += " " + e.directives.map(print).join(" ");
+      r += " " + e.directives.map(print).join(" ");
     }
-    return n + " " + print(e.selectionSet);
+    return r + " " + print(e.selectionSet);
 
-   case r.VARIABLE_DEFINITION:
-    n = print(e.variable) + ": " + print(e.type);
+   case "VariableDefinition":
+    r = print(e.variable) + ": " + print(e.type);
     if (e.defaultValue) {
-      n += " = " + print(e.defaultValue);
+      r += " = " + print(e.defaultValue);
     }
     if (hasItems(e.directives)) {
-      n += " " + e.directives.map(print).join(" ");
+      r += " " + e.directives.map(print).join(" ");
     }
-    return n;
+    return r;
 
-   case r.FIELD:
-    n = (e.alias ? print(e.alias) + ": " : "") + e.name.value;
+   case "Field":
+    r = (e.alias ? print(e.alias) + ": " : "") + e.name.value;
     if (hasItems(e.arguments)) {
       var i = e.arguments.map(print);
-      var t = n + "(" + i.join(", ") + ")";
-      n = t.length > h ? n + "(\n  " + i.join("\n").replace(/\n/g, "\n  ") + "\n)" : t;
+      var n = r + "(" + i.join(", ") + ")";
+      r = n.length > S ? r + "(\n  " + i.join("\n").replace(/\n/g, "\n  ") + "\n)" : n;
     }
     if (hasItems(e.directives)) {
-      n += " " + e.directives.map(print).join(" ");
+      r += " " + e.directives.map(print).join(" ");
     }
-    return e.selectionSet ? n + " " + print(e.selectionSet) : n;
+    return e.selectionSet ? r + " " + print(e.selectionSet) : r;
 
-   case r.STRING:
+   case "StringValue":
     return e.block ? printBlockString(e.value) : printString(e.value);
 
-   case r.BOOLEAN:
+   case "BooleanValue":
     return "" + e.value;
 
-   case r.NULL:
+   case "NullValue":
     return "null";
 
-   case r.INT:
-   case r.FLOAT:
-   case r.ENUM:
-   case r.NAME:
+   case "IntValue":
+   case "FloatValue":
+   case "EnumValue":
+   case "Name":
     return e.value;
 
-   case r.LIST:
+   case "ListValue":
     return "[" + e.values.map(print).join(", ") + "]";
 
-   case r.OBJECT:
+   case "ObjectValue":
     return "{" + e.fields.map(print).join(", ") + "}";
 
-   case r.OBJECT_FIELD:
+   case "ObjectField":
+   case "Argument":
     return e.name.value + ": " + print(e.value);
 
-   case r.VARIABLE:
+   case "Variable":
     return "$" + e.name.value;
 
-   case r.DOCUMENT:
+   case "Document":
     return hasItems(e.definitions) ? e.definitions.map(print).join("\n\n") : "";
 
-   case r.SELECTION_SET:
+   case "SelectionSet":
     return "{\n  " + e.selections.map(print).join("\n").replace(/\n/g, "\n  ") + "\n}";
 
-   case r.ARGUMENT:
-    return e.name.value + ": " + print(e.value);
-
-   case r.FRAGMENT_SPREAD:
-    n = "..." + e.name.value;
+   case "FragmentSpread":
+    r = "..." + e.name.value;
     if (hasItems(e.directives)) {
-      n += " " + e.directives.map(print).join(" ");
+      r += " " + e.directives.map(print).join(" ");
     }
-    return n;
+    return r;
 
-   case r.INLINE_FRAGMENT:
-    n = "...";
+   case "InlineFragment":
+    r = "...";
     if (e.typeCondition) {
-      n += " on " + e.typeCondition.name.value;
+      r += " on " + e.typeCondition.name.value;
     }
     if (hasItems(e.directives)) {
-      n += " " + e.directives.map(print).join(" ");
+      r += " " + e.directives.map(print).join(" ");
     }
-    return n + " " + print(e.selectionSet);
+    return r + " " + print(e.selectionSet);
 
-   case r.FRAGMENT_DEFINITION:
-    n = "fragment " + e.name.value;
-    n += " on " + e.typeCondition.name.value;
+   case "FragmentDefinition":
+    r = "fragment " + e.name.value;
+    r += " on " + e.typeCondition.name.value;
     if (hasItems(e.directives)) {
-      n += " " + e.directives.map(print).join(" ");
+      r += " " + e.directives.map(print).join(" ");
     }
-    return n + " " + print(e.selectionSet);
+    return r + " " + print(e.selectionSet);
 
-   case r.DIRECTIVE:
-    n = "@" + e.name.value;
+   case "Directive":
+    r = "@" + e.name.value;
     if (hasItems(e.arguments)) {
-      n += "(" + e.arguments.map(print).join(", ") + ")";
+      r += "(" + e.arguments.map(print).join(", ") + ")";
     }
-    return n;
+    return r;
 
-   case r.NAMED_TYPE:
+   case "NamedType":
     return e.name.value;
 
-   case r.LIST_TYPE:
+   case "ListType":
     return "[" + print(e.type) + "]";
 
-   case r.NON_NULL_TYPE:
+   case "NonNullType":
     return print(e.type) + "!";
+
+   default:
+    return "";
   }
 }
 
-function valueFromASTUntyped(e, n) {
+function valueFromASTUntyped(e, r) {
   switch (e.kind) {
-   case r.NULL:
+   case "NullValue":
     return null;
 
-   case r.INT:
+   case "IntValue":
     return parseInt(e.value, 10);
 
-   case r.FLOAT:
+   case "FloatValue":
     return parseFloat(e.value);
 
-   case r.STRING:
-   case r.ENUM:
-   case r.BOOLEAN:
+   case "StringValue":
+   case "EnumValue":
+   case "BooleanValue":
     return e.value;
 
-   case r.LIST:
+   case "ListValue":
     var i = [];
-    for (var t = 0, a = e.values; t < a.length; t += 1) {
-      i.push(valueFromASTUntyped(a[t], n));
+    for (var n = 0, t = e.values; n < t.length; n += 1) {
+      i.push(valueFromASTUntyped(t[n], r));
     }
     return i;
 
-   case r.OBJECT:
-    var o = Object.create(null);
-    for (var u = 0, s = e.fields; u < s.length; u += 1) {
-      var l = s[u];
-      o[l.name.value] = valueFromASTUntyped(l.value, n);
+   case "ObjectValue":
+    var a = Object.create(null);
+    for (var o = 0, l = e.fields; o < l.length; o += 1) {
+      var u = l[o];
+      a[u.name.value] = valueFromASTUntyped(u.value, r);
     }
-    return o;
+    return a;
 
-   case r.VARIABLE:
-    return n && n[e.name.value];
+   case "Variable":
+    return r && r[e.name.value];
   }
 }
 
-function valueFromTypeNode(e, n, i) {
-  if (e.kind === r.VARIABLE) {
-    return i ? valueFromTypeNode(i[e.name.value], n, i) : void 0;
-  } else if (n.kind === r.NON_NULL_TYPE) {
-    return e.kind !== r.NULL ? valueFromTypeNode(e, n, i) : void 0;
-  } else if (e.kind === r.NULL) {
+function valueFromTypeNode(e, r, i) {
+  if ("Variable" === e.kind) {
+    return i ? valueFromTypeNode(i[e.name.value], r, i) : void 0;
+  } else if ("NonNullType" === r.kind) {
+    return "NullValue" !== e.kind ? valueFromTypeNode(e, r, i) : void 0;
+  } else if ("NullValue" === e.kind) {
     return null;
-  } else if (n.kind === r.LIST_TYPE) {
-    if (e.kind === r.LIST) {
-      var t = [];
-      for (var a = 0, o = e.values; a < o.length; a += 1) {
-        var u = valueFromTypeNode(o[a], n.type, i);
-        if (void 0 === u) {
+  } else if ("ListType" === r.kind) {
+    if ("ListValue" === e.kind) {
+      var n = [];
+      for (var t = 0, a = e.values; t < a.length; t += 1) {
+        var o = valueFromTypeNode(a[t], r.type, i);
+        if (void 0 === o) {
           return;
         } else {
-          t.push(u);
+          n.push(o);
         }
       }
-      return t;
+      return n;
     }
-  } else if (n.kind === r.NAMED_TYPE) {
-    switch (n.name.value) {
+  } else if ("NamedType" === r.kind) {
+    switch (r.name.value) {
      case "Int":
      case "Float":
      case "String":
      case "Bool":
-      return n.name.value + "Value" === e.kind ? valueFromASTUntyped(e, i) : void 0;
+      return r.name.value + "Value" === e.kind ? valueFromASTUntyped(e, i) : void 0;
 
      default:
       return valueFromASTUntyped(e, i);
@@ -858,5 +855,5 @@ function valueFromTypeNode(e, n, i) {
   }
 }
 
-export { A as BREAK, GraphQLError, r as Kind, e as OperationTypeNode, blockString, parse, parseType, parseValue, print, printBlockString, printString, valueFromASTUntyped, valueFromTypeNode, visit };
+export { y as BREAK, GraphQLError, e as Kind, r as OperationTypeNode, blockString, parse, parseType, parseValue, print, printBlockString, printString, valueFromASTUntyped, valueFromTypeNode, visit };
 //# sourceMappingURL=graphql.web.mjs.map