https://transform.tools/_next/static/cba37845c60204d8200d.worker.js

1/******/ (function(modules) { // webpackBootstrap
2/******/ 	// The module cache
3/******/ 	var installedModules = {};
4/******/
5/******/ 	// The require function
6/******/ 	function __webpack_require__(moduleId) {
7/******/
8/******/ 		// Check if module is in cache
9/******/ 		if(installedModules[moduleId]) {
10/******/ 			return installedModules[moduleId].exports;
11/******/ 		}
12/******/ 		// Create a new module (and put it into the cache)
13/******/ 		var module = installedModules[moduleId] = {
14/******/ 			i: moduleId,
15/******/ 			l: false,
16/******/ 			exports: {}
17/******/ 		};
18/******/
19/******/ 		// Execute the module function
20/******/ 		var threw = true;
21/******/ 		try {
22/******/ 			modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
23/******/ 			threw = false;
24/******/ 		} finally {
25/******/ 			if(threw) delete installedModules[moduleId];
26/******/ 		}
27/******/
28/******/ 		// Flag the module as loaded
29/******/ 		module.l = true;
30/******/
31/******/ 		// Return the exports of the module
32/******/ 		return module.exports;
33/******/ 	}
34/******/
35/******/
36/******/ 	// expose the modules object (__webpack_modules__)
37/******/ 	__webpack_require__.m = modules;
38/******/
39/******/ 	// expose the module cache
40/******/ 	__webpack_require__.c = installedModules;
41/******/
42/******/ 	// define getter function for harmony exports
43/******/ 	__webpack_require__.d = function(exports, name, getter) {
44/******/ 		if(!__webpack_require__.o(exports, name)) {
45/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
46/******/ 		}
47/******/ 	};
48/******/
49/******/ 	// define __esModule on exports
50/******/ 	__webpack_require__.r = function(exports) {
51/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
52/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
53/******/ 		}
54/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
55/******/ 	};
56/******/
57/******/ 	// create a fake namespace object
58/******/ 	// mode & 1: value is a module id, require it
59/******/ 	// mode & 2: merge all properties of value into the ns
60/******/ 	// mode & 4: return value when already ns object
61/******/ 	// mode & 8|1: behave like require
62/******/ 	__webpack_require__.t = function(value, mode) {
63/******/ 		if(mode & 1) value = __webpack_require__(value);
64/******/ 		if(mode & 8) return value;
65/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
66/******/ 		var ns = Object.create(null);
67/******/ 		__webpack_require__.r(ns);
68/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
69/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
70/******/ 		return ns;
71/******/ 	};
72/******/
73/******/ 	// getDefaultExport function for compatibility with non-harmony modules
74/******/ 	__webpack_require__.n = function(module) {
75/******/ 		var getter = module && module.__esModule ?
76/******/ 			function getDefault() { return module['default']; } :
77/******/ 			function getModuleExports() { return module; };
78/******/ 		__webpack_require__.d(getter, 'a', getter);
79/******/ 		return getter;
80/******/ 	};
81/******/
82/******/ 	// Object.prototype.hasOwnProperty.call
83/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
84/******/
85/******/ 	// __webpack_public_path__
86/******/ 	__webpack_require__.p = "";
87/******/
88/******/
89/******/ 	// Load entry module and return exports
90/******/ 	return __webpack_require__(__webpack_require__.s = "Ggmd");
91/******/ })
92/************************************************************************/
93/******/ ({
94
95/***/ "+dZ+":
96/***/ (function(__webpack_module__, __webpack_exports__, __webpack_require__) {
97
98"use strict";
99/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return defineInspect; });
100/* harmony import */ var _invariant_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("2C6G");
101/* harmony import */ var _nodejsCustomInspectSymbol_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("RKIb");
102
103
104/**
105 * The `defineInspect()` function defines `inspect()` prototype method as alias of `toJSON`
106 */
107
108function defineInspect(classObject) {
109  var fn = classObject.prototype.toJSON;

110  typeof fn === 'function' || Object(_invariant_mjs__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(0);
111  classObject.prototype.inspect = fn; // istanbul ignore else (See: 'https://github.com/graphql/graphql-js/issues/2317')
112
113  if (_nodejsCustomInspectSymbol_mjs__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"]) {
114    classObject.prototype[_nodejsCustomInspectSymbol_mjs__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"]] = fn;
115  }
116}
117
118
119/***/ }),
120
121/***/ "/HjL":
122/***/ (function(module, exports, __webpack_require__) {
123
124"use strict";
125/**
126 * Copyright (c) Facebook, Inc. and its affiliates.
127 *
128 * This source code is licensed under the MIT license found in the
129 * LICENSE file in the root directory of this source tree.
130 *
131 * 
132 * @format
133 */
134// flowlint ambiguous-object-type:error
135
136
137var invariant = __webpack_require__("OUqe");
138
139var _require = __webpack_require__("sriv"),
140    DEFAULT_HANDLE_KEY = _require.DEFAULT_HANDLE_KEY;
141
142var INDENT = '  ';
143/**
144 * Converts an IR node into a GraphQL string. Custom Relay
145 * extensions (directives) are not supported; to print fragments with
146 * variables or fragment spreads with arguments, transform the node
147 * prior to printing.
148 */
149
150function print(schema, node) {
151  switch (node.kind) {
152    case 'Fragment':
153      return "fragment ".concat(node.name, " on ").concat(schema.getTypeString(node.type)) + printFragmentArgumentDefinitions(schema, node.argumentDefinitions) + printDirectives(schema, node.directives) + printSelections(schema, node, '', {}) + '\n';
154
155    case 'Root':
156      return "".concat(node.operation, " ").concat(node.name) + printArgumentDefinitions(schema, node.argumentDefinitions) + printDirectives(schema, node.directives) + printSelections(schema, node, '', {}) + '\n';
157
158    case 'SplitOperation':
159      return "SplitOperation ".concat(node.name, " on ").concat(schema.getTypeString(node.type)) + printSelections(schema, node, '', {}) + '\n';
160
161    default:
162      node;
163       true ?  false ? undefined : invariant(false) : undefined;
164  }
165}
166
167function printSelections(schema, node, indent, options) {
168  var selections = node.selections;
169
170  if (selections == null) {
171    return '';
172  }
173
174  var printed = selections.map(function (selection) {
175    return printSelection(schema, selection, indent, options);
176  });
177  return printed.length ? " {\n".concat(indent + INDENT).concat(printed.join('\n' + indent + INDENT), "\n").concat(indent).concat((options === null || options === void 0 ? void 0 : options.isClientExtension) === true ? '# ' : '', "}") : '';
178}
179/**
180 * Prints a field without subselections.
181 */
182
183
184function printField(schema, field, options) {
185  var _options$parentDirect;
186
187  var parentDirectives = (_options$parentDirect = options === null || options === void 0 ? void 0 : options.parentDirectives) !== null && _options$parentDirect !== void 0 ? _options$parentDirect : '';
188  var isClientExtension = (options === null || options === void 0 ? void 0 : options.isClientExtension) === true;
189  return (isClientExtension ? '# ' : '') + (field.alias === field.name ? field.name : field.alias + ': ' + field.name) + printArguments(schema, field.args) + parentDirectives + printDirectives(schema, field.directives) + printHandles(schema, field);
190}
191
192function printSelection(schema, selection, indent, options) {
193  var _options$parentDirect2;
194
195  var str;
196  var parentDirectives = (_options$parentDirect2 = options === null || options === void 0 ? void 0 : options.parentDirectives) !== null && _options$parentDirect2 !== void 0 ? _options$parentDirect2 : '';
197  var isClientExtension = (options === null || options === void 0 ? void 0 : options.isClientExtension) === true;
198
199  if (selection.kind === 'LinkedField') {
200    str = printField(schema, selection, {
201      parentDirectives: parentDirectives,
202      isClientExtension: isClientExtension
203    });
204    str += printSelections(schema, selection, indent + INDENT, {
205      isClientExtension: isClientExtension
206    });
207  } else if (selection.kind === 'ModuleImport') {
208    str = selection.selections.map(function (matchSelection) {
209      return printSelection(schema, matchSelection, indent, {
210        parentDirectives: parentDirectives,
211        isClientExtension: isClientExtension
212      });
213    }).join('\n' + indent + INDENT);
214  } else if (selection.kind === 'ScalarField') {
215    str = printField(schema, selection, {
216      parentDirectives: parentDirectives,
217      isClientExtension: isClientExtension
218    });
219  } else if (selection.kind === 'InlineFragment') {
220    str = '';
221
222    if (isClientExtension) {
223      str += '# ';
224    }
225
226    str += '... on ' + schema.getTypeString(selection.typeCondition);
227    str += parentDirectives;
228    str += printDirectives(schema, selection.directives);
229    str += printSelections(schema, selection, indent + INDENT, {
230      isClientExtension: isClientExtension
231    });
232  } else if (selection.kind === 'FragmentSpread') {
233    str = '';
234
235    if (isClientExtension) {
236      str += '# ';
237    }
238
239    str += '...' + selection.name;
240    str += parentDirectives;

241    str += printFragmentArguments(schema, selection.args);
242    str += printDirectives(schema, selection.directives);
243  } else if (selection.kind === 'InlineDataFragmentSpread') {
244    str = "# ".concat(selection.name, " @inline") + "\n".concat(indent).concat(INDENT, "...") + parentDirectives + printSelections(schema, selection, indent + INDENT, {});
245  } else if (selection.kind === 'Condition') {
246    var value = printValue(schema, selection.condition, null); // For Flow
247
248    !(value != null) ?  false ? undefined : invariant(false) : void 0;
249    var condStr = selection.passingValue ? ' @include' : ' @skip';
250    condStr += '(if: ' + value + ')';
251    condStr += parentDirectives; // For multi-selection conditions, pushes the condition down to each
252
253    var subSelections = selection.selections.map(function (sel) {
254      return printSelection(schema, sel, indent, {
255        parentDirectives: condStr,
256        isClientExtension: isClientExtension
257      });
258    });
259    str = subSelections.join('\n' + indent + INDENT);
260  } else if (selection.kind === 'Stream') {
261    var streamStr = parentDirectives;
262    streamStr += " @stream(label: \"".concat(selection.label, "\"");
263
264    if (selection["if"] !== null) {
265      var _printValue;
266
267      streamStr += ", if: ".concat((_printValue = printValue(schema, selection["if"], null)) !== null && _printValue !== void 0 ? _printValue : '');
268    }
269
270    if (selection.initialCount !== null) {
271      var _printValue2;
272
273      streamStr += ", initial_count: ".concat((_printValue2 = printValue(schema, selection.initialCount, null)) !== null && _printValue2 !== void 0 ? _printValue2 : '');
274    }
275
276    if (selection.useCustomizedBatch !== null) {
277      var _printValue3;
278
279      streamStr += ", use_customized_batch: ".concat((_printValue3 = printValue(schema, selection.useCustomizedBatch, null)) !== null && _printValue3 !== void 0 ? _printValue3 : 'false');
280    }
281
282    streamStr += ')';
283
284    var _subSelections = selection.selections.map(function (sel) {
285      return printSelection(schema, sel, indent, {
286        parentDirectives: streamStr,
287        isClientExtension: isClientExtension
288      });
289    });
290
291    str = _subSelections.join('\n' + INDENT);
292  } else if (selection.kind === 'Defer') {
293    var deferStr = parentDirectives;
294    deferStr += " @defer(label: \"".concat(selection.label, "\"");
295
296    if (selection["if"] !== null) {
297      var _printValue4;
298
299      deferStr += ", if: ".concat((_printValue4 = printValue(schema, selection["if"], null)) !== null && _printValue4 !== void 0 ? _printValue4 : '');
300    }
301
302    deferStr += ')';
303
304    if (selection.selections.every(function (subSelection) {
305      return subSelection.kind === 'InlineFragment' || subSelection.kind === 'FragmentSpread';
306    })) {
307      var _subSelections2 = selection.selections.map(function (sel) {
308        return printSelection(schema, sel, indent, {
309          parentDirectives: deferStr,
310          isClientExtension: isClientExtension
311        });
312      });
313
314      str = _subSelections2.join('\n' + INDENT);
315    } else {
316      str = '...' + deferStr;
317      str += printSelections(schema, selection, indent + INDENT, {
318        isClientExtension: isClientExtension
319      });
320    }
321  } else if (selection.kind === 'ClientExtension') {
322    !(isClientExtension === false) ?  false ? undefined : invariant(false) : void 0;
323    str = '# Client-only selections:\n' + indent + INDENT + selection.selections.map(function (sel) {
324      return printSelection(schema, sel, indent, {
325        parentDirectives: parentDirectives,
326        isClientExtension: true
327      });
328    }).join('\n' + indent + INDENT);
329  } else {
330    selection;
331     true ?  false ? undefined : invariant(false) : undefined;
332  }
333
334  return str;
335}
336
337function printArgumentDefinitions(schema, argumentDefinitions) {
338  var printed = argumentDefinitions.map(function (def) {
339    var str = "$".concat(def.name, ": ").concat(schema.getTypeString(def.type));
340
341    if (def.defaultValue != null) {
342      str += ' = ' + printLiteral(schema, def.defaultValue, def.type);
343    }
344
345    return str;
346  });
347  return printed.length ? "(\n".concat(INDENT).concat(printed.join('\n' + INDENT), "\n)") : '';
348}
349
350function printFragmentArgumentDefinitions(schema, argumentDefinitions) {
351  var printed;
352  argumentDefinitions.forEach(function (def) {
353    if (def.kind !== 'LocalArgumentDefinition') {
354      return;
355    }
356
357    printed = printed || [];
358    var str = "".concat(def.name, ": {type: \"").concat(schema.getTypeString(def.type), "\"");
359
360    if (def.defaultValue != null) {
361      str += ", defaultValue: ".concat(printLiteral(schema, def.defaultValue, def.type));
362    }
363
364    str += '}';
365    printed.push(str);
366  });
367  return printed && printed.length ? " @argumentDefinitions(\n".concat(INDENT).concat(printed.join('\n' + INDENT), "\n)") : '';
368}
369
370function printHandles(schema, field) {
371  if (!field.handles) {
372    return '';
373  }
374
375  var printed = field.handles.map(function (handle) {
376    // For backward compatibility.
377    var key = handle.key === DEFAULT_HANDLE_KEY ? '' : ", key: \"".concat(handle.key, "\"");
378    var filters = handle.filters == null ? '' : ", filters: ".concat(JSON.stringify(Array.from(handle.filters).sort()));
379    var handleArgs = handle.handleArgs == null ? '' : ", handleArgs: ".concat(printArguments(schema, handle.handleArgs));
380    return "@__clientField(handle: \"".concat(handle.name, "\"").concat(key).concat(filters).concat(handleArgs, ")");
381  });
382  return printed.length ? ' ' + printed.join(' ') : '';
383}
384
385function printDirectives(schema, directives) {
386  var printed = directives.map(function (directive) {
387    return '@' + directive.name + printArguments(schema, directive.args);
388  });
389  return printed.length ? ' ' + printed.join(' ') : '';
390}
391
392function printFragmentArguments(schema, args) {
393  var printedArgs = printArguments(schema, args);
394
395  if (!printedArgs.length) {
396    return '';
397  }
398
399  return " @arguments".concat(printedArgs);
400}
401
402function printArguments(schema, args) {
403  var printed = [];

404  args.forEach(function (arg) {
405    var printedValue = printValue(schema, arg.value, arg.type);
406
407    if (printedValue != null) {
408      printed.push(arg.name + ': ' + printedValue);
409    }
410  });
411  return printed.length ? '(' + printed.join(', ') + ')' : '';
412}
413
414function printValue(schema, value, type) {
415  if (type != null && schema.isNonNull(type)) {
416    type = schema.getNullableType(type);
417  }
418
419  if (value.kind === 'Variable') {
420    return '$' + value.variableName;
421  } else if (value.kind === 'ObjectValue') {
422    var inputType = type != null ? schema.asInputObjectType(type) : null;
423    var pairs = value.fields.map(function (field) {
424      var fieldConfig = inputType != null ? schema.hasField(inputType, field.name) ? schema.getFieldConfig(schema.expectField(inputType, field.name)) : null : null;
425      var innerValue = printValue(schema, field.value, fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.type);
426      return innerValue == null ? null : field.name + ': ' + innerValue;
427    }).filter(Boolean);
428    return '{' + pairs.join(', ') + '}';
429  } else if (value.kind === 'ListValue') {
430    !(type && schema.isList(type)) ?  false ? undefined : invariant(false) : void 0;
431    var innerType = schema.getListItemType(type);
432    return "[".concat(value.items.map(function (i) {
433      return printValue(schema, i, innerType);
434    }).join(', '), "]");
435  } else if (value.value != null) {
436    return printLiteral(schema, value.value, type);
437  } else {
438    return null;
439  }
440}
441
442function printLiteral(schema, value, type) {
443  if (value == null) {
444    var _JSON$stringify;
445
446    return (_JSON$stringify = JSON.stringify(value)) !== null && _JSON$stringify !== void 0 ? _JSON$stringify : 'null';
447  }
448
449  if (type != null && schema.isNonNull(type)) {
450    type = schema.getNullableType(type);
451  }
452
453  if (type && schema.isEnum(type)) {
454    var _JSON$stringify2;
455
456    var result = schema.serialize(schema.assertEnumType(type), value);
457
458    if (result == null && typeof value === 'string') {
459      // For backwards compatibility, print invalid input values as-is. This
460      // can occur with literals defined as an @argumentDefinitions
461      // defaultValue.
462      result = value;
463    }
464
465    !(typeof result === 'string') ?  false ? undefined : invariant(false) : void 0;
466    return result;
467  } else if (type && (schema.isId(type) || schema.isInt(type))) {
468    var _JSON$stringify3;
469
470    return (_JSON$stringify3 = JSON.stringify(value)) !== null && _JSON$stringify3 !== void 0 ? _JSON$stringify3 : '';
471  } else if (type && schema.isScalar(type)) {
472    var _JSON$stringify4;
473
474    var _result = schema.serialize(schema.assertScalarType(type), value);
475
476    return (_JSON$stringify4 = JSON.stringify(_result)) !== null && _JSON$stringify4 !== void 0 ? _JSON$stringify4 : '';
477  } else if (Array.isArray(value)) {
478    !(type && schema.isList(type)) ?  false ? undefined : invariant(false) : void 0;
479    var itemType = schema.getListItemType(type);
480    return '[' + value.map(function (item) {
481      return printLiteral(schema, item, itemType);
482    }).join(', ') + ']';
483  } else if (type && schema.isList(type) && value != null) {
484    // Not an array, but still a list. Treat as list-of-one as per spec 3.1.7:
485    // http://facebook.github.io/graphql/October2016/#sec-Lists
486    return printLiteral(schema, value, schema.getListItemType(type));
487  } else if (typeof value === 'object' && value != null) {
488    var fields = [];
489    !(type && schema.isInputObject(type)) ?  false ? undefined : invariant(false) : void 0;
490    var inputType = schema.assertInputObjectType(type);
491
492    for (var key in value) {
493      if (value.hasOwnProperty(key)) {
494        var fieldConfig = schema.getFieldConfig(schema.expectField(inputType, key));
495        fields.push(key + ': ' + printLiteral(schema, value[key], fieldConfig.type));
496      }
497    }
498
499    return '{' + fields.join(', ') + '}';
500  } else {
501    var _JSON$stringify5;
502
503    return (_JSON$stringify5 = JSON.stringify(value)) !== null && _JSON$stringify5 !== void 0 ? _JSON$stringify5 : 'null';
504  }
505}
506
507module.exports = {
508  print: print,
509  printField: printField,
510  printArguments: printArguments,
511  printDirectives: printDirectives
512};
513
514/***/ }),
515
516/***/ "/jXB":
517/***/ (function(__webpack_module__, __webpack_exports__, __webpack_require__) {
518
519"use strict";
520/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Kind; });
521/**
522 * The set of allowed kind values for AST nodes.
523 */
524var Kind = Object.freeze({
525  // Name
526  NAME: 'Name',
527  // Document
528  DOCUMENT: 'Document',
529  OPERATION_DEFINITION: 'OperationDefinition',
530  VARIABLE_DEFINITION: 'VariableDefinition',
531  SELECTION_SET: 'SelectionSet',
532  FIELD: 'Field',
533  ARGUMENT: 'Argument',
534  // Fragments
535  FRAGMENT_SPREAD: 'FragmentSpread',
536  INLINE_FRAGMENT: 'InlineFragment',
537  FRAGMENT_DEFINITION: 'FragmentDefinition',
538  // Values
539  VARIABLE: 'Variable',
540  INT: 'IntValue',
541  FLOAT: 'FloatValue',
542  STRING: 'StringValue',
543  BOOLEAN: 'BooleanValue',
544  NULL: 'NullValue',
545  ENUM: 'EnumValue',
546  LIST: 'ListValue',
547  OBJECT: 'ObjectValue',
548  OBJECT_FIELD: 'ObjectField',
549  // Directives
550  DIRECTIVE: 'Directive',
551  // Types
552  NAMED_TYPE: 'NamedType',
553  LIST_TYPE: 'ListType',
554  NON_NULL_TYPE: 'NonNullType',
555  // Type System Definitions
556  SCHEMA_DEFINITION: 'SchemaDefinition',

557  OPERATION_TYPE_DEFINITION: 'OperationTypeDefinition',
558  // Type Definitions
559  SCALAR_TYPE_DEFINITION: 'ScalarTypeDefinition',
560  OBJECT_TYPE_DEFINITION: 'ObjectTypeDefinition',
561  FIELD_DEFINITION: 'FieldDefinition',
562  INPUT_VALUE_DEFINITION: 'InputValueDefinition',
563  INTERFACE_TYPE_DEFINITION: 'InterfaceTypeDefinition',
564  UNION_TYPE_DEFINITION: 'UnionTypeDefinition',
565  ENUM_TYPE_DEFINITION: 'EnumTypeDefinition',
566  ENUM_VALUE_DEFINITION: 'EnumValueDefinition',
567  INPUT_OBJECT_TYPE_DEFINITION: 'InputObjectTypeDefinition',
568  // Directive Definitions
569  DIRECTIVE_DEFINITION: 'DirectiveDefinition',
570  // Type System Extensions
571  SCHEMA_EXTENSION: 'SchemaExtension',
572  // Type Extensions
573  SCALAR_TYPE_EXTENSION: 'ScalarTypeExtension',
574  OBJECT_TYPE_EXTENSION: 'ObjectTypeExtension',
575  INTERFACE_TYPE_EXTENSION: 'InterfaceTypeExtension',
576  UNION_TYPE_EXTENSION: 'UnionTypeExtension',
577  ENUM_TYPE_EXTENSION: 'EnumTypeExtension',
578  INPUT_OBJECT_TYPE_EXTENSION: 'InputObjectTypeExtension'
579});
580/**
581 * The enum type representing the possible kind values of AST nodes.
582 */
583
584
585/***/ }),
586
587/***/ "/sVA":
588/***/ (function(module, exports, __webpack_require__) {
589
590"use strict";
591
592
593var toStr = Object.prototype.toString;
594var hasSymbols = __webpack_require__("UVaH")();
595
596if (hasSymbols) {
597	var symToStr = Symbol.prototype.toString;
598	var symStringRegex = /^Symbol\(.*\)$/;
599	var isSymbolObject = function isRealSymbolObject(value) {
600		if (typeof value.valueOf() !== 'symbol') {
601			return false;
602		}
603		return symStringRegex.test(symToStr.call(value));
604	};
605
606	module.exports = function isSymbol(value) {
607		if (typeof value === 'symbol') {
608			return true;
609		}
610		if (toStr.call(value) !== '[object Symbol]') {
611			return false;
612		}
613		try {
614			return isSymbolObject(value);
615		} catch (e) {
616			return false;
617		}
618	};
619} else {
620
621	module.exports = function isSymbol(value) {
622		// this environment does not support Symbols.
623		return  false && false;
624	};
625}
626
627
628/***/ }),
629
630/***/ "/vyT":
631/***/ (function(__webpack_module__, __webpack_exports__, __webpack_require__) {
632
633"use strict";
634/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return KnownTypeNamesRule; });
635/* harmony import */ var _jsutils_didYouMean_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("pv/G");
636/* harmony import */ var _jsutils_suggestionList_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("T95z");
637/* harmony import */ var _error_GraphQLError_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("dWS+");
638/* harmony import */ var _language_predicates_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("Xizt");
639/* harmony import */ var _type_scalars_mjs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("19Hc");
640/* harmony import */ var _type_introspection_mjs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("LViu");
641
642
643
644
645
646
647
648/**
649 * Known type names
650 *
651 * A GraphQL document is only valid if referenced types (specifically
652 * variable definitions and fragment conditions) are defined by the type schema.
653 */
654function KnownTypeNamesRule(context) {
655  var schema = context.getSchema();
656  var existingTypesMap = schema ? schema.getTypeMap() : Object.create(null);
657  var definedTypes = Object.create(null);
658
659  for (var _i2 = 0, _context$getDocument$2 = context.getDocument().definitions; _i2 < _context$getDocument$2.length; _i2++) {
660    var def = _context$getDocument$2[_i2];
661
662    if (Object(_language_predicates_mjs__WEBPACK_IMPORTED_MODULE_3__[/* isTypeDefinitionNode */ "d"])(def)) {
663      definedTypes[def.name.value] = true;
664    }
665  }
666
667  var typeNames = Object.keys(existingTypesMap).concat(Object.keys(definedTypes));
668  return {
669    NamedType: function NamedType(node, _1, parent, _2, ancestors) {
670      var typeName = node.name.value;
671
672      if (!existingTypesMap[typeName] && !definedTypes[typeName]) {
673        var _ancestors$;
674
675        var definitionNode = (_ancestors$ = ancestors[2]) !== null && _ancestors$ !== void 0 ? _ancestors$ : parent;
676        var isSDL = definitionNode != null && isSDLNode(definitionNode);
677
678        if (isSDL && isStandardTypeName(typeName)) {
679          return;
680        }
681
682        var suggestedTypes = Object(_jsutils_suggestionList_mjs__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(typeName, isSDL ? standardTypeNames.concat(typeNames) : typeNames);
683        context.reportError(new _error_GraphQLError_mjs__WEBPACK_IMPORTED_MODULE_2__[/* GraphQLError */ "a"]("Unknown type \"".concat(typeName, "\".") + Object(_jsutils_didYouMean_mjs__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(suggestedTypes), node));
684      }
685    }
686  };
687}
688var standardTypeNames = [].concat(_type_scalars_mjs__WEBPACK_IMPORTED_MODULE_4__[/* specifiedScalarTypes */ "g"], _type_introspection_mjs__WEBPACK_IMPORTED_MODULE_5__[/* introspectionTypes */ "m"]).map(function (type) {

689  return type.name;
690});
691
692function isStandardTypeName(typeName) {
693  return standardTypeNames.indexOf(typeName) !== -1;
694}
695
696function isSDLNode(value) {
697  return !Array.isArray(value) && (Object(_language_predicates_mjs__WEBPACK_IMPORTED_MODULE_3__[/* isTypeSystemDefinitionNode */ "g"])(value) || Object(_language_predicates_mjs__WEBPACK_IMPORTED_MODULE_3__[/* isTypeSystemExtensionNode */ "h"])(value));
698}
699
700
701/***/ }),
702
703/***/ 0:
704/***/ (function(module, exports) {
705
706/* (ignored) */
707
708/***/ }),
709
710/***/ "1/U3":
711/***/ (function(__webpack_module__, __webpack_exports__, __webpack_require__) {
712
713"use strict";
714/* eslint-disable no-redeclare */
715// $FlowFixMe[name-already-bound]
716var find = Array.prototype.find ? function (list, predicate) {
717  return Array.prototype.find.call(list, predicate);
718} : function (list, predicate) {
719  for (var _i2 = 0; _i2 < list.length; _i2++) {
720    var value = list[_i2];
721
722    if (predicate(value)) {
723      return value;
724    }
725  }
726};
727/* harmony default export */ __webpack_exports__["a"] = (find);
728
729
730/***/ }),
731
732/***/ "19Hc":
733/***/ (function(__webpack_module__, __webpack_exports__, __webpack_require__) {
734
735"use strict";
736
737// EXPORTS
738__webpack_require__.d(__webpack_exports__, "d", function() { return /* binding */ GraphQLInt; });
739__webpack_require__.d(__webpack_exports__, "b", function() { return /* binding */ GraphQLFloat; });
740__webpack_require__.d(__webpack_exports__, "e", function() { return /* binding */ GraphQLString; });
741__webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ GraphQLBoolean; });
742__webpack_require__.d(__webpack_exports__, "c", function() { return /* binding */ GraphQLID; });
743__webpack_require__.d(__webpack_exports__, "g", function() { return /* binding */ specifiedScalarTypes; });
744__webpack_require__.d(__webpack_exports__, "f", function() { return /* binding */ isSpecifiedScalarType; });
745
746// EXTERNAL MODULE: ./node_modules/graphql/polyfills/isFinite.mjs
747var polyfills_isFinite = __webpack_require__("lAJ0");
748
749// CONCATENATED MODULE: ./node_modules/graphql/polyfills/isInteger.mjs
750/* eslint-disable no-redeclare */
751// $FlowFixMe[name-already-bound] workaround for: https://github.com/facebook/flow/issues/4441
752var isInteger = Number.isInteger || function (value) {
753  return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
754};
755
756/* harmony default export */ var polyfills_isInteger = (isInteger);
757
758// EXTERNAL MODULE: ./node_modules/graphql/jsutils/inspect.mjs
759var inspect = __webpack_require__("rWdj");
760
761// EXTERNAL MODULE: ./node_modules/graphql/jsutils/isObjectLike.mjs
762var isObjectLike = __webpack_require__("zpYP");
763
764// EXTERNAL MODULE: ./node_modules/graphql/language/kinds.mjs
765var kinds = __webpack_require__("/jXB");
766
767// EXTERNAL MODULE: ./node_modules/graphql/language/printer.mjs
768var printer = __webpack_require__("dQau");
769
770// EXTERNAL MODULE: ./node_modules/graphql/error/GraphQLError.mjs
771var GraphQLError = __webpack_require__("dWS+");
772
773// EXTERNAL MODULE: ./node_modules/graphql/type/definition.mjs + 1 modules
774var definition = __webpack_require__("axIb");
775
776// CONCATENATED MODULE: ./node_modules/graphql/type/scalars.mjs
777
778
779
780
781
782
783
784 // As per the GraphQL Spec, Integers are only treated as valid when a valid
785// 32-bit signed integer, providing the broadest support across platforms.
786//
787// n.b. JavaScript's integers are safe between -(2^53 - 1) and 2^53 - 1 because
788// they are internally represented as IEEE 754 doubles.
789
790var MAX_INT = 2147483647;
791var MIN_INT = -2147483648;
792
793function serializeInt(outputValue) {
794  var coercedValue = serializeObject(outputValue);
795
796  if (typeof coercedValue === 'boolean') {
797    return coercedValue ? 1 : 0;
798  }
799
800  var num = coercedValue;
801
802  if (typeof coercedValue === 'string' && coercedValue !== '') {
803    num = Number(coercedValue);
804  }
805
806  if (!polyfills_isInteger(num)) {
807    throw new GraphQLError["a" /* GraphQLError */]("Int cannot represent non-integer value: ".concat(Object(inspect["a" /* default */])(coercedValue)));
808  }
809
810  if (num > MAX_INT || num < MIN_INT) {
811    throw new GraphQLError["a" /* GraphQLError */]('Int cannot represent non 32-bit signed integer value: ' + Object(inspect["a" /* default */])(coercedValue));
812  }
813
814  return num;
815}
816
817function coerceInt(inputValue) {
818  if (!polyfills_isInteger(inputValue)) {
819    throw new GraphQLError["a" /* GraphQLError */]("Int cannot represent non-integer value: ".concat(Object(inspect["a" /* default */])(inputValue)));
820  }
821
822  if (inputValue > MAX_INT || inputValue < MIN_INT) {
823    throw new GraphQLError["a" /* GraphQLError */]("Int cannot represent non 32-bit signed integer value: ".concat(inputValue));
824  }
825
826  return inputValue;
827}
828
829var GraphQLInt = new definition["g" /* GraphQLScalarType */]({
830  name: 'Int',
831  description: 'The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.',
832  serialize: serializeInt,
833  parseValue: coerceInt,
834  parseLiteral: function parseLiteral(valueNode) {
835    if (valueNode.kind !== kinds["a" /* Kind */].INT) {
836      throw new GraphQLError["a" /* GraphQLError */]("Int cannot represent non-integer value: ".concat(Object(printer["a" /* print */])(valueNode)), valueNode);
837    }
838
839    var num = parseInt(valueNode.value, 10);
840
841    if (num > MAX_INT || num < MIN_INT) {
842      throw new GraphQLError["a" /* GraphQLError */]("Int cannot represent non 32-bit signed integer value: ".concat(valueNode.value), valueNode);
843    }
844
845    return num;
846  }
847});
848
849function serializeFloat(outputValue) {
850  var coercedValue = serializeObject(outputValue);
851
852  if (typeof coercedValue === 'boolean') {
853    return coercedValue ? 1 : 0;
854  }
855
856  var num = coercedValue;
857
858  if (typeof coercedValue === 'string' && coercedValue !== '') {
859    num = Number(coercedValue);
860  }
861
862  if (!Object(polyfills_isFinite["a" /* default */])(num)) {
863    throw new GraphQLError["a" /* GraphQLError */]("Float cannot represent non numeric value: ".concat(Object(inspect["a" /* default */])(coercedValue)));
864  }
865
866  return num;
867}
868
869function coerceFloat(inputValue) {
870  if (!Object(polyfills_isFinite["a" /* default */])(inputValue)) {
871    throw new GraphQLError["a" /* GraphQLError */]("Float cannot represent non numeric value: ".concat(Object(inspect["a" /* default */])(inputValue)));
872  }
873
874  return inputValue;
875}
876
877var GraphQLFloat = new definition["g" /* GraphQLScalarType */]({
878  name: 'Float',
879  description: 'The `Float` scalar type represents signed double-precision fractional values as specified by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point).',
880  serialize: serializeFloat,
881  parseValue: coerceFloat,
882  parseLiteral: function parseLiteral(valueNode) {
883    if (valueNode.kind !== kinds["a" /* Kind */].FLOAT && valueNode.kind !== kinds["a" /* Kind */].INT) {
884      throw new GraphQLError["a" /* GraphQLError */]("Float cannot represent non numeric value: ".concat(Object(printer["a" /* print */])(valueNode)), valueNode);
885    }
886
887    return parseFloat(valueNode.value);
888  }
889});

889 // Support serializing objects with custom valueOf() or toJSON() functions -
890// a common way to represent a complex value which can be represented as
891// a string (ex: MongoDB id objects).
892
893function serializeObject(outputValue) {
894  if (Object(isObjectLike["a" /* default */])(outputValue)) {
895    if (typeof outputValue.valueOf === 'function') {
896      var valueOfResult = outputValue.valueOf();
897
898      if (!Object(isObjectLike["a" /* default */])(valueOfResult)) {
899        return valueOfResult;
900      }
901    }
902
903    if (typeof outputValue.toJSON === 'function') {
904      // $FlowFixMe[incompatible-use]
905      return outputValue.toJSON();
906    }
907  }
908
909  return outputValue;
910}
911
912function serializeString(outputValue) {
913  var coercedValue = serializeObject(outputValue); // Serialize string, boolean and number values to a string, but do not
914  // attempt to coerce object, function, symbol, or other types as strings.
915
916  if (typeof coercedValue === 'string') {
917    return coercedValue;
918  }
919
920  if (typeof coercedValue === 'boolean') {
921    return coercedValue ? 'true' : 'false';
922  }
923
924  if (Object(polyfills_isFinite["a" /* default */])(coercedValue)) {
925    return coercedValue.toString();
926  }
927
928  throw new GraphQLError["a" /* GraphQLError */]("String cannot represent value: ".concat(Object(inspect["a" /* default */])(outputValue)));
929}
930
931function coerceString(inputValue) {
932  if (typeof inputValue !== 'string') {
933    throw new GraphQLError["a" /* GraphQLError */]("String cannot represent a non string value: ".concat(Object(inspect["a" /* default */])(inputValue)));
934  }
935
936  return inputValue;
937}
938
939var GraphQLString = new definition["g" /* GraphQLScalarType */]({
940  name: 'String',
941  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.',
942  serialize: serializeString,
943  parseValue: coerceString,
944  parseLiteral: function parseLiteral(valueNode) {
945    if (valueNode.kind !== kinds["a" /* Kind */].STRING) {
946      throw new GraphQLError["a" /* GraphQLError */]("String cannot represent a non string value: ".concat(Object(printer["a" /* print */])(valueNode)), valueNode);
947    }
948
949    return valueNode.value;
950  }
951});
952
953function serializeBoolean(outputValue) {
954  var coercedValue = serializeObject(outputValue);
955
956  if (typeof coercedValue === 'boolean') {
957    return coercedValue;
958  }
959
960  if (Object(polyfills_isFinite["a" /* default */])(coercedValue)) {
961    return coercedValue !== 0;
962  }
963
964  throw new GraphQLError["a" /* GraphQLError */]("Boolean cannot represent a non boolean value: ".concat(Object(inspect["a" /* default */])(coercedValue)));
965}
966
967function coerceBoolean(inputValue) {
968  if (typeof inputValue !== 'boolean') {
969    throw new GraphQLError["a" /* GraphQLError */]("Boolean cannot represent a non boolean value: ".concat(Object(inspect["a" /* default */])(inputValue)));
970  }
971
972  return inputValue;
973}
974
975var GraphQLBoolean = new definition["g" /* GraphQLScalarType */]({
976  name: 'Boolean',
977  description: 'The `Boolean` scalar type represents `true` or `false`.',
978  serialize: serializeBoolean,
979  parseValue: coerceBoolean,
980  parseLiteral: function parseLiteral(valueNode) {
981    if (valueNode.kind !== kinds["a" /* Kind */].BOOLEAN) {
982      throw new GraphQLError["a" /* GraphQLError */]("Boolean cannot represent a non boolean value: ".concat(Object(printer["a" /* print */])(valueNode)), valueNode);
983    }
984
985    return valueNode.value;
986  }
987});
988
989function serializeID(outputValue) {
990  var coercedValue = serializeObject(outputValue);
991
992  if (typeof coercedValue === 'string') {
993    return coercedValue;
994  }
995
996  if (polyfills_isInteger(coercedValue)) {
997    return String(coercedValue);
998  }
999
1000  throw new GraphQLError["a" /* GraphQLError */]("ID cannot represent value: ".concat(Object(inspect["a" /* default */])(outputValue)));
1001}
1002
1003function coerceID(inputValue) {
1004  if (typeof inputValue === 'string') {
1005    return inputValue;
1006  }
1007
1008  if (polyfills_isInteger(inputValue)) {
1009    return inputValue.toString();
1010  }
1011
1012  throw new GraphQLError["a" /* GraphQLError */]("ID cannot represent value: ".concat(Object(inspect["a" /* default */])(inputValue)));
1013}
1014
1015var GraphQLID = new definition["g" /* GraphQLScalarType */]({
1016  name: 'ID',
1017  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.',
1018  serialize: serializeID,
1019  parseValue: coerceID,
1020  parseLiteral: function parseLiteral(valueNode) {
1021    if (valueNode.kind !== kinds["a" /* Kind */].STRING && valueNode.kind !== kinds["a" /* Kind */].INT) {
1022      throw new GraphQLError["a" /* GraphQLError */]('ID cannot represent a non-string and non-integer value: ' + Object(printer["a" /* print */])(valueNode), valueNode);
1023    }
1024
1025    return valueNode.value;
1026  }
1027});
1028var specifiedScalarTypes = Object.freeze([GraphQLString, GraphQLInt, GraphQLFloat, GraphQLBoolean, GraphQLID]);
1029function isSpecifiedScalarType(type) {
1030  return specifiedScalarTypes.some(function (_ref) {
1031    var name = _ref.name;

1032    return type.name === name;
1033  });
1034}
1035
1036
1037/***/ }),
1038
1039/***/ "1KsK":
1040/***/ (function(module, exports, __webpack_require__) {
1041
1042"use strict";
1043
1044
1045var toStr = Object.prototype.toString;
1046
1047module.exports = function isArguments(value) {
1048	var str = toStr.call(value);
1049	var isArgs = str === '[object Arguments]';
1050	if (!isArgs) {
1051		isArgs = str !== '[object Array]' &&
1052			value !== null &&
1053			typeof value === 'object' &&
1054			typeof value.length === 'number' &&
1055			value.length >= 0 &&
1056			toStr.call(value.callee) === '[object Function]';
1057	}
1058	return isArgs;
1059};
1060
1061
1062/***/ }),
1063
1064/***/ "1QEH":
1065/***/ (function(__webpack_module__, __webpack_exports__, __webpack_require__) {
1066
1067"use strict";
1068/* eslint-disable no-redeclare */
1069// $FlowFixMe[name-already-bound] workaround for: https://github.com/facebook/flow/issues/4441
1070var objectValues = Object.values || function (obj) {
1071  return Object.keys(obj).map(function (key) {
1072    return obj[key];
1073  });
1074};
1075
1076/* harmony default export */ __webpack_exports__["a"] = (objectValues);
1077
1078
1079/***/ }),
1080
1081/***/ "1Wi7":
1082/***/ (function(module, __webpack_exports__, __webpack_require__) {
1083
1084"use strict";
1085__webpack_require__.r(__webpack_exports__);
1086/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "swapCase", function() { return swapCase; });
1087function swapCase(input) {
1088    var result = "";
1089    for (var i = 0; i < input.length; i++) {
1090        var lower = input[i].toLowerCase();
1091        result += input[i] === lower ? input[i].toUpperCase() : lower;
1092    }
1093    return result;
1094}
1095//# sourceMappingURL=index.js.map
1096
1097/***/ }),
1098
1099/***/ "1fn3":
1100/***/ (function(module, exports, __webpack_require__) {
1101
1102"use strict";
1103
1104
1105// http://262.ecma-international.org/5.1/#sec-9.1
1106
1107module.exports = __webpack_require__("Lxf3");
1108
1109
1110/***/ }),
1111
1112/***/ "1seS":
1113/***/ (function(module, exports, __webpack_require__) {
1114
1115"use strict";
1116
1117
1118var slice = Array.prototype.slice;
1119var isArgs = __webpack_require__("1KsK");
1120
1121var origKeys = Object.keys;
1122var keysShim = origKeys ? function keys(o) { return origKeys(o); } : __webpack_require__("sYn3");
1123
1124var originalKeys = Object.keys;
1125
1126keysShim.shim = function shimObjectKeys() {
1127	if (Object.keys) {
1128		var keysWorksWithArguments = (function () {
1129			// Safari 5.0 bug
1130			var args = Object.keys(arguments);
1131			return args && args.length === arguments.length;
1132		}(1, 2));
1133		if (!keysWorksWithArguments) {
1134			Object.keys = function keys(object) { // eslint-disable-line func-name-matching
1135				if (isArgs(object)) {
1136					return originalKeys(slice.call(object));
1137				}
1138				return originalKeys(object);
1139			};
1140		}
1141	} else {
1142		Object.keys = keysShim;
1143	}
1144	return Object.keys || keysShim;
1145};
1146
1147module.exports = keysShim;
1148
1149
1150/***/ }),
1151
1152/***/ "2C6G":
1153/***/ (function(__webpack_module__, __webpack_exports__, __webpack_require__) {
1154
1155"use strict";
1156/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return invariant; });
1157function invariant(condition, message) {
1158  var booleanCondition = Boolean(condition); // istanbul ignore else (See transformation done in './resources/inlineInvariant.js')
1159
1160  if (!booleanCondition) {
1161    throw new Error(message != null ? message : 'Unexpected invariant triggered.');
1162  }
1163}
1164
1165
1166/***/ }),
1167
1168/***/ "2Fve":
1169/***/ (function(__webpack_module__, __webpack_exports__, __webpack_require__) {
1170
1171"use strict";
1172/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return SYMBOL_ITERATOR; });
1173/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return SYMBOL_ASYNC_ITERATOR; });
1174/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return SYMBOL_TO_STRING_TAG; });
1175// In ES2015 (or a polyfilled) environment, this will be Symbol.iterator
1176// istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')
1177var SYMBOL_ITERATOR = typeof Symbol === 'function' && Symbol.iterator != null ? Symbol.iterator : '@@iterator'; // In ES2017 (or a polyfilled) environment, this will be Symbol.asyncIterator
1178// istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')
1179
1180var SYMBOL_ASYNC_ITERATOR = typeof Symbol === 'function' && Symbol.asyncIterator != null ? Symbol.asyncIterator : '@@asyncIterator'; // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')
1181
1182var SYMBOL_TO_STRING_TAG = typeof Symbol === 'function' && Symbol.toStringTag != null ? Symbol.toStringTag : '@@toStringTag';
1183
1184
1185/***/ }),
1186
1187/***/ "3HNt":
1188/***/ (function(__webpack_module__, __webpack_exports__, __webpack_require__) {
1189
1190"use strict";
1191/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return astFromValue; });
1192/* harmony import */ var _polyfills_isFinite_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("lAJ0");
1193/* harmony import */ var _polyfills_objectValues_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("1QEH");
1194/* harmony import */ var _jsutils_inspect_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("rWdj");
1195/* harmony import */ var _jsutils_invariant_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("2C6G");
1196/* harmony import */ var _jsutils_isObjectLike_mjs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("zpYP");
1197/* harmony import */ var _jsutils_safeArrayFrom_mjs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("k9pe");
1198/* harmony import */ var _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("/jXB");
1199/* harmony import */ var _type_scalars_mjs__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__("19Hc");
1200/* harmony import */ var _type_definition_mjs__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__("axIb");
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210/**
1211 * Produces a GraphQL Value AST given a JavaScript object.
1212 * Function will match JavaScript/JSON values to GraphQL AST schema format
1213 * by using suggested GraphQLInputType. For example:
1214 *
1215 *     astFromValue("value", GraphQLString)
1216 *
1217 * A GraphQL type must be provided, which will be used to interpret different
1218 * JavaScript values.
1219 *
1220 * | JSON Value    | GraphQL Value        |
1221 * | ------------- | -------------------- |
1222 * | Object        | Input Object         |
1223 * | Array         | List                 |
1224 * | Boolean       | Boolean              |
1225 * | String        | String / Enum Value  |
1226 * | Number        | Int / Float          |
1227 * | Mixed         | Enum Value           |

1228 * | null          | NullValue            |
1229 *
1230 */
1231
1232function astFromValue(value, type) {
1233  if (Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_8__[/* isNonNullType */ "L"])(type)) {
1234    var astValue = astFromValue(value, type.ofType);
1235
1236    if ((astValue === null || astValue === void 0 ? void 0 : astValue.kind) === _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_6__[/* Kind */ "a"].NULL) {
1237      return null;
1238    }
1239
1240    return astValue;
1241  } // only explicit null, not undefined, NaN
1242
1243
1244  if (value === null) {
1245    return {
1246      kind: _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_6__[/* Kind */ "a"].NULL
1247    };
1248  } // undefined
1249
1250
1251  if (value === undefined) {
1252    return null;
1253  } // Convert JavaScript array to GraphQL list. If the GraphQLType is a list, but
1254  // the value is not an array, convert the value using the list's item type.
1255
1256
1257  if (Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_8__[/* isListType */ "J"])(type)) {
1258    var itemType = type.ofType;
1259    var items = Object(_jsutils_safeArrayFrom_mjs__WEBPACK_IMPORTED_MODULE_5__[/* default */ "a"])(value);
1260
1261    if (items != null) {
1262      var valuesNodes = [];
1263
1264      for (var _i2 = 0; _i2 < items.length; _i2++) {
1265        var item = items[_i2];
1266        var itemNode = astFromValue(item, itemType);
1267
1268        if (itemNode != null) {
1269          valuesNodes.push(itemNode);
1270        }
1271      }
1272
1273      return {
1274        kind: _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_6__[/* Kind */ "a"].LIST,
1275        values: valuesNodes
1276      };
1277    }
1278
1279    return astFromValue(value, itemType);
1280  } // Populate the fields of the input object by creating ASTs from each value
1281  // in the JavaScript object according to the fields in the input type.
1282
1283
1284  if (Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_8__[/* isInputObjectType */ "F"])(type)) {
1285    if (!Object(_jsutils_isObjectLike_mjs__WEBPACK_IMPORTED_MODULE_4__[/* default */ "a"])(value)) {
1286      return null;
1287    }
1288
1289    var fieldNodes = [];
1290
1291    for (var _i4 = 0, _objectValues2 = Object(_polyfills_objectValues_mjs__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(type.getFields()); _i4 < _objectValues2.length; _i4++) {
1292      var field = _objectValues2[_i4];
1293      var fieldValue = astFromValue(value[field.name], field.type);
1294
1295      if (fieldValue) {
1296        fieldNodes.push({
1297          kind: _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_6__[/* Kind */ "a"].OBJECT_FIELD,
1298          name: {
1299            kind: _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_6__[/* Kind */ "a"].NAME,
1300            value: field.name
1301          },
1302          value: fieldValue
1303        });
1304      }
1305    }
1306
1307    return {
1308      kind: _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_6__[/* Kind */ "a"].OBJECT,
1309      fields: fieldNodes
1310    };
1311  } // istanbul ignore else (See: 'https://github.com/graphql/graphql-js/issues/2618')
1312
1313
1314  if (Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_8__[/* isLeafType */ "I"])(type)) {
1315    // Since value is an internally represented value, it must be serialized
1316    // to an externally represented value before converting into an AST.
1317    var serialized = type.serialize(value);
1318
1319    if (serialized == null) {
1320      return null;
1321    } // Others serialize based on their corresponding JavaScript scalar types.
1322
1323
1324    if (typeof serialized === 'boolean') {
1325      return {
1326        kind: _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_6__[/* Kind */ "a"].BOOLEAN,
1327        value: serialized
1328      };
1329    } // JavaScript numbers can be Int or Float values.
1330
1331
1332    if (typeof serialized === 'number' && Object(_polyfills_isFinite_mjs__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(serialized)) {
1333      var stringNum = String(serialized);
1334      return integerStringRegExp.test(stringNum) ? {
1335        kind: _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_6__[/* Kind */ "a"].INT,
1336        value: stringNum
1337      } : {
1338        kind: _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_6__[/* Kind */ "a"].FLOAT,
1339        value: stringNum
1340      };
1341    }
1342
1343    if (typeof serialized === 'string') {
1344      // Enum types use Enum literals.
1345      if (Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_8__[/* isEnumType */ "E"])(type)) {
1346        return {
1347          kind: _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_6__[/* Kind */ "a"].ENUM,
1348          value: serialized
1349        };
1350      } // ID types can use Int literals.
1351
1352
1353      if (type === _type_scalars_mjs__WEBPACK_IMPORTED_MODULE_7__[/* GraphQLID */ "c"] && integerStringRegExp.test(serialized)) {
1354        return {
1355          kind: _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_6__[/* Kind */ "a"].INT,
1356          value: serialized
1357        };
1358      }
1359
1360      return {
1361        kind: _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_6__[/* Kind */ "a"].STRING,
1362        value: serialized
1363      };
1364    }
1365
1366    throw new TypeError("Cannot convert value to AST: ".concat(Object(_jsutils_inspect_mjs__WEBPACK_IMPORTED_MODULE_2__[/* default */ "a"])(serialized), "."));
1367  } // istanbul ignore next (Not reachable. All possible input types have been considered)
1368
1369
1370   false || Object(_jsutils_invariant_mjs__WEBPACK_IMPORTED_MODULE_3__[/* default */ "a"])(0, 'Unexpected input type: ' + Object(_jsutils_inspect_mjs__WEBPACK_IMPORTED_MODULE_2__[/* default */ "a"])(type));
1371}
1372/**
1373 * IntValue:

1374 *   - NegativeSign? 0
1375 *   - NegativeSign? NonZeroDigit ( Digit+ )?
1376 */
1377
1378var integerStringRegExp = /^-?(?:0|[1-9][0-9]*)$/;
1379
1380
1381/***/ }),
1382
1383/***/ "3SWA":
1384/***/ (function(module, exports, __webpack_require__) {
1385
1386"use strict";
1387
1388
1389var GetIntrinsic = __webpack_require__("AM7I");
1390
1391var $TypeError = GetIntrinsic('%TypeError%');
1392
1393// http://262.ecma-international.org/5.1/#sec-9.10
1394
1395module.exports = function CheckObjectCoercible(value, optMessage) {
1396	if (value == null) {
1397		throw new $TypeError(optMessage || ('Cannot call method on ' + value));
1398	}
1399	return value;
1400};
1401
1402
1403/***/ }),
1404
1405/***/ "3Tnt":
1406/***/ (function(module, exports, __webpack_require__) {
1407
1408"use strict";
1409
1410
1411var isRelative = __webpack_require__("WAOt");
1412var isWindows = __webpack_require__("Ndee");
1413
1414/**
1415 * Expose `isAbsolute`
1416 */
1417
1418module.exports = isAbsolute;
1419
1420/**
1421 * Returns true if a file path is absolute.
1422 *
1423 * @param  {String} `fp`
1424 * @return {Boolean}
1425 */
1426
1427function isAbsolute(fp) {
1428  if (typeof fp !== 'string') {
1429    throw new TypeError('isAbsolute expects a string.');
1430  }
1431  return isWindows() ? isAbsolute.win32(fp) : isAbsolute.posix(fp);
1432}
1433
1434/**
1435 * Test posix paths.
1436 */
1437
1438isAbsolute.posix = function posixPath(fp) {
1439  return fp.charAt(0) === '/';
1440};
1441
1442/**
1443 * Test windows paths.
1444 */
1445
1446isAbsolute.win32 = function win32(fp) {
1447  if (/[a-z]/i.test(fp.charAt(0)) && fp.charAt(1) === ':' && fp.charAt(2) === '\\') {
1448    return true;
1449  }
1450  // Microsoft Azure absolute filepath
1451  if (fp.slice(0, 2) === '\\\\') {
1452    return true;
1453  }
1454  return !isRelative(fp);
1455};
1456
1457
1458/***/ }),
1459
1460/***/ "3XYS":
1461/***/ (function(module, exports, __webpack_require__) {
1462
1463"use strict";
1464
1465Object.defineProperty(exports, "__esModule", { value: true });
1466exports.isLowerCase = exports.isUpperCase = exports.upperCaseFirst = exports.localeUpperCase = exports.upperCase = exports.titleCase = exports.swapCase = exports.spongeCase = exports.lowerCaseFirst = exports.localeLowerCase = exports.lowerCase = exports.snakeCase = exports.sentenceCase = exports.pathCase = exports.pascalCase = exports.paramCase = exports.noCase = exports.headerCase = exports.dotCase = exports.constantCase = exports.capitalCase = exports.camelCase = void 0;
1467var changeCase = __webpack_require__("8LIU");
1468var lowerCase1 = __webpack_require__("Wyu6");
1469var lowerCaseFirst1 = __webpack_require__("U/hW");
1470var spongeCase1 = __webpack_require__("QTt7");
1471var swapCase1 = __webpack_require__("1Wi7");
1472var titleCase1 = __webpack_require__("Mooo");
1473var upperCase1 = __webpack_require__("9bHt");
1474var upperCaseFirst1 = __webpack_require__("x3m3");
1475var isUpperCase1 = __webpack_require__("9hl7");
1476var isLowerCase1 = __webpack_require__("5lwn");
1477// Core
1478exports.camelCase = changeCase.camelCase;
1479exports.capitalCase = changeCase.capitalCase;
1480exports.constantCase = changeCase.constantCase;
1481exports.dotCase = changeCase.dotCase;
1482exports.headerCase = changeCase.headerCase;
1483exports.noCase = changeCase.noCase;
1484exports.paramCase = changeCase.paramCase;
1485exports.pascalCase = changeCase.pascalCase;
1486exports.pathCase = changeCase.pathCase;
1487exports.sentenceCase = changeCase.sentenceCase;
1488exports.snakeCase = changeCase.snakeCase;
1489// Extended
1490exports.lowerCase = lowerCase1.lowerCase;
1491exports.localeLowerCase = lowerCase1.localeLowerCase;
1492exports.lowerCaseFirst = lowerCaseFirst1.lowerCaseFirst;
1493exports.spongeCase = spongeCase1.spongeCase;
1494exports.swapCase = swapCase1.swapCase;
1495exports.titleCase = titleCase1.titleCase;
1496exports.upperCase = upperCase1.upperCase;
1497exports.localeUpperCase = upperCase1.localeUpperCase;
1498exports.upperCaseFirst = upperCaseFirst1.upperCaseFirst;
1499exports.isUpperCase = isUpperCase1.isUpperCase;
1500exports.isLowerCase = isLowerCase1.isLowerCase;
1501
1502
1503/***/ }),
1504
1505/***/ "3aNz":
1506/***/ (function(module, exports, __webpack_require__) {
1507
1508"use strict";
1509
1510
1511var define = __webpack_require__("82c2");
1512var callBind = __webpack_require__("PrET");
1513
1514var implementation = __webpack_require__("HYxC");
1515var getPolyfill = __webpack_require__("l1+S");
1516var polyfill = getPolyfill();
1517var shim = __webpack_require__("yCJC");
1518
1519var boundFlatMap = callBind(polyfill);
1520
1521define(boundFlatMap, {
1522	getPolyfill: getPolyfill,
1523	implementation: implementation,
1524	shim: shim
1525});
1526
1527module.exports = boundFlatMap;
1528
1529
1530/***/ }),
1531
1532/***/ "3lu9":
1533/***/ (function(module, exports, __webpack_require__) {
1534
1535"use strict";
1536
1537
1538var GetIntrinsic = __webpack_require__("AM7I");
1539var callBound = __webpack_require__("VF6F");
1540
1541var $TypeError = GetIntrinsic('%TypeError%');
1542
1543var IsArray = __webpack_require__("plxK");
1544
1545var $apply = GetIntrinsic('%Reflect.apply%', true) || callBound('%Function.prototype.apply%');
1546
1547// https://ecma-international.org/ecma-262/6.0/#sec-call
1548
1549module.exports = function Call(F, V) {
1550	var argumentsList = arguments.length > 2 ? arguments[2] : [];
1551	if (!IsArray(argumentsList)) {
1552		throw new $TypeError('Assertion failed: optional `argumentsList`, if provided, must be a List');
1553	}
1554	return $apply(F, V, argumentsList);
1555};
1556
1557
1558/***/ }),
1559
1560/***/ "3vMM":
1561/***/ (function(__webpack_module__, __webpack_exports__, __webpack_require__) {
1562
1563"use strict";
1564/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return printSchema; });
1565/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return printIntrospectionSchema; });
1566/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return printType; });
1567/* harmony import */ var _polyfills_objectValues_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("1QEH");
1568/* harmony import */ var _jsutils_inspect_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("rWdj");
1569/* harmony import */ var _jsutils_invariant_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("2C6G");
1570/* harmony import */ var _language_printer_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("dQau");
1571/* harmony import */ var _language_blockString_mjs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("BLR7");
1572/* harmony import */ var _type_introspection_mjs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("LViu");
1573/* harmony import */ var _type_scalars_mjs__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("19Hc");
1574/* harmony import */ var _type_directives_mjs__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__("4suF");
1575/* harmony import */ var _type_definition_mjs__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__("axIb");
1576/* harmony import */ var _astFromValue_mjs__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__("3HNt");
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588/**
1589 * Accepts options as a second argument:
1590 *
1591 *    - commentDescriptions:
1592 *        Provide true to use preceding comments as the description.
1593 *
1594 */
1595function printSchema(schema, options) {
1596  return printFilteredSchema(schema, function (n) {
1597    return !Object(_type_directives_mjs__WEBPACK_IMPORTED_MODULE_7__[/* isSpecifiedDirective */ "i"])(n);
1598  }, isDefinedType, options);
1599}
1600function printIntrospectionSchema(schema, options) {
1601  return printFilteredSchema(schema, _type_directives_mjs__WEBPACK_IMPORTED_MODULE_7__[/* isSpecifiedDirective */ "i"], _type_introspection_mjs__WEBPACK_IMPORTED_MODULE_5__[/* isIntrospectionType */ "n"], options);
1602}
1603
1604function isDefinedType(type) {
1605  return !Object(_type_scalars_mjs__WEBPACK_IMPORTED_MODULE_6__[/* isSpecifiedScalarType */ "f"])(type) && !Object(_type_introspection_mjs__WEBPACK_IMPORTED_MODULE_5__[/* isIntrospectionType */ "n"])(type);
1606}
1607
1608function printFilteredSchema(schema, directiveFilter, typeFilter, options) {
1609  var directives = schema.getDirectives().filter(directiveFilter);
1610  var types = Object(_polyfills_objectValues_mjs__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(schema.getTypeMap()).filter(typeFilter);
1611  return [printSchemaDefinition(schema)].concat(directives.map(function (directive) {
1612    return printDirective(directive, options);
1613  }), types.map(function (type) {
1614    return printType(type, options);
1615  }

1615)).filter(Boolean).join('\n\n') + '\n';
1616}
1617
1618function printSchemaDefinition(schema) {
1619  if (schema.description == null && isSchemaOfCommonNames(schema)) {
1620    return;
1621  }
1622
1623  var operationTypes = [];
1624  var queryType = schema.getQueryType();
1625
1626  if (queryType) {
1627    operationTypes.push("  query: ".concat(queryType.name));
1628  }
1629
1630  var mutationType = schema.getMutationType();
1631
1632  if (mutationType) {
1633    operationTypes.push("  mutation: ".concat(mutationType.name));
1634  }
1635
1636  var subscriptionType = schema.getSubscriptionType();
1637
1638  if (subscriptionType) {
1639    operationTypes.push("  subscription: ".concat(subscriptionType.name));
1640  }
1641
1642  return printDescription({}, schema) + "schema {\n".concat(operationTypes.join('\n'), "\n}");
1643}
1644/**
1645 * GraphQL schema define root types for each type of operation. These types are
1646 * the same as any other type and can be named in any manner, however there is
1647 * a common naming convention:
1648 *
1649 *   schema {
1650 *     query: Query
1651 *     mutation: Mutation
1652 *   }
1653 *
1654 * When using this naming convention, the schema description can be omitted.
1655 */
1656
1657
1658function isSchemaOfCommonNames(schema) {
1659  var queryType = schema.getQueryType();
1660
1661  if (queryType && queryType.name !== 'Query') {
1662    return false;
1663  }
1664
1665  var mutationType = schema.getMutationType();
1666
1667  if (mutationType && mutationType.name !== 'Mutation') {
1668    return false;
1669  }
1670
1671  var subscriptionType = schema.getSubscriptionType();
1672
1673  if (subscriptionType && subscriptionType.name !== 'Subscription') {
1674    return false;
1675  }
1676
1677  return true;
1678}
1679
1680function printType(type, options) {
1681  if (Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_8__[/* isScalarType */ "R"])(type)) {
1682    return printScalar(type, options);
1683  }
1684
1685  if (Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_8__[/* isObjectType */ "N"])(type)) {
1686    return printObject(type, options);
1687  }
1688
1689  if (Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_8__[/* isInterfaceType */ "H"])(type)) {
1690    return printInterface(type, options);
1691  }
1692
1693  if (Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_8__[/* isUnionType */ "T"])(type)) {
1694    return printUnion(type, options);
1695  }
1696
1697  if (Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_8__[/* isEnumType */ "E"])(type)) {
1698    return printEnum(type, options);
1699  } // istanbul ignore else (See: 'https://github.com/graphql/graphql-js/issues/2618')
1700
1701
1702  if (Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_8__[/* isInputObjectType */ "F"])(type)) {
1703    return printInputObject(type, options);
1704  } // istanbul ignore next (Not reachable. All possible types have been considered)
1705
1706
1707   false || Object(_jsutils_invariant_mjs__WEBPACK_IMPORTED_MODULE_2__[/* default */ "a"])(0, 'Unexpected type: ' + Object(_jsutils_inspect_mjs__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(type));
1708}
1709
1710function printScalar(type, options) {
1711  return printDescription(options, type) + "scalar ".concat(type.name) + printSpecifiedByUrl(type);
1712}
1713
1714function printImplementedInterfaces(type) {
1715  var interfaces = type.getInterfaces();
1716  return interfaces.length ? ' implements ' + interfaces.map(function (i) {
1717    return i.name;
1718  }).join(' & ') : '';
1719}
1720
1721function printObject(type, options) {
1722  return printDescription(options, type) + "type ".concat(type.name) + printImplementedInterfaces(type) + printFields(options, type);
1723}
1724
1725function printInterface(type, options) {
1726  return printDescription(options, type) + "interface ".concat(type.name) + printImplementedInterfaces(type) + printFields(options, type);
1727}
1728
1729function printUnion(type, options) {
1730  var types = type.getTypes();
1731  var possibleTypes = types.length ? ' = ' + types.join(' | ') : '';
1732  return printDescription(options, type) + 'union ' + type.name + possibleTypes;
1733}
1734
1735function printEnum(type, options) {
1736  var values = type.getValues().map(function (value, i) {
1737    return printDescription(options, value, '  ', !i) + '  ' + value.name + printDeprecated(value.deprecationReason);
1738  });
1739  return printDescription(options, type) + "enum ".concat(type.name) + printBlock(values);
1740}
1741
1742function printInputObject(type, options) {
1743  var fields = Object(_polyfills_objectValues_mjs__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(type.getFields()).map(function (f, i) {
1744    return printDescription(options, f, '  ', !i) + '  ' + printInputValue(f);
1745  });
1746  return printDescription(options, type) + "input ".concat(type.name) + printBlock(fields);
1747}
1748
1749function printFields(options, type) {
1750  var fields = Object(_polyfills_objectValues_mjs__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(type.getFields()).map(function (f, i) {
1751    return printDescription(options, f, '  ', !i) + '  ' + f.name + printArgs(options, f.args, '  ') + ': ' + String(f.type) + printDeprecated(f.deprecationReason);
1752  });
1753  return printBlock(fields);
1754}
1755
1756function printBlock(items) {
1757  return items.length !== 0 ? ' {\n' + items.join('\n') + '\n}' : '';
1758}
1759
1760function printArgs(options, args) {
1761  var indentation = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
1762
1763  if (args.length === 0) {
1764    return '';
1765  } // If every arg does not have a description, print them on one line.
1766
1767
1768  if (args.every(function (arg) {
1769    return !arg.description;
1770  })) {
1771    return '(' + args.map(printInputValue).join(', ') + ')';
1772  }
1773
1774  return '(\n' + args.map(function (arg, i) {
1775    return printDescription(options, arg, '  ' + indentation, !i) + '  ' + indentation + printInputValue(arg);
1776  }).join('\n') + '\n' + indentation + ')';
1777}
1778
1779function printInputValue(arg) {
1780  var defaultAST = Object(_astFromValue_mjs__WEBPACK_IMPORTED_MODULE_9__[/* astFromValue */ "a"])(arg.defaultValue, arg.type);
1781  var argDecl = arg.name + ': ' + String(arg.type);
1782
1783  if (defaultAST) {
1784    argDecl += " = ".concat(Object(_language_printer_mjs__WEBPACK_IMPORTED_MODULE_3__[/* print */ "a"])(defaultAST));
1785  }
1786
1787  return argDecl + printDeprecated(arg.deprecationReason);
1788}
1789
1790function printDirective(directive, options) {
1791  return printDescription(options, directive) + 'directive @' + directive.name + printArgs(options, directive.args) + (directive.isRepeatable ? ' repeatable' : '') + ' on ' + directive.locations.join(' | ');
1792}
1793
1794function printDeprecated(reason) {
1795  if (reason == null) {
1796    return '';
1797  }
1798
1799  var reasonAST = Object(_astFromValue_mjs__WEBPACK_IMPORTED_MODULE_9__[/* astFromValue */ "a"])(reason, _type_scalars_mjs__WEBPACK_IMPORTED_MODULE_6__[/* GraphQLString */ "e"]);
1800
1801  if (reasonAST && reason !== _type_directives_mjs__WEBPACK_IMPORTED_MODULE_7__[/* DEFAULT_DEPRECATION_REASON */ "a"]) {
1802    return ' @deprecated(reason: ' + Object(_language_printer_mjs__WEBPACK_IMPORTED_MODULE_3__[/* print */ "a"])(reasonAST) + ')';
1803  }
1804
1805  return ' @deprecated';
1806}
1807
1808function printSpecifiedByUrl(scalar) {
1809  if (scalar.specifiedByUrl == null) {
1810    return '';
1811  }
1812
1813  var url = scalar.specifiedByUrl;
1814  var urlAST = Object(_astFromValue_mjs__WEBPACK_IMPORTED_MODULE_9__[/* astFromValue */ "a"])(url, _type_scalars_mjs__WEBPACK_IMPORTED_MODULE_6__[/* GraphQLString */ "e"]);
1815  urlAST || Object(_jsutils_invariant_mjs__WEBPACK_IMPORTED_MODULE_2__[/* default */ "a"])(0, 'Unexpected null value returned from `astFromValue` for specifiedByUrl');
1816  return ' @specifiedBy(url: ' + Object(_language_printer_mjs__WEBPACK_IMPORTED_MODULE_3__[/* print */ "a"])(urlAST) + ')';
1817}
1818
1819function printDescription(options, def) {
1820  var indentation = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
1821  var firstInBlock = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
1822  var description = def.description;
1823
1824  if (description == null) {
1825    return '';
1826  }
1827
1828  if ((options === null || options === void 0 ? void 0 : options.commentDescriptions) === true) {
1829    return printDescriptionWithComments(description, indentation, firstInBlock);
1830  }
1831
1832  var preferMultipleLines = description.length > 70;
1833  var blockString = Object(_language_blockString_mjs__WEBPACK_IMPORTED_MODULE_4__[/* printBlockString */ "c"])(description, '', preferMultipleLines);
1834  var prefix = indentation && !firstInBlock ? '\n' + indentation : indentation;
1835  return prefix + blockString.replace(/\n/g, '\n' + indentation) + '\n';
1836}
1837
1838function printDescriptionWithComments(description, indentation, firstInBlock) {
1839  var prefix = indentation && !firstInBlock ? '\n' : '';
1840  var comment = description.split('\n').map(function (line) {
1841    return indentation + (line !== '' ? '# ' + line : '#');
1842  }).join('\n');
1843  return prefix + comment + '\n';
1844}
1845
1846
1847/***/ }),
1848
1849/***/ "4RMZ":
1850/***/ (function(__webpack_module__, __webpack_exports__, __webpack_require__) {
1851
1852"use strict";
1853/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return TypeInfo; });
1854/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return visitWithTypeInfo; });
1855/* harmony import */ var _polyfills_find_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("1/U3");
1856/* harmony import */ var _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("/jXB");
1857/* harmony import */ var _language_ast_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("klf5");
1858/* harmony import */ var _language_visitor_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("L2ys");
1859/* harmony import */ var _type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("axIb");
1860/* harmony import */ var _type_introspection_mjs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("LViu");
1861/* harmony import */ var _typeFromAST_mjs__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("umOc");
1862
1863
1864
1865
1866
1867
1868
1869/**
1870 * TypeInfo is a utility class which, given a GraphQL schema, can keep track
1871 * of the current field and type definitions at any point in a GraphQL document
1872 * AST during a recursive descent by calling `enter(node)` and `leave(node)`.
1873 */
1874
1875var TypeInfo = /*#__PURE__*/function () {
1876  function TypeInfo(schema, // NOTE: this experimental optional second parameter is only needed in order
1877  // to support non-spec-compliant code bases. You should never need to use it.
1878  // It may disappear in the future.
1879  getFieldDefFn, // Initial type may be provided in rare cases to facilitate traversals
1880  // beginning somewhere other than documents.
1881  initialType) {
1882    this._schema = schema;
1883    this._typeStack = [];
1884    this._parentTypeStack = [];
1885    this._inputTypeStack = [];
1886    this._fieldDefStack = [];
1887    this._defaultValueStack = [];
1888    this._directive = null;
1889    this._argument = null;
1890    this._enumValue = null;
1891    this._getFieldDef = getFieldDefFn !== null && getFieldDefFn !== void 0 ? getFieldDefFn : getFieldDef;
1892
1893    if (initialType) {
1894      if (Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* isInputType */ "G"])(initialType)) {
1895        this._inputTypeStack.push(initialType);
1896      }
1897
1898      if (Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* isCompositeType */ "D"])(initialType)) {
1899        this._parentTypeStack.push(initialType);
1900      }
1901
1902      if (Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* isOutputType */ "O"])(initialType)) {
1903        this._typeStack.push(initialType);
1904      }
1905    }
1906  }
1907
1908  var _proto = TypeInfo.prototype;
1909
1910  _proto.getType = function getType() {
1911    if (this._typeStack.length > 0) {
1912      return this._typeStack[this._typeStack.length - 1];
1913    }
1914  };
1915
1916  _proto.getParentType = function getParentType() {
1917    if (this._parentTypeStack.length > 0) {
1918      return this._parentTypeStack[this._parentTypeStack.length - 1];
1919    }
1920  };
1921
1922  _proto.getInputType = function getInputType() {
1923    if (this._inputTypeStack.length > 0) {
1924      return this._inputTypeStack[this._inputTypeStack.length - 1];
1925    }
1926  };
1927
1928  _proto.getParentInputType = function getParentInputType() {
1929    if (this._inputTypeStack.length > 1) {
1930      return this._inputTypeStack[this._inputTypeStack.length - 2];
1931    }
1932  };
1933
1934  _proto.getFieldDef = function getFieldDef() {
1935    if (this._fieldDefStack.length > 0) {
1936      return this._fieldDefStack[this._fieldDefStack.length - 1];
1937    }
1938  };
1939
1940  _proto.getDefaultValue = function getDefaultValue() {
1941    if (this._defaultValueStack.length > 0) {
1942      return this._defaultValueStack[this._defaultValueStack.length - 1];
1943    }
1944  };
1945
1946  _proto.getDirective = function getDirective() {
1947    return this._directive;
1948  };
1949
1950  _proto.getArgument = function getArgument() {
1951    return this._argument;
1952  };
1953
1954  _proto.getEnumValue = function getEnumValue() {
1955    return this._enumValue;
1956  };
1957
1958  _proto.enter = function enter(node) {
1959    var schema = this._schema; // Note: many of the types below are explicitly typed as "mixed" to drop
1960    // any assumptions of a valid schema to ensure runtime types are properly
1961    // checked before continuing since TypeInfo is used as part of validation
1962    // which occurs before guarantees of schema and document validity.
1963
1964    switch (node.kind) {
1965      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].SELECTION_SET:
1966        {
1967          var namedType = Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* getNamedType */ "A"])(this.getType());
1968
1969          this._parentTypeStack.push(Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* isCompositeType */ "D"])(namedType) ? namedType : undefined);
1970
1971          break;
1972        }
1973
1974      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].FIELD:
1975        {
1976          var parentType = this.getParentType();
1977          var fieldDef;
1978          var fieldType;
1979
1980          if (parentType) {
1981            fieldDef = this._getFieldDef(schema, parentType, node);
1982
1983            if (fieldDef) {
1984              fieldType = fieldDef.type;
1985            }
1986          }
1987
1988          this._fieldDefStack.push(fieldDef);
1989
1990          this._typeStack.push(Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* isOutputType */ "O"])(fieldType) ? fieldType : undefined);
1991
1992          break;
1993        }
1994
1995      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].DIRECTIVE:
1996        this._directive = schema.getDirective(node.name.value);
1997        break;
1998
1999      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].OPERATION_DEFINITION:
2000        {
2001          var type;
2002
2003          switch (node.operation) {
2004            case 'query':
2005              type = schema.getQueryType();
2006              break;
2007
2008            case 'mutation':
2009              type = schema.getMutationType();
2010              break;
2011
2012            case 'subscription':
2013              type = schema.getSubscriptionType();
2014              break;
2015          }
2016
2017          this._typeStack.push(Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* isObjectType */ "N"])(type) ? type : undefined);
2018
2019          break;
2020        }
2021
2022      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].INLINE_FRAGMENT:
2023      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].FRAGMENT_DEFINITION:
2024        {
2025          var typeConditionAST = node.typeCondition;
2026          var outputType = typeConditionAST ? Object(_typeFromAST_mjs__WEBPACK_IMPORTED_MODULE_6__[/* typeFromAST */ "a"])(schema, typeConditionAST) : Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* getNamedType */ "A"])(this.getType());
2027
2028          this._typeStack.push(Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* isOutputType */ "O"])(outputType) ? outputType : undefined);
2029
2030          break;
2031        }
2032
2033      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].VARIABLE_DEFINITION:
2034        {
2035          var inputType = Object(_typeFromAST_mjs__WEBPACK_IMPORTED_MODULE_6__[/* typeFromAST */ "a"])(schema, node.type);
2036
2037          this._inputTypeStack.push(Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* isInputType */ "G"])(inputType) ? inputType : undefined);
2038
2039          break;
2040        }
2041
2042      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].ARGUMENT:
2043        {
2044          var _this$getDirective;
2045
2046          var argDef;
2047          var argType;
2048          var fieldOrDirective = (_this$getDirective = this.getDirective()) !== null && _this$getDirective !== void 0 ? _this$getDirective : this.getFieldDef();
2049
2050          if (fieldOrDirective) {
2051            argDef = Object(_polyfills_find_mjs__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(fieldOrDirective.args, function (arg) {
2052              return arg.name === node.name.value;
2053            });
2054
2055            if (argDef) {
2056              argType

2056 = argDef.type;
2057            }
2058          }
2059
2060          this._argument = argDef;
2061
2062          this._defaultValueStack.push(argDef ? argDef.defaultValue : undefined);
2063
2064          this._inputTypeStack.push(Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* isInputType */ "G"])(argType) ? argType : undefined);
2065
2066          break;
2067        }
2068
2069      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].LIST:
2070        {
2071          var listType = Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* getNullableType */ "B"])(this.getInputType());
2072          var itemType = Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* isListType */ "J"])(listType) ? listType.ofType : listType; // List positions never have a default value.
2073
2074          this._defaultValueStack.push(undefined);
2075
2076          this._inputTypeStack.push(Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* isInputType */ "G"])(itemType) ? itemType : undefined);
2077
2078          break;
2079        }
2080
2081      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].OBJECT_FIELD:
2082        {
2083          var objectType = Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* getNamedType */ "A"])(this.getInputType());
2084          var inputFieldType;
2085          var inputField;
2086
2087          if (Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* isInputObjectType */ "F"])(objectType)) {
2088            inputField = objectType.getFields()[node.name.value];
2089
2090            if (inputField) {
2091              inputFieldType = inputField.type;
2092            }
2093          }
2094
2095          this._defaultValueStack.push(inputField ? inputField.defaultValue : undefined);
2096
2097          this._inputTypeStack.push(Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* isInputType */ "G"])(inputFieldType) ? inputFieldType : undefined);
2098
2099          break;
2100        }
2101
2102      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].ENUM:
2103        {
2104          var enumType = Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* getNamedType */ "A"])(this.getInputType());
2105          var enumValue;
2106
2107          if (Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* isEnumType */ "E"])(enumType)) {
2108            enumValue = enumType.getValue(node.value);
2109          }
2110
2111          this._enumValue = enumValue;
2112          break;
2113        }
2114    }
2115  };
2116
2117  _proto.leave = function leave(node) {
2118    switch (node.kind) {
2119      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].SELECTION_SET:
2120        this._parentTypeStack.pop();
2121
2122        break;
2123
2124      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].FIELD:
2125        this._fieldDefStack.pop();
2126
2127        this._typeStack.pop();
2128
2129        break;
2130
2131      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].DIRECTIVE:
2132        this._directive = null;
2133        break;
2134
2135      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].OPERATION_DEFINITION:
2136      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].INLINE_FRAGMENT:
2137      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].FRAGMENT_DEFINITION:
2138        this._typeStack.pop();
2139
2140        break;
2141
2142      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].VARIABLE_DEFINITION:
2143        this._inputTypeStack.pop();
2144
2145        break;
2146
2147      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].ARGUMENT:
2148        this._argument = null;
2149
2150        this._defaultValueStack.pop();
2151
2152        this._inputTypeStack.pop();
2153
2154        break;
2155
2156      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].LIST:
2157      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].OBJECT_FIELD:
2158        this._defaultValueStack.pop();
2159
2160        this._inputTypeStack.pop();
2161
2162        break;
2163
2164      case _language_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__[/* Kind */ "a"].ENUM:
2165        this._enumValue = null;
2166        break;
2167    }
2168  };
2169
2170  return TypeInfo;
2171}();
2172/**
2173 * Not exactly the same as the executor's definition of getFieldDef, in this
2174 * statically evaluated environment we do not always have an Object type,
2175 * and need to handle Interface and Union types.
2176 */
2177
2178function getFieldDef(schema, parentType, fieldNode) {
2179  var name = fieldNode.name.value;
2180
2181  if (name === _type_introspection_mjs__WEBPACK_IMPORTED_MODULE_5__[/* SchemaMetaFieldDef */ "a"].name && schema.getQueryType() === parentType) {
2182    return _type_introspection_mjs__WEBPACK_IMPORTED_MODULE_5__[/* SchemaMetaFieldDef */ "a"];
2183  }
2184
2185  if (name === _type_introspection_mjs__WEBPACK_IMPORTED_MODULE_5__[/* TypeMetaFieldDef */ "c"].name && schema.getQueryType() === parentType) {
2186    return _type_introspection_mjs__WEBPACK_IMPORTED_MODULE_5__[/* TypeMetaFieldDef */ "c"];
2187  }
2188
2189  if (name === _type_introspection_mjs__WEBPACK_IMPORTED_MODULE_5__[/* TypeNameMetaFieldDef */ "d"].name && Ob

2189ject(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* isCompositeType */ "D"])(parentType)) {
2190    return _type_introspection_mjs__WEBPACK_IMPORTED_MODULE_5__[/* TypeNameMetaFieldDef */ "d"];
2191  }
2192
2193  if (Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* isObjectType */ "N"])(parentType) || Object(_type_definition_mjs__WEBPACK_IMPORTED_MODULE_4__[/* isInterfaceType */ "H"])(parentType)) {
2194    return parentType.getFields()[name];
2195  }
2196}
2197/**
2198 * Creates a new visitor instance which maintains a provided TypeInfo instance
2199 * along with visiting visitor.
2200 */
2201
2202
2203function visitWithTypeInfo(typeInfo, visitor) {
2204  return {
2205    enter: function enter(node) {
2206      typeInfo.enter(node);
2207      var fn = Object(_language_visitor_mjs__WEBPACK_IMPORTED_MODULE_3__[/* getVisitFn */ "b"])(visitor, node.kind,
2208      /* isLeaving */
2209      false);
2210
2211      if (fn) {
2212        var result = fn.apply(visitor, arguments);
2213
2214        if (result !== undefined) {
2215          typeInfo.leave(node);
2216
2217          if (Object(_language_ast_mjs__WEBPACK_IMPORTED_MODULE_2__[/* isNode */ "c"])(result)) {
2218            typeInfo.enter(result);
2219          }
2220        }
2221
2222        return result;
2223      }
2224    },
2225    leave: function leave(node) {
2226      var fn = Object(_language_visitor_mjs__WEBPACK_IMPORTED_MODULE_3__[/* getVisitFn */ "b"])(visitor, node.kind,
2227      /* isLeaving */
2228      true);
2229      var result;
2230
2231      if (fn) {
2232        result = fn.apply(visitor, arguments);
2233      }
2234
2235      typeInfo.leave(node);
2236      return result;
2237    }
2238  };
2239}
2240
2241
2242/***/ }),
2243
2244/***/ "4suF":
2245/***/ (function(__webpack_module__, __webpack_exports__, __webpack_require__) {
2246
2247"use strict";
2248/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return isDirective; });
2249/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return assertDirective; });
2250/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return GraphQLDirective; });
2251/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return GraphQLIncludeDirective; });
2252/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return GraphQLSkipDirective; });
2253/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return DEFAULT_DEPRECATION_REASON; });
2254/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return GraphQLDeprecatedDirective; });
2255/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return GraphQLSpecifiedByDirective; });
2256/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return specifiedDirectives; });
2257/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return isSpecifiedDirective; });
2258/* harmony import */ var _polyfills_objectEntries_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("Y/la");
2259/* harmony import */ var _polyfills_symbols_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("2Fve");
2260/* harmony import */ var _jsutils_inspect_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("rWdj");
2261/* harmony import */ var _jsutils_toObjMap_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("E9SJ");
2262/* harmony import */ var _jsutils_devAssert_mjs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("t3R0");
2263/* harmony import */ var _jsutils_instanceOf_mjs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("Mw0p");
2264/* harmony import */ var _jsutils_isObjectLike_mjs__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("zpYP");
2265/* harmony import */ var _jsutils_defineInspect_mjs__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__("+dZ+");
2266/* harmony import */ var _language_directiveLocation_mjs__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__("F8X2");
2267/* harmony import */ var _scalars_mjs__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__("19Hc");
2268/* harmony import */ var _definition_mjs__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__("axIb");
2269function _defineProperties(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); } }
2270
2271function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284/**
2285 * Test if the given value is a GraphQL directive.
2286 */
2287
2288// eslint-disable-next-line no-redeclare
2289function isDirective(directive) {
2290  return Object(_jsutils_instanceOf_mjs__WEBPACK_IMPORTED_MODULE_5__[/* default */ "a"])(directive, GraphQLDirective);
2291}
2292function assertDirective(directive) {
2293  if (!isDirective(directive)) {
2294    throw new Error("Expected ".concat(Object(_jsutils_inspect_mjs__WEBPACK_IMPORTED_MODULE_2__[/* default */ "a"])(directive), " to be a GraphQL directive."));
2295  }
2296
2297  return directive;
2298}
2299/**
2300 * Directives are used by the GraphQL runtime as a way of modifying execution
2301 * behavior. Type system creators will usually not create these directly.
2302 */
2303
2304var GraphQLDirective = /*#__PURE__*/function () {
2305  function GraphQLDirective(config) {
2306    var _config$isRepeatable, _config$args;
2307
2308    this.name = config.name;
2309    this.description = config.description;
2310    this.locations = config.locations;
2311    this.isRepeatable = (_config$isRepeatable = config.isRepeatable) !== null && _config$isRepeatable !== void 0 ? _config$isRepeatable : false;

2312    this.extensions = config.extensions && Object(_jsutils_toObjMap_mjs__WEBPACK_IMPORTED_MODULE_3__[/* default */ "a"])(config.extensions);
2313    this.astNode = config.astNode;
2314    config.name || Object(_jsutils_devAssert_mjs__WEBPACK_IMPORTED_MODULE_4__[/* default */ "a"])(0, 'Directive must be named.');
2315    Array.isArray(config.locations) || Object(_jsutils_devAssert_mjs__WEBPACK_IMPORTED_MODULE_4__[/* default */ "a"])(0, "@".concat(config.name, " locations must be an Array."));
2316    var args = (_config$args = config.args) !== null && _config$args !== void 0 ? _config$args : {};
2317    Object(_jsutils_isObjectLike_mjs__WEBPACK_IMPORTED_MODULE_6__[/* default */ "a"])(args) && !Array.isArray(args) || Object(_jsutils_devAssert_mjs__WEBPACK_IMPORTED_MODULE_4__[/* default */ "a"])(0, "@".concat(config.name, " args must be an object with argument names as keys."));
2318    this.args = Object(_polyfills_objectEntries_mjs__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(args).map(function (_ref) {
2319      var argName = _ref[0],
2320          argConfig = _ref[1];
2321      return {
2322        name: argName,
2323        description: argConfig.description,
2324        type: argConfig.type,
2325        defaultValue: argConfig.defaultValue,
2326        deprecationReason: argConfig.deprecationReason,
2327        extensions: argConfig.extensions && Object(_jsutils_toObjMap_mjs__WEBPACK_IMPORTED_MODULE_3__[/* default */ "a"])(argConfig.extensions),
2328        astNode: argConfig.astNode
2329      };
2330    });
2331  }
2332
2333  var _proto = GraphQLDirective.prototype;
2334
2335  _proto.toConfig = function toConfig() {
2336    return {
2337      name: this.name,
2338      description: this.description,
2339      locations: this.locations,
2340      args: Object(_definition_mjs__WEBPACK_IMPORTED_MODULE_10__[/* argsToArgsConfig */ "i"])(this.args),
2341      isRepeatable: this.isRepeatable,
2342      extensions: this.extensions,
2343      astNode: this.astNode
2344    };
2345  };
2346
2347  _proto.toString = function toString() {
2348    return '@' + this.name;
2349  };
2350
2351  _proto.toJSON = function toJSON() {
2352    return this.toString();
2353  } // $FlowFixMe[unsupported-syntax] Flow doesn't support computed properties yet
2354  ;
2355
2356  _createClass(GraphQLDirective, [{
2357    key: _polyfills_symbols_mjs__WEBPACK_IMPORTED_MODULE_1__[/* SYMBOL_TO_STRING_TAG */ "c"],
2358    get: function get() {
2359      return 'GraphQLDirective';
2360    }
2361  }]);
2362
2363  return GraphQLDirective;
2364}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.
2365
2366Object(_jsutils_defineInspect_mjs__WEBPACK_IMPORTED_MODULE_7__[/* default */ "a"])(GraphQLDirective);
2367
2368/**
2369 * Used to conditionally include fields or fragments.
2370 */
2371var GraphQLIncludeDirective = new GraphQLDirective({
2372  name: 'include',
2373  description: 'Directs the executor to include this field or fragment only when the `if` argument is true.',
2374  locations: [_language_directiveLocation_mjs__WEBPACK_IMPORTED_MODULE_8__[/* DirectiveLocation */ "a"].FIELD, _language_directiveLocation_mjs__WEBPACK_IMPORTED_MODULE_8__[/* DirectiveLocation */ "a"].FRAGMENT_SPREAD, _language_directiveLocation_mjs__WEBPACK_IMPORTED_MODULE_8__[/* DirectiveLocation */ "a"].INLINE_FRAGMENT],
2375  args: {
2376    if: {
2377      type: new _definition_mjs__WEBPACK_IMPORTED_MODULE_10__[/* GraphQLNonNull */ "e"](_scalars_mjs__WEBPACK_IMPORTED_MODULE_9__[/* GraphQLBoolean */ "a"]),
2378      description: 'Included when true.'
2379    }
2380  }
2381});
2382/**
2383 * Used to conditionally skip (exclude) fields or fragments.
2384 */
2385
2386var GraphQLSkipDirective = new GraphQLDirective({
2387  name: 'skip',
2388  description: 'Directs the executor to skip this field or fragment when the `if` argument is true.',
2389  locations: [_language_directiveLocation_mjs__WEBPACK_IMPORTED_MODULE_8__[/* DirectiveLocation */ "a"].FIELD, _language_directiveLocation_mjs__WEBPACK_IMPORTED_MODULE_8__[/* DirectiveLocation */ "a"].FRAGMENT_SPREAD, _language_directiveLocation_mjs__WEBPACK_IMPORTED_MODULE_8__[/* DirectiveLocation */ "a"].INLINE_FRAGMENT],
2390  args: {
2391    if: {
2392      type: new _definition_mjs__WEBPACK_IMPORTED_MODULE_10__[/* GraphQLNonNull */ "e"](_scalars_mjs__WEBPACK_IMPORTED_MODULE_9__[/* GraphQLBoolean */ "a"]),
2393      description: 'Skipped when true.'
2394    }
2395  }
2396});
2397/**
2398 * Constant string used for default reason for a deprecation.
2399 */
2400
2401var DEFAULT_DEPRECATION_REASON = 'No longer supported';
2402/**
2403 * Used to declare element of a GraphQL schema as deprecated.
2404 */
2405
2406var GraphQLDeprecatedDirective = new GraphQLDirective({
2407  name: 'deprecated',
2408  description: 'Marks an element of a GraphQL schema as no longer supported.',
2409  locations: [_language_directiveLocation_mjs__WEBPACK_IMPORTED_MODULE_8__[/* DirectiveLocation */ "a"].FIELD_DEFINITION, _language_directiveLocation_mjs__WEBPACK_IMPORTED_MODULE_8__[/* DirectiveLocation */ "a"].ARGUMENT_DEFINITION, _language_directiveLocation_mjs__WEBPACK_IMPORTED_MODULE_8__[/* DirectiveLocation */ "a"].INPUT_FIELD_DEFINITION, _language_directiveLocation_mjs__WEBPACK_IMPORTED_MODULE_8__[/* DirectiveLocation */ "a"].ENUM_VALUE],
2410  args: {
2411    reason: {
2412      type: _scalars_mjs__WEBPACK_IMPORTED_MODULE_9__[/* GraphQLString */ "e"],
2413      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/).',
2414      defaultValue: DEFAULT_DEPRECATION_REASON
2415    }
2416  }
2417});
2418/**
2419 * Used to provide a URL for specifying the behaviour of custom scalar definitions.
2420 */
2421
2422var GraphQLSpecifiedByDirective = new GraphQLDirective({
2423  name: 'specifiedBy',
2424  description: 'Exposes a URL that specifies the behaviour of this scalar.',
2425  locations: [_language_directiveLocation_mjs__WEBPACK_IMPORTED_MODULE_8__[/* DirectiveLocation */ "a"].SCALAR],
2426  args: {
2427    url: {
2428      type: new _definition_mjs__WEBPACK_IMPORTED_MODULE_10__[/* GraphQLNonNull */ "e"](_scalars_mjs__WEBPACK_IMPORTED_MODULE_9__[/* GraphQLString */ "e"]),
2429      description: 'The URL that specifies the behaviour of this scalar.'
2430    }
2431  }
2432});
2433/**
2434 * The full list of specified directives.
2435 */
2436
2437var specifiedDirectives = Object.freeze([GraphQLIncludeDirective, GraphQLSkipDirective, GraphQLDeprecatedDirective, GraphQLSpecifiedByDirective]);
2438function isSpecifiedDirective(directive) {
2439  return specifiedDirectives.some(function (_ref2) {
2440    var name = _ref2.name;
2441    return name === directive.name;
2442  });
2443}
2444
2445
2446/***/ }),
2447
2448/***/ "51nL":
2449/***/ (function(__webpack_module__, __webpack_exports__, __webpack_require__) {
2450
2451"use strict";
2452/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return isSchema; });
2453/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return assertSchema; });
2454/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return GraphQLSchema; });
2455/* harmony import */ var _polyfills_find_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("1/U3");
2456/* harmony import */ var _polyfills_arrayFrom_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("Qx16");
2457/* harmony import */ var _polyfills_objectValues_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("1QEH");
2458/* harmony import */ var _polyfills_symbols_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("2Fve");
2459/* harmony import */ var _jsutils_inspect_mjs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("rWdj");
2460/* harmony import */ var _jsutils_toObjMap_mjs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("E9SJ");
2461/* harmony import */ var _jsutils_devAssert_mjs__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("t3R0");
2462/* harmony import */ var _jsutils_instanceOf_mjs__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__("Mw0p");
2463/* harmony import */ var _jsutils_isObjectLike_mjs__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__("zpYP");
2464/* harmony import */ var _introspection_mjs__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__("LViu");
2465/* harmony import */ var _directives_mjs__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__("4suF");
2466/* harmony import */ var _definition_mjs__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__("axIb");
2467function _defineProperties(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); } }
2468
2469function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483/**
2484 * Test if the given value is a GraphQL schema.
2485 */
2486
2487// eslint-disable-next-line no-redeclare
2488function isSchema(schema) {
2489  return Object(_jsutils_instanceOf_mjs__WEBPACK_IMPORTED_MODULE_7__[/* default */ "a"])(schema, GraphQLSchema);
2490}
2491function assertSchema(schema) {
2492  if (!isSchema(schema)) {
2493    throw new Error("Expected ".concat(Object(_jsutils_inspect_mjs__WEBPACK_IMPORTED_MODULE_4__[/* default */ "a"])(schema), " to be a GraphQL schema."));
2494  }
2495
2496  return schema;
2497}
2498/**
2499 * Schema Definition
2500 *
2501 * A Schema is created by supplying the root types of each type of operation,
2502 * query and mutation (optional). A schema definition is then supplied to the
2503 * validator and executor.
2504 *
2505 * Example:
2506 *
2507 *     const MyAppSchema = new GraphQLSchema({
2508 *       query: MyAppQueryRootType,
2509 *       mutation: MyAppMutationRootType,
2510 *     })
2511 *
2512 * Note: When the schema is constructed, by default only the types that are
2513 * reachable by traversing the root types are included, other types must be
2514 * explicitly referenced.
2515 *
2516 * Example:
2517 *
2518 *     const characterInterface = new GraphQLInterfaceType({
2519 *       name: 'Character',
2520 *       ...
2521 *     });
2522 *
2523 *     const humanType = new GraphQLObjectType({
2524 *       name: 'Human',
2525 *       interfaces: [characterInterface],
2526 *       ...
2527 *     });
2528 *
2529 *     const droidType = new GraphQLObjectType({
2530 *       name: 'Droid',
2531 *       interfaces: [characterInterface],
2532 *       ...
2533 *     });
2534 *
2535 *     const schema = new GraphQLSchema({
2536 *       query: new GraphQLObjectType({
2537 *         name: 'Query',
2538 *         fields: {
2539 *           hero: { type: characterInterface, ... },
2540 *         }
2541 *       }),
2542 *       ...
2543 *       // Since this schema references only the `Character` interface it's
2544 *       // necessary to explicitly list the types that implement it if
2545 *       // you want them to be included in the final schema.
2546 *       types: [humanType, droidType],
2547 *     })
2548 *
2549 * Note: If an array of `directives` are provided to GraphQLSchema, that will be
2550 * the exact list of directives represented and allowed. If `directives` is not
2551 * provided then a default set of the specified directives (e.g. @include and
2552 * @skip) will be used. If you wish to provide *additional* directives to these
2553 * specified directives, you must explicitly declare them. Example:
2554 *
2555 *     const MyAppSchema = new GraphQLSchema({
2556 *       ...
2557 *       directives: specifiedDirectives.concat([ myCustomDirective ]),
2558 *     })
2559 *
2560 */
2561
2562var GraphQLSchema = /*#__PURE__*/function () {
2563  // Used as a cache for validateSchema().
2564  function GraphQLSchema(config) {
2565    var _config$directives;
2566
2567    // If this schema was built from a source known to be valid, then it may be
2568    // marked with assumeValid to avoid an additional type system validation.
2569    this.__validationErrors = config.assumeValid === true ? [] : undefined;

2569 // Check for common mistakes during construction to produce early errors.
2570
2571    Object(_jsutils_isObjectLike_mjs__WEBPACK_IMPORTED_MODULE_8__[/* default */ "a"])(config) || Object(_jsutils_devAssert_mjs__WEBPACK_IMPORTED_MODULE_6__[/* default */ "a"])(0, 'Must provide configuration object.');
2572    !config.types || Array.isArray(config.types) || Object(_jsutils_devAssert_mjs__WEBPACK_IMPORTED_MODULE_6__[/* default */ "a"])(0, "\"types\" must be Array if provided but got: ".concat(Object(_jsutils_inspect_mjs__WEBPACK_IMPORTED_MODULE_4__[/* default */ "a"])(config.types), "."));
2573    !config.directives || Array.isArray(config.directives) || Object(_jsutils_devAssert_mjs__WEBPACK_IMPORTED_MODULE_6__[/* default */ "a"])(0, '"directives" must be Array if provided but got: ' + "".concat(Object(_jsutils_inspect_mjs__WEBPACK_IMPORTED_MODULE_4__[/* default */ "a"])(config.directives), "."));
2574    this.description = config.description;
2575    this.extensions = config.extensions && Object(_jsutils_toObjMap_mjs__WEBPACK_IMPORTED_MODULE_5__[/* default */ "a"])(config.extensions);
2576    this.astNode = config.astNode;
2577    this.extensionASTNodes = config.extensionASTNodes;
2578    this._queryType = config.query;
2579    this._mutationType = config.mutation;
2580    this._subscriptionType = config.subscription; // Provide specified directives (e.g. @include and @skip) by default.
2581
2582    this._directives = (_config$directives = config.directives) !== null && _config$directives !== void 0 ? _config$directives : _directives_mjs__WEBPACK_IMPORTED_MODULE_10__[/* specifiedDirectives */ "j"]; // To preserve order of user-provided types, we add first to add them to
2583    // the set of "collected" types, so `collectReferencedTypes` ignore them.
2584
2585    var allReferencedTypes = new Set(config.types);
2586
2587    if (config.types != null) {
2588      for (var _i2 = 0, _config$types2 = config.types; _i2 < _config$types2.length; _i2++) {
2589        var type = _config$types2[_i2];
2590        // When we ready to process this type, we remove it from "collected" types
2591        // and then add it together with all dependent types in the correct position.
2592        allReferencedTypes.delete(type);
2593        collectReferencedTypes(type, allReferencedTypes);
2594      }
2595    }
2596
2597    if (this._queryType != null) {
2598      collectReferencedTypes(this._queryType, allReferencedTypes);
2599    }
2600
2601    if (this._mutationType != null) {
2602      collectReferencedTypes(this._mutationType, allReferencedTypes);
2603    }
2604
2605    if (this._subscriptionType != null) {
2606      collectReferencedTypes(this._subscriptionType, allReferencedTypes);
2607    }
2608
2609    for (var _i4 = 0, _this$_directives2 = this._directives; _i4 < _this$_directives2.length; _i4++) {
2610      var directive = _this$_directives2[_i4];
2611
2612      // Directives are not validated until validateSchema() is called.
2613      if (Object(_directives_mjs__WEBPACK_IMPORTED_MODULE_10__[/* isDirective */ "h"])(directive)) {
2614        for (var _i6 = 0, _directive$args2 = directive.args; _i6 < _directive$args2.length; _i6++) {
2615          var arg = _directive$args2[_i6];
2616          collectReferencedTypes(arg.type, allReferencedTypes);
2617        }
2618      }
2619    }
2620
2621    collectReferencedTypes(_introspection_mjs__WEBPACK_IMPORTED_MODULE_9__[/* __Schema */ "j"], allReferencedTypes); // Storing the resulting map for reference by the schema.
2622
2623    this._typeMap = Object.create(null);
2624    this._subTypeMap = Object.create(null); // Keep track of all implementations by interface name.
2625
2626    this._implementationsMap = Object.create(null);
2627
2628    for (var _i8 = 0, _arrayFrom2 = Object(_polyfills_arrayFrom_mjs__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(allReferencedTypes); _i8 < _arrayFrom2.length; _i8++) {
2629      var namedType = _arrayFrom2[_i8];
2630
2631      if (namedType == null) {
2632        continue;
2633      }
2634
2635      var typeName = namedType.name;
2636      typeName || Object(_jsutils_devAssert_mjs__WEBPACK_IMPORTED_MODULE_6__[/* default */ "a"])(0, 'One of the provided types for building the Schema is missing a name.');
2637
2638      if (this._typeMap[typeName] !== undefined) {
2639        throw new Error("Schema must contain uniquely named types but contains multiple types named \"".concat(typeName, "\"."));
2640      }
2641
2642      this._typeMap[typeName] = namedType;
2643
2644      if (Object(_definition_mjs__WEBPACK_IMPORTED_MODULE_11__[/* isInterfaceType */ "H"])(namedType)) {
2645        // Store implementations by interface.
2646        for (var _i10 = 0, _namedType$getInterfa2 = namedType.getInterfaces(); _i10 < _namedType$getInterfa2.length; _i10++) {
2647          var iface = _namedType$getInterfa2[_i10];
2648
2649          if (Object(_definition_mjs__WEBPACK_IMPORTED_MODULE_11__[/* isInterfaceType */ "H"])(iface)) {
2650            var implementations = this._implementationsMap[iface.name];
2651
2652            if (implementations === undefined) {
2653              implementations = this._implementationsMap[iface.name] = {
2654                objects: [],
2655                interfaces: []
2656              };
2657            }
2658
2659            implementations.interfaces.push(namedType);
2660          }
2661        }
2662      } else if (Object(_definition_mjs__WEBPACK_IMPORTED_MODULE_11__[/* isObjectType */ "N"])(namedType)) {
2663        // Store implementations by objects.
2664        for (var _i12 = 0, _namedType$getInterfa4 = namedType.getInterfaces(); _i12 < _namedType$getInterfa4.length; _i12++) {
2665          var _iface = _namedType$getInterfa4[_i12];
2666
2667          if (Object(_definition_mjs__WEBPACK_IMPORTED_MODULE_11__[/* isInterfaceType */ "H"])(_iface)) {
2668            var _implementations = this._implementationsMap[_iface.name];
2669
2670            if (_implementations === undefined) {
2671              _implementations = this._implementationsMap[_iface.name] = {
2672                objects: [],
2673                interfaces: []
2674              };
2675            }
2676
2677            _implementations.objects.push(namedType);
2678          }
2679        }
2680      }
2681    }
2682  }
2683
2684  var _proto = GraphQLSchema.prototype;
2685
2686  _proto.getQueryType = function getQueryType() {
2687    return this._queryType;
2688  };
2689
2690  _proto.getMutationType = function getMutationType() {
2691    return this._mutationType;
2692  };
2693
2694  _proto.getSubscriptionType = function getSubscriptionType() {
2695    return this._subscriptionType;
2696  };
2697
2698  _proto.getTypeMap = function getTypeMap() {
2699    return this._typeMap;
2700  };
2701
2702  _proto.getType = function getType(name) {
2703    return this.getTypeMap()[name];
2704  };
2705
2706  _proto.getPossibleTypes = function getPossibleTypes(abstractType) {
2707    return Object(_definition_mjs__WEBPACK_IMPORTED_MODULE_11__[/* isUnionType */ "T"])(abstractType) ? abstractType.getTypes() : this.getImplementations(abstractType).objects;
2708  };
2709
2710  _proto.getImplementations = function getImplementations(interfaceType) {
2711    var implementations = this._implementationsMap[interfaceType.name];
2712    return implementations !== null && implementations !== void 0 ? implementations : {
2713      objects: [],
2714      interfaces: []
2715    };
2716  } // @deprecated: use isSubType instead - will be removed in v16.
2717  ;
2718
2719  _proto.isPossibleType = function isPossibleType(abstractType, possibleType) {
2720    return this.isSubType(abstractType, possibleType);
2721  };
2722
2723  _proto.isSubType = function isSubType(abstractType, maybeSubType) {
2724    var map = this._subTypeMap[abstractType.name];
2725
2726    if (map === undefined) {
2727      map = Object.create(null);
2728
2729      if (Object(_definition_mjs__WEBPACK_IMPORTED_MODULE_11__[/* isUnionType */ "T"])(abstractType)) {
2730        for (var _i14 = 0, _abstractType$getType2 = abstractType.getTypes(); _i14 < _abstractType$getType2.length; _i14++) {
2731          var type = _abstractType$getType2[_i14];
2732          map[type.name] = true;
2733        }
2734      } else {
2735        var implementations = this.getImplementations(abstractType);
2736
2737        for (var _i16 = 0, _implementations$obje2 = implementations.objects; _i16 < _implementations$obje2.length; _i16++) {
2738          var _type = _implementations$obje2[_i16];
2739          map[_type.name] = true;
2740        }
2741
2742        for (var _i18 = 0, _implementations$inte2 = implementations.interfaces; _i18 < _implementations$inte2.length; _i18++) {
2743          var _type2 = _implementations$inte2[_i18];
2744          map[_type2.name] = true;
2745        }
2746      }
2747
2748      this._subTypeMap[abstractType.name] = map;
2749    }
2750
2751    return map[maybeSubType.name] !== undefined;
2752  };
2753
2754  _proto.getDirectives = function getDirectives() {
2755    return this._directives;
2756  };
2757
2758  _proto.getDirective = function getDirective(name) {
2759    return Object(_polyfills_find_mjs__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(this.getDirectives(), function (directive) {
2760      return directive.name === name;
2761    });
2762  };
2763
2764  _proto.toConfig = function toConfig() {
2765    var _this$extensionASTNod;
2766
2767    return {
2768      description: this.description,
2769      query: this.getQueryType(),
2770      mutation: this.getMutationType(),