@faststore/core 2.0.164-alpha.0 → 2.0.166-alpha.0

package/.next/server/chunks/{431.js → 650.js}

@@ -1,9 +1,9 @@
 "use strict";
-exports.id = 431;
-exports.ids = [431];
+exports.id = 650;
+exports.ids = [650];
 exports.modules = {
 
-/***/ 2396:
+/***/ 12396:
 /***/ ((module) => {
 
 
@@ -430,14 +430,1915 @@ module.exports = DataLoader;
 
 /***/ }),
 
-/***/ 9886:
+/***/ 30038:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "__assign": () => (/* binding */ __assign),
+/* harmony export */   "__asyncDelegator": () => (/* binding */ __asyncDelegator),
+/* harmony export */   "__asyncGenerator": () => (/* binding */ __asyncGenerator),
+/* harmony export */   "__asyncValues": () => (/* binding */ __asyncValues),
+/* harmony export */   "__await": () => (/* binding */ __await),
+/* harmony export */   "__awaiter": () => (/* binding */ __awaiter),
+/* harmony export */   "__classPrivateFieldGet": () => (/* binding */ __classPrivateFieldGet),
+/* harmony export */   "__classPrivateFieldIn": () => (/* binding */ __classPrivateFieldIn),
+/* harmony export */   "__classPrivateFieldSet": () => (/* binding */ __classPrivateFieldSet),
+/* harmony export */   "__createBinding": () => (/* binding */ __createBinding),
+/* harmony export */   "__decorate": () => (/* binding */ __decorate),
+/* harmony export */   "__exportStar": () => (/* binding */ __exportStar),
+/* harmony export */   "__extends": () => (/* binding */ __extends),
+/* harmony export */   "__generator": () => (/* binding */ __generator),
+/* harmony export */   "__importDefault": () => (/* binding */ __importDefault),
+/* harmony export */   "__importStar": () => (/* binding */ __importStar),
+/* harmony export */   "__makeTemplateObject": () => (/* binding */ __makeTemplateObject),
+/* harmony export */   "__metadata": () => (/* binding */ __metadata),
+/* harmony export */   "__param": () => (/* binding */ __param),
+/* harmony export */   "__read": () => (/* binding */ __read),
+/* harmony export */   "__rest": () => (/* binding */ __rest),
+/* harmony export */   "__spread": () => (/* binding */ __spread),
+/* harmony export */   "__spreadArray": () => (/* binding */ __spreadArray),
+/* harmony export */   "__spreadArrays": () => (/* binding */ __spreadArrays),
+/* harmony export */   "__values": () => (/* binding */ __values)
+/* harmony export */ });
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    }
+    return __assign.apply(this, arguments);
+}
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+var __createBinding = Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+});
+
+function __exportStar(m, o) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+/** @deprecated */
+function __spread() {
+    for (var ar = [], i = 0; i < arguments.length; i++)
+        ar = ar.concat(__read(arguments[i]));
+    return ar;
+}
+
+/** @deprecated */
+function __spreadArrays() {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+function __asyncDelegator(o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+}
+
+function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+function __makeTemplateObject(cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+
+var __setModuleDefault = Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+};
+
+function __importStar(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+}
+
+function __importDefault(mod) {
+    return (mod && mod.__esModule) ? mod : { default: mod };
+}
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+function __classPrivateFieldIn(state, receiver) {
+    if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
+    return typeof state === "function" ? receiver === state : state.has(receiver);
+}
+
+
+/***/ }),
+
+/***/ 90454:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.envelop = void 0;
+const enable_if_js_1 = __webpack_require__(670);
+const orchestrator_js_1 = __webpack_require__(92932);
+const traced_orchestrator_js_1 = __webpack_require__(20727);
+function envelop(options) {
+    const plugins = options.plugins.filter(enable_if_js_1.isPluginEnabled);
+    let orchestrator = (0, orchestrator_js_1.createEnvelopOrchestrator)(plugins);
+    if (options.enableInternalTracing) {
+        orchestrator = (0, traced_orchestrator_js_1.traceOrchestrator)(orchestrator);
+    }
+    const getEnveloped = (initialContext = {}) => {
+        const typedOrchestrator = orchestrator;
+        typedOrchestrator.init(initialContext);
+        return {
+            parse: typedOrchestrator.parse(initialContext),
+            validate: typedOrchestrator.validate(initialContext),
+            contextFactory: typedOrchestrator.contextFactory(initialContext),
+            execute: typedOrchestrator.execute,
+            subscribe: typedOrchestrator.subscribe,
+            schema: typedOrchestrator.getCurrentSchema(),
+        };
+    };
+    getEnveloped._plugins = plugins;
+    return getEnveloped;
+}
+exports.envelop = envelop;
+
+
+/***/ }),
+
+/***/ 670:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.enableIf = exports.isPluginEnabled = void 0;
+/**
+ * This enum is used only internally in order to create nominal type for the disabled plugin
+ */
+var EnableIfBranded;
+(function (EnableIfBranded) {
+    EnableIfBranded[EnableIfBranded["DisabledPlugin"] = 0] = "DisabledPlugin";
+})(EnableIfBranded || (EnableIfBranded = {}));
+function isPluginEnabled(t) {
+    return t !== EnableIfBranded.DisabledPlugin && t !== null;
+}
+exports.isPluginEnabled = isPluginEnabled;
+/**
+ * Utility function to enable a plugin.
+ */
+function enableIf(condition, plugin) {
+    if (condition) {
+        return typeof plugin === 'function' ? plugin() : plugin;
+    }
+    return EnableIfBranded.DisabledPlugin;
+}
+exports.enableIf = enableIf;
+
+
+/***/ }),
+
+/***/ 90357:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const tslib_1 = __webpack_require__(30038);
+tslib_1.__exportStar(__webpack_require__(49673), exports);
+tslib_1.__exportStar(__webpack_require__(90454), exports);
+tslib_1.__exportStar(__webpack_require__(42049), exports);
+tslib_1.__exportStar(__webpack_require__(91047), exports);
+tslib_1.__exportStar(__webpack_require__(98750), exports);
+tslib_1.__exportStar(__webpack_require__(44654), exports);
+tslib_1.__exportStar(__webpack_require__(37583), exports);
+tslib_1.__exportStar(__webpack_require__(3312), exports);
+tslib_1.__exportStar(__webpack_require__(62713), exports);
+tslib_1.__exportStar(__webpack_require__(86417), exports);
+tslib_1.__exportStar(__webpack_require__(24569), exports);
+tslib_1.__exportStar(__webpack_require__(60683), exports);
+tslib_1.__exportStar(__webpack_require__(670), exports);
+
+
+/***/ }),
+
+/***/ 92932:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.createEnvelopOrchestrator = void 0;
+const graphql_1 = __webpack_require__(57343);
+const traced_schema_js_1 = __webpack_require__(78172);
+const utils_js_1 = __webpack_require__(42049);
+function createEnvelopOrchestrator(plugins) {
+    let schema = null;
+    let initDone = false;
+    const onResolversHandlers = [];
+    for (const plugin of plugins) {
+        if (plugin.onResolverCalled) {
+            onResolversHandlers.push(plugin.onResolverCalled);
+        }
+    }
+    // Define the initial method for replacing the GraphQL schema, this is needed in order
+    // to allow setting the schema from the onPluginInit callback. We also need to make sure
+    // here not to call the same plugin that initiated the schema switch.
+    const replaceSchema = (newSchema, ignorePluginIndex = -1) => {
+        if (onResolversHandlers.length) {
+            (0, traced_schema_js_1.prepareTracedSchema)(newSchema);
+        }
+        schema = newSchema;
+        if (initDone) {
+            for (const [i, plugin] of plugins.entries()) {
+                if (i !== ignorePluginIndex) {
+                    plugin.onSchemaChange &&
+                        plugin.onSchemaChange({
+                            schema,
+                            replaceSchema: schemaToSet => {
+                                replaceSchema(schemaToSet, i);
+                            },
+                        });
+                }
+            }
+        }
+    };
+    const contextErrorHandlers = [];
+    // Iterate all plugins and trigger onPluginInit
+    for (const [i, plugin] of plugins.entries()) {
+        plugin.onPluginInit &&
+            plugin.onPluginInit({
+                plugins,
+                addPlugin: newPlugin => {
+                    plugins.push(newPlugin);
+                },
+                setSchema: modifiedSchema => replaceSchema(modifiedSchema, i),
+                registerContextErrorHandler: handler => contextErrorHandlers.push(handler),
+            });
+    }
+    // A set of before callbacks defined here in order to allow it to be used later
+    const beforeCallbacks = {
+        init: [],
+        parse: [],
+        validate: [],
+        subscribe: [],
+        execute: [],
+        context: [],
+    };
+    for (const { onContextBuilding, onExecute, onParse, onSubscribe, onValidate, onEnveloped } of plugins) {
+        onEnveloped && beforeCallbacks.init.push(onEnveloped);
+        onContextBuilding && beforeCallbacks.context.push(onContextBuilding);
+        onExecute && beforeCallbacks.execute.push(onExecute);
+        onParse && beforeCallbacks.parse.push(onParse);
+        onSubscribe && beforeCallbacks.subscribe.push(onSubscribe);
+        onValidate && beforeCallbacks.validate.push(onValidate);
+    }
+    const init = initialContext => {
+        for (const [i, onEnveloped] of beforeCallbacks.init.entries()) {
+            onEnveloped({
+                context: initialContext,
+                extendContext: extension => {
+                    if (!initialContext) {
+                        return;
+                    }
+                    Object.assign(initialContext, extension);
+                },
+                setSchema: modifiedSchema => replaceSchema(modifiedSchema, i),
+            });
+        }
+    };
+    const customParse = beforeCallbacks.parse.length
+        ? initialContext => (source, parseOptions) => {
+            let result = null;
+            let parseFn = graphql_1.parse;
+            const context = initialContext;
+            const afterCalls = [];
+            for (const onParse of beforeCallbacks.parse) {
+                const afterFn = onParse({
+                    context,
+                    extendContext: extension => {
+                        Object.assign(context, extension);
+                    },
+                    params: { source, options: parseOptions },
+                    parseFn,
+                    setParseFn: newFn => {
+                        parseFn = newFn;
+                    },
+                    setParsedDocument: newDoc => {
+                        result = newDoc;
+                    },
+                });
+                afterFn && afterCalls.push(afterFn);
+            }
+            if (result === null) {
+                try {
+                    result = parseFn(source, parseOptions);
+                }
+                catch (e) {
+                    result = e;
+                }
+            }
+            for (const afterCb of afterCalls) {
+                afterCb({
+                    context,
+                    extendContext: extension => {
+                        Object.assign(context, extension);
+                    },
+                    replaceParseResult: newResult => {
+                        result = newResult;
+                    },
+                    result,
+                });
+            }
+            if (result === null) {
+                throw new Error(`Failed to parse document.`);
+            }
+            if (result instanceof Error) {
+                throw result;
+            }
+            return result;
+        }
+        : () => graphql_1.parse;
+    const customValidate = beforeCallbacks.validate.length
+        ? initialContext => (schema, documentAST, rules, typeInfo, validationOptions) => {
+            let actualRules = rules ? [...rules] : undefined;
+            let validateFn = graphql_1.validate;
+            let result = null;
+            const context = initialContext;
+            const afterCalls = [];
+            for (const onValidate of beforeCallbacks.validate) {
+                const afterFn = onValidate({
+                    context,
+                    extendContext: extension => {
+                        Object.assign(context, extension);
+                    },
+                    params: {
+                        schema,
+                        documentAST,
+                        rules: actualRules,
+                        typeInfo,
+                        options: validationOptions,
+                    },
+                    validateFn,
+                    addValidationRule: rule => {
+                        if (!actualRules) {
+                            actualRules = [...graphql_1.specifiedRules];
+                        }
+                        actualRules.push(rule);
+                    },
+                    setValidationFn: newFn => {
+                        validateFn = newFn;
+                    },
+                    setResult: newResults => {
+                        result = newResults;
+                    },
+                });
+                afterFn && afterCalls.push(afterFn);
+            }
+            if (!result) {
+                result = validateFn(schema, documentAST, actualRules, typeInfo, validationOptions);
+            }
+            const valid = result.length === 0;
+            for (const afterCb of afterCalls) {
+                afterCb({
+                    valid,
+                    result,
+                    context,
+                    extendContext: extension => {
+                        Object.assign(context, extension);
+                    },
+                    setResult: newResult => {
+                        result = newResult;
+                    },
+                });
+            }
+            return result;
+        }
+        : () => graphql_1.validate;
+    const customContextFactory = beforeCallbacks.context
+        .length
+        ? initialContext => async (orchestratorCtx) => {
+            const afterCalls = [];
+            // In order to have access to the "last working" context object we keep this outside of the try block:
+            let context = orchestratorCtx ? { ...initialContext, ...orchestratorCtx } : initialContext;
+            try {
+                let isBreakingContextBuilding = false;
+                for (const onContext of beforeCallbacks.context) {
+                    const afterHookResult = await onContext({
+                        context,
+                        extendContext: extension => {
+                            context = { ...context, ...extension };
+                        },
+                        breakContextBuilding: () => {
+                            isBreakingContextBuilding = true;
+                        },
+                    });
+                    if (typeof afterHookResult === 'function') {
+                        afterCalls.push(afterHookResult);
+                    }
+                    if (isBreakingContextBuilding === true) {
+                        break;
+                    }
+                }
+                for (const afterCb of afterCalls) {
+                    afterCb({
+                        context,
+                        extendContext: extension => {
+                            context = { ...context, ...extension };
+                        },
+                    });
+                }
+                return context;
+            }
+            catch (err) {
+                let error = err;
+                for (const errorCb of contextErrorHandlers) {
+                    errorCb({
+                        context,
+                        error,
+                        setError: err => {
+                            error = err;
+                        },
+                    });
+                }
+                throw error;
+            }
+        }
+        : initialContext => orchestratorCtx => orchestratorCtx ? { ...initialContext, ...orchestratorCtx } : initialContext;
+    const useCustomSubscribe = beforeCallbacks.subscribe.length || onResolversHandlers.length;
+    const customSubscribe = useCustomSubscribe
+        ? (0, utils_js_1.makeSubscribe)(async (args) => {
+            let subscribeFn = graphql_1.subscribe;
+            const afterCalls = [];
+            const subscribeErrorHandlers = [];
+            let context = args.contextValue || {};
+            let result;
+            for (const onSubscribe of beforeCallbacks.subscribe) {
+                const after = await onSubscribe({
+                    subscribeFn,
+                    setSubscribeFn: newSubscribeFn => {
+                        subscribeFn = newSubscribeFn;
+                    },
+                    extendContext: extension => {
+                        context = { ...context, ...extension };
+                    },
+                    args: args,
+                    setResultAndStopExecution: stopResult => {
+                        result = stopResult;
+                    },
+                });
+                if (after) {
+                    if (after.onSubscribeResult) {
+                        afterCalls.push(after.onSubscribeResult);
+                    }
+                    if (after.onSubscribeError) {
+                        subscribeErrorHandlers.push(after.onSubscribeError);
+                    }
+                }
+                if (result !== undefined) {
+                    break;
+                }
+            }
+            if (onResolversHandlers.length) {
+                context[traced_schema_js_1.resolversHooksSymbol] = onResolversHandlers;
+            }
+            if (result === undefined) {
+                result = await subscribeFn({
+                    ...args,
+                    contextValue: context,
+                    // Casted for GraphQL.js 15 compatibility
+                    // Can be removed once we drop support for GraphQL.js 15
+                });
+            }
+            const onNextHandler = [];
+            const onEndHandler = [];
+            for (const afterCb of afterCalls) {
+                const hookResult = afterCb({
+                    args: args,
+                    result,
+                    setResult: newResult => {
+                        result = newResult;
+                    },
+                });
+                if (hookResult) {
+                    if (hookResult.onNext) {
+                        onNextHandler.push(hookResult.onNext);
+                    }
+                    if (hookResult.onEnd) {
+                        onEndHandler.push(hookResult.onEnd);
+                    }
+                }
+            }
+            if (onNextHandler.length && (0, utils_js_1.isAsyncIterable)(result)) {
+                result = (0, utils_js_1.mapAsyncIterator)(result, async (result) => {
+                    for (const onNext of onNextHandler) {
+                        await onNext({
+                            args: args,
+                            result,
+                            setResult: newResult => (result = newResult),
+                        });
+                    }
+                    return result;
+                });
+            }
+            if (onEndHandler.length && (0, utils_js_1.isAsyncIterable)(result)) {
+                result = (0, utils_js_1.finalAsyncIterator)(result, () => {
+                    for (const onEnd of onEndHandler) {
+                        onEnd();
+                    }
+                });
+            }
+            if (subscribeErrorHandlers.length && (0, utils_js_1.isAsyncIterable)(result)) {
+                result = (0, utils_js_1.errorAsyncIterator)(result, err => {
+                    let error = err;
+                    for (const handler of subscribeErrorHandlers) {
+                        handler({
+                            error,
+                            setError: err => {
+                                error = err;
+                            },
+                        });
+                    }
+                    throw error;
+                });
+            }
+            return result;
+        })
+        : (0, utils_js_1.makeSubscribe)(graphql_1.subscribe);
+    const useCustomExecute = beforeCallbacks.execute.length || onResolversHandlers.length;
+    const customExecute = useCustomExecute
+        ? (0, utils_js_1.makeExecute)(async (args) => {
+            let executeFn = graphql_1.execute;
+            let result;
+            const afterCalls = [];
+            let context = args.contextValue || {};
+            for (const onExecute of beforeCallbacks.execute) {
+                const after = await onExecute({
+                    executeFn,
+                    setExecuteFn: newExecuteFn => {
+                        executeFn = newExecuteFn;
+                    },
+                    setResultAndStopExecution: stopResult => {
+                        result = stopResult;
+                    },
+                    extendContext: extension => {
+                        if (typeof extension === 'object') {
+                            context = {
+                                ...context,
+                                ...extension,
+                            };
+                        }
+                        else {
+                            throw new Error(`Invalid context extension provided! Expected "object", got: "${JSON.stringify(extension)}" (${typeof extension})`);
+                        }
+                    },
+                    args: args,
+                });
+                if (after === null || after === void 0 ? void 0 : after.onExecuteDone) {
+                    afterCalls.push(after.onExecuteDone);
+                }
+                if (result !== undefined) {
+                    break;
+                }
+            }
+            if (onResolversHandlers.length) {
+                context[traced_schema_js_1.resolversHooksSymbol] = onResolversHandlers;
+            }
+            if (result === undefined) {
+                result = (await executeFn({
+                    ...args,
+                    contextValue: context,
+                }));
+            }
+            const onNextHandler = [];
+            const onEndHandler = [];
+            for (const afterCb of afterCalls) {
+                const hookResult = await afterCb({
+                    args: args,
+                    result,
+                    setResult: newResult => {
+                        result = newResult;
+                    },
+                });
+                if (hookResult) {
+                    if (hookResult.onNext) {
+                        onNextHandler.push(hookResult.onNext);
+                    }
+                    if (hookResult.onEnd) {
+                        onEndHandler.push(hookResult.onEnd);
+                    }
+                }
+            }
+            if (onNextHandler.length && (0, utils_js_1.isAsyncIterable)(result)) {
+                result = (0, utils_js_1.mapAsyncIterator)(result, async (result) => {
+                    for (const onNext of onNextHandler) {
+                        await onNext({
+                            args: args,
+                            result,
+                            setResult: newResult => {
+                                result = newResult;
+                            },
+                        });
+                    }
+                    return result;
+                });
+            }
+            if (onEndHandler.length && (0, utils_js_1.isAsyncIterable)(result)) {
+                result = (0, utils_js_1.finalAsyncIterator)(result, () => {
+                    for (const onEnd of onEndHandler) {
+                        onEnd();
+                    }
+                });
+            }
+            return result;
+        })
+        : (0, utils_js_1.makeExecute)(graphql_1.execute);
+    initDone = true;
+    // This is done in order to trigger the first schema available, to allow plugins that needs the schema
+    // eagerly to have it.
+    if (schema) {
+        for (const [i, plugin] of plugins.entries()) {
+            plugin.onSchemaChange &&
+                plugin.onSchemaChange({
+                    schema,
+                    replaceSchema: modifiedSchema => replaceSchema(modifiedSchema, i),
+                });
+        }
+    }
+    return {
+        getCurrentSchema() {
+            return schema;
+        },
+        init,
+        parse: customParse,
+        validate: customValidate,
+        execute: customExecute,
+        subscribe: customSubscribe,
+        contextFactory: customContextFactory,
+    };
+}
+exports.createEnvelopOrchestrator = createEnvelopOrchestrator;
+
+
+/***/ }),
+
+/***/ 91047:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.useEnvelop = void 0;
+const useEnvelop = (envelop) => {
+    return {
+        onPluginInit({ addPlugin }) {
+            for (const plugin of envelop._plugins) {
+                addPlugin(plugin);
+            }
+        },
+    };
+};
+exports.useEnvelop = useEnvelop;
+
+
+/***/ }),
+
+/***/ 3312:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.useErrorHandler = void 0;
+const utils_js_1 = __webpack_require__(42049);
+const makeHandleResult = (errorHandler) => ({ result, args }) => {
+    var _a;
+    if ((_a = result.errors) === null || _a === void 0 ? void 0 : _a.length) {
+        errorHandler(result.errors, args);
+    }
+};
+const useErrorHandler = (errorHandler) => {
+    const handleResult = makeHandleResult(errorHandler);
+    return {
+        onExecute() {
+            return {
+                onExecuteDone(payload) {
+                    return (0, utils_js_1.handleStreamOrSingleExecutionResult)(payload, handleResult);
+                },
+            };
+        },
+        onSubscribe() {
+            return {
+                onSubscribeResult(payload) {
+                    return (0, utils_js_1.handleStreamOrSingleExecutionResult)(payload, handleResult);
+                },
+            };
+        },
+    };
+};
+exports.useErrorHandler = useErrorHandler;
+
+
+/***/ }),
+
+/***/ 62713:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.useExtendContext = void 0;
+const useExtendContext = (contextFactory) => ({
+    async onContextBuilding({ context, extendContext }) {
+        extendContext((await contextFactory(context)));
+    },
+});
+exports.useExtendContext = useExtendContext;
+
+
+/***/ }),
+
+/***/ 60683:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.useImmediateIntrospection = void 0;
+const graphql_1 = __webpack_require__(57343);
+const OnNonIntrospectionFieldReachedValidationRule = (onNonIntrospectionField) => ctx => {
+    const rootQueryType = ctx.getSchema().getQueryType();
+    const rootMutationType = ctx.getSchema().getMutationType();
+    const rootSubscriptionType = ctx.getSchema().getSubscriptionType();
+    return {
+        Field(field) {
+            const parentType = ctx.getParentType();
+            const isQuery = parentType === rootQueryType;
+            const isMutation = parentType === rootMutationType;
+            const isSubscription = parentType === rootSubscriptionType;
+            if ((isQuery && !field.name.value.startsWith('__')) || isMutation || isSubscription) {
+                onNonIntrospectionField();
+                return graphql_1.BREAK;
+            }
+            return undefined;
+        },
+    };
+};
+const fastIntroSpectionSymbol = Symbol('fastIntrospection');
+/**
+ * In case a GraphQL operation only contains introspection fields the context building can be skipped completely.
+ * With this plugin any further context extensions will be skipped.
+ */
+const useImmediateIntrospection = () => {
+    return {
+        onValidate({ addValidationRule }) {
+            let isIntrospectionOnly = true;
+            addValidationRule(OnNonIntrospectionFieldReachedValidationRule(() => {
+                isIntrospectionOnly = false;
+            }));
+            return function afterValidate({ extendContext }) {
+                if (isIntrospectionOnly) {
+                    extendContext({ [fastIntroSpectionSymbol]: true });
+                }
+            };
+        },
+        onContextBuilding({ context, breakContextBuilding }) {
+            if (context[fastIntroSpectionSymbol]) {
+                // hijack and skip all other context related stuff.
+                // We dont need a context!
+                breakContextBuilding();
+            }
+        },
+    };
+};
+exports.useImmediateIntrospection = useImmediateIntrospection;
+
+
+/***/ }),
+
+/***/ 98750:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.useLogger = void 0;
+const utils_js_1 = __webpack_require__(42049);
+const DEFAULT_OPTIONS = {
+    logFn: console.log,
+};
+const useLogger = (rawOptions = DEFAULT_OPTIONS) => {
+    const options = {
+        DEFAULT_OPTIONS,
+        ...rawOptions,
+    };
+    return {
+        onParse({ extendContext, params }) {
+            if (options.skipIntrospection && (0, utils_js_1.isIntrospectionOperationString)(params.source)) {
+                extendContext({
+                    [utils_js_1.envelopIsIntrospectionSymbol]: true,
+                });
+            }
+        },
+        onExecute({ args }) {
+            if (args.contextValue[utils_js_1.envelopIsIntrospectionSymbol]) {
+                return;
+            }
+            options.logFn('execute-start', { args });
+            return {
+                onExecuteDone: ({ result }) => {
+                    options.logFn('execute-end', { args, result });
+                },
+            };
+        },
+        onSubscribe({ args }) {
+            if (args.contextValue[utils_js_1.envelopIsIntrospectionSymbol]) {
+                return;
+            }
+            options.logFn('subscribe-start', { args });
+            return {
+                onSubscribeResult: ({ result }) => {
+                    options.logFn('subscribe-end', { args, result });
+                },
+            };
+        },
+    };
+};
+exports.useLogger = useLogger;
+
+
+/***/ }),
+
+/***/ 24569:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.useMaskedErrors = exports.formatError = exports.EnvelopError = exports.DEFAULT_ERROR_MESSAGE = void 0;
+const graphql_1 = __webpack_require__(57343);
+const utils_js_1 = __webpack_require__(42049);
+exports.DEFAULT_ERROR_MESSAGE = 'Unexpected error.';
+class EnvelopError extends graphql_1.GraphQLError {
+    constructor(message, extensions) {
+        super(message, undefined, undefined, undefined, undefined, undefined, extensions);
+    }
+}
+exports.EnvelopError = EnvelopError;
+const formatError = (err, message, isDev) => {
+    var _a, _b, _c, _d;
+    if (err instanceof graphql_1.GraphQLError) {
+        if (
+        /** execution error */
+        (err.originalError && err.originalError instanceof EnvelopError === false) ||
+            /** validate and parse errors */
+            (err.originalError === undefined && err instanceof EnvelopError === false)) {
+            return new graphql_1.GraphQLError(message, err.nodes, err.source, err.positions, err.path, undefined, isDev
+                ? {
+                    originalError: {
+                        message: (_b = (_a = err.originalError) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : err.message,
+                        stack: (_d = (_c = err.originalError) === null || _c === void 0 ? void 0 : _c.stack) !== null && _d !== void 0 ? _d : err.stack,
+                    },
+                }
+                : undefined);
+        }
+        return err;
+    }
+    return new graphql_1.GraphQLError(message);
+};
+exports.formatError = formatError;
+const makeHandleResult = (format, message, isDev) => ({ result, setResult }) => {
+    if (result.errors != null) {
+        setResult({ ...result, errors: result.errors.map(error => format(error, message, isDev)) });
+    }
+};
+const useMaskedErrors = (opts) => {
+    var _a, _b;
+    const format = (_a = opts === null || opts === void 0 ? void 0 : opts.formatError) !== null && _a !== void 0 ? _a : exports.formatError;
+    const message = (opts === null || opts === void 0 ? void 0 : opts.errorMessage) || exports.DEFAULT_ERROR_MESSAGE;
+    // eslint-disable-next-line dot-notation
+    const isDev = (_b = opts === null || opts === void 0 ? void 0 : opts.isDev) !== null && _b !== void 0 ? _b : (typeof process !== 'undefined' ? "production" === 'development' : false);
+    const handleResult = makeHandleResult(format, message, isDev);
+    return {
+        onParse: (opts === null || opts === void 0 ? void 0 : opts.handleParseErrors) === true
+            ? function onParse() {
+                return function onParseEnd({ result, replaceParseResult }) {
+                    if (result instanceof Error) {
+                        replaceParseResult(format(result, message, isDev));
+                    }
+                };
+            }
+            : undefined,
+        onValidate: (opts === null || opts === void 0 ? void 0 : opts.handleValidationErrors) === true
+            ? function onValidate() {
+                return function onValidateEnd({ valid, result, setResult }) {
+                    if (valid === false) {
+                        setResult(result.map(error => format(error, message, isDev)));
+                    }
+                };
+            }
+            : undefined,
+        onPluginInit(context) {
+            context.registerContextErrorHandler(({ error, setError }) => {
+                if (error instanceof graphql_1.GraphQLError === false && error instanceof Error) {
+                    error = new graphql_1.GraphQLError(error.message, undefined, undefined, undefined, undefined, error);
+                }
+                setError(format(error, message, isDev));
+            });
+        },
+        onExecute() {
+            return {
+                onExecuteDone(payload) {
+                    return (0, utils_js_1.handleStreamOrSingleExecutionResult)(payload, handleResult);
+                },
+            };
+        },
+        onSubscribe() {
+            return {
+                onSubscribeResult(payload) {
+                    return (0, utils_js_1.handleStreamOrSingleExecutionResult)(payload, handleResult);
+                },
+                onSubscribeError({ error, setError }) {
+                    setError(format(error, message, isDev));
+                },
+            };
+        },
+    };
+};
+exports.useMaskedErrors = useMaskedErrors;
+
+
+/***/ }),
+
+/***/ 86417:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.usePayloadFormatter = void 0;
+const utils_js_1 = __webpack_require__(42049);
+const makeHandleResult = (formatter) => ({ args, result, setResult, }) => {
+    const modified = formatter(result, args);
+    if (modified !== false) {
+        setResult(modified);
+    }
+};
+const usePayloadFormatter = (formatter) => ({
+    onExecute() {
+        const handleResult = makeHandleResult(formatter);
+        return {
+            onExecuteDone(payload) {
+                return (0, utils_js_1.handleStreamOrSingleExecutionResult)(payload, handleResult);
+            },
+        };
+    },
+});
+exports.usePayloadFormatter = usePayloadFormatter;
+
+
+/***/ }),
+
+/***/ 37583:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.useAsyncSchema = exports.useLazyLoadedSchema = exports.useSchema = void 0;
+const useSchema = (schema) => {
+    return {
+        onPluginInit({ setSchema }) {
+            setSchema(schema);
+        },
+    };
+};
+exports.useSchema = useSchema;
+const useLazyLoadedSchema = (schemaLoader) => {
+    return {
+        onEnveloped({ setSchema, context }) {
+            setSchema(schemaLoader(context));
+        },
+    };
+};
+exports.useLazyLoadedSchema = useLazyLoadedSchema;
+const useAsyncSchema = (schemaPromise) => {
+    return {
+        onPluginInit({ setSchema }) {
+            schemaPromise.then(schemaObj => {
+                setSchema(schemaObj);
+            });
+        },
+    };
+};
+exports.useAsyncSchema = useAsyncSchema;
+
+
+/***/ }),
+
+/***/ 44654:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.useTiming = void 0;
+const graphql_1 = __webpack_require__(57343);
+const utils_js_1 = __webpack_require__(42049);
+const HR_TO_NS = 1e9;
+const NS_TO_MS = 1e6;
+const DEFAULT_OPTIONS = {
+    onExecutionMeasurement: (args, timing) => console.log(`Operation execution "${args.operationName}" done in ${timing.ms}ms`),
+    onSubscriptionMeasurement: (args, timing) => console.log(`Operation subscription "${args.operationName}" done in ${timing.ms}ms`),
+    onParsingMeasurement: (source, timing) => console.log(`Parsing "${source}" done in ${timing.ms}ms`),
+    onValidationMeasurement: (document, timing) => { var _a, _b; return console.log(`Validation "${((_b = (_a = (0, graphql_1.getOperationAST)(document)) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.value) || '-'}" done in ${timing.ms}ms`); },
+    onResolverMeasurement: (info, timing) => console.log(`\tResolver of "${info.parentType.toString()}.${info.fieldName}" done in ${timing.ms}ms`),
+    onContextBuildingMeasurement: (timing) => console.log(`Context building done in ${timing.ms}ms`),
+};
+const deltaFrom = (hrtime) => {
+    const delta = process.hrtime(hrtime);
+    const ns = delta[0] * HR_TO_NS + delta[1];
+    return {
+        ns,
+        get ms() {
+            return ns / NS_TO_MS;
+        },
+    };
+};
+const useTiming = (rawOptions) => {
+    const options = {
+        ...DEFAULT_OPTIONS,
+        ...rawOptions,
+    };
+    const result = {};
+    if (options.onContextBuildingMeasurement) {
+        result.onContextBuilding = ({ context }) => {
+            if (context[utils_js_1.envelopIsIntrospectionSymbol]) {
+                return;
+            }
+            const contextStartTime = process.hrtime();
+            return () => {
+                options.onContextBuildingMeasurement(deltaFrom(contextStartTime));
+            };
+        };
+    }
+    if (options.onParsingMeasurement) {
+        result.onParse = ({ params, extendContext }) => {
+            if (options.skipIntrospection && (0, utils_js_1.isIntrospectionOperationString)(params.source)) {
+                extendContext({
+                    [utils_js_1.envelopIsIntrospectionSymbol]: true,
+                });
+                return;
+            }
+            const parseStartTime = process.hrtime();
+            return () => {
+                options.onParsingMeasurement(params.source, deltaFrom(parseStartTime));
+            };
+        };
+    }
+    if (options.onValidationMeasurement) {
+        result.onValidate = ({ params, context }) => {
+            if (context[utils_js_1.envelopIsIntrospectionSymbol]) {
+                return;
+            }
+            const validateStartTime = process.hrtime();
+            return () => {
+                options.onValidationMeasurement(params.documentAST, deltaFrom(validateStartTime));
+            };
+        };
+    }
+    if (options.onExecutionMeasurement) {
+        if (options.onResolverMeasurement) {
+            result.onExecute = ({ args }) => {
+                if (args.contextValue[utils_js_1.envelopIsIntrospectionSymbol]) {
+                    return;
+                }
+                const executeStartTime = process.hrtime();
+                return {
+                    onExecuteDone: () => {
+                        options.onExecutionMeasurement(args, deltaFrom(executeStartTime));
+                    },
+                };
+            };
+            result.onResolverCalled = ({ info }) => {
+                const resolverStartTime = process.hrtime();
+                return () => {
+                    options.onResolverMeasurement(info, deltaFrom(resolverStartTime));
+                };
+            };
+        }
+        else {
+            result.onExecute = ({ args }) => {
+                if (args.contextValue[utils_js_1.envelopIsIntrospectionSymbol]) {
+                    return;
+                }
+                const executeStartTime = process.hrtime();
+                return {
+                    onExecuteDone: () => {
+                        options.onExecutionMeasurement(args, deltaFrom(executeStartTime));
+                    },
+                };
+            };
+        }
+    }
+    if (options.onSubscriptionMeasurement) {
+        if (options.onResolverMeasurement) {
+            result.onSubscribe = ({ args }) => {
+                if (args.contextValue[utils_js_1.envelopIsIntrospectionSymbol]) {
+                    return;
+                }
+                const subscribeStartTime = process.hrtime();
+                return {
+                    onSubscribeResult: () => {
+                        options.onSubscriptionMeasurement && options.onSubscriptionMeasurement(args, deltaFrom(subscribeStartTime));
+                    },
+                };
+            };
+            result.onResolverCalled = ({ info }) => {
+                const resolverStartTime = process.hrtime();
+                return () => {
+                    options.onResolverMeasurement && options.onResolverMeasurement(info, deltaFrom(resolverStartTime));
+                };
+            };
+        }
+        else {
+            result.onSubscribe = ({ args }) => {
+                if (args.contextValue[utils_js_1.envelopIsIntrospectionSymbol]) {
+                    return;
+                }
+                const subscribeStartTime = process.hrtime();
+                return {
+                    onSubscribeResult: () => {
+                        options.onSubscriptionMeasurement && options.onSubscriptionMeasurement(args, deltaFrom(subscribeStartTime));
+                    },
+                };
+            };
+        }
+    }
+    return result;
+};
+exports.useTiming = useTiming;
+
+
+/***/ }),
+
+/***/ 20727:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+var _a;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.traceOrchestrator = void 0;
+const graphql_1 = __webpack_require__(57343);
+const utils_js_1 = __webpack_require__(42049);
+const getTimestamp = typeof globalThis !== 'undefined' && ((_a = globalThis === null || globalThis === void 0 ? void 0 : globalThis.performance) === null || _a === void 0 ? void 0 : _a.now)
+    ? () => globalThis.performance.now()
+    : () => Date.now();
+const measure = () => {
+    const start = getTimestamp();
+    return () => {
+        const end = getTimestamp();
+        return end - start;
+    };
+};
+const tracingSymbol = Symbol('envelopTracing');
+function traceOrchestrator(orchestrator) {
+    const createTracer = (name, ctx) => {
+        const end = measure();
+        return () => {
+            ctx[tracingSymbol][name] = end();
+        };
+    };
+    return {
+        ...orchestrator,
+        init: (ctx = {}) => {
+            ctx[tracingSymbol] = ctx[tracingSymbol] || {};
+            const done = createTracer('init', ctx || {});
+            try {
+                return orchestrator.init(ctx);
+            }
+            finally {
+                done();
+            }
+        },
+        parse: (ctx = {}) => {
+            ctx[tracingSymbol] = ctx[tracingSymbol] || {};
+            const actualFn = orchestrator.parse(ctx);
+            return (...args) => {
+                const done = createTracer('parse', ctx);
+                try {
+                    return actualFn(...args);
+                }
+                finally {
+                    done();
+                }
+            };
+        },
+        validate: (ctx = {}) => {
+            ctx[tracingSymbol] = ctx[tracingSymbol] || {};
+            const actualFn = orchestrator.validate(ctx);
+            return (...args) => {
+                const done = createTracer('validate', ctx);
+                try {
+                    return actualFn(...args);
+                }
+                finally {
+                    done();
+                }
+            };
+        },
+        execute: async (argsOrSchema, document, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) => {
+            const args = argsOrSchema instanceof graphql_1.GraphQLSchema
+                ? {
+                    schema: argsOrSchema,
+                    document: document,
+                    rootValue,
+                    contextValue,
+                    variableValues,
+                    operationName,
+                    fieldResolver,
+                    typeResolver,
+                }
+                : argsOrSchema;
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore GraphQL.js types contextValue as unknown
+            const done = createTracer('execute', args.contextValue || {});
+            try {
+                const result = await orchestrator.execute(args);
+                done();
+                if (!(0, utils_js_1.isAsyncIterable)(result)) {
+                    result.extensions = result.extensions || {};
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore GraphQL.js types contextValue as unknown
+                    result.extensions.envelopTracing = args.contextValue[tracingSymbol];
+                }
+                else {
+                    // eslint-disable-next-line no-console
+                    console.warn(`"traceOrchestrator" encountered a AsyncIterator which is not supported yet, so tracing data is not available for the operation.`);
+                }
+                return result;
+            }
+            catch (e) {
+                done();
+                throw e;
+            }
+        },
+        subscribe: async (argsOrSchema, document, rootValue, contextValue, variableValues, operationName, fieldResolver, subscribeFieldResolver) => {
+            const args = argsOrSchema instanceof graphql_1.GraphQLSchema
+                ? {
+                    schema: argsOrSchema,
+                    document: document,
+                    rootValue,
+                    contextValue,
+                    variableValues,
+                    operationName,
+                    fieldResolver,
+                    subscribeFieldResolver,
+                }
+                : argsOrSchema;
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore GraphQL.js types contextValue as unknown
+            const done = createTracer('subscribe', args.contextValue || {});
+            try {
+                return await orchestrator.subscribe(args);
+            }
+            finally {
+                done();
+            }
+        },
+        contextFactory: (ctx = {}) => {
+            const actualFn = orchestrator.contextFactory(ctx);
+            return async (childCtx) => {
+                const done = createTracer('contextFactory', ctx);
+                try {
+                    return await actualFn(childCtx);
+                }
+                finally {
+                    done();
+                }
+            };
+        },
+    };
+}
+exports.traceOrchestrator = traceOrchestrator;
+
+
+/***/ }),
+
+/***/ 78172:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.prepareTracedSchema = exports.resolversHooksSymbol = exports.trackedSchemaSymbol = void 0;
+const graphql_1 = __webpack_require__(57343);
+exports.trackedSchemaSymbol = Symbol('TRACKED_SCHEMA');
+exports.resolversHooksSymbol = Symbol('RESOLVERS_HOOKS');
+function prepareTracedSchema(schema) {
+    if (!schema || schema[exports.trackedSchemaSymbol]) {
+        return;
+    }
+    schema[exports.trackedSchemaSymbol] = true;
+    const entries = Object.values(schema.getTypeMap());
+    for (const type of entries) {
+        if (!(0, graphql_1.isIntrospectionType)(type) && (0, graphql_1.isObjectType)(type)) {
+            const fields = Object.values(type.getFields());
+            for (const field of fields) {
+                let resolverFn = (field.resolve || graphql_1.defaultFieldResolver);
+                field.resolve = async (root, args, context, info) => {
+                    if (context && context[exports.resolversHooksSymbol]) {
+                        const hooks = context[exports.resolversHooksSymbol];
+                        const afterCalls = [];
+                        for (const hook of hooks) {
+                            const afterFn = await hook({
+                                root,
+                                args,
+                                context,
+                                info,
+                                resolverFn,
+                                replaceResolverFn: newFn => {
+                                    resolverFn = newFn;
+                                },
+                            });
+                            afterFn && afterCalls.push(afterFn);
+                        }
+                        try {
+                            let result = await resolverFn(root, args, context, info);
+                            for (const afterFn of afterCalls) {
+                                afterFn({
+                                    result,
+                                    setResult: newResult => {
+                                        result = newResult;
+                                    },
+                                });
+                            }
+                            return result;
+                        }
+                        catch (e) {
+                            let resultErr = e;
+                            for (const afterFn of afterCalls) {
+                                afterFn({
+                                    result: resultErr,
+                                    setResult: newResult => {
+                                        resultErr = newResult;
+                                    },
+                                });
+                            }
+                            throw resultErr;
+                        }
+                    }
+                    else {
+                        return resolverFn(root, args, context, info);
+                    }
+                };
+            }
+        }
+    }
+}
+exports.prepareTracedSchema = prepareTracedSchema;
+
+
+/***/ }),
+
+/***/ 42049:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.errorAsyncIterator = exports.finalAsyncIterator = exports.handleStreamOrSingleExecutionResult = exports.isAsyncIterable = exports.makeExecute = exports.mapAsyncIterator = exports.makeSubscribe = exports.isIntrospectionOperationString = exports.isIntrospectionDocument = exports.isIntrospectionOperation = exports.isOperationDefinition = exports.envelopIsIntrospectionSymbol = void 0;
+const graphql_1 = __webpack_require__(57343);
+exports.envelopIsIntrospectionSymbol = Symbol('ENVELOP_IS_INTROSPECTION');
+function isOperationDefinition(def) {
+    return def.kind === graphql_1.Kind.OPERATION_DEFINITION;
+}
+exports.isOperationDefinition = isOperationDefinition;
+function isIntrospectionOperation(operation) {
+    return isIntrospectionDocument({
+        kind: graphql_1.Kind.DOCUMENT,
+        definitions: [operation],
+    });
+}
+exports.isIntrospectionOperation = isIntrospectionOperation;
+function isIntrospectionDocument(document) {
+    let isIntrospectionOperation = false;
+    (0, graphql_1.visit)(document, {
+        Field: node => {
+            if (node.name.value === '__schema' || node.name.value === '__type') {
+                isIntrospectionOperation = true;
+                return graphql_1.BREAK;
+            }
+        },
+    });
+    return isIntrospectionOperation;
+}
+exports.isIntrospectionDocument = isIntrospectionDocument;
+function isIntrospectionOperationString(operation) {
+    return (typeof operation === 'string' ? operation : operation.body).indexOf('__schema') !== -1;
+}
+exports.isIntrospectionOperationString = isIntrospectionOperationString;
+function getSubscribeArgs(args) {
+    return args.length === 1
+        ? args[0]
+        : {
+            schema: args[0],
+            document: args[1],
+            rootValue: args[2],
+            contextValue: args[3],
+            variableValues: args[4],
+            operationName: args[5],
+            fieldResolver: args[6],
+            subscribeFieldResolver: args[7],
+        };
+}
+/**
+ * Utility function for making a subscribe function that handles polymorphic arguments.
+ */
+const makeSubscribe = (subscribeFn) => ((...polyArgs) => subscribeFn(getSubscribeArgs(polyArgs)));
+exports.makeSubscribe = makeSubscribe;
+function mapAsyncIterator(source, mapper) {
+    const iterator = source[Symbol.asyncIterator]();
+    async function mapResult(result) {
+        var _a;
+        if (result.done) {
+            return result;
+        }
+        try {
+            return { value: await mapper(result.value), done: false };
+        }
+        catch (error) {
+            try {
+                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+            }
+            catch (_error) {
+                /* ignore error */
+            }
+            throw error;
+        }
+    }
+    const stream = {
+        [Symbol.asyncIterator]() {
+            return stream;
+        },
+        async next() {
+            return await mapResult(await iterator.next());
+        },
+        async return() {
+            var _a;
+            const promise = (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            return promise ? await mapResult(await promise) : { value: undefined, done: true };
+        },
+        async throw(error) {
+            var _a;
+            const promise = (_a = iterator.throw) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            if (promise) {
+                return await mapResult(await promise);
+            }
+            // if the source has no throw method we just re-throw error
+            // usually throw is not called anyways
+            throw error;
+        },
+    };
+    return stream;
+}
+exports.mapAsyncIterator = mapAsyncIterator;
+function getExecuteArgs(args) {
+    return args.length === 1
+        ? args[0]
+        : {
+            schema: args[0],
+            document: args[1],
+            rootValue: args[2],
+            contextValue: args[3],
+            variableValues: args[4],
+            operationName: args[5],
+            fieldResolver: args[6],
+            typeResolver: args[7],
+        };
+}
+/**
+ * Utility function for making a execute function that handles polymorphic arguments.
+ */
+const makeExecute = (executeFn) => ((...polyArgs) => executeFn(getExecuteArgs(polyArgs)));
+exports.makeExecute = makeExecute;
+/**
+ * Returns true if the provided object implements the AsyncIterator protocol via
+ * implementing a `Symbol.asyncIterator` method.
+ *
+ * Source: https://github.com/graphql/graphql-js/blob/main/src/jsutils/isAsyncIterable.ts
+ */
+function isAsyncIterable(maybeAsyncIterable) {
+    return (typeof maybeAsyncIterable === 'object' &&
+        maybeAsyncIterable != null &&
+        typeof maybeAsyncIterable[Symbol.asyncIterator] === 'function');
+}
+exports.isAsyncIterable = isAsyncIterable;
+/**
+ * A utility function for handling `onExecuteDone` hook result, for simplifying the handling of AsyncIterable returned from `execute`.
+ *
+ * @param payload The payload send to `onExecuteDone` hook function
+ * @param fn The handler to be executed on each result
+ * @returns a subscription for streamed results, or undefined in case of an non-async
+ */
+function handleStreamOrSingleExecutionResult(payload, fn) {
+    if (isAsyncIterable(payload.result)) {
+        return { onNext: fn };
+    }
+    fn({
+        args: payload.args,
+        result: payload.result,
+        setResult: payload.setResult,
+    });
+    return undefined;
+}
+exports.handleStreamOrSingleExecutionResult = handleStreamOrSingleExecutionResult;
+function finalAsyncIterator(source, onFinal) {
+    const iterator = source[Symbol.asyncIterator]();
+    let isDone = false;
+    const stream = {
+        [Symbol.asyncIterator]() {
+            return stream;
+        },
+        async next() {
+            const result = await iterator.next();
+            if (result.done && isDone === false) {
+                isDone = true;
+                onFinal();
+            }
+            return result;
+        },
+        async return() {
+            var _a;
+            const promise = (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            if (isDone === false) {
+                isDone = true;
+                onFinal();
+            }
+            return promise ? await promise : { done: true, value: undefined };
+        },
+        async throw(error) {
+            var _a;
+            const promise = (_a = iterator.throw) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            if (promise) {
+                return await promise;
+            }
+            // if the source has no throw method we just re-throw error
+            // usually throw is not called anyways
+            throw error;
+        },
+    };
+    return stream;
+}
+exports.finalAsyncIterator = finalAsyncIterator;
+function errorAsyncIterator(source, onError) {
+    const iterator = source[Symbol.asyncIterator]();
+    const stream = {
+        [Symbol.asyncIterator]() {
+            return stream;
+        },
+        async next() {
+            try {
+                return await iterator.next();
+            }
+            catch (error) {
+                onError(error);
+                return { done: true, value: undefined };
+            }
+        },
+        async return() {
+            var _a;
+            const promise = (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            return promise ? await promise : { done: true, value: undefined };
+        },
+        async throw(error) {
+            var _a;
+            const promise = (_a = iterator.throw) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            if (promise) {
+                return await promise;
+            }
+            // if the source has no throw method we just re-throw error
+            // usually throw is not called anyways
+            throw error;
+        },
+    };
+    return stream;
+}
+exports.errorAsyncIterator = errorAsyncIterator;
+
+
+/***/ }),
+
+/***/ 37006:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.useOnResolve = void 0;
+const graphql_1 = __webpack_require__(57343);
+/**
+ * Wraps the provided schema by hooking into the resolvers of every field.
+ *
+ * Use the `onResolve` argument to manipulate the resolver and its results/errors.
+ */
+function useOnResolve(onResolve) {
+    return {
+        onSchemaChange({ schema: _schema }) {
+            const schema = _schema;
+            if (!schema)
+                return; // nothing to do if schema is missing
+            for (const type of Object.values(schema.getTypeMap())) {
+                if (!(0, graphql_1.isIntrospectionType)(type) && (0, graphql_1.isObjectType)(type)) {
+                    for (const field of Object.values(type.getFields())) {
+                        let resolver = (field.resolve || graphql_1.defaultFieldResolver);
+                        field.resolve = async (root, args, context, info) => {
+                            const afterResolve = await onResolve({
+                                root,
+                                args,
+                                context,
+                                info,
+                                resolver,
+                                replaceResolver: newResolver => {
+                                    resolver = newResolver;
+                                },
+                            });
+                            let result;
+                            try {
+                                result = await resolver(root, args, context, info);
+                            }
+                            catch (err) {
+                                result = err;
+                            }
+                            if (typeof afterResolve === 'function') {
+                                await afterResolve({
+                                    result,
+                                    setResult: newResult => {
+                                        result = newResult;
+                                    },
+                                });
+                            }
+                            if (result instanceof Error) {
+                                throw result;
+                            }
+                            return result;
+                        };
+                    }
+                }
+            }
+        },
+    };
+}
+exports.useOnResolve = useOnResolve;
+
+
+/***/ }),
+
+/***/ 23073:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+
+/***/ 54686:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+
+/***/ 79277:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+
+/***/ 88036:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+
+/***/ 49673:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const tslib_1 = __webpack_require__(40752);
+tslib_1.__exportStar(__webpack_require__(23073), exports);
+tslib_1.__exportStar(__webpack_require__(88036), exports);
+tslib_1.__exportStar(__webpack_require__(19818), exports);
+tslib_1.__exportStar(__webpack_require__(54686), exports);
+tslib_1.__exportStar(__webpack_require__(79277), exports);
+tslib_1.__exportStar(__webpack_require__(46760), exports);
+
+
+/***/ }),
+
+/***/ 19818:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+
+/***/ 46760:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+
+/***/ 39886:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.extractExtensionsFromSchema = exports.applyExtensions = exports.mergeExtensions = exports.travelSchemaPossibleExtensions = void 0;
-const graphql_1 = __webpack_require__(7343);
-const utils_1 = __webpack_require__(2371);
+const graphql_1 = __webpack_require__(57343);
+const utils_1 = __webpack_require__(22371);
 function travelSchemaPossibleExtensions(schema, hooks) {
     hooks.onSchema(schema);
     const typesMap = schema.getTypeMap();
@@ -569,26 +2470,26 @@ exports.extractExtensionsFromSchema = extractExtensionsFromSchema;
 
 /***/ }),
 
-/***/ 1369:
+/***/ 51369:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-const tslib_1 = __webpack_require__(752);
-tslib_1.__exportStar(__webpack_require__(3337), exports);
-tslib_1.__exportStar(__webpack_require__(6603), exports);
-tslib_1.__exportStar(__webpack_require__(9886), exports);
+const tslib_1 = __webpack_require__(40752);
+tslib_1.__exportStar(__webpack_require__(93337), exports);
+tslib_1.__exportStar(__webpack_require__(36603), exports);
+tslib_1.__exportStar(__webpack_require__(39886), exports);
 
 
 /***/ }),
 
-/***/ 3337:
+/***/ 93337:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.mergeResolvers = void 0;
-const utils_1 = __webpack_require__(2371);
+const utils_1 = __webpack_require__(22371);
 /**
  * Deep merges multiple resolver definition objects into a single definition.
  * @param resolversDefinitions Resolver definitions to be merged
@@ -662,7 +2563,7 @@ exports.mergeResolvers = mergeResolvers;
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.mergeArguments = void 0;
-const utils_1 = __webpack_require__(2371);
+const utils_1 = __webpack_require__(22371);
 function mergeArguments(args1, args2, config) {
     const result = deduplicateArguments([...args2, ...args1].filter(utils_1.isSome));
     if (config && config.sort) {
@@ -684,14 +2585,14 @@ function deduplicateArguments(args) {
 
 /***/ }),
 
-/***/ 5333:
+/***/ 75333:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.mergeDirective = exports.mergeDirectives = void 0;
-const graphql_1 = __webpack_require__(7343);
-const utils_1 = __webpack_require__(2371);
+const graphql_1 = __webpack_require__(57343);
+const utils_1 = __webpack_require__(22371);
 function directiveAlreadyExists(directivesArr, otherDirective) {
     return !!directivesArr.find(directive => directive.name.value === otherDirective.name.value);
 }
@@ -791,14 +2692,14 @@ function deduplicateLists(source, target, filterFn) {
 
 /***/ }),
 
-/***/ 9114:
+/***/ 79114:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.mergeEnumValues = void 0;
-const directives_js_1 = __webpack_require__(5333);
-const utils_1 = __webpack_require__(2371);
+const directives_js_1 = __webpack_require__(75333);
+const utils_1 = __webpack_require__(22371);
 function mergeEnumValues(first, second, config) {
     if (config === null || config === void 0 ? void 0 : config.consistentEnumMerge) {
         const reversed = [];
@@ -838,15 +2739,15 @@ exports.mergeEnumValues = mergeEnumValues;
 
 /***/ }),
 
-/***/ 1671:
+/***/ 31671:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.mergeEnum = void 0;
-const graphql_1 = __webpack_require__(7343);
-const directives_js_1 = __webpack_require__(5333);
-const enum_values_js_1 = __webpack_require__(9114);
+const graphql_1 = __webpack_require__(57343);
+const directives_js_1 = __webpack_require__(75333);
+const enum_values_js_1 = __webpack_require__(79114);
 function mergeEnum(e1, e2, config) {
     if (e2) {
         return {
@@ -872,15 +2773,15 @@ exports.mergeEnum = mergeEnum;
 
 /***/ }),
 
-/***/ 7754:
+/***/ 17754:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.mergeFields = void 0;
-const utils_js_1 = __webpack_require__(2825);
-const directives_js_1 = __webpack_require__(5333);
-const utils_1 = __webpack_require__(2371);
+const utils_js_1 = __webpack_require__(32825);
+const directives_js_1 = __webpack_require__(75333);
+const utils_1 = __webpack_require__(22371);
 const arguments_js_1 = __webpack_require__(5293);
 function fieldAlreadyExists(fieldsArr, otherField, config) {
     const result = fieldsArr.find(field => field.name.value === otherField.name.value);
@@ -964,39 +2865,39 @@ function safeChangeForFieldType(oldType, newType, ignoreNullability = false) {
 
 /***/ }),
 
-/***/ 6603:
+/***/ 36603:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-const tslib_1 = __webpack_require__(752);
+const tslib_1 = __webpack_require__(40752);
 tslib_1.__exportStar(__webpack_require__(5293), exports);
-tslib_1.__exportStar(__webpack_require__(5333), exports);
-tslib_1.__exportStar(__webpack_require__(9114), exports);
-tslib_1.__exportStar(__webpack_require__(1671), exports);
-tslib_1.__exportStar(__webpack_require__(7754), exports);
-tslib_1.__exportStar(__webpack_require__(9777), exports);
-tslib_1.__exportStar(__webpack_require__(239), exports);
-tslib_1.__exportStar(__webpack_require__(3915), exports);
-tslib_1.__exportStar(__webpack_require__(1642), exports);
-tslib_1.__exportStar(__webpack_require__(3878), exports);
-tslib_1.__exportStar(__webpack_require__(7551), exports);
-tslib_1.__exportStar(__webpack_require__(7524), exports);
-tslib_1.__exportStar(__webpack_require__(7747), exports);
-tslib_1.__exportStar(__webpack_require__(2825), exports);
+tslib_1.__exportStar(__webpack_require__(75333), exports);
+tslib_1.__exportStar(__webpack_require__(79114), exports);
+tslib_1.__exportStar(__webpack_require__(31671), exports);
+tslib_1.__exportStar(__webpack_require__(17754), exports);
+tslib_1.__exportStar(__webpack_require__(39777), exports);
+tslib_1.__exportStar(__webpack_require__(80239), exports);
+tslib_1.__exportStar(__webpack_require__(73915), exports);
+tslib_1.__exportStar(__webpack_require__(51642), exports);
+tslib_1.__exportStar(__webpack_require__(23878), exports);
+tslib_1.__exportStar(__webpack_require__(17551), exports);
+tslib_1.__exportStar(__webpack_require__(97524), exports);
+tslib_1.__exportStar(__webpack_require__(87747), exports);
+tslib_1.__exportStar(__webpack_require__(32825), exports);
 
 
 /***/ }),
 
-/***/ 9777:
+/***/ 39777:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.mergeInputType = void 0;
-const graphql_1 = __webpack_require__(7343);
-const fields_js_1 = __webpack_require__(7754);
-const directives_js_1 = __webpack_require__(5333);
+const graphql_1 = __webpack_require__(57343);
+const fields_js_1 = __webpack_require__(17754);
+const directives_js_1 = __webpack_require__(75333);
 function mergeInputType(node, existingNode, config) {
     if (existingNode) {
         try {
@@ -1029,16 +2930,16 @@ exports.mergeInputType = mergeInputType;
 
 /***/ }),
 
-/***/ 239:
+/***/ 80239:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.mergeInterface = void 0;
-const graphql_1 = __webpack_require__(7343);
-const fields_js_1 = __webpack_require__(7754);
-const directives_js_1 = __webpack_require__(5333);
-const index_js_1 = __webpack_require__(6603);
+const graphql_1 = __webpack_require__(57343);
+const fields_js_1 = __webpack_require__(17754);
+const directives_js_1 = __webpack_require__(75333);
+const index_js_1 = __webpack_require__(36603);
 function mergeInterface(node, existingNode, config) {
     if (existingNode) {
         try {
@@ -1074,13 +2975,13 @@ exports.mergeInterface = mergeInterface;
 
 /***/ }),
 
-/***/ 3915:
+/***/ 73915:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.mergeNamedTypeArray = void 0;
-const utils_1 = __webpack_require__(2371);
+const utils_1 = __webpack_require__(22371);
 function alreadyExists(arr, other) {
     return !!arr.find(i => i.name.value === other.name.value);
 }
@@ -1096,22 +2997,22 @@ exports.mergeNamedTypeArray = mergeNamedTypeArray;
 
 /***/ }),
 
-/***/ 1642:
+/***/ 51642:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.mergeGraphQLNodes = exports.isNamedDefinitionNode = exports.schemaDefSymbol = void 0;
-const graphql_1 = __webpack_require__(7343);
-const type_js_1 = __webpack_require__(7524);
-const enum_js_1 = __webpack_require__(1671);
-const scalar_js_1 = __webpack_require__(7551);
-const union_js_1 = __webpack_require__(7747);
-const input_type_js_1 = __webpack_require__(9777);
-const interface_js_1 = __webpack_require__(239);
-const directives_js_1 = __webpack_require__(5333);
-const schema_def_js_1 = __webpack_require__(3400);
-const utils_1 = __webpack_require__(2371);
+const graphql_1 = __webpack_require__(57343);
+const type_js_1 = __webpack_require__(97524);
+const enum_js_1 = __webpack_require__(31671);
+const scalar_js_1 = __webpack_require__(17551);
+const union_js_1 = __webpack_require__(87747);
+const input_type_js_1 = __webpack_require__(39777);
+const interface_js_1 = __webpack_require__(80239);
+const directives_js_1 = __webpack_require__(75333);
+const schema_def_js_1 = __webpack_require__(23400);
+const utils_1 = __webpack_require__(22371);
 exports.schemaDefSymbol = 'SCHEMA_DEF_SYMBOL';
 function isNamedDefinitionNode(definitionNode) {
     return 'name' in definitionNode;
@@ -1175,17 +3076,17 @@ exports.mergeGraphQLNodes = mergeGraphQLNodes;
 
 /***/ }),
 
-/***/ 3878:
+/***/ 23878:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.mergeGraphQLTypes = exports.mergeTypeDefs = void 0;
-const graphql_1 = __webpack_require__(7343);
-const utils_js_1 = __webpack_require__(2825);
-const merge_nodes_js_1 = __webpack_require__(1642);
-const utils_1 = __webpack_require__(2371);
-const schema_def_js_1 = __webpack_require__(3400);
+const graphql_1 = __webpack_require__(57343);
+const utils_js_1 = __webpack_require__(32825);
+const merge_nodes_js_1 = __webpack_require__(51642);
+const utils_1 = __webpack_require__(22371);
+const schema_def_js_1 = __webpack_require__(23400);
 function mergeTypeDefs(typeSource, config) {
     (0, utils_1.resetComments)();
     const doc = {
@@ -1303,14 +3204,14 @@ exports.mergeGraphQLTypes = mergeGraphQLTypes;
 
 /***/ }),
 
-/***/ 7551:
+/***/ 17551:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.mergeScalar = void 0;
-const graphql_1 = __webpack_require__(7343);
-const directives_js_1 = __webpack_require__(5333);
+const graphql_1 = __webpack_require__(57343);
+const directives_js_1 = __webpack_require__(75333);
 function mergeScalar(node, existingNode, config) {
     if (existingNode) {
         return {
@@ -1337,14 +3238,14 @@ exports.mergeScalar = mergeScalar;
 
 /***/ }),
 
-/***/ 3400:
+/***/ 23400:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.mergeSchemaDefs = exports.DEFAULT_OPERATION_TYPE_NAME_MAP = void 0;
-const graphql_1 = __webpack_require__(7343);
-const directives_js_1 = __webpack_require__(5333);
+const graphql_1 = __webpack_require__(57343);
+const directives_js_1 = __webpack_require__(75333);
 exports.DEFAULT_OPERATION_TYPE_NAME_MAP = {
     query: 'Query',
     mutation: 'Mutation',
@@ -1383,16 +3284,16 @@ exports.mergeSchemaDefs = mergeSchemaDefs;
 
 /***/ }),
 
-/***/ 7524:
+/***/ 97524:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.mergeType = void 0;
-const graphql_1 = __webpack_require__(7343);
-const fields_js_1 = __webpack_require__(7754);
-const directives_js_1 = __webpack_require__(5333);
-const merge_named_type_array_js_1 = __webpack_require__(3915);
+const graphql_1 = __webpack_require__(57343);
+const fields_js_1 = __webpack_require__(17754);
+const directives_js_1 = __webpack_require__(75333);
+const merge_named_type_array_js_1 = __webpack_require__(73915);
 function mergeType(node, existingNode, config) {
     if (existingNode) {
         try {
@@ -1426,15 +3327,15 @@ exports.mergeType = mergeType;
 
 /***/ }),
 
-/***/ 7747:
+/***/ 87747:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.mergeUnion = void 0;
-const graphql_1 = __webpack_require__(7343);
-const directives_js_1 = __webpack_require__(5333);
-const merge_named_type_array_js_1 = __webpack_require__(3915);
+const graphql_1 = __webpack_require__(57343);
+const directives_js_1 = __webpack_require__(75333);
+const merge_named_type_array_js_1 = __webpack_require__(73915);
 function mergeUnion(first, second, config) {
     if (second) {
         return {
@@ -1461,13 +3362,13 @@ exports.mergeUnion = mergeUnion;
 
 /***/ }),
 
-/***/ 2825:
+/***/ 32825:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.defaultStringComparator = exports.CompareVal = exports.printTypeNode = exports.isNonNullTypeNode = exports.isListTypeNode = exports.isWrappingTypeNode = exports.extractType = exports.isSourceTypes = exports.isStringTypes = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 function isStringTypes(types) {
     return typeof types === 'string';
 }
@@ -1533,16 +3434,16 @@ exports.defaultStringComparator = defaultStringComparator;
 
 /***/ }),
 
-/***/ 4042:
+/***/ 24042:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.addResolversToSchema = void 0;
-const graphql_1 = __webpack_require__(7343);
-const utils_1 = __webpack_require__(2371);
-const checkForResolveTypeResolver_js_1 = __webpack_require__(1406);
-const extendResolversFromInterfaces_js_1 = __webpack_require__(6913);
+const graphql_1 = __webpack_require__(57343);
+const utils_1 = __webpack_require__(22371);
+const checkForResolveTypeResolver_js_1 = __webpack_require__(81406);
+const extendResolversFromInterfaces_js_1 = __webpack_require__(26913);
 function addResolversToSchema(schemaOrOptions, legacyInputResolvers, legacyInputValidationOptions) {
     const options = (0, graphql_1.isSchema)(schemaOrOptions)
         ? {
@@ -1866,14 +3767,14 @@ function setFieldProperties(field, propertiesObj) {
 
 /***/ }),
 
-/***/ 1932:
+/***/ 41932:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.assertResolversPresent = void 0;
-const graphql_1 = __webpack_require__(7343);
-const utils_1 = __webpack_require__(2371);
+const graphql_1 = __webpack_require__(57343);
+const utils_1 = __webpack_require__(22371);
 function assertResolversPresent(schema, resolverValidationOptions = {}) {
     const { requireResolversForArgs, requireResolversForNonScalar, requireResolversForAllFields } = resolverValidationOptions;
     if (requireResolversForAllFields && (requireResolversForArgs || requireResolversForNonScalar)) {
@@ -1920,13 +3821,13 @@ To disable this validator, use:
 
 /***/ }),
 
-/***/ 516:
+/***/ 80516:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.chainResolvers = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 function chainResolvers(resolvers) {
     return (root, args, ctx, info) => resolvers.reduce((prev, curResolver) => {
         if (curResolver != null) {
@@ -1940,13 +3841,13 @@ exports.chainResolvers = chainResolvers;
 
 /***/ }),
 
-/***/ 1406:
+/***/ 81406:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.checkForResolveTypeResolver = void 0;
-const utils_1 = __webpack_require__(2371);
+const utils_1 = __webpack_require__(22371);
 // If we have any union or interface types throw if no there is no resolveType resolver
 function checkForResolveTypeResolver(schema, requireResolversForResolveType) {
     (0, utils_1.mapSchema)(schema, {
@@ -1970,7 +3871,7 @@ exports.checkForResolveTypeResolver = checkForResolveTypeResolver;
 
 /***/ }),
 
-/***/ 6913:
+/***/ 26913:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -2012,41 +3913,41 @@ exports.extendResolversFromInterfaces = extendResolversFromInterfaces;
 
 /***/ }),
 
-/***/ 4246:
+/***/ 14246:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.extendResolversFromInterfaces = exports.checkForResolveTypeResolver = exports.addResolversToSchema = exports.chainResolvers = exports.assertResolversPresent = void 0;
-const tslib_1 = __webpack_require__(752);
-var assertResolversPresent_js_1 = __webpack_require__(1932);
+const tslib_1 = __webpack_require__(40752);
+var assertResolversPresent_js_1 = __webpack_require__(41932);
 Object.defineProperty(exports, "assertResolversPresent", ({ enumerable: true, get: function () { return assertResolversPresent_js_1.assertResolversPresent; } }));
-var chainResolvers_js_1 = __webpack_require__(516);
+var chainResolvers_js_1 = __webpack_require__(80516);
 Object.defineProperty(exports, "chainResolvers", ({ enumerable: true, get: function () { return chainResolvers_js_1.chainResolvers; } }));
-var addResolversToSchema_js_1 = __webpack_require__(4042);
+var addResolversToSchema_js_1 = __webpack_require__(24042);
 Object.defineProperty(exports, "addResolversToSchema", ({ enumerable: true, get: function () { return addResolversToSchema_js_1.addResolversToSchema; } }));
-var checkForResolveTypeResolver_js_1 = __webpack_require__(1406);
+var checkForResolveTypeResolver_js_1 = __webpack_require__(81406);
 Object.defineProperty(exports, "checkForResolveTypeResolver", ({ enumerable: true, get: function () { return checkForResolveTypeResolver_js_1.checkForResolveTypeResolver; } }));
-var extendResolversFromInterfaces_js_1 = __webpack_require__(6913);
+var extendResolversFromInterfaces_js_1 = __webpack_require__(26913);
 Object.defineProperty(exports, "extendResolversFromInterfaces", ({ enumerable: true, get: function () { return extendResolversFromInterfaces_js_1.extendResolversFromInterfaces; } }));
-tslib_1.__exportStar(__webpack_require__(8931), exports);
-tslib_1.__exportStar(__webpack_require__(4287), exports);
-tslib_1.__exportStar(__webpack_require__(8961), exports);
+tslib_1.__exportStar(__webpack_require__(78931), exports);
+tslib_1.__exportStar(__webpack_require__(74287), exports);
+tslib_1.__exportStar(__webpack_require__(48961), exports);
 
 
 /***/ }),
 
-/***/ 8931:
+/***/ 78931:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.makeExecutableSchema = void 0;
-const graphql_1 = __webpack_require__(7343);
-const utils_1 = __webpack_require__(2371);
-const addResolversToSchema_js_1 = __webpack_require__(4042);
-const assertResolversPresent_js_1 = __webpack_require__(1932);
-const merge_1 = __webpack_require__(1369);
+const graphql_1 = __webpack_require__(57343);
+const utils_1 = __webpack_require__(22371);
+const addResolversToSchema_js_1 = __webpack_require__(24042);
+const assertResolversPresent_js_1 = __webpack_require__(41932);
+const merge_1 = __webpack_require__(51369);
 /**
  * Builds a schema from the provided type definitions and resolvers.
  *
@@ -2139,15 +4040,15 @@ exports.makeExecutableSchema = makeExecutableSchema;
 
 /***/ }),
 
-/***/ 8961:
+/***/ 48961:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.mergeSchemas = void 0;
-const merge_1 = __webpack_require__(1369);
-const utils_1 = __webpack_require__(2371);
-const makeExecutableSchema_js_1 = __webpack_require__(8931);
+const merge_1 = __webpack_require__(51369);
+const utils_1 = __webpack_require__(22371);
+const makeExecutableSchema_js_1 = __webpack_require__(78931);
 /**
  * Synchronously merges multiple schemas, typeDefinitions and/or resolvers into a single schema.
  * @param config Configuration object
@@ -2175,7 +4076,7 @@ exports.mergeSchemas = mergeSchemas;
 
 /***/ }),
 
-/***/ 4287:
+/***/ 74287:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -2216,7 +4117,7 @@ exports.isAggregateError = isAggregateError;
 
 /***/ }),
 
-/***/ 8352:
+/***/ 58352:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -2254,7 +4155,7 @@ var MapperKind;
 
 /***/ }),
 
-/***/ 7146:
+/***/ 37146:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
@@ -2287,9 +4188,9 @@ var MapperKind;
 //
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.addTypes = void 0;
-const graphql_1 = __webpack_require__(7343);
-const getObjectTypeFromTypeMap_js_1 = __webpack_require__(6365);
-const rewire_js_1 = __webpack_require__(4545);
+const graphql_1 = __webpack_require__(57343);
+const getObjectTypeFromTypeMap_js_1 = __webpack_require__(56365);
+const rewire_js_1 = __webpack_require__(74545);
 function addTypes(schema, newTypesOrDirectives) {
     const config = schema.toConfig();
     const originalTypeMap = {};
@@ -2323,14 +4224,14 @@ exports.addTypes = addTypes;
 
 /***/ }),
 
-/***/ 9969:
+/***/ 29969:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.astFromType = void 0;
-const graphql_1 = __webpack_require__(7343);
-const inspect_js_1 = __webpack_require__(6891);
+const graphql_1 = __webpack_require__(57343);
+const inspect_js_1 = __webpack_require__(26891);
 function astFromType(type) {
     if ((0, graphql_1.isNonNullType)(type)) {
         const innerType = astFromType(type.ofType);
@@ -2361,13 +4262,13 @@ exports.astFromType = astFromType;
 
 /***/ }),
 
-/***/ 9640:
+/***/ 59640:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.astFromValueUntyped = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 /**
  * Produces a GraphQL Value AST given a JavaScript object.
  * Function will match JavaScript/JSON values to GraphQL AST schema format
@@ -2452,8 +4353,8 @@ const integerStringRegExp = /^-?(?:0|[1-9][0-9]*)$/;
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.buildOperationNodeForField = void 0;
-const graphql_1 = __webpack_require__(7343);
-const rootTypes_js_1 = __webpack_require__(274);
+const graphql_1 = __webpack_require__(57343);
+const rootTypes_js_1 = __webpack_require__(30274);
 let operationVariables = [];
 let fieldTypeMap = new Map();
 function addOperationVariable(variable) {
@@ -2804,14 +4705,14 @@ function hasCircularRef(types, config = {
 
 /***/ }),
 
-/***/ 7668:
+/***/ 67668:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.collectSubFields = exports.collectFields = void 0;
-const memoize_js_1 = __webpack_require__(1251);
-const graphql_1 = __webpack_require__(7343);
+const memoize_js_1 = __webpack_require__(41251);
+const graphql_1 = __webpack_require__(57343);
 // Taken from GraphQL-JS v16 for backwards compat
 function collectFields(schema, fragments, variableValues, runtimeType, selectionSet, fields, visitedFragmentNames) {
     for (const selection of selectionSet.selections) {
@@ -2909,13 +4810,13 @@ exports.collectSubFields = (0, memoize_js_1.memoize5)(function collectSubFields(
 
 /***/ }),
 
-/***/ 5376:
+/***/ 85376:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.getBlockStringIndentation = exports.dedentBlockStringValue = exports.getLeadingCommentBlock = exports.getComment = exports.getDescription = exports.printWithComments = exports.printComment = exports.pushComment = exports.collectComment = exports.resetComments = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 const MAX_LINE_LENGTH = 80;
 let commentsRegistry = {};
 function resetComments() {
@@ -3302,7 +5203,7 @@ function isBlank(str) {
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.relocatedError = exports.createGraphQLError = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 function createGraphQLError(message, options) {
     if (graphql_1.versionInfo.major >= 17) {
         return new graphql_1.GraphQLError(message, options);
@@ -3325,7 +5226,7 @@ exports.relocatedError = relocatedError;
 
 /***/ }),
 
-/***/ 5639:
+/***/ 25639:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -3334,16 +5235,16 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 
 /***/ }),
 
-/***/ 6590:
+/***/ 56590:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.modifyObjectFields = exports.selectObjectFields = exports.removeObjectFields = exports.appendObjectFields = void 0;
-const graphql_1 = __webpack_require__(7343);
-const Interfaces_js_1 = __webpack_require__(8352);
-const mapSchema_js_1 = __webpack_require__(1275);
-const addTypes_js_1 = __webpack_require__(7146);
+const graphql_1 = __webpack_require__(57343);
+const Interfaces_js_1 = __webpack_require__(58352);
+const mapSchema_js_1 = __webpack_require__(11275);
+const addTypes_js_1 = __webpack_require__(37146);
 function appendObjectFields(schema, typeName, additionalFields) {
     if (schema.getType(typeName) == null) {
         return (0, addTypes_js_1.addTypes)(schema, [
@@ -3456,15 +5357,15 @@ exports.modifyObjectFields = modifyObjectFields;
 
 /***/ }),
 
-/***/ 4723:
+/***/ 14723:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.filterSchema = void 0;
-const graphql_1 = __webpack_require__(7343);
-const Interfaces_js_1 = __webpack_require__(8352);
-const mapSchema_js_1 = __webpack_require__(1275);
+const graphql_1 = __webpack_require__(57343);
+const Interfaces_js_1 = __webpack_require__(58352);
+const mapSchema_js_1 = __webpack_require__(11275);
 function filterSchema({ schema, typeFilter = () => true, fieldFilter = undefined, rootFieldFilter = undefined, objectFieldFilter = undefined, interfaceFieldFilter = undefined, inputObjectFieldFilter = undefined, argumentFilter = undefined, }) {
     const filteredSchema = (0, mapSchema_js_1.mapSchema)(schema, {
         [Interfaces_js_1.MapperKind.QUERY]: (type) => filterRootFields(type, 'Query', rootFieldFilter, argumentFilter),
@@ -3529,14 +5430,14 @@ function filterElementFields(ElementConstructor, type, fieldFilter, argumentFilt
 
 /***/ }),
 
-/***/ 8373:
+/***/ 58373:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.fixSchemaAst = void 0;
-const graphql_1 = __webpack_require__(7343);
-const print_schema_with_directives_js_1 = __webpack_require__(5943);
+const graphql_1 = __webpack_require__(57343);
+const print_schema_with_directives_js_1 = __webpack_require__(55943);
 function buildFixedSchema(schema, options) {
     const document = (0, print_schema_with_directives_js_1.getDocumentNodeFromSchema)(schema);
     return (0, graphql_1.buildASTSchema)(document, {
@@ -3562,13 +5463,13 @@ exports.fixSchemaAst = fixSchemaAst;
 
 /***/ }),
 
-/***/ 5446:
+/***/ 35446:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.forEachDefaultValue = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 function forEachDefaultValue(schema, fn) {
     const typeMap = schema.getTypeMap();
     for (const typeName in typeMap) {
@@ -3604,7 +5505,7 @@ exports.forEachDefaultValue = forEachDefaultValue;
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.forEachField = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 function forEachField(schema, fn) {
     const typeMap = schema.getTypeMap();
     for (const typeName in typeMap) {
@@ -3624,13 +5525,13 @@ exports.forEachField = forEachField;
 
 /***/ }),
 
-/***/ 755:
+/***/ 50755:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.getDirective = exports.getDirectives = exports.getDirectiveInExtensions = exports.getDirectivesInExtensions = void 0;
-const getArgumentValues_js_1 = __webpack_require__(7882);
+const getArgumentValues_js_1 = __webpack_require__(17882);
 function getDirectivesInExtensions(node, pathToDirectivesInExtensions = ['directives']) {
     return pathToDirectivesInExtensions.reduce((acc, pathSegment) => (acc == null ? acc : acc[pathSegment]), node === null || node === void 0 ? void 0 : node.extensions);
 }
@@ -3734,13 +5635,13 @@ exports.getDirective = getDirective;
 
 /***/ }),
 
-/***/ 6415:
+/***/ 46415:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.getFieldsWithDirectives = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 function parseDirectiveValue(value) {
     switch (value.kind) {
         case graphql_1.Kind.INT:
@@ -3793,13 +5694,13 @@ exports.getFieldsWithDirectives = getFieldsWithDirectives;
 
 /***/ }),
 
-/***/ 1281:
+/***/ 21281:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.getImplementingTypes = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 function getImplementingTypes(interfaceName, schema) {
     const allTypesMap = schema.getTypeMap();
     const result = [];
@@ -3819,15 +5720,15 @@ exports.getImplementingTypes = getImplementingTypes;
 
 /***/ }),
 
-/***/ 7882:
+/***/ 17882:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.getArgumentValues = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 const errors_js_1 = __webpack_require__(4189);
-const inspect_js_1 = __webpack_require__(6891);
+const inspect_js_1 = __webpack_require__(26891);
 /**
  * Prepares an object map of argument values given a list of argument
  * definitions and list of argument AST nodes.
@@ -3902,13 +5803,13 @@ exports.getArgumentValues = getArgumentValues;
 
 /***/ }),
 
-/***/ 6365:
+/***/ 56365:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.getObjectTypeFromTypeMap = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 function getObjectTypeFromTypeMap(typeMap, type) {
     if (type) {
         const maybeObjectType = typeMap[type.name];
@@ -3922,14 +5823,14 @@ exports.getObjectTypeFromTypeMap = getObjectTypeFromTypeMap;
 
 /***/ }),
 
-/***/ 3724:
+/***/ 30236:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.getOperationASTFromRequest = exports.getOperationASTFromDocument = void 0;
-const graphql_1 = __webpack_require__(7343);
-const memoize_js_1 = __webpack_require__(1251);
+const graphql_1 = __webpack_require__(57343);
+const memoize_js_1 = __webpack_require__(41251);
 function getOperationASTFromDocument(documentNode, operationName) {
     const doc = (0, graphql_1.getOperationAST)(documentNode, operationName);
     if (!doc) {
@@ -3945,13 +5846,13 @@ exports.getOperationASTFromRequest = (0, memoize_js_1.memoize1)(function getOper
 
 /***/ }),
 
-/***/ 2681:
+/***/ 32681:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.getResolversFromSchema = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 function getResolversFromSchema(schema, 
 // Include default merged resolvers
 includeDefaultMergedResolver) {
@@ -4025,7 +5926,7 @@ exports.getResolversFromSchema = getResolversFromSchema;
 
 /***/ }),
 
-/***/ 2241:
+/***/ 32241:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -4044,13 +5945,13 @@ exports.getResponseKeyFromInfo = getResponseKeyFromInfo;
 
 /***/ }),
 
-/***/ 2043:
+/***/ 52043:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.healTypes = exports.healSchema = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 // Update any references to named schema types that disagree with the named
 // types found in schema.getTypeMap().
 //
@@ -4228,13 +6129,13 @@ exports.healTypes = healTypes;
 
 /***/ }),
 
-/***/ 2971:
+/***/ 62971:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.assertSome = exports.isSome = exports.compareNodes = exports.nodeToString = exports.compareStrings = exports.isValidPath = exports.isDocumentString = exports.asArray = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 const asArray = (fns) => (Array.isArray(fns) ? fns : fns ? [fns] : []);
 exports.asArray = asArray;
 const invalidDocRegex = /\.[a-z0-9]+$/i;
@@ -4311,13 +6212,13 @@ exports.assertSome = assertSome;
 
 /***/ }),
 
-/***/ 7325:
+/***/ 87325:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.implementsAbstractType = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 function implementsAbstractType(schema, typeA, typeB) {
     if (typeB == null || typeA == null) {
         return false;
@@ -4335,67 +6236,67 @@ exports.implementsAbstractType = implementsAbstractType;
 
 /***/ }),
 
-/***/ 2371:
+/***/ 22371:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-const tslib_1 = __webpack_require__(752);
-tslib_1.__exportStar(__webpack_require__(9636), exports);
-tslib_1.__exportStar(__webpack_require__(2971), exports);
-tslib_1.__exportStar(__webpack_require__(755), exports);
-tslib_1.__exportStar(__webpack_require__(6415), exports);
-tslib_1.__exportStar(__webpack_require__(1281), exports);
-tslib_1.__exportStar(__webpack_require__(5943), exports);
-tslib_1.__exportStar(__webpack_require__(6415), exports);
-tslib_1.__exportStar(__webpack_require__(5779), exports);
-tslib_1.__exportStar(__webpack_require__(2811), exports);
-tslib_1.__exportStar(__webpack_require__(6354), exports);
+const tslib_1 = __webpack_require__(40752);
+tslib_1.__exportStar(__webpack_require__(89636), exports);
+tslib_1.__exportStar(__webpack_require__(62971), exports);
+tslib_1.__exportStar(__webpack_require__(50755), exports);
+tslib_1.__exportStar(__webpack_require__(46415), exports);
+tslib_1.__exportStar(__webpack_require__(21281), exports);
+tslib_1.__exportStar(__webpack_require__(55943), exports);
+tslib_1.__exportStar(__webpack_require__(46415), exports);
+tslib_1.__exportStar(__webpack_require__(85779), exports);
+tslib_1.__exportStar(__webpack_require__(72811), exports);
+tslib_1.__exportStar(__webpack_require__(86354), exports);
 tslib_1.__exportStar(__webpack_require__(3079), exports);
-tslib_1.__exportStar(__webpack_require__(5606), exports);
-tslib_1.__exportStar(__webpack_require__(4723), exports);
-tslib_1.__exportStar(__webpack_require__(2043), exports);
-tslib_1.__exportStar(__webpack_require__(2681), exports);
+tslib_1.__exportStar(__webpack_require__(75606), exports);
+tslib_1.__exportStar(__webpack_require__(14723), exports);
+tslib_1.__exportStar(__webpack_require__(52043), exports);
+tslib_1.__exportStar(__webpack_require__(32681), exports);
 tslib_1.__exportStar(__webpack_require__(7291), exports);
-tslib_1.__exportStar(__webpack_require__(5446), exports);
-tslib_1.__exportStar(__webpack_require__(1275), exports);
-tslib_1.__exportStar(__webpack_require__(7146), exports);
-tslib_1.__exportStar(__webpack_require__(4545), exports);
-tslib_1.__exportStar(__webpack_require__(8852), exports);
+tslib_1.__exportStar(__webpack_require__(35446), exports);
+tslib_1.__exportStar(__webpack_require__(11275), exports);
+tslib_1.__exportStar(__webpack_require__(37146), exports);
+tslib_1.__exportStar(__webpack_require__(74545), exports);
+tslib_1.__exportStar(__webpack_require__(98852), exports);
 tslib_1.__exportStar(__webpack_require__(1472), exports);
-tslib_1.__exportStar(__webpack_require__(8352), exports);
+tslib_1.__exportStar(__webpack_require__(58352), exports);
 tslib_1.__exportStar(__webpack_require__(1242), exports);
-tslib_1.__exportStar(__webpack_require__(4679), exports);
-tslib_1.__exportStar(__webpack_require__(2241), exports);
-tslib_1.__exportStar(__webpack_require__(6590), exports);
-tslib_1.__exportStar(__webpack_require__(1174), exports);
-tslib_1.__exportStar(__webpack_require__(8305), exports);
-tslib_1.__exportStar(__webpack_require__(8964), exports);
-tslib_1.__exportStar(__webpack_require__(7717), exports);
-tslib_1.__exportStar(__webpack_require__(7325), exports);
+tslib_1.__exportStar(__webpack_require__(84679), exports);
+tslib_1.__exportStar(__webpack_require__(32241), exports);
+tslib_1.__exportStar(__webpack_require__(56590), exports);
+tslib_1.__exportStar(__webpack_require__(71174), exports);
+tslib_1.__exportStar(__webpack_require__(88305), exports);
+tslib_1.__exportStar(__webpack_require__(78964), exports);
+tslib_1.__exportStar(__webpack_require__(77717), exports);
+tslib_1.__exportStar(__webpack_require__(87325), exports);
 tslib_1.__exportStar(__webpack_require__(4189), exports);
-tslib_1.__exportStar(__webpack_require__(236), exports);
+tslib_1.__exportStar(__webpack_require__(10236), exports);
 tslib_1.__exportStar(__webpack_require__(7141), exports);
-tslib_1.__exportStar(__webpack_require__(7882), exports);
-tslib_1.__exportStar(__webpack_require__(674), exports);
-tslib_1.__exportStar(__webpack_require__(6192), exports);
-tslib_1.__exportStar(__webpack_require__(9384), exports);
-tslib_1.__exportStar(__webpack_require__(9640), exports);
-tslib_1.__exportStar(__webpack_require__(5639), exports);
+tslib_1.__exportStar(__webpack_require__(17882), exports);
+tslib_1.__exportStar(__webpack_require__(60674), exports);
+tslib_1.__exportStar(__webpack_require__(26192), exports);
+tslib_1.__exportStar(__webpack_require__(49384), exports);
+tslib_1.__exportStar(__webpack_require__(59640), exports);
+tslib_1.__exportStar(__webpack_require__(25639), exports);
 tslib_1.__exportStar(__webpack_require__(4608), exports);
 tslib_1.__exportStar(__webpack_require__(4840), exports);
-tslib_1.__exportStar(__webpack_require__(274), exports);
-tslib_1.__exportStar(__webpack_require__(5376), exports);
-tslib_1.__exportStar(__webpack_require__(7668), exports);
-tslib_1.__exportStar(__webpack_require__(6891), exports);
-tslib_1.__exportStar(__webpack_require__(1251), exports);
-tslib_1.__exportStar(__webpack_require__(8373), exports);
-tslib_1.__exportStar(__webpack_require__(3724), exports);
+tslib_1.__exportStar(__webpack_require__(30274), exports);
+tslib_1.__exportStar(__webpack_require__(85376), exports);
+tslib_1.__exportStar(__webpack_require__(67668), exports);
+tslib_1.__exportStar(__webpack_require__(26891), exports);
+tslib_1.__exportStar(__webpack_require__(41251), exports);
+tslib_1.__exportStar(__webpack_require__(58373), exports);
+tslib_1.__exportStar(__webpack_require__(30236), exports);
 
 
 /***/ }),
 
-/***/ 6891:
+/***/ 26891:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
@@ -4403,7 +6304,7 @@ tslib_1.__exportStar(__webpack_require__(3724), exports);
 // https://github.com/graphql/graphql-js/blob/main/src/jsutils/inspect.ts
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.inspect = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 const AggregateError_js_1 = __webpack_require__(4840);
 const MAX_RECURSIVE_DEPTH = 3;
 /**
@@ -4509,7 +6410,7 @@ function getObjectTag(object) {
 
 /***/ }),
 
-/***/ 6192:
+/***/ 26192:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -4526,13 +6427,13 @@ exports.isAsyncIterable = isAsyncIterable;
 
 /***/ }),
 
-/***/ 9384:
+/***/ 49384:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.isDocumentNode = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 function isDocumentNode(object) {
     return object && typeof object === 'object' && 'kind' in object && object.kind === graphql_1.Kind.DOCUMENT;
 }
@@ -4541,7 +6442,7 @@ exports.isDocumentNode = isDocumentNode;
 
 /***/ }),
 
-/***/ 9636:
+/***/ 89636:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -4550,7 +6451,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 
 /***/ }),
 
-/***/ 8964:
+/***/ 78964:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -4610,17 +6511,17 @@ function iteratorResult(value) {
 
 /***/ }),
 
-/***/ 1275:
+/***/ 11275:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.correctASTNodes = exports.mapSchema = void 0;
-const graphql_1 = __webpack_require__(7343);
-const getObjectTypeFromTypeMap_js_1 = __webpack_require__(6365);
-const Interfaces_js_1 = __webpack_require__(8352);
-const rewire_js_1 = __webpack_require__(4545);
-const transformInputValue_js_1 = __webpack_require__(8305);
+const graphql_1 = __webpack_require__(57343);
+const getObjectTypeFromTypeMap_js_1 = __webpack_require__(56365);
+const Interfaces_js_1 = __webpack_require__(58352);
+const rewire_js_1 = __webpack_require__(74545);
+const transformInputValue_js_1 = __webpack_require__(88305);
 function mapSchema(schema, schemaMapper = {}) {
     const newTypeMap = mapArguments(mapFields(mapTypes(mapDefaultValues(mapEnumValues(mapTypes(mapDefaultValues(schema.getTypeMap(), schema, transformInputValue_js_1.serializeInputValue), schema, schemaMapper, type => (0, graphql_1.isLeafType)(type)), schema, schemaMapper), schema, transformInputValue_js_1.parseInputValue), schema, schemaMapper, type => !(0, graphql_1.isLeafType)(type)), schema, schemaMapper), schema, schemaMapper);
     const originalDirectives = schema.getDirectives();
@@ -5087,7 +6988,7 @@ exports.correctASTNodes = correctASTNodes;
 
 /***/ }),
 
-/***/ 1251:
+/***/ 41251:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -5289,7 +7190,7 @@ exports.memoize2of4 = memoize2of4;
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.mergeDeep = void 0;
-const helpers_js_1 = __webpack_require__(2971);
+const helpers_js_1 = __webpack_require__(62971);
 function mergeDeep(sources, respectPrototype = false) {
     const target = sources[0] || {};
     const output = {};
@@ -5335,7 +7236,7 @@ function isObject(item) {
 
 /***/ }),
 
-/***/ 236:
+/***/ 10236:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -5427,13 +7328,13 @@ exports.observableToAsyncIterable = observableToAsyncIterable;
 
 /***/ }),
 
-/***/ 2811:
+/***/ 72811:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.parseGraphQLJSON = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 function stripBOM(content) {
     content = content.toString();
     // Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
@@ -5478,14 +7379,14 @@ exports.parseGraphQLJSON = parseGraphQLJSON;
 
 /***/ }),
 
-/***/ 6354:
+/***/ 86354:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.isDescribable = exports.transformCommentsToDescriptions = exports.parseGraphQLSDL = void 0;
-const graphql_1 = __webpack_require__(7343);
-const comments_js_1 = __webpack_require__(5376);
+const graphql_1 = __webpack_require__(57343);
+const comments_js_1 = __webpack_require__(85376);
 function parseGraphQLSDL(location, rawSDL, options = {}) {
     let document;
     try {
@@ -5569,18 +7470,18 @@ exports.isDescribable = isDescribable;
 
 /***/ }),
 
-/***/ 5943:
+/***/ 55943:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.makeDirectiveNodes = exports.makeDirectiveNode = exports.makeDeprecatedDirective = exports.astFromEnumValue = exports.astFromInputField = exports.astFromField = exports.astFromScalarType = exports.astFromEnumType = exports.astFromInputObjectType = exports.astFromUnionType = exports.astFromInterfaceType = exports.astFromObjectType = exports.astFromArg = exports.getDeprecatableDirectiveNodes = exports.getDirectiveNodes = exports.astFromDirective = exports.astFromSchema = exports.printSchemaWithDirectives = exports.getDocumentNodeFromSchema = void 0;
-const graphql_1 = __webpack_require__(7343);
-const astFromType_js_1 = __webpack_require__(9969);
-const get_directives_js_1 = __webpack_require__(755);
-const astFromValueUntyped_js_1 = __webpack_require__(9640);
-const helpers_js_1 = __webpack_require__(2971);
-const rootTypes_js_1 = __webpack_require__(274);
+const graphql_1 = __webpack_require__(57343);
+const astFromType_js_1 = __webpack_require__(29969);
+const get_directives_js_1 = __webpack_require__(50755);
+const astFromValueUntyped_js_1 = __webpack_require__(59640);
+const helpers_js_1 = __webpack_require__(62971);
+const rootTypes_js_1 = __webpack_require__(30274);
 function getDocumentNodeFromSchema(schema, options = {}) {
     const pathToDirectivesInExtensions = options.pathToDirectivesInExtensions;
     const typesMap = schema.getTypeMap();
@@ -6070,17 +7971,17 @@ exports.makeDirectiveNodes = makeDirectiveNodes;
 
 /***/ }),
 
-/***/ 8852:
+/***/ 98852:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.pruneSchema = void 0;
-const graphql_1 = __webpack_require__(7343);
-const mapSchema_js_1 = __webpack_require__(1275);
-const Interfaces_js_1 = __webpack_require__(8352);
-const rootTypes_js_1 = __webpack_require__(274);
-const get_implementing_types_js_1 = __webpack_require__(1281);
+const graphql_1 = __webpack_require__(57343);
+const mapSchema_js_1 = __webpack_require__(11275);
+const Interfaces_js_1 = __webpack_require__(58352);
+const rootTypes_js_1 = __webpack_require__(30274);
+const get_implementing_types_js_1 = __webpack_require__(21281);
 /**
  * Prunes the provided schema, removing unused and empty types
  * @param schema The schema to prune
@@ -6210,13 +8111,13 @@ function visitQueue(queue, schema, visited = new Set()) {
 
 /***/ }),
 
-/***/ 1174:
+/***/ 71174:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.renameType = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 function renameType(type, newTypeName) {
     if ((0, graphql_1.isObjectType)(type)) {
         return new graphql_1.GraphQLObjectType({
@@ -6369,13 +8270,13 @@ exports.renameType = renameType;
 
 /***/ }),
 
-/***/ 4545:
+/***/ 74545:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.rewireTypes = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 const stub_js_1 = __webpack_require__(1242);
 function rewireTypes(originalTypeMap, directives) {
     const referenceTypeMap = Object.create(null);
@@ -6535,13 +8436,13 @@ exports.rewireTypes = rewireTypes;
 
 /***/ }),
 
-/***/ 274:
+/***/ 30274:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.getRootTypeMap = exports.getRootTypes = exports.getRootTypeNames = exports.getDefinedRootType = void 0;
-const memoize_js_1 = __webpack_require__(1251);
+const memoize_js_1 = __webpack_require__(41251);
 function getDefinedRootType(schema, operation) {
     const rootTypeMap = (0, exports.getRootTypeMap)(schema);
     const rootType = rootTypeMap.get(operation);
@@ -6579,13 +8480,13 @@ exports.getRootTypeMap = (0, memoize_js_1.memoize1)(function getRootTypeMap(sche
 
 /***/ }),
 
-/***/ 4679:
+/***/ 84679:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.parseSelectionSet = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 function parseSelectionSet(selectionSet, options) {
     const query = (0, graphql_1.parse)(selectionSet, options).definitions[0];
     return query.selectionSet;
@@ -6601,7 +8502,7 @@ exports.parseSelectionSet = parseSelectionSet;
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.getBuiltInForStub = exports.isNamedStub = exports.createStub = exports.createNamedStub = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 function createNamedStub(name, type) {
     let constructor;
     if (type === 'object') {
@@ -6670,13 +8571,13 @@ exports.getBuiltInForStub = getBuiltInForStub;
 
 /***/ }),
 
-/***/ 8305:
+/***/ 88305:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.parseInputValueLiteral = exports.parseInputValue = exports.serializeInputValue = exports.transformInputValue = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 function transformInputValue(type, value, inputLeafValueTransformer = null, inputObjectValueTransformer = null) {
     if (value == null) {
         return value;
@@ -6732,7 +8633,7 @@ exports.parseInputValueLiteral = parseInputValueLiteral;
 
 /***/ }),
 
-/***/ 5606:
+/***/ 75606:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -6766,14 +8667,14 @@ var DirectiveLocation;
 
 /***/ }),
 
-/***/ 7717:
+/***/ 77717:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.createVariableNameGenerator = exports.updateArgument = void 0;
-const graphql_1 = __webpack_require__(7343);
-const astFromType_js_1 = __webpack_require__(9969);
+const graphql_1 = __webpack_require__(57343);
+const astFromType_js_1 = __webpack_require__(29969);
 function updateArgument(argumentNodes, variableDefinitionsMap, variableValues, argName, varName, type, value) {
     argumentNodes[argName] = {
         kind: graphql_1.Kind.ARGUMENT,
@@ -6827,13 +8728,13 @@ exports.createVariableNameGenerator = createVariableNameGenerator;
 
 /***/ }),
 
-/***/ 5779:
+/***/ 85779:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.createDefaultRules = exports.checkValidationErrors = exports.validateGraphQlDocuments = void 0;
-const graphql_1 = __webpack_require__(7343);
+const graphql_1 = __webpack_require__(57343);
 const AggregateError_js_1 = __webpack_require__(4840);
 async function validateGraphQlDocuments(schema, documentFiles, effectiveRules = createDefaultRules()) {
     const allFragmentMap = new Map();
@@ -6910,7 +8811,7 @@ exports.createDefaultRules = createDefaultRules;
 
 /***/ }),
 
-/***/ 674:
+/***/ 60674:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -6944,9 +8845,9 @@ exports.valueMatchesCriteria = valueMatchesCriteria;
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.visitResult = exports.visitErrors = exports.visitData = void 0;
-const getOperationASTFromRequest_js_1 = __webpack_require__(3724);
-const graphql_1 = __webpack_require__(7343);
-const collectFields_js_1 = __webpack_require__(7668);
+const getOperationASTFromRequest_js_1 = __webpack_require__(30236);
+const graphql_1 = __webpack_require__(57343);
+const collectFields_js_1 = __webpack_require__(67668);
 function visitData(data, enter, leave) {
     if (Array.isArray(data)) {
         return data.map(value => visitData(value, enter, leave));
@@ -7180,7 +9081,7 @@ function addPathSegmentInfo(type, fieldName, pathIndex, errors = [], errorInfo)
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.withCancel = exports.getAsyncIterableWithCancel = exports.getAsyncIteratorWithCancel = void 0;
-const memoize_js_1 = __webpack_require__(1251);
+const memoize_js_1 = __webpack_require__(41251);
 async function defaultAsyncIteratorReturn(value) {
     return { value, done: true };
 }