@luvio/graphql-parser 0.81.1-238.2 → 0.84.0

package/dist/luvioGraphqlParser.mjs

@@ -3854,54 +3854,6 @@ var find = Array.prototype.find ? function (list, predicate) {
 };
 var find$1 = find;
 
-/* eslint-disable no-redeclare */
-// $FlowFixMe[name-already-bound]
-var arrayFrom = Array.from || function (obj, mapFn, thisArg) {
-  if (obj == null) {
-    throw new TypeError('Array.from requires an array-like object - not null or undefined');
-  } // Is Iterable?
-
-
-  var iteratorMethod = obj[SYMBOL_ITERATOR];
-
-  if (typeof iteratorMethod === 'function') {
-    var iterator = iteratorMethod.call(obj);
-    var result = [];
-    var step;
-
-    for (var i = 0; !(step = iterator.next()).done; ++i) {
-      result.push(mapFn.call(thisArg, step.value, i)); // Infinite Iterators could cause forEach to run forever.
-      // After a very large number of iterations, produce an error.
-      // istanbul ignore if (Too big to actually test)
-
-      if (i > 9999999) {
-        throw new TypeError('Near-infinite iteration.');
-      }
-    }
-
-    return result;
-  } // Is Array like?
-
-
-  var length = obj.length;
-
-  if (typeof length === 'number' && length >= 0 && length % 1 === 0) {
-    var _result = [];
-
-    for (var _i = 0; _i < length; ++_i) {
-      if (Object.prototype.hasOwnProperty.call(obj, _i)) {
-        _result.push(mapFn.call(thisArg, obj[_i], _i));
-      }
-    }
-
-    return _result;
-  }
-
-  return [];
-};
-
-var arrayFrom$1 = arrayFrom;
-
 /* eslint-disable no-redeclare */
 // $FlowFixMe[name-already-bound] workaround for: https://github.com/facebook/flow/issues/4441
 var objectValues = Object.values || function (obj) {
@@ -3922,105 +3874,6 @@ var objectEntries = Object.entries || function (obj) {
 
 var objectEntries$1 = objectEntries;
 
-function toObjMap(obj) {
-  /* eslint-enable no-redeclare */
-  if (Object.getPrototypeOf(obj) === null) {
-    return obj;
-  }
-
-  var map = Object.create(null);
-
-  for (var _i2 = 0, _objectEntries2 = objectEntries$1(obj); _i2 < _objectEntries2.length; _i2++) {
-    var _ref2 = _objectEntries2[_i2];
-    var key = _ref2[0];
-    var value = _ref2[1];
-    map[key] = value;
-  }
-
-  return map;
-}
-
-/* eslint-disable no-redeclare */
-// $FlowFixMe[name-already-bound] workaround for: https://github.com/facebook/flow/issues/4441
-var isFinitePolyfill = Number.isFinite || function (value) {
-  return typeof value === 'number' && isFinite(value);
-};
-
-var isFinite$1 = isFinitePolyfill;
-
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-/**
- * Safer version of `Array.from` that return `null` if value isn't convertible to array.
- * Also protects against Array-like objects without items.
- *
- * @example
- *
- * safeArrayFrom([ 1, 2, 3 ]) // [1, 2, 3]
- * safeArrayFrom('ABC') // null
- * safeArrayFrom({ length: 1 }) // null
- * safeArrayFrom({ length: 1, 0: 'Alpha' }) // ['Alpha']
- * safeArrayFrom({ key: 'value' }) // null
- * safeArrayFrom(new Map()) // []
- *
- */
-
-function safeArrayFrom(collection) {
-  var mapFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (item) {
-    return item;
-  };
-
-  if (collection == null || _typeof(collection) !== 'object') {
-    return null;
-  }
-
-  if (Array.isArray(collection)) {
-    return collection.map(mapFn);
-  } // Is Iterable?
-
-
-  var iteratorMethod = collection[SYMBOL_ITERATOR];
-
-  if (typeof iteratorMethod === 'function') {
-    // $FlowFixMe[incompatible-use]
-    var iterator = iteratorMethod.call(collection);
-    var result = [];
-    var step;
-
-    for (var i = 0; !(step = iterator.next()).done; ++i) {
-      result.push(mapFn(step.value, i));
-    }
-
-    return result;
-  } // Is Array like?
-
-
-  var length = collection.length;
-
-  if (typeof length === 'number' && length >= 0 && length % 1 === 0) {
-    var _result = [];
-
-    for (var _i = 0; _i < length; ++_i) {
-      if (!Object.prototype.hasOwnProperty.call(collection, _i)) {
-        return null;
-      }
-
-      _result.push(mapFn(collection[String(_i)], _i));
-    }
-
-    return _result;
-  }
-
-  return null;
-}
-
-/* eslint-disable no-redeclare */
-// $FlowFixMe[name-already-bound] workaround for: https://github.com/facebook/flow/issues/4441
-var isInteger = Number.isInteger || function (value) {
-  return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
-};
-
-var isInteger$1 = isInteger;
-
 /**
  * Creates a keyed JS object from an array, given a function to produce the keys
  * for each value in the array.
@@ -4068,6 +3921,24 @@ function mapValue(map, fn) {
   return result;
 }
 
+function toObjMap(obj) {
+  /* eslint-enable no-redeclare */
+  if (Object.getPrototypeOf(obj) === null) {
+    return obj;
+  }
+
+  var map = Object.create(null);
+
+  for (var _i2 = 0, _objectEntries2 = objectEntries$1(obj); _i2 < _objectEntries2.length; _i2++) {
+    var _ref2 = _objectEntries2[_i2];
+    var key = _ref2[0];
+    var value = _ref2[1];
+    map[key] = value;
+  }
+
+  return map;
+}
+
 /**
  * Creates a keyed JS object from an array, given a function to produce the keys
  * and a function to produce the values from each item in the array.
@@ -5351,52 +5222,262 @@ function isRequiredInputField(field) {
   return isNonNullType(field.type) && field.defaultValue === undefined;
 }
 
-// 32-bit signed integer, providing the broadest support across platforms.
-//
-// n.b. JavaScript's integers are safe between -(2^53 - 1) and 2^53 - 1 because
-// they are internally represented as IEEE 754 doubles.
+/**
+ * Provided a type and a super type, return true if the first type is either
+ * equal or a subset of the second super type (covariant).
+ */
 
-var MAX_INT = 2147483647;
-var MIN_INT = -2147483648;
+function isTypeSubTypeOf(schema, maybeSubType, superType) {
+  // Equivalent type is a valid subtype
+  if (maybeSubType === superType) {
+    return true;
+  } // If superType is non-null, maybeSubType must also be non-null.
 
-function serializeInt(outputValue) {
-  var coercedValue = serializeObject(outputValue);
 
-  if (typeof coercedValue === 'boolean') {
-    return coercedValue ? 1 : 0;
+  if (isNonNullType(superType)) {
+    if (isNonNullType(maybeSubType)) {
+      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
+    }
+
+    return false;
   }
 
-  var num = coercedValue;
+  if (isNonNullType(maybeSubType)) {
+    // If superType is nullable, maybeSubType may be non-null or nullable.
+    return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);
+  } // If superType type is a list, maybeSubType type must also be a list.
 
-  if (typeof coercedValue === 'string' && coercedValue !== '') {
-    num = Number(coercedValue);
-  }
 
-  if (!isInteger$1(num)) {
-    throw new GraphQLError("Int cannot represent non-integer value: ".concat(inspect(coercedValue)));
-  }
+  if (isListType(superType)) {
+    if (isListType(maybeSubType)) {
+      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
+    }
 
-  if (num > MAX_INT || num < MIN_INT) {
-    throw new GraphQLError('Int cannot represent non 32-bit signed integer value: ' + inspect(coercedValue));
+    return false;
   }
 
-  return num;
+  if (isListType(maybeSubType)) {
+    // If superType is not a list, maybeSubType must also be not a list.
+    return false;
+  } // If superType type is an abstract type, check if it is super type of maybeSubType.
+  // Otherwise, the child type is not a valid subtype of the parent type.
+
+
+  return isAbstractType(superType) && (isInterfaceType(maybeSubType) || isObjectType(maybeSubType)) && schema.isSubType(superType, maybeSubType);
 }
+/**
+ * Provided two composite types, determine if they "overlap". Two composite
+ * types overlap when the Sets of possible concrete types for each intersect.
+ *
+ * This is often used to determine if a fragment of a given type could possibly
+ * be visited in a context of another type.
+ *
+ * This function is commutative.
+ */
 
-function coerceInt(inputValue) {
-  if (!isInteger$1(inputValue)) {
-    throw new GraphQLError("Int cannot represent non-integer value: ".concat(inspect(inputValue)));
+function doTypesOverlap(schema, typeA, typeB) {
+  // Equivalent types overlap
+  if (typeA === typeB) {
+    return true;
   }
 
-  if (inputValue > MAX_INT || inputValue < MIN_INT) {
-    throw new GraphQLError("Int cannot represent non 32-bit signed integer value: ".concat(inputValue));
+  if (isAbstractType(typeA)) {
+    if (isAbstractType(typeB)) {
+      // If both types are abstract, then determine if there is any intersection
+      // between possible concrete types of each.
+      return schema.getPossibleTypes(typeA).some(function (type) {
+        return schema.isSubType(typeB, type);
+      });
+    } // Determine if the latter type is a possible concrete type of the former.
+
+
+    return schema.isSubType(typeA, typeB);
   }
 
-  return inputValue;
+  if (isAbstractType(typeB)) {
+    // Determine if the former type is a possible concrete type of the latter.
+    return schema.isSubType(typeB, typeA);
+  } // Otherwise the types do not overlap.
+
+
+  return false;
 }
 
-var GraphQLInt = new GraphQLScalarType({
-  name: 'Int',
+/* eslint-disable no-redeclare */
+// $FlowFixMe[name-already-bound]
+var arrayFrom = Array.from || function (obj, mapFn, thisArg) {
+  if (obj == null) {
+    throw new TypeError('Array.from requires an array-like object - not null or undefined');
+  } // Is Iterable?
+
+
+  var iteratorMethod = obj[SYMBOL_ITERATOR];
+
+  if (typeof iteratorMethod === 'function') {
+    var iterator = iteratorMethod.call(obj);
+    var result = [];
+    var step;
+
+    for (var i = 0; !(step = iterator.next()).done; ++i) {
+      result.push(mapFn.call(thisArg, step.value, i)); // Infinite Iterators could cause forEach to run forever.
+      // After a very large number of iterations, produce an error.
+      // istanbul ignore if (Too big to actually test)
+
+      if (i > 9999999) {
+        throw new TypeError('Near-infinite iteration.');
+      }
+    }
+
+    return result;
+  } // Is Array like?
+
+
+  var length = obj.length;
+
+  if (typeof length === 'number' && length >= 0 && length % 1 === 0) {
+    var _result = [];
+
+    for (var _i = 0; _i < length; ++_i) {
+      if (Object.prototype.hasOwnProperty.call(obj, _i)) {
+        _result.push(mapFn.call(thisArg, obj[_i], _i));
+      }
+    }
+
+    return _result;
+  }
+
+  return [];
+};
+
+var arrayFrom$1 = arrayFrom;
+
+/* eslint-disable no-redeclare */
+// $FlowFixMe[name-already-bound] workaround for: https://github.com/facebook/flow/issues/4441
+var isFinitePolyfill = Number.isFinite || function (value) {
+  return typeof value === 'number' && isFinite(value);
+};
+
+var isFinite$1 = isFinitePolyfill;
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+/**
+ * Safer version of `Array.from` that return `null` if value isn't convertible to array.
+ * Also protects against Array-like objects without items.
+ *
+ * @example
+ *
+ * safeArrayFrom([ 1, 2, 3 ]) // [1, 2, 3]
+ * safeArrayFrom('ABC') // null
+ * safeArrayFrom({ length: 1 }) // null
+ * safeArrayFrom({ length: 1, 0: 'Alpha' }) // ['Alpha']
+ * safeArrayFrom({ key: 'value' }) // null
+ * safeArrayFrom(new Map()) // []
+ *
+ */
+
+function safeArrayFrom(collection) {
+  var mapFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (item) {
+    return item;
+  };
+
+  if (collection == null || _typeof(collection) !== 'object') {
+    return null;
+  }
+
+  if (Array.isArray(collection)) {
+    return collection.map(mapFn);
+  } // Is Iterable?
+
+
+  var iteratorMethod = collection[SYMBOL_ITERATOR];
+
+  if (typeof iteratorMethod === 'function') {
+    // $FlowFixMe[incompatible-use]
+    var iterator = iteratorMethod.call(collection);
+    var result = [];
+    var step;
+
+    for (var i = 0; !(step = iterator.next()).done; ++i) {
+      result.push(mapFn(step.value, i));
+    }
+
+    return result;
+  } // Is Array like?
+
+
+  var length = collection.length;
+
+  if (typeof length === 'number' && length >= 0 && length % 1 === 0) {
+    var _result = [];
+
+    for (var _i = 0; _i < length; ++_i) {
+      if (!Object.prototype.hasOwnProperty.call(collection, _i)) {
+        return null;
+      }
+
+      _result.push(mapFn(collection[String(_i)], _i));
+    }
+
+    return _result;
+  }
+
+  return null;
+}
+
+/* eslint-disable no-redeclare */
+// $FlowFixMe[name-already-bound] workaround for: https://github.com/facebook/flow/issues/4441
+var isInteger = Number.isInteger || function (value) {
+  return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
+};
+
+var isInteger$1 = isInteger;
+
+// 32-bit signed integer, providing the broadest support across platforms.
+//
+// n.b. JavaScript's integers are safe between -(2^53 - 1) and 2^53 - 1 because
+// they are internally represented as IEEE 754 doubles.
+
+var MAX_INT = 2147483647;
+var MIN_INT = -2147483648;
+
+function serializeInt(outputValue) {
+  var coercedValue = serializeObject(outputValue);
+
+  if (typeof coercedValue === 'boolean') {
+    return coercedValue ? 1 : 0;
+  }
+
+  var num = coercedValue;
+
+  if (typeof coercedValue === 'string' && coercedValue !== '') {
+    num = Number(coercedValue);
+  }
+
+  if (!isInteger$1(num)) {
+    throw new GraphQLError("Int cannot represent non-integer value: ".concat(inspect(coercedValue)));
+  }
+
+  if (num > MAX_INT || num < MIN_INT) {
+    throw new GraphQLError('Int cannot represent non 32-bit signed integer value: ' + inspect(coercedValue));
+  }
+
+  return num;
+}
+
+function coerceInt(inputValue) {
+  if (!isInteger$1(inputValue)) {
+    throw new GraphQLError("Int cannot represent non-integer value: ".concat(inspect(inputValue)));
+  }
+
+  if (inputValue > MAX_INT || inputValue < MIN_INT) {
+    throw new GraphQLError("Int cannot represent non 32-bit signed integer value: ".concat(inputValue));
+  }
+
+  return inputValue;
+}
+
+var GraphQLInt = new GraphQLScalarType({
+  name: 'Int',
   description: 'The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.',
   serialize: serializeInt,
   parseValue: coerceInt,
@@ -6827,87 +6908,6 @@ function collectReferencedTypes(type, typeSet) {
   return typeSet;
 }
 
-/**
- * Provided a type and a super type, return true if the first type is either
- * equal or a subset of the second super type (covariant).
- */
-
-function isTypeSubTypeOf(schema, maybeSubType, superType) {
-  // Equivalent type is a valid subtype
-  if (maybeSubType === superType) {
-    return true;
-  } // If superType is non-null, maybeSubType must also be non-null.
-
-
-  if (isNonNullType(superType)) {
-    if (isNonNullType(maybeSubType)) {
-      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
-    }
-
-    return false;
-  }
-
-  if (isNonNullType(maybeSubType)) {
-    // If superType is nullable, maybeSubType may be non-null or nullable.
-    return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);
-  } // If superType type is a list, maybeSubType type must also be a list.
-
-
-  if (isListType(superType)) {
-    if (isListType(maybeSubType)) {
-      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
-    }
-
-    return false;
-  }
-
-  if (isListType(maybeSubType)) {
-    // If superType is not a list, maybeSubType must also be not a list.
-    return false;
-  } // If superType type is an abstract type, check if it is super type of maybeSubType.
-  // Otherwise, the child type is not a valid subtype of the parent type.
-
-
-  return isAbstractType(superType) && (isInterfaceType(maybeSubType) || isObjectType(maybeSubType)) && schema.isSubType(superType, maybeSubType);
-}
-/**
- * Provided two composite types, determine if they "overlap". Two composite
- * types overlap when the Sets of possible concrete types for each intersect.
- *
- * This is often used to determine if a fragment of a given type could possibly
- * be visited in a context of another type.
- *
- * This function is commutative.
- */
-
-function doTypesOverlap(schema, typeA, typeB) {
-  // Equivalent types overlap
-  if (typeA === typeB) {
-    return true;
-  }
-
-  if (isAbstractType(typeA)) {
-    if (isAbstractType(typeB)) {
-      // If both types are abstract, then determine if there is any intersection
-      // between possible concrete types of each.
-      return schema.getPossibleTypes(typeA).some(function (type) {
-        return schema.isSubType(typeB, type);
-      });
-    } // Determine if the latter type is a possible concrete type of the former.
-
-
-    return schema.isSubType(typeA, typeB);
-  }
-
-  if (isAbstractType(typeB)) {
-    // Determine if the former type is a possible concrete type of the latter.
-    return schema.isSubType(typeB, typeA);
-  } // Otherwise the types do not overlap.
-
-
-  return false;
-}
-
 /**
  * Given a Schema and an AST node describing a type, return a GraphQLType
  * definition which applies to that type. For example, if provided the parsed
@@ -6941,273 +6941,6 @@ function typeFromAST(schema, typeNode) {
   invariant(0, 'Unexpected type node: ' + inspect(typeNode));
 }
 
-/**
- * Produces a JavaScript value given a GraphQL Value AST.
- *
- * A GraphQL type must be provided, which will be used to interpret different
- * GraphQL Value literals.
- *
- * Returns `undefined` when the value could not be validly coerced according to
- * the provided type.
- *
- * | GraphQL Value        | JSON Value    |
- * | -------------------- | ------------- |
- * | Input Object         | Object        |
- * | List                 | Array         |
- * | Boolean              | Boolean       |
- * | String               | String        |
- * | Int / Float          | Number        |
- * | Enum Value           | Mixed         |
- * | NullValue            | null          |
- *
- */
-
-function valueFromAST(valueNode, type, variables) {
-  if (!valueNode) {
-    // When there is no node, then there is also no value.
-    // Importantly, this is different from returning the value null.
-    return;
-  }
-
-  if (valueNode.kind === Kind.VARIABLE) {
-    var variableName = valueNode.name.value;
-
-    if (variables == null || variables[variableName] === undefined) {
-      // No valid return value.
-      return;
-    }
-
-    var variableValue = variables[variableName];
-
-    if (variableValue === null && isNonNullType(type)) {
-      return; // Invalid: intentionally return no value.
-    } // Note: This does no further checking that this variable is correct.
-    // This assumes that this query has been validated and the variable
-    // usage here is of the correct type.
-
-
-    return variableValue;
-  }
-
-  if (isNonNullType(type)) {
-    if (valueNode.kind === Kind.NULL) {
-      return; // Invalid: intentionally return no value.
-    }
-
-    return valueFromAST(valueNode, type.ofType, variables);
-  }
-
-  if (valueNode.kind === Kind.NULL) {
-    // This is explicitly returning the value null.
-    return null;
-  }
-
-  if (isListType(type)) {
-    var itemType = type.ofType;
-
-    if (valueNode.kind === Kind.LIST) {
-      var coercedValues = [];
-
-      for (var _i2 = 0, _valueNode$values2 = valueNode.values; _i2 < _valueNode$values2.length; _i2++) {
-        var itemNode = _valueNode$values2[_i2];
-
-        if (isMissingVariable(itemNode, variables)) {
-          // If an array contains a missing variable, it is either coerced to
-          // null or if the item type is non-null, it considered invalid.
-          if (isNonNullType(itemType)) {
-            return; // Invalid: intentionally return no value.
-          }
-
-          coercedValues.push(null);
-        } else {
-          var itemValue = valueFromAST(itemNode, itemType, variables);
-
-          if (itemValue === undefined) {
-            return; // Invalid: intentionally return no value.
-          }
-
-          coercedValues.push(itemValue);
-        }
-      }
-
-      return coercedValues;
-    }
-
-    var coercedValue = valueFromAST(valueNode, itemType, variables);
-
-    if (coercedValue === undefined) {
-      return; // Invalid: intentionally return no value.
-    }
-
-    return [coercedValue];
-  }
-
-  if (isInputObjectType(type)) {
-    if (valueNode.kind !== Kind.OBJECT) {
-      return; // Invalid: intentionally return no value.
-    }
-
-    var coercedObj = Object.create(null);
-    var fieldNodes = keyMap(valueNode.fields, function (field) {
-      return field.name.value;
-    });
-
-    for (var _i4 = 0, _objectValues2 = objectValues$1(type.getFields()); _i4 < _objectValues2.length; _i4++) {
-      var field = _objectValues2[_i4];
-      var fieldNode = fieldNodes[field.name];
-
-      if (!fieldNode || isMissingVariable(fieldNode.value, variables)) {
-        if (field.defaultValue !== undefined) {
-          coercedObj[field.name] = field.defaultValue;
-        } else if (isNonNullType(field.type)) {
-          return; // Invalid: intentionally return no value.
-        }
-
-        continue;
-      }
-
-      var fieldValue = valueFromAST(fieldNode.value, field.type, variables);
-
-      if (fieldValue === undefined) {
-        return; // Invalid: intentionally return no value.
-      }
-
-      coercedObj[field.name] = fieldValue;
-    }
-
-    return coercedObj;
-  } // istanbul ignore else (See: 'https://github.com/graphql/graphql-js/issues/2618')
-
-
-  if (isLeafType(type)) {
-    // Scalars and Enums fulfill parsing a literal value via parseLiteral().
-    // Invalid values represent a failure to parse correctly, in which case
-    // no value is returned.
-    var result;
-
-    try {
-      result = type.parseLiteral(valueNode, variables);
-    } catch (_error) {
-      return; // Invalid: intentionally return no value.
-    }
-
-    if (result === undefined) {
-      return; // Invalid: intentionally return no value.
-    }
-
-    return result;
-  } // istanbul ignore next (Not reachable. All possible input types have been considered)
-
-
-  invariant(0, 'Unexpected input type: ' + inspect(type));
-} // Returns true if the provided valueNode is a variable which is not defined
-// in the set of variables.
-
-function isMissingVariable(valueNode, variables) {
-  return valueNode.kind === Kind.VARIABLE && (variables == null || variables[valueNode.name.value] === undefined);
-}
-
-/**
- * Prepares an object map of argument values given a list of argument
- * definitions and list of argument AST nodes.
- *
- * Note: The returned value is a plain Object with a prototype, since it is
- * exposed to user code. Care should be taken to not pull values from the
- * Object prototype.
- *
- * @internal
- */
-
-
-function getArgumentValues(def, node, variableValues) {
-  var _node$arguments;
-
-  var coercedValues = {}; // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
-
-  var argumentNodes = (_node$arguments = node.arguments) !== null && _node$arguments !== void 0 ? _node$arguments : [];
-  var argNodeMap = keyMap(argumentNodes, function (arg) {
-    return arg.name.value;
-  });
-
-  for (var _i4 = 0, _def$args2 = def.args; _i4 < _def$args2.length; _i4++) {
-    var argDef = _def$args2[_i4];
-    var name = argDef.name;
-    var argType = argDef.type;
-    var argumentNode = argNodeMap[name];
-
-    if (!argumentNode) {
-      if (argDef.defaultValue !== undefined) {
-        coercedValues[name] = argDef.defaultValue;
-      } else if (isNonNullType(argType)) {
-        throw new GraphQLError("Argument \"".concat(name, "\" of required type \"").concat(inspect(argType), "\" ") + 'was not provided.', node);
-      }
-
-      continue;
-    }
-
-    var valueNode = argumentNode.value;
-    var isNull = valueNode.kind === Kind.NULL;
-
-    if (valueNode.kind === Kind.VARIABLE) {
-      var variableName = valueNode.name.value;
-
-      if (variableValues == null || !hasOwnProperty(variableValues, variableName)) {
-        if (argDef.defaultValue !== undefined) {
-          coercedValues[name] = argDef.defaultValue;
-        } else if (isNonNullType(argType)) {
-          throw new GraphQLError("Argument \"".concat(name, "\" of required type \"").concat(inspect(argType), "\" ") + "was provided the variable \"$".concat(variableName, "\" which was not provided a runtime value."), valueNode);
-        }
-
-        continue;
-      }
-
-      isNull = variableValues[variableName] == null;
-    }
-
-    if (isNull && isNonNullType(argType)) {
-      throw new GraphQLError("Argument \"".concat(name, "\" of non-null type \"").concat(inspect(argType), "\" ") + 'must not be null.', valueNode);
-    }
-
-    var coercedValue = valueFromAST(valueNode, argType, variableValues);
-
-    if (coercedValue === undefined) {
-      // Note: ValuesOfCorrectTypeRule validation should catch this before
-      // execution. This is a runtime check to ensure execution does not
-      // continue with an invalid argument value.
-      throw new GraphQLError("Argument \"".concat(name, "\" has invalid value ").concat(print(valueNode), "."), valueNode);
-    }
-
-    coercedValues[name] = coercedValue;
-  }
-
-  return coercedValues;
-}
-/**
- * Prepares an object map of argument values given a directive definition
- * and a AST node which may contain directives. Optionally also accepts a map
- * of variable values.
- *
- * If the directive does not exist on the node, returns undefined.
- *
- * Note: The returned value is a plain Object with a prototype, since it is
- * exposed to user code. Care should be taken to not pull values from the
- * Object prototype.
- */
-
-function getDirectiveValues(directiveDef, node, variableValues) {
-  var directiveNode = node.directives && find$1(node.directives, function (directive) {
-    return directive.name.value === directiveDef.name;
-  });
-
-  if (directiveNode) {
-    return getArgumentValues(directiveDef, directiveNode, variableValues);
-  }
-}
-
-function hasOwnProperty(obj, prop) {
-  return Object.prototype.hasOwnProperty.call(obj, prop);
-}
-
 /**
  * Executable definitions
  *
@@ -9409,147 +9142,414 @@ var ASTValidationContext = /*#__PURE__*/function () {
     this._onError = onError;
   }
 
-  var _proto = ASTValidationContext.prototype;
+  var _proto = ASTValidationContext.prototype;
+
+  _proto.reportError = function reportError(error) {
+    this._onError(error);
+  };
+
+  _proto.getDocument = function getDocument() {
+    return this._ast;
+  };
+
+  _proto.getFragment = function getFragment(name) {
+    var fragments = this._fragments;
+
+    if (!fragments) {
+      this._fragments = fragments = this.getDocument().definitions.reduce(function (frags, statement) {
+        if (statement.kind === Kind.FRAGMENT_DEFINITION) {
+          frags[statement.name.value] = statement;
+        }
+
+        return frags;
+      }, Object.create(null));
+    }
+
+    return fragments[name];
+  };
+
+  _proto.getFragmentSpreads = function getFragmentSpreads(node) {
+    var spreads = this._fragmentSpreads.get(node);
+
+    if (!spreads) {
+      spreads = [];
+      var setsToVisit = [node];
+
+      while (setsToVisit.length !== 0) {
+        var set = setsToVisit.pop();
+
+        for (var _i2 = 0, _set$selections2 = set.selections; _i2 < _set$selections2.length; _i2++) {
+          var selection = _set$selections2[_i2];
+
+          if (selection.kind === Kind.FRAGMENT_SPREAD) {
+            spreads.push(selection);
+          } else if (selection.selectionSet) {
+            setsToVisit.push(selection.selectionSet);
+          }
+        }
+      }
+
+      this._fragmentSpreads.set(node, spreads);
+    }
+
+    return spreads;
+  };
+
+  _proto.getRecursivelyReferencedFragments = function getRecursivelyReferencedFragments(operation) {
+    var fragments = this._recursivelyReferencedFragments.get(operation);
+
+    if (!fragments) {
+      fragments = [];
+      var collectedNames = Object.create(null);
+      var nodesToVisit = [operation.selectionSet];
+
+      while (nodesToVisit.length !== 0) {
+        var node = nodesToVisit.pop();
+
+        for (var _i4 = 0, _this$getFragmentSpre2 = this.getFragmentSpreads(node); _i4 < _this$getFragmentSpre2.length; _i4++) {
+          var spread = _this$getFragmentSpre2[_i4];
+          var fragName = spread.name.value;
+
+          if (collectedNames[fragName] !== true) {
+            collectedNames[fragName] = true;
+            var fragment = this.getFragment(fragName);
+
+            if (fragment) {
+              fragments.push(fragment);
+              nodesToVisit.push(fragment.selectionSet);
+            }
+          }
+        }
+      }
+
+      this._recursivelyReferencedFragments.set(operation, fragments);
+    }
+
+    return fragments;
+  };
+
+  return ASTValidationContext;
+}();
+var SDLValidationContext = /*#__PURE__*/function (_ASTValidationContext) {
+  _inheritsLoose(SDLValidationContext, _ASTValidationContext);
+
+  function SDLValidationContext(ast, schema, onError) {
+    var _this;
+
+    _this = _ASTValidationContext.call(this, ast, onError) || this;
+    _this._schema = schema;
+    return _this;
+  }
+
+  var _proto2 = SDLValidationContext.prototype;
+
+  _proto2.getSchema = function getSchema() {
+    return this._schema;
+  };
+
+  return SDLValidationContext;
+}(ASTValidationContext);
+
+/**
+ * @internal
+ */
+
+function validateSDL(documentAST, schemaToExtend) {
+  var rules = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : specifiedSDLRules;
+  var errors = [];
+  var context = new SDLValidationContext(documentAST, schemaToExtend, function (error) {
+    errors.push(error);
+  });
+  var visitors = rules.map(function (rule) {
+    return rule(context);
+  });
+  visit(documentAST, visitInParallel(visitors));
+  return errors;
+}
+/**
+ * Utility function which asserts a SDL document is valid by throwing an error
+ * if it is invalid.
+ *
+ * @internal
+ */
+
+function assertValidSDL(documentAST) {
+  var errors = validateSDL(documentAST);
+
+  if (errors.length !== 0) {
+    throw new Error(errors.map(function (error) {
+      return error.message;
+    }).join('\n\n'));
+  }
+}
+
+/**
+ * Produces a JavaScript value given a GraphQL Value AST.
+ *
+ * A GraphQL type must be provided, which will be used to interpret different
+ * GraphQL Value literals.
+ *
+ * Returns `undefined` when the value could not be validly coerced according to
+ * the provided type.
+ *
+ * | GraphQL Value        | JSON Value    |
+ * | -------------------- | ------------- |
+ * | Input Object         | Object        |
+ * | List                 | Array         |
+ * | Boolean              | Boolean       |
+ * | String               | String        |
+ * | Int / Float          | Number        |
+ * | Enum Value           | Mixed         |
+ * | NullValue            | null          |
+ *
+ */
+
+function valueFromAST(valueNode, type, variables) {
+  if (!valueNode) {
+    // When there is no node, then there is also no value.
+    // Importantly, this is different from returning the value null.
+    return;
+  }
+
+  if (valueNode.kind === Kind.VARIABLE) {
+    var variableName = valueNode.name.value;
+
+    if (variables == null || variables[variableName] === undefined) {
+      // No valid return value.
+      return;
+    }
+
+    var variableValue = variables[variableName];
+
+    if (variableValue === null && isNonNullType(type)) {
+      return; // Invalid: intentionally return no value.
+    } // Note: This does no further checking that this variable is correct.
+    // This assumes that this query has been validated and the variable
+    // usage here is of the correct type.
+
+
+    return variableValue;
+  }
+
+  if (isNonNullType(type)) {
+    if (valueNode.kind === Kind.NULL) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    return valueFromAST(valueNode, type.ofType, variables);
+  }
+
+  if (valueNode.kind === Kind.NULL) {
+    // This is explicitly returning the value null.
+    return null;
+  }
+
+  if (isListType(type)) {
+    var itemType = type.ofType;
+
+    if (valueNode.kind === Kind.LIST) {
+      var coercedValues = [];
+
+      for (var _i2 = 0, _valueNode$values2 = valueNode.values; _i2 < _valueNode$values2.length; _i2++) {
+        var itemNode = _valueNode$values2[_i2];
+
+        if (isMissingVariable(itemNode, variables)) {
+          // If an array contains a missing variable, it is either coerced to
+          // null or if the item type is non-null, it considered invalid.
+          if (isNonNullType(itemType)) {
+            return; // Invalid: intentionally return no value.
+          }
+
+          coercedValues.push(null);
+        } else {
+          var itemValue = valueFromAST(itemNode, itemType, variables);
+
+          if (itemValue === undefined) {
+            return; // Invalid: intentionally return no value.
+          }
+
+          coercedValues.push(itemValue);
+        }
+      }
+
+      return coercedValues;
+    }
+
+    var coercedValue = valueFromAST(valueNode, itemType, variables);
+
+    if (coercedValue === undefined) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    return [coercedValue];
+  }
+
+  if (isInputObjectType(type)) {
+    if (valueNode.kind !== Kind.OBJECT) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    var coercedObj = Object.create(null);
+    var fieldNodes = keyMap(valueNode.fields, function (field) {
+      return field.name.value;
+    });
+
+    for (var _i4 = 0, _objectValues2 = objectValues$1(type.getFields()); _i4 < _objectValues2.length; _i4++) {
+      var field = _objectValues2[_i4];
+      var fieldNode = fieldNodes[field.name];
 
-  _proto.reportError = function reportError(error) {
-    this._onError(error);
-  };
+      if (!fieldNode || isMissingVariable(fieldNode.value, variables)) {
+        if (field.defaultValue !== undefined) {
+          coercedObj[field.name] = field.defaultValue;
+        } else if (isNonNullType(field.type)) {
+          return; // Invalid: intentionally return no value.
+        }
 
-  _proto.getDocument = function getDocument() {
-    return this._ast;
-  };
+        continue;
+      }
 
-  _proto.getFragment = function getFragment(name) {
-    var fragments = this._fragments;
+      var fieldValue = valueFromAST(fieldNode.value, field.type, variables);
 
-    if (!fragments) {
-      this._fragments = fragments = this.getDocument().definitions.reduce(function (frags, statement) {
-        if (statement.kind === Kind.FRAGMENT_DEFINITION) {
-          frags[statement.name.value] = statement;
-        }
+      if (fieldValue === undefined) {
+        return; // Invalid: intentionally return no value.
+      }
 
-        return frags;
-      }, Object.create(null));
+      coercedObj[field.name] = fieldValue;
     }
 
-    return fragments[name];
-  };
+    return coercedObj;
+  } // istanbul ignore else (See: 'https://github.com/graphql/graphql-js/issues/2618')
 
-  _proto.getFragmentSpreads = function getFragmentSpreads(node) {
-    var spreads = this._fragmentSpreads.get(node);
 
-    if (!spreads) {
-      spreads = [];
-      var setsToVisit = [node];
+  if (isLeafType(type)) {
+    // Scalars and Enums fulfill parsing a literal value via parseLiteral().
+    // Invalid values represent a failure to parse correctly, in which case
+    // no value is returned.
+    var result;
 
-      while (setsToVisit.length !== 0) {
-        var set = setsToVisit.pop();
+    try {
+      result = type.parseLiteral(valueNode, variables);
+    } catch (_error) {
+      return; // Invalid: intentionally return no value.
+    }
 
-        for (var _i2 = 0, _set$selections2 = set.selections; _i2 < _set$selections2.length; _i2++) {
-          var selection = _set$selections2[_i2];
+    if (result === undefined) {
+      return; // Invalid: intentionally return no value.
+    }
 
-          if (selection.kind === Kind.FRAGMENT_SPREAD) {
-            spreads.push(selection);
-          } else if (selection.selectionSet) {
-            setsToVisit.push(selection.selectionSet);
-          }
-        }
-      }
+    return result;
+  } // istanbul ignore next (Not reachable. All possible input types have been considered)
 
-      this._fragmentSpreads.set(node, spreads);
-    }
 
-    return spreads;
-  };
+  invariant(0, 'Unexpected input type: ' + inspect(type));
+} // Returns true if the provided valueNode is a variable which is not defined
+// in the set of variables.
 
-  _proto.getRecursivelyReferencedFragments = function getRecursivelyReferencedFragments(operation) {
-    var fragments = this._recursivelyReferencedFragments.get(operation);
+function isMissingVariable(valueNode, variables) {
+  return valueNode.kind === Kind.VARIABLE && (variables == null || variables[valueNode.name.value] === undefined);
+}
 
-    if (!fragments) {
-      fragments = [];
-      var collectedNames = Object.create(null);
-      var nodesToVisit = [operation.selectionSet];
+/**
+ * Prepares an object map of argument values given a list of argument
+ * definitions and list of argument AST nodes.
+ *
+ * Note: The returned value is a plain Object with a prototype, since it is
+ * exposed to user code. Care should be taken to not pull values from the
+ * Object prototype.
+ *
+ * @internal
+ */
 
-      while (nodesToVisit.length !== 0) {
-        var node = nodesToVisit.pop();
 
-        for (var _i4 = 0, _this$getFragmentSpre2 = this.getFragmentSpreads(node); _i4 < _this$getFragmentSpre2.length; _i4++) {
-          var spread = _this$getFragmentSpre2[_i4];
-          var fragName = spread.name.value;
+function getArgumentValues(def, node, variableValues) {
+  var _node$arguments;
 
-          if (collectedNames[fragName] !== true) {
-            collectedNames[fragName] = true;
-            var fragment = this.getFragment(fragName);
+  var coercedValues = {}; // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
 
-            if (fragment) {
-              fragments.push(fragment);
-              nodesToVisit.push(fragment.selectionSet);
-            }
-          }
-        }
+  var argumentNodes = (_node$arguments = node.arguments) !== null && _node$arguments !== void 0 ? _node$arguments : [];
+  var argNodeMap = keyMap(argumentNodes, function (arg) {
+    return arg.name.value;
+  });
+
+  for (var _i4 = 0, _def$args2 = def.args; _i4 < _def$args2.length; _i4++) {
+    var argDef = _def$args2[_i4];
+    var name = argDef.name;
+    var argType = argDef.type;
+    var argumentNode = argNodeMap[name];
+
+    if (!argumentNode) {
+      if (argDef.defaultValue !== undefined) {
+        coercedValues[name] = argDef.defaultValue;
+      } else if (isNonNullType(argType)) {
+        throw new GraphQLError("Argument \"".concat(name, "\" of required type \"").concat(inspect(argType), "\" ") + 'was not provided.', node);
       }
 
-      this._recursivelyReferencedFragments.set(operation, fragments);
+      continue;
     }
 
-    return fragments;
-  };
+    var valueNode = argumentNode.value;
+    var isNull = valueNode.kind === Kind.NULL;
 
-  return ASTValidationContext;
-}();
-var SDLValidationContext = /*#__PURE__*/function (_ASTValidationContext) {
-  _inheritsLoose(SDLValidationContext, _ASTValidationContext);
+    if (valueNode.kind === Kind.VARIABLE) {
+      var variableName = valueNode.name.value;
 
-  function SDLValidationContext(ast, schema, onError) {
-    var _this;
+      if (variableValues == null || !hasOwnProperty(variableValues, variableName)) {
+        if (argDef.defaultValue !== undefined) {
+          coercedValues[name] = argDef.defaultValue;
+        } else if (isNonNullType(argType)) {
+          throw new GraphQLError("Argument \"".concat(name, "\" of required type \"").concat(inspect(argType), "\" ") + "was provided the variable \"$".concat(variableName, "\" which was not provided a runtime value."), valueNode);
+        }
 
-    _this = _ASTValidationContext.call(this, ast, onError) || this;
-    _this._schema = schema;
-    return _this;
-  }
+        continue;
+      }
 
-  var _proto2 = SDLValidationContext.prototype;
+      isNull = variableValues[variableName] == null;
+    }
 
-  _proto2.getSchema = function getSchema() {
-    return this._schema;
-  };
+    if (isNull && isNonNullType(argType)) {
+      throw new GraphQLError("Argument \"".concat(name, "\" of non-null type \"").concat(inspect(argType), "\" ") + 'must not be null.', valueNode);
+    }
 
-  return SDLValidationContext;
-}(ASTValidationContext);
+    var coercedValue = valueFromAST(valueNode, argType, variableValues);
 
-/**
- * @internal
- */
+    if (coercedValue === undefined) {
+      // Note: ValuesOfCorrectTypeRule validation should catch this before
+      // execution. This is a runtime check to ensure execution does not
+      // continue with an invalid argument value.
+      throw new GraphQLError("Argument \"".concat(name, "\" has invalid value ").concat(print(valueNode), "."), valueNode);
+    }
 
-function validateSDL(documentAST, schemaToExtend) {
-  var rules = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : specifiedSDLRules;
-  var errors = [];
-  var context = new SDLValidationContext(documentAST, schemaToExtend, function (error) {
-    errors.push(error);
-  });
-  var visitors = rules.map(function (rule) {
-    return rule(context);
-  });
-  visit(documentAST, visitInParallel(visitors));
-  return errors;
+    coercedValues[name] = coercedValue;
+  }
+
+  return coercedValues;
 }
 /**
- * Utility function which asserts a SDL document is valid by throwing an error
- * if it is invalid.
+ * Prepares an object map of argument values given a directive definition
+ * and a AST node which may contain directives. Optionally also accepts a map
+ * of variable values.
  *
- * @internal
+ * If the directive does not exist on the node, returns undefined.
+ *
+ * Note: The returned value is a plain Object with a prototype, since it is
+ * exposed to user code. Care should be taken to not pull values from the
+ * Object prototype.
  */
 
-function assertValidSDL(documentAST) {
-  var errors = validateSDL(documentAST);
+function getDirectiveValues(directiveDef, node, variableValues) {
+  var directiveNode = node.directives && find$1(node.directives, function (directive) {
+    return directive.name.value === directiveDef.name;
+  });
 
-  if (errors.length !== 0) {
-    throw new Error(errors.map(function (error) {
-      return error.message;
-    }).join('\n\n'));
+  if (directiveNode) {
+    return getArgumentValues(directiveDef, directiveNode, variableValues);
   }
 }
 
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
@@ -10265,6 +10265,116 @@ function buildASTSchema(documentAST, options) {
   return new GraphQLSchema(config);
 }
 
+/**
+ * Strips characters that are not significant to the validity or execution
+ * of a GraphQL document:
+ *   - UnicodeBOM
+ *   - WhiteSpace
+ *   - LineTerminator
+ *   - Comment
+ *   - Comma
+ *   - BlockString indentation
+ *
+ * Note: It is required to have a delimiter character between neighboring
+ * non-punctuator tokens and this function always uses single space as delimiter.
+ *
+ * It is guaranteed that both input and output documents if parsed would result
+ * in the exact same AST except for nodes location.
+ *
+ * Warning: It is guaranteed that this function will always produce stable results.
+ * However, it's not guaranteed that it will stay the same between different
+ * releases due to bugfixes or changes in the GraphQL specification.
+ *
+ * Query example:
+ *
+ * query SomeQuery($foo: String!, $bar: String) {
+ *   someField(foo: $foo, bar: $bar) {
+ *     a
+ *     b {
+ *       c
+ *       d
+ *     }
+ *   }
+ * }
+ *
+ * Becomes:
+ *
+ * query SomeQuery($foo:String!$bar:String){someField(foo:$foo bar:$bar){a b{c d}}}
+ *
+ * SDL example:
+ *
+ * """
+ * Type description
+ * """
+ * type Foo {
+ *   """
+ *   Field description
+ *   """
+ *   bar: String
+ * }
+ *
+ * Becomes:
+ *
+ * """Type description""" type Foo{"""Field description""" bar:String}
+ */
+
+function stripIgnoredCharacters(source) {
+  var sourceObj = isSource(source) ? source : new Source(source);
+  var body = sourceObj.body;
+  var lexer = new Lexer(sourceObj);
+  var strippedBody = '';
+  var wasLastAddedTokenNonPunctuator = false;
+
+  while (lexer.advance().kind !== TokenKind.EOF) {
+    var currentToken = lexer.token;
+    var tokenKind = currentToken.kind;
+    /**
+     * Every two non-punctuator tokens should have space between them.
+     * Also prevent case of non-punctuator token following by spread resulting
+     * in invalid token (e.g. `1...` is invalid Float token).
+     */
+
+    var isNonPunctuator = !isPunctuatorTokenKind(currentToken.kind);
+
+    if (wasLastAddedTokenNonPunctuator) {
+      if (isNonPunctuator || currentToken.kind === TokenKind.SPREAD) {
+        strippedBody += ' ';
+      }
+    }
+
+    var tokenBody = body.slice(currentToken.start, currentToken.end);
+
+    if (tokenKind === TokenKind.BLOCK_STRING) {
+      strippedBody += dedentBlockString(tokenBody);
+    } else {
+      strippedBody += tokenBody;
+    }
+
+    wasLastAddedTokenNonPunctuator = isNonPunctuator;
+  }
+
+  return strippedBody;
+}
+
+function dedentBlockString(blockStr) {
+  // skip leading and trailing triple quotations
+  var rawStr = blockStr.slice(3, -3);
+  var body = dedentBlockStringValue(rawStr);
+
+  if (getBlockStringIndentation(body) > 0) {
+    body = '\n' + body;
+  }
+
+  var lastChar = body[body.length - 1];
+  var hasTrailingQuote = lastChar === '"' && body.slice(-4) !== '\\"""';
+
+  if (hasTrailingQuote || lastChar === '\\') {
+    body += '\n';
+  }
+
+  return '"""' + body + '"""';
+}
+
 /* Util Functions */
 function isOperationDefinitionNode(input) {
     return input.kind === 'OperationDefinition';
@@ -10686,26 +10796,12 @@ function transform(root) {
     };
 }
 
-class LuvioGraphQLSchema {
-    constructor(luvioSchemaParams) {
-        this.schemaName = luvioSchemaParams.schemaName;
-        this.schema = luvioSchemaParams.schema;
-    }
-}
-
 /*
     Deprecated - Remove after existing usages are removed.
 */
 function parseAndVisit(source) {
     const ast = parse(source);
     return transform(ast);
-}
-function parseLuvioSchema(source, schemaName) {
-    const schema = buildASTSchema(parse(source));
-    return new LuvioGraphQLSchema({
-        schema,
-        schemaName,
-    });
 }
 
-export { Kind, LuvioGraphQLSchema, isScalarType, parseAndVisit, parseLuvioSchema };
+export { GraphQLScalarType, GraphQLSchema, Kind, buildASTSchema, isScalarType, parse, parseAndVisit, print, stripIgnoredCharacters };