@salesforce/lds-ads-bridge 1.294.0 → 1.296.0

package/dist/adsBridge.js

@@ -12,11 +12,11 @@
  *  *******************************************************************************************
  */
 /* proxy-compat-disable */
-import { RECORD_ID_PREFIX, RECORD_FIELDS_KEY_JUNCTION, ingestRecord, keyBuilderRecord, keyBuilderObjectInfo } from 'force/ldsAdaptersUiapi';
-import { withDefaultLuvio } from 'force/ldsEngine';
+import { ingestRecord, keyBuilderRecord, keyBuilderObjectInfo } from 'force/ldsAdaptersUiapi';
+import { register, withDefaultLuvio } from 'force/ldsEngine';
 
-const { push } = Array.prototype;
-const { keys } = Object;
+const { push: push$1 } = Array.prototype;
+const { keys: keys$1 } = Object;
 const { hasOwnProperty } = Object.prototype;
 const { parse, stringify } = JSON;
 
@@ -24,9 +24,4298 @@ const ADS_BRIDGE_ADD_RECORDS_DURATION = 'ads-bridge-add-records-duration';
 const ADS_BRIDGE_EMIT_RECORD_CHANGED_DURATION = 'ads-bridge-emit-record-changed-duration';
 const ADS_BRIDGE_EVICT_DURATION = 'ads-bridge-evict-duration';
 
+// For use by callers within this module to instrument interesting things.
+let instrumentation$1 = {
+    timerMetricAddDuration: (_metricName, _valueInMs) => { },
+};
+/**
+ * Allows external modules (typically a runtime environment) to set
+ * instrumentation hooks for this module. Note that the hooks are
+ * incremental - hooks not suppiled in newInstrumentation will retain
+ * their previous values. The default instrumentation hooks are no-ops.
+ *
+ * @param newInstrumentation instrumentation hooks to be overridden
+ */
+function instrument$1(newInstrumentation) {
+    instrumentation$1 = Object.assign(instrumentation$1, newInstrumentation);
+}
+
+var SnapshotState;
+(function (SnapshotState) {
+    SnapshotState["Fulfilled"] = "Fulfilled";
+    SnapshotState["Unfulfilled"] = "Unfulfilled";
+    SnapshotState["Error"] = "Error";
+    SnapshotState["Pending"] = "Pending";
+    SnapshotState["Stale"] = "Stale";
+})(SnapshotState || (SnapshotState = {}));
+
+Promise.resolve();
+
+var StoreErrorStatus;
+(function (StoreErrorStatus) {
+    StoreErrorStatus[StoreErrorStatus["RESOURCE_NOT_FOUND"] = 404] = "RESOURCE_NOT_FOUND";
+})(StoreErrorStatus || (StoreErrorStatus = {}));
+var StoreRecordType;
+(function (StoreRecordType) {
+    StoreRecordType["Error"] = "error";
+})(StoreRecordType || (StoreRecordType = {}));
+var StoreLinkStateValues$1;
+(function (StoreLinkStateValues) {
+    StoreLinkStateValues[StoreLinkStateValues["NotPresent"] = 0] = "NotPresent";
+    StoreLinkStateValues[StoreLinkStateValues["RefNotPresent"] = 1] = "RefNotPresent";
+    StoreLinkStateValues[StoreLinkStateValues["RefPresent"] = 2] = "RefPresent";
+    StoreLinkStateValues[StoreLinkStateValues["Null"] = 3] = "Null";
+    StoreLinkStateValues[StoreLinkStateValues["Missing"] = 4] = "Missing";
+    StoreLinkStateValues[StoreLinkStateValues["Pending"] = 5] = "Pending";
+})(StoreLinkStateValues$1 || (StoreLinkStateValues$1 = {}));
+var StoreResolveResultState;
+(function (StoreResolveResultState) {
+    StoreResolveResultState[StoreResolveResultState["Found"] = 0] = "Found";
+    StoreResolveResultState[StoreResolveResultState["Error"] = 1] = "Error";
+    StoreResolveResultState[StoreResolveResultState["Null"] = 2] = "Null";
+    StoreResolveResultState[StoreResolveResultState["NotPresent"] = 3] = "NotPresent";
+    StoreResolveResultState[StoreResolveResultState["Stale"] = 4] = "Stale";
+})(StoreResolveResultState || (StoreResolveResultState = {}));
+var HttpStatusCode;
+(function (HttpStatusCode) {
+    HttpStatusCode[HttpStatusCode["Ok"] = 200] = "Ok";
+    HttpStatusCode[HttpStatusCode["Created"] = 201] = "Created";
+    HttpStatusCode[HttpStatusCode["NoContent"] = 204] = "NoContent";
+    HttpStatusCode[HttpStatusCode["NotModified"] = 304] = "NotModified";
+    HttpStatusCode[HttpStatusCode["BadRequest"] = 400] = "BadRequest";
+    HttpStatusCode[HttpStatusCode["Unauthorized"] = 401] = "Unauthorized";
+    HttpStatusCode[HttpStatusCode["Forbidden"] = 403] = "Forbidden";
+    HttpStatusCode[HttpStatusCode["NotFound"] = 404] = "NotFound";
+    HttpStatusCode[HttpStatusCode["ServerError"] = 500] = "ServerError";
+    HttpStatusCode[HttpStatusCode["GatewayTimeout"] = 504] = "GatewayTimeout";
+})(HttpStatusCode || (HttpStatusCode = {}));
+var GraphNodeType;
+(function (GraphNodeType) {
+    GraphNodeType["Link"] = "Link";
+    GraphNodeType["Node"] = "Node";
+    GraphNodeType["Error"] = "Error";
+    GraphNodeType["Locked"] = "Locked";
+})(GraphNodeType || (GraphNodeType = {}));
+
+var StoreLinkStateValues;
+(function (StoreLinkStateValues) {
+    StoreLinkStateValues[StoreLinkStateValues["NotPresent"] = 0] = "NotPresent";
+    StoreLinkStateValues[StoreLinkStateValues["RefNotPresent"] = 1] = "RefNotPresent";
+    StoreLinkStateValues[StoreLinkStateValues["RefPresent"] = 2] = "RefPresent";
+    StoreLinkStateValues[StoreLinkStateValues["Null"] = 3] = "Null";
+    StoreLinkStateValues[StoreLinkStateValues["Missing"] = 4] = "Missing";
+    StoreLinkStateValues[StoreLinkStateValues["Pending"] = 5] = "Pending";
+})(StoreLinkStateValues || (StoreLinkStateValues = {}));
+var FragmentReadResultState;
+(function (FragmentReadResultState) {
+    FragmentReadResultState[FragmentReadResultState["Missing"] = 0] = "Missing";
+    FragmentReadResultState[FragmentReadResultState["Success"] = 1] = "Success";
+    FragmentReadResultState[FragmentReadResultState["Error"] = 2] = "Error";
+})(FragmentReadResultState || (FragmentReadResultState = {}));
+({
+    state: FragmentReadResultState.Missing,
+});
+
+var ResourceParamType;
+(function (ResourceParamType) {
+    ResourceParamType[ResourceParamType["UrlParameter"] = 0] = "UrlParameter";
+    ResourceParamType[ResourceParamType["QueryParameter"] = 1] = "QueryParameter";
+    ResourceParamType[ResourceParamType["Body"] = 2] = "Body";
+    ResourceParamType[ResourceParamType["Header"] = 3] = "Header";
+})(ResourceParamType || (ResourceParamType = {}));
+var TypeCheckShapes;
+(function (TypeCheckShapes) {
+    TypeCheckShapes[TypeCheckShapes["String"] = 0] = "String";
+    TypeCheckShapes[TypeCheckShapes["Boolean"] = 1] = "Boolean";
+    TypeCheckShapes[TypeCheckShapes["Number"] = 2] = "Number";
+    TypeCheckShapes[TypeCheckShapes["Integer"] = 3] = "Integer";
+    TypeCheckShapes[TypeCheckShapes["Unsupported"] = 4] = "Unsupported";
+})(TypeCheckShapes || (TypeCheckShapes = {}));
+// engine version: 0.154.20-1c52d927
+
+/**
+ * Returns true if the value acts like a Promise, i.e. has a "then" function,
+ * otherwise returns false.
+ */
+// eslint-disable-next-line no-redeclare
+
+function _typeof$4(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$4 = function _typeof(obj) { return typeof obj; }; } else { _typeof$4 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$4(obj); }
+
+/**
+ * Return true if `value` is object-like. A value is object-like if it's not
+ * `null` and has a `typeof` result of "object".
+ */
+function isObjectLike(value) {
+  return _typeof$4(value) == 'object' && value !== null;
+}
+
+// In ES2015 (or a polyfilled) environment, this will be Symbol.iterator
+// istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')
+var SYMBOL_ITERATOR = typeof Symbol === 'function' && Symbol.iterator != null ? Symbol.iterator : '@@iterator'; // In ES2017 (or a polyfilled) environment, this will be Symbol.asyncIterator
+
+var SYMBOL_TO_STRING_TAG = typeof Symbol === 'function' && Symbol.toStringTag != null ? Symbol.toStringTag : '@@toStringTag';
+
+/**
+ * Represents a location in a Source.
+ */
+
+/**
+ * Takes a Source and a UTF-8 character offset, and returns the corresponding
+ * line and column as a SourceLocation.
+ */
+function getLocation(source, position) {
+  var lineRegexp = /\r\n|[\n\r]/g;
+  var line = 1;
+  var column = position + 1;
+  var match;
+
+  while ((match = lineRegexp.exec(source.body)) && match.index < position) {
+    line += 1;
+    column = position + 1 - (match.index + match[0].length);
+  }
+
+  return {
+    line: line,
+    column: column
+  };
+}
+
+/**
+ * Render a helpful description of the location in the GraphQL Source document.
+ */
+
+function printLocation(location) {
+  return printSourceLocation(location.source, getLocation(location.source, location.start));
+}
+/**
+ * Render a helpful description of the location in the GraphQL Source document.
+ */
+
+function printSourceLocation(source, sourceLocation) {
+  var firstLineColumnOffset = source.locationOffset.column - 1;
+  var body = whitespace(firstLineColumnOffset) + source.body;
+  var lineIndex = sourceLocation.line - 1;
+  var lineOffset = source.locationOffset.line - 1;
+  var lineNum = sourceLocation.line + lineOffset;
+  var columnOffset = sourceLocation.line === 1 ? firstLineColumnOffset : 0;
+  var columnNum = sourceLocation.column + columnOffset;
+  var locationStr = "".concat(source.name, ":").concat(lineNum, ":").concat(columnNum, "\n");
+  var lines = body.split(/\r\n|[\n\r]/g);
+  var locationLine = lines[lineIndex]; // Special case for minified documents
+
+  if (locationLine.length > 120) {
+    var subLineIndex = Math.floor(columnNum / 80);
+    var subLineColumnNum = columnNum % 80;
+    var subLines = [];
+
+    for (var i = 0; i < locationLine.length; i += 80) {
+      subLines.push(locationLine.slice(i, i + 80));
+    }
+
+    return locationStr + printPrefixedLines([["".concat(lineNum), subLines[0]]].concat(subLines.slice(1, subLineIndex + 1).map(function (subLine) {
+      return ['', subLine];
+    }), [[' ', whitespace(subLineColumnNum - 1) + '^'], ['', subLines[subLineIndex + 1]]]));
+  }
+
+  return locationStr + printPrefixedLines([// Lines specified like this: ["prefix", "string"],
+  ["".concat(lineNum - 1), lines[lineIndex - 1]], ["".concat(lineNum), locationLine], ['', whitespace(columnNum - 1) + '^'], ["".concat(lineNum + 1), lines[lineIndex + 1]]]);
+}
+
+function printPrefixedLines(lines) {
+  var existingLines = lines.filter(function (_ref) {
+    _ref[0];
+        var line = _ref[1];
+    return line !== undefined;
+  });
+  var padLen = Math.max.apply(Math, existingLines.map(function (_ref2) {
+    var prefix = _ref2[0];
+    return prefix.length;
+  }));
+  return existingLines.map(function (_ref3) {
+    var prefix = _ref3[0],
+        line = _ref3[1];
+    return leftPad(padLen, prefix) + (line ? ' | ' + line : ' |');
+  }).join('\n');
+}
+
+function whitespace(len) {
+  return Array(len + 1).join(' ');
+}
+
+function leftPad(len, str) {
+  return whitespace(len - str.length) + str;
+}
+
+function _typeof$3(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$3 = function _typeof(obj) { return typeof obj; }; } else { _typeof$3 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$3(obj); }
+
+function ownKeys$1(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$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty$2(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty$2(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties$4(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass$4(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$4(Constructor.prototype, protoProps); if (staticProps) _defineProperties$4(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof$3(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+/**
+ * A GraphQLError describes an Error found during the parse, validate, or
+ * execute phases of performing a GraphQL operation. In addition to a message
+ * and stack trace, it also includes information about the locations in a
+ * GraphQL document and/or execution result that correspond to the Error.
+ */
+
+var GraphQLError = /*#__PURE__*/function (_Error) {
+  _inherits(GraphQLError, _Error);
+
+  var _super = _createSuper(GraphQLError);
+
+  /**
+   * An array of { line, column } locations within the source GraphQL document
+   * which correspond to this error.
+   *
+   * Errors during validation often contain multiple locations, for example to
+   * point out two things with the same name. Errors during execution include a
+   * single location, the field which produced the error.
+   *
+   * Enumerable, and appears in the result of JSON.stringify().
+   */
+
+  /**
+   * An array describing the JSON-path into the execution response which
+   * corresponds to this error. Only included for errors during execution.
+   *
+   * Enumerable, and appears in the result of JSON.stringify().
+   */
+
+  /**
+   * An array of GraphQL AST Nodes corresponding to this error.
+   */
+
+  /**
+   * The source GraphQL document for the first location of this error.
+   *
+   * Note that if this Error represents more than one node, the source may not
+   * represent nodes after the first node.
+   */
+
+  /**
+   * An array of character offsets within the source GraphQL document
+   * which correspond to this error.
+   */
+
+  /**
+   * The original error thrown from a field resolver during execution.
+   */
+
+  /**
+   * Extension fields to add to the formatted error.
+   */
+  function GraphQLError(message, nodes, source, positions, path, originalError, extensions) {
+    var _nodeLocations, _nodeLocations2, _nodeLocations3;
+
+    var _this;
+
+    _classCallCheck(this, GraphQLError);
+
+    _this = _super.call(this, message);
+    _this.name = 'GraphQLError';
+    _this.originalError = originalError !== null && originalError !== void 0 ? originalError : undefined; // Compute list of blame nodes.
+
+    _this.nodes = undefinedIfEmpty(Array.isArray(nodes) ? nodes : nodes ? [nodes] : undefined);
+    var nodeLocations = [];
+
+    for (var _i2 = 0, _ref3 = (_this$nodes = _this.nodes) !== null && _this$nodes !== void 0 ? _this$nodes : []; _i2 < _ref3.length; _i2++) {
+      var _this$nodes;
+
+      var _ref4 = _ref3[_i2];
+      var loc = _ref4.loc;
+
+      if (loc != null) {
+        nodeLocations.push(loc);
+      }
+    }
+
+    nodeLocations = undefinedIfEmpty(nodeLocations); // Compute locations in the source for the given nodes/positions.
+
+    _this.source = source !== null && source !== void 0 ? source : (_nodeLocations = nodeLocations) === null || _nodeLocations === void 0 ? void 0 : _nodeLocations[0].source;
+    _this.positions = positions !== null && positions !== void 0 ? positions : (_nodeLocations2 = nodeLocations) === null || _nodeLocations2 === void 0 ? void 0 : _nodeLocations2.map(function (loc) {
+      return loc.start;
+    });
+    _this.locations = positions && source ? positions.map(function (pos) {
+      return getLocation(source, pos);
+    }) : (_nodeLocations3 = nodeLocations) === null || _nodeLocations3 === void 0 ? void 0 : _nodeLocations3.map(function (loc) {
+      return getLocation(loc.source, loc.start);
+    });
+    _this.path = path !== null && path !== void 0 ? path : undefined;
+    var originalExtensions = originalError === null || originalError === void 0 ? void 0 : originalError.extensions;
+
+    if (extensions == null && isObjectLike(originalExtensions)) {
+      _this.extensions = _objectSpread$1({}, originalExtensions);
+    } else {
+      _this.extensions = extensions !== null && extensions !== void 0 ? extensions : {};
+    } // By being enumerable, JSON.stringify will include bellow properties in the resulting output.
+    // This ensures that the simplest possible GraphQL service adheres to the spec.
+
+
+    Object.defineProperties(_assertThisInitialized(_this), {
+      message: {
+        enumerable: true
+      },
+      locations: {
+        enumerable: _this.locations != null
+      },
+      path: {
+        enumerable: _this.path != null
+      },
+      extensions: {
+        enumerable: _this.extensions != null && Object.keys(_this.extensions).length > 0
+      },
+      name: {
+        enumerable: false
+      },
+      nodes: {
+        enumerable: false
+      },
+      source: {
+        enumerable: false
+      },
+      positions: {
+        enumerable: false
+      },
+      originalError: {
+        enumerable: false
+      }
+    }); // Include (non-enumerable) stack trace.
+
+    if (originalError !== null && originalError !== void 0 && originalError.stack) {
+      Object.defineProperty(_assertThisInitialized(_this), 'stack', {
+        value: originalError.stack,
+        writable: true,
+        configurable: true
+      });
+      return _possibleConstructorReturn(_this);
+    } // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')
+
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(_assertThisInitialized(_this), GraphQLError);
+    } else {
+      Object.defineProperty(_assertThisInitialized(_this), 'stack', {
+        value: Error().stack,
+        writable: true,
+        configurable: true
+      });
+    }
+
+    return _this;
+  }
+
+  _createClass$4(GraphQLError, [{
+    key: "toString",
+    value: function toString() {
+      return printError(this);
+    } // FIXME: workaround to not break chai comparisons, should be remove in v16
+    // $FlowFixMe[unsupported-syntax] Flow doesn't support computed properties yet
+
+  }, {
+    key: SYMBOL_TO_STRING_TAG,
+    get: function get() {
+      return 'Object';
+    }
+  }]);
+
+  return GraphQLError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+function undefinedIfEmpty(array) {
+  return array === undefined || array.length === 0 ? undefined : array;
+}
+/**
+ * Prints a GraphQLError to a string, representing useful location information
+ * about the error's position in the source.
+ */
+
+
+function printError(error) {
+  var output = error.message;
+
+  if (error.nodes) {
+    for (var _i4 = 0, _error$nodes2 = error.nodes; _i4 < _error$nodes2.length; _i4++) {
+      var node = _error$nodes2[_i4];
+
+      if (node.loc) {
+        output += '\n\n' + printLocation(node.loc);
+      }
+    }
+  } else if (error.source && error.locations) {
+    for (var _i6 = 0, _error$locations2 = error.locations; _i6 < _error$locations2.length; _i6++) {
+      var location = _error$locations2[_i6];
+      output += '\n\n' + printSourceLocation(error.source, location);
+    }
+  }
+
+  return output;
+}
+
+/**
+ * The set of allowed kind values for AST nodes.
+ */
+var Kind = Object.freeze({
+  // Name
+  NAME: 'Name',
+  // Document
+  DOCUMENT: 'Document',
+  OPERATION_DEFINITION: 'OperationDefinition',
+  VARIABLE_DEFINITION: 'VariableDefinition',
+  SELECTION_SET: 'SelectionSet',
+  FIELD: 'Field',
+  ARGUMENT: 'Argument',
+  // Fragments
+  FRAGMENT_SPREAD: 'FragmentSpread',
+  INLINE_FRAGMENT: 'InlineFragment',
+  FRAGMENT_DEFINITION: 'FragmentDefinition',
+  // Values
+  VARIABLE: 'Variable',
+  INT: 'IntValue',
+  FLOAT: 'FloatValue',
+  STRING: 'StringValue',
+  BOOLEAN: 'BooleanValue',
+  NULL: 'NullValue',
+  ENUM: 'EnumValue',
+  LIST: 'ListValue',
+  OBJECT: 'ObjectValue',
+  OBJECT_FIELD: 'ObjectField',
+  // Directives
+  DIRECTIVE: 'Directive',
+  // Types
+  NAMED_TYPE: 'NamedType',
+  LIST_TYPE: 'ListType',
+  NON_NULL_TYPE: 'NonNullType',
+  // Type System Definitions
+  SCHEMA_DEFINITION: 'SchemaDefinition',
+  OPERATION_TYPE_DEFINITION: 'OperationTypeDefinition',
+  // Type Definitions
+  SCALAR_TYPE_DEFINITION: 'ScalarTypeDefinition',
+  OBJECT_TYPE_DEFINITION: 'ObjectTypeDefinition',
+  FIELD_DEFINITION: 'FieldDefinition',
+  INPUT_VALUE_DEFINITION: 'InputValueDefinition',
+  INTERFACE_TYPE_DEFINITION: 'InterfaceTypeDefinition',
+  UNION_TYPE_DEFINITION: 'UnionTypeDefinition',
+  ENUM_TYPE_DEFINITION: 'EnumTypeDefinition',
+  ENUM_VALUE_DEFINITION: 'EnumValueDefinition',
+  INPUT_OBJECT_TYPE_DEFINITION: 'InputObjectTypeDefinition',
+  // Directive Definitions
+  DIRECTIVE_DEFINITION: 'DirectiveDefinition',
+  // Type System Extensions
+  SCHEMA_EXTENSION: 'SchemaExtension',
+  // Type Extensions
+  SCALAR_TYPE_EXTENSION: 'ScalarTypeExtension',
+  OBJECT_TYPE_EXTENSION: 'ObjectTypeExtension',
+  INTERFACE_TYPE_EXTENSION: 'InterfaceTypeExtension',
+  UNION_TYPE_EXTENSION: 'UnionTypeExtension',
+  ENUM_TYPE_EXTENSION: 'EnumTypeExtension',
+  INPUT_OBJECT_TYPE_EXTENSION: 'InputObjectTypeExtension'
+});
+/**
+ * The enum type representing the possible kind values of AST nodes.
+ */
+
+function invariant(condition, message) {
+  var booleanCondition = Boolean(condition); // istanbul ignore else (See transformation done in './resources/inlineInvariant.js')
+
+  if (!booleanCondition) {
+    throw new Error(message != null ? message : 'Unexpected invariant triggered.');
+  }
+}
+
+// istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')
+var nodejsCustomInspectSymbol = typeof Symbol === 'function' && typeof Symbol.for === 'function' ? Symbol.for('nodejs.util.inspect.custom') : undefined;
+var nodejsCustomInspectSymbol$1 = nodejsCustomInspectSymbol;
+
+/**
+ * The `defineInspect()` function defines `inspect()` prototype method as alias of `toJSON`
+ */
+
+function defineInspect(classObject) {
+  var fn = classObject.prototype.toJSON;
+  typeof fn === 'function' || invariant(0);
+  classObject.prototype.inspect = fn; // istanbul ignore else (See: 'https://github.com/graphql/graphql-js/issues/2317')
+
+  if (nodejsCustomInspectSymbol$1) {
+    classObject.prototype[nodejsCustomInspectSymbol$1] = fn;
+  }
+}
+
+/**
+ * Contains a range of UTF-8 character offsets and token references that
+ * identify the region of the source from which the AST derived.
+ */
+var Location = /*#__PURE__*/function () {
+  /**
+   * The character offset at which this Node begins.
+   */
+
+  /**
+   * The character offset at which this Node ends.
+   */
+
+  /**
+   * The Token at which this Node begins.
+   */
+
+  /**
+   * The Token at which this Node ends.
+   */
+
+  /**
+   * The Source document the AST represents.
+   */
+  function Location(startToken, endToken, source) {
+    this.start = startToken.start;
+    this.end = endToken.end;
+    this.startToken = startToken;
+    this.endToken = endToken;
+    this.source = source;
+  }
+
+  var _proto = Location.prototype;
+
+  _proto.toJSON = function toJSON() {
+    return {
+      start: this.start,
+      end: this.end
+    };
+  };
+
+  return Location;
+}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.
+
+defineInspect(Location);
+/**
+ * Represents a range of characters represented by a lexical token
+ * within a Source.
+ */
+
+var Token = /*#__PURE__*/function () {
+  /**
+   * The kind of Token.
+   */
+
+  /**
+   * The character offset at which this Node begins.
+   */
+
+  /**
+   * The character offset at which this Node ends.
+   */
+
+  /**
+   * The 1-indexed line number on which this Token appears.
+   */
+
+  /**
+   * The 1-indexed column number at which this Token begins.
+   */
+
+  /**
+   * For non-punctuation tokens, represents the interpreted value of the token.
+   */
+
+  /**
+   * Tokens exist as nodes in a double-linked-list amongst all tokens
+   * including ignored tokens. <SOF> is always the first node and <EOF>
+   * the last.
+   */
+  function Token(kind, start, end, line, column, prev, value) {
+    this.kind = kind;
+    this.start = start;
+    this.end = end;
+    this.line = line;
+    this.column = column;
+    this.value = value;
+    this.prev = prev;
+    this.next = null;
+  }
+
+  var _proto2 = Token.prototype;
+
+  _proto2.toJSON = function toJSON() {
+    return {
+      kind: this.kind,
+      value: this.value,
+      line: this.line,
+      column: this.column
+    };
+  };
+
+  return Token;
+}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.
+
+defineInspect(Token);
+/**
+ * @internal
+ */
+
+function isNode(maybeNode) {
+  return maybeNode != null && typeof maybeNode.kind === 'string';
+}
+/**
+ * The enum type representing the token kinds values.
+ */
+
+function _typeof$2(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$2 = function _typeof(obj) { return typeof obj; }; } else { _typeof$2 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$2(obj); }
+var MAX_ARRAY_LENGTH = 10;
+var MAX_RECURSIVE_DEPTH = 2;
+/**
+ * Used to print values in error messages.
+ */
+
+function inspect(value) {
+  return formatValue(value, []);
+}
+
+function formatValue(value, seenValues) {
+  switch (_typeof$2(value)) {
+    case 'string':
+      return JSON.stringify(value);
+
+    case 'function':
+      return value.name ? "[function ".concat(value.name, "]") : '[function]';
+
+    case 'object':
+      if (value === null) {
+        return 'null';
+      }
+
+      return formatObjectValue(value, seenValues);
+
+    default:
+      return String(value);
+  }
+}
+
+function formatObjectValue(value, previouslySeenValues) {
+  if (previouslySeenValues.indexOf(value) !== -1) {
+    return '[Circular]';
+  }
+
+  var seenValues = [].concat(previouslySeenValues, [value]);
+  var customInspectFn = getCustomFn(value);
+
+  if (customInspectFn !== undefined) {
+    var customValue = customInspectFn.call(value); // check for infinite recursion
+
+    if (customValue !== value) {
+      return typeof customValue === 'string' ? customValue : formatValue(customValue, seenValues);
+    }
+  } else if (Array.isArray(value)) {
+    return formatArray(value, seenValues);
+  }
+
+  return formatObject(value, seenValues);
+}
+
+function formatObject(object, seenValues) {
+  var keys = Object.keys(object);
+
+  if (keys.length === 0) {
+    return '{}';
+  }
+
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return '[' + getObjectTag(object) + ']';
+  }
+
+  var properties = keys.map(function (key) {
+    var value = formatValue(object[key], seenValues);
+    return key + ': ' + value;
+  });
+  return '{ ' + properties.join(', ') + ' }';
+}
+
+function formatArray(array, seenValues) {
+  if (array.length === 0) {
+    return '[]';
+  }
+
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return '[Array]';
+  }
+
+  var len = Math.min(MAX_ARRAY_LENGTH, array.length);
+  var remaining = array.length - len;
+  var items = [];
+
+  for (var i = 0; i < len; ++i) {
+    items.push(formatValue(array[i], seenValues));
+  }
+
+  if (remaining === 1) {
+    items.push('... 1 more item');
+  } else if (remaining > 1) {
+    items.push("... ".concat(remaining, " more items"));
+  }
+
+  return '[' + items.join(', ') + ']';
+}
+
+function getCustomFn(object) {
+  var customInspectFn = object[String(nodejsCustomInspectSymbol$1)];
+
+  if (typeof customInspectFn === 'function') {
+    return customInspectFn;
+  }
+
+  if (typeof object.inspect === 'function') {
+    return object.inspect;
+  }
+}
+
+function getObjectTag(object) {
+  var tag = Object.prototype.toString.call(object).replace(/^\[object /, '').replace(/]$/, '');
+
+  if (tag === 'Object' && typeof object.constructor === 'function') {
+    var name = object.constructor.name;
+
+    if (typeof name === 'string' && name !== '') {
+      return name;
+    }
+  }
+
+  return tag;
+}
+
+function devAssert(condition, message) {
+  var booleanCondition = Boolean(condition); // istanbul ignore else (See transformation done in './resources/inlineInvariant.js')
+
+  if (!booleanCondition) {
+    throw new Error(message);
+  }
+}
+
+function _typeof$1(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1 = function _typeof(obj) { return typeof obj; }; } else { _typeof$1 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1(obj); }
+/**
+ * A replacement for instanceof which includes an error warning when multi-realm
+ * constructors are detected.
+ */
+
+// See: https://expressjs.com/en/advanced/best-practice-performance.html#set-node_env-to-production
+// See: https://webpack.js.org/guides/production/
+var instanceOf = process.env.NODE_ENV === 'production' ? // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')
+// eslint-disable-next-line no-shadow
+function instanceOf(value, constructor) {
+  return value instanceof constructor;
+} : // eslint-disable-next-line no-shadow
+function instanceOf(value, constructor) {
+  if (value instanceof constructor) {
+    return true;
+  }
+
+  if (_typeof$1(value) === 'object' && value !== null) {
+    var _value$constructor;
+
+    var className = constructor.prototype[Symbol.toStringTag];
+    var valueClassName = // We still need to support constructor's name to detect conflicts with older versions of this library.
+    Symbol.toStringTag in value ? value[Symbol.toStringTag] : (_value$constructor = value.constructor) === null || _value$constructor === void 0 ? void 0 : _value$constructor.name;
+
+    if (className === valueClassName) {
+      var stringifiedValue = inspect(value);
+      throw new Error("Cannot use ".concat(className, " \"").concat(stringifiedValue, "\" from another module or realm.\n\nEnsure that there is only one instance of \"graphql\" in the node_modules\ndirectory. If different versions of \"graphql\" are the dependencies of other\nrelied on modules, use \"resolutions\" to ensure only one version is installed.\n\nhttps://yarnpkg.com/en/docs/selective-version-resolutions\n\nDuplicate \"graphql\" modules cannot be used at the same time since different\nversions may have different capabilities and behavior. The data from one\nversion used in the function from another could produce confusing and\nspurious results."));
+    }
+  }
+
+  return false;
+};
+
+/**
+ * The set of allowed directive location values.
+ */
+var DirectiveLocation = Object.freeze({
+  // Request Definitions
+  QUERY: 'QUERY',
+  MUTATION: 'MUTATION',
+  SUBSCRIPTION: 'SUBSCRIPTION',
+  FIELD: 'FIELD',
+  FRAGMENT_DEFINITION: 'FRAGMENT_DEFINITION',
+  FRAGMENT_SPREAD: 'FRAGMENT_SPREAD',
+  INLINE_FRAGMENT: 'INLINE_FRAGMENT',
+  VARIABLE_DEFINITION: 'VARIABLE_DEFINITION',
+  // Type System Definitions
+  SCHEMA: 'SCHEMA',
+  SCALAR: 'SCALAR',
+  OBJECT: 'OBJECT',
+  FIELD_DEFINITION: 'FIELD_DEFINITION',
+  ARGUMENT_DEFINITION: 'ARGUMENT_DEFINITION',
+  INTERFACE: 'INTERFACE',
+  UNION: 'UNION',
+  ENUM: 'ENUM',
+  ENUM_VALUE: 'ENUM_VALUE',
+  INPUT_OBJECT: 'INPUT_OBJECT',
+  INPUT_FIELD_DEFINITION: 'INPUT_FIELD_DEFINITION'
+});
+/**
+ * Print a block string in the indented block form by adding a leading and
+ * trailing blank line. However, if a block string starts with whitespace and is
+ * a single-line, adding a leading blank line would strip that whitespace.
+ *
+ * @internal
+ */
+
+function printBlockString(value) {
+  var indentation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  var preferMultipleLines = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var isSingleLine = value.indexOf('\n') === -1;
+  var hasLeadingSpace = value[0] === ' ' || value[0] === '\t';
+  var hasTrailingQuote = value[value.length - 1] === '"';
+  var hasTrailingSlash = value[value.length - 1] === '\\';
+  var printAsMultipleLines = !isSingleLine || hasTrailingQuote || hasTrailingSlash || preferMultipleLines;
+  var result = ''; // Format a multi-line block quote to account for leading space.
+
+  if (printAsMultipleLines && !(isSingleLine && hasLeadingSpace)) {
+    result += '\n' + indentation;
+  }
+
+  result += indentation ? value.replace(/\n/g, '\n' + indentation) : value;
+
+  if (printAsMultipleLines) {
+    result += '\n';
+  }
+
+  return '"""' + result.replace(/"""/g, '\\"""') + '"""';
+}
+
+/**
+ * A visitor is provided to visit, it contains the collection of
+ * relevant functions to be called during the visitor's traversal.
+ */
+
+var QueryDocumentKeys = {
+  Name: [],
+  Document: ['definitions'],
+  OperationDefinition: ['name', 'variableDefinitions', 'directives', 'selectionSet'],
+  VariableDefinition: ['variable', 'type', 'defaultValue', 'directives'],
+  Variable: ['name'],
+  SelectionSet: ['selections'],
+  Field: ['alias', 'name', 'arguments', 'directives', 'selectionSet'],
+  Argument: ['name', 'value'],
+  FragmentSpread: ['name', 'directives'],
+  InlineFragment: ['typeCondition', 'directives', 'selectionSet'],
+  FragmentDefinition: ['name', // Note: fragment variable definitions are experimental and may be changed
+  // or removed in the future.
+  'variableDefinitions', 'typeCondition', 'directives', 'selectionSet'],
+  IntValue: [],
+  FloatValue: [],
+  StringValue: [],
+  BooleanValue: [],
+  NullValue: [],
+  EnumValue: [],
+  ListValue: ['values'],
+  ObjectValue: ['fields'],
+  ObjectField: ['name', 'value'],
+  Directive: ['name', 'arguments'],
+  NamedType: ['name'],
+  ListType: ['type'],
+  NonNullType: ['type'],
+  SchemaDefinition: ['description', 'directives', 'operationTypes'],
+  OperationTypeDefinition: ['type'],
+  ScalarTypeDefinition: ['description', 'name', 'directives'],
+  ObjectTypeDefinition: ['description', 'name', 'interfaces', 'directives', 'fields'],
+  FieldDefinition: ['description', 'name', 'arguments', 'type', 'directives'],
+  InputValueDefinition: ['description', 'name', 'type', 'defaultValue', 'directives'],
+  InterfaceTypeDefinition: ['description', 'name', 'interfaces', 'directives', 'fields'],
+  UnionTypeDefinition: ['description', 'name', 'directives', 'types'],
+  EnumTypeDefinition: ['description', 'name', 'directives', 'values'],
+  EnumValueDefinition: ['description', 'name', 'directives'],
+  InputObjectTypeDefinition: ['description', 'name', 'directives', 'fields'],
+  DirectiveDefinition: ['description', 'name', 'arguments', 'locations'],
+  SchemaExtension: ['directives', 'operationTypes'],
+  ScalarTypeExtension: ['name', 'directives'],
+  ObjectTypeExtension: ['name', 'interfaces', 'directives', 'fields'],
+  InterfaceTypeExtension: ['name', 'interfaces', 'directives', 'fields'],
+  UnionTypeExtension: ['name', 'directives', 'types'],
+  EnumTypeExtension: ['name', 'directives', 'values'],
+  InputObjectTypeExtension: ['name', 'directives', 'fields']
+};
+var BREAK = Object.freeze({});
+/**
+ * visit() will walk through an AST using a depth-first traversal, calling
+ * the visitor's enter function at each node in the traversal, and calling the
+ * leave function after visiting that node and all of its child nodes.
+ *
+ * By returning different values from the enter and leave functions, the
+ * behavior of the visitor can be altered, including skipping over a sub-tree of
+ * the AST (by returning false), editing the AST by returning a value or null
+ * to remove the value, or to stop the whole traversal by returning BREAK.
+ *
+ * When using visit() to edit an AST, the original AST will not be modified, and
+ * a new version of the AST with the changes applied will be returned from the
+ * visit function.
+ *
+ *     const editedAST = visit(ast, {
+ *       enter(node, key, parent, path, ancestors) {
+ *         // @return
+ *         //   undefined: no action
+ *         //   false: skip visiting this node
+ *         //   visitor.BREAK: stop visiting altogether
+ *         //   null: delete this node
+ *         //   any value: replace this node with the returned value
+ *       },
+ *       leave(node, key, parent, path, ancestors) {
+ *         // @return
+ *         //   undefined: no action
+ *         //   false: no action
+ *         //   visitor.BREAK: stop visiting altogether
+ *         //   null: delete this node
+ *         //   any value: replace this node with the returned value
+ *       }
+ *     });
+ *
+ * Alternatively to providing enter() and leave() functions, a visitor can
+ * instead provide functions named the same as the kinds of AST nodes, or
+ * enter/leave visitors at a named key, leading to four permutations of the
+ * visitor API:
+ *
+ * 1) Named visitors triggered when entering a node of a specific kind.
+ *
+ *     visit(ast, {
+ *       Kind(node) {
+ *         // enter the "Kind" node
+ *       }
+ *     })
+ *
+ * 2) Named visitors that trigger upon entering and leaving a node of
+ *    a specific kind.
+ *
+ *     visit(ast, {
+ *       Kind: {
+ *         enter(node) {
+ *           // enter the "Kind" node
+ *         }
+ *         leave(node) {
+ *           // leave the "Kind" node
+ *         }
+ *       }
+ *     })
+ *
+ * 3) Generic visitors that trigger upon entering and leaving any node.
+ *
+ *     visit(ast, {
+ *       enter(node) {
+ *         // enter any node
+ *       },
+ *       leave(node) {
+ *         // leave any node
+ *       }
+ *     })
+ *
+ * 4) Parallel visitors for entering and leaving nodes of a specific kind.
+ *
+ *     visit(ast, {
+ *       enter: {
+ *         Kind(node) {
+ *           // enter the "Kind" node
+ *         }
+ *       },
+ *       leave: {
+ *         Kind(node) {
+ *           // leave the "Kind" node
+ *         }
+ *       }
+ *     })
+ */
+
+function visit(root, visitor) {
+  var visitorKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : QueryDocumentKeys;
+
+  /* eslint-disable no-undef-init */
+  var stack = undefined;
+  var inArray = Array.isArray(root);
+  var keys = [root];
+  var index = -1;
+  var edits = [];
+  var node = undefined;
+  var key = undefined;
+  var parent = undefined;
+  var path = [];
+  var ancestors = [];
+  var newRoot = root;
+  /* eslint-enable no-undef-init */
+
+  do {
+    index++;
+    var isLeaving = index === keys.length;
+    var isEdited = isLeaving && edits.length !== 0;
+
+    if (isLeaving) {
+      key = ancestors.length === 0 ? undefined : path[path.length - 1];
+      node = parent;
+      parent = ancestors.pop();
+
+      if (isEdited) {
+        if (inArray) {
+          node = node.slice();
+        } else {
+          var clone = {};
+
+          for (var _i2 = 0, _Object$keys2 = Object.keys(node); _i2 < _Object$keys2.length; _i2++) {
+            var k = _Object$keys2[_i2];
+            clone[k] = node[k];
+          }
+
+          node = clone;
+        }
+
+        var editOffset = 0;
+
+        for (var ii = 0; ii < edits.length; ii++) {
+          var editKey = edits[ii][0];
+          var editValue = edits[ii][1];
+
+          if (inArray) {
+            editKey -= editOffset;
+          }
+
+          if (inArray && editValue === null) {
+            node.splice(editKey, 1);
+            editOffset++;
+          } else {
+            node[editKey] = editValue;
+          }
+        }
+      }
+
+      index = stack.index;
+      keys = stack.keys;
+      edits = stack.edits;
+      inArray = stack.inArray;
+      stack = stack.prev;
+    } else {
+      key = parent ? inArray ? index : keys[index] : undefined;
+      node = parent ? parent[key] : newRoot;
+
+      if (node === null || node === undefined) {
+        continue;
+      }
+
+      if (parent) {
+        path.push(key);
+      }
+    }
+
+    var result = void 0;
+
+    if (!Array.isArray(node)) {
+      if (!isNode(node)) {
+        throw new Error("Invalid AST Node: ".concat(inspect(node), "."));
+      }
+
+      var visitFn = getVisitFn(visitor, node.kind, isLeaving);
+
+      if (visitFn) {
+        result = visitFn.call(visitor, node, key, parent, path, ancestors);
+
+        if (result === BREAK) {
+          break;
+        }
+
+        if (result === false) {
+          if (!isLeaving) {
+            path.pop();
+            continue;
+          }
+        } else if (result !== undefined) {
+          edits.push([key, result]);
+
+          if (!isLeaving) {
+            if (isNode(result)) {
+              node = result;
+            } else {
+              path.pop();
+              continue;
+            }
+          }
+        }
+      }
+    }
+
+    if (result === undefined && isEdited) {
+      edits.push([key, node]);
+    }
+
+    if (isLeaving) {
+      path.pop();
+    } else {
+      var _visitorKeys$node$kin;
+
+      stack = {
+        inArray: inArray,
+        index: index,
+        keys: keys,
+        edits: edits,
+        prev: stack
+      };
+      inArray = Array.isArray(node);
+      keys = inArray ? node : (_visitorKeys$node$kin = visitorKeys[node.kind]) !== null && _visitorKeys$node$kin !== void 0 ? _visitorKeys$node$kin : [];
+      index = -1;
+      edits = [];
+
+      if (parent) {
+        ancestors.push(parent);
+      }
+
+      parent = node;
+    }
+  } while (stack !== undefined);
+
+  if (edits.length !== 0) {
+    newRoot = edits[edits.length - 1][1];
+  }
+
+  return newRoot;
+}
+/**
+ * Given a visitor instance, if it is leaving or not, and a node kind, return
+ * the function the visitor runtime should call.
+ */
+
+function getVisitFn(visitor, kind, isLeaving) {
+  var kindVisitor = visitor[kind];
+
+  if (kindVisitor) {
+    if (!isLeaving && typeof kindVisitor === 'function') {
+      // { Kind() {} }
+      return kindVisitor;
+    }
+
+    var kindSpecificVisitor = isLeaving ? kindVisitor.leave : kindVisitor.enter;
+
+    if (typeof kindSpecificVisitor === 'function') {
+      // { Kind: { enter() {}, leave() {} } }
+      return kindSpecificVisitor;
+    }
+  } else {
+    var specificVisitor = isLeaving ? visitor.leave : visitor.enter;
+
+    if (specificVisitor) {
+      if (typeof specificVisitor === 'function') {
+        // { enter() {}, leave() {} }
+        return specificVisitor;
+      }
+
+      var specificKindVisitor = specificVisitor[kind];
+
+      if (typeof specificKindVisitor === 'function') {
+        // { enter: { Kind() {} }, leave: { Kind() {} } }
+        return specificKindVisitor;
+      }
+    }
+  }
+}
+
+/* eslint-disable no-redeclare */
+// $FlowFixMe[name-already-bound] workaround for: https://github.com/facebook/flow/issues/4441
+var objectValues = Object.values || function (obj) {
+  return Object.keys(obj).map(function (key) {
+    return obj[key];
+  });
+};
+
+var objectValues$1 = objectValues;
+
+/* eslint-disable no-redeclare */
+// $FlowFixMe[name-already-bound] workaround for: https://github.com/facebook/flow/issues/4441
+var objectEntries = Object.entries || function (obj) {
+  return Object.keys(obj).map(function (key) {
+    return [key, obj[key]];
+  });
+};
+
+var objectEntries$1 = objectEntries;
+
+/**
+ * Creates a keyed JS object from an array, given a function to produce the keys
+ * for each value in the array.
+ *
+ * This provides a convenient lookup for the array items if the key function
+ * produces unique results.
+ *
+ *     const phoneBook = [
+ *       { name: 'Jon', num: '555-1234' },
+ *       { name: 'Jenny', num: '867-5309' }
+ *     ]
+ *
+ *     // { Jon: { name: 'Jon', num: '555-1234' },
+ *     //   Jenny: { name: 'Jenny', num: '867-5309' } }
+ *     const entriesByName = keyMap(
+ *       phoneBook,
+ *       entry => entry.name
+ *     )
+ *
+ *     // { name: 'Jenny', num: '857-6309' }
+ *     const jennyEntry = entriesByName['Jenny']
+ *
+ */
+function keyMap(list, keyFn) {
+  return list.reduce(function (map, item) {
+    map[keyFn(item)] = item;
+    return map;
+  }, Object.create(null));
+}
+
+/**
+ * Creates an object map with the same keys as `map` and values generated by
+ * running each value of `map` thru `fn`.
+ */
+function mapValue(map, fn) {
+  var result = Object.create(null);
+
+  for (var _i2 = 0, _objectEntries2 = objectEntries$1(map); _i2 < _objectEntries2.length; _i2++) {
+    var _ref2 = _objectEntries2[_i2];
+    var _key = _ref2[0];
+    var _value = _ref2[1];
+    result[_key] = fn(_value, _key);
+  }
+
+  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.
+ *
+ *     const phoneBook = [
+ *       { name: 'Jon', num: '555-1234' },
+ *       { name: 'Jenny', num: '867-5309' }
+ *     ]
+ *
+ *     // { Jon: '555-1234', Jenny: '867-5309' }
+ *     const phonesByName = keyValMap(
+ *       phoneBook,
+ *       entry => entry.name,
+ *       entry => entry.num
+ *     )
+ *
+ */
+function keyValMap(list, keyFn, valFn) {
+  return list.reduce(function (map, item) {
+    map[keyFn(item)] = valFn(item);
+    return map;
+  }, Object.create(null));
+}
+
+var MAX_SUGGESTIONS = 5;
+/**
+ * Given [ A, B, C ] return ' Did you mean A, B, or C?'.
+ */
+
+// eslint-disable-next-line no-redeclare
+function didYouMean(firstArg, secondArg) {
+  var _ref = typeof firstArg === 'string' ? [firstArg, secondArg] : [undefined, firstArg],
+      subMessage = _ref[0],
+      suggestionsArg = _ref[1];
+
+  var message = ' Did you mean ';
+
+  if (subMessage) {
+    message += subMessage + ' ';
+  }
+
+  var suggestions = suggestionsArg.map(function (x) {
+    return "\"".concat(x, "\"");
+  });
+
+  switch (suggestions.length) {
+    case 0:
+      return '';
+
+    case 1:
+      return message + suggestions[0] + '?';
+
+    case 2:
+      return message + suggestions[0] + ' or ' + suggestions[1] + '?';
+  }
+
+  var selected = suggestions.slice(0, MAX_SUGGESTIONS);
+  var lastItem = selected.pop();
+  return message + selected.join(', ') + ', or ' + lastItem + '?';
+}
+
+/**
+ * Returns the first argument it receives.
+ */
+function identityFunc(x) {
+  return x;
+}
+
+/**
+ * Returns a number indicating whether a reference string comes before, or after,
+ * or is the same as the given string in natural sort order.
+ *
+ * See: https://en.wikipedia.org/wiki/Natural_sort_order
+ *
+ */
+function naturalCompare(aStr, bStr) {
+  var aIdx = 0;
+  var bIdx = 0;
+
+  while (aIdx < aStr.length && bIdx < bStr.length) {
+    var aChar = aStr.charCodeAt(aIdx);
+    var bChar = bStr.charCodeAt(bIdx);
+
+    if (isDigit(aChar) && isDigit(bChar)) {
+      var aNum = 0;
+
+      do {
+        ++aIdx;
+        aNum = aNum * 10 + aChar - DIGIT_0;
+        aChar = aStr.charCodeAt(aIdx);
+      } while (isDigit(aChar) && aNum > 0);
+
+      var bNum = 0;
+
+      do {
+        ++bIdx;
+        bNum = bNum * 10 + bChar - DIGIT_0;
+        bChar = bStr.charCodeAt(bIdx);
+      } while (isDigit(bChar) && bNum > 0);
+
+      if (aNum < bNum) {
+        return -1;
+      }
+
+      if (aNum > bNum) {
+        return 1;
+      }
+    } else {
+      if (aChar < bChar) {
+        return -1;
+      }
+
+      if (aChar > bChar) {
+        return 1;
+      }
+
+      ++aIdx;
+      ++bIdx;
+    }
+  }
+
+  return aStr.length - bStr.length;
+}
+var DIGIT_0 = 48;
+var DIGIT_9 = 57;
+
+function isDigit(code) {
+  return !isNaN(code) && DIGIT_0 <= code && code <= DIGIT_9;
+}
+
+/**
+ * Given an invalid input string and a list of valid options, returns a filtered
+ * list of valid options sorted based on their similarity with the input.
+ */
+
+function suggestionList(input, options) {
+  var optionsByDistance = Object.create(null);
+  var lexicalDistance = new LexicalDistance(input);
+  var threshold = Math.floor(input.length * 0.4) + 1;
+
+  for (var _i2 = 0; _i2 < options.length; _i2++) {
+    var option = options[_i2];
+    var distance = lexicalDistance.measure(option, threshold);
+
+    if (distance !== undefined) {
+      optionsByDistance[option] = distance;
+    }
+  }
+
+  return Object.keys(optionsByDistance).sort(function (a, b) {
+    var distanceDiff = optionsByDistance[a] - optionsByDistance[b];
+    return distanceDiff !== 0 ? distanceDiff : naturalCompare(a, b);
+  });
+}
+/**
+ * Computes the lexical distance between strings A and B.
+ *
+ * The "distance" between two strings is given by counting the minimum number
+ * of edits needed to transform string A into string B. An edit can be an
+ * insertion, deletion, or substitution of a single character, or a swap of two
+ * adjacent characters.
+ *
+ * Includes a custom alteration from Damerau-Levenshtein to treat case changes
+ * as a single edit which helps identify mis-cased values with an edit distance
+ * of 1.
+ *
+ * This distance can be useful for detecting typos in input or sorting
+ */
+
+var LexicalDistance = /*#__PURE__*/function () {
+  function LexicalDistance(input) {
+    this._input = input;
+    this._inputLowerCase = input.toLowerCase();
+    this._inputArray = stringToArray(this._inputLowerCase);
+    this._rows = [new Array(input.length + 1).fill(0), new Array(input.length + 1).fill(0), new Array(input.length + 1).fill(0)];
+  }
+
+  var _proto = LexicalDistance.prototype;
+
+  _proto.measure = function measure(option, threshold) {
+    if (this._input === option) {
+      return 0;
+    }
+
+    var optionLowerCase = option.toLowerCase(); // Any case change counts as a single edit
+
+    if (this._inputLowerCase === optionLowerCase) {
+      return 1;
+    }
+
+    var a = stringToArray(optionLowerCase);
+    var b = this._inputArray;
+
+    if (a.length < b.length) {
+      var tmp = a;
+      a = b;
+      b = tmp;
+    }
+
+    var aLength = a.length;
+    var bLength = b.length;
+
+    if (aLength - bLength > threshold) {
+      return undefined;
+    }
+
+    var rows = this._rows;
+
+    for (var j = 0; j <= bLength; j++) {
+      rows[0][j] = j;
+    }
+
+    for (var i = 1; i <= aLength; i++) {
+      var upRow = rows[(i - 1) % 3];
+      var currentRow = rows[i % 3];
+      var smallestCell = currentRow[0] = i;
+
+      for (var _j = 1; _j <= bLength; _j++) {
+        var cost = a[i - 1] === b[_j - 1] ? 0 : 1;
+        var currentCell = Math.min(upRow[_j] + 1, // delete
+        currentRow[_j - 1] + 1, // insert
+        upRow[_j - 1] + cost // substitute
+        );
+
+        if (i > 1 && _j > 1 && a[i - 1] === b[_j - 2] && a[i - 2] === b[_j - 1]) {
+          // transposition
+          var doubleDiagonalCell = rows[(i - 2) % 3][_j - 2];
+          currentCell = Math.min(currentCell, doubleDiagonalCell + 1);
+        }
+
+        if (currentCell < smallestCell) {
+          smallestCell = currentCell;
+        }
+
+        currentRow[_j] = currentCell;
+      } // Early exit, since distance can't go smaller than smallest element of the previous row.
+
+
+      if (smallestCell > threshold) {
+        return undefined;
+      }
+    }
+
+    var distance = rows[aLength % 3][bLength];
+    return distance <= threshold ? distance : undefined;
+  };
+
+  return LexicalDistance;
+}();
+
+function stringToArray(str) {
+  var strLength = str.length;
+  var array = new Array(strLength);
+
+  for (var i = 0; i < strLength; ++i) {
+    array[i] = str.charCodeAt(i);
+  }
+
+  return array;
+}
+
+/**
+ * Converts an AST into a string, using one set of reasonable
+ * formatting rules.
+ */
+
+function print(ast) {
+  return visit(ast, {
+    leave: printDocASTReducer
+  });
+}
+var MAX_LINE_LENGTH = 80; // TODO: provide better type coverage in future
+
+var printDocASTReducer = {
+  Name: function Name(node) {
+    return node.value;
+  },
+  Variable: function Variable(node) {
+    return '$' + node.name;
+  },
+  // Document
+  Document: function Document(node) {
+    return join(node.definitions, '\n\n') + '\n';
+  },
+  OperationDefinition: function OperationDefinition(node) {
+    var op = node.operation;
+    var name = node.name;
+    var varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');
+    var directives = join(node.directives, ' ');
+    var selectionSet = node.selectionSet; // Anonymous queries with no directives or variable definitions can use
+    // the query short form.
+
+    return !name && !directives && !varDefs && op === 'query' ? selectionSet : join([op, join([name, varDefs]), directives, selectionSet], ' ');
+  },
+  VariableDefinition: function VariableDefinition(_ref) {
+    var variable = _ref.variable,
+        type = _ref.type,
+        defaultValue = _ref.defaultValue,
+        directives = _ref.directives;
+    return variable + ': ' + type + wrap(' = ', defaultValue) + wrap(' ', join(directives, ' '));
+  },
+  SelectionSet: function SelectionSet(_ref2) {
+    var selections = _ref2.selections;
+    return block(selections);
+  },
+  Field: function Field(_ref3) {
+    var alias = _ref3.alias,
+        name = _ref3.name,
+        args = _ref3.arguments,
+        directives = _ref3.directives,
+        selectionSet = _ref3.selectionSet;
+    var prefix = wrap('', alias, ': ') + name;
+    var argsLine = prefix + wrap('(', join(args, ', '), ')');
+
+    if (argsLine.length > MAX_LINE_LENGTH) {
+      argsLine = prefix + wrap('(\n', indent(join(args, '\n')), '\n)');
+    }
+
+    return join([argsLine, join(directives, ' '), selectionSet], ' ');
+  },
+  Argument: function Argument(_ref4) {
+    var name = _ref4.name,
+        value = _ref4.value;
+    return name + ': ' + value;
+  },
+  // Fragments
+  FragmentSpread: function FragmentSpread(_ref5) {
+    var name = _ref5.name,
+        directives = _ref5.directives;
+    return '...' + name + wrap(' ', join(directives, ' '));
+  },
+  InlineFragment: function InlineFragment(_ref6) {
+    var typeCondition = _ref6.typeCondition,
+        directives = _ref6.directives,
+        selectionSet = _ref6.selectionSet;
+    return join(['...', wrap('on ', typeCondition), join(directives, ' '), selectionSet], ' ');
+  },
+  FragmentDefinition: function FragmentDefinition(_ref7) {
+    var name = _ref7.name,
+        typeCondition = _ref7.typeCondition,
+        variableDefinitions = _ref7.variableDefinitions,
+        directives = _ref7.directives,
+        selectionSet = _ref7.selectionSet;
+    return (// Note: fragment variable definitions are experimental and may be changed
+      // or removed in the future.
+      "fragment ".concat(name).concat(wrap('(', join(variableDefinitions, ', '), ')'), " ") + "on ".concat(typeCondition, " ").concat(wrap('', join(directives, ' '), ' ')) + selectionSet
+    );
+  },
+  // Value
+  IntValue: function IntValue(_ref8) {
+    var value = _ref8.value;
+    return value;
+  },
+  FloatValue: function FloatValue(_ref9) {
+    var value = _ref9.value;
+    return value;
+  },
+  StringValue: function StringValue(_ref10, key) {
+    var value = _ref10.value,
+        isBlockString = _ref10.block;
+    return isBlockString ? printBlockString(value, key === 'description' ? '' : '  ') : JSON.stringify(value);
+  },
+  BooleanValue: function BooleanValue(_ref11) {
+    var value = _ref11.value;
+    return value ? 'true' : 'false';
+  },
+  NullValue: function NullValue() {
+    return 'null';
+  },
+  EnumValue: function EnumValue(_ref12) {
+    var value = _ref12.value;
+    return value;
+  },
+  ListValue: function ListValue(_ref13) {
+    var values = _ref13.values;
+    return '[' + join(values, ', ') + ']';
+  },
+  ObjectValue: function ObjectValue(_ref14) {
+    var fields = _ref14.fields;
+    return '{' + join(fields, ', ') + '}';
+  },
+  ObjectField: function ObjectField(_ref15) {
+    var name = _ref15.name,
+        value = _ref15.value;
+    return name + ': ' + value;
+  },
+  // Directive
+  Directive: function Directive(_ref16) {
+    var name = _ref16.name,
+        args = _ref16.arguments;
+    return '@' + name + wrap('(', join(args, ', '), ')');
+  },
+  // Type
+  NamedType: function NamedType(_ref17) {
+    var name = _ref17.name;
+    return name;
+  },
+  ListType: function ListType(_ref18) {
+    var type = _ref18.type;
+    return '[' + type + ']';
+  },
+  NonNullType: function NonNullType(_ref19) {
+    var type = _ref19.type;
+    return type + '!';
+  },
+  // Type System Definitions
+  SchemaDefinition: addDescription(function (_ref20) {
+    var directives = _ref20.directives,
+        operationTypes = _ref20.operationTypes;
+    return join(['schema', join(directives, ' '), block(operationTypes)], ' ');
+  }),
+  OperationTypeDefinition: function OperationTypeDefinition(_ref21) {
+    var operation = _ref21.operation,
+        type = _ref21.type;
+    return operation + ': ' + type;
+  },
+  ScalarTypeDefinition: addDescription(function (_ref22) {
+    var name = _ref22.name,
+        directives = _ref22.directives;
+    return join(['scalar', name, join(directives, ' ')], ' ');
+  }),
+  ObjectTypeDefinition: addDescription(function (_ref23) {
+    var name = _ref23.name,
+        interfaces = _ref23.interfaces,
+        directives = _ref23.directives,
+        fields = _ref23.fields;
+    return join(['type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');
+  }),
+  FieldDefinition: addDescription(function (_ref24) {
+    var name = _ref24.name,
+        args = _ref24.arguments,
+        type = _ref24.type,
+        directives = _ref24.directives;
+    return name + (hasMultilineItems(args) ? wrap('(\n', indent(join(args, '\n')), '\n)') : wrap('(', join(args, ', '), ')')) + ': ' + type + wrap(' ', join(directives, ' '));
+  }),
+  InputValueDefinition: addDescription(function (_ref25) {
+    var name = _ref25.name,
+        type = _ref25.type,
+        defaultValue = _ref25.defaultValue,
+        directives = _ref25.directives;
+    return join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' ');
+  }),
+  InterfaceTypeDefinition: addDescription(function (_ref26) {
+    var name = _ref26.name,
+        interfaces = _ref26.interfaces,
+        directives = _ref26.directives,
+        fields = _ref26.fields;
+    return join(['interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');
+  }),
+  UnionTypeDefinition: addDescription(function (_ref27) {
+    var name = _ref27.name,
+        directives = _ref27.directives,
+        types = _ref27.types;
+    return join(['union', name, join(directives, ' '), types && types.length !== 0 ? '= ' + join(types, ' | ') : ''], ' ');
+  }),
+  EnumTypeDefinition: addDescription(function (_ref28) {
+    var name = _ref28.name,
+        directives = _ref28.directives,
+        values = _ref28.values;
+    return join(['enum', name, join(directives, ' '), block(values)], ' ');
+  }),
+  EnumValueDefinition: addDescription(function (_ref29) {
+    var name = _ref29.name,
+        directives = _ref29.directives;
+    return join([name, join(directives, ' ')], ' ');
+  }),
+  InputObjectTypeDefinition: addDescription(function (_ref30) {
+    var name = _ref30.name,
+        directives = _ref30.directives,
+        fields = _ref30.fields;
+    return join(['input', name, join(directives, ' '), block(fields)], ' ');
+  }),
+  DirectiveDefinition: addDescription(function (_ref31) {
+    var name = _ref31.name,
+        args = _ref31.arguments,
+        repeatable = _ref31.repeatable,
+        locations = _ref31.locations;
+    return 'directive @' + name + (hasMultilineItems(args) ? wrap('(\n', indent(join(args, '\n')), '\n)') : wrap('(', join(args, ', '), ')')) + (repeatable ? ' repeatable' : '') + ' on ' + join(locations, ' | ');
+  }),
+  SchemaExtension: function SchemaExtension(_ref32) {
+    var directives = _ref32.directives,
+        operationTypes = _ref32.operationTypes;
+    return join(['extend schema', join(directives, ' '), block(operationTypes)], ' ');
+  },
+  ScalarTypeExtension: function ScalarTypeExtension(_ref33) {
+    var name = _ref33.name,
+        directives = _ref33.directives;
+    return join(['extend scalar', name, join(directives, ' ')], ' ');
+  },
+  ObjectTypeExtension: function ObjectTypeExtension(_ref34) {
+    var name = _ref34.name,
+        interfaces = _ref34.interfaces,
+        directives = _ref34.directives,
+        fields = _ref34.fields;
+    return join(['extend type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');
+  },
+  InterfaceTypeExtension: function InterfaceTypeExtension(_ref35) {
+    var name = _ref35.name,
+        interfaces = _ref35.interfaces,
+        directives = _ref35.directives,
+        fields = _ref35.fields;
+    return join(['extend interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');
+  },
+  UnionTypeExtension: function UnionTypeExtension(_ref36) {
+    var name = _ref36.name,
+        directives = _ref36.directives,
+        types = _ref36.types;
+    return join(['extend union', name, join(directives, ' '), types && types.length !== 0 ? '= ' + join(types, ' | ') : ''], ' ');
+  },
+  EnumTypeExtension: function EnumTypeExtension(_ref37) {
+    var name = _ref37.name,
+        directives = _ref37.directives,
+        values = _ref37.values;
+    return join(['extend enum', name, join(directives, ' '), block(values)], ' ');
+  },
+  InputObjectTypeExtension: function InputObjectTypeExtension(_ref38) {
+    var name = _ref38.name,
+        directives = _ref38.directives,
+        fields = _ref38.fields;
+    return join(['extend input', name, join(directives, ' '), block(fields)], ' ');
+  }
+};
+
+function addDescription(cb) {
+  return function (node) {
+    return join([node.description, cb(node)], '\n');
+  };
+}
+/**
+ * Given maybeArray, print an empty string if it is null or empty, otherwise
+ * print all items together separated by separator if provided
+ */
+
+
+function join(maybeArray) {
+  var _maybeArray$filter$jo;
+
+  var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  return (_maybeArray$filter$jo = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.filter(function (x) {
+    return x;
+  }).join(separator)) !== null && _maybeArray$filter$jo !== void 0 ? _maybeArray$filter$jo : '';
+}
+/**
+ * Given array, print each item on its own line, wrapped in an
+ * indented "{ }" block.
+ */
+
+
+function block(array) {
+  return wrap('{\n', indent(join(array, '\n')), '\n}');
+}
+/**
+ * If maybeString is not null or empty, then wrap with start and end, otherwise print an empty string.
+ */
+
+
+function wrap(start, maybeString) {
+  var end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  return maybeString != null && maybeString !== '' ? start + maybeString + end : '';
+}
+
+function indent(str) {
+  return wrap('  ', str.replace(/\n/g, '\n  '));
+}
+
+function isMultiline(str) {
+  return str.indexOf('\n') !== -1;
+}
+
+function hasMultilineItems(maybeArray) {
+  return maybeArray != null && maybeArray.some(isMultiline);
+}
+
+/**
+ * Produces a JavaScript value given a GraphQL Value AST.
+ *
+ * Unlike `valueFromAST()`, no type is provided. The resulting JavaScript value
+ * will reflect the provided GraphQL value AST.
+ *
+ * | GraphQL Value        | JavaScript Value |
+ * | -------------------- | ---------------- |
+ * | Input Object         | Object           |
+ * | List                 | Array            |
+ * | Boolean              | Boolean          |
+ * | String / Enum        | String           |
+ * | Int / Float          | Number           |
+ * | Null                 | null             |
+ *
+ */
+function valueFromASTUntyped(valueNode, variables) {
+  switch (valueNode.kind) {
+    case Kind.NULL:
+      return null;
+
+    case Kind.INT:
+      return parseInt(valueNode.value, 10);
+
+    case Kind.FLOAT:
+      return parseFloat(valueNode.value);
+
+    case Kind.STRING:
+    case Kind.ENUM:
+    case Kind.BOOLEAN:
+      return valueNode.value;
+
+    case Kind.LIST:
+      return valueNode.values.map(function (node) {
+        return valueFromASTUntyped(node, variables);
+      });
+
+    case Kind.OBJECT:
+      return keyValMap(valueNode.fields, function (field) {
+        return field.name.value;
+      }, function (field) {
+        return valueFromASTUntyped(field.value, variables);
+      });
+
+    case Kind.VARIABLE:
+      return variables === null || variables === void 0 ? void 0 : variables[valueNode.name.value];
+  } // istanbul ignore next (Not reachable. All possible value nodes have been considered)
+
+
+  invariant(0, 'Unexpected value node: ' + inspect(valueNode));
+}
+
+function _defineProperties$2(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass$2(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2(Constructor, staticProps); return Constructor; }
+function isType(type) {
+  return isScalarType(type) || isObjectType(type) || isInterfaceType(type) || isUnionType(type) || isEnumType(type) || isInputObjectType(type) || isListType(type) || isNonNullType(type);
+}
+function assertType(type) {
+  if (!isType(type)) {
+    throw new Error("Expected ".concat(inspect(type), " to be a GraphQL type."));
+  }
+
+  return type;
+}
+/**
+ * There are predicates for each kind of GraphQL type.
+ */
+
+// eslint-disable-next-line no-redeclare
+function isScalarType(type) {
+  return instanceOf(type, GraphQLScalarType);
+}
+// eslint-disable-next-line no-redeclare
+function isObjectType(type) {
+  return instanceOf(type, GraphQLObjectType);
+}
+// eslint-disable-next-line no-redeclare
+function isInterfaceType(type) {
+  return instanceOf(type, GraphQLInterfaceType);
+}
+// eslint-disable-next-line no-redeclare
+function isUnionType(type) {
+  return instanceOf(type, GraphQLUnionType);
+}
+// eslint-disable-next-line no-redeclare
+function isEnumType(type) {
+  return instanceOf(type, GraphQLEnumType);
+}
+// eslint-disable-next-line no-redeclare
+function isInputObjectType(type) {
+  return instanceOf(type, GraphQLInputObjectType);
+}
+// eslint-disable-next-line no-redeclare
+function isListType(type) {
+  return instanceOf(type, GraphQLList);
+}
+// eslint-disable-next-line no-redeclare
+function isNonNullType(type) {
+  return instanceOf(type, GraphQLNonNull);
+}
+/**
+ * These types may describe types which may be leaf values.
+ */
+
+function isLeafType(type) {
+  return isScalarType(type) || isEnumType(type);
+}
+/**
+ * These types may describe the parent context of a selection set.
+ */
+
+function isAbstractType(type) {
+  return isInterfaceType(type) || isUnionType(type);
+}
+/**
+ * List Type Wrapper
+ *
+ * A list is a wrapping type which points to another type.
+ * Lists are often created within the context of defining the fields of
+ * an object type.
+ *
+ * Example:
+ *
+ *     const PersonType = new GraphQLObjectType({
+ *       name: 'Person',
+ *       fields: () => ({
+ *         parents: { type: new GraphQLList(PersonType) },
+ *         children: { type: new GraphQLList(PersonType) },
+ *       })
+ *     })
+ *
+ */
+// FIXME: workaround to fix issue with Babel parser
+
+/* ::
+declare class GraphQLList<+T: GraphQLType> {
+  +ofType: T;
+  static <T>(ofType: T): GraphQLList<T>;
+  // Note: constructors cannot be used for covariant types. Drop the "new".
+  constructor(ofType: GraphQLType): void;
+}
+*/
+
+function GraphQLList(ofType) {
+  // istanbul ignore else (to be removed in v16.0.0)
+  if (this instanceof GraphQLList) {
+    this.ofType = assertType(ofType);
+  } else {
+    return new GraphQLList(ofType);
+  }
+} // Need to cast through any to alter the prototype.
+
+GraphQLList.prototype.toString = function toString() {
+  return '[' + String(this.ofType) + ']';
+};
+
+GraphQLList.prototype.toJSON = function toJSON() {
+  return this.toString();
+};
+
+Object.defineProperty(GraphQLList.prototype, SYMBOL_TO_STRING_TAG, {
+  get: function get() {
+    return 'GraphQLList';
+  }
+}); // Print a simplified form when appearing in `inspect` and `util.inspect`.
+
+defineInspect(GraphQLList);
+/**
+ * Non-Null Type Wrapper
+ *
+ * A non-null is a wrapping type which points to another type.
+ * Non-null types enforce that their values are never null and can ensure
+ * an error is raised if this ever occurs during a request. It is useful for
+ * fields which you can make a strong guarantee on non-nullability, for example
+ * usually the id field of a database row will never be null.
+ *
+ * Example:
+ *
+ *     const RowType = new GraphQLObjectType({
+ *       name: 'Row',
+ *       fields: () => ({
+ *         id: { type: new GraphQLNonNull(GraphQLString) },
+ *       })
+ *     })
+ *
+ * Note: the enforcement of non-nullability occurs within the executor.
+ */
+// FIXME: workaround to fix issue with Babel parser
+
+/* ::
+declare class GraphQLNonNull<+T: GraphQLNullableType> {
+  +ofType: T;
+  static <T>(ofType: T): GraphQLNonNull<T>;
+  // Note: constructors cannot be used for covariant types. Drop the "new".
+  constructor(ofType: GraphQLType): void;
+}
+*/
+
+function GraphQLNonNull(ofType) {
+  // istanbul ignore else (to be removed in v16.0.0)
+  if (this instanceof GraphQLNonNull) {
+    this.ofType = assertNullableType(ofType);
+  } else {
+    return new GraphQLNonNull(ofType);
+  }
+} // Need to cast through any to alter the prototype.
+
+GraphQLNonNull.prototype.toString = function toString() {
+  return String(this.ofType) + '!';
+};
+
+GraphQLNonNull.prototype.toJSON = function toJSON() {
+  return this.toString();
+};
+
+Object.defineProperty(GraphQLNonNull.prototype, SYMBOL_TO_STRING_TAG, {
+  get: function get() {
+    return 'GraphQLNonNull';
+  }
+}); // Print a simplified form when appearing in `inspect` and `util.inspect`.
+
+defineInspect(GraphQLNonNull);
+/**
+ * These types can all accept null as a value.
+ */
+
+function isNullableType(type) {
+  return isType(type) && !isNonNullType(type);
+}
+function assertNullableType(type) {
+  if (!isNullableType(type)) {
+    throw new Error("Expected ".concat(inspect(type), " to be a GraphQL nullable type."));
+  }
+
+  return type;
+}
+/**
+ * Used while defining GraphQL types to allow for circular references in
+ * otherwise immutable type definitions.
+ */
+
+function resolveThunk(thunk) {
+  // $FlowFixMe[incompatible-use]
+  return typeof thunk === 'function' ? thunk() : thunk;
+}
+
+function undefineIfEmpty(arr) {
+  return arr && arr.length > 0 ? arr : undefined;
+}
+/**
+ * Scalar Type Definition
+ *
+ * The leaf values of any request and input values to arguments are
+ * Scalars (or Enums) and are defined with a name and a series of functions
+ * used to parse input from ast or variables and to ensure validity.
+ *
+ * If a type's serialize function does not return a value (i.e. it returns
+ * `undefined`) then an error will be raised and a `null` value will be returned
+ * in the response. If the serialize function returns `null`, then no error will
+ * be included in the response.
+ *
+ * Example:
+ *
+ *     const OddType = new GraphQLScalarType({
+ *       name: 'Odd',
+ *       serialize(value) {
+ *         if (value % 2 === 1) {
+ *           return value;
+ *         }
+ *       }
+ *     });
+ *
+ */
+
+
+var GraphQLScalarType = /*#__PURE__*/function () {
+  function GraphQLScalarType(config) {
+    var _config$parseValue, _config$serialize, _config$parseLiteral;
+
+    var parseValue = (_config$parseValue = config.parseValue) !== null && _config$parseValue !== void 0 ? _config$parseValue : identityFunc;
+    this.name = config.name;
+    this.description = config.description;
+    this.specifiedByUrl = config.specifiedByUrl;
+    this.serialize = (_config$serialize = config.serialize) !== null && _config$serialize !== void 0 ? _config$serialize : identityFunc;
+    this.parseValue = parseValue;
+    this.parseLiteral = (_config$parseLiteral = config.parseLiteral) !== null && _config$parseLiteral !== void 0 ? _config$parseLiteral : function (node, variables) {
+      return parseValue(valueFromASTUntyped(node, variables));
+    };
+    this.extensions = config.extensions && toObjMap(config.extensions);
+    this.astNode = config.astNode;
+    this.extensionASTNodes = undefineIfEmpty(config.extensionASTNodes);
+    typeof config.name === 'string' || devAssert(0, 'Must provide name.');
+    config.specifiedByUrl == null || typeof config.specifiedByUrl === 'string' || devAssert(0, "".concat(this.name, " must provide \"specifiedByUrl\" as a string, ") + "but got: ".concat(inspect(config.specifiedByUrl), "."));
+    config.serialize == null || typeof config.serialize === 'function' || devAssert(0, "".concat(this.name, " must provide \"serialize\" function. If this custom Scalar is also used as an input type, ensure \"parseValue\" and \"parseLiteral\" functions are also provided."));
+
+    if (config.parseLiteral) {
+      typeof config.parseValue === 'function' && typeof config.parseLiteral === 'function' || devAssert(0, "".concat(this.name, " must provide both \"parseValue\" and \"parseLiteral\" functions."));
+    }
+  }
+
+  var _proto = GraphQLScalarType.prototype;
+
+  _proto.toConfig = function toConfig() {
+    var _this$extensionASTNod;
+
+    return {
+      name: this.name,
+      description: this.description,
+      specifiedByUrl: this.specifiedByUrl,
+      serialize: this.serialize,
+      parseValue: this.parseValue,
+      parseLiteral: this.parseLiteral,
+      extensions: this.extensions,
+      astNode: this.astNode,
+      extensionASTNodes: (_this$extensionASTNod = this.extensionASTNodes) !== null && _this$extensionASTNod !== void 0 ? _this$extensionASTNod : []
+    };
+  };
+
+  _proto.toString = function toString() {
+    return this.name;
+  };
+
+  _proto.toJSON = function toJSON() {
+    return this.toString();
+  } // $FlowFixMe[unsupported-syntax] Flow doesn't support computed properties yet
+  ;
+
+  _createClass$2(GraphQLScalarType, [{
+    key: SYMBOL_TO_STRING_TAG,
+    get: function get() {
+      return 'GraphQLScalarType';
+    }
+  }]);
+
+  return GraphQLScalarType;
+}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.
+
+defineInspect(GraphQLScalarType);
+
+/**
+ * Object Type Definition
+ *
+ * Almost all of the GraphQL types you define will be object types. Object types
+ * have a name, but most importantly describe their fields.
+ *
+ * Example:
+ *
+ *     const AddressType = new GraphQLObjectType({
+ *       name: 'Address',
+ *       fields: {
+ *         street: { type: GraphQLString },
+ *         number: { type: GraphQLInt },
+ *         formatted: {
+ *           type: GraphQLString,
+ *           resolve(obj) {
+ *             return obj.number + ' ' + obj.street
+ *           }
+ *         }
+ *       }
+ *     });
+ *
+ * When two types need to refer to each other, or a type needs to refer to
+ * itself in a field, you can use a function expression (aka a closure or a
+ * thunk) to supply the fields lazily.
+ *
+ * Example:
+ *
+ *     const PersonType = new GraphQLObjectType({
+ *       name: 'Person',
+ *       fields: () => ({
+ *         name: { type: GraphQLString },
+ *         bestFriend: { type: PersonType },
+ *       })
+ *     });
+ *
+ */
+var GraphQLObjectType = /*#__PURE__*/function () {
+  function GraphQLObjectType(config) {
+    this.name = config.name;
+    this.description = config.description;
+    this.isTypeOf = config.isTypeOf;
+    this.extensions = config.extensions && toObjMap(config.extensions);
+    this.astNode = config.astNode;
+    this.extensionASTNodes = undefineIfEmpty(config.extensionASTNodes);
+    this._fields = defineFieldMap.bind(undefined, config);
+    this._interfaces = defineInterfaces.bind(undefined, config);
+    typeof config.name === 'string' || devAssert(0, 'Must provide name.');
+    config.isTypeOf == null || typeof config.isTypeOf === 'function' || devAssert(0, "".concat(this.name, " must provide \"isTypeOf\" as a function, ") + "but got: ".concat(inspect(config.isTypeOf), "."));
+  }
+
+  var _proto2 = GraphQLObjectType.prototype;
+
+  _proto2.getFields = function getFields() {
+    if (typeof this._fields === 'function') {
+      this._fields = this._fields();
+    }
+
+    return this._fields;
+  };
+
+  _proto2.getInterfaces = function getInterfaces() {
+    if (typeof this._interfaces === 'function') {
+      this._interfaces = this._interfaces();
+    }
+
+    return this._interfaces;
+  };
+
+  _proto2.toConfig = function toConfig() {
+    return {
+      name: this.name,
+      description: this.description,
+      interfaces: this.getInterfaces(),
+      fields: fieldsToFieldsConfig(this.getFields()),
+      isTypeOf: this.isTypeOf,
+      extensions: this.extensions,
+      astNode: this.astNode,
+      extensionASTNodes: this.extensionASTNodes || []
+    };
+  };
+
+  _proto2.toString = function toString() {
+    return this.name;
+  };
+
+  _proto2.toJSON = function toJSON() {
+    return this.toString();
+  } // $FlowFixMe[unsupported-syntax] Flow doesn't support computed properties yet
+  ;
+
+  _createClass$2(GraphQLObjectType, [{
+    key: SYMBOL_TO_STRING_TAG,
+    get: function get() {
+      return 'GraphQLObjectType';
+    }
+  }]);
+
+  return GraphQLObjectType;
+}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.
+
+defineInspect(GraphQLObjectType);
+
+function defineInterfaces(config) {
+  var _resolveThunk;
+
+  var interfaces = (_resolveThunk = resolveThunk(config.interfaces)) !== null && _resolveThunk !== void 0 ? _resolveThunk : [];
+  Array.isArray(interfaces) || devAssert(0, "".concat(config.name, " interfaces must be an Array or a function which returns an Array."));
+  return interfaces;
+}
+
+function defineFieldMap(config) {
+  var fieldMap = resolveThunk(config.fields);
+  isPlainObj(fieldMap) || devAssert(0, "".concat(config.name, " fields must be an object with field names as keys or a function which returns such an object."));
+  return mapValue(fieldMap, function (fieldConfig, fieldName) {
+    var _fieldConfig$args;
+
+    isPlainObj(fieldConfig) || devAssert(0, "".concat(config.name, ".").concat(fieldName, " field config must be an object."));
+    !('isDeprecated' in fieldConfig) || devAssert(0, "".concat(config.name, ".").concat(fieldName, " should provide \"deprecationReason\" instead of \"isDeprecated\"."));
+    fieldConfig.resolve == null || typeof fieldConfig.resolve === 'function' || devAssert(0, "".concat(config.name, ".").concat(fieldName, " field resolver must be a function if ") + "provided, but got: ".concat(inspect(fieldConfig.resolve), "."));
+    var argsConfig = (_fieldConfig$args = fieldConfig.args) !== null && _fieldConfig$args !== void 0 ? _fieldConfig$args : {};
+    isPlainObj(argsConfig) || devAssert(0, "".concat(config.name, ".").concat(fieldName, " args must be an object with argument names as keys."));
+    var args = objectEntries$1(argsConfig).map(function (_ref) {
+      var argName = _ref[0],
+          argConfig = _ref[1];
+      return {
+        name: argName,
+        description: argConfig.description,
+        type: argConfig.type,
+        defaultValue: argConfig.defaultValue,
+        deprecationReason: argConfig.deprecationReason,
+        extensions: argConfig.extensions && toObjMap(argConfig.extensions),
+        astNode: argConfig.astNode
+      };
+    });
+    return {
+      name: fieldName,
+      description: fieldConfig.description,
+      type: fieldConfig.type,
+      args: args,
+      resolve: fieldConfig.resolve,
+      subscribe: fieldConfig.subscribe,
+      isDeprecated: fieldConfig.deprecationReason != null,
+      deprecationReason: fieldConfig.deprecationReason,
+      extensions: fieldConfig.extensions && toObjMap(fieldConfig.extensions),
+      astNode: fieldConfig.astNode
+    };
+  });
+}
+
+function isPlainObj(obj) {
+  return isObjectLike(obj) && !Array.isArray(obj);
+}
+
+function fieldsToFieldsConfig(fields) {
+  return mapValue(fields, function (field) {
+    return {
+      description: field.description,
+      type: field.type,
+      args: argsToArgsConfig(field.args),
+      resolve: field.resolve,
+      subscribe: field.subscribe,
+      deprecationReason: field.deprecationReason,
+      extensions: field.extensions,
+      astNode: field.astNode
+    };
+  });
+}
+/**
+ * @internal
+ */
+
+
+function argsToArgsConfig(args) {
+  return keyValMap(args, function (arg) {
+    return arg.name;
+  }, function (arg) {
+    return {
+      description: arg.description,
+      type: arg.type,
+      defaultValue: arg.defaultValue,
+      deprecationReason: arg.deprecationReason,
+      extensions: arg.extensions,
+      astNode: arg.astNode
+    };
+  });
+}
+
+/**
+ * Interface Type Definition
+ *
+ * When a field can return one of a heterogeneous set of types, a Interface type
+ * is used to describe what types are possible, what fields are in common across
+ * all types, as well as a function to determine which type is actually used
+ * when the field is resolved.
+ *
+ * Example:
+ *
+ *     const EntityType = new GraphQLInterfaceType({
+ *       name: 'Entity',
+ *       fields: {
+ *         name: { type: GraphQLString }
+ *       }
+ *     });
+ *
+ */
+var GraphQLInterfaceType = /*#__PURE__*/function () {
+  function GraphQLInterfaceType(config) {
+    this.name = config.name;
+    this.description = config.description;
+    this.resolveType = config.resolveType;
+    this.extensions = config.extensions && toObjMap(config.extensions);
+    this.astNode = config.astNode;
+    this.extensionASTNodes = undefineIfEmpty(config.extensionASTNodes);
+    this._fields = defineFieldMap.bind(undefined, config);
+    this._interfaces = defineInterfaces.bind(undefined, config);
+    typeof config.name === 'string' || devAssert(0, 'Must provide name.');
+    config.resolveType == null || typeof config.resolveType === 'function' || devAssert(0, "".concat(this.name, " must provide \"resolveType\" as a function, ") + "but got: ".concat(inspect(config.resolveType), "."));
+  }
+
+  var _proto3 = GraphQLInterfaceType.prototype;
+
+  _proto3.getFields = function getFields() {
+    if (typeof this._fields === 'function') {
+      this._fields = this._fields();
+    }
+
+    return this._fields;
+  };
+
+  _proto3.getInterfaces = function getInterfaces() {
+    if (typeof this._interfaces === 'function') {
+      this._interfaces = this._interfaces();
+    }
+
+    return this._interfaces;
+  };
+
+  _proto3.toConfig = function toConfig() {
+    var _this$extensionASTNod2;
+
+    return {
+      name: this.name,
+      description: this.description,
+      interfaces: this.getInterfaces(),
+      fields: fieldsToFieldsConfig(this.getFields()),
+      resolveType: this.resolveType,
+      extensions: this.extensions,
+      astNode: this.astNode,
+      extensionASTNodes: (_this$extensionASTNod2 = this.extensionASTNodes) !== null && _this$extensionASTNod2 !== void 0 ? _this$extensionASTNod2 : []
+    };
+  };
+
+  _proto3.toString = function toString() {
+    return this.name;
+  };
+
+  _proto3.toJSON = function toJSON() {
+    return this.toString();
+  } // $FlowFixMe[unsupported-syntax] Flow doesn't support computed properties yet
+  ;
+
+  _createClass$2(GraphQLInterfaceType, [{
+    key: SYMBOL_TO_STRING_TAG,
+    get: function get() {
+      return 'GraphQLInterfaceType';
+    }
+  }]);
+
+  return GraphQLInterfaceType;
+}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.
+
+defineInspect(GraphQLInterfaceType);
+
+/**
+ * Union Type Definition
+ *
+ * When a field can return one of a heterogeneous set of types, a Union type
+ * is used to describe what types are possible as well as providing a function
+ * to determine which type is actually used when the field is resolved.
+ *
+ * Example:
+ *
+ *     const PetType = new GraphQLUnionType({
+ *       name: 'Pet',
+ *       types: [ DogType, CatType ],
+ *       resolveType(value) {
+ *         if (value instanceof Dog) {
+ *           return DogType;
+ *         }
+ *         if (value instanceof Cat) {
+ *           return CatType;
+ *         }
+ *       }
+ *     });
+ *
+ */
+var GraphQLUnionType = /*#__PURE__*/function () {
+  function GraphQLUnionType(config) {
+    this.name = config.name;
+    this.description = config.description;
+    this.resolveType = config.resolveType;
+    this.extensions = config.extensions && toObjMap(config.extensions);
+    this.astNode = config.astNode;
+    this.extensionASTNodes = undefineIfEmpty(config.extensionASTNodes);
+    this._types = defineTypes.bind(undefined, config);
+    typeof config.name === 'string' || devAssert(0, 'Must provide name.');
+    config.resolveType == null || typeof config.resolveType === 'function' || devAssert(0, "".concat(this.name, " must provide \"resolveType\" as a function, ") + "but got: ".concat(inspect(config.resolveType), "."));
+  }
+
+  var _proto4 = GraphQLUnionType.prototype;
+
+  _proto4.getTypes = function getTypes() {
+    if (typeof this._types === 'function') {
+      this._types = this._types();
+    }
+
+    return this._types;
+  };
+
+  _proto4.toConfig = function toConfig() {
+    var _this$extensionASTNod3;
+
+    return {
+      name: this.name,
+      description: this.description,
+      types: this.getTypes(),
+      resolveType: this.resolveType,
+      extensions: this.extensions,
+      astNode: this.astNode,
+      extensionASTNodes: (_this$extensionASTNod3 = this.extensionASTNodes) !== null && _this$extensionASTNod3 !== void 0 ? _this$extensionASTNod3 : []
+    };
+  };
+
+  _proto4.toString = function toString() {
+    return this.name;
+  };
+
+  _proto4.toJSON = function toJSON() {
+    return this.toString();
+  } // $FlowFixMe[unsupported-syntax] Flow doesn't support computed properties yet
+  ;
+
+  _createClass$2(GraphQLUnionType, [{
+    key: SYMBOL_TO_STRING_TAG,
+    get: function get() {
+      return 'GraphQLUnionType';
+    }
+  }]);
+
+  return GraphQLUnionType;
+}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.
+
+defineInspect(GraphQLUnionType);
+
+function defineTypes(config) {
+  var types = resolveThunk(config.types);
+  Array.isArray(types) || devAssert(0, "Must provide Array of types or a function which returns such an array for Union ".concat(config.name, "."));
+  return types;
+}
+
+/**
+ * Enum Type Definition
+ *
+ * Some leaf values of requests and input values are Enums. GraphQL serializes
+ * Enum values as strings, however internally Enums can be represented by any
+ * kind of type, often integers.
+ *
+ * Example:
+ *
+ *     const RGBType = new GraphQLEnumType({
+ *       name: 'RGB',
+ *       values: {
+ *         RED: { value: 0 },
+ *         GREEN: { value: 1 },
+ *         BLUE: { value: 2 }
+ *       }
+ *     });
+ *
+ * Note: If a value is not provided in a definition, the name of the enum value
+ * will be used as its internal value.
+ */
+var GraphQLEnumType
+/* <T> */
+= /*#__PURE__*/function () {
+  function GraphQLEnumType(config) {
+    this.name = config.name;
+    this.description = config.description;
+    this.extensions = config.extensions && toObjMap(config.extensions);
+    this.astNode = config.astNode;
+    this.extensionASTNodes = undefineIfEmpty(config.extensionASTNodes);
+    this._values = defineEnumValues(this.name, config.values);
+    this._valueLookup = new Map(this._values.map(function (enumValue) {
+      return [enumValue.value, enumValue];
+    }));
+    this._nameLookup = keyMap(this._values, function (value) {
+      return value.name;
+    });
+    typeof config.name === 'string' || devAssert(0, 'Must provide name.');
+  }
+
+  var _proto5 = GraphQLEnumType.prototype;
+
+  _proto5.getValues = function getValues() {
+    return this._values;
+  };
+
+  _proto5.getValue = function getValue(name) {
+    return this._nameLookup[name];
+  };
+
+  _proto5.serialize = function serialize(outputValue) {
+    var enumValue = this._valueLookup.get(outputValue);
+
+    if (enumValue === undefined) {
+      throw new GraphQLError("Enum \"".concat(this.name, "\" cannot represent value: ").concat(inspect(outputValue)));
+    }
+
+    return enumValue.name;
+  };
+
+  _proto5.parseValue = function parseValue(inputValue)
+  /* T */
+  {
+    if (typeof inputValue !== 'string') {
+      var valueStr = inspect(inputValue);
+      throw new GraphQLError("Enum \"".concat(this.name, "\" cannot represent non-string value: ").concat(valueStr, ".") + didYouMeanEnumValue(this, valueStr));
+    }
+
+    var enumValue = this.getValue(inputValue);
+
+    if (enumValue == null) {
+      throw new GraphQLError("Value \"".concat(inputValue, "\" does not exist in \"").concat(this.name, "\" enum.") + didYouMeanEnumValue(this, inputValue));
+    }
+
+    return enumValue.value;
+  };
+
+  _proto5.parseLiteral = function parseLiteral(valueNode, _variables)
+  /* T */
+  {
+    // Note: variables will be resolved to a value before calling this function.
+    if (valueNode.kind !== Kind.ENUM) {
+      var valueStr = print(valueNode);
+      throw new GraphQLError("Enum \"".concat(this.name, "\" cannot represent non-enum value: ").concat(valueStr, ".") + didYouMeanEnumValue(this, valueStr), valueNode);
+    }
+
+    var enumValue = this.getValue(valueNode.value);
+
+    if (enumValue == null) {
+      var _valueStr = print(valueNode);
+
+      throw new GraphQLError("Value \"".concat(_valueStr, "\" does not exist in \"").concat(this.name, "\" enum.") + didYouMeanEnumValue(this, _valueStr), valueNode);
+    }
+
+    return enumValue.value;
+  };
+
+  _proto5.toConfig = function toConfig() {
+    var _this$extensionASTNod4;
+
+    var values = keyValMap(this.getValues(), function (value) {
+      return value.name;
+    }, function (value) {
+      return {
+        description: value.description,
+        value: value.value,
+        deprecationReason: value.deprecationReason,
+        extensions: value.extensions,
+        astNode: value.astNode
+      };
+    });
+    return {
+      name: this.name,
+      description: this.description,
+      values: values,
+      extensions: this.extensions,
+      astNode: this.astNode,
+      extensionASTNodes: (_this$extensionASTNod4 = this.extensionASTNodes) !== null && _this$extensionASTNod4 !== void 0 ? _this$extensionASTNod4 : []
+    };
+  };
+
+  _proto5.toString = function toString() {
+    return this.name;
+  };
+
+  _proto5.toJSON = function toJSON() {
+    return this.toString();
+  } // $FlowFixMe[unsupported-syntax] Flow doesn't support computed properties yet
+  ;
+
+  _createClass$2(GraphQLEnumType, [{
+    key: SYMBOL_TO_STRING_TAG,
+    get: function get() {
+      return 'GraphQLEnumType';
+    }
+  }]);
+
+  return GraphQLEnumType;
+}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.
+
+defineInspect(GraphQLEnumType);
+
+function didYouMeanEnumValue(enumType, unknownValueStr) {
+  var allNames = enumType.getValues().map(function (value) {
+    return value.name;
+  });
+  var suggestedValues = suggestionList(unknownValueStr, allNames);
+  return didYouMean('the enum value', suggestedValues);
+}
+
+function defineEnumValues(typeName, valueMap) {
+  isPlainObj(valueMap) || devAssert(0, "".concat(typeName, " values must be an object with value names as keys."));
+  return objectEntries$1(valueMap).map(function (_ref2) {
+    var valueName = _ref2[0],
+        valueConfig = _ref2[1];
+    isPlainObj(valueConfig) || devAssert(0, "".concat(typeName, ".").concat(valueName, " must refer to an object with a \"value\" key ") + "representing an internal value but got: ".concat(inspect(valueConfig), "."));
+    !('isDeprecated' in valueConfig) || devAssert(0, "".concat(typeName, ".").concat(valueName, " should provide \"deprecationReason\" instead of \"isDeprecated\"."));
+    return {
+      name: valueName,
+      description: valueConfig.description,
+      value: valueConfig.value !== undefined ? valueConfig.value : valueName,
+      isDeprecated: valueConfig.deprecationReason != null,
+      deprecationReason: valueConfig.deprecationReason,
+      extensions: valueConfig.extensions && toObjMap(valueConfig.extensions),
+      astNode: valueConfig.astNode
+    };
+  });
+}
+
+/**
+ * Input Object Type Definition
+ *
+ * An input object defines a structured collection of fields which may be
+ * supplied to a field argument.
+ *
+ * Using `NonNull` will ensure that a value must be provided by the query
+ *
+ * Example:
+ *
+ *     const GeoPoint = new GraphQLInputObjectType({
+ *       name: 'GeoPoint',
+ *       fields: {
+ *         lat: { type: new GraphQLNonNull(GraphQLFloat) },
+ *         lon: { type: new GraphQLNonNull(GraphQLFloat) },
+ *         alt: { type: GraphQLFloat, defaultValue: 0 },
+ *       }
+ *     });
+ *
+ */
+var GraphQLInputObjectType = /*#__PURE__*/function () {
+  function GraphQLInputObjectType(config) {
+    this.name = config.name;
+    this.description = config.description;
+    this.extensions = config.extensions && toObjMap(config.extensions);
+    this.astNode = config.astNode;
+    this.extensionASTNodes = undefineIfEmpty(config.extensionASTNodes);
+    this._fields = defineInputFieldMap.bind(undefined, config);
+    typeof config.name === 'string' || devAssert(0, 'Must provide name.');
+  }
+
+  var _proto6 = GraphQLInputObjectType.prototype;
+
+  _proto6.getFields = function getFields() {
+    if (typeof this._fields === 'function') {
+      this._fields = this._fields();
+    }
+
+    return this._fields;
+  };
+
+  _proto6.toConfig = function toConfig() {
+    var _this$extensionASTNod5;
+
+    var fields = mapValue(this.getFields(), function (field) {
+      return {
+        description: field.description,
+        type: field.type,
+        defaultValue: field.defaultValue,
+        deprecationReason: field.deprecationReason,
+        extensions: field.extensions,
+        astNode: field.astNode
+      };
+    });
+    return {
+      name: this.name,
+      description: this.description,
+      fields: fields,
+      extensions: this.extensions,
+      astNode: this.astNode,
+      extensionASTNodes: (_this$extensionASTNod5 = this.extensionASTNodes) !== null && _this$extensionASTNod5 !== void 0 ? _this$extensionASTNod5 : []
+    };
+  };
+
+  _proto6.toString = function toString() {
+    return this.name;
+  };
+
+  _proto6.toJSON = function toJSON() {
+    return this.toString();
+  } // $FlowFixMe[unsupported-syntax] Flow doesn't support computed properties yet
+  ;
+
+  _createClass$2(GraphQLInputObjectType, [{
+    key: SYMBOL_TO_STRING_TAG,
+    get: function get() {
+      return 'GraphQLInputObjectType';
+    }
+  }]);
+
+  return GraphQLInputObjectType;
+}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.
+
+defineInspect(GraphQLInputObjectType);
+
+function defineInputFieldMap(config) {
+  var fieldMap = resolveThunk(config.fields);
+  isPlainObj(fieldMap) || devAssert(0, "".concat(config.name, " fields must be an object with field names as keys or a function which returns such an object."));
+  return mapValue(fieldMap, function (fieldConfig, fieldName) {
+    !('resolve' in fieldConfig) || devAssert(0, "".concat(config.name, ".").concat(fieldName, " field has a resolve property, but Input Types cannot define resolvers."));
+    return {
+      name: fieldName,
+      description: fieldConfig.description,
+      type: fieldConfig.type,
+      defaultValue: fieldConfig.defaultValue,
+      deprecationReason: fieldConfig.deprecationReason,
+      extensions: fieldConfig.extensions && toObjMap(fieldConfig.extensions),
+      astNode: fieldConfig.astNode
+    };
+  });
+}
+
+/* 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,
+  parseLiteral: function parseLiteral(valueNode) {
+    if (valueNode.kind !== Kind.INT) {
+      throw new GraphQLError("Int cannot represent non-integer value: ".concat(print(valueNode)), valueNode);
+    }
+
+    var num = parseInt(valueNode.value, 10);
+
+    if (num > MAX_INT || num < MIN_INT) {
+      throw new GraphQLError("Int cannot represent non 32-bit signed integer value: ".concat(valueNode.value), valueNode);
+    }
+
+    return num;
+  }
+});
+
+function serializeFloat(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 (!isFinite$1(num)) {
+    throw new GraphQLError("Float cannot represent non numeric value: ".concat(inspect(coercedValue)));
+  }
+
+  return num;
+}
+
+function coerceFloat(inputValue) {
+  if (!isFinite$1(inputValue)) {
+    throw new GraphQLError("Float cannot represent non numeric value: ".concat(inspect(inputValue)));
+  }
+
+  return inputValue;
+}
+
+var GraphQLFloat = new GraphQLScalarType({
+  name: 'Float',
+  description: 'The `Float` scalar type represents signed double-precision fractional values as specified by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point).',
+  serialize: serializeFloat,
+  parseValue: coerceFloat,
+  parseLiteral: function parseLiteral(valueNode) {
+    if (valueNode.kind !== Kind.FLOAT && valueNode.kind !== Kind.INT) {
+      throw new GraphQLError("Float cannot represent non numeric value: ".concat(print(valueNode)), valueNode);
+    }
+
+    return parseFloat(valueNode.value);
+  }
+}); // Support serializing objects with custom valueOf() or toJSON() functions -
+// a common way to represent a complex value which can be represented as
+// a string (ex: MongoDB id objects).
+
+function serializeObject(outputValue) {
+  if (isObjectLike(outputValue)) {
+    if (typeof outputValue.valueOf === 'function') {
+      var valueOfResult = outputValue.valueOf();
+
+      if (!isObjectLike(valueOfResult)) {
+        return valueOfResult;
+      }
+    }
+
+    if (typeof outputValue.toJSON === 'function') {
+      // $FlowFixMe[incompatible-use]
+      return outputValue.toJSON();
+    }
+  }
+
+  return outputValue;
+}
+
+function serializeString(outputValue) {
+  var coercedValue = serializeObject(outputValue); // Serialize string, boolean and number values to a string, but do not
+  // attempt to coerce object, function, symbol, or other types as strings.
+
+  if (typeof coercedValue === 'string') {
+    return coercedValue;
+  }
+
+  if (typeof coercedValue === 'boolean') {
+    return coercedValue ? 'true' : 'false';
+  }
+
+  if (isFinite$1(coercedValue)) {
+    return coercedValue.toString();
+  }
+
+  throw new GraphQLError("String cannot represent value: ".concat(inspect(outputValue)));
+}
+
+function coerceString(inputValue) {
+  if (typeof inputValue !== 'string') {
+    throw new GraphQLError("String cannot represent a non string value: ".concat(inspect(inputValue)));
+  }
+
+  return inputValue;
+}
+
+var GraphQLString = new GraphQLScalarType({
+  name: 'String',
+  description: 'The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.',
+  serialize: serializeString,
+  parseValue: coerceString,
+  parseLiteral: function parseLiteral(valueNode) {
+    if (valueNode.kind !== Kind.STRING) {
+      throw new GraphQLError("String cannot represent a non string value: ".concat(print(valueNode)), valueNode);
+    }
+
+    return valueNode.value;
+  }
+});
+
+function serializeBoolean(outputValue) {
+  var coercedValue = serializeObject(outputValue);
+
+  if (typeof coercedValue === 'boolean') {
+    return coercedValue;
+  }
+
+  if (isFinite$1(coercedValue)) {
+    return coercedValue !== 0;
+  }
+
+  throw new GraphQLError("Boolean cannot represent a non boolean value: ".concat(inspect(coercedValue)));
+}
+
+function coerceBoolean(inputValue) {
+  if (typeof inputValue !== 'boolean') {
+    throw new GraphQLError("Boolean cannot represent a non boolean value: ".concat(inspect(inputValue)));
+  }
+
+  return inputValue;
+}
+
+var GraphQLBoolean = new GraphQLScalarType({
+  name: 'Boolean',
+  description: 'The `Boolean` scalar type represents `true` or `false`.',
+  serialize: serializeBoolean,
+  parseValue: coerceBoolean,
+  parseLiteral: function parseLiteral(valueNode) {
+    if (valueNode.kind !== Kind.BOOLEAN) {
+      throw new GraphQLError("Boolean cannot represent a non boolean value: ".concat(print(valueNode)), valueNode);
+    }
+
+    return valueNode.value;
+  }
+});
+
+function serializeID(outputValue) {
+  var coercedValue = serializeObject(outputValue);
+
+  if (typeof coercedValue === 'string') {
+    return coercedValue;
+  }
+
+  if (isInteger$1(coercedValue)) {
+    return String(coercedValue);
+  }
+
+  throw new GraphQLError("ID cannot represent value: ".concat(inspect(outputValue)));
+}
+
+function coerceID(inputValue) {
+  if (typeof inputValue === 'string') {
+    return inputValue;
+  }
+
+  if (isInteger$1(inputValue)) {
+    return inputValue.toString();
+  }
+
+  throw new GraphQLError("ID cannot represent value: ".concat(inspect(inputValue)));
+}
+
+var GraphQLID = new GraphQLScalarType({
+  name: 'ID',
+  description: 'The `ID` scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `"4"`) or integer (such as `4`) input value will be accepted as an ID.',
+  serialize: serializeID,
+  parseValue: coerceID,
+  parseLiteral: function parseLiteral(valueNode) {
+    if (valueNode.kind !== Kind.STRING && valueNode.kind !== Kind.INT) {
+      throw new GraphQLError('ID cannot represent a non-string and non-integer value: ' + print(valueNode), valueNode);
+    }
+
+    return valueNode.value;
+  }
+});
+var specifiedScalarTypes = Object.freeze([GraphQLString, GraphQLInt, GraphQLFloat, GraphQLBoolean, GraphQLID]);
+
+/**
+ * Produces a GraphQL Value AST given a JavaScript object.
+ * Function will match JavaScript/JSON values to GraphQL AST schema format
+ * by using suggested GraphQLInputType. For example:
+ *
+ *     astFromValue("value", GraphQLString)
+ *
+ * A GraphQL type must be provided, which will be used to interpret different
+ * JavaScript values.
+ *
+ * | JSON Value    | GraphQL Value        |
+ * | ------------- | -------------------- |
+ * | Object        | Input Object         |
+ * | Array         | List                 |
+ * | Boolean       | Boolean              |
+ * | String        | String / Enum Value  |
+ * | Number        | Int / Float          |
+ * | Mixed         | Enum Value           |
+ * | null          | NullValue            |
+ *
+ */
+
+function astFromValue(value, type) {
+  if (isNonNullType(type)) {
+    var astValue = astFromValue(value, type.ofType);
+
+    if ((astValue === null || astValue === void 0 ? void 0 : astValue.kind) === Kind.NULL) {
+      return null;
+    }
+
+    return astValue;
+  } // only explicit null, not undefined, NaN
+
+
+  if (value === null) {
+    return {
+      kind: Kind.NULL
+    };
+  } // undefined
+
+
+  if (value === undefined) {
+    return null;
+  } // Convert JavaScript array to GraphQL list. If the GraphQLType is a list, but
+  // the value is not an array, convert the value using the list's item type.
+
+
+  if (isListType(type)) {
+    var itemType = type.ofType;
+    var items = safeArrayFrom(value);
+
+    if (items != null) {
+      var valuesNodes = [];
+
+      for (var _i2 = 0; _i2 < items.length; _i2++) {
+        var item = items[_i2];
+        var itemNode = astFromValue(item, itemType);
+
+        if (itemNode != null) {
+          valuesNodes.push(itemNode);
+        }
+      }
+
+      return {
+        kind: Kind.LIST,
+        values: valuesNodes
+      };
+    }
+
+    return astFromValue(value, itemType);
+  } // Populate the fields of the input object by creating ASTs from each value
+  // in the JavaScript object according to the fields in the input type.
+
+
+  if (isInputObjectType(type)) {
+    if (!isObjectLike(value)) {
+      return null;
+    }
+
+    var fieldNodes = [];
+
+    for (var _i4 = 0, _objectValues2 = objectValues$1(type.getFields()); _i4 < _objectValues2.length; _i4++) {
+      var field = _objectValues2[_i4];
+      var fieldValue = astFromValue(value[field.name], field.type);
+
+      if (fieldValue) {
+        fieldNodes.push({
+          kind: Kind.OBJECT_FIELD,
+          name: {
+            kind: Kind.NAME,
+            value: field.name
+          },
+          value: fieldValue
+        });
+      }
+    }
+
+    return {
+      kind: Kind.OBJECT,
+      fields: fieldNodes
+    };
+  } // istanbul ignore else (See: 'https://github.com/graphql/graphql-js/issues/2618')
+
+
+  if (isLeafType(type)) {
+    // Since value is an internally represented value, it must be serialized
+    // to an externally represented value before converting into an AST.
+    var serialized = type.serialize(value);
+
+    if (serialized == null) {
+      return null;
+    } // Others serialize based on their corresponding JavaScript scalar types.
+
+
+    if (typeof serialized === 'boolean') {
+      return {
+        kind: Kind.BOOLEAN,
+        value: serialized
+      };
+    } // JavaScript numbers can be Int or Float values.
+
+
+    if (typeof serialized === 'number' && isFinite$1(serialized)) {
+      var stringNum = String(serialized);
+      return integerStringRegExp.test(stringNum) ? {
+        kind: Kind.INT,
+        value: stringNum
+      } : {
+        kind: Kind.FLOAT,
+        value: stringNum
+      };
+    }
+
+    if (typeof serialized === 'string') {
+      // Enum types use Enum literals.
+      if (isEnumType(type)) {
+        return {
+          kind: Kind.ENUM,
+          value: serialized
+        };
+      } // ID types can use Int literals.
+
+
+      if (type === GraphQLID && integerStringRegExp.test(serialized)) {
+        return {
+          kind: Kind.INT,
+          value: serialized
+        };
+      }
+
+      return {
+        kind: Kind.STRING,
+        value: serialized
+      };
+    }
+
+    throw new TypeError("Cannot convert value to AST: ".concat(inspect(serialized), "."));
+  } // istanbul ignore next (Not reachable. All possible input types have been considered)
+
+
+  invariant(0, 'Unexpected input type: ' + inspect(type));
+}
+/**
+ * IntValue:
+ *   - NegativeSign? 0
+ *   - NegativeSign? NonZeroDigit ( Digit+ )?
+ */
+
+var integerStringRegExp = /^-?(?:0|[1-9][0-9]*)$/;
+
+var __Schema = new GraphQLObjectType({
+  name: '__Schema',
+  description: 'A GraphQL Schema defines the capabilities of a GraphQL server. It exposes all available types and directives on the server, as well as the entry points for query, mutation, and subscription operations.',
+  fields: function fields() {
+    return {
+      description: {
+        type: GraphQLString,
+        resolve: function resolve(schema) {
+          return schema.description;
+        }
+      },
+      types: {
+        description: 'A list of all types supported by this server.',
+        type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(__Type))),
+        resolve: function resolve(schema) {
+          return objectValues$1(schema.getTypeMap());
+        }
+      },
+      queryType: {
+        description: 'The type that query operations will be rooted at.',
+        type: new GraphQLNonNull(__Type),
+        resolve: function resolve(schema) {
+          return schema.getQueryType();
+        }
+      },
+      mutationType: {
+        description: 'If this server supports mutation, the type that mutation operations will be rooted at.',
+        type: __Type,
+        resolve: function resolve(schema) {
+          return schema.getMutationType();
+        }
+      },
+      subscriptionType: {
+        description: 'If this server support subscription, the type that subscription operations will be rooted at.',
+        type: __Type,
+        resolve: function resolve(schema) {
+          return schema.getSubscriptionType();
+        }
+      },
+      directives: {
+        description: 'A list of all directives supported by this server.',
+        type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(__Directive))),
+        resolve: function resolve(schema) {
+          return schema.getDirectives();
+        }
+      }
+    };
+  }
+});
+var __Directive = new GraphQLObjectType({
+  name: '__Directive',
+  description: "A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document.\n\nIn some cases, you need to provide options to alter GraphQL's execution behavior in ways field arguments will not suffice, such as conditionally including or skipping a field. Directives provide this by describing additional information to the executor.",
+  fields: function fields() {
+    return {
+      name: {
+        type: new GraphQLNonNull(GraphQLString),
+        resolve: function resolve(directive) {
+          return directive.name;
+        }
+      },
+      description: {
+        type: GraphQLString,
+        resolve: function resolve(directive) {
+          return directive.description;
+        }
+      },
+      isRepeatable: {
+        type: new GraphQLNonNull(GraphQLBoolean),
+        resolve: function resolve(directive) {
+          return directive.isRepeatable;
+        }
+      },
+      locations: {
+        type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(__DirectiveLocation))),
+        resolve: function resolve(directive) {
+          return directive.locations;
+        }
+      },
+      args: {
+        type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(__InputValue))),
+        args: {
+          includeDeprecated: {
+            type: GraphQLBoolean,
+            defaultValue: false
+          }
+        },
+        resolve: function resolve(field, _ref) {
+          var includeDeprecated = _ref.includeDeprecated;
+          return includeDeprecated ? field.args : field.args.filter(function (arg) {
+            return arg.deprecationReason == null;
+          });
+        }
+      }
+    };
+  }
+});
+var __DirectiveLocation = new GraphQLEnumType({
+  name: '__DirectiveLocation',
+  description: 'A Directive can be adjacent to many parts of the GraphQL language, a __DirectiveLocation describes one such possible adjacencies.',
+  values: {
+    QUERY: {
+      value: DirectiveLocation.QUERY,
+      description: 'Location adjacent to a query operation.'
+    },
+    MUTATION: {
+      value: DirectiveLocation.MUTATION,
+      description: 'Location adjacent to a mutation operation.'
+    },
+    SUBSCRIPTION: {
+      value: DirectiveLocation.SUBSCRIPTION,
+      description: 'Location adjacent to a subscription operation.'
+    },
+    FIELD: {
+      value: DirectiveLocation.FIELD,
+      description: 'Location adjacent to a field.'
+    },
+    FRAGMENT_DEFINITION: {
+      value: DirectiveLocation.FRAGMENT_DEFINITION,
+      description: 'Location adjacent to a fragment definition.'
+    },
+    FRAGMENT_SPREAD: {
+      value: DirectiveLocation.FRAGMENT_SPREAD,
+      description: 'Location adjacent to a fragment spread.'
+    },
+    INLINE_FRAGMENT: {
+      value: DirectiveLocation.INLINE_FRAGMENT,
+      description: 'Location adjacent to an inline fragment.'
+    },
+    VARIABLE_DEFINITION: {
+      value: DirectiveLocation.VARIABLE_DEFINITION,
+      description: 'Location adjacent to a variable definition.'
+    },
+    SCHEMA: {
+      value: DirectiveLocation.SCHEMA,
+      description: 'Location adjacent to a schema definition.'
+    },
+    SCALAR: {
+      value: DirectiveLocation.SCALAR,
+      description: 'Location adjacent to a scalar definition.'
+    },
+    OBJECT: {
+      value: DirectiveLocation.OBJECT,
+      description: 'Location adjacent to an object type definition.'
+    },
+    FIELD_DEFINITION: {
+      value: DirectiveLocation.FIELD_DEFINITION,
+      description: 'Location adjacent to a field definition.'
+    },
+    ARGUMENT_DEFINITION: {
+      value: DirectiveLocation.ARGUMENT_DEFINITION,
+      description: 'Location adjacent to an argument definition.'
+    },
+    INTERFACE: {
+      value: DirectiveLocation.INTERFACE,
+      description: 'Location adjacent to an interface definition.'
+    },
+    UNION: {
+      value: DirectiveLocation.UNION,
+      description: 'Location adjacent to a union definition.'
+    },
+    ENUM: {
+      value: DirectiveLocation.ENUM,
+      description: 'Location adjacent to an enum definition.'
+    },
+    ENUM_VALUE: {
+      value: DirectiveLocation.ENUM_VALUE,
+      description: 'Location adjacent to an enum value definition.'
+    },
+    INPUT_OBJECT: {
+      value: DirectiveLocation.INPUT_OBJECT,
+      description: 'Location adjacent to an input object type definition.'
+    },
+    INPUT_FIELD_DEFINITION: {
+      value: DirectiveLocation.INPUT_FIELD_DEFINITION,
+      description: 'Location adjacent to an input object field definition.'
+    }
+  }
+});
+var __Type = new GraphQLObjectType({
+  name: '__Type',
+  description: 'The fundamental unit of any GraphQL Schema is the type. There are many kinds of types in GraphQL as represented by the `__TypeKind` enum.\n\nDepending on the kind of a type, certain fields describe information about that type. Scalar types provide no information beyond a name, description and optional `specifiedByUrl`, while Enum types provide their values. Object and Interface types provide the fields they describe. Abstract types, Union and Interface, provide the Object types possible at runtime. List and NonNull types compose other types.',
+  fields: function fields() {
+    return {
+      kind: {
+        type: new GraphQLNonNull(__TypeKind),
+        resolve: function resolve(type) {
+          if (isScalarType(type)) {
+            return TypeKind.SCALAR;
+          }
+
+          if (isObjectType(type)) {
+            return TypeKind.OBJECT;
+          }
+
+          if (isInterfaceType(type)) {
+            return TypeKind.INTERFACE;
+          }
+
+          if (isUnionType(type)) {
+            return TypeKind.UNION;
+          }
+
+          if (isEnumType(type)) {
+            return TypeKind.ENUM;
+          }
+
+          if (isInputObjectType(type)) {
+            return TypeKind.INPUT_OBJECT;
+          }
+
+          if (isListType(type)) {
+            return TypeKind.LIST;
+          } // istanbul ignore else (See: 'https://github.com/graphql/graphql-js/issues/2618')
+
+
+          if (isNonNullType(type)) {
+            return TypeKind.NON_NULL;
+          } // istanbul ignore next (Not reachable. All possible types have been considered)
+
+
+          invariant(0, "Unexpected type: \"".concat(inspect(type), "\"."));
+        }
+      },
+      name: {
+        type: GraphQLString,
+        resolve: function resolve(type) {
+          return type.name !== undefined ? type.name : undefined;
+        }
+      },
+      description: {
+        type: GraphQLString,
+        resolve: function resolve(type) {
+          return type.description !== undefined ? type.description : undefined;
+        }
+      },
+      specifiedByUrl: {
+        type: GraphQLString,
+        resolve: function resolve(obj) {
+          return obj.specifiedByUrl !== undefined ? obj.specifiedByUrl : undefined;
+        }
+      },
+      fields: {
+        type: new GraphQLList(new GraphQLNonNull(__Field)),
+        args: {
+          includeDeprecated: {
+            type: GraphQLBoolean,
+            defaultValue: false
+          }
+        },
+        resolve: function resolve(type, _ref2) {
+          var includeDeprecated = _ref2.includeDeprecated;
+
+          if (isObjectType(type) || isInterfaceType(type)) {
+            var fields = objectValues$1(type.getFields());
+            return includeDeprecated ? fields : fields.filter(function (field) {
+              return field.deprecationReason == null;
+            });
+          }
+        }
+      },
+      interfaces: {
+        type: new GraphQLList(new GraphQLNonNull(__Type)),
+        resolve: function resolve(type) {
+          if (isObjectType(type) || isInterfaceType(type)) {
+            return type.getInterfaces();
+          }
+        }
+      },
+      possibleTypes: {
+        type: new GraphQLList(new GraphQLNonNull(__Type)),
+        resolve: function resolve(type, _args, _context, _ref3) {
+          var schema = _ref3.schema;
+
+          if (isAbstractType(type)) {
+            return schema.getPossibleTypes(type);
+          }
+        }
+      },
+      enumValues: {
+        type: new GraphQLList(new GraphQLNonNull(__EnumValue)),
+        args: {
+          includeDeprecated: {
+            type: GraphQLBoolean,
+            defaultValue: false
+          }
+        },
+        resolve: function resolve(type, _ref4) {
+          var includeDeprecated = _ref4.includeDeprecated;
+
+          if (isEnumType(type)) {
+            var values = type.getValues();
+            return includeDeprecated ? values : values.filter(function (field) {
+              return field.deprecationReason == null;
+            });
+          }
+        }
+      },
+      inputFields: {
+        type: new GraphQLList(new GraphQLNonNull(__InputValue)),
+        args: {
+          includeDeprecated: {
+            type: GraphQLBoolean,
+            defaultValue: false
+          }
+        },
+        resolve: function resolve(type, _ref5) {
+          var includeDeprecated = _ref5.includeDeprecated;
+
+          if (isInputObjectType(type)) {
+            var values = objectValues$1(type.getFields());
+            return includeDeprecated ? values : values.filter(function (field) {
+              return field.deprecationReason == null;
+            });
+          }
+        }
+      },
+      ofType: {
+        type: __Type,
+        resolve: function resolve(type) {
+          return type.ofType !== undefined ? type.ofType : undefined;
+        }
+      }
+    };
+  }
+});
+var __Field = new GraphQLObjectType({
+  name: '__Field',
+  description: 'Object and Interface types are described by a list of Fields, each of which has a name, potentially a list of arguments, and a return type.',
+  fields: function fields() {
+    return {
+      name: {
+        type: new GraphQLNonNull(GraphQLString),
+        resolve: function resolve(field) {
+          return field.name;
+        }
+      },
+      description: {
+        type: GraphQLString,
+        resolve: function resolve(field) {
+          return field.description;
+        }
+      },
+      args: {
+        type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(__InputValue))),
+        args: {
+          includeDeprecated: {
+            type: GraphQLBoolean,
+            defaultValue: false
+          }
+        },
+        resolve: function resolve(field, _ref6) {
+          var includeDeprecated = _ref6.includeDeprecated;
+          return includeDeprecated ? field.args : field.args.filter(function (arg) {
+            return arg.deprecationReason == null;
+          });
+        }
+      },
+      type: {
+        type: new GraphQLNonNull(__Type),
+        resolve: function resolve(field) {
+          return field.type;
+        }
+      },
+      isDeprecated: {
+        type: new GraphQLNonNull(GraphQLBoolean),
+        resolve: function resolve(field) {
+          return field.deprecationReason != null;
+        }
+      },
+      deprecationReason: {
+        type: GraphQLString,
+        resolve: function resolve(field) {
+          return field.deprecationReason;
+        }
+      }
+    };
+  }
+});
+var __InputValue = new GraphQLObjectType({
+  name: '__InputValue',
+  description: 'Arguments provided to Fields or Directives and the input fields of an InputObject are represented as Input Values which describe their type and optionally a default value.',
+  fields: function fields() {
+    return {
+      name: {
+        type: new GraphQLNonNull(GraphQLString),
+        resolve: function resolve(inputValue) {
+          return inputValue.name;
+        }
+      },
+      description: {
+        type: GraphQLString,
+        resolve: function resolve(inputValue) {
+          return inputValue.description;
+        }
+      },
+      type: {
+        type: new GraphQLNonNull(__Type),
+        resolve: function resolve(inputValue) {
+          return inputValue.type;
+        }
+      },
+      defaultValue: {
+        type: GraphQLString,
+        description: 'A GraphQL-formatted string representing the default value for this input value.',
+        resolve: function resolve(inputValue) {
+          var type = inputValue.type,
+              defaultValue = inputValue.defaultValue;
+          var valueAST = astFromValue(defaultValue, type);
+          return valueAST ? print(valueAST) : null;
+        }
+      },
+      isDeprecated: {
+        type: new GraphQLNonNull(GraphQLBoolean),
+        resolve: function resolve(field) {
+          return field.deprecationReason != null;
+        }
+      },
+      deprecationReason: {
+        type: GraphQLString,
+        resolve: function resolve(obj) {
+          return obj.deprecationReason;
+        }
+      }
+    };
+  }
+});
+var __EnumValue = new GraphQLObjectType({
+  name: '__EnumValue',
+  description: 'One possible value for a given Enum. Enum values are unique values, not a placeholder for a string or numeric value. However an Enum value is returned in a JSON response as a string.',
+  fields: function fields() {
+    return {
+      name: {
+        type: new GraphQLNonNull(GraphQLString),
+        resolve: function resolve(enumValue) {
+          return enumValue.name;
+        }
+      },
+      description: {
+        type: GraphQLString,
+        resolve: function resolve(enumValue) {
+          return enumValue.description;
+        }
+      },
+      isDeprecated: {
+        type: new GraphQLNonNull(GraphQLBoolean),
+        resolve: function resolve(enumValue) {
+          return enumValue.deprecationReason != null;
+        }
+      },
+      deprecationReason: {
+        type: GraphQLString,
+        resolve: function resolve(enumValue) {
+          return enumValue.deprecationReason;
+        }
+      }
+    };
+  }
+});
+var TypeKind = Object.freeze({
+  SCALAR: 'SCALAR',
+  OBJECT: 'OBJECT',
+  INTERFACE: 'INTERFACE',
+  UNION: 'UNION',
+  ENUM: 'ENUM',
+  INPUT_OBJECT: 'INPUT_OBJECT',
+  LIST: 'LIST',
+  NON_NULL: 'NON_NULL'
+});
+var __TypeKind = new GraphQLEnumType({
+  name: '__TypeKind',
+  description: 'An enum describing what kind of type a given `__Type` is.',
+  values: {
+    SCALAR: {
+      value: TypeKind.SCALAR,
+      description: 'Indicates this type is a scalar.'
+    },
+    OBJECT: {
+      value: TypeKind.OBJECT,
+      description: 'Indicates this type is an object. `fields` and `interfaces` are valid fields.'
+    },
+    INTERFACE: {
+      value: TypeKind.INTERFACE,
+      description: 'Indicates this type is an interface. `fields`, `interfaces`, and `possibleTypes` are valid fields.'
+    },
+    UNION: {
+      value: TypeKind.UNION,
+      description: 'Indicates this type is a union. `possibleTypes` is a valid field.'
+    },
+    ENUM: {
+      value: TypeKind.ENUM,
+      description: 'Indicates this type is an enum. `enumValues` is a valid field.'
+    },
+    INPUT_OBJECT: {
+      value: TypeKind.INPUT_OBJECT,
+      description: 'Indicates this type is an input object. `inputFields` is a valid field.'
+    },
+    LIST: {
+      value: TypeKind.LIST,
+      description: 'Indicates this type is a list. `ofType` is a valid field.'
+    },
+    NON_NULL: {
+      value: TypeKind.NON_NULL,
+      description: 'Indicates this type is a non-null. `ofType` is a valid field.'
+    }
+  }
+});
+/**
+ * Note that these are GraphQLField and not GraphQLFieldConfig,
+ * so the format for args is different.
+ */
+
+({
+  name: '__schema',
+  type: new GraphQLNonNull(__Schema),
+  description: 'Access the current type schema of this server.',
+  args: [],
+  resolve: function resolve(_source, _args, _context, _ref7) {
+    var schema = _ref7.schema;
+    return schema;
+  },
+  isDeprecated: false,
+  deprecationReason: undefined,
+  extensions: undefined,
+  astNode: undefined
+});
+({
+  name: '__type',
+  type: __Type,
+  description: 'Request the type information of a single type.',
+  args: [{
+    name: 'name',
+    description: undefined,
+    type: new GraphQLNonNull(GraphQLString),
+    defaultValue: undefined,
+    deprecationReason: undefined,
+    extensions: undefined,
+    astNode: undefined
+  }],
+  resolve: function resolve(_source, _ref8, _context, _ref9) {
+    var name = _ref8.name;
+    var schema = _ref9.schema;
+    return schema.getType(name);
+  },
+  isDeprecated: false,
+  deprecationReason: undefined,
+  extensions: undefined,
+  astNode: undefined
+});
+({
+  name: '__typename',
+  type: new GraphQLNonNull(GraphQLString),
+  description: 'The name of the current Object type at runtime.',
+  args: [],
+  resolve: function resolve(_source, _args, _context, _ref10) {
+    var parentType = _ref10.parentType;
+    return parentType.name;
+  },
+  isDeprecated: false,
+  deprecationReason: undefined,
+  extensions: undefined,
+  astNode: undefined
+});
+var introspectionTypes = Object.freeze([__Schema, __Directive, __DirectiveLocation, __Type, __Field, __InputValue, __EnumValue, __TypeKind]);
+
+function _defineProperties$1(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass$1(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1(Constructor, staticProps); return Constructor; }
+/**
+ * Directives are used by the GraphQL runtime as a way of modifying execution
+ * behavior. Type system creators will usually not create these directly.
+ */
+
+var GraphQLDirective = /*#__PURE__*/function () {
+  function GraphQLDirective(config) {
+    var _config$isRepeatable, _config$args;
+
+    this.name = config.name;
+    this.description = config.description;
+    this.locations = config.locations;
+    this.isRepeatable = (_config$isRepeatable = config.isRepeatable) !== null && _config$isRepeatable !== void 0 ? _config$isRepeatable : false;
+    this.extensions = config.extensions && toObjMap(config.extensions);
+    this.astNode = config.astNode;
+    config.name || devAssert(0, 'Directive must be named.');
+    Array.isArray(config.locations) || devAssert(0, "@".concat(config.name, " locations must be an Array."));
+    var args = (_config$args = config.args) !== null && _config$args !== void 0 ? _config$args : {};
+    isObjectLike(args) && !Array.isArray(args) || devAssert(0, "@".concat(config.name, " args must be an object with argument names as keys."));
+    this.args = objectEntries$1(args).map(function (_ref) {
+      var argName = _ref[0],
+          argConfig = _ref[1];
+      return {
+        name: argName,
+        description: argConfig.description,
+        type: argConfig.type,
+        defaultValue: argConfig.defaultValue,
+        deprecationReason: argConfig.deprecationReason,
+        extensions: argConfig.extensions && toObjMap(argConfig.extensions),
+        astNode: argConfig.astNode
+      };
+    });
+  }
+
+  var _proto = GraphQLDirective.prototype;
+
+  _proto.toConfig = function toConfig() {
+    return {
+      name: this.name,
+      description: this.description,
+      locations: this.locations,
+      args: argsToArgsConfig(this.args),
+      isRepeatable: this.isRepeatable,
+      extensions: this.extensions,
+      astNode: this.astNode
+    };
+  };
+
+  _proto.toString = function toString() {
+    return '@' + this.name;
+  };
+
+  _proto.toJSON = function toJSON() {
+    return this.toString();
+  } // $FlowFixMe[unsupported-syntax] Flow doesn't support computed properties yet
+  ;
+
+  _createClass$1(GraphQLDirective, [{
+    key: SYMBOL_TO_STRING_TAG,
+    get: function get() {
+      return 'GraphQLDirective';
+    }
+  }]);
+
+  return GraphQLDirective;
+}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.
+
+defineInspect(GraphQLDirective);
+
+/**
+ * Used to conditionally include fields or fragments.
+ */
+new GraphQLDirective({
+  name: 'include',
+  description: 'Directs the executor to include this field or fragment only when the `if` argument is true.',
+  locations: [DirectiveLocation.FIELD, DirectiveLocation.FRAGMENT_SPREAD, DirectiveLocation.INLINE_FRAGMENT],
+  args: {
+    if: {
+      type: new GraphQLNonNull(GraphQLBoolean),
+      description: 'Included when true.'
+    }
+  }
+});
+/**
+ * Used to conditionally skip (exclude) fields or fragments.
+ */
+
+new GraphQLDirective({
+  name: 'skip',
+  description: 'Directs the executor to skip this field or fragment when the `if` argument is true.',
+  locations: [DirectiveLocation.FIELD, DirectiveLocation.FRAGMENT_SPREAD, DirectiveLocation.INLINE_FRAGMENT],
+  args: {
+    if: {
+      type: new GraphQLNonNull(GraphQLBoolean),
+      description: 'Skipped when true.'
+    }
+  }
+});
+/**
+ * Constant string used for default reason for a deprecation.
+ */
+
+var DEFAULT_DEPRECATION_REASON = 'No longer supported';
+/**
+ * Used to declare element of a GraphQL schema as deprecated.
+ */
+
+new GraphQLDirective({
+  name: 'deprecated',
+  description: 'Marks an element of a GraphQL schema as no longer supported.',
+  locations: [DirectiveLocation.FIELD_DEFINITION, DirectiveLocation.ARGUMENT_DEFINITION, DirectiveLocation.INPUT_FIELD_DEFINITION, DirectiveLocation.ENUM_VALUE],
+  args: {
+    reason: {
+      type: GraphQLString,
+      description: 'Explains why this element was deprecated, usually also including a suggestion for how to access supported similar data. Formatted using the Markdown syntax, as specified by [CommonMark](https://commonmark.org/).',
+      defaultValue: DEFAULT_DEPRECATION_REASON
+    }
+  }
+});
+/**
+ * Used to provide a URL for specifying the behaviour of custom scalar definitions.
+ */
+
+new GraphQLDirective({
+  name: 'specifiedBy',
+  description: 'Exposes a URL that specifies the behaviour of this scalar.',
+  locations: [DirectiveLocation.SCALAR],
+  args: {
+    url: {
+      type: new GraphQLNonNull(GraphQLString),
+      description: 'The URL that specifies the behaviour of this scalar.'
+    }
+  }
+});
+[].concat(specifiedScalarTypes, introspectionTypes).map(function (type) {
+  return type.name;
+});
+
+var _defKindToExtKind;
+
+function _defineProperty$1(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+(_defKindToExtKind = {}, _defineProperty$1(_defKindToExtKind, Kind.SCALAR_TYPE_DEFINITION, Kind.SCALAR_TYPE_EXTENSION), _defineProperty$1(_defKindToExtKind, Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION), _defineProperty$1(_defKindToExtKind, Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION), _defineProperty$1(_defKindToExtKind, Kind.UNION_TYPE_DEFINITION, Kind.UNION_TYPE_EXTENSION), _defineProperty$1(_defKindToExtKind, Kind.ENUM_TYPE_DEFINITION, Kind.ENUM_TYPE_EXTENSION), _defineProperty$1(_defKindToExtKind, Kind.INPUT_OBJECT_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_EXTENSION), _defKindToExtKind);
+keyMap(specifiedScalarTypes.concat(introspectionTypes), function (type) {
+  return type.name;
+});
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * Defines configuration for the module with a default value which can be overridden by the runtime environment.
+ */
+/**
+ * Environment Aware GraphQLBatch adapter
+ */
+let environmentAwareGraphQLBatchAdapter = undefined;
+/**
+ * Draft-aware GraphQL adapter
+ */
+let draftAwareGraphQLAdapter = undefined;
+/**
+ * Draft-aware createRecord adapter
+ */
+let draftAwareCreateRecordAdapter = undefined;
+/**
+ * Draft-aware updateRecord adapter
+ */
+let draftAwareUpdateRecordAdapter = undefined;
+/**
+ * Draft-aware deleteRecord adapter
+ */
+let draftAwareDeleteRecordAdapter = undefined;
+/**
+ * Draft-aware createContentDocumentAndVersion adapter
+ */
+let draftAwareCreateContentDocumentAndVersionAdapter = undefined;
+/**
+ * Draft-aware createContentVersion adapter
+ */
+let draftAwareCreateContentVersionAdapter = undefined;
+/**
+ * Depth to which tracked fields will be added to a request that results from a cache miss.
+ * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
+ * be reached by following 1 relationship from the root record, etc.
+ * @defaultValue '5', replicates the current behavior
+ */
+let trackedFieldDepthOnCacheMiss = 5;
+/**
+ * Depth to which tracked fields will be added to a request that results from a merge conflict
+ * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
+ * be reached by following 1 relationship from the root record, etc.
+ * @defaultValue '5', replicates the current behavior
+ */
+let trackedFieldDepthOnCacheMergeConflict = 5;
+/**
+ * Depth to which tracked fields will be added to a request that results from a notify change invocation by the consumer
+ * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
+ * be reached by following 1 relationship from the root record, etc.
+ * @defaultValue '5', replicates the current behavior
+ */
+let trackedFieldDepthOnNotifyChange = 5;
+/**
+ * Determines if we will only fetch the 'Id' field for the leaf relationship record
+ * @defaultValue 'false', replicates the current behavior and fetches all fields in the store for the leaf relationship record
+ */
+let trackedFieldLeafNodeIdAndNameOnly = false;
+/**
+ * One store enabled Get Object Info adapter
+ */
+let oneStoreGetObjectInfoAdapter = undefined;
+/**
+ * One store enabled Get Object Infos adapter
+ */
+let oneStoreGetObjectInfosAdapter = undefined;
+/**
+ * Determines when to include PDL strategies for Related Lists
+ */
+let relatedListsPredictionsEnabled = false;
+/**
+ * Defines the configuration API and is exposed internally as well as externally.
+ * Configuration for one store enabled REST adapters only.
+ */
+const configurationForOneStoreEnabledAdapters = {
+    setGetObjectInfoAdapter: function (adapter) {
+        oneStoreGetObjectInfoAdapter = adapter;
+    },
+    getGetObjectInfoAdapter: function () {
+        return oneStoreGetObjectInfoAdapter;
+    },
+    setGetObjectInfosAdapter: function (adapter) {
+        oneStoreGetObjectInfosAdapter = adapter;
+    },
+    getGetObjectInfosAdapter: function () {
+        return oneStoreGetObjectInfosAdapter;
+    },
+};
+/**
+ * Defines the configuration API and is exposed internally as well as externally.
+ * Configuration for REST adapters only.
+ */
+const configurationForRestAdapters = {
+    setTrackedFieldDepthOnCacheMiss: function (trackedFieldDepthOnCacheMissParam) {
+        trackedFieldDepthOnCacheMiss = trackedFieldDepthOnCacheMissParam;
+    },
+    getTrackedFieldDepthOnCacheMiss: function () {
+        return trackedFieldDepthOnCacheMiss;
+    },
+    setTrackedFieldDepthOnCacheMergeConflict: function (trackedFieldDepthOnCacheMergeConflictParam) {
+        trackedFieldDepthOnCacheMergeConflict = trackedFieldDepthOnCacheMergeConflictParam;
+    },
+    getTrackedFieldDepthOnCacheMergeConflict: function () {
+        return trackedFieldDepthOnCacheMergeConflict;
+    },
+    setTrackedFieldDepthOnNotifyChange: function (trackedFieldDepthOnNotifyChangeParam) {
+        trackedFieldDepthOnNotifyChange = trackedFieldDepthOnNotifyChangeParam;
+    },
+    getTrackedFieldDepthOnNotifyChange: function () {
+        return trackedFieldDepthOnNotifyChange;
+    },
+    setTrackedFieldLeafNodeIdAndNameOnly: function (trackedFieldLeafNodeIdAndNameOnlyParam) {
+        trackedFieldLeafNodeIdAndNameOnly = trackedFieldLeafNodeIdAndNameOnlyParam;
+    },
+    getTrackedFieldLeafNodeIdAndNameOnly: function () {
+        return trackedFieldLeafNodeIdAndNameOnly;
+    },
+    // createRecord
+    setDraftAwareCreateRecordAdapter: function (adapter) {
+        draftAwareCreateRecordAdapter = adapter;
+    },
+    getDraftAwareCreateRecordAdapter: function () {
+        return draftAwareCreateRecordAdapter;
+    },
+    // updateRecord
+    setDraftAwareUpdateRecordAdapter: function (adapter) {
+        draftAwareUpdateRecordAdapter = adapter;
+    },
+    getDraftAwareUpdateRecordAdapter: function () {
+        return draftAwareUpdateRecordAdapter;
+    },
+    // deleteRecord
+    setDraftAwareDeleteRecordAdapter: function (adapter) {
+        draftAwareDeleteRecordAdapter = adapter;
+    },
+    getDraftAwareDeleteRecordAdapter: function () {
+        return draftAwareDeleteRecordAdapter;
+    },
+    // createContentDocumentAndVersion
+    setDraftAwareCreateContentDocumentAndVersionAdapter: function (adapter) {
+        draftAwareCreateContentDocumentAndVersionAdapter = adapter;
+    },
+    getDraftAwareCreateContentDocumentAndVersionAdapter: function () {
+        return draftAwareCreateContentDocumentAndVersionAdapter;
+    },
+    setRelatedListsPredictionsEnabled: function (f) {
+        relatedListsPredictionsEnabled = f;
+    },
+    areRelatedListsPredictionsEnabled: function () {
+        return relatedListsPredictionsEnabled === true;
+    },
+    // createContentVersion
+    setDraftAwareCreateContentVersionAdapter: function (adapter) {
+        draftAwareCreateContentVersionAdapter = adapter;
+    },
+    getDraftAwareCreateContentVersionAdapter: function () {
+        return draftAwareCreateContentVersionAdapter;
+    },
+    ...configurationForOneStoreEnabledAdapters,
+};
+/**
+ * Defines the configuration API and is exposed internally as well as externally.
+ * Configuration for GraphQL adapters only.
+ */
+const configurationForGraphQLAdapters = {
+    setDraftAwareGraphQLAdapter: function (adapter) {
+        draftAwareGraphQLAdapter = adapter;
+    },
+    getDraftAwareGraphQLAdapter: function () {
+        return draftAwareGraphQLAdapter;
+    },
+    setEnvironmentAwareGraphQLBatchAdapter: function (adapter) {
+        environmentAwareGraphQLBatchAdapter = adapter;
+    },
+    getEnvironmentAwareGraphQLBatchAdapter: function () {
+        return environmentAwareGraphQLBatchAdapter;
+    },
+};
+const registrations = new Set();
+/**
+ * lds-adapter-uiapi is special.  The non-SFDC bundle combines REST and GQL adapters,
+ * yet for SFDC those are separate bundles.  So non-SFDC bundle (./main.ts) registers
+ * both REST and GQL configs.  We want each SFDC bundle to register (we don't want one
+ * SFDC bundle to assume the other is being loaded and therefore the other one will
+ * take care of registration) but we don't want to double register either.
+ *
+ * So we make this function that memoizes if it's been called before and only
+ * actually registers once.
+ */
+function ensureRegisteredOnce(registration) {
+    const { id } = registration;
+    if (!registrations.has(id)) {
+        register(registration);
+        registrations.add(id);
+    }
+}
+
 // For use by callers within this module to instrument interesting things.
 let instrumentation = {
-    timerMetricAddDuration: (_metricName, _valueInMs) => { },
+    /**
+     * Called when a set of record conflicts has been fully resolved. The
+     * parameter indicates the number of server requests that were needed
+     * to fully resolve all the record conflicts.
+     */
+    recordConflictsResolved: (_serverRequestCount) => { },
+    /**
+     * Called during merging of incoming and existing FieldValues.
+     * Called when the incoming FieldValue display value is null.
+     *
+     * Note: Temporary instrumentation to capture distribution and frequency, W-8990630
+     * Flipped to counter metric due to W-9611107
+     */
+    nullDisplayValueConflict: (_fieldInfo) => { },
+    /**
+     * SFDC Throttling
+     * getRecordNotifyChange and notifyRecordUpdateAvailable are both throttled
+     */
+    getRecordNotifyChangeAllowed: () => { },
+    getRecordNotifyChangeDropped: () => { },
+    notifyRecordUpdateAvailableAllowed: () => { },
+    notifyRecordUpdateAvailableDropped: () => { },
+    /**
+     * RecordRepresentation merge
+     * Called when records change apiName
+     */
+    recordApiNameChanged: (_existingApiName, _incomingApiName) => { },
+    recordTypeIdIsNull: (_apiName) => { },
+    /**
+     * RecordRepresentation merge
+     * Called when either incoming or existing RecordRepresentation has a weakEtag=0
+     */
+    weakEtagZero: (_incomingWeakEtagZero, _existingWeakEtagZero, _apiName) => { },
+    /**
+     * getRecord notifyChangeFactory
+     * Called when dispatchResourceRequest is resolved/rejected
+     */
+    getRecordNotifyChangeNetworkResult: (_uniqueWeakEtags, _error) => { },
 };
 /**
  * Allows external modules (typically a runtime environment) to set
@@ -39,6 +4328,479 @@ let instrumentation = {
 function instrument(newInstrumentation) {
     instrumentation = Object.assign(instrumentation, newInstrumentation);
 }
+const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
+function generateParamConfigMetadata(name, required, resourceType, typeCheckShape, isArrayShape = false, coerceFn) {
+    return {
+        name,
+        required,
+        resourceType,
+        typeCheckShape,
+        isArrayShape,
+        coerceFn,
+    };
+}
+function buildAdapterValidationConfig(displayName, paramsMeta) {
+    const required = paramsMeta.filter(p => p.required).map(p => p.name);
+    const optional = paramsMeta.filter(p => !p.required).map(p => p.name);
+    return {
+        displayName,
+        parameters: {
+            required,
+            optional,
+        }
+    };
+}
+
+const { assign, create, freeze, isFrozen, keys } = Object;
+const { isArray } = Array;
+const { concat, filter, includes, push, reduce } = Array.prototype;
+
+function isString(value) {
+    return typeof value === 'string';
+}
+/**
+ * @param value The array to dedupe
+ * @returns An array without duplicates.
+ */
+function dedupe(value) {
+    const result = {};
+    for (let i = 0, len = value.length; i < len; i += 1) {
+        result[value[i]] = true;
+    }
+    return keys(result);
+}
+
+function isObjectId(unknown) {
+    if (typeof unknown !== 'object' || unknown === null) {
+        return false;
+    }
+    return isString(unknown.objectApiName);
+}
+
+/**
+ * Returns the object API name.
+ * @param value The value from which to get the object API name.
+ * @returns The object API name.
+ */
+function getObjectApiName$1(value) {
+    // Note: tightening validation logic changes behavior from userland getting
+    // a server-provided error to the adapter noop'ing. In 224 we decided to not
+    // change the behavior.
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed.length > 0) {
+            return trimmed;
+        }
+    }
+    else if (isObjectId(value)) {
+        return value.objectApiName.trim();
+    }
+    return undefined;
+}
+
+function isFieldId(unknown) {
+    if (typeof unknown !== 'object' || unknown === null) {
+        return false;
+    }
+    const value = unknown;
+    return isString(value.objectApiName) && isString(value.fieldApiName);
+}
+
+/**
+ * Returns the field API name, qualified with an object name if possible.
+ * @param value The value from which to get the qualified field API name.
+ * @param onlyQualifiedFieldNames - Whether or not this function should skip fieldApiName that do not include the delimiter '.'
+ * @return The qualified field API name.
+ */
+function getFieldApiName(value, onlyQualifiedFieldNames = false) {
+    // Note: tightening validation logic changes behavior from userland getting
+    // a server-provided error to the adapter noop'ing. In 224 we decided to not
+    // change the behavior. In 250 we decided to add the 'onlyQualifiedFieldName' flag to tighten the logic
+    // optionally to avoid issues with persisted invalid field names.
+    if (isString(value)) {
+        const trimmed = value.trim();
+        if (trimmed.length > 0 && (onlyQualifiedFieldNames ? trimmed.indexOf('.') > -1 : true)) {
+            return trimmed;
+        }
+    }
+    else if (isFieldId(value)) {
+        return value.objectApiName + '.' + value.fieldApiName;
+    }
+    return undefined;
+}
+
+/**
+ * Returns the field API name.
+ * @param value The value from which to get the field API name.
+ * @param options Option bag. onlyQualifiedFieldNames is a boolean that allows this function to skip returning invalid FieldApiNames.
+ * @returns The field API name.
+ */
+function getFieldApiNamesArray(value, options = { onlyQualifiedFieldNames: false }) {
+    const valueArray = isArray(value) ? value : [value];
+    const array = [];
+    for (let i = 0, len = valueArray.length; i < len; i += 1) {
+        const item = valueArray[i];
+        const apiName = getFieldApiName(item, options.onlyQualifiedFieldNames);
+        if (apiName === undefined) {
+            if (options.onlyQualifiedFieldNames) {
+                continue; // Just skips invalid field names rather than failing to return an array at all
+            }
+            return undefined;
+        }
+        push.call(array, apiName);
+    }
+    if (array.length === 0) {
+        return undefined;
+    }
+    return dedupe(array).sort();
+}
+freeze({
+    name: '',
+    children: {},
+});
+
+ObjectCreate$1(null);
+
+ObjectCreate$1(null);
+
+const adapterName$$ = 'getListUiByApiName';
+const getListUiByApiName_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('listViewApiName', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('objectApiName', true, 0 /* UrlParameter */, 0 /* String */, false, getObjectApiName$1),
+    generateParamConfigMetadata('fields', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+    generateParamConfigMetadata('optionalFields', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+    generateParamConfigMetadata('pageSize', false, 1 /* QueryParameter */, 3 /* Integer */),
+    generateParamConfigMetadata('pageToken', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('sortBy', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+];
+const getListUiByApiName_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$$, getListUiByApiName_ConfigPropertyMetadata);
+
+const adapterName$_ = 'getListUiByListViewId';
+const getListUiByListViewId_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('listViewId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('fields', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+    generateParamConfigMetadata('optionalFields', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+    generateParamConfigMetadata('pageSize', false, 1 /* QueryParameter */, 3 /* Integer */),
+    generateParamConfigMetadata('pageToken', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('sortBy', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+];
+const getListUiByListViewId_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$_, getListUiByListViewId_ConfigPropertyMetadata);
+
+const adapterName$Y = 'getMruListUi';
+const getMruListUi_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('objectApiName', true, 0 /* UrlParameter */, 0 /* String */, false, getObjectApiName$1),
+    generateParamConfigMetadata('fields', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+    generateParamConfigMetadata('optionalFields', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+    generateParamConfigMetadata('pageSize', false, 1 /* QueryParameter */, 3 /* Integer */),
+    generateParamConfigMetadata('pageToken', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('sortBy', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+];
+const getMruListUi_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$Y, getMruListUi_ConfigPropertyMetadata);
+// make local copies of the adapter configs so we can ignore other getListUi config parameters to match
+// lds222 behavior
+({
+    ...getMruListUi_ConfigPropertyNames,
+    parameters: {
+        ...getMruListUi_ConfigPropertyNames.parameters,
+        optional: [
+            ...getMruListUi_ConfigPropertyNames.parameters.optional,
+            'listViewApiName',
+            'listViewId',
+        ],
+    },
+});
+// make local copies of the adapter configs so we can have them ignore each other's config parameters
+// to match lds222 behavior
+({
+    ...getListUiByApiName_ConfigPropertyNames,
+    parameters: {
+        ...getListUiByApiName_ConfigPropertyNames.parameters,
+        optional: [...getListUiByApiName_ConfigPropertyNames.parameters.optional, 'listViewId'],
+    },
+});
+({
+    ...getListUiByListViewId_ConfigPropertyNames,
+    parameters: {
+        ...getListUiByListViewId_ConfigPropertyNames.parameters,
+        optional: [
+            ...getListUiByListViewId_ConfigPropertyNames.parameters.optional,
+            'listViewApiName',
+            'objectApiName',
+        ],
+    },
+});
+
+var DiscriminatorValues$5;
+(function (DiscriminatorValues) {
+    DiscriminatorValues["EmptySpace"] = "EmptySpace";
+    DiscriminatorValues["ReportChart"] = "ReportChart";
+    DiscriminatorValues["VisualforcePage"] = "VisualforcePage";
+    DiscriminatorValues["Canvas"] = "Canvas";
+    DiscriminatorValues["Field"] = "Field";
+    DiscriminatorValues["CustomLink"] = "CustomLink";
+})(DiscriminatorValues$5 || (DiscriminatorValues$5 = {}));
+
+var LayoutMode;
+(function (LayoutMode) {
+    LayoutMode["View"] = "View";
+    LayoutMode["Edit"] = "Edit";
+    LayoutMode["Create"] = "Create";
+})(LayoutMode || (LayoutMode = {}));
+
+LayoutMode.View;
+
+var FormFactor;
+(function (FormFactor) {
+    FormFactor["Large"] = "Large";
+    FormFactor["Medium"] = "Medium";
+    FormFactor["Small"] = "Small";
+})(FormFactor || (FormFactor = {}));
+
+ObjectCreate$1(null);
+
+var LayoutType;
+(function (LayoutType) {
+    LayoutType["Full"] = "Full";
+    LayoutType["Compact"] = "Compact";
+})(LayoutType || (LayoutType = {}));
+
+ObjectCreate$1(null);
+
+ObjectCreate$1(null);
+
+const VERSION$1O = "8d2032474fb4fabdf5cf4042be9042d9";
+const select$20 = function WorkStepPicklistValueAttributeRepresentationSelect() {
+    const { selections: AbstractPicklistValueAttributesRepresentationSelections } = select$1Y();
+    return {
+        kind: 'Fragment',
+        version: VERSION$1O,
+        private: [],
+        selections: [
+            ...AbstractPicklistValueAttributesRepresentationSelections,
+            {
+                name: 'sortOrder',
+                kind: 'Scalar'
+            },
+            {
+                name: 'statusCode',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+
+const VERSION$1N = "53893a219bc0888951863f2c44317cac";
+const select$1$ = function LeadStatusPicklistValueAttributesRepresentationSelect() {
+    const { selections: AbstractPicklistValueAttributesRepresentationSelections } = select$1Y();
+    return {
+        kind: 'Fragment',
+        version: VERSION$1N,
+        private: [],
+        selections: [
+            ...AbstractPicklistValueAttributesRepresentationSelections,
+            {
+                name: 'converted',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+
+const VERSION$1M = "4818ec07c499784571c1012ead048c88";
+const select$1_ = function CaseStatusPicklistValueAttributesRepresentationSelect() {
+    const { selections: AbstractPicklistValueAttributesRepresentationSelections } = select$1Y();
+    return {
+        kind: 'Fragment',
+        version: VERSION$1M,
+        private: [],
+        selections: [
+            ...AbstractPicklistValueAttributesRepresentationSelections,
+            {
+                name: 'closed',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+
+const VERSION$1L = "950a3a962acbd2b128f937d4c055a9d6";
+const select$1Z = function OpportunityStagePicklistValueAttributesRepresentationSelect() {
+    const { selections: AbstractPicklistValueAttributesRepresentationSelections } = select$1Y();
+    return {
+        kind: 'Fragment',
+        version: VERSION$1L,
+        private: [],
+        selections: [
+            ...AbstractPicklistValueAttributesRepresentationSelections,
+            {
+                name: 'closed',
+                kind: 'Scalar'
+            },
+            {
+                name: 'defaultProbability',
+                kind: 'Scalar'
+            },
+            {
+                name: 'forecastCategoryName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'won',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+
+var DiscriminatorValues$4;
+(function (DiscriminatorValues) {
+    DiscriminatorValues["WorkStepStatus"] = "WorkStepStatus";
+    DiscriminatorValues["LeadStatus"] = "LeadStatus";
+    DiscriminatorValues["CaseStatus"] = "CaseStatus";
+    DiscriminatorValues["OpportunityStage"] = "OpportunityStage";
+})(DiscriminatorValues$4 || (DiscriminatorValues$4 = {}));
+const VERSION$1K = "bd523b2343366edfc25a2dbee2c4e986";
+const selectChildren$2 = function AbstractPicklistValueAttributesRepresentationSelectChildren() {
+    const workStepPicklistValueAttributeRepresentationSelections = select$20();
+    const leadStatusPicklistValueAttributesRepresentationSelections = select$1$();
+    const caseStatusPicklistValueAttributesRepresentationSelections = select$1_();
+    const opportunityStagePicklistValueAttributesRepresentationSelections = select$1Z();
+    return {
+        kind: 'Fragment',
+        union: true,
+        discriminator: 'picklistAtrributesValueType',
+        unionSelections: {
+            [DiscriminatorValues$4.WorkStepStatus]: workStepPicklistValueAttributeRepresentationSelections,
+            [DiscriminatorValues$4.LeadStatus]: leadStatusPicklistValueAttributesRepresentationSelections,
+            [DiscriminatorValues$4.CaseStatus]: caseStatusPicklistValueAttributesRepresentationSelections,
+            [DiscriminatorValues$4.OpportunityStage]: opportunityStagePicklistValueAttributesRepresentationSelections
+        }
+    };
+};
+const select$1Y = function AbstractPicklistValueAttributesRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$1K,
+        private: [],
+        selections: [
+            {
+                name: 'picklistAtrributesValueType',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+
+const VERSION$1J = "9e2a16a80378487f557124c771201cf9";
+const select$1X = function PicklistValueRepresentationSelect() {
+    const AbstractPicklistValueAttributesRepresentation__unionSelections = selectChildren$2();
+    return {
+        kind: 'Fragment',
+        version: VERSION$1J,
+        private: [],
+        selections: [
+            {
+                kind: 'Object',
+                name: 'attributes',
+                discriminator: AbstractPicklistValueAttributesRepresentation__unionSelections.discriminator,
+                union: true,
+                nullable: true,
+                unionSelections: AbstractPicklistValueAttributesRepresentation__unionSelections.unionSelections
+            },
+            {
+                name: 'label',
+                kind: 'Scalar'
+            },
+            {
+                name: 'validFor',
+                kind: 'Scalar',
+                plural: true
+            },
+            {
+                name: 'value',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+const VERSION$1I = "0a361a49370acb4c6a31721a2057649a";
+const select$1W = function PicklistValuesRepresentationSelect() {
+    const { selections: PicklistValueRepresentation__selections, opaque: PicklistValueRepresentation__opaque, } = select$1X();
+    return {
+        kind: 'Fragment',
+        version: VERSION$1I,
+        private: [
+            'eTag'
+        ],
+        selections: [
+            {
+                name: 'controllerValues',
+                kind: 'Scalar',
+                map: true
+            },
+            {
+                name: 'defaultValue',
+                kind: 'Object',
+                nullable: true,
+                selections: PicklistValueRepresentation__selections
+            },
+            {
+                name: 'url',
+                kind: 'Scalar'
+            },
+            {
+                name: 'values',
+                kind: 'Object',
+                plural: true,
+                selections: PicklistValueRepresentation__selections
+            }
+        ]
+    };
+};
+
+select$1W().selections;
+
+var DiscriminatorValues$3;
+(function (DiscriminatorValues) {
+    DiscriminatorValues["Photo"] = "Photo";
+    DiscriminatorValues["Theme"] = "Theme";
+})(DiscriminatorValues$3 || (DiscriminatorValues$3 = {}));
+
+ObjectCreate$1(null);
+
+ObjectCreate$1(null);
+
+ObjectCreate$1(null);
+
+ObjectCreate$1(null);
+
+var DiscriminatorValues$1;
+(function (DiscriminatorValues) {
+    DiscriminatorValues["Text"] = "Text";
+    DiscriminatorValues["Select"] = "Select";
+})(DiscriminatorValues$1 || (DiscriminatorValues$1 = {}));
+
+var DiscriminatorValues;
+(function (DiscriminatorValues) {
+    DiscriminatorValues["Field"] = "Field";
+    DiscriminatorValues["DataCategory"] = "DataCategory";
+})(DiscriminatorValues || (DiscriminatorValues = {}));
+
+const API_NAMESPACE = 'UiApi';
+const RECORD_REPRESENTATION_NAME = 'RecordRepresentation';
+const RECORD_ID_PREFIX = `${API_NAMESPACE}::${RECORD_REPRESENTATION_NAME}:`;
+const RECORD_FIELDS_KEY_JUNCTION = '__fields__';
+// The rest of this is copy-pasted. Sorry.
+ObjectCreate$1(null);
+ensureRegisteredOnce({
+    id: '@salesforce/lds-adapters-uiapi-mobile',
+    configuration: {
+        ...configurationForRestAdapters,
+        ...configurationForGraphQLAdapters,
+        ...configurationForOneStoreEnabledAdapters,
+    },
+    instrument,
+});
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -175,7 +4937,7 @@ function fixRecordTypes(luvio, record) {
         }
     }
     // recurse on nested records
-    const fieldKeys = keys(record.fields);
+    const fieldKeys = keys$1(record.fields);
     const fieldKeysLen = fieldKeys.length;
     for (let i = 0; i < fieldKeysLen; ++i) {
         const fieldValue = record.fields[fieldKeys[i]].value;
@@ -246,7 +5008,7 @@ class AdsBridge {
             if (didIngestRecord === true) {
                 luvio.storeBroadcast();
             }
-            instrumentation.timerMetricAddDuration(ADS_BRIDGE_ADD_RECORDS_DURATION, Date.now() - startTime);
+            instrumentation$1.timerMetricAddDuration(ADS_BRIDGE_ADD_RECORDS_DURATION, Date.now() - startTime);
         });
     }
     /**
@@ -259,7 +5021,7 @@ class AdsBridge {
         return this.lockLdsRecordEmit(() => {
             luvio.storeEvict(key);
             luvio.storeBroadcast();
-            instrumentation.timerMetricAddDuration(ADS_BRIDGE_EVICT_DURATION, Date.now() - startTime);
+            instrumentation$1.timerMetricAddDuration(ADS_BRIDGE_EVICT_DURATION, Date.now() - startTime);
             return Promise.resolve();
         });
     }
@@ -281,7 +5043,7 @@ class AdsBridge {
         // Prefix all the fields with the record API name.
         const qualifiedFieldNames = [];
         for (let i = 0, len = fieldNames.length; i < len; i++) {
-            push.call(qualifiedFieldNames, `${apiName}.${fieldNames[i]}`);
+            push$1.call(qualifiedFieldNames, `${apiName}.${fieldNames[i]}`);
         }
         return Promise.resolve(qualifiedFieldNames);
     }
@@ -342,7 +5104,7 @@ class AdsBridge {
         if (shouldEmit === true) {
             callback(adsRecordMap, adsObjectMap);
         }
-        instrumentation.timerMetricAddDuration(ADS_BRIDGE_EMIT_RECORD_CHANGED_DURATION, Date.now() - startTime);
+        instrumentation$1.timerMetricAddDuration(ADS_BRIDGE_EMIT_RECORD_CHANGED_DURATION, Date.now() - startTime);
     }
 }
 
@@ -370,5 +5132,5 @@ function withAdsBridge(callback) {
     callbacks.push(callback);
 }
 
-export { instrument, withAdsBridge };
-// version: 1.294.0-06a44f23f
+export { instrument$1 as instrument, withAdsBridge };
+// version: 1.296.0-ad26368c0