{"version":3,"sources":["jsdelivr-header.js","/npm/@graphql-tools/delegate@12.0.2/dist/index.js"],"names":[],"mappings":"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","file":"/npm/@graphql-tools/delegate@12.0.2/dist/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/@graphql-tools/delegate@12.0.2/dist/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","import { memoize2, memoize1, promiseReduce, collectFields, relocatedError, mergeDeep, pathToArray, getResponseKeyFromInfo, memoize3, getDefinedRootType, createGraphQLError, implementsAbstractType, getRootTypeNames, astFromArg, astFromValueUntyped, asArray, isAsyncIterable, getOperationASTFromRequest } from '@graphql-tools/utils';\nexport { createDeferred } from '@graphql-tools/utils';\nimport { GraphQLError, locatedError, isAbstractType, getNullableType, isLeafType, isCompositeType, isListType, responsePathAsArray, Kind, TypeInfo, versionInfo, visit, visitWithTypeInfo, isNullableType, isUnionType, getNamedType, isObjectType, isInterfaceType, isNonNullType, isInputObjectType, defaultFieldResolver, isSchema, validate } from 'graphql';\nimport { handleMaybePromise, isPromise, createDeferredPromise, mapAsyncIterator } from '@whatwg-node/promise-helpers';\nimport { CRITICAL_ERROR, executorFromSchema } from '@graphql-tools/executor';\nexport { executorFromSchema as createDefaultExecutor } from '@graphql-tools/executor';\nimport { getBatchingExecutor } from '@graphql-tools/batch-execute';\nimport { Repeater } from '@repeaterjs/repeater';\n\nconst applySchemaTransforms = memoize2(function applySchemaTransforms2(originalWrappingSchema, subschemaConfig) {\n  const schemaTransforms = subschemaConfig.transforms;\n  if (schemaTransforms == null) {\n    return originalWrappingSchema;\n  }\n  return schemaTransforms.reduce(\n    (schema, transform) => transform.transformSchema?.(schema, subschemaConfig) || schema,\n    originalWrappingSchema\n  );\n});\n\nfunction isSubschema(value) {\n  return Boolean(value.transformedSchema);\n}\nclass Subschema {\n  name;\n  schema;\n  executor;\n  batch;\n  batchingOptions;\n  createProxyingResolver;\n  transforms;\n  _transformedSchema;\n  merge;\n  constructor(config) {\n    this.name = config.name;\n    this.schema = config.schema;\n    this.executor = config.executor;\n    this.batch = config.batch;\n    this.batchingOptions = config.batchingOptions;\n    this.createProxyingResolver = config.createProxyingResolver;\n    this.transforms = config.transforms ?? [];\n    this.merge = config.merge;\n  }\n  get transformedSchema() {\n    if (!this._transformedSchema) {\n      if (globalThis.process?.env?.[\"DEBUG\"] != null) {\n        console.warn(\n          \"Transformed schema is not set yet. Returning a dummy one.\"\n        );\n      }\n      this._transformedSchema = applySchemaTransforms(this.schema, this);\n    }\n    return this._transformedSchema;\n  }\n  set transformedSchema(value) {\n    this._transformedSchema = value;\n  }\n}\n\nconst prototypePollutingKeys = [\n  \"__proto__\",\n  \"constructor\",\n  \"prototype\"\n];\nfunction isPrototypePollutingKey(key) {\n  return prototypePollutingKeys.includes(key);\n}\n\nconst leftOverByDelegationPlan = /* @__PURE__ */ new WeakMap();\nconst PLAN_LEFT_OVER = Symbol(\"PLAN_LEFT_OVER\");\nfunction getPlanLeftOverFromParent(parent) {\n  if (parent != null && typeof parent === \"object\") {\n    return parent[PLAN_LEFT_OVER];\n  }\n  return void 0;\n}\n\nconst UNPATHED_ERRORS_SYMBOL = Symbol.for(\"subschemaErrors\");\nconst OBJECT_SUBSCHEMA_SYMBOL = Symbol.for(\"initialSubschema\");\nconst FIELD_SUBSCHEMA_MAP_SYMBOL = Symbol.for(\"subschemaMap\");\n\nfunction isExternalObject(data) {\n  return data[UNPATHED_ERRORS_SYMBOL] !== void 0;\n}\nfunction annotateExternalObject(object, errors, subschema, subschemaMap) {\n  Object.defineProperties(object, {\n    [OBJECT_SUBSCHEMA_SYMBOL]: { value: subschema, writable: true },\n    [FIELD_SUBSCHEMA_MAP_SYMBOL]: { value: subschemaMap, writable: true },\n    [UNPATHED_ERRORS_SYMBOL]: { value: errors, writable: true }\n  });\n  return object;\n}\nfunction getSubschema(object, responseKey) {\n  return object[FIELD_SUBSCHEMA_MAP_SYMBOL]?.[responseKey] ?? object[OBJECT_SUBSCHEMA_SYMBOL];\n}\nfunction getUnpathedErrors(object) {\n  return object[UNPATHED_ERRORS_SYMBOL];\n}\nconst EMPTY_ARRAY = [];\nconst EMPTY_OBJECT = /* @__PURE__ */ Object.create(null);\nconst getActualFieldNodes = memoize1(function(fieldNode) {\n  return [fieldNode];\n});\nfunction mergeFields(mergedTypeInfo, object, sourceSubschema, context, info) {\n  const delegationMaps = mergedTypeInfo.delegationPlanBuilder(\n    info.schema,\n    sourceSubschema,\n    info.variableValues != null && Object.keys(info.variableValues).length > 0 ? info.variableValues : EMPTY_OBJECT,\n    info.fragments != null && Object.keys(info.fragments).length > 0 ? info.fragments : EMPTY_OBJECT,\n    info.fieldNodes?.length ? info.fieldNodes.length === 1 && info.fieldNodes[0] ? getActualFieldNodes(info.fieldNodes[0]) : info.fieldNodes : EMPTY_ARRAY,\n    context,\n    info\n  );\n  const leftOver = leftOverByDelegationPlan.get(delegationMaps);\n  if (leftOver) {\n    object[PLAN_LEFT_OVER] = leftOver;\n  }\n  return handleMaybePromise(\n    () => promiseReduce(\n      delegationMaps,\n      (_, delegationMap) => executeDelegationStage(\n        mergedTypeInfo,\n        delegationMap,\n        object,\n        context,\n        info\n      ),\n      void 0\n    ),\n    () => object\n  );\n}\nfunction handleResolverResult(resolverResult, subschema, selectionSet, object, combinedFieldSubschemaMap, info, path, combinedErrors) {\n  if (resolverResult instanceof Error || resolverResult == null) {\n    const schema = subschema.transformedSchema || info.schema;\n    const type = schema.getType(object.__typename);\n    const { fields } = collectFields(\n      schema,\n      info.fragments,\n      info.variableValues,\n      type,\n      selectionSet\n    );\n    const nullResult = {};\n    for (const [responseKey, fieldNodes] of fields) {\n      const combinedPath = [...path, responseKey];\n      if (resolverResult instanceof GraphQLError) {\n        if (resolverResult.message.includes(\n          \"Cannot return null for non-nullable field\"\n        )) {\n          nullResult[responseKey] = null;\n        } else {\n          nullResult[responseKey] = relocatedError(\n            resolverResult,\n            combinedPath\n          );\n        }\n      } else if (resolverResult instanceof Error) {\n        nullResult[responseKey] = locatedError(\n          resolverResult,\n          fieldNodes,\n          combinedPath\n        );\n      } else {\n        nullResult[responseKey] = null;\n      }\n    }\n    resolverResult = nullResult;\n  } else {\n    if (resolverResult[UNPATHED_ERRORS_SYMBOL]) {\n      combinedErrors.push(...resolverResult[UNPATHED_ERRORS_SYMBOL]);\n    }\n  }\n  const objectSubschema = resolverResult[OBJECT_SUBSCHEMA_SYMBOL];\n  const fieldSubschemaMap = resolverResult[FIELD_SUBSCHEMA_MAP_SYMBOL];\n  for (const responseKey in resolverResult) {\n    if (isPrototypePollutingKey(responseKey)) {\n      continue;\n    }\n    const existingPropValue = object[responseKey];\n    const sourcePropValue = resolverResult[responseKey];\n    if (responseKey === \"__typename\" && existingPropValue !== sourcePropValue && isAbstractType(subschema.transformedSchema.getType(sourcePropValue))) {\n      continue;\n    }\n    if (sourcePropValue != null || existingPropValue == null) {\n      if (existingPropValue != null && typeof existingPropValue === \"object\" && !(existingPropValue instanceof Error) && Object.keys(existingPropValue).length > 0) {\n        if (Array.isArray(existingPropValue) && Array.isArray(sourcePropValue) && existingPropValue.length === sourcePropValue.length) {\n          object[responseKey] = existingPropValue.map(\n            (existingElement, index) => sourcePropValue instanceof Error ? existingElement : mergeDeep(\n              [existingElement, sourcePropValue[index]],\n              void 0,\n              true,\n              true\n            )\n          );\n        } else if (!(sourcePropValue instanceof Error)) {\n          object[responseKey] = mergeDeep(\n            [existingPropValue, sourcePropValue],\n            void 0,\n            true,\n            true\n          );\n        }\n      } else {\n        object[responseKey] = sourcePropValue;\n      }\n    }\n    combinedFieldSubschemaMap[responseKey] = fieldSubschemaMap?.[responseKey] ?? objectSubschema ?? subschema;\n  }\n}\nfunction executeDelegationStage(mergedTypeInfo, delegationMap, object, context, info) {\n  const combinedErrors = object[UNPATHED_ERRORS_SYMBOL];\n  const path = pathToArray(info.path);\n  const combinedFieldSubschemaMap = object[FIELD_SUBSCHEMA_MAP_SYMBOL];\n  const jobs = [];\n  for (const [subschema, selectionSet] of delegationMap) {\n    const schema = subschema.transformedSchema || info.schema;\n    const type = schema.getType(object.__typename);\n    const resolver = mergedTypeInfo.resolvers.get(subschema);\n    if (resolver) {\n      try {\n        const resolverResult$ = resolver(\n          object,\n          context,\n          info,\n          subschema,\n          selectionSet,\n          void 0,\n          type\n        );\n        if (isPromise(resolverResult$)) {\n          jobs.push(\n            resolverResult$.then(\n              (resolverResult) => handleResolverResult(\n                resolverResult,\n                subschema,\n                selectionSet,\n                object,\n                combinedFieldSubschemaMap,\n                info,\n                path,\n                combinedErrors\n              ),\n              (error) => handleResolverResult(\n                error,\n                subschema,\n                selectionSet,\n                object,\n                combinedFieldSubschemaMap,\n                info,\n                path,\n                combinedErrors\n              )\n            )\n          );\n        } else {\n          handleResolverResult(\n            resolverResult$,\n            subschema,\n            selectionSet,\n            object,\n            combinedFieldSubschemaMap,\n            info,\n            path,\n            combinedErrors\n          );\n        }\n      } catch (error) {\n        handleResolverResult(\n          error,\n          subschema,\n          selectionSet,\n          object,\n          combinedFieldSubschemaMap,\n          info,\n          path,\n          combinedErrors\n        );\n      }\n    }\n  }\n  if (jobs.length) {\n    if (jobs.length === 1) {\n      return jobs[0];\n    }\n    return Promise.all(jobs);\n  }\n}\n\nfunction resolveExternalValue(result, unpathedErrors, subschema, context, info, returnType = getReturnType$1(info), skipTypeMerging) {\n  const type = getNullableType(returnType);\n  if (result instanceof Error) {\n    return result;\n  }\n  if (result == null) {\n    return reportUnpathedErrorsViaNull(unpathedErrors);\n  }\n  if (isLeafType(type)) {\n    try {\n      return type.parseValue(result);\n    } catch {\n      return null;\n    }\n  } else if (isCompositeType(type)) {\n    return handleMaybePromise(\n      () => resolveExternalObject(\n        type,\n        result,\n        unpathedErrors,\n        subschema,\n        context,\n        info,\n        skipTypeMerging\n      ),\n      (result2) => {\n        if (info && isAbstractType(type)) {\n          if (result2.__typename != null) {\n            const resolvedType = info.schema.getType(result2.__typename);\n            if (!resolvedType) {\n              return null;\n            }\n          }\n          return result2;\n        }\n        return result2;\n      }\n    );\n  } else if (isListType(type)) {\n    if (Array.isArray(result)) {\n      return resolveExternalList(\n        type,\n        result,\n        unpathedErrors,\n        subschema,\n        context,\n        info,\n        skipTypeMerging\n      );\n    }\n    return resolveExternalValue(\n      result,\n      unpathedErrors,\n      subschema,\n      context,\n      info,\n      type.ofType,\n      skipTypeMerging\n    );\n  }\n}\nfunction resolveExternalObject(type, object, unpathedErrors, subschema, context, info, skipTypeMerging) {\n  if (!isExternalObject(object)) {\n    annotateExternalObject(\n      object,\n      unpathedErrors,\n      subschema,\n      /* @__PURE__ */ Object.create(null)\n    );\n  }\n  if (skipTypeMerging || info == null) {\n    return object;\n  }\n  const stitchingInfo = info.schema.extensions?.[\"stitchingInfo\"];\n  if (stitchingInfo == null) {\n    return object;\n  }\n  let mergedTypeInfo;\n  const possibleTypeNames = [object.__typename, type.name];\n  for (const possibleTypeName of possibleTypeNames) {\n    if (possibleTypeName != null && stitchingInfo.mergedTypes[possibleTypeName]?.targetSubschemas?.get(\n      subschema\n    )?.length) {\n      mergedTypeInfo = stitchingInfo.mergedTypes[possibleTypeName];\n      break;\n    }\n  }\n  if (!mergedTypeInfo) {\n    for (const possibleTypeName of possibleTypeNames) {\n      const potentialMergedTypeInfo = stitchingInfo.mergedTypes[possibleTypeName];\n      if (potentialMergedTypeInfo != null) {\n        for (const [\n          sourceSubschema,\n          targetSubschemas\n        ] of potentialMergedTypeInfo.targetSubschemas) {\n          if (targetSubschemas.length && sourceSubschema.name === subschema.name) {\n            subschema = sourceSubschema;\n            mergedTypeInfo = potentialMergedTypeInfo;\n          }\n        }\n        break;\n      }\n    }\n  }\n  if (!mergedTypeInfo) {\n    return object;\n  }\n  return mergeFields(\n    mergedTypeInfo,\n    object,\n    subschema,\n    context,\n    info\n  );\n}\nfunction resolveExternalList(type, list, unpathedErrors, subschema, context, info, skipTypeMerging) {\n  return list.map(\n    (listMember) => resolveExternalValue(\n      listMember,\n      unpathedErrors,\n      subschema,\n      context,\n      info,\n      type.ofType,\n      skipTypeMerging\n    )\n  );\n}\nconst reportedErrors = /* @__PURE__ */ new WeakSet();\nfunction reportUnpathedErrorsViaNull(unpathedErrors) {\n  if (unpathedErrors.length) {\n    const unreportedErrors = [];\n    for (const error of unpathedErrors) {\n      if (!reportedErrors.has(error)) {\n        unreportedErrors.push(error);\n        reportedErrors.add(error);\n      }\n    }\n    if (unreportedErrors.length) {\n      const unreportedError = unreportedErrors[0];\n      if (unreportedErrors.length === 1 && unreportedError) {\n        return locatedError(\n          unreportedError,\n          void 0,\n          unreportedError.path\n        );\n      }\n      return new AggregateError(\n        unreportedErrors.map(\n          (e) => (\n            // We cast path as any for GraphQL.js 14 compat\n            // locatedError path argument must be defined, but it is just forwarded to a constructor that allows a undefined value\n            // https://github.com/graphql/graphql-js/blob/b4bff0ba9c15c9d7245dd68556e754c41f263289/src/error/locatedError.js#L25\n            // https://github.com/graphql/graphql-js/blob/b4bff0ba9c15c9d7245dd68556e754c41f263289/src/error/GraphQLError.js#L19\n            locatedError(e, void 0, unreportedError?.path)\n          )\n        ),\n        unreportedErrors.map((error) => error.message).join(\", \\n\")\n      );\n    }\n  }\n  return null;\n}\nfunction getReturnType$1(info) {\n  if (info == null) {\n    throw new Error(`Return type cannot be inferred without a source schema.`);\n  }\n  return info.returnType;\n}\n\nfunction checkResultAndHandleErrors(result = {\n  data: null,\n  errors: []\n}, delegationContext) {\n  const {\n    context,\n    info,\n    fieldName: responseKey = getResponseKey(info),\n    subschema,\n    returnType = getReturnType(info),\n    skipTypeMerging,\n    onLocatedError\n  } = delegationContext;\n  const { data, unpathedErrors } = mergeDataAndErrors(\n    result.data == null ? void 0 : result.data[responseKey],\n    result.errors == null ? [] : result.errors,\n    info != null && info.path ? responsePathAsArray(info.path) : void 0,\n    onLocatedError\n  );\n  return resolveExternalValue(\n    data,\n    unpathedErrors,\n    subschema,\n    context,\n    info,\n    returnType,\n    skipTypeMerging\n  );\n}\nfunction mergeDataAndErrors(data, errors, path, onLocatedError, index = 1) {\n  if (data == null) {\n    if (!errors.length) {\n      return { data: null, unpathedErrors: [] };\n    }\n    if (errors.length === 1 && errors[0]) {\n      const error = onLocatedError ? onLocatedError(errors[0]) : errors[0];\n      const newPath = path === void 0 ? error.path : !error.path ? path : path.concat(error.path.slice(1));\n      return { data: relocatedError(errors[0], newPath), unpathedErrors: [] };\n    }\n    const combinedError = new AggregateError(\n      errors.map((e) => {\n        const error = onLocatedError ? onLocatedError(e) : e;\n        const newPath = path === void 0 ? error.path : !error.path ? path : path.concat(error.path.slice(1));\n        return relocatedError(error, newPath);\n      }),\n      errors.map((error) => error.message).join(\",\\n\")\n    );\n    return { data: combinedError, unpathedErrors: [] };\n  }\n  if (!errors.length) {\n    return { data, unpathedErrors: [] };\n  }\n  const unpathedErrors = [];\n  const errorMap = /* @__PURE__ */ new Map();\n  for (const error of errors) {\n    const pathSegment = error.path?.[index];\n    if (pathSegment != null) {\n      let pathSegmentErrors = errorMap.get(pathSegment);\n      if (pathSegmentErrors === void 0) {\n        pathSegmentErrors = [error];\n        errorMap.set(pathSegment, pathSegmentErrors);\n      } else {\n        pathSegmentErrors.push(error);\n      }\n    } else {\n      unpathedErrors.push(error);\n    }\n  }\n  for (const [pathSegment, pathSegmentErrors] of errorMap) {\n    if (data[pathSegment] !== void 0) {\n      const { data: newData, unpathedErrors: newErrors } = mergeDataAndErrors(\n        data[pathSegment],\n        pathSegmentErrors,\n        path,\n        onLocatedError,\n        index + 1\n      );\n      data[pathSegment] = newData;\n      unpathedErrors.push(...newErrors);\n    } else {\n      unpathedErrors.push(...pathSegmentErrors);\n    }\n  }\n  return { data, unpathedErrors };\n}\nfunction getResponseKey(info) {\n  if (info == null) {\n    throw new Error(\n      `Data cannot be extracted from result without an explicit key or source schema.`\n    );\n  }\n  return getResponseKeyFromInfo(info);\n}\nfunction getReturnType(info) {\n  if (info == null) {\n    throw new Error(`Return type cannot be inferred without a source schema.`);\n  }\n  return info.returnType;\n}\n\nfunction getDocumentMetadata(document) {\n  const operations = [];\n  const fragments = [];\n  const fragmentNames = /* @__PURE__ */ new Set();\n  for (let i = 0; i < document.definitions.length; i++) {\n    const def = document.definitions[i];\n    if (def?.kind === Kind.FRAGMENT_DEFINITION) {\n      fragments.push(def);\n      fragmentNames.add(def.name.value);\n    } else if (def?.kind === Kind.OPERATION_DEFINITION) {\n      operations.push(def);\n    }\n  }\n  return {\n    operations,\n    fragments,\n    fragmentNames\n  };\n}\n\nconst getTypeInfo = memoize1(function getTypeInfo2(schema) {\n  return new TypeInfo(schema);\n});\nconst getTypeInfoWithType = memoize2(function getTypeInfoWithType2(schema, type) {\n  return versionInfo.major < 16 ? new TypeInfo(schema, void 0, type) : new TypeInfo(schema, type);\n});\n\nconst handleOverrideByDelegation = memoize3(\n  function handleOverrideByDelegation2(info, context, overrideHandler) {\n    return overrideHandler(context, info);\n  }\n);\n\nfunction finalizeGatewayDocument(targetSchema, fragments, operations, onOverlappingAliases, delegationContext) {\n  let usedVariables = [];\n  let usedFragments = [];\n  const newOperations = [];\n  let newFragments = [];\n  const validFragments = [];\n  const validFragmentsWithType = /* @__PURE__ */ Object.create(null);\n  for (const fragment of fragments) {\n    const typeName = fragment.typeCondition.name.value;\n    const type = targetSchema.getType(typeName);\n    if (type != null) {\n      validFragments.push(fragment);\n      validFragmentsWithType[fragment.name.value] = type;\n    }\n  }\n  let fragmentSet = /* @__PURE__ */ Object.create(null);\n  let selectionCnt = 0;\n  for (const operation of operations) {\n    const type = getDefinedRootType(targetSchema, operation.operation);\n    const {\n      selectionSet,\n      usedFragments: operationUsedFragments,\n      usedVariables: operationUsedVariables\n    } = finalizeSelectionSet(\n      targetSchema,\n      type,\n      validFragmentsWithType,\n      operation.selectionSet,\n      onOverlappingAliases,\n      delegationContext\n    );\n    usedFragments = union(usedFragments, operationUsedFragments);\n    const {\n      usedVariables: collectedUsedVariables,\n      newFragments: collectedNewFragments,\n      fragmentSet: collectedFragmentSet\n    } = collectFragmentVariables(\n      targetSchema,\n      fragmentSet,\n      validFragments,\n      validFragmentsWithType,\n      usedFragments,\n      onOverlappingAliases,\n      delegationContext\n    );\n    const operationOrFragmentVariables = union(\n      operationUsedVariables,\n      collectedUsedVariables\n    );\n    usedVariables = union(usedVariables, operationOrFragmentVariables);\n    newFragments = collectedNewFragments;\n    fragmentSet = collectedFragmentSet;\n    const variableDefinitions = [];\n    for (const variableName of operationOrFragmentVariables) {\n      const variableDef = operation.variableDefinitions?.find(\n        (varDef) => varDef.variable.name.value === variableName\n      );\n      if (variableDef != null) {\n        variableDefinitions.push(variableDef);\n      } else {\n        const variableDef2 = delegationContext.info?.operation.variableDefinitions?.find(\n          (varDef) => varDef.variable.name.value === variableName\n        );\n        if (variableDef2 != null) {\n          variableDefinitions.push(variableDef2);\n        }\n      }\n    }\n    if (operation.operation === \"subscription\") {\n      selectionSet.selections = selectionSet.selections.filter(\n        (selection) => selection.kind !== Kind.FIELD || selection.name.value !== \"__typename\"\n      );\n    }\n    if (selectionSet.selections.length === 1 && selectionSet.selections[0] && selectionSet.selections[0].kind === Kind.FIELD && selectionSet.selections[0].name.value === \"__typename\") {\n      continue;\n    }\n    selectionCnt += selectionSet.selections.length;\n    newOperations.push({\n      kind: Kind.OPERATION_DEFINITION,\n      operation: operation.operation,\n      name: operation.name,\n      directives: operation.directives,\n      variableDefinitions,\n      selectionSet\n    });\n  }\n  if (!newOperations.length || selectionCnt === 0) {\n    throw createGraphQLError(\n      \"Failed to create a gateway request. The request must contain at least one operation.\",\n      {\n        extensions: {\n          [CRITICAL_ERROR]: true\n        }\n      }\n    );\n  }\n  let newDocument = {\n    kind: Kind.DOCUMENT,\n    definitions: [...newOperations, ...newFragments]\n  };\n  const stitchingInfo = delegationContext.info?.schema?.extensions?.[\"stitchingInfo\"];\n  if (stitchingInfo != null) {\n    const typeInfo = getTypeInfo(targetSchema);\n    newDocument = visit(\n      newDocument,\n      visitWithTypeInfo(typeInfo, {\n        [Kind.FIELD](fieldNode) {\n          const parentType = typeInfo.getParentType();\n          if (parentType) {\n            const parentTypeName = parentType.name;\n            const typeConfig = stitchingInfo?.mergedTypes?.[parentTypeName];\n            if (typeConfig) {\n              const providedSelectionsByField = typeConfig?.providedSelectionsByField?.get(\n                delegationContext.subschema\n              );\n              if (providedSelectionsByField) {\n                const providedSelection = providedSelectionsByField[fieldNode.name.value];\n                if (providedSelection) {\n                  return {\n                    ...fieldNode,\n                    selectionSet: {\n                      kind: Kind.SELECTION_SET,\n                      selections: [\n                        ...providedSelection.selections,\n                        ...fieldNode.selectionSet?.selections ?? []\n                      ]\n                    }\n                  };\n                }\n              }\n            }\n          }\n          return fieldNode;\n        }\n      })\n    );\n  }\n  return {\n    usedVariables,\n    newDocument\n  };\n}\nfunction finalizeGatewayRequest(originalRequest, delegationContext, onOverlappingAliases) {\n  let { operations, fragments } = getDocumentMetadata(originalRequest.document);\n  const { targetSchema } = delegationContext;\n  const { usedVariables, newDocument } = finalizeGatewayDocument(\n    targetSchema,\n    fragments,\n    operations,\n    onOverlappingAliases,\n    delegationContext\n  );\n  const newVariables = {};\n  const outerVariables = delegationContext.info?.variableValues;\n  for (const varName of usedVariables) {\n    const existingVar = originalRequest.variables?.[varName];\n    const outerVar = outerVariables?.[varName];\n    if (existingVar != null) {\n      newVariables[varName] = existingVar;\n    } else if (outerVar != null) {\n      newVariables[varName] = outerVar;\n    }\n    if (existingVar === null || outerVar === null) {\n      newVariables[varName] = null;\n    }\n  }\n  return {\n    ...originalRequest,\n    document: newDocument,\n    variables: newVariables\n  };\n}\nfunction isTypeNameField(selection) {\n  return selection.kind === Kind.FIELD && !selection.alias && selection.name.value === \"__typename\";\n}\nfunction filterTypenameFields(selections) {\n  let hasTypeNameField = false;\n  const filteredSelections = selections.filter((selection) => {\n    if (isTypeNameField(selection)) {\n      hasTypeNameField = true;\n      return false;\n    }\n    return true;\n  });\n  return {\n    hasTypeNameField,\n    selections: filteredSelections\n  };\n}\nfunction collectFragmentVariables(targetSchema, fragmentSet, validFragments, validFragmentsWithType, usedFragments, onOverlappingAliases, delegationContext) {\n  let remainingFragments = usedFragments.slice();\n  let usedVariables = [];\n  const newFragments = [];\n  while (remainingFragments.length !== 0) {\n    const nextFragmentName = remainingFragments.pop();\n    const fragment = validFragments.find(\n      (fr) => fr.name.value === nextFragmentName\n    );\n    if (fragment != null) {\n      const name = nextFragmentName;\n      const typeName = fragment.typeCondition.name.value;\n      const type = targetSchema.getType(typeName);\n      if (type == null) {\n        throw new Error(\n          `Fragment reference type \"${typeName}\", but the type is not contained within the target schema.`\n        );\n      }\n      const {\n        selectionSet,\n        usedFragments: fragmentUsedFragments,\n        usedVariables: fragmentUsedVariables\n      } = finalizeSelectionSet(\n        targetSchema,\n        type,\n        validFragmentsWithType,\n        fragment.selectionSet,\n        onOverlappingAliases,\n        delegationContext\n      );\n      remainingFragments = union(remainingFragments, fragmentUsedFragments);\n      usedVariables = union(usedVariables, fragmentUsedVariables);\n      if (name && !(name in fragmentSet)) {\n        fragmentSet[name] = true;\n        newFragments.push({\n          kind: Kind.FRAGMENT_DEFINITION,\n          name: {\n            kind: Kind.NAME,\n            value: name\n          },\n          typeCondition: fragment.typeCondition,\n          selectionSet\n        });\n      }\n    }\n  }\n  return {\n    usedVariables,\n    newFragments,\n    fragmentSet\n  };\n}\nconst filteredSelectionSetVisitorKeys = {\n  SelectionSet: [\"selections\"],\n  Field: [\"selectionSet\"],\n  InlineFragment: [\"selectionSet\"],\n  FragmentDefinition: [\"selectionSet\"]\n};\nconst variablesVisitorKeys = {\n  SelectionSet: [\"selections\"],\n  Field: [\"arguments\", \"directives\", \"selectionSet\"],\n  Argument: [\"value\"],\n  InlineFragment: [\"directives\", \"selectionSet\"],\n  FragmentSpread: [\"directives\"],\n  FragmentDefinition: [\"selectionSet\"],\n  ObjectValue: [\"fields\"],\n  ObjectField: [\"name\", \"value\"],\n  Directive: [\"arguments\"],\n  ListValue: [\"values\"]\n};\nfunction finalizeSelectionSet(schema, type, validFragments, selectionSet, onOverlappingAliases, delegationContext) {\n  const usedFragments = [];\n  const usedVariables = [];\n  const typeInfo = getTypeInfoWithType(schema, type);\n  const seenNonNullableMap = /* @__PURE__ */ new WeakMap();\n  const seenNullableMap = /* @__PURE__ */ new WeakMap();\n  const filteredSelectionSet = filterSelectionSet(\n    schema,\n    typeInfo,\n    validFragments,\n    selectionSet,\n    onOverlappingAliases,\n    usedFragments,\n    seenNonNullableMap,\n    seenNullableMap,\n    delegationContext\n  );\n  visit(\n    filteredSelectionSet,\n    {\n      [Kind.VARIABLE]: (variableNode) => {\n        usedVariables.push(variableNode.name.value);\n      }\n    },\n    // visitorKeys argument usage a la https://github.com/gatsbyjs/gatsby/blob/master/packages/gatsby-source-graphql/src/batching/merge-queries.js\n    // empty keys cannot be removed only because of typescript errors\n    // will hopefully be fixed in future version of graphql-js to be optional\n    variablesVisitorKeys\n  );\n  return {\n    selectionSet: filteredSelectionSet,\n    usedFragments,\n    usedVariables\n  };\n}\nfunction filterSelectionSet(schema, typeInfo, validFragments, selectionSet, onOverlappingAliases, usedFragments, seenNonNullableMap, seenNullableMap, delegationContext) {\n  return visit(\n    selectionSet,\n    visitWithTypeInfo(typeInfo, {\n      [Kind.FIELD]: {\n        enter: (node) => {\n          const parentType = typeInfo.getParentType();\n          const field = typeInfo.getFieldDef();\n          if (delegationContext.context != null && delegationContext.info != null && parentType != null && field != null) {\n            const parentTypeName = parentType.name;\n            const overrideHandler = delegationContext.subschemaConfig?.merge?.[parentTypeName]?.fields?.[field.name]?.override;\n            if (overrideHandler != null) {\n              const overridden = handleOverrideByDelegation(\n                delegationContext.info,\n                delegationContext.context,\n                overrideHandler\n              );\n              if (!overridden) {\n                return null;\n              }\n            }\n          }\n          if (isObjectType(parentType) || isInterfaceType(parentType)) {\n            if (!field) {\n              return null;\n            }\n            const args = field.args != null ? field.args : [];\n            const argsMap = /* @__PURE__ */ Object.create(null);\n            for (const arg of args) {\n              argsMap[arg.name] = arg;\n            }\n            if (node.arguments != null) {\n              const newArgs = [];\n              for (const arg of node.arguments) {\n                if (arg.name.value in argsMap) {\n                  newArgs.push(arg);\n                }\n              }\n              if (newArgs.length !== node.arguments.length) {\n                return {\n                  ...node,\n                  arguments: newArgs\n                };\n              }\n            }\n          }\n          if (isUnionType(parentType) && typeInfo.getType() == null) {\n            const possibleTypeNames = [];\n            const fieldName = node.name.value;\n            for (const memberType of parentType.getTypes()) {\n              const memberFields = memberType.getFields();\n              const possibleField = memberFields[fieldName];\n              if (possibleField != null) {\n                const namedType = getNamedType(possibleField.type);\n                if (node.selectionSet?.selections?.length && isLeafType(namedType)) {\n                  continue;\n                }\n                if (!node.selectionSet?.selections?.length && isCompositeType(namedType)) {\n                  continue;\n                }\n                possibleTypeNames.push(memberType.name);\n              }\n            }\n            if (possibleTypeNames.length > 0) {\n              const spreads = possibleTypeNames.map((possibleTypeName) => {\n                if (!node.selectionSet?.selections) {\n                  return {\n                    kind: Kind.INLINE_FRAGMENT,\n                    typeCondition: {\n                      kind: Kind.NAMED_TYPE,\n                      name: {\n                        kind: Kind.NAME,\n                        value: possibleTypeName\n                      }\n                    },\n                    selectionSet: {\n                      kind: Kind.SELECTION_SET,\n                      selections: [node]\n                    }\n                  };\n                }\n                const possibleType = schema.getType(\n                  possibleTypeName\n                );\n                const possibleField = possibleType.getFields()[node.name.value];\n                if (!possibleField) {\n                  return void 0;\n                }\n                const fieldFilteredSelectionSet = filterSelectionSet(\n                  schema,\n                  getTypeInfoWithType(schema, possibleField.type),\n                  validFragments,\n                  node.selectionSet,\n                  onOverlappingAliases,\n                  usedFragments,\n                  seenNonNullableMap,\n                  seenNullableMap,\n                  delegationContext\n                );\n                if (!fieldFilteredSelectionSet.selections.length) {\n                  return void 0;\n                }\n                return {\n                  kind: Kind.INLINE_FRAGMENT,\n                  typeCondition: {\n                    kind: Kind.NAMED_TYPE,\n                    name: {\n                      kind: Kind.NAME,\n                      value: possibleTypeName\n                    }\n                  },\n                  selectionSet: {\n                    kind: Kind.SELECTION_SET,\n                    selections: [\n                      {\n                        ...node,\n                        selectionSet: fieldFilteredSelectionSet\n                      }\n                    ]\n                  }\n                };\n              });\n              const nonEmptySpreads = spreads.filter(Boolean);\n              if (!nonEmptySpreads.length) {\n                return void 0;\n              }\n              return nonEmptySpreads;\n            }\n          }\n          return void 0;\n        },\n        leave: (node) => {\n          const type = typeInfo.getType();\n          if (type == null) {\n            return null;\n          }\n          const namedType = getNamedType(type);\n          if (schema.getType(namedType.name) == null) {\n            return null;\n          }\n          if (isObjectType(namedType) || isInterfaceType(namedType)) {\n            const selections = node.selectionSet != null ? node.selectionSet.selections : null;\n            if (selections == null || selections.length === 0) {\n              return null;\n            }\n          }\n          return void 0;\n        }\n      },\n      [Kind.FRAGMENT_SPREAD]: {\n        enter: (node) => {\n          if (!(node.name.value in validFragments)) {\n            return null;\n          }\n          const parentType = typeInfo.getParentType();\n          const innerType = validFragments[node.name.value];\n          if (!implementsAbstractType(schema, parentType, innerType)) {\n            return null;\n          }\n          usedFragments.push(node.name.value);\n          return void 0;\n        }\n      },\n      [Kind.SELECTION_SET]: {\n        enter: (node, _key, _parent, _path) => {\n          const parentType = typeInfo.getParentType();\n          const { hasTypeNameField, selections } = filterTypenameFields(\n            node.selections\n          );\n          if (hasTypeNameField || parentType != null && isAbstractType(parentType)) {\n            selections.unshift({\n              kind: Kind.FIELD,\n              name: {\n                kind: Kind.NAME,\n                value: \"__typename\"\n              }\n            });\n          }\n          return {\n            ...node,\n            selections\n          };\n        }\n      },\n      [Kind.INLINE_FRAGMENT]: {\n        enter: (node) => {\n          if (node.typeCondition != null) {\n            const parentType = typeInfo.getParentType();\n            const innerType = schema.getType(node.typeCondition.name.value);\n            if (isUnionType(parentType) && parentType.getTypes().some((t) => t.name === innerType?.name)) {\n              return node;\n            }\n            if (!implementsAbstractType(schema, parentType, innerType)) {\n              return null;\n            }\n          }\n          return void 0;\n        },\n        leave: (selection, _key, parent) => {\n          if (!selection.selectionSet?.selections?.length) {\n            return null;\n          }\n          if (Array.isArray(parent)) {\n            const selectionTypeName = selection.typeCondition?.name.value;\n            if (selectionTypeName) {\n              const selectionType = schema.getType(selectionTypeName);\n              if (selectionType && \"getFields\" in selectionType) {\n                const selectionTypeFields = selectionType.getFields();\n                let seenNonNullable = seenNonNullableMap.get(parent);\n                if (!seenNonNullable) {\n                  seenNonNullable = /* @__PURE__ */ new Set();\n                  seenNonNullableMap.set(parent, seenNonNullable);\n                }\n                let seenNullable = seenNullableMap.get(parent);\n                if (!seenNullable) {\n                  seenNullable = /* @__PURE__ */ new Set();\n                  seenNullableMap.set(parent, seenNullable);\n                }\n                selection = {\n                  ...selection,\n                  selectionSet: {\n                    ...selection.selectionSet,\n                    selections: selection.selectionSet.selections.map(\n                      (subSelection) => {\n                        if (subSelection.kind === Kind.FIELD) {\n                          const fieldName = subSelection.name.value;\n                          if (!subSelection.alias) {\n                            const field = selectionTypeFields[fieldName];\n                            if (field) {\n                              let currentNullable;\n                              if (isNullableType(field.type)) {\n                                seenNullable.add(fieldName);\n                                currentNullable = true;\n                              } else {\n                                seenNonNullable.add(fieldName);\n                                currentNullable = false;\n                              }\n                              if (seenNullable.has(fieldName) && seenNonNullable.has(fieldName)) {\n                                onOverlappingAliases();\n                                return {\n                                  ...subSelection,\n                                  alias: {\n                                    kind: Kind.NAME,\n                                    value: currentNullable ? `_nullable_${fieldName}` : `_nonNullable_${fieldName}`\n                                  }\n                                };\n                              }\n                            }\n                          }\n                        }\n                        return subSelection;\n                      }\n                    )\n                  }\n                };\n              }\n            }\n          }\n          const { selections } = filterTypenameFields(\n            selection.selectionSet.selections\n          );\n          if (selections.length === 0) {\n            return null;\n          }\n          return {\n            ...selection,\n            selectionSet: {\n              ...selection.selectionSet,\n              selections\n            },\n            // @defer is not available for the communication between the gw and subgraph\n            directives: selection.directives?.filter?.(\n              (directive) => directive.name.value !== \"defer\"\n            )\n          };\n        }\n      }\n    }),\n    // visitorKeys argument usage a la https://github.com/gatsbyjs/gatsby/blob/master/packages/gatsby-source-graphql/src/batching/merge-queries.js\n    // empty keys cannot be removed only because of typescript errors\n    // will hopefully be fixed in future version of graphql-js to be optional\n    filteredSelectionSetVisitorKeys\n  );\n}\nfunction union(...arrays) {\n  const cache = /* @__PURE__ */ Object.create(null);\n  const result = [];\n  for (const array of arrays) {\n    for (const item of array) {\n      if (!(item in cache)) {\n        cache[item] = true;\n        result.push(item);\n      }\n    }\n  }\n  return result;\n}\n\nfunction prepareGatewayDocument(originalDocument, transformedSchema, returnType, infoSchema) {\n  const wrappedConcreteTypesDocument = wrapConcreteTypes(\n    returnType,\n    transformedSchema,\n    originalDocument\n  );\n  if (infoSchema == null) {\n    return wrappedConcreteTypesDocument;\n  }\n  const visitedSelections = /* @__PURE__ */ new WeakSet();\n  const {\n    possibleTypesMap,\n    reversePossibleTypesMap: reversePossibleTypesMap2,\n    interfaceExtensionsMap,\n    fieldNodesByType,\n    fieldNodesByField,\n    dynamicSelectionSetsByField\n  } = getSchemaMetaData(infoSchema, transformedSchema);\n  const { operations, fragments, fragmentNames } = getDocumentMetadata(\n    wrappedConcreteTypesDocument\n  );\n  const { expandedFragments, fragmentReplacements } = getExpandedFragments(\n    fragments,\n    fragmentNames,\n    possibleTypesMap\n  );\n  const typeInfo = getTypeInfo(transformedSchema);\n  const expandedDocument = {\n    kind: Kind.DOCUMENT,\n    definitions: [...operations, ...fragments, ...expandedFragments]\n  };\n  const visitorKeyMap = {\n    Document: [\"definitions\"],\n    OperationDefinition: [\"selectionSet\"],\n    SelectionSet: [\"selections\"],\n    Field: [\"selectionSet\"],\n    InlineFragment: [\"selectionSet\"],\n    FragmentDefinition: [\"selectionSet\"]\n  };\n  return visit(\n    expandedDocument,\n    visitWithTypeInfo(typeInfo, {\n      [Kind.SELECTION_SET]: (node) => visitSelectionSet(\n        node,\n        fragmentReplacements,\n        transformedSchema,\n        typeInfo,\n        possibleTypesMap,\n        reversePossibleTypesMap2,\n        interfaceExtensionsMap,\n        fieldNodesByType,\n        fieldNodesByField,\n        dynamicSelectionSetsByField,\n        infoSchema,\n        visitedSelections\n      )\n    }),\n    // visitorKeys argument usage a la https://github.com/gatsbyjs/gatsby/blob/master/packages/gatsby-source-graphql/src/batching/merge-queries.js\n    // empty keys cannot be removed only because of typescript errors\n    // will hopefully be fixed in future version of graphql-js to be optional\n    visitorKeyMap\n  );\n}\nconst getExtraPossibleTypesFn = memoize2(function getExtraPossibleTypes(transformedSchema, infoSchema) {\n  const extraPossiblesTypesMap = /* @__PURE__ */ new Map();\n  return function getExtraPossibleTypes2(typeName) {\n    let extraTypesForSubschema = extraPossiblesTypesMap.get(typeName);\n    if (!extraTypesForSubschema) {\n      extraTypesForSubschema = /* @__PURE__ */ new Set();\n      const gatewayType = infoSchema.getType(typeName);\n      const subschemaType = transformedSchema.getType(typeName);\n      if (isAbstractType(gatewayType) && isAbstractType(subschemaType)) {\n        const possibleTypes = infoSchema.getPossibleTypes(gatewayType);\n        const possibleTypesInSubschema = transformedSchema.getPossibleTypes(subschemaType);\n        for (const possibleType of possibleTypes) {\n          const possibleTypeInSubschema = transformedSchema.getType(\n            possibleType.name\n          );\n          if (!possibleTypeInSubschema) {\n            continue;\n          }\n          if (possibleTypeInSubschema && possibleTypesInSubschema.some((t) => t.name === possibleType.name)) {\n            continue;\n          }\n          extraTypesForSubschema.add(possibleType.name);\n        }\n      }\n      extraPossiblesTypesMap.set(typeName, extraTypesForSubschema);\n    }\n    return extraTypesForSubschema;\n  };\n});\nfunction visitSelectionSet(node, fragmentReplacements, transformedSchema, typeInfo, possibleTypesMap, reversePossibleTypesMap2, interfaceExtensionsMap, fieldNodesByType, fieldNodesByField, dynamicSelectionSetsByField, infoSchema, visitedSelections) {\n  const newSelections = /* @__PURE__ */ new Set();\n  const maybeType = typeInfo.getParentType();\n  if (maybeType != null) {\n    const parentType = getNamedType(maybeType);\n    const parentTypeName = parentType.name;\n    const fieldNodes = fieldNodesByType[parentTypeName];\n    if (fieldNodes) {\n      for (const fieldNode of fieldNodes) {\n        newSelections.add(fieldNode);\n      }\n    }\n    const interfaceExtensions = interfaceExtensionsMap[parentType.name];\n    const interfaceExtensionFields = [];\n    for (const selection of node.selections) {\n      if (selection.kind === Kind.INLINE_FRAGMENT) {\n        if (selection.typeCondition != null) {\n          if (!visitedSelections.has(selection)) {\n            visitedSelections.add(selection);\n            const typeName = selection.typeCondition.name.value;\n            const getExtraPossibleTypes2 = getExtraPossibleTypesFn(\n              transformedSchema,\n              infoSchema\n            );\n            const extraPossibleTypes = getExtraPossibleTypes2(typeName);\n            for (const extraPossibleTypeName of extraPossibleTypes) {\n              newSelections.add({\n                ...selection,\n                typeCondition: {\n                  kind: Kind.NAMED_TYPE,\n                  name: {\n                    kind: Kind.NAME,\n                    value: extraPossibleTypeName\n                  }\n                }\n              });\n            }\n            const typeInSubschema = transformedSchema.getType(typeName);\n            if (isObjectType(typeInSubschema) || isInterfaceType(typeInSubschema)) {\n              const fieldMap = typeInSubschema.getFields();\n              for (const subSelection of selection.selectionSet.selections) {\n                if (subSelection.kind === Kind.FIELD) {\n                  const fieldName = subSelection.name.value;\n                  const field = fieldMap[fieldName];\n                  if (!field) {\n                    newSelections.add(subSelection);\n                  }\n                }\n              }\n            } else if (!typeInSubschema) {\n              for (const subSelection of selection.selectionSet.selections) {\n                newSelections.add(subSelection);\n              }\n            }\n          }\n          const possibleTypes = possibleTypesMap[selection.typeCondition.name.value];\n          if (possibleTypes == null) {\n            const fieldNodesForTypeName = fieldNodesByField[parentTypeName]?.[\"__typename\"];\n            if (fieldNodesForTypeName) {\n              for (const fieldNode of fieldNodesForTypeName) {\n                newSelections.add(fieldNode);\n              }\n            }\n            newSelections.add(selection);\n            continue;\n          }\n          for (const possibleTypeName of possibleTypes) {\n            const maybePossibleType = transformedSchema.getType(possibleTypeName);\n            if (maybePossibleType != null && implementsAbstractType(\n              transformedSchema,\n              parentType,\n              maybePossibleType\n            )) {\n              newSelections.add(\n                generateInlineFragment(\n                  possibleTypeName,\n                  selection.selectionSet\n                )\n              );\n            }\n          }\n          if (possibleTypes.length === 0) {\n            newSelections.add(selection);\n          }\n        } else {\n          newSelections.add(selection);\n        }\n      } else if (selection.kind === Kind.FRAGMENT_SPREAD) {\n        const fragmentName = selection.name.value;\n        if (!fragmentReplacements[fragmentName]) {\n          newSelections.add(selection);\n          continue;\n        }\n        for (const replacement of fragmentReplacements[fragmentName]) {\n          const typeName = replacement.typeName;\n          const maybeReplacementType = transformedSchema.getType(typeName);\n          if (maybeReplacementType != null && implementsAbstractType(transformedSchema, parentType, maybeType)) {\n            newSelections.add({\n              kind: Kind.FRAGMENT_SPREAD,\n              name: {\n                kind: Kind.NAME,\n                value: replacement.fragmentName\n              }\n            });\n          }\n        }\n      } else {\n        const fieldName = selection.name.value;\n        if (isAbstractType(parentType)) {\n          const fieldNodesForTypeName = fieldNodesByField[parentTypeName]?.[\"__typename\"];\n          if (fieldNodesForTypeName) {\n            for (const fieldNode of fieldNodesForTypeName) {\n              newSelections.add(fieldNode);\n            }\n          }\n        }\n        const fieldNodesMapForType = fieldNodesByField[parentTypeName];\n        if (fieldNodesMapForType) {\n          addDependenciesNestedly(\n            selection,\n            /* @__PURE__ */ new Set(),\n            fieldNodesMapForType,\n            newSelections\n          );\n        }\n        const dynamicSelectionSets = dynamicSelectionSetsByField[parentTypeName]?.[fieldName];\n        if (dynamicSelectionSets != null) {\n          for (const selectionSetFn of dynamicSelectionSets) {\n            const selectionSet = selectionSetFn(selection);\n            if (selectionSet != null) {\n              for (const selection2 of selectionSet.selections) {\n                newSelections.add(selection2);\n              }\n            }\n          }\n        }\n        if (interfaceExtensions?.[fieldName]) {\n          interfaceExtensionFields.push(selection);\n        } else {\n          newSelections.add(selection);\n        }\n      }\n    }\n    if (reversePossibleTypesMap2[parentType.name]) {\n      newSelections.add({\n        kind: Kind.FIELD,\n        name: {\n          kind: Kind.NAME,\n          value: \"__typename\"\n        }\n      });\n    }\n    if (interfaceExtensionFields.length) {\n      const possibleTypes = possibleTypesMap[parentType.name];\n      if (possibleTypes != null) {\n        for (const possibleType of possibleTypes) {\n          newSelections.add(\n            generateInlineFragment(possibleType, {\n              kind: Kind.SELECTION_SET,\n              selections: interfaceExtensionFields\n            })\n          );\n        }\n      }\n    }\n    return {\n      ...node,\n      selections: Array.from(newSelections)\n    };\n  }\n  return node;\n}\nfunction addDependenciesNestedly(fieldNode, seenFieldNames, fieldNodesByField, newSelections) {\n  if (seenFieldNames.has(fieldNode.name.value)) {\n    return;\n  }\n  seenFieldNames.add(fieldNode.name.value);\n  const fieldNodes = fieldNodesByField[fieldNode.name.value];\n  if (fieldNodes != null) {\n    for (const nestedFieldNode of fieldNodes) {\n      newSelections.add(nestedFieldNode);\n      addDependenciesNestedly(\n        nestedFieldNode,\n        seenFieldNames,\n        fieldNodesByField,\n        newSelections\n      );\n    }\n  }\n}\nfunction generateInlineFragment(typeName, selectionSet) {\n  return {\n    kind: Kind.INLINE_FRAGMENT,\n    typeCondition: {\n      kind: Kind.NAMED_TYPE,\n      name: {\n        kind: Kind.NAME,\n        value: typeName\n      }\n    },\n    selectionSet\n  };\n}\nconst getSchemaMetaData = memoize2(\n  (sourceSchema, targetSchema) => {\n    const typeMap = sourceSchema.getTypeMap();\n    const targetTypeMap = targetSchema.getTypeMap();\n    const possibleTypesMap = /* @__PURE__ */ Object.create(null);\n    const interfaceExtensionsMap = /* @__PURE__ */ Object.create(null);\n    for (const typeName in typeMap) {\n      const type = typeMap[typeName];\n      if (isAbstractType(type)) {\n        const targetType = targetTypeMap[typeName];\n        if (isInterfaceType(type) && isInterfaceType(targetType)) {\n          const targetTypeFields = targetType.getFields();\n          const sourceTypeFields = type.getFields();\n          const extensionFields = /* @__PURE__ */ Object.create(null);\n          let isExtensionFieldsEmpty = true;\n          for (const fieldName in sourceTypeFields) {\n            if (!targetTypeFields[fieldName]) {\n              extensionFields[fieldName] = true;\n              isExtensionFieldsEmpty = false;\n            }\n          }\n          if (!isExtensionFieldsEmpty) {\n            interfaceExtensionsMap[typeName] = extensionFields;\n          }\n        }\n        if (interfaceExtensionsMap[typeName] || !isAbstractType(targetType)) {\n          const implementations = sourceSchema.getPossibleTypes(type);\n          possibleTypesMap[typeName] = [];\n          for (const impl of implementations) {\n            if (targetTypeMap[impl.name]) {\n              possibleTypesMap[typeName].push(impl.name);\n            }\n          }\n        }\n      }\n    }\n    const stitchingInfo = sourceSchema.extensions?.[\"stitchingInfo\"];\n    return {\n      possibleTypesMap,\n      reversePossibleTypesMap: reversePossibleTypesMap(possibleTypesMap),\n      interfaceExtensionsMap,\n      fieldNodesByType: stitchingInfo?.fieldNodesByType ?? {},\n      fieldNodesByField: stitchingInfo?.fieldNodesByField ?? {},\n      dynamicSelectionSetsByField: stitchingInfo?.dynamicSelectionSetsByField ?? {}\n    };\n  }\n);\nfunction reversePossibleTypesMap(possibleTypesMap) {\n  const result = /* @__PURE__ */ Object.create(null);\n  for (const typeName in possibleTypesMap) {\n    const toTypeNames = possibleTypesMap[typeName];\n    if (toTypeNames) {\n      for (const toTypeName of toTypeNames) {\n        if (!result[toTypeName]) {\n          result[toTypeName] = [];\n        }\n        result[toTypeName].push(typeName);\n      }\n    }\n  }\n  return result;\n}\nfunction getExpandedFragments(fragments, fragmentNames, possibleTypesMap) {\n  let fragmentCounter = 0;\n  function generateFragmentName(typeName) {\n    let fragmentName;\n    do {\n      fragmentName = `_${typeName}_Fragment${fragmentCounter.toString()}`;\n      fragmentCounter++;\n    } while (fragmentNames.has(fragmentName));\n    return fragmentName;\n  }\n  const expandedFragments = [];\n  const fragmentReplacements = /* @__PURE__ */ Object.create(null);\n  for (const fragment of fragments) {\n    const possibleTypes = possibleTypesMap[fragment.typeCondition.name.value];\n    if (possibleTypes != null) {\n      const fragmentName = fragment.name.value;\n      fragmentReplacements[fragmentName] = [];\n      for (const possibleTypeName of possibleTypes) {\n        const name = generateFragmentName(possibleTypeName);\n        fragmentNames.add(name);\n        expandedFragments.push({\n          kind: Kind.FRAGMENT_DEFINITION,\n          name: {\n            kind: Kind.NAME,\n            value: name\n          },\n          typeCondition: {\n            kind: Kind.NAMED_TYPE,\n            name: {\n              kind: Kind.NAME,\n              value: possibleTypeName\n            }\n          },\n          selectionSet: fragment.selectionSet\n        });\n        fragmentReplacements[fragmentName].push({\n          fragmentName: name,\n          typeName: possibleTypeName\n        });\n      }\n    }\n  }\n  return {\n    expandedFragments,\n    fragmentReplacements\n  };\n}\nfunction wrapConcreteTypes(returnType, targetSchema, document) {\n  const namedType = getNamedType(returnType);\n  if (isLeafType(namedType)) {\n    return document;\n  }\n  let possibleTypes = isAbstractType(\n    namedType\n  ) ? targetSchema.getPossibleTypes(namedType) : [namedType];\n  if (possibleTypes.length === 0) {\n    possibleTypes = [namedType];\n  }\n  const rootTypeNames = getRootTypeNames(targetSchema);\n  const typeInfo = getTypeInfo(targetSchema);\n  const visitorKeys = {\n    Document: [\"definitions\"],\n    OperationDefinition: [\"selectionSet\"],\n    SelectionSet: [\"selections\"],\n    InlineFragment: [\"selectionSet\"],\n    FragmentDefinition: [\"selectionSet\"]\n  };\n  return visit(\n    document,\n    visitWithTypeInfo(typeInfo, {\n      [Kind.FRAGMENT_DEFINITION]: (node) => {\n        const typeName = node.typeCondition.name.value;\n        if (!rootTypeNames.has(typeName)) {\n          return false;\n        }\n        return void 0;\n      },\n      [Kind.FIELD]: (node) => {\n        const fieldType = typeInfo.getType();\n        if (fieldType) {\n          const fieldNamedType = getNamedType(fieldType);\n          if (isAbstractType(fieldNamedType) && fieldNamedType.name !== namedType.name && possibleTypes.length > 0) {\n            return {\n              ...node,\n              selectionSet: {\n                kind: Kind.SELECTION_SET,\n                selections: possibleTypes.map((possibleType) => ({\n                  kind: Kind.INLINE_FRAGMENT,\n                  typeCondition: {\n                    kind: Kind.NAMED_TYPE,\n                    name: {\n                      kind: Kind.NAME,\n                      value: possibleType.name\n                    }\n                  },\n                  selectionSet: node.selectionSet\n                }))\n              }\n            };\n          }\n        }\n        return void 0;\n      }\n    }),\n    // visitorKeys argument usage a la https://github.com/gatsbyjs/gatsby/blob/master/packages/gatsby-source-graphql/src/batching/merge-queries.js\n    // empty keys cannot be removed only because of typescript errors\n    // will hopefully be fixed in future version of graphql-js to be optional\n    visitorKeys\n  );\n}\n\nclass Transformer {\n  transformations = [];\n  delegationContext;\n  hasOverlappingAliases = false;\n  constructor(context) {\n    this.delegationContext = context;\n    const transforms = context.transforms;\n    const delegationTransforms = transforms.slice().reverse();\n    for (const transform of delegationTransforms) {\n      this.addTransform(transform);\n    }\n  }\n  addTransform(transform, context = {}) {\n    this.transformations.push({ transform, context });\n  }\n  transformRequest(originalRequest) {\n    let request = {\n      ...originalRequest,\n      document: prepareGatewayDocument(\n        originalRequest.document,\n        this.delegationContext.transformedSchema,\n        this.delegationContext.returnType,\n        this.delegationContext.info?.schema\n      )\n    };\n    for (const transformation of this.transformations) {\n      if (transformation.transform.transformRequest) {\n        request = transformation.transform.transformRequest(\n          request,\n          this.delegationContext,\n          transformation.context\n        );\n      }\n    }\n    return finalizeGatewayRequest(request, this.delegationContext, () => {\n      this.hasOverlappingAliases = true;\n    });\n  }\n  transformResult(originalResult) {\n    let result = originalResult;\n    for (let i = this.transformations.length - 1; i >= 0; i--) {\n      const transformation = this.transformations[i];\n      if (transformation?.transform.transformResult) {\n        result = transformation.transform.transformResult(\n          result,\n          this.delegationContext,\n          transformation.context\n        );\n      }\n    }\n    if (this.hasOverlappingAliases) {\n      result = removeOverlappingAliases(result);\n    }\n    return checkResultAndHandleErrors(result, this.delegationContext);\n  }\n}\nfunction removeOverlappingAliases(result) {\n  if (result != null) {\n    if (Array.isArray(result)) {\n      return result.map(removeOverlappingAliases);\n    } else if (typeof result === \"object\") {\n      const newResult = {};\n      for (const key in result) {\n        if (key.startsWith(\"_nullable_\") || key.startsWith(\"_nonNullable_\")) {\n          const newKey = key.replace(/^_nullable_/, \"\").replace(/^_nonNullable_/, \"\");\n          newResult[newKey] = removeOverlappingAliases(result[key]);\n        } else {\n          newResult[key] = removeOverlappingAliases(result[key]);\n        }\n      }\n      return newResult;\n    }\n  }\n  return result;\n}\n\nfunction getDelegatingOperation(parentType, schema) {\n  if (parentType === schema.getMutationType()) {\n    return \"mutation\";\n  } else if (parentType === schema.getSubscriptionType()) {\n    return \"subscription\";\n  }\n  return \"query\";\n}\nfunction createRequest({\n  subgraphName,\n  fragments,\n  rootValue,\n  targetOperationName,\n  targetOperation,\n  targetSchema,\n  targetFieldName,\n  selectionSet,\n  fieldNodes,\n  context,\n  info,\n  args\n}) {\n  let newSelectionSet;\n  if (selectionSet != null) {\n    newSelectionSet = selectionSet;\n  } else {\n    const selections = [];\n    for (const fieldNode2 of fieldNodes || []) {\n      if (fieldNode2.selectionSet) {\n        for (const selection of fieldNode2.selectionSet.selections) {\n          selections.push(selection);\n        }\n      }\n    }\n    newSelectionSet = selections.length ? {\n      kind: Kind.SELECTION_SET,\n      selections\n    } : void 0;\n  }\n  const fieldNode = fieldNodes?.[0];\n  const rootFieldName = targetFieldName ?? fieldNode?.name.value;\n  if (rootFieldName === void 0) {\n    throw new Error(\n      `Either \"targetFieldName\" or a non empty \"fieldNodes\" array must be provided.`\n    );\n  }\n  const newVariables = /* @__PURE__ */ Object.create(null);\n  const variableDefinitions = [];\n  const argNodes = [];\n  if (args != null) {\n    const rootType = targetSchema != null ? getDefinedRootType(targetSchema, targetOperation) : void 0;\n    const rootField = rootType?.getFields()[rootFieldName];\n    const rootFieldArgs = rootField?.args;\n    for (const argName in args) {\n      const argValue = args[argName];\n      const argInstance = rootFieldArgs?.find((arg) => arg.name === argName);\n      if (argInstance) {\n        const argAst = astFromArg(argInstance, targetSchema);\n        const varExists = (varName2) => variableDefinitions.some(\n          (varDef) => varDef.variable.name.value === varName2\n        );\n        let varName = argName;\n        if (varExists(varName)) {\n          varName = `_${rootFieldName}_${argName}`;\n          let i = 0;\n          while (varExists(varName)) {\n            varName = `_${i++}_${rootFieldName}_${argName}`;\n          }\n        }\n        variableDefinitions.push({\n          kind: Kind.VARIABLE_DEFINITION,\n          variable: {\n            kind: Kind.VARIABLE,\n            name: {\n              kind: Kind.NAME,\n              value: varName\n            }\n          },\n          type: argAst.type\n        });\n        newVariables[varName] = projectArgumentValue(\n          argValue,\n          argInstance.type\n        );\n        argNodes.push({\n          kind: Kind.ARGUMENT,\n          name: {\n            kind: Kind.NAME,\n            value: argName\n          },\n          value: {\n            kind: Kind.VARIABLE,\n            name: {\n              kind: Kind.NAME,\n              value: varName\n            }\n          }\n        });\n      } else {\n        const valueNode = astFromValueUntyped(argValue);\n        if (valueNode != null) {\n          argNodes.push({\n            kind: Kind.ARGUMENT,\n            name: {\n              kind: Kind.NAME,\n              value: argName\n            },\n            value: valueNode\n          });\n        }\n      }\n    }\n  }\n  const rootfieldNode = {\n    kind: Kind.FIELD,\n    arguments: argNodes,\n    name: {\n      kind: Kind.NAME,\n      value: rootFieldName\n    },\n    selectionSet: newSelectionSet,\n    directives: fieldNode?.directives\n  };\n  const operationName = targetOperationName ? {\n    kind: Kind.NAME,\n    value: targetOperationName\n  } : void 0;\n  const operationDefinition = {\n    kind: Kind.OPERATION_DEFINITION,\n    name: operationName,\n    operation: targetOperation,\n    variableDefinitions,\n    selectionSet: {\n      kind: Kind.SELECTION_SET,\n      selections: [rootfieldNode]\n    }\n  };\n  const definitions = [operationDefinition];\n  if (fragments != null) {\n    definitions.push(...fragments);\n  }\n  const document = {\n    kind: Kind.DOCUMENT,\n    definitions\n  };\n  return {\n    subgraphName,\n    document,\n    variables: newVariables,\n    rootValue,\n    operationName: targetOperationName,\n    context,\n    info,\n    operationType: targetOperation\n  };\n}\nfunction projectArgumentValue(argValue, argType) {\n  if (isNonNullType(argType)) {\n    return projectArgumentValue(argValue, argType.ofType);\n  }\n  if (isListType(argType)) {\n    return asArray(argValue).map(\n      (item) => projectArgumentValue(item, argType.ofType)\n    );\n  }\n  if (isInputObjectType(argType) && typeof argValue === \"object\" && argValue !== null) {\n    const projectedValue = {};\n    const fields = argType.getFields();\n    for (const key in argValue) {\n      const field = fields[key];\n      if (field) {\n        projectedValue[key] = projectArgumentValue(argValue[key], field.type);\n      }\n    }\n    return projectedValue;\n  }\n  if (argValue != null) {\n    if (argType.name === \"Boolean\") {\n      return Boolean(argValue);\n    }\n    if (argType.name === \"Int\" || argType.name === \"Float\") {\n      return Number(argValue);\n    }\n    if (argType.name === \"String\") {\n      return String(argValue);\n    }\n  }\n  return argValue;\n}\n\nfunction defaultMergedResolver(parent, args, context, info) {\n  if (!parent) {\n    return null;\n  }\n  const responseKey = getResponseKeyFromInfo(info);\n  if (!isExternalObject(parent)) {\n    return defaultFieldResolver(parent, args, context, info);\n  }\n  if (!Object.prototype.hasOwnProperty.call(parent, responseKey)) {\n    const leftOver = getPlanLeftOverFromParent(parent);\n    if (leftOver) {\n      let missingFieldNodes = leftOver.missingFieldsParentMap.get(parent);\n      if (!missingFieldNodes) {\n        missingFieldNodes = [];\n        leftOver.missingFieldsParentMap.set(parent, missingFieldNodes);\n      }\n      missingFieldNodes.push(\n        ...info.fieldNodes.filter(\n          (fieldNode) => leftOver.unproxiableFieldNodes.some(\n            (unproxiableFieldNode) => unproxiableFieldNode === fieldNode\n          )\n        )\n      );\n      let missingDeferredFields = leftOver.missingFieldsParentDeferredMap.get(parent);\n      if (!missingDeferredFields) {\n        missingDeferredFields = /* @__PURE__ */ new Map();\n        leftOver.missingFieldsParentDeferredMap.set(\n          parent,\n          missingDeferredFields\n        );\n      }\n      const deferred = createDeferredPromise();\n      missingDeferredFields.set(responseKey, deferred);\n      const stitchingInfo = info.schema.extensions?.[\"stitchingInfo\"];\n      const parentTypeName = parent?.__typename || info.parentType.name;\n      const fieldNodesByType = stitchingInfo?.fieldNodesByField?.[parentTypeName]?.[info.fieldName];\n      if (fieldNodesByType?.every((fieldNode) => {\n        const responseKey2 = fieldNode.alias?.value ?? fieldNode.name.value;\n        return Object.prototype.hasOwnProperty.call(parent, responseKey2);\n      })) {\n        handleResult(parent, responseKey, context, info);\n      } else {\n        handleLeftOver(parent, context, info, leftOver);\n      }\n      return deferred.promise;\n    }\n    return void 0;\n  }\n  return handleResult(parent, responseKey, context, info);\n}\nfunction handleResult(parent, responseKey, context, info) {\n  const subschema = getSubschema(parent, responseKey);\n  const data = parent[responseKey];\n  const unpathedErrors = getUnpathedErrors(parent);\n  const resolvedData$ = resolveExternalValue(\n    data,\n    unpathedErrors,\n    subschema,\n    context,\n    info\n  );\n  const leftOver = getPlanLeftOverFromParent(parent);\n  if (leftOver) {\n    return handleMaybePromise(\n      () => resolvedData$,\n      (resolvedData) => {\n        parent[responseKey] = resolvedData;\n        handleLeftOver(parent, context, info, leftOver);\n        return resolvedData;\n      }\n    );\n  }\n  return resolvedData$;\n}\nfunction handleLeftOver(parent, context, info, leftOver) {\n  const stitchingInfo = info.schema.extensions?.[\"stitchingInfo\"];\n  if (stitchingInfo) {\n    for (const possibleSubschema of leftOver.nonProxiableSubschemas) {\n      const parentTypeName = info.parentType.name;\n      const selectionSets = /* @__PURE__ */ new Set();\n      const mainSelectionSet = stitchingInfo.mergedTypes[parentTypeName]?.selectionSets.get(\n        possibleSubschema\n      );\n      if (mainSelectionSet) {\n        selectionSets.add(mainSelectionSet);\n      }\n      for (const fieldNode of leftOver.unproxiableFieldNodes) {\n        const fieldName = fieldNode.name.value;\n        const fieldSelectionSet = stitchingInfo.mergedTypes[parentTypeName]?.fieldSelectionSets.get(\n          possibleSubschema\n        )?.[fieldName];\n        if (fieldSelectionSet) {\n          selectionSets.add(fieldSelectionSet);\n        }\n      }\n      if (selectionSets.size) {\n        const selectionSet = {\n          kind: Kind.SELECTION_SET,\n          selections: Array.from(selectionSets).flatMap(\n            (selectionSet2) => selectionSet2.selections\n          )\n        };\n        handleMaybePromise(\n          () => flattenPromise(parent),\n          (flattenedParent) => {\n            handleFlattenedParent(\n              flattenedParent,\n              parent,\n              possibleSubschema,\n              selectionSet,\n              leftOver,\n              stitchingInfo,\n              parentTypeName,\n              context,\n              info\n            );\n          }\n        );\n      }\n    }\n  }\n}\nfunction handleFlattenedParent(flattenedParent, leftOverParent, possibleSubschema, selectionSet, leftOver, stitchingInfo, parentTypeName, context, info) {\n  if (parentSatisfiedSelectionSet(flattenedParent, selectionSet)) {\n    const missingFieldNodes = leftOver.missingFieldsParentMap.get(leftOverParent);\n    if (missingFieldNodes) {\n      const resolver = stitchingInfo.mergedTypes[parentTypeName]?.resolvers.get(\n        possibleSubschema\n      );\n      if (resolver) {\n        Object.assign(leftOverParent, flattenedParent);\n        const selectionSet2 = {\n          kind: Kind.SELECTION_SET,\n          selections: missingFieldNodes\n        };\n        handleMaybePromise(\n          () => resolver(\n            leftOverParent,\n            context,\n            info,\n            possibleSubschema,\n            selectionSet2,\n            info.parentType,\n            info.parentType\n          ),\n          (resolverResult) => {\n            handleDeferredResolverResult(\n              resolverResult,\n              possibleSubschema,\n              selectionSet2,\n              leftOverParent,\n              leftOver,\n              context,\n              info\n            );\n          },\n          (error) => handleDeferredResolverFailure(leftOver, leftOverParent, error)\n        );\n      }\n    }\n  } else {\n    for (const selectionNode of selectionSet.selections) {\n      if (selectionNode.kind === Kind.FIELD && selectionNode.selectionSet?.selections?.length) {\n        const responseKey = selectionNode.alias?.value ?? selectionNode.name.value;\n        const nestedParent = flattenedParent[responseKey];\n        const nestedSelectionSet = selectionNode.selectionSet;\n        if (nestedParent != null) {\n          if (!parentSatisfiedSelectionSet(nestedParent, nestedSelectionSet)) {\n            async function handleNestedParentItem(nestedParentItem, fieldNode) {\n              const nestedTypeName = nestedParentItem[\"__typename\"];\n              const sourceSubschema = getSubschema(\n                flattenedParent,\n                responseKey\n              );\n              if (sourceSubschema && nestedTypeName) {\n                const delegationPlan = stitchingInfo.mergedTypes[nestedTypeName]?.delegationPlanBuilder(\n                  info.schema,\n                  sourceSubschema,\n                  info.variableValues != null && Object.keys(info.variableValues).length > 0 ? info.variableValues : EMPTY_OBJECT,\n                  info.fragments != null && Object.keys(info.fragments).length > 0 ? info.fragments : EMPTY_OBJECT,\n                  getActualFieldNodes(fieldNode),\n                  context,\n                  info\n                );\n                if (delegationPlan?.length) {\n                  for (const delegationMap of delegationPlan) {\n                    for (const [subschema, selectionSet2] of delegationMap) {\n                      const resolver = stitchingInfo.mergedTypes[nestedTypeName]?.resolvers.get(subschema);\n                      if (resolver) {\n                        const subschemaTypes = stitchingInfo.mergedTypes[nestedTypeName].typeMaps.get(subschema);\n                        const returnType = subschemaTypes[nestedTypeName];\n                        const res = await resolver(\n                          nestedParentItem,\n                          context,\n                          info,\n                          subschema,\n                          selectionSet2,\n                          returnType,\n                          // returnType\n                          info.parentType\n                        );\n                        if (res) {\n                          handleResolverResult(\n                            res,\n                            subschema,\n                            selectionSet2,\n                            nestedParentItem,\n                            nestedParentItem[FIELD_SUBSCHEMA_MAP_SYMBOL] ||= /* @__PURE__ */ new Map(),\n                            info,\n                            responsePathAsArray(info.path),\n                            nestedParentItem[UNPATHED_ERRORS_SYMBOL] ||= []\n                          );\n                        }\n                      }\n                    }\n                  }\n                }\n                if (parentSatisfiedSelectionSet(nestedParent, nestedSelectionSet)) {\n                  handleFlattenedParent(\n                    flattenedParent,\n                    leftOverParent,\n                    possibleSubschema,\n                    selectionSet,\n                    leftOver,\n                    stitchingInfo,\n                    parentTypeName,\n                    context,\n                    info\n                  );\n                }\n              }\n            }\n            if (Array.isArray(nestedParent)) {\n              nestedParent.forEach(\n                (nestedParentItem) => handleNestedParentItem(nestedParentItem, selectionNode)\n              );\n            } else {\n              handleNestedParentItem(nestedParent, selectionNode);\n            }\n          }\n        }\n      }\n    }\n  }\n}\nfunction handleDeferredResolverResult(resolverResult, possibleSubschema, selectionSet, leftOverParent, leftOver, context, info) {\n  handleResolverResult(\n    resolverResult,\n    possibleSubschema,\n    selectionSet,\n    leftOverParent,\n    leftOverParent[FIELD_SUBSCHEMA_MAP_SYMBOL],\n    info,\n    responsePathAsArray(info.path),\n    leftOverParent[UNPATHED_ERRORS_SYMBOL]\n  );\n  const deferredFields = leftOver.missingFieldsParentDeferredMap.get(leftOverParent);\n  if (deferredFields) {\n    const stitchingInfo = info.schema.extensions?.[\"stitchingInfo\"];\n    const parentTypeName = leftOverParent?.__typename || info.parentType.name;\n    const resolvedKeys = /* @__PURE__ */ new Set();\n    for (const [responseKey, deferred] of deferredFields) {\n      if (Object.prototype.hasOwnProperty.call(leftOverParent, responseKey)) {\n        deferred.resolve(\n          handleResult(leftOverParent, responseKey, context, info)\n        );\n        resolvedKeys.add(responseKey);\n      } else {\n        const fieldNodesByType = stitchingInfo?.fieldNodesByField?.[parentTypeName]?.[responseKey];\n        if (fieldNodesByType) {\n          if (fieldNodesByType.every((fieldNode) => {\n            const requiredKey = fieldNode.alias?.value ?? fieldNode.name.value;\n            return Object.prototype.hasOwnProperty.call(\n              leftOverParent,\n              requiredKey\n            );\n          })) {\n            setTimeout(() => {\n              handleLeftOver(leftOverParent, context, info, leftOver);\n            }, 0);\n          }\n        }\n      }\n    }\n    for (const key of resolvedKeys) {\n      deferredFields.delete(key);\n    }\n    if (deferredFields.size === 0) {\n      leftOver.missingFieldsParentDeferredMap.delete(leftOverParent);\n    }\n  }\n}\nfunction handleDeferredResolverFailure(leftOver, leftOverParent, error) {\n  const deferredFields = leftOver.missingFieldsParentDeferredMap.get(leftOverParent);\n  if (deferredFields) {\n    for (const [_responseKey, deferred] of deferredFields) {\n      deferred.reject(error);\n    }\n    leftOver.missingFieldsParentDeferredMap.delete(leftOverParent);\n  }\n}\nfunction parentSatisfiedSelectionSet(parent, selectionSet) {\n  if (Array.isArray(parent)) {\n    const subschemas2 = /* @__PURE__ */ new Set();\n    for (const item of parent) {\n      const satisfied = parentSatisfiedSelectionSet(item, selectionSet);\n      if (satisfied === void 0) {\n        return void 0;\n      }\n      for (const subschema of satisfied) {\n        subschemas2.add(subschema);\n      }\n    }\n    return subschemas2;\n  }\n  if (parent === null) {\n    return /* @__PURE__ */ new Set();\n  }\n  if (parent === void 0) {\n    return void 0;\n  }\n  const subschemas = /* @__PURE__ */ new Set();\n  for (const selection of selectionSet.selections) {\n    if (selection.kind === Kind.FIELD) {\n      const responseKey = selection.alias?.value ?? selection.name.value;\n      if (parent[responseKey] === void 0) {\n        return void 0;\n      }\n      if (isExternalObject(parent)) {\n        const subschema = getSubschema(parent, responseKey);\n        if (subschema) {\n          subschemas.add(subschema);\n        }\n      }\n      if (parent[responseKey] === null) {\n        continue;\n      }\n      if (selection.selectionSet != null) {\n        const satisfied = parentSatisfiedSelectionSet(\n          parent[responseKey],\n          selection.selectionSet\n        );\n        if (satisfied === void 0) {\n          return void 0;\n        }\n        for (const subschema of satisfied) {\n          subschemas.add(subschema);\n        }\n      }\n    } else if (selection.kind === Kind.INLINE_FRAGMENT) {\n      const inlineSatisfied = parentSatisfiedSelectionSet(\n        parent,\n        selection.selectionSet\n      );\n      if (inlineSatisfied === void 0) {\n        return void 0;\n      }\n      for (const subschema of inlineSatisfied) {\n        subschemas.add(subschema);\n      }\n    }\n  }\n  return subschemas;\n}\nfunction flattenPromise(data) {\n  if (isPromise(data)) {\n    return data.then(flattenPromise);\n  }\n  if (Array.isArray(data)) {\n    return Promise.all(data.map(flattenPromise));\n  }\n  if (data != null && typeof data === \"object\") {\n    const jobs = [];\n    const newData = {};\n    for (const key in data) {\n      const keyResult = flattenPromise(data[key]);\n      if (isPromise(keyResult)) {\n        jobs.push(\n          keyResult.then((resolvedKeyResult) => {\n            newData[key] = resolvedKeyResult;\n          })\n        );\n      } else {\n        newData[key] = keyResult;\n      }\n    }\n    if (OBJECT_SUBSCHEMA_SYMBOL in data) {\n      newData[OBJECT_SUBSCHEMA_SYMBOL] = data[OBJECT_SUBSCHEMA_SYMBOL];\n    }\n    if (FIELD_SUBSCHEMA_MAP_SYMBOL in data) {\n      newData[FIELD_SUBSCHEMA_MAP_SYMBOL] = data[FIELD_SUBSCHEMA_MAP_SYMBOL];\n    }\n    if (UNPATHED_ERRORS_SYMBOL in data) {\n      newData[UNPATHED_ERRORS_SYMBOL] = data[UNPATHED_ERRORS_SYMBOL];\n    }\n    if (jobs.length) {\n      return Promise.all(jobs).then(() => newData);\n    }\n    return newData;\n  }\n  return data;\n}\n\nfunction isSubschemaConfig(value) {\n  return Boolean(value?.schema);\n}\nfunction cloneSubschemaConfig(subschemaConfig) {\n  const newSubschemaConfig = {\n    ...subschemaConfig,\n    transforms: subschemaConfig.transforms != null ? [...subschemaConfig.transforms] : void 0\n  };\n  if (newSubschemaConfig.merge != null) {\n    newSubschemaConfig.merge = { ...subschemaConfig.merge };\n    for (const typeName in newSubschemaConfig.merge) {\n      const mergedTypeConfig = newSubschemaConfig.merge[typeName] = {\n        ...subschemaConfig.merge?.[typeName] ?? {}\n      };\n      if (mergedTypeConfig.entryPoints != null) {\n        mergedTypeConfig.entryPoints = mergedTypeConfig.entryPoints.map(\n          (entryPoint) => ({\n            ...entryPoint\n          })\n        );\n      }\n      if (mergedTypeConfig.fields != null) {\n        const fields = mergedTypeConfig.fields = {\n          ...mergedTypeConfig.fields\n        };\n        for (const fieldName in fields) {\n          fields[fieldName] = { ...fields[fieldName] };\n        }\n      }\n    }\n  }\n  return newSubschemaConfig;\n}\n\nconst getFragmentDefinitions = memoize1(\n  (info) => {\n    const fragmentMap = info.fragments;\n    return Object.values(fragmentMap);\n  }\n);\nfunction delegateToSchema(options) {\n  const {\n    info,\n    schema,\n    rootValue = schema.rootValue ?? info.rootValue,\n    operationName = info.operation.name?.value,\n    operation = getDelegatingOperation(info.parentType, info.schema),\n    fieldName = info.fieldName,\n    selectionSet,\n    fieldNodes = info.fieldNodes,\n    context,\n    args\n  } = options;\n  let targetSchema = options.targetSchema;\n  if (isSubschema(schema)) {\n    targetSchema = schema.transformedSchema;\n  } else if (isSchema(schema)) {\n    targetSchema = schema;\n  } else {\n    const stitchingInfo = info.schema.extensions?.[\"stitchingInfo\"];\n    const subschema = stitchingInfo?.subschemaMap.get(schema);\n    if (subschema != null) {\n      targetSchema = subschema.transformedSchema;\n    } else {\n      targetSchema = applySchemaTransforms(schema.schema, schema);\n    }\n  }\n  const fragments = info ? getFragmentDefinitions(info) : void 0;\n  const request = createRequest({\n    subgraphName: schema.name,\n    fragments,\n    targetSchema,\n    rootValue,\n    targetOperationName: operationName,\n    targetOperation: operation,\n    targetFieldName: fieldName,\n    selectionSet,\n    fieldNodes,\n    context,\n    info,\n    args\n  });\n  return delegateRequest({\n    ...options,\n    targetSchema,\n    request\n  });\n}\nfunction getDelegationReturnType(targetSchema, operation, fieldName) {\n  const rootType = getDefinedRootType(targetSchema, operation);\n  const rootFieldType = rootType.getFields()[fieldName];\n  if (!rootFieldType) {\n    throw new Error(\n      `Unable to find field '${fieldName}' in type '${rootType}'.`\n    );\n  }\n  return rootFieldType.type;\n}\nfunction delegateRequest(options) {\n  const delegationContext = getDelegationContext(options);\n  const transformer = new Transformer(delegationContext);\n  const processedRequest = transformer.transformRequest(options.request);\n  if (options.validateRequest) {\n    validateRequest(delegationContext, processedRequest.document);\n  }\n  return handleMaybePromise(\n    () => getExecutor(delegationContext)(processedRequest),\n    function handleExecutorResult(executorResult) {\n      if (isAsyncIterable(executorResult)) {\n        if (delegationContext.operation === \"query\" && isListType(delegationContext.returnType)) {\n          return new Repeater(async (push, stop) => {\n            const pushed = /* @__PURE__ */ new WeakSet();\n            let stopped = false;\n            stop.finally(() => {\n              stopped = true;\n            });\n            try {\n              for await (const result of executorResult) {\n                if (stopped) {\n                  break;\n                }\n                if (result.incremental) {\n                  const data = {};\n                  for (const incrementalRes of result.incremental) {\n                    if (incrementalRes.items?.length) {\n                      for (const item of incrementalRes.items) {\n                        setObjectKeyPath(\n                          data,\n                          (incrementalRes.path || []).slice(0, -1),\n                          item\n                        );\n                      }\n                      await push(await transformer.transformResult({ data }));\n                    }\n                  }\n                  if (result.hasNext === false) {\n                    break;\n                  } else {\n                    continue;\n                  }\n                }\n                const transformedResult = await transformer.transformResult(result);\n                if (Array.isArray(transformedResult)) {\n                  for (const individualResult$ of transformedResult) {\n                    if (stopped) {\n                      break;\n                    }\n                    const individualResult = await individualResult$;\n                    if (!pushed.has(individualResult)) {\n                      pushed.add(individualResult);\n                      await push(individualResult);\n                    }\n                  }\n                } else {\n                  await push(await transformedResult);\n                }\n              }\n              stop();\n            } catch (error) {\n              stop(error);\n            }\n          });\n        }\n        return mapAsyncIterator(\n          executorResult,\n          (result) => transformer.transformResult(result)\n        );\n      }\n      return transformer.transformResult(executorResult);\n    }\n  );\n}\nfunction getDelegationContext({\n  request,\n  schema,\n  fieldName,\n  returnType,\n  info,\n  args,\n  transforms = [],\n  targetSchema: transformedSchema,\n  skipTypeMerging = false,\n  onLocatedError\n}) {\n  const operationDefinition = getOperationASTFromRequest(request);\n  let targetFieldName;\n  if (fieldName == null) {\n    targetFieldName = operationDefinition.selectionSet.selections[0].name.value;\n  } else {\n    targetFieldName = fieldName;\n  }\n  const stitchingInfo = info?.schema.extensions?.[\"stitchingInfo\"];\n  const subschemaOrSubschemaConfig = stitchingInfo?.subschemaMap.get(schema) ?? schema;\n  const operation = operationDefinition.operation;\n  if (isSubschemaConfig(subschemaOrSubschemaConfig)) {\n    const targetSchema = subschemaOrSubschemaConfig.schema;\n    return {\n      subschema: schema,\n      subschemaConfig: subschemaOrSubschemaConfig,\n      targetSchema,\n      operation,\n      fieldName: targetFieldName,\n      context: request.context,\n      info,\n      returnType: returnType ?? info?.returnType ?? getDelegationReturnType(targetSchema, operation, targetFieldName),\n      transforms: subschemaOrSubschemaConfig.transforms != null ? subschemaOrSubschemaConfig.transforms.concat(transforms) : transforms,\n      transformedSchema,\n      skipTypeMerging,\n      onLocatedError,\n      args\n    };\n  }\n  return {\n    subschema: schema,\n    subschemaConfig: void 0,\n    targetSchema: subschemaOrSubschemaConfig,\n    operation,\n    fieldName: targetFieldName,\n    context: request.context,\n    info,\n    returnType: returnType ?? info?.returnType ?? getDelegationReturnType(\n      subschemaOrSubschemaConfig,\n      operation,\n      targetFieldName\n    ),\n    transforms,\n    transformedSchema: transformedSchema ?? subschemaOrSubschemaConfig,\n    skipTypeMerging\n  };\n}\nfunction validateRequest(delegationContext, document) {\n  const errors = validate(delegationContext.targetSchema, document);\n  if (errors.length > 0) {\n    if (errors.length > 1) {\n      const combinedError = new AggregateError(\n        errors,\n        errors.map((error2) => error2.message).join(\", \\n\")\n      );\n      throw combinedError;\n    }\n    const error = errors[0];\n    if (error) {\n      throw error.originalError || error;\n    }\n  }\n}\nconst GLOBAL_CONTEXT = {};\nfunction getExecutor(delegationContext) {\n  const { subschemaConfig, targetSchema, context } = delegationContext;\n  let executor = subschemaConfig?.executor || executorFromSchema(targetSchema);\n  if (subschemaConfig?.batch) {\n    const batchingOptions = subschemaConfig?.batchingOptions;\n    executor = getBatchingExecutor(\n      context ?? GLOBAL_CONTEXT,\n      executor,\n      batchingOptions?.dataLoaderOptions,\n      batchingOptions?.extensionsReducer\n    );\n  }\n  return executor;\n}\nfunction setObjectKeyPath(obj, path, value) {\n  let current = obj;\n  for (let i = 0; i < path.length - 1; i++) {\n    const key = path[i];\n    if (key == null || key === \"__proto__\" || key === \"constructor\" || key === \"prototype\") {\n      return;\n    }\n    if (current[key] == null) {\n      current[key] = typeof path[i + 1] === \"number\" ? [] : {};\n    }\n    current = current[key];\n  }\n  const lastKey = path[path.length - 1];\n  if (lastKey == null || lastKey === \"__proto__\" || lastKey === \"constructor\" || lastKey === \"prototype\") {\n    return;\n  }\n  const existingValue = current[lastKey];\n  current[lastKey] = existingValue ? mergeDeep([existingValue, value]) : value;\n}\n\nfunction extractUnavailableFieldsFromSelectionSet(schema, fieldType, fieldSelectionSet, shouldAdd, fragments = {}) {\n  if (isLeafType(fieldType)) {\n    return [];\n  }\n  if (isUnionType(fieldType)) {\n    const unavailableSelections2 = [];\n    for (const type of fieldType.getTypes()) {\n      const fieldSelectionExcluded = {\n        ...fieldSelectionSet,\n        selections: fieldSelectionSet.selections.filter(\n          (selection) => selection.kind === Kind.INLINE_FRAGMENT ? selection.typeCondition ? selection.typeCondition.name.value === type.name : false : true\n        )\n      };\n      unavailableSelections2.push(\n        ...extractUnavailableFieldsFromSelectionSet(\n          schema,\n          type,\n          fieldSelectionExcluded,\n          shouldAdd,\n          fragments\n        )\n      );\n    }\n    return unavailableSelections2;\n  }\n  const subFields = fieldType.getFields();\n  const unavailableSelections = [];\n  for (const selection of fieldSelectionSet.selections) {\n    if (selection.kind === Kind.FIELD) {\n      if (selection.name.value === \"__typename\") {\n        continue;\n      }\n      const fieldName = selection.name.value;\n      const selectionField = subFields[fieldName];\n      if (!selectionField) {\n        if (shouldAdd(fieldType, selection)) {\n          unavailableSelections.push(selection);\n        }\n      } else {\n        const unavailableSubFields = extractUnavailableFields(\n          schema,\n          selectionField,\n          selection,\n          shouldAdd,\n          fragments\n        );\n        if (unavailableSubFields.length) {\n          unavailableSelections.push({\n            ...selection,\n            selectionSet: {\n              kind: Kind.SELECTION_SET,\n              selections: unavailableSubFields\n            }\n          });\n        }\n      }\n    } else if (selection.kind === Kind.INLINE_FRAGMENT) {\n      const subFieldName = selection.typeCondition?.name.value || fieldType.name;\n      const subFieldType = selection.typeCondition && schema.getType(subFieldName) || fieldType;\n      if (subFieldName === fieldType.name || (isObjectType(subFieldType) || isInterfaceType(subFieldType)) && isAbstractType(fieldType) && schema.isSubType(fieldType, subFieldType)) {\n        const unavailableFields = extractUnavailableFieldsFromSelectionSet(\n          schema,\n          subFieldType,\n          selection.selectionSet,\n          shouldAdd,\n          fragments\n        );\n        if (unavailableFields.length) {\n          unavailableSelections.push({\n            ...selection,\n            selectionSet: {\n              kind: Kind.SELECTION_SET,\n              selections: unavailableFields\n            }\n          });\n        }\n      } else if (isObjectType(subFieldType) || isInterfaceType(subFieldType)) {\n        for (const subSelection of selection.selectionSet.selections) {\n          if (subSelection.kind === Kind.FIELD && subSelection.name.value === \"__typename\") {\n            continue;\n          }\n          if (shouldAdd(subFieldType, subSelection)) {\n            unavailableSelections.push(subSelection);\n          }\n        }\n      }\n    } else if (selection.kind === Kind.FRAGMENT_SPREAD) {\n      const fragment = fragments[selection.name.value];\n      if (fragment) {\n        const fragmentUnavailableFields = extractUnavailableFieldsFromSelectionSet(\n          schema,\n          fieldType,\n          {\n            kind: Kind.SELECTION_SET,\n            selections: [\n              {\n                kind: Kind.INLINE_FRAGMENT,\n                typeCondition: {\n                  kind: Kind.NAMED_TYPE,\n                  name: {\n                    kind: Kind.NAME,\n                    value: fragment.typeCondition.name.value\n                  }\n                },\n                selectionSet: fragment.selectionSet\n              }\n            ]\n          },\n          shouldAdd,\n          fragments\n        );\n        if (fragmentUnavailableFields.length) {\n          unavailableSelections.push(...fragmentUnavailableFields);\n        }\n      }\n    }\n  }\n  return unavailableSelections;\n}\nfunction extractUnavailableFields(schema, field, fieldNode, shouldAdd, fragments = {}) {\n  if (fieldNode.selectionSet) {\n    const fieldType = getNamedType(field.type);\n    return extractUnavailableFieldsFromSelectionSet(\n      schema,\n      fieldType,\n      fieldNode.selectionSet,\n      shouldAdd,\n      fragments\n    );\n  }\n  return [];\n}\nfunction subtractSelectionSets(selectionSetA, selectionSetB) {\n  const newSelections = [];\n  for (const selectionA of selectionSetA.selections) {\n    switch (selectionA.kind) {\n      case Kind.FIELD: {\n        const fieldA = selectionA;\n        const fieldsInOtherSelectionSet = selectionSetB.selections.filter(\n          (subselectionB) => {\n            if (subselectionB.kind !== Kind.FIELD) {\n              return false;\n            }\n            return fieldA.name.value === subselectionB.name.value;\n          }\n        );\n        if (fieldsInOtherSelectionSet.length > 0 && fieldA.selectionSet?.selections?.length) {\n          const newSubSelection = fieldsInOtherSelectionSet.reduce(\n            (acc, fieldB) => fieldB.selectionSet ? subtractSelectionSets(acc, fieldB.selectionSet) : acc,\n            {\n              kind: Kind.SELECTION_SET,\n              selections: fieldA.selectionSet.selections\n            }\n          );\n          if (newSubSelection.selections.length) {\n            newSelections.push({\n              ...fieldA,\n              selectionSet: newSubSelection\n            });\n          }\n        } else if (fieldsInOtherSelectionSet.length === 0) {\n          newSelections.push(selectionA);\n        }\n        break;\n      }\n      case Kind.INLINE_FRAGMENT: {\n        const inlineFragmentA = selectionA;\n        const inlineFragmentsFromB = selectionSetB.selections.filter(\n          (subselectionB) => {\n            if (subselectionB.kind !== Kind.INLINE_FRAGMENT) {\n              return false;\n            }\n            const inlineFragmentB = subselectionB;\n            return inlineFragmentA.typeCondition?.name.value === inlineFragmentB.typeCondition?.name.value;\n          }\n        );\n        if (inlineFragmentsFromB.length > 0) {\n          const newSubSelection = inlineFragmentsFromB.reduce(\n            (acc, subselectionB) => subselectionB.selectionSet ? subtractSelectionSets(acc, subselectionB.selectionSet) : acc,\n            {\n              kind: Kind.SELECTION_SET,\n              selections: inlineFragmentA.selectionSet.selections\n            }\n          );\n          if (newSubSelection.selections.length) {\n            if (newSubSelection.selections.length === 1) {\n              const onlySelection = newSubSelection.selections[0];\n              if (onlySelection?.kind === Kind.FIELD) {\n                const responseKey = onlySelection.alias?.value || onlySelection.name.value;\n                if (responseKey === \"__typename\") {\n                  continue;\n                }\n              }\n            }\n            newSelections.push({\n              ...inlineFragmentA,\n              selectionSet: newSubSelection\n            });\n          }\n        } else {\n          newSelections.push(selectionA);\n        }\n        break;\n      }\n      case Kind.FRAGMENT_SPREAD: {\n        const fragmentSpreadA = selectionA;\n        if (!selectionSetB.selections.some(\n          (subselectionB) => subselectionB.kind === Kind.FRAGMENT_SPREAD && subselectionB.name.value === fragmentSpreadA.name.value\n        )) {\n          newSelections.push(selectionA);\n        }\n        break;\n      }\n    }\n  }\n  return {\n    kind: Kind.SELECTION_SET,\n    selections: newSelections\n  };\n}\n\nexport { EMPTY_ARRAY, EMPTY_OBJECT, FIELD_SUBSCHEMA_MAP_SYMBOL, OBJECT_SUBSCHEMA_SYMBOL, PLAN_LEFT_OVER, Subschema, Transformer, UNPATHED_ERRORS_SYMBOL, annotateExternalObject, applySchemaTransforms, cloneSubschemaConfig, createRequest, defaultMergedResolver, delegateRequest, delegateToSchema, extractUnavailableFields, extractUnavailableFieldsFromSelectionSet, getActualFieldNodes, getDelegatingOperation, getPlanLeftOverFromParent, getSubschema, getTypeInfo, getTypeInfoWithType, getUnpathedErrors, handleOverrideByDelegation, handleResolverResult, isExternalObject, isPrototypePollutingKey, isSubschema, isSubschemaConfig, leftOverByDelegationPlan, mergeFields, resolveExternalValue, subtractSelectionSets };\n"]}