@0no-co/graphql.web 0.1.5 → 1.0.0

package/README.md

@@ -31,6 +31,20 @@ spec-compliant or compatible with GraphQL.js’ implementation.
 > project](https://github.com/0no-co/graphql-web-lite) is maintained to be
 > a full shim/alias for the `graphql` package.
 
+### Overview
+
+`@0no-co/graphql.web` aims to provide a minimal set of exports to implement
+client-side GraphQL utilities, mostly including parsing, printing, and visiting
+the GraphQL AST, and the `GraphQLError` class.
+
+Currently, `graphql.web` compresses to under 4kB and doesn’t regress on
+GraphQL.js’ performance when parsing, printing, or visiting the AST.
+
+For all primary APIs we aim to hit 100% test coverage and match the output,
+types, and API compatibility of GraphQL.js, including — as far as possible
+— TypeScript type compatibility of the AST types with the currently stable
+version of GraphQL.js.
+
 ### API
 
 Currently, only a select few exports are provided — namely, the ones listed here

package/dist/graphql.web.d.ts

@@ -1,3 +1,7 @@
+/*!@ts-ignore*/
+import * as GraphQL from 'graphql';
+
+type Or<T, U> = 0 extends 1 & T ? U : T;
 type Maybe<T> = T | undefined | null;
 interface Extensions {
     [extension: string]: unknown;
@@ -80,30 +84,30 @@ declare enum OperationTypeNode {
 }
 
 /** Type System Definition */
-declare type TypeSystemDefinitionNode = SchemaDefinitionNode | TypeDefinitionNode | DirectiveDefinitionNode;
-interface SchemaDefinitionNode {
+declare type TypeSystemDefinitionNode = Or<GraphQL.TypeSystemDefinitionNode, SchemaDefinitionNode | TypeDefinitionNode | DirectiveDefinitionNode>;
+type SchemaDefinitionNode = Or<GraphQL.SchemaDefinitionNode, {
     readonly kind: Kind.SCHEMA_DEFINITION;
     readonly loc?: Location;
     readonly description?: StringValueNode;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
     readonly operationTypes: ReadonlyArray<OperationTypeDefinitionNode>;
-}
-interface OperationTypeDefinitionNode {
+}>;
+type OperationTypeDefinitionNode = Or<GraphQL.OperationTypeDefinitionNode, {
     readonly kind: Kind.OPERATION_TYPE_DEFINITION;
     readonly loc?: Location;
     readonly operation: OperationTypeNode;
     readonly type: NamedTypeNode;
-}
+}>;
 /** Type Definition */
-declare type TypeDefinitionNode = ScalarTypeDefinitionNode | ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode | UnionTypeDefinitionNode | EnumTypeDefinitionNode | InputObjectTypeDefinitionNode;
-interface ScalarTypeDefinitionNode {
+declare type TypeDefinitionNode = Or<GraphQL.TypeDefinitionNode, ScalarTypeDefinitionNode | ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode | UnionTypeDefinitionNode | EnumTypeDefinitionNode | InputObjectTypeDefinitionNode>;
+type ScalarTypeDefinitionNode = Or<GraphQL.ScalarTypeDefinitionNode, {
     readonly kind: Kind.SCALAR_TYPE_DEFINITION;
     readonly loc?: Location;
     readonly description?: StringValueNode;
     readonly name: NameNode;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
-}
-interface ObjectTypeDefinitionNode {
+}>;
+type ObjectTypeDefinitionNode = Or<GraphQL.ObjectTypeDefinitionNode, {
     readonly kind: Kind.OBJECT_TYPE_DEFINITION;
     readonly loc?: Location;
     readonly description?: StringValueNode;
@@ -111,8 +115,8 @@ interface ObjectTypeDefinitionNode {
     readonly interfaces?: ReadonlyArray<NamedTypeNode>;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
     readonly fields?: ReadonlyArray<FieldDefinitionNode>;
-}
-interface FieldDefinitionNode {
+}>;
+type FieldDefinitionNode = Or<GraphQL.FieldDefinitionNode, {
     readonly kind: Kind.FIELD_DEFINITION;
     readonly loc?: Location;
     readonly description?: StringValueNode;
@@ -120,8 +124,8 @@ interface FieldDefinitionNode {
     readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;
     readonly type: TypeNode;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
-}
-interface InputValueDefinitionNode {
+}>;
+type InputValueDefinitionNode = Or<GraphQL.InputValueDefinitionNode, {
     readonly kind: Kind.INPUT_VALUE_DEFINITION;
     readonly loc?: Location;
     readonly description?: StringValueNode;
@@ -129,8 +133,8 @@ interface InputValueDefinitionNode {
     readonly type: TypeNode;
     readonly defaultValue?: ConstValueNode;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
-}
-interface InterfaceTypeDefinitionNode {
+}>;
+type InterfaceTypeDefinitionNode = Or<GraphQL.InterfaceTypeDefinitionNode, {
     readonly kind: Kind.INTERFACE_TYPE_DEFINITION;
     readonly loc?: Location;
     readonly description?: StringValueNode;
@@ -138,40 +142,39 @@ interface InterfaceTypeDefinitionNode {
     readonly interfaces?: ReadonlyArray<NamedTypeNode>;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
     readonly fields?: ReadonlyArray<FieldDefinitionNode>;
-}
-interface UnionTypeDefinitionNode {
+}>;
+type UnionTypeDefinitionNode = Or<GraphQL.UnionTypeDefinitionNode, {
     readonly kind: Kind.UNION_TYPE_DEFINITION;
     readonly loc?: Location;
     readonly description?: StringValueNode;
     readonly name: NameNode;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
     readonly types?: ReadonlyArray<NamedTypeNode>;
-}
-interface EnumTypeDefinitionNode {
+}>;
+type EnumTypeDefinitionNode = Or<GraphQL.EnumTypeDefinitionNode, {
     readonly kind: Kind.ENUM_TYPE_DEFINITION;
     readonly loc?: Location;
     readonly description?: StringValueNode;
     readonly name: NameNode;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
     readonly values?: ReadonlyArray<EnumValueDefinitionNode>;
-}
-interface EnumValueDefinitionNode {
+}>;
+type EnumValueDefinitionNode = Or<GraphQL.EnumValueDefinitionNode, {
     readonly kind: Kind.ENUM_VALUE_DEFINITION;
     readonly loc?: Location;
     readonly description?: StringValueNode;
     readonly name: NameNode;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
-}
-interface InputObjectTypeDefinitionNode {
+}>;
+type InputObjectTypeDefinitionNode = Or<GraphQL.InputObjectTypeDefinitionNode, {
     readonly kind: Kind.INPUT_OBJECT_TYPE_DEFINITION;
     readonly loc?: Location;
     readonly description?: StringValueNode;
     readonly name: NameNode;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
     readonly fields?: ReadonlyArray<InputValueDefinitionNode>;
-}
-/** Directive Definitions */
-interface DirectiveDefinitionNode {
+}>;
+type DirectiveDefinitionNode = Or<GraphQL.DirectiveDefinitionNode, {
     readonly kind: Kind.DIRECTIVE_DEFINITION;
     readonly loc?: Location;
     readonly description?: StringValueNode;
@@ -179,75 +182,73 @@ interface DirectiveDefinitionNode {
     readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;
     readonly repeatable: boolean;
     readonly locations: ReadonlyArray<NameNode>;
-}
-/** Type System Extensions */
-declare type TypeSystemExtensionNode = SchemaExtensionNode | TypeExtensionNode;
-interface SchemaExtensionNode {
+}>;
+type TypeSystemExtensionNode = Or<GraphQL.TypeSystemExtensionNode, SchemaExtensionNode | TypeExtensionNode>;
+type SchemaExtensionNode = Or<GraphQL.SchemaExtensionNode, {
     readonly kind: Kind.SCHEMA_EXTENSION;
     readonly loc?: Location;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
     readonly operationTypes?: ReadonlyArray<OperationTypeDefinitionNode>;
-}
-/** Type Extensions */
-declare type TypeExtensionNode = ScalarTypeExtensionNode | ObjectTypeExtensionNode | InterfaceTypeExtensionNode | UnionTypeExtensionNode | EnumTypeExtensionNode | InputObjectTypeExtensionNode;
-interface ScalarTypeExtensionNode {
+}>;
+declare type TypeExtensionNode = Or<GraphQL.TypeExtensionNode, ScalarTypeExtensionNode | ObjectTypeExtensionNode | InterfaceTypeExtensionNode | UnionTypeExtensionNode | EnumTypeExtensionNode | InputObjectTypeExtensionNode>;
+type ScalarTypeExtensionNode = Or<GraphQL.ScalarTypeExtensionNode, {
     readonly kind: Kind.SCALAR_TYPE_EXTENSION;
     readonly loc?: Location;
     readonly name: NameNode;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
-}
-interface ObjectTypeExtensionNode {
+}>;
+type ObjectTypeExtensionNode = Or<GraphQL.ObjectTypeExtensionNode, {
     readonly kind: Kind.OBJECT_TYPE_EXTENSION;
     readonly loc?: Location;
     readonly name: NameNode;
     readonly interfaces?: ReadonlyArray<NamedTypeNode>;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
     readonly fields?: ReadonlyArray<FieldDefinitionNode>;
-}
-interface InterfaceTypeExtensionNode {
+}>;
+type InterfaceTypeExtensionNode = Or<GraphQL.InterfaceTypeExtensionNode, {
     readonly kind: Kind.INTERFACE_TYPE_EXTENSION;
     readonly loc?: Location;
     readonly name: NameNode;
     readonly interfaces?: ReadonlyArray<NamedTypeNode>;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
     readonly fields?: ReadonlyArray<FieldDefinitionNode>;
-}
-interface UnionTypeExtensionNode {
+}>;
+type UnionTypeExtensionNode = Or<GraphQL.UnionTypeExtensionNode, {
     readonly kind: Kind.UNION_TYPE_EXTENSION;
     readonly loc?: Location;
     readonly name: NameNode;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
     readonly types?: ReadonlyArray<NamedTypeNode>;
-}
-interface EnumTypeExtensionNode {
+}>;
+type EnumTypeExtensionNode = Or<GraphQL.EnumTypeExtensionNode, {
     readonly kind: Kind.ENUM_TYPE_EXTENSION;
     readonly loc?: Location;
     readonly name: NameNode;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
     readonly values?: ReadonlyArray<EnumValueDefinitionNode>;
-}
-interface InputObjectTypeExtensionNode {
+}>;
+type InputObjectTypeExtensionNode = Or<GraphQL.InputObjectTypeExtensionNode, {
     readonly kind: Kind.INPUT_OBJECT_TYPE_EXTENSION;
     readonly loc?: Location;
     readonly name: NameNode;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
     readonly fields?: ReadonlyArray<InputValueDefinitionNode>;
-}
+}>;
 
-type ASTNode = NameNode | DocumentNode | OperationDefinitionNode | VariableDefinitionNode | VariableNode | SelectionSetNode | FieldNode | ArgumentNode | FragmentSpreadNode | InlineFragmentNode | FragmentDefinitionNode | IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ListValueNode | ObjectValueNode | ObjectFieldNode | DirectiveNode | NamedTypeNode | ListTypeNode | NonNullTypeNode | SchemaDefinitionNode | OperationTypeDefinitionNode | ScalarTypeDefinitionNode | ObjectTypeDefinitionNode | FieldDefinitionNode | InputValueDefinitionNode | InterfaceTypeDefinitionNode | UnionTypeDefinitionNode | EnumTypeDefinitionNode | EnumValueDefinitionNode | InputObjectTypeDefinitionNode | DirectiveDefinitionNode | SchemaExtensionNode | ScalarTypeExtensionNode | ObjectTypeExtensionNode | InterfaceTypeExtensionNode | UnionTypeExtensionNode | EnumTypeExtensionNode | InputObjectTypeExtensionNode;
-interface NameNode {
+type ASTNode = Or<GraphQL.ASTNode, NameNode | DocumentNode | OperationDefinitionNode | VariableDefinitionNode | VariableNode | SelectionSetNode | FieldNode | ArgumentNode | FragmentSpreadNode | InlineFragmentNode | FragmentDefinitionNode | IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ListValueNode | ObjectValueNode | ObjectFieldNode | DirectiveNode | NamedTypeNode | ListTypeNode | NonNullTypeNode | SchemaDefinitionNode | OperationTypeDefinitionNode | ScalarTypeDefinitionNode | ObjectTypeDefinitionNode | FieldDefinitionNode | InputValueDefinitionNode | InterfaceTypeDefinitionNode | UnionTypeDefinitionNode | EnumTypeDefinitionNode | EnumValueDefinitionNode | InputObjectTypeDefinitionNode | DirectiveDefinitionNode | SchemaExtensionNode | ScalarTypeExtensionNode | ObjectTypeExtensionNode | InterfaceTypeExtensionNode | UnionTypeExtensionNode | EnumTypeExtensionNode | InputObjectTypeExtensionNode>;
+type NameNode = Or<GraphQL.NameNode, {
     readonly kind: Kind.NAME;
     readonly value: string;
     readonly loc?: Location;
-}
-interface DocumentNode {
+}>;
+type DocumentNode = Or<GraphQL.DocumentNode, {
     readonly kind: Kind.DOCUMENT;
     readonly definitions: ReadonlyArray<DefinitionNode>;
     readonly loc?: Location;
-}
-type DefinitionNode = ExecutableDefinitionNode | TypeSystemDefinitionNode | TypeSystemExtensionNode;
-type ExecutableDefinitionNode = OperationDefinitionNode | FragmentDefinitionNode;
-interface OperationDefinitionNode {
+}>;
+type DefinitionNode = Or<GraphQL.DefinitionNode, ExecutableDefinitionNode | TypeSystemDefinitionNode | TypeSystemExtensionNode>;
+type ExecutableDefinitionNode = Or<GraphQL.ExecutableDefinitionNode, OperationDefinitionNode | FragmentDefinitionNode>;
+type OperationDefinitionNode = Or<GraphQL.OperationDefinitionNode, {
     readonly kind: Kind.OPERATION_DEFINITION;
     readonly operation: OperationTypeNode;
     readonly name?: NameNode;
@@ -255,27 +256,27 @@ interface OperationDefinitionNode {
     readonly directives?: ReadonlyArray<DirectiveNode>;
     readonly selectionSet: SelectionSetNode;
     readonly loc?: Location;
-}
-interface VariableDefinitionNode {
+}>;
+type VariableDefinitionNode = Or<GraphQL.VariableDefinitionNode, {
     readonly kind: Kind.VARIABLE_DEFINITION;
     readonly variable: VariableNode;
     readonly type: TypeNode;
     readonly defaultValue?: ConstValueNode;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
     readonly loc?: Location;
-}
-interface VariableNode {
+}>;
+type VariableNode = Or<GraphQL.VariableNode, {
     readonly kind: Kind.VARIABLE;
     readonly name: NameNode;
     readonly loc?: Location;
-}
-interface SelectionSetNode {
+}>;
+type SelectionSetNode = Or<GraphQL.SelectionSetNode, {
     readonly kind: Kind.SELECTION_SET;
     readonly selections: ReadonlyArray<SelectionNode>;
     readonly loc?: Location;
-}
-declare type SelectionNode = FieldNode | FragmentSpreadNode | InlineFragmentNode;
-interface FieldNode {
+}>;
+declare type SelectionNode = Or<GraphQL.SelectionNode, FieldNode | FragmentSpreadNode | InlineFragmentNode>;
+type FieldNode = Or<GraphQL.FieldNode, {
     readonly kind: Kind.FIELD;
     readonly alias?: NameNode;
     readonly name: NameNode;
@@ -283,132 +284,132 @@ interface FieldNode {
     readonly directives?: ReadonlyArray<DirectiveNode>;
     readonly selectionSet?: SelectionSetNode;
     readonly loc?: Location;
-}
-interface ArgumentNode {
+}>;
+type ArgumentNode = Or<GraphQL.ArgumentNode, {
     readonly kind: Kind.ARGUMENT;
     readonly name: NameNode;
     readonly value: ValueNode;
     readonly loc?: Location;
-}
-interface ConstArgumentNode {
+}>;
+type ConstArgumentNode = Or<GraphQL.ConstArgumentNode, {
     readonly kind: Kind.ARGUMENT;
     readonly name: NameNode;
     readonly value: ConstValueNode;
     readonly loc?: Location;
-}
-interface FragmentSpreadNode {
+}>;
+type FragmentSpreadNode = Or<GraphQL.FragmentSpreadNode, {
     readonly kind: Kind.FRAGMENT_SPREAD;
     readonly name: NameNode;
     readonly directives?: ReadonlyArray<DirectiveNode>;
     readonly loc?: Location;
-}
-interface InlineFragmentNode {
+}>;
+type InlineFragmentNode = Or<GraphQL.InlineFragmentNode, {
     readonly kind: Kind.INLINE_FRAGMENT;
     readonly typeCondition?: NamedTypeNode;
     readonly directives?: ReadonlyArray<DirectiveNode>;
     readonly selectionSet: SelectionSetNode;
     readonly loc?: Location;
-}
-interface FragmentDefinitionNode {
+}>;
+type FragmentDefinitionNode = Or<GraphQL.FragmentDefinitionNode, {
     readonly kind: Kind.FRAGMENT_DEFINITION;
     readonly name: NameNode;
     readonly typeCondition: NamedTypeNode;
     readonly directives?: ReadonlyArray<DirectiveNode>;
     readonly selectionSet: SelectionSetNode;
     readonly loc?: Location;
-}
-type ValueNode = VariableNode | IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ListValueNode | ObjectValueNode;
-type ConstValueNode = IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ConstListValueNode | ConstObjectValueNode;
-interface IntValueNode {
+}>;
+type ValueNode = Or<GraphQL.ValueNode, VariableNode | IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ListValueNode | ObjectValueNode>;
+type ConstValueNode = Or<GraphQL.ConstValueNode, IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ConstListValueNode | ConstObjectValueNode>;
+type IntValueNode = Or<GraphQL.IntValueNode, {
     readonly kind: Kind.INT;
     readonly value: string;
     readonly loc?: Location;
-}
-interface FloatValueNode {
+}>;
+type FloatValueNode = Or<GraphQL.FloatValueNode, {
     readonly kind: Kind.FLOAT;
     readonly value: string;
     readonly loc?: Location;
-}
-interface StringValueNode {
+}>;
+type StringValueNode = Or<GraphQL.FloatValueNode, {
     readonly kind: Kind.STRING;
     readonly value: string;
     readonly block?: boolean;
     readonly loc?: Location;
-}
-interface BooleanValueNode {
+}>;
+type BooleanValueNode = Or<GraphQL.BooleanValueNode, {
     readonly kind: Kind.BOOLEAN;
     readonly value: boolean;
     readonly loc?: Location;
-}
-interface NullValueNode {
+}>;
+type NullValueNode = Or<GraphQL.NullValueNode, {
     readonly kind: Kind.NULL;
     readonly loc?: Location;
-}
-interface EnumValueNode {
+}>;
+type EnumValueNode = Or<GraphQL.EnumValueNode, {
     readonly kind: Kind.ENUM;
     readonly value: string;
     readonly loc?: Location;
-}
-interface ListValueNode {
+}>;
+type ListValueNode = Or<GraphQL.ListValueNode, {
     readonly kind: Kind.LIST;
     readonly values: ReadonlyArray<ValueNode>;
     readonly loc?: Location;
-}
-interface ConstListValueNode {
+}>;
+type ConstListValueNode = Or<GraphQL.ConstListValueNode, {
     readonly kind: Kind.LIST;
     readonly values: ReadonlyArray<ConstValueNode>;
     readonly loc?: Location;
-}
-interface ObjectValueNode {
+}>;
+type ObjectValueNode = Or<GraphQL.ObjectValueNode, {
     readonly kind: Kind.OBJECT;
     readonly fields: ReadonlyArray<ObjectFieldNode>;
     readonly loc?: Location;
-}
-interface ConstObjectValueNode {
+}>;
+type ConstObjectValueNode = Or<GraphQL.ConstObjectValueNode, {
     readonly kind: Kind.OBJECT;
     readonly fields: ReadonlyArray<ConstObjectFieldNode>;
     readonly loc?: Location;
-}
-interface ObjectFieldNode {
+}>;
+type ObjectFieldNode = Or<GraphQL.ObjectFieldNode, {
     readonly kind: Kind.OBJECT_FIELD;
     readonly name: NameNode;
     readonly value: ValueNode;
     readonly loc?: Location;
-}
-interface ConstObjectFieldNode {
+}>;
+type ConstObjectFieldNode = Or<GraphQL.ConstObjectFieldNode, {
     readonly kind: Kind.OBJECT_FIELD;
     readonly name: NameNode;
     readonly value: ConstValueNode;
     readonly loc?: Location;
-}
-interface DirectiveNode {
+}>;
+type DirectiveNode = Or<GraphQL.DirectiveNode, {
     readonly kind: Kind.DIRECTIVE;
     readonly name: NameNode;
     readonly arguments?: ReadonlyArray<ArgumentNode>;
     readonly loc?: Location;
-}
-interface ConstDirectiveNode {
+}>;
+type ConstDirectiveNode = Or<GraphQL.ConstDirectiveNode, {
     readonly kind: Kind.DIRECTIVE;
     readonly name: NameNode;
     readonly arguments?: ReadonlyArray<ConstArgumentNode>;
     readonly loc?: Location;
-}
-declare type TypeNode = NamedTypeNode | ListTypeNode | NonNullTypeNode;
-interface NamedTypeNode {
+}>;
+type TypeNode = Or<GraphQL.TypeNode, NamedTypeNode | ListTypeNode | NonNullTypeNode>;
+type NamedTypeNode = Or<GraphQL.NamedTypeNode, {
     readonly kind: Kind.NAMED_TYPE;
     readonly name: NameNode;
     readonly loc?: Location;
-}
-interface ListTypeNode {
+}>;
+type ListTypeNode = Or<GraphQL.ListTypeNode, {
     readonly kind: Kind.LIST_TYPE;
     readonly type: TypeNode;
     readonly loc?: Location;
-}
-interface NonNullTypeNode {
+}>;
+type NonNullTypeNode = Or<GraphQL.NonNullTypeNode, {
     readonly kind: Kind.NON_NULL_TYPE;
     readonly type: NamedTypeNode | ListTypeNode;
     readonly loc?: Location;
-}
+}>;
 
 declare class GraphQLError extends Error {
     readonly locations: ReadonlyArray<any> | undefined;
@@ -424,7 +425,6 @@ declare class GraphQLError extends Error {
     get [Symbol.toStringTag](): string;
 }
 
-declare function blockString(string: string): string;
 type ParseOptions = {
     [option: string]: any;
 };
@@ -462,4 +462,4 @@ declare function print(node: ASTNode): string;
 declare function valueFromASTUntyped(node: ValueNode, variables?: Maybe<Record<string, any>>): unknown;
 declare function valueFromTypeNode(node: ValueNode, type: TypeNode, variables?: Maybe<Record<string, any>>): unknown;
 
-export { ASTNode, ASTReducer, ASTVisitFn, ASTVisitor, ArgumentNode, BREAK, BooleanValueNode, ConstArgumentNode, ConstDirectiveNode, ConstListValueNode, ConstObjectFieldNode, ConstObjectValueNode, ConstValueNode, DefinitionNode, DirectiveDefinitionNode, DirectiveNode, DocumentNode, EnumTypeDefinitionNode, EnumTypeExtensionNode, EnumValueDefinitionNode, EnumValueNode, ExecutableDefinitionNode, FieldDefinitionNode, FieldNode, FloatValueNode, FragmentDefinitionNode, FragmentSpreadNode, GraphQLError, InlineFragmentNode, InputObjectTypeDefinitionNode, InputObjectTypeExtensionNode, InputValueDefinitionNode, IntValueNode, InterfaceTypeDefinitionNode, InterfaceTypeExtensionNode, Kind, ListTypeNode, ListValueNode, Location, NameNode, NamedTypeNode, NonNullTypeNode, NullValueNode, ObjectFieldNode, ObjectTypeDefinitionNode, ObjectTypeExtensionNode, ObjectValueNode, OperationDefinitionNode, OperationTypeDefinitionNode, OperationTypeNode, ScalarTypeDefinitionNode, ScalarTypeExtensionNode, SchemaDefinitionNode, SchemaExtensionNode, SelectionNode, SelectionSetNode, Source, StringValueNode, TypeDefinitionNode, TypeExtensionNode, TypeNode, TypeSystemDefinitionNode, TypeSystemExtensionNode, UnionTypeDefinitionNode, UnionTypeExtensionNode, ValueNode, VariableDefinitionNode, VariableNode, blockString, parse, parseType, parseValue, print, printBlockString, printString, valueFromASTUntyped, valueFromTypeNode, visit };
+export { ASTNode, ASTReducer, ASTVisitFn, ASTVisitor, ArgumentNode, BREAK, BooleanValueNode, ConstArgumentNode, ConstDirectiveNode, ConstListValueNode, ConstObjectFieldNode, ConstObjectValueNode, ConstValueNode, DefinitionNode, DirectiveDefinitionNode, DirectiveNode, DocumentNode, EnumTypeDefinitionNode, EnumTypeExtensionNode, EnumValueDefinitionNode, EnumValueNode, ExecutableDefinitionNode, FieldDefinitionNode, FieldNode, FloatValueNode, FragmentDefinitionNode, FragmentSpreadNode, GraphQLError, InlineFragmentNode, InputObjectTypeDefinitionNode, InputObjectTypeExtensionNode, InputValueDefinitionNode, IntValueNode, InterfaceTypeDefinitionNode, InterfaceTypeExtensionNode, Kind, ListTypeNode, ListValueNode, Location, NameNode, NamedTypeNode, NonNullTypeNode, NullValueNode, ObjectFieldNode, ObjectTypeDefinitionNode, ObjectTypeExtensionNode, ObjectValueNode, OperationDefinitionNode, OperationTypeDefinitionNode, OperationTypeNode, ScalarTypeDefinitionNode, ScalarTypeExtensionNode, SchemaDefinitionNode, SchemaExtensionNode, SelectionNode, SelectionSetNode, Source, StringValueNode, TypeDefinitionNode, TypeExtensionNode, TypeNode, TypeSystemDefinitionNode, TypeSystemExtensionNode, UnionTypeDefinitionNode, UnionTypeExtensionNode, ValueNode, VariableDefinitionNode, VariableNode, parse, parseType, parseValue, print, printBlockString, printString, valueFromASTUntyped, valueFromTypeNode, visit };

package/dist/graphql.web.js

@@ -33,7 +33,8 @@ class GraphQLError extends Error {
   }
   toJSON() {
     return {
-      ...this
+      ...this,
+      message: this.message
     };
   }
   toString() {
@@ -111,15 +112,15 @@ var t = /null|true|false/y;
 
 var a = /\$[_\w][_\d\w]*/y;
 
-var o = /[-]?\d+/y;
+var o = /-?\d+/y;
 
-var l = /(?:[-]?\d+)?(?:\.\d+)(?:[eE][+-]?\d+)?/y;
+var l = /(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
 
 var u = /\\/g;
 
-var d = /"""(?:[\s\S]+(?="""))?"""/y;
+var v = /"""(?:[\s\S]+(?="""))?"""/y;
 
-var v = /"(?:[^"\r\n]+)?"/y;
+var d = /"(?:[^"\r\n]+)?"/y;
 
 function value(i) {
   var s;
@@ -139,28 +140,31 @@ function value(i) {
         value: c.slice(1)
       }
     };
-  } else if (c = advance(l)) {
-    s = {
-      kind: "FloatValue",
-      value: c
-    };
   } else if (c = advance(o)) {
-    s = {
-      kind: "IntValue",
-      value: c
-    };
+    var f = c;
+    if (c = advance(l)) {
+      s = {
+        kind: "FloatValue",
+        value: f + c
+      };
+    } else {
+      s = {
+        kind: "IntValue",
+        value: f
+      };
+    }
   } else if (c = advance(n)) {
     s = {
       kind: "EnumValue",
       value: c
     };
-  } else if (c = advance(d)) {
+  } else if (c = advance(v)) {
     s = {
       kind: "StringValue",
       value: blockString(c.slice(3, -3)),
       block: !0
     };
-  } else if (c = advance(v)) {
+  } else if (c = advance(d)) {
     s = {
       kind: "StringValue",
       value: u.test(c) ? JSON.parse(c) : c.slice(1, -1),
@@ -453,9 +457,6 @@ function operationDefinition() {
             throw error("VariableDefinition");
           }
           var t = type();
-          if (!t) {
-            throw error("VariableDefinition");
-          }
           var o = void 0;
           if (61 === e.charCodeAt(r)) {
             r++;
@@ -683,24 +684,19 @@ exports.OperationTypeNode = {
   SUBSCRIPTION: "subscription"
 };
 
-exports.blockString = blockString;
-
 exports.parse = function parse(i, n) {
   e = "string" == typeof i.body ? i.body : i;
   r = 0;
   return function document() {
-    var i;
+    var e;
     ignored();
-    var n = [];
-    while (i = fragmentDefinition() || operationDefinition()) {
-      n.push(i);
-    }
-    if (r !== e.length) {
-      throw error("Document");
+    var r = [];
+    while (e = fragmentDefinition() || operationDefinition()) {
+      r.push(e);
     }
     return {
       kind: "Document",
-      definitions: n
+      definitions: r
     };
   }();
 };
@@ -708,11 +704,7 @@ exports.parse = function parse(i, n) {
 exports.parseType = function parseType(i, n) {
   e = "string" == typeof i.body ? i.body : i;
   r = 0;
-  var t = type();
-  if (!t) {
-    throw error("TypeNode");
-  }
-  return t;
+  return type();
 };
 
 exports.parseValue = function parseValue(i, n) {
@@ -789,8 +781,8 @@ exports.visit = function visit(e, r) {
       if (a) {
         i.push(a);
       }
-      var d;
-      var v = {
+      var v;
+      var d = {
         ...e
       };
       for (var s in e) {
@@ -802,29 +794,27 @@ exports.visit = function visit(e, r) {
             if (null != c[p] && "string" == typeof c[p].kind) {
               i.push(e);
               n.push(p);
-              d = traverse(c[p], p, c);
+              v = traverse(c[p], p, c);
               n.pop();
               i.pop();
-              if (void 0 === d) {
-                f.push(c[p]);
-              } else if (null === d) {
+              if (null == v) {
                 o = !0;
               } else {
-                o = o || d !== c[p];
-                f.push(d);
+                o = o || v !== c[p];
+                f.push(v);
               }
             }
           }
           c = f;
         } else if (null != c && "string" == typeof c.kind) {
-          if (void 0 !== (d = traverse(c, s, e))) {
-            o = o || c !== d;
-            c = d;
+          if (void 0 !== (v = traverse(c, s, e))) {
+            o = o || c !== v;
+            c = v;
           }
         }
         n.pop();
         if (o) {
-          v[s] = c;
+          d[s] = c;
         }
       }
       if (a) {
@@ -837,9 +827,9 @@ exports.visit = function visit(e, r) {
       } else if (void 0 !== h) {
         return h;
       } else if (void 0 !== u) {
-        return o ? v : u;
+        return o ? d : u;
       } else {
-        return o ? v : e;
+        return o ? d : e;
       }
     }(e);
     return void 0 !== t && !1 !== t ? t : e;